12. Интроспекция и метапрограмиране, част 2

21 ноември 2016

Днес

Още интроспекция. Метапрограмиране!

Практика, практика, практика

Това е единственият начин, по който може да трупате знания и умения
Сухата теория е необходима, но крайно недостатъчна
Задачи, предизвикателства, четене на код и експерименти – всичко помага
Колкото по-рано и редовно – толкова по-добре

Първи тест

На 30 ноември, вместо лекция; ще бъдете разделени на две групи
30 затворени въпроса, 45 минути; верен отговор = 1 т.; грешен = 0 т.
Ще включва материал, предаден до 28 ноември, включително
Има два теста, носят по максимум 30 точки всеки
Вторият тест ще е в края на семестъра и/или по време на сесията

Въпрос 1

Какъв ще е резултатът от кода по-долу – грешка или стойност? Ако е стойност, каква?

class Foo; end
class Bar; end

Foo.const_get(:Bar).name # => ?

Резултатът ще е "Bar". const_get работи на принципа на нормалното търсене на константи. Ако константа не се намери в текущия namespace, се продължава търсене нагоре, докато евентуално не се стигне до root namespace-а.

Въпрос 2

На какво ще се оцени кодът по-долу? Защо?

object_a = {}
object_b = Hash

object_a.methods.size == object_b.methods.size # => ?

Резултатът ще е false. Причината за това е, че object_a е тип "речник" и отгoваря на едни методи, а object_b е тип "клас" и отгваря на други методи. Object#methods е интроспективен метод, връщащ списък с нещата, които можем да извикваме на получателя.

Въпрос 3

На какво ще се оцени кодът по-долу? Защо?

class Rectangle
  attr_accessor :x, :y, :width, :height
  def initialize(x, y) @x, @y = x, y end
end

rect = Rectangle.new(5, 10)
rect.height

rect.instance_variables # => ?

Резултатът ще е [:@x, :@y]. Интроспективният метод Object#instance_variables връща списък с имената на инстанционните променливи на дадения обект. Инстанционните променливи се появяват при първото им задаване на стойност. attr_* клас-макросите създават методи, които вътрешно ползват инстанционни променливи.

Въпрос 4

Какво ще се изведе на екрана в резултат на изпълнението на следния код? Защо?

x = 42
defined?(x += 1)
puts x

На екрана ще се изведе 42. Причината за това е, че изразът, подаден като аргумент на defined?, няма да бъде изпълнен/оценен, тъй като defined? е синтаксис и оценява "подадения" израз само синтактично.

defined? връща или низ с описанието на израза, или nil, ако това е несъществуваща локална/глобална променлива/метод.

Въпрос 5

Какъв ще е резултатът от кода по-долу?

def greet_with
  "Hello, #{yield}!"
end

def pass_block
  greet_with(&Proc.new) if block_given?
end

pass_block            # => ?
pass_block { 'Matz' } # => ?

Резултатът от първото извикване на pass_block ще е nil, а от второто – "Hello, Matz!".

Ако в метод извикаме Proc.new без аргументи и без блок, Proc.new ще ни върне блока, асоцииран с извикването на обкръжаващия метод. Ако няма такъв блок и викнем Proc.new, ще се получи грешка.

Въпрос 6

Представете си, че сте открили, че някоя библиотека в Ruby програмата ви е monkey patch-нала Hash#reject и това е довело до неочаквани бъгове във вашия код, но не сте сигурни коя и как. Как може да откриете виновника?

Бихте могли да използвате интроспекцията Object#method(method_name) по следния начин, някъде в програмата ви:

raise {}.method(:reject).source_location.inspect

Горното ще предизвика изключение, чиито текст ще изглежда така:

RuntimeError: ["/path/to/the/offending/gem.rb", 42]

Въпрос 7

Какво прави методът parameters на класа Method? Кои други класове имат такъв публичен метод?

Method#parameters връща списък с информация за параметрите на метода – името и вида им.

Такъв метод имат и инстанциите на класа Proc, тоест – блокове и анонимни функции. Също така и класът UnboundMethod.

Метапрограмиране

Липсващи методи и константи (method_missing и компания)
Любопитни неща за обектния модел в Ruby
define_method
Всичките варианти на eval
В дълбочина за обектния модел в Ruby
Singleton класове
Ще започнем с Hooks

Hooks

Куки

Ruby ви дава възможност да се закачате на определени събития посредством hooks
Обикновено във въпросните hooks може да промените нещото, което се случва, по някакъв начин
Ще разгледаме някои hooks за събития, възникващи при промяна и изпълнение на код

Добавяне и махане на методи

Можем да бъдем известени, че някой е добавил метод в модул или клас
Това става като си дефинираме Module#method_added(method_name)
Същото нещо, но за премахване на методи, е Module#method_removed(...)

Добавяне и махане на методи

Пример

module Foo
  def self.method_added(name)
    puts "A-ha! You added the #{name} method!"
  end
end

module Foo
  def bar
  end
end # Извежда "A-ha! You added the bar method!"

Още hooks

Kernel::singleton_method_added се вика, когато добавите класов метод в модул или клас
Class#inherited се вика, когато вашият клас бъде наследен от друг клас
Bar.included се вика, когато някой напише class Foo; include Bar; end
Bar.extend_object се вика, когато някой напише class Foo; extend Bar; end
Това не е изчерпателен списък
Закачате се за всяка от тях, като дефинирате метод def self.some_hook_name(...) end

Hooks

В тези hooks получавате аргументи, които ви дават възможност да следите какво се случва
Например – името на добавен/премахнат метод, класът наследник, класът, който ви е include-нал и т.н.
В тези моменти можете да извършите някакво допълнително действие, ако се налага
Това е един от механизмите за създаване на любопитни, динамични разширения на езика
included е може би най-често използваната; inherited също се ползва понякога

Човъркане с виртуалната машина

Имаме възможност да правим някои неща с виртуалната машина (интерпретатора) на Ruby
Да спрем събирането на боклука
Модулът GC - интерфейс към mark-and-sweep garbage collector-а на Ruby
GC.disable спира събирането на неизползвани обекти

GC.methods - Object.methods # => [:count, :stat, :start, :enable, :disable, :stress, :stress=, :latest_gc_info, :verify_internal_consistency]
GC.constants                # => [:INTERNAL_CONSTANTS, :Profiler, :OPTS]

GC::Profiler

Профилиране на garbage collector-а

GC::Profiler.enable
require 'active_support/ordered_hash'
puts GC::Profiler.result

Резултати:

GC 8 invokes.
Index  Invoke Time(sec)  Use Size(byte)  Total Size(byte)  Total Object  GC Time(ms)
    1             0.706         2889840          16818080        420452      23.7169

За десерт

Kernel#set_trace_func(proc)
Задава въпросния proc обект като трасираща функция
Параметри: име на събитие, файл, ред, object_id, binding, клас
Понеже му давате proc, може да пропуснете част от параметрите

Kernel#set_trace_func(proc)

Събития

c-call - извикване на C-метод
c-return - връщане от C-метод
call - извикване на Ruby метод
return - връщане от Ruby метод
class начало на дефиниция на клас или модул
end край на горната дефиниция
line изпълняване на код на ред Х
raise възникнало изключение

Kernel#set_trace_func

Пример

tracer = proc do |event, file, line, id, binding, classname|
   printf "%8s %s:%-2d %15s %15s\n", event, file, line, id, classname
end

set_trace_func tracer

class Foo
  def bar
    a, b = 1, 2
  end
end

larodi = Foo.new
larodi.bar

Kernel#set_trace_func

Резултати

c-return t.rb:5   set_trace_func          Kernel
    line t.rb:7
  c-call t.rb:7        inherited           Class
c-return t.rb:7        inherited           Class
   class t.rb:7
    line t.rb:8
  c-call t.rb:8     method_added          Module
c-return t.rb:8     method_added          Module
     end t.rb:11
(Продължава на следващия слайд...)

Kernel#set_trace_func

Резултати

(Продължение от предишния слайд...)
    line t.rb:13
  c-call t.rb:13             new           Class
  c-call t.rb:13      initialize     BasicObject
c-return t.rb:13      initialize     BasicObject
c-return t.rb:13             new           Class
    line t.rb:14
    call t.rb:8              bar             Foo
    line t.rb:9              bar             Foo
  return t.rb:10             bar             Foo

Kernel#trace_var

Може да ползвате Kernel#trace_var, за да следите за промени по глобални променливи
Важи само за "специални" глобални променливи, не за такива, дефинирани от вас

Kernel#trace_var

Пример

trace_var :$_ do |value|
  puts "$_ is now #{value.inspect}"
end

$_ = "Ruby"
$_ = ' > Python'

Извежда следното:

$_ is now "Ruby"
$_ is now " > Python"

Интроспекция

Code smell!

Напомняме: третирайте всички техники, показани тук, като code smell
Много е вероятно да има друг, по-прост, чист и елегантен дизайн, решаващ същия проблем
Просто вие не сте го открили още; помислете добре, преди да прибегнете до тези техники
Ползвайте ги само за дебъг, експерименти, или в краен случай, когато нямате друг избор

Метапрограмиране

първа дефиниция

Метапрограмирането е писането на код, който пише друг код

meta-

meta- (also met- before a vowel or h)
combining form

1. denoting a change of position or condition : metamorphosis | metathesis.
2. denoting position behind, after, or beyond: : metacarpus.
3. denoting something of a higher or second-order kind : metalanguage | metonym.
4. Chemistry denoting substitution at two carbon atoms separated by one other in a benzene ring, e.g., in 1,3 positions : metadichlorobenzene. Compare with ortho- and para- 1 .
5. Chemistry denoting a compound formed by dehydration : metaphosphoric acid.

ORIGIN from Greek meta ‘with, across, or after.’

Заигравка с Proc#parameters (0)

Припомняме какво връща методът Proc#parameters:

proc { |x, y = 5, *z| }.parameters
# => [[:opt, :x], [:opt, :y], [:rest, :z]]

Списък от списъци с по два елемента. Вторият елемент на вътрешния списък е името на параметъра. Ако искате да вземете имената на всички параметри:

proc { |x, y = 5, *z| }.parameters.map(&:last)
# => [:x, :y, :z]

Заигравка с Proc#parameters (1)

Нека имаме този клас:

class Student
  attr_accessor :name, :age, :faculty_number

  def initialize(**attributes)
    attributes.each do |name, value|
      send "#{name}=", value
    end
  end
end

average_joe = Student.new name: 'Joe', age: 33, faculty_number: '42042'
average_joe.name           # => "Joe"
average_joe.age            # => 33
average_joe.faculty_number # => "42042"

Заигравка с Proc#parameters (2)

Нека имаме списък с такива студенти:

students = [
  Student.new(name: 'Asya',   age: 6,  faculty_number: '12345'),
  Student.new(name: 'Stefan', age: 28, faculty_number: '666'),
  Student.new(name: 'Tsanka', age: 12, faculty_number: '42042'),
  Student.new(name: 'Sava',   age: 3,  faculty_number: '53453'),
]

Заигравка с Proc#parameters (3)

И нека сме направили този monkey patch:

class Enumerator
  def extract(&block)
    each do |object|
      block.call object.send(block.parameters.first.last)
    end
  end
end

Заигравка с Proc#parameters (4)

Тогава, можем да направим това:

students.map.extract { |name| name.upcase }
# => ["ASYA", "STEFAN", "TSANKA", "SAVA"]
students.map.extract { |age| age * 10 }
# => [60, 280, 120, 30]

students.each.extract do |faculty_number|
  puts faculty_number
end
# Prints out 12345, then 666, then 42042, then 53453

Въпроси дотук?

Ще продължим с method_missing.

Извикване на несъществуващи методи

При извикване на метод bar върху обект foo в Ruby:

foo.bar(42)

Търси се първият клас или модул във foo.ancestors, имащ метод bar
Използва се първата намерена версия
Ако foo.ancestors се изчерпи и не се намери метод bar?
Преди да видим изключението NoMethodError, се случва още нещо
Ruby претърсва ancestors още веднъж, извиквайки method_missing(:bar, 42)
Такъв метод има дефиниран в BasicObject и имплементацията му хвърля NoMethodError

BasicObject#method_missing

примерна имплементация

class BasicObject
  def method_missing(method_name, *arguments, &block)
    message = "undefined local variable or method `#{method_name}' for #{inspect}:#{self.class}"
    raise NoMethodError, message
  end
end

BasicObject#method_missing

Можем да го предефинираме по-рано в ancestors (обикновено в нашия клас)
Това можем да променим поведението на Ruby при извикване на несъществуващи методи върху обектите от класа ни
Обикновено в част от случаите на имплементацията все пак викаме и super
Трябва да се прави внимателно, понеже има бая поле за грешка

BasicObject#method_missing

пример

class Hash
  def method_missing(name, *args, &block)
    args.empty? ? self[name] : super
  end
end

things = {fish: 'Nemo', lion: 'Simba'}

things.fish   # => "Nemo"
things.lion   # => "Simba"
things.larodi # => nil
things.foo(1) # => error: NoMethodError

BasicObject#method_missing

капани и коварни моменти

class Hash
  def method_missing(name, *arg, &block)
    args.empty? ? self[name] : super
  end
end

things = {lion: 'Simba'}
things.lion # => error: SystemStackError (stack level too deep)

Има typo - arg вместо args.
args всъщност е self.args.
Такъв метод няма и Ruby вика method_missing и – хоп! Бездънна рекурсия.

Object#respond_to_missing?

Спомняте ли си respond_to?
respond_to? не работи за методите, на които "отговаряте" през method_missing
respond_to? вика respond_to_missing?, ако методът, за който питате, не е дефиниран
Добра практика е да дефинирате respond_to_missing?, ако имате и method_missing

Object#respond_to_missing?

сигнатура

class Foo
  def respond_to_missing?(symbol, include_private)
    # Return true or false
  end
end

Object#respond_to_missing?

пример

class Foo
  def respond_to_missing?(method_name, include_private)
    puts "Looking for #{method_name}"
    super
  end

  private

  def bar() end
end

Foo.new.respond_to? :larodi     # false и на екрана се извежда "Looking for larodi"
Foo.new.respond_to? :bar        # false и на екрана се извежда "Looking for bar"
Foo.new.respond_to? :bar, true  # true

Module#const_missing

module Unicode
  def self.const_missing(name)
    if name.to_s =~ /^U([0-9a-fA-F]{4,5}|10[0-9a-fA-F]{4})$/
      codepoint = $1.to_i(16)
      utf8 = [codepoint].pack('U')
      utf8.freeze
      const_set(name, utf8)
      utf8
    else
      super
    end
  end
end

Unicode::U20AC  # => "€"
Unicode::U221E  # => "∞"
Unicode::Baba   # => error: NameError

Въпроси дотук?

Ще продължим с концептуален пример.

Пример

Пишем приложение за киномани
Пазим информацията в релационна база
Имаме таблици за филми, за актьори и прочее
Искаме да имаме класове, които да отговарят на обектите от предметната ни област - филм, актьор, ...
Всеки такъв клас ще предоставя възможност за работа с един конкретен запис, или с колекция от такива

Примерът с филмите

някаква абстракция

class Entity
  attr_reader :table, :id

  def initialize(table, id)
    @table = table
    @id    = id
    DB.connection.execute "INSERT INTO #{@table} (id) VALUES (#{@id})"
  end

  def set(col, val)
    escaped = DB.connection.escape(val)
    DB.connection.execute "UPDATE #{@table} SET #{col}='#{escaped}' WHERE id=#{@id}"
  end

  def get(col)
    DB.connection.fetch_value "SELECT #{col} FROM #{@table} WHERE id=#{@id}"
  end
end

Примерът с филмите

class Movie < Entity
  def initialize(id)
    super("movies", id)
  end

  def title
    get("title")
  end

  def title=(value)
    set("title", value)
  end

  def director
    get("director")
  end

  def director=(value)
    set("director", value)
  end
end

DRY

Представете си да трябва да правите това за всеки клас и всяко негово поле (атрибут). Ще има повторение на концепции:

Има таблица movies с колона title и клас Movie с поле @title
Стринговият литерал "title" се повтаря
Двойката title() и title=() някак повтаря двойката director() и director=()
Низът "movies" изглежда повтаря, че класът се казва Movie

Примерът с филмите

С малко метапрограмиране би могло да изглежда така:

class Movie < ApplicationRecord
end

activerecord е съществуваща библиотека, част от Ruby on Rails
ORM (object-relational mapper)
Стъпва на конвенции ("класът Movie моделира таблица movies, идентификаторът се пази в колона id)
Създава динамично getter-и и setter-и за всяка колона в базата
Това са 3% от нещата, които прави

Метапрограмиране

подобрена дефиниция

Метапрограмирането е писането на код, с който се управляват конструкциите на езика по време на изпълнение

Метапрограмирането и ние

...или къде се намираме в този голям, страшен свят

Ще си говорим за различни похвати, с които това става
За да разберем похватите, трябва да си говорим за някои детайли в Ruby
Първият такъв е ОО моделът на Ruby

Класове и инстанции

разделение на ролите

Доста просто:

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

Класове и инстанции

прост пример

class MyClass
  def my_method
    @v = 1
  end
end

obj = MyClass.new
obj.my_method

# but_what_is?(obj)

Класове и инстанции

Инстанционни променливи

припомняме

Пазят се в нещо като таблица (речник) за всеки клас:

class MyClass
  def initialize
    @a = 1
    @b = 2
  end
end

MyClass.new.instance_variables # => [:@a, :@b]

Класове

Всеки клас дефинира методи
Тези методи са достъпни на инстанциите му
Отделно, класът е обект...
...и има собствени методи
Има разлика между методите на обекта клас и методите на неговите инстанции

Класове и инстанции

припомняме

Можете да вземете класа на всеки обект с Object#class.

"abc".class              # => String
"abc".class.class        # => Class
"abc".class.class.class  # => Class

Класове

методи

String.instance_methods == "abc".methods # => true
String.methods          == "abc".methods # => false

"abc".length     # => 3
String.length    # => error: NoMethodError

String.ancestors # => [String, Comparable, Object, Kernel, BasicObject]
"abc".ancestors  # => error: NoMethodError

Клас и суперклас

припомняме

Можете да вземете родителския клас с Object#superclass.

class A; end
class B < A; end
class C < B; end

C.superclass                       # => B
C.superclass.superclass            # => A
C.superclass.superclass.superclass # => Object

Класове

и модули

Казахме, че инстанциите пазят полета, пък класовете - методи
Е, модулите също пазят методи
Всъщност, Class е наследник на Module
Още Class.superclass == Module
Още известно като Class < Module
Спомнете си ancestor chain-а. Всичко в него е kind_of?(Module)
В Ruby, данните се пазят в обекти, а кодът - в модули

Проста визуализация

По-сложна визуализация

Конвенцията Module#foo за клас-макроси

Предните две диаграми дават обяснение защо ползваме конвенцията Module#foo за клас-макроси
Например, методите private, protected, attr_accessor, include, extend и т.н.
Все инстанционни методи, идващи от Module или Class
Съответно, всички обекти (инстанции) на Module и Class имат достъп до тези методи

Въпроси дотук?

Продължаваме с BasicObject и *_eval методи.

BasicObject

истинският Object

BasicObject идва в Ruby 1.9 и е много опростена версия на Object.

Подходящ е за method_missing магарии

Object.instance_methods.count      # => 56
BasicObject.instance_methods.count # => 8

m = BasicObject.instance_methods.join(', ')
m # => "!, ==, !=, __send__, equal?, instance_eval, instance_exec, __id__"

Което ни навежда на следващия въпрос - instance_eval

Object#instance_eval

прочетете този слайд много внимателно, три пъти

Всеки Ruby израз има някакъв неявен self
Този self се ползва за полета (@foo) и търсене на методи (bar()).
Може да го наричаме "текущ обект"
instance_eval променя self в рамките на един блок

Object#instance_eval

пример

class Person
  private
  def greeting() "I am #{@name}" end
end

mityo = Person.new
mityo.instance_eval do
  @name = 'Mityo'

  greeting # => "I am Mityo"
  self     # => #<Person:0x002b2fdae42b88 @name="Mityo">
end

self       # => main

mityo.instance_variable_get :@name # => "Mityo"

Object#instance_exec

instance_exec е като instance_eval, но позволява да давате параметри на блока.

obj = Object.new
set = ->(value) { @x = value }

obj.instance_exec(42, &set)

obj.instance_variable_get :@x  # => 42
obj.instance_eval { @x }       # => 42

Това е смислено, когато имате блока като обект предварително. Иначе няма нужда.