간단한 메타프로그래밍 예제

# 일반적인 방식
class Person
  def name
    @name
  end
  
  def name=(value)
    @name = value
  end
  
  def age
    @age
  end
  
  def age=(value)
    @age = value
  end
end

# 메타프로그래밍 방식
class Person
  [:name, :age].each do |attribute|
    # getter 메서드 동적 생성
    define_method(attribute) do
      instance_variable_get("@#{attribute}")
    end
    
    # setter 메서드 동적 생성
    define_method("#{attribute}=") do |value|
      instance_variable_set("@#{attribute}", value)
    end
  end
end
      

# 클래스도 객체다
String.class  # => Class
Array.class   # => Class

# 클래스에 메서드 호출
String.instance_methods.size  # => 많은 수의 메서드 수 반환
      

# 최상위 레벨에서 self는 main 객체
puts self  # => main

class MyClass
  # 클래스 정의 내에서 self는 클래스 자체
  puts self  # => MyClass
  
  def instance_method
    # 인스턴스 메서드 내에서 self는 해당 인스턴스
    puts self  # => #<MyClass:0x00007f9f8b0b7f98>
  end
  
  def self.class_method
    # 클래스 메서드 내에서 self는 클래스
    puts self  # => MyClass
  end
end
      

# String 클래스에 새 메서드 추가
class String
  def palindrome?
    self == self.reverse
  end
end

"level".palindrome?  # => true
"ruby".palindrome?   # => false
      

class Person
  def initialize(name)
    @name = name
  end
  
  def greet
    "Hello, #{@name}!"
  end
end

person = Person.new("Ruby")

# 일반적인 메서드 호출
puts person.greet  # => "Hello, Ruby!"

# 동적 메서드 호출
method_name = "greet"
puts person.send(method_name)  # => "Hello, Ruby!"
      

# 객체의 인스턴스 변수 목록
person.instance_variables  # => [:@name]

# 클래스의 인스턴스 메서드 목록
Person.instance_methods(false)  # => [:greet]

# 객체가 응답할 수 있는 메서드 확인
person.respond_to?("greet")  # => true
person.respond_to?("dance")  # => false
      

"hello".class  # => String
123.class      # => Integer
[1, 2, 3].class  # => Array
      

String.class  # => Class
Array.class   # => Class
Class.class   # => Class  # 심지어 Class도 Class의 인스턴스!
      

obj = Object.new

# obj 객체에만 존재하는 메서드 정의
def obj.speak
  "Hello, I'm a unique object!"
end

obj.speak  # => "Hello, I'm a unique object!"

# 다른 Object 인스턴스에는 이 메서드가 없음
Object.new.speak  # => NoMethodError
      

# 싱글톤 클래스에 접근하는 방법 1
singleton = class << obj
  self
end

# 싱글톤 클래스에 접근하는 방법 2
singleton = obj.singleton_class
      

# 메서드 조회 경로 확인하기
module MyModule
  def module_method
    "I'm from a module"
  end
end

class Parent
  def parent_method
    "I'm from parent"
  end
end

class Child < Parent
  include MyModule
  
  def child_method
    "I'm from child"
  end
end

Child.ancestors  # => [Child, MyModule, Parent, Object, Kernel, BasicObject]
      

module Loggable
  def log(message)
    puts "[LOG] #{message}"
  end
end

class Service
  include Loggable
  
  def perform
    log("Service is performing")
    # 서비스 로직...
  end
end

service = Service.new
service.perform  # => [LOG] Service is performing
      

obj = Object.new
obj.extend(Loggable)
obj.log("This is a singleton method now")  # => [LOG] This is a singleton method now
      

class DynamicFinder
  def initialize(data)
    @data = data
  end
  
  def method_missing(method_name, *arguments, &block)
    # find_by_name, find_by_age 등의 패턴 확인
    if method_name.to_s =~ /^find_by_(.+)$/
      attribute = $1
      
      # 해당 속성으로 데이터 찾기
      @data.find { |item| item[attribute.to_sym] == arguments.first }
    else
      # 패턴에 맞지 않으면 원래의 method_missing 동작 수행
      super
    end
  end
  
  # respond_to_missing?도 함께 구현해야 함
  def respond_to_missing?(method_name, include_private = false)
    method_name.to_s.start_with?('find_by_') || super
  end
end

# 사용 예
data = [
  {name: 'Alice', age: 25, city: 'New York'},
  {name: 'Bob', age: 30, city: 'Boston'},
  {name: 'Charlie', age: 35, city: 'Chicago'}
]

finder = DynamicFinder.new(data)
finder.find_by_name('Alice')  # => {name: 'Alice', age: 25, city: 'New York'}
finder.find_by_age(30)        # => {name: 'Bob', age: 30, city: 'Boston'}
finder.find_by_city('Chicago') # => {name: 'Charlie', age: 35, city: 'Chicago'}
      

# respond_to_missing? 없이는
finder.respond_to?(:find_by_name)  # => false (잘못된 결과)

# respond_to_missing?을 구현하면
finder.respond_to?(:find_by_name)  # => true (올바른 결과)
      

method_missing과 일반 메서드의 성능 비교

require 'benchmark'

class WithMethodMissing
  def method_missing(name, *args)
    if name.to_s =~ /^find_(\d+)$/
      "Found #{$1}"
    else
      super
    end
  end
end

class WithDefinedMethods
  100.times do |i|
    define_method("find_#{i}") do
      "Found #{i}"
    end
  end
end

missing = WithMethodMissing.new
defined = WithDefinedMethods.new

Benchmark.bm do |x|
  x.report("method_missing:") do
    10000.times { missing.find_42 }
  end
  
  x.report("defined_method:") do
    10000.times { defined.find_42 }
  end
end

# 결과 (예시):
#                     user     system      total        real
# method_missing:  0.020000   0.000000   0.020000 (  0.018479)
# defined_method:  0.010000   0.000000   0.010000 (  0.006196)
      

class Person
  # 일반적인 방식으로 메서드 정의
  def name
    @name
  end
  
  # define_method를 사용한 동적 메서드 정의
  define_method :age do
    @age
  end
end

# 여러 메서드를 한 번에 정의
class Product
  [:title, :price, :category].each do |attribute|
    define_method(attribute) do
      instance_variable_get("@#{attribute}")
    end
    
    define_method("#{attribute}=") do |value|
      instance_variable_set("@#{attribute}", value)
    end
  end
end

product = Product.new
product.title = "Ruby Book"
product.price = 29.99
puts product.title  # => "Ruby Book"
puts product.price  # => 29.99
      

class HTMLGenerator
  def initialize(tag)
    @tag = tag
    
    # 지역 변수 tag를 캡처하는 메서드 생성
    define_method("generate_#{tag}") do |content|
      "<#{tag}>#{content}</#{tag}>"
    end
  end
end

generator = HTMLGenerator.new('div')
puts generator.generate_div("Hello, Ruby!")  # => "<div>Hello, Ruby!</div>"

generator = HTMLGenerator.new('p')
puts generator.generate_p("This is a paragraph")  # => "<p>This is a paragraph</p>"
      

class MyClass
  def self.my_attr_accessor(*attributes)
    attributes.each do |attribute|
      # Getter 메서드
      define_method(attribute) do
        instance_variable_get("@#{attribute}")
      end
      
      # Setter 메서드
      define_method("#{attribute}=") do |value|
        instance_variable_set("@#{attribute}", value)
      end
    end
  end
  
  my_attr_accessor :name, :age, :email
end

obj = MyClass.new
obj.name = "Ruby"
obj.age = 25
puts obj.name  # => "Ruby"
puts obj.age   # => 25
      

class DynamicFinder
  def initialize(data)
    @data = data
  end
  
  def method_missing(method_name, *arguments, &block)
    if method_name.to_s =~ /^find_by_(.+)$/
      attribute = $1.to_sym
      
      # 이 패턴의 메서드를 실제로 정의
      self.class.define_method(method_name) do |value|
        @data.find { |item| item[attribute] == value }
      end
      
      # 새로 정의된 메서드 호출
      send(method_name, *arguments)
    else
      super
    end
  end
  
  def respond_to_missing?(method_name, include_private = false)
    method_name.to_s.start_with?('find_by_') || super
  end
end

data = [
  {name: 'Alice', age: 25, city: 'New York'},
  {name: 'Bob', age: 30, city: 'Boston'},
  {name: 'Charlie', age: 35, city: 'Chicago'}
]

finder = DynamicFinder.new(data)

# 첫 번째 호출 - method_missing 사용, 메서드 정의
result1 = finder.find_by_name('Alice')

# 두 번째 호출 - 이미 정의된 메서드 사용 (더 빠름)
result2 = finder.find_by_name('Bob')
      

# 기본적인 eval 사용법
result = eval("2 + 2")  # => 4

# 변수 접근
x = 10
result = eval("x * 3")  # => 30

# 새 변수 정의
eval("y = 20")
puts y  # => 20
      

# 위험한 사용법 (절대 하지 마!)
user_input = "system('rm -rf /')"  # 악의적인 코드
eval(user_input)  # 시스템 파일을 삭제하려고 시도
      

# instance_eval - 객체의 컨텍스트에서 블록 실행
obj = Object.new
obj.instance_eval do
  @x = 10  # 객체의 인스턴스 변수 설정
  
  def speak
    "Hello, my @x is #{@x}"
  end
end

puts obj.speak  # => "Hello, my @x is 10"

# class_eval - 클래스의 컨텍스트에서 블록 실행
String.class_eval do
  def palindrome?
    self == self.reverse
  end
end

puts "level".palindrome?  # => true
puts "ruby".palindrome?   # => false
      

class MyClass
end

# instance_eval로 정의된 메서드는 싱글톤 메서드 (클래스 메서드)
MyClass.instance_eval do
  def class_method
    "I'm a class method"
  end
end

# class_eval로 정의된 메서드는 인스턴스 메서드
MyClass.class_eval do
  def instance_method
    "I'm an instance method"
  end
end

puts MyClass.class_method      # => "I'm a class method"
puts MyClass.new.instance_method  # => "I'm an instance method"
      

# instance_exec 사용 예
obj = Object.new
value = 42

obj.instance_exec(value) do |val|
  @value = val
  def get_value
    @value
  end
end

puts obj.get_value  # => 42

# class_exec 사용 예
class Person
end

name = "Ruby"
Person.class_exec(name) do |n|
  define_method(:greet) do
    "Hello, #{n}!"
  end
end

puts Person.new.greet  # => "Hello, Ruby!"
      

def create_binding(x)
  binding  # 현재 컨텍스트의 binding 반환
end

b = create_binding(10)
eval("x * 2", b)  # => 20
      

# 나쁜 예
user_input = gets.chomp
eval(user_input)  # 위험!

# 더 나은 접근법
allowed_operations = {
  'add' => ->(a, b) { a + b },
  'subtract' => ->(a, b) { a - b },
  'multiply' => ->(a, b) { a * b },
  'divide' => ->(a, b) { a / b }
}

operation = gets.chomp
a = gets.to_i
b = gets.to_i

if allowed_operations.key?(operation)
  result = allowed_operations[operation].call(a, b)
  puts result
else
  puts "Operation not allowed"
end
      

# 일반적인 클래스 정의
class Person
  def initialize(name)
    @name = name
  end
  
  def greet
    "Hello, #{@name}!"
  end
end

# Class.new를 사용한 동적 클래스 생성
Person = Class.new do
  def initialize(name)
    @name = name
  end
  
  def greet
    "Hello, #{@name}!"
  end
end

person = Person.new("Ruby")
puts person.greet  # => "Hello, Ruby!"
      

# 상속을 사용한 동적 클래스 생성
Animal = Class.new
Dog = Class.new(Animal) do
  def speak
    "Woof!"
  end
end

puts Dog.new.speak  # => "Woof!"
puts Dog.superclass == Animal  # => true
      

# 일반적인 모듈 정의
module Loggable
  def log(message)
    puts "[LOG] #{message}"
  end
end

# Module.new를 사용한 동적 모듈 생성
Loggable = Module.new do
  def log(message)
    puts "[LOG] #{message}"
  end
end

class Service
  include Loggable
end

Service.new.log("Service started")  # => [LOG] Service started
      

# 동적으로 여러 클래스 생성하기
['Cat', 'Dog', 'Bird'].each do |animal_name|
  Object.const_set(animal_name, Class.new do
    define_method(:speak) do
      case animal_name
      when 'Cat' then "Meow!"
      when 'Dog' then "Woof!"
      when 'Bird' then "Tweet!"
      end
    end
  end)
end

puts Cat.new.speak  # => "Meow!"
puts Dog.new.speak  # => "Woof!"
puts Bird.new.speak  # => "Tweet!"
      

class ServiceFactory
  def self.create_service(type, config = {})
    # 서비스 클래스가 이미 존재하는지 확인
    if Object.const_defined?(service_class_name(type))
      service_class = Object.const_get(service_class_name(type))
    else
      # 존재하지 않으면 동적으로 생성
      service_class = Class.new do
        attr_reader :config
        
        define_method(:initialize) do |config|
          @config = config
        end
        
        define_method(:run) do
          puts "Running #{type} service with config: #{config}"
          # 서비스 로직...
        end
      end
      
      # 생성한 클래스를 상수에 할당
      Object.const_set(service_class_name(type), service_class)
    end
    
    # 새 서비스 인스턴스 반환
    service_class.new(config)
  end
  
  def self.service_class_name(type)
    "#{type.capitalize}Service"
  end
end

# 사용 예
email_service = ServiceFactory.create_service('email', {from: 'ruby@example.com'})
sms_service = ServiceFactory.create_service('sms', {provider: 'twilio'})

email_service.run  # => "Running email service with config: {:from=>'ruby@example.com'}"
sms_service.run    # => "Running sms service with config: {:provider=>'twilio'}"
      

module MyApp
  module Services
    # 네임스페이스 내에 동적으로 클래스 생성
    def self.create_service(name)
      const_set(name, Class.new do
        def initialize
          @name = name
        end
        
        def run
          "Running #{@name} service"
        end
      end)
    end
  end
end

# 서비스 클래스 생성
MyApp::Services.create_service('Email')
MyApp::Services.create_service('SMS')

# 사용
email_service = MyApp::Services::Email.new
puts email_service.run  # => "Running Email service"
      

class Configuration
  def initialize
    @settings = {}
  end
  
  def method_missing(name, *args, &block)
    @settings[name] = args.first
  end
  
  def to_hash
    @settings
  end
  
  def self.load(&block)
    config = new
    config.instance_eval(&block)
    config
  end
end

# DSL 사용 예
config = Configuration.load do
  database "mysql"
  host "localhost"
  username "root"
  password "secret"
  pool 5
end

puts config.to_hash
# => {:database=>"mysql", :host=>"localhost", :username=>"root", :password=>"secret", :pool=>5}
      

class TestCase
  def initialize(description, &block)
    @description = description
    @block = block
    @before_blocks = []
    @after_blocks = []
    @it_blocks = []
  end
  
  def before(&block)
    @before_blocks << block
  end
  
  def after(&block)
    @after_blocks << block
  end
  
  def it(description, &block)
    @it_blocks << [description, block]
  end
  
  def run
    puts "Running test case: #{@description}"
    
    @it_blocks.each do |description, block|
      context = Object.new
      
      begin
        # before 블록 실행
        @before_blocks.each { |b| context.instance_eval(&b) }
        
        # 테스트 블록 실행
        context.instance_eval(&block)
        
        puts "  ✓ #{description}"
      rescue => e
        puts "  ✗ #{description}: #{e.message}"
      ensure
        # after 블록 실행
        @after_blocks.each { |b| context.instance_eval(&b) }
      end
    end
  end
  
  def self.describe(description, &block)
    test_case = new(description)
    test_case.instance_eval(&block)
    test_case.run
  end
end

# DSL 사용 예
TestCase.describe "Array" do
  before do
    @array = [1, 2, 3]
  end
  
  after do
    @array = nil
  end
  
  it "should have the correct size" do
    raise "Wrong size" unless @array.size == 3
  end
  
  it "should include the number 2" do
    raise "Doesn't include 2" unless @array.include?(2)
  end
  
  it "should raise an error" do
    raise "This test should fail"
  end
end
      

class HTMLBuilder
  def initialize
    @html = ""
  end
  
  def method_missing(tag, *args, &block)
    attributes = args.first.is_a?(Hash) ? args.shift : {}
    content = args.first
    
    # 태그 시작
    @html << "<#{tag}"
    
    # 속성 추가
    attributes.each do |key, value|
      @html << " #{key}=\"#{value}\""
    end
    
    if block_given? || content
      @html << ">"
      
      # 내용 추가
      @html << content.to_s if content
      
      # 중첩된 태그 처리
      if block_given?
        builder = HTMLBuilder.new
        builder.instance_eval(&block)
        @html << builder.to_html
      end
      
      # 태그 종료
      @html << "</#{tag}>"
    else
      # 자체 닫는 태그
      @html << " />"
    end
  end
  
  def to_html
    @html
  end
  
  def self.build(&block)
    builder = new
    builder.instance_eval(&block)
    builder.to_html
  end
end

# DSL 사용 예
html = HTMLBuilder.build do
  html do
    head do
      title "My Page"
      meta charset: "utf-8"
    end
    body do
      h1 "Welcome to my page"
      p "This is a paragraph"
      ul do
        li "Item 1"
        li "Item 2"
        li "Item 3"
      end
    end
  end
end

puts html
      

module Validations
  def self.included(base)
    base.extend(ClassMethods)
  end
  
  module ClassMethods
    def validations
      @validations ||= {}
    end
    
    def validate(attribute, options = {})
      validations[attribute] = options
    end
  end
  
  def valid?
    errors.clear
    self.class.validations.each do |attribute, options|
      value = send(attribute)
      
      # presence 검증
      if options[:presence] && (value.nil? || value.to_s.empty?)
        errors << "#{attribute} can't be blank"
      end
      
      # format 검증
      if options[:format] && value && !(value.to_s =~ options[:format])
        errors << "#{attribute} has invalid format"
      end
      
      # length 검증
      if options[:length] && value
        min = options[:length][:minimum]
        max = options[:length][:maximum]
        
        if min && value.to_s.length < min
          errors << "#{attribute} is too short (minimum is #{min} characters)"
        end
        
        if max && value.to_s.length > max
          errors << "#{attribute} is too long (maximum is #{max} characters)"
        end
      end
    end
    
    errors.empty?
  end
  
  def errors
    @errors ||= []
  end
end

# 사용 예
class User
  include Validations
  
  attr_accessor :name, :email, :password
  
  validate :name, presence: true
  validate :email, presence: true, format: /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i
  validate :password, presence: true, length: { minimum: 8, maximum: 20 }
  
  def initialize(attributes = {})
    attributes.each do |key, value|
      send("#{key}=", value)
    end
  end
end

user = User.new(name: "Ruby", email: "invalid-email", password: "short")
puts user.valid?  # => false
puts user.errors  # => ["email has invalid format", "password is too short (minimum is 8 characters)"]

user = User.new(name: "Ruby", email: "ruby@example.com", password: "password123")
puts user.valid?  # => true
puts user.errors  # => []
      

module SimpleORM
  def self.included(base)
    base.extend(ClassMethods)
  end
  
  module ClassMethods
    def table_name
      self.name.downcase + 's'
    end
    
    def columns(*names)
      @columns ||= []
      
      if names.empty?
        @columns
      else
        names.each do |name|
          @columns << name
          
          # getter 메서드
          define_method(name) do
            instance_variable_get("@#{name}")
          end
          
          # setter 메서드
          define_method("#{name}=") do |value|
            instance_variable_set("@#{name}", value)
          end
        end
      end
    end
    
    def find(id)
      # 실제로는 데이터베이스에서 조회
      # 여기서는 간단히 시뮬레이션
      new.tap do |obj|
        obj.instance_variable_set("@id", id)
        obj.instance_variable_set("@loaded_from_db", true)
      end
    end
    
    def all
      # 실제로는 데이터베이스에서 모든 레코드 조회
      # 여기서는 간단히 빈 배열 반환
      []
    end
  end
  
  def initialize(attributes = {})
    attributes.each do |key, value|
      send("#{key}=", value) if respond_to?("#{key}=")
    end
  end
  
  def save
    if @id
      update
    else
      insert
    end
  end
  
  def update
    # 실제로는 SQL UPDATE 실행
    puts "UPDATE #{self.class.table_name} SET #{changes_for_sql} WHERE id = #{@id}"
    true
  end
  
  def insert
    # 실제로는 SQL INSERT 실행
    @id = rand(1000)  # 임의의 ID 할당
    puts "INSERT INTO #{self.class.table_name} (#{columns_for_sql}) VALUES (#{values_for_sql})"
    true
  end
  
  def destroy
    # 실제로는 SQL DELETE 실행
    puts "DELETE FROM #{self.class.table_name} WHERE id = #{@id}"
    @id = nil
    true
  end
  
  private
  
  def columns_for_sql
    self.class.columns.join(', ')
  end
  
  def values_for_sql
    self.class.columns.map { |col| "'#{send(col)}'" }.join(', ')
  end
  
  def changes_for_sql
    self.class.columns.map { |col| "#{col} = '#{send(col)}'" }.join(', ')
  end
end

# 사용 예
class Product
  include SimpleORM
  
  columns :name, :price, :category
end

product = Product.new(name: "Ruby Book", price: 29.99, category: "Programming")
product.save  # => INSERT INTO products (name, price, category) VALUES ('Ruby Book', '29.99', 'Programming')

product = Product.find(42)
product.name = "Updated Name"
product.save  # => UPDATE products SET name = 'Updated Name', price = '', category = '' WHERE id = 42

product.destroy  # => DELETE FROM products WHERE id = 42
      

module MethodLogger
  def self.included(base)
    base.class_eval do
      # 클래스의 인스턴스 메서드 목록 가져오기
      methods_to_log = instance_methods(false)
      
      methods_to_log.each do |method_name|
        # 원래 메서드 별칭 만들기
        alias_method "original_#{method_name}", method_name
        
        # 메서드 재정의
        define_method(method_name) do |*args, &block|
          start_time = Time.now
          
          # 메서드 호출 로깅
          puts "[#{Time.now}] Calling #{method_name} with args: #{args.inspect}"
          
          # 원래 메서드 호출
          result = send("original_#{method_name}", *args, &block)
          
          # 메서드 실행 시간 계산
          execution_time = Time.now - start_time
          
          # 결과 로깅
          puts "[#{Time.now}] #{method_name} completed in #{execution_time}s with result: #{result.inspect}"
          
          # 원래 결과 반환
          result
        end
      end
    end
  end
end

# 사용 예
class Calculator
  def add(a, b)
    a + b
  end
  
  def subtract(a, b)
    a - b
  end
  
  def multiply(a, b)
    a * b
  end
  
  # 로깅 추가
  include MethodLogger
end

calc = Calculator.new
calc.add(5, 3)
# => [2023-05-20 10:15:30] Calling add with args: [5, 3]
# => [2023-05-20 10:15:30] add completed in 0.0001s with result: 8

calc.multiply(4, 6)
# => [2023-05-20 10:15:30] Calling multiply with args: [4, 6]
# => [2023-05-20 10:15:30] multiply completed in 0.0001s with result: 24
      

Rails의 메타프로그래밍 예제

# ActiveRecord의 동적 파인더
User.find_by_email("example@example.com")
User.find_by_name_and_age("John", 30)

# has_many, belongs_to 같은 관계 매크로
class User < ApplicationRecord
  has_many :posts
  belongs_to :department
end

# 검증 매크로
class Product < ApplicationRecord
  validates :name, presence: true
  validates :price, numericality: { greater_than: 0 }
end