Рубиновый ноль-подобный объект - PullRequest
12 голосов
/ 07 января 2012

Как я могу создать объект в ruby, который будет оцениваться как ложный в логических выражениях, подобных nil?

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

Например:

fizz.buzz.foo.bar

Если бы свойство buzz fizz было недоступно, я бы возвратил мой объект, похожий на ноль, который бы принимал вызовы вплоть до bar, возвращая себя сам.В конечном итоге приведенное выше утверждение должно быть неверным.

Редактировать:

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

class NilClass
  attr_accessor :forgiving
  def method_missing(name, *args, &block)
    return self if @forgiving
    super
  end
  def forgive
    @forgiving = true
    yield if block_given?
    @forgiving = false
  end
end

Это допускает некоторые хитрые уловки, например:

nil.forgiving {
    hash = {}
    value = hash[:key].i.dont.care.that.you.dont.exist
    if value.nil?
        # great, we found out without checking all its parents too
    else
        # got the value without checking its parents, yaldi
    end
}

Очевидно, что вы можете прозрачно обернуть этот блок внутри некоторого вызова функции / класса / модуля / где угодно.

Ответы [ 4 ]

9 голосов
/ 07 января 2012

Это довольно длинный ответ с кучей идей и примеров кода о том, как решить проблему.

try

В Rails есть метод try , который позволяет вам так программировать. Вот как это реализовано:

class Object
  def try(*args, &b)
    __send__(*a, &b)
  end
end

class NilClass        # NilClass is the class of the nil singleton object
  def try(*args)
    nil
  end
end

Вы можете запрограммировать его следующим образом:

fizz.try(:buzz).try(:foo).try(:bar)

Вы можете изменить это, чтобы работать немного по-другому, чтобы поддерживать более элегантный API:

class Object
  def try(*args)
    if args.length > 0
      method = args.shift         # get the first method
      __send__(method).try(*args) # Call `try` recursively on the result method
    else
      self                        # No more methods in chain return result
    end
  end
end
# And keep NilClass same as above

Тогда вы могли бы сделать:

fizz.try(:buzz, :foo, :bar)

andand

andand использует более гнусную технику, взломав тот факт, что вы не можете напрямую создавать экземпляры подклассов NilClass:

class Object
  def andand
    if self
      self
    else               # this branch is chosen if `self.nil? or self == false`
      Mock.new(self)   # might want to modify if you have useful methods on false
    end
  end
end

class Mock < BasicObject
  def initialize(me)
    super()
    @me = me
  end
  def method_missing(*args)  # if any method is called return the original object
    @me
  end
end

Это позволяет программировать следующим образом:

fizz.andand.buzz.andand.foo.andand.bar

Объединить с какой-нибудь необычной перепиской

Опять вы можете расширить эту технику:

class Object
  def method_missing(m, *args, &blk)        # `m` is the name of the method
    if m[0] == '_' and respond_to? m[1..-1] # if it starts with '_' and the object
      Mock.new(self.send(m[1..-1]))         # responds to the rest wrap it.
    else                                    # otherwise throw exception or use
      super                                 # object specific method_missing
    end
  end
end

class Mock < BasicObject
  def initialize(me)
    super()
    @me = me
  end
  def method_missing(m, *args, &blk)
    if m[-1] == '_'  # If method ends with '_'
      # If @me isn't nil call m without final '_' and return its result.
      # If @me is nil then return `nil`.
      @me.send(m[0...-1], *args, &blk) if @me 
    else 
      @me = @me.send(m, *args, &blk) if @me # Otherwise call method on `@me` and
      self                                  # store result then return mock.
    end
  end
end

Чтобы объяснить, что происходит: когда вы вызываете подчеркнутый метод, вы запускаете фиктивный режим, результат _meth автоматически переносится в объект Mock. Каждый раз, когда вы вызываете метод для этого макета, он проверяет, не содержит ли он nil, а затем перенаправляет ваш метод этому объекту (здесь он хранится в переменной @me). Затем макет заменяет исходный объект результатом вызова вашей функции. Когда вы вызываете meth_, он завершает режим имитации и возвращает фактическое возвращаемое значение meth.

Это позволяет использовать API, подобный этому (я использовал подчеркивание, но вы могли бы использовать действительно что угодно):

fizz._buzz.foo.bum.yum.bar_

Брутальный подход к исправлению обезьян

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

class NilClass
  attr_accessor :complain
  def method_missing(*args)
    if @complain
      super
    else
      self
    end
  end
end
nil.complain = true

Используйте вот так:

nil.complain = false
fizz.buzz.foo.bar
nil.complain = true
6 голосов
/ 07 января 2012

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

Камень andand используется так:

require 'andand'
...
fizz.buzz.andand.foo.andand.bar
3 голосов
/ 07 января 2012

Вы можете изменить класс NilClass, чтобы использовать method_missing() для ответа на любой еще не определенные методы.

> class NilClass
>   def method_missing(name)
>     return self
>   end
> end
=> nil
> if nil:
*   puts "true"
> end
=> nil
> nil.foo.bar.baz
=> nil
2 голосов
/ 07 января 2012

Существует принцип, называемый Законом Деметры [1], который предполагает, что то, что вы пытаетесь сделать, не является хорошей практикой, поскольку ваши объекты не обязательно должны знать так много о взаимоотношениях других объектов.

Однако мы все это делаем: -)

В простых случаях я склонен делегировать цепочку атрибутов методу, который проверяет существование:

class Fizz
  def buzz_foo_bar
    self.buzz.foo.bar if buzz && buzz.foo && buzz.foo.bar
  end
end

Так что теперь я могу позвонить fizz.buzz_foo_bar, зная, что не получу исключение.

Но у меня также есть фрагмент кода (на работе, и я не могу получить его до следующей недели), который обрабатывает пропущенный метод и ищет подчеркивания и тестирует отраженные ассоциации, чтобы увидеть, отвечают ли они остальной части цепь. Это означает, что мне теперь не нужно писать методы делегата и многое другое - просто включите патч method_missing:

module ActiveRecord
  class Base
    def children_names
      association_names=self.class.reflect_on_all_associations.find_all{|x| x.instance_variable_get("@macro")==:belongs_to}
      association_names.map{|x| x.instance_variable_get("@name").to_s} | association_names.map{|x| x.instance_variable_get("@name").to_s.gsub(/^#{self.class.name.underscore}_/,'')}
    end

    def reflected_children_regex
      Regexp.new("^(" << children_names.join('|') << ")_(.*)")
    end

    def method_missing(method_id, *args, &block)
      begin
        super
      rescue NoMethodError, NameError
        if match_data=method_id.to_s.match(reflected_children_regex)
          association_name=self.methods.include?(match_data[1]) ? match_data[1] : "#{self.class.name.underscore}_#{match_data[1]}"
          if association=send(association_name)
            association.send(match_data[2],*args,&block)
          end
        else
          raise
        end
      end
    end
  end
end

[1] http://en.wikipedia.org/wiki/Law_of_Demeter

...