Делегирование методов экземпляра методу класса

Question

В Ruby, предположим, у меня есть класс Foo чтобы позволить мне составить каталог моей большой коллекции Фоо.Это фундаментальный закон природы, согласно которому все Foo зеленые и сферические, поэтому я определил методы класса следующим образом:

class Foo
  def self.colour
    "green"
  end

  def self.is_spherical?
    true
  end
end

Это позволяет мне делать

Foo.colour # "green"

но не

my_foo = Foo.new
my_foo.colour # Error!

несмотря на то , что my_foo явно зеленый.

Очевидно, что я мог бы определить метод экземпляра colour который призывает self.class.colour, но это становится громоздким, если у меня много таких фундаментальных характеристик.

Я также, вероятно, могу сделать это, определив method_missing чтобы попробовать класс для любых отсутствующих методов, но мне неясно, является ли это тем, что я должен делать, или уродливым взломом, или как это сделать безопасно (тем более, что я на самом деле использую ActiveRecord в Rails, который, как я понимаю, выполняет некоторые умные забавные вещи с method_missing).

Что бы вы порекомендовали?

Answer 1

Вы можете определить транзитное средство:

module Passthrough
  def passthrough(*methods)
    methods.each do |method|
      ## make sure the argument is the right type.
      raise ArgumentError if ! method.is_a?(Symbol)
      method_str = method.to_s
      self.class_eval("def #{method_str}(*args) ; self.class.#{method_str}(*args) ; end")
    end
  end
end

class Foo
  extend Passthrough

  def self::colour ; "green" ; end
  def self::is_spherical? ; true ; end
  passthrough :colour, :is_spherical?
end

f = Foo.new
puts(f.colour)
puts(Foo.colour)

Я вообще не люблю использовать eval, но здесь должно быть довольно безопасно.

Answer 2

Модуль Forwardable, поставляемый с Ruby, прекрасно справится с этой задачей:

#!/usr/bin/ruby1.8

require 'forwardable'

class Foo

  extend Forwardable

  def self.color
    "green"
  end

  def_delegator self, :color

  def self.is_spherical?
    true
  end

  def_delegator self, :is_spherical?

end

p Foo.color                # "green"
p Foo.is_spherical?        # true
p Foo.new.color            # "green"
p Foo.new.is_spherical?    # true

Answer 3

Если это простой Ruby, то используя Пересылаемый это правильный ответ

Если бы это Rails, я бы использовал делегат, например

class Foo
  delegate :colour, to: :class

  def self.colour
    "green"
  end
end

irb(main):012:0> my_foo = Foo.new
=> #<Foo:0x007f9913110d60>
irb(main):013:0> my_foo.colour
=> "green"

Answer 4

Вы можете использовать модуль:

module FooProperties
  def colour ; "green" ; end
  def is_spherical? ; true ; end
end

class Foo
  extend FooProperties
  include FooProperties
end

Немного некрасиво, но лучше, чем использовать method_missing.Я постараюсь включить другие варианты в другие ответы...

Answer 5

С точки зрения дизайна, я бы сказал, что, хотя ответ один и тот же для всех Foos, цветной и сферический?являются свойствами экземпляров Foo и поэтому их следует определять как методы экземпляра, а не как методы класса.

Однако я вижу некоторые случаи, когда вам хотелось бы такого поведения, например.когда у тебя есть Bars в вашей системе все они синие, и где-то в вашем коде вам передается класс, и вы хотели бы знать, какого цвета будет экземпляр, прежде чем вызывать new на классе.

Кроме того, вы правы в том, что ActiveRecord широко использует method_missing напримердля динамических поисковиков, поэтому, если вы пойдете по этому маршруту, вам нужно будет убедиться, что ваш метод_missing вызывает метод из суперкласса, если он определит, что имя метода не является тем, с которым он может справиться сам.

Answer 6

Я думаю, что лучший способ сделать это - использовать метод массива Двемти.

Я собираюсь поискать и дополнить детали, но вот скелет

РЕДАКТИРОВАТЬ:Ура!Работающий!

class Object
  # class where singleton methods for an object are stored
  def metaclass
    class<<self;self;end
  end
  def metaclass_eval &block
    metaclass.instance_eval &block
  end
end
module Defaults
  def self.included(klass, defaults = [])
    klass.metaclass_eval do
      define_method(:add_default) do |attr_name|
        # first, define getters and setters for the instances
        # i.e <class>.new.<attr_name> and <class>.new.<attr_name>=
        attr_accessor attr_name

        # open the class's class
        metaclass_eval do
          # now define our getter and setters for the class
          # i.e. <class>.<attr_name> and <class>.<attr_name>=
          attr_accessor attr_name
        end

        # add to our list of defaults
        defaults << attr_name
      end
      define_method(:inherited) do |subclass|
        # make sure any defaults added to the child are stored with the child
        # not with the parent
        Defaults.included( subclass, defaults.dup )
        defaults.each do |attr_name|
          # copy the parent's current default values
          subclass.instance_variable_set "@#{attr_name}", self.send(attr_name)
        end
      end
    end
    klass.class_eval do
      # define an initialize method that grabs the defaults from the class to 
      # set up the initial values for those attributes
      define_method(:initialize) do
        defaults.each do |attr_name|
          instance_variable_set "@#{attr_name}", self.class.send(attr_name)
        end
      end
    end
  end
end
class Foo
  include Defaults

  add_default :color
  # you can use the setter
  # (without `self.` it would think `color` was a local variable, 
  # not an instance method)
  self.color = "green"

  add_default :is_spherical
  # or the class instance variable directly
  @is_spherical = true
end

Foo.color #=> "green"
foo1 = Foo.new

Foo.color = "blue"
Foo.color #=> "blue"
foo2 = Foo.new

foo1.color #=> "green"
foo2.color #=> "blue"

class Bar < Foo
  add_defaults :texture
  @texture = "rough"

  # be sure to call the original initialize when overwriting it
  alias :load_defaults :initialize
  def initialize
    load_defaults
    @color = += " (default value)"
  end
end

Bar.color #=> "blue"
Bar.texture #=> "rough"
Bar.new.color #=> "blue (default value)"

Bar.color = "red"
Bar.color #=> "red"
Foo.color #=> "blue"

Answer 7

Вы также можете сделать это:

def self.color your_args; your_expression end

define_method :color, &method(:color)

Answer 8

Это может показаться чем-то вроде отговорки, но на практике в этом редко возникает необходимость, когда вы можете так же легко вызвать Foo.color .Исключение составляет случай, если у вас много классов с определенными цветовыми методами.@var может быть одним из нескольких классов, и вы хотите отображать цвет независимо от этого.

Когда это так, я бы спросил себя, где вы больше используете метод - в классе или в модели?Это почти всегда тот или иной метод, и нет ничего плохого в том, чтобы сделать его методом экземпляра, даже если ожидается, что он будет одинаковым во всех экземплярах.

В редком случае, если вы хотите, чтобы метод "вызывался" обоими, вы можете либо выполнить @var.class.color (без создания специального метода), либо создать специальный метод следующим образом:

определение цвета self.class.color конец

Я бы определенно избегал универсального решения (method_missing), потому что это освобождает вас от реального рассмотрения использования каждого метода и того, принадлежит ли он классу или уровню экземпляра.