Сухая инициализация Ruby с хэш-аргументом

Я довольно часто использую хэш-аргументы для конструкторов, особенно при написании DSL для конфигурации или других бит API, которые будут доступны конечному пользователю. В конечном итоге я делаю что-то вроде следующего:

class Example

    PROPERTIES = [:name, :age]

    PROPERTIES.each { |p| attr_reader p }

    def initialize(args)
        PROPERTIES.each do |p|
            self.instance_variable_set "@#{p}", args[p] if not args[p].nil?
        end
    end

end

нет ли более идиоматические способ достичь этого? Константа выброса и преобразование символа в строку кажутся особенно вопиющими.

50
dry idioms initialization ruby

6 ответов

вам не нужна константа, но я не думаю, что вы можете устранить символ в строку:

class Example
  attr_reader :name, :age

  def initialize args
    args.each do |k,v|
      instance_variable_set("@#{k}", v) unless v.nil?
    end
  end
end
#=> nil
e1 = Example.new :name => 'foo', :age => 33
#=> #<Example:0x3f9a1c @name="foo", @age=33>
e2 = Example.new :name => 'bar'
#=> #<Example:0x3eb15c @name="bar">
e1.name
#=> "foo"
e1.age
#=> 33
e2.name
#=> "bar"
e2.age
#=> nil

кстати, вы можете взглянуть (если вы еще этого не сделали) на Struct Class generator class, это несколько похоже на то, что вы делаете, но нет инициализации хэш-типа (но я думаю, было бы нетрудно сделать адекватный класс генератора).

HasProperties

пытаясь реализовать идею хурихана, это то, что я пришел кому:

module HasProperties
  attr_accessor :props

  def has_properties *args
    @props = args
    instance_eval { attr_reader *args }
  end

  def self.included base
    base.extend self
  end

  def initialize(args)
    args.each {|k,v|
      instance_variable_set "@#{k}", v if self.class.props.member?(k)
    } if args.is_a? Hash
  end
end

class Example
  include HasProperties

  has_properties :foo, :bar

  # you'll have to call super if you want custom constructor
  def initialize args
    super
    puts 'init example'
  end
end

e = Example.new :foo => 'asd', :bar => 23
p e.foo
#=> "asd"
p e.bar
#=> 23

поскольку я не настолько опытен в метапрограммировании,я сделал ответ сообщества wiki, так что любой может изменить реализацию.

Struct.hash_initialized

расширяя ответ Марка-Андре, вот общий,Struct основанный метод для создания хэш-инициализированных классов:

class Struct
  def self.hash_initialized *params
    klass = Class.new(self.new(*params))

    klass.class_eval do
      define_method(:initialize) do |h|
        super(*h.values_at(*params))
      end
    end
    klass
  end
end

# create class and give it a list of properties
MyClass = Struct.hash_initialized :name, :age

# initialize an instance with a hash
m = MyClass.new :name => 'asd', :age => 32
p m
#=>#<struct MyClass name="asd", age=32>
78

на Struct clas может помочь вам создать такой класс. Инициализатор принимает аргументы один за другим, а не как хэш, но это легко преобразовать:

class Example < Struct.new(:name, :age)
    def initialize(h)
        super(*h.values_at(:name, :age))
    end
end

Если вы хотите оставаться более общим, вы можете позвонить values_at(*self.class.members) вместо.

31

в Ruby есть некоторые полезные вещи для такого рода вещей. Класс OpenStruct сделает значения a переданными для его инициализации метод доступен в качестве атрибутов класса.

require 'ostruct'

class InheritanceExample < OpenStruct
end

example1 = InheritanceExample.new(:some => 'thing', :foo => 'bar')

puts example1.some  # => thing
puts example1.foo   # => bar

документы здесь: http://www.ruby-doc.org/stdlib-1.9.3/libdoc/ostruct/rdoc/OpenStruct.html

Что делать, если вы не хотите наследовать OpenStruct (или не можете, потому что вы уже наследование от чего-то другого)? Вы можете делегировать все метод вызовы экземпляра OpenStruct с возможностью пересылки.

require 'forwardable'
require 'ostruct'

class DelegationExample
  extend Forwardable

  def initialize(options = {})
    @options = OpenStruct.new(options)
    self.class.instance_eval do
      def_delegators :@options, *options.keys
    end
  end
end

example2 = DelegationExample.new(:some => 'thing', :foo => 'bar')

puts example2.some  # => thing
puts example2.foo   # => bar

документы для Forwardable здесь: http://www.ruby-doc.org/stdlib-1.9.3/libdoc/forwardable/rdoc/Forwardable.html

10

учитывая, что ваши хэши будут включать ActiveSupport::CoreExtensions::Hash::Slice, есть очень хорошее решение:

class Example

  PROPERTIES = [:name, :age]

  attr_reader *PROPERTIES  #<-- use the star expansion operator here

  def initialize(args)
    args.slice(PROPERTIES).each {|k,v|  #<-- slice comes from ActiveSupport
      instance_variable_set "@#{k}", v
    } if args.is_a? Hash
  end
end

Я бы абстрагировал это на общий модуль, который вы могли бы включить и который определяет метод "has_properties" для установки свойств и правильной инициализации (это непроверено, возьмите его как псевдо-код):

module HasProperties
  def self.has_properties *args
    class_eval { attr_reader *args }
  end

  def self.included base
    base.extend InstanceMethods
  end

  module InstanceMethods
    def initialize(args)
      args.slice(PROPERTIES).each {|k,v|
        instance_variable_set "@#{k}", v
      } if args.is_a? Hash
    end
  end
end
3

мое решение похоже на Marc-André Lafortune. Разница в том, что каждое значение удаляется из входного хэша, поскольку оно используется для назначения переменной-члена. Затем производный от структуры класс может выполнять дальнейшую обработку того, что может остаться в хэше. Например, jobrequest ниже сохраняет любые "дополнительные" аргументы из хэша в поле options.

module Message
  def init_from_params(params)
    members.each {|m| self[m] ||= params.delete(m)}
  end
end

class JobRequest < Struct.new(:url, :file, :id, :command, :created_at, :options)
  include Message

  # Initialize from a Hash of symbols to values.
  def initialize(params)
    init_from_params(params)
    self.created_at ||= Time.now
    self.options = params
  end
end
2

пожалуйста, взгляните на мой драгоценный камень,ценность:

class PhoneNumber < Valuable
  has_value :description
  has_value :number
end

class Person < Valuable
  has_value :name
  has_value :favorite_color, :default => 'red'
  has_value :age, :klass => :integer
  has_collection :phone_numbers, :klass => PhoneNumber
end

jackson = Person.new(name: 'Michael Jackson', age: '50', phone_numbers: [{description: 'home', number: '800-867-5309'}, {description: 'cell', number: '123-456-7890'})

> jackson.name
=> "Michael Jackson"
> jackson.age
=> 50
> jackson.favorite_color
=> "red"
>> jackson.phone_numbers.first
=> #<PhoneNumber:0x1d5a0 @attributes={:description=>"home", :number=>"800-867-5309"}>

Я использую его для всего: от классов поиска ( EmployeeSearch, TimeEntrySearch) до отчетов (EmployeesWhoDidNotClockOutReport, ExecutiveSummaryReport) до докладчиков до конечных точек API. Если вы добавите некоторые биты ActiveModel, вы можете легко подключить эти классы к формам для сбора критериев. Надеюсь, вы найдете это полезным.

1