Метапрограмма, определяющая методы Ruby, которые принимают аргументы ключевых слов?

Question

Struct позволяет мне создать новый класс, который принимает аргументы и имеет хорошую семантику. Однако аргументы не являются обязательными, и их порядок требует согласования с определением:

Point = Struct.new(:x, :y) 

Point.new(111, 222) 
#=> <point instance with x = 111, y = 222> 

Point.new(111) 
#=> <point instance with x = 111, y = nil> 

я хотел бы что-то похожее на структуру, но использует именованные аргументы вместо:

Point = StricterStruct.new(:x, :y) 

Point.new(x: 111, y: 222) 
#=> <point instance with x = 111, y = 222> 

Point.new(x: 111) 
#=> ArgumentError 

, которые могли бы выглядеть примерно так:

module StricterStruct 
    def self.new(*attributes) 
    klass = Class.new 
    klass.instance_eval { ... } 

    klass 
    end 
end 

Но что должно идти в скобки, чтобы определить initialize метод на klass, что:

• Требуется наличие аргументов ключевого слова без значения по умолчанию;
• ключевые слова задаются в виде массива символов в attributes; и
• метод initialize присваивает их переменным экземпляра одного и того же имени

Answer 1

я завелся с использованием (удивительно Pythonic) стратегии **kwargs, благодаря новым признакам в Руби 2.0+:

module StricterStruct 
    def self.new(*attribute_names_as_symbols) 
    c = Class.new 
    l = attribute_names_as_symbols 

    c.instance_eval { 
     define_method(:initialize) do |**kwargs| 
     unless kwargs.keys.sort == l.sort 
      extra = kwargs.keys - l 
      missing = l - kwargs.keys 

      raise ArgumentError.new <<-MESSAGE 
      keys do not match expected list: 
       -- missing keys: #{missing} 
       -- extra keys: #{extra} 
      MESSAGE 
     end 

     kwargs.map do |k, v| 
      instance_variable_set "@#{k}", v 
     end 
     end 

     l.each do |sym| 
     attr_reader sym 
     end 
    } 

    c 
    end 
end 

Answer 2

я мог бы быть недопонимание вопрос, но вы ищете что-то вроде этого?

module StricterStruct 
    def self.new(*attributes) 
    klass = Class.new 
    klass.class_eval do 
     attributes.map!{|n| n.to_s.downcase.gsub(/[^\s\w\d]/,'').split.join("_")} 
     define_method("initialize") do |args| 
     raise ArgumentError unless args.keys.map(&:to_s).sort == attributes.sort 
     args.each { |var,val| instance_variable_set("@#{var}",val) } 
     end 
     attr_accessor *attributes 
    end 
    klass 
    end 
end 

Тогда

Point = StricterStruct.new(:x,:y) 
#=> Point 
p = Point.new(x: 12, y: 77) 
#=> #<Point:0x2a89400 @x=12, @y=77> 
p2 = Point.new(x: 17) 
#=> ArgumentError 
p2 = Point.new(y: 12) 
#=> ArgumentError 
p2 = Point.new(y:17, x: 22) 
#=> #<Point:0x28cf308 @y=17, @x=22> 

Если вы хотите что-то больше, пожалуйста, объясните, как я думаю, что это соответствует вашим критериям, по крайней мере, мое понимание этого. Поскольку он определяет методы и может принимать аргумент «keyword» (Hash) и назначать соответствующие переменные экземпляра.

Если вы хотите, чтобы аргументы указывались в том же порядке, в каком они были определены, просто удалите сортировки.

Также могут быть более чистые реализации.

Answer 3

Похоже, что вы ищете рубин встроенный OpenStruct:

require 'ostruct' 

foo = OpenStruct.new(bar: 1, 'baz' => 2) 
foo # => #<OpenStruct bar=1, baz=2> 

foo.bar # => 1 
foo[:bar] # => 1 
foo.baz # => 2 
foo.baz = 3 
foo # => #<OpenStruct bar=1, baz=3> 

Я думаю, что OpenStruct является конфетным покрытием на Hash, где мы можем получить доступ и присваивать экземпляр без каких-либо реальных ограничений, в отличие от создания реального класса с обычными аксессуарами. Мы можем притвориться, что это хэш, или класс с методами. Это десертная верхушка, нет, это пол-воск, нет, это две вещи в одном!

Answer 4

Я был также охота вокруг этого, и в конце концов наткнулся на этот драгоценный камень, который делает именно это:

https://github.com/etiennebarrie/kwattr

class FooBar 
    kwattr :foo, bar: 21 
end 

foobar = FooBar.new(foo: 42) # => #<FooBar @foo=42, @bar=21> 
foobar.foo # => 42 
foobar.bar # => 21 

вместо

class FooBar 
    attr_reader :foo, :bar 

    def initialize(foo:, bar: 21) 
    @foo = foo 
    @bar = bar 
    end 
end