• Още метапрограмиране и Ruby вътрешности
• Някои бележки относно ваши решения от втора задача и предизвикателство
• По-късно днес - трета задача

• Ще бъде из Плана планина
• Среща в 10:50 на спирката на автобус №3 до Метро (карта)
• Oбути подходящо, с дъждобранче (за всеки случай)
• Елате навреме, защото автобусът е през час и няма да чакаме закъснелите
• Тема във форума
• Събитието във Фейсбук - отбележете, ако ще идвате

• Искахме да напишете клас Spy, който е по същество едно прокси
• Да събира извикванията на методи в списък, достъпен отвън чрез Spy#calls
• Да хвърля Spy::Error (наследник на NoMethodError), ако target-а не отговаря на даден метод

• Да наследите от BasicObject (даже имаше подсказка за това във форумите)
• Да изпозлвате respond_to? и public_send
• Да се сблъскате с някои проблеми, произтичащи от факта, че наследявате от BasicObject

• Много от вас са се усетили, че трябва да ползват :: пред външни константи в проксито
• Примерите са ::NoMethodError, ::Kernel и т.н.
• Причината е, че Spy.ancestors не съдържа Object и Spy е клас
• Затова не можем да разчитаме на стандартния път за търсене на константи, които не са дефинирани в Spy

• Ако някой е опитал да извика raise, е усетил, че това не работи
• raise идва от Kernel
• Ако наследявате от BasicObject, не получавате нищо от Kernel
• Как можем да извикаме raise, тогава?
• Бихме могли да направим това: Object.new.send :raise, ...
• Или, можем да подходим по-умно

• Както знаете, Kernel се миксира (include-ва) в Object
• Инстанционните методи в този модул са private

module Kernel
  private

  def puts()  ... end
  def raise() ... end
  ...
end

• В нашето решение, ние ползваме Kernel.raise
• Kernel прави extends self

module Kernel
  extends self

  private

  def puts()  ... end
  def raise() ... end
  ...
end

Не ползвате attr_*:

def calls
  @called_methods
end

Ползвате attr_accessor:

class Spy
  attr_accessor :calls
end

Ползвате attr_accessor за неща, които не трябват:

class Spy
  attr_accessor :instance, :calls
end

Собствените методи на едно прокси трябва да бъдат свеждани до минимум.

Това @instance.methods.include? name го видях на поне три места:

def method_missing(name, *args, &block)
  if not @instance.methods.include? name
    raise Error.new
  else
    @called_metods = @called_methods << name
    @instance.method(name).call *args, &block
  end
end

Няколко други проблема тук:

• if not - по-добре unless или обръщане на клаузите
• Зацикляне - класическият капан на method_missing
• foo = foo << bar

class Spy::Error < NoMethodError
end

• Вложени класове обикновено се дефинират вътре в класа
• Използвате ::NoMethodError, за да работи в случая

Това е очевидно и е проблем за проксито.

Долното не е честа практика, излишно е и е по-добре на два реда:

def initialize(object)
  @object, @calls = object, []
end

#!/usr/local/bin/ruby -w

class Spy ...

Не го правете.

class Spy
  attr_accessor :victim, :method_calls
  ...
end

Не.

class Spy
  def method_missing(name, *args)
    if @object.class.instance_methods(false).include? name then
      ...
  end
end

• respond_to? :wat?!
• if ... then

def method_missing(name, *args, &block)
  unless @object.respond_to? name
      raise Error, "Undefined method #{name} called on object of class #{@object.class}."
  end

  @calls << name unless name == :inspect
  @object.send(name, *args, &block)
end

• @calls << name unless name == :inspect - защо?
• Проблеми с идентацията!
• Ненужно съобщение за грешка в случая (не го искахме в условието)

• Все още има решения с проблеми в идентацията
• Крайно недопустимо
• В тази връзка, подготвяме нови skeptic правила
• Stay tuned...

Не ползвате най-простото работещо решение:

def method_missing(name, *args, &block)
  begin
    result = @class_instance.public_send(name, *args, &block)
  rescue NoMethodError
    raise Error
  else
    @calls << name.to_sym
    result
  end
end

• Това може да има странични ефекти
• to_sym е излишно
• Нуждата от result тук трябва да е сигнал

Това с Error.error е любопитен начин за заобикаляне на липсата на raise в контекста на Spy, признавам:

class Spy < BasicObject
  def method_missing(name, *args, &block)
    if @object.respond_to? name
      @calls << name
      @object.method(name).call *args, &block
    else
      Error.error
    end
  end

  class Error < ::NoMethodError
    def self.error
      raise Error
    end
  end
end

Само че foo.public_send :bar, а не foo.method(:bar).call.

Между другото, това е интересен трик, който не сме споменавали:

class Spy
  def respond_to_missing?(method, *)
    # I don't care about all other args except "method"
  end
end

Как Ruby пази полета и методи?

Кажете ми всичко, което знаете за instance променливите.

Кой е класът на "foo"? На Integer? На Class?

Кой е родителят на String? На Object? На Class?

"foo".class == String  # true
Integer.class == Class # true
Class.class == Class   # true

String < Object        # true
Object < BasicObject   # true
Class < Module         # true

Какво прави instance_eval?

Изпълнява блока с променен self.

Как Ruby знае къде да постави метод, дефиниран с def?

Винаги има текущ клас, в който този метод отива. Той може да се промени с module, class и class_eval. Всъщност, дори с instance_eval, но за това — по-късно.

Може да (пре)дефинирате метод в конкретен обект.

things = [22, :f, 'Sofia']

def things.size
  -5
end

def things.asl
  "#{self[0]}/#{self[1]}/#{self[2]}"
end

things        # [22, :f, "Sofia"]
things.size   # -5
things.length # 3
things.asl    # "22/f/Sofia"

[].asl        # error: NoMethodError
[].size       # 0

• Само модули могат да съдържат методи
• Когато дефинирате метод на конкретен обект, Ruby го добавя в специален клас за този обект
• Всеки обект има специален клас, наречен singleton class, който съдържа специалните за него методи
• Горното е полу-истина. Такъв клас се създава само ако има нужда
• Известен е още като metaclass, eigenclass и собствен клас

Собственият клас е достъпен чрез #singleton_class

things = []

def things.answer
  42
end

things.singleton_class # #<Class:#<Array:0x4151d448>>
things.singleton_class.instance_methods(false) # [:answer]

[].singleton_class.instance_methods(false)     # []

Целите числа и символите нямат собствени класове. Това е заради оптимизация. В Ruby интерпретатора, те се представят по много различен начин от всички други обекти.

1_000.singleton_class # error: TypeError
:blah.singleton_class # error: TypeError

Можете да отворите собствения клас на обект с class <<

things = [22, :f, 'Sofia']

class << things
  def size
    -5
  end

  def asl
    "#{self[0]}/#{self[1]}/#{self[2]}"
  end
end

things.asl  # "22/f/Sofia"
things.size # -5

Оригиналният метод е достъпен чрез super.

Някой има ли идея защо super работи?

things = []

def things.answer
  42
end

things.singleton_class # #<Class:#<Array:0x412261cc>>
things.singleton_class.superclass # Array

Вероятно помните, че класови методи могат да се дефинират така:

class Something
  def Something.foo() 42 end
  def self.bar() 42 end

  class << self
    def qux() 42 end
  end
end

Класовите методи се пазят в собствения клас на класа

class Something
  def self.answer() 42 end
end

Something.singleton_class # #<Class:Something>
Something.singleton_class.instance_methods(false) # [:answer]

Помните ли extend?

module Knowledge
  def answer() 42 end
end

class Something
  extend Knowledge
end

Something.answer # 42

module Knowledge
  def answer() 42 end
end

text = "fourty-two"
text.extend Knowledge

text.answer # 42

Сещате ли се как може да се имплементира?

module Knowledge
  def answer() 42 end
end

class Something; end

Something.singleton_class.include Knowledge

Something.answer # 42

Изводът е, че include и extend са просто методи, викащи се на определени обекти.

Класовите методи на родителя са достъпни в класовите методи на наследника:

class Something
  def self.answer() 42 end
end

class Other < Something
  def self.better_answer() answer * 2 end
end

Other.better_answer # 84

Собственият клас на наследника наследява собствения клас на родителя:

class Something; end
class Other < Something; end

Something.singleton_class        # #<Class:Something>
Other.singleton_class.superclass # #<Class:Something>

Something.singleton_class == Other.singleton_class.superclass # true

• Това продължава още едно ниво нагоре – до BasicObject и неговия метаклас
• Метакласът на BasicObject наследява от Class
• Тук "цикълът" се затваря и нещата започват да изглеждат както при метакласове на обикновени обекти
• Обърнете внимание на разликата в родителя на метакласа при обикновени обекти и при обекти тип "клас"
• При класове (които също са обекти), йерархията е по-различна

Метакласът на суперкласа е суперкласът на метакласа.

1. Има само един вид обекти - били те обикновени или модули
2. Има само един вид модули - били те обикновени или клас
3. Има само един вид методи - живеят в модули, които често са класове
4. Всеки обект има "реален клас" - бил той обикновен клас или собствен клас
5. Всеки клас има точно един суперклас - с изключение на BasicObject
6. Суперкласът на метакласа на обект е класът на обекта. Суперкласът на метакласа на клас е метакласът на родителя на класа.
7. При извикване на метод, Ruby взема "реалния клас" и търси в неговия ancestor chain

∎

• Викайки метод на произволен обект object, Ruby го търси в object.singleton_class.ancestors
• Тоест, за всеки инстанционен метод, в това число и "класовите", се гледа ancestor chain-а на singleton класа на обекта
• А класовите методи са просто инстанционни методи и инстанцията е обектът от тип "клас"
• Толкова просто е

Относно търсенето на (инстанционни) методи на обектите от тип String:

''.singleton_class.ancestors
# => [#<Class:#<String:0x007f8788e51bd8>>, String,
#     Comparable, Object, Kernel, BasicObject]

''.class.ancestors
# => [String, Comparable, Object, Kernel, BasicObject]

String.ancestors
# => [String, Comparable, Object, Kernel, BasicObject]

По отношение на "класовите" методи, викани върхy String:

String.singleton_class.ancestors
# => [#<Class:String>, #<Class:Object>, #<Class:BasicObject>,
#    Class, Module, Object, Kernel, BasicObject]

String.class.ancestors
# => [Class, Module, Object, Kernel, BasicObject]

Class.ancestors
# => [Class, Module, Object, Kernel, BasicObject]

• Стефан ще ви поговори за тестване (най-накрая)
• И вероятно за lambda смятане :)

• http://fmi.ruby.bg/
• @rbfmi