• Module#extend
• Интроспекция в Ruby - прелюдия към метапрограмирането
• Наченки на метапрограмиране
• Класът Method
• Записки по трета задача

• 17 ноември – Интроспекция и метапрограмиране, част 2
• 19 ноември – Интроспекция и метапрограмиране, част 3
• 24 ноември – Регулярни изрази
• 26 ноември – Git
• 3 декември – първи тест
• Web с Ruby, Sinatra, Ruby core & stdlib, конкурентност
• GUI, UI, Gosu, Shoes и каквото друго ви е интересно

• Ново, пето предизвикателство днес
• След лекцията отиваме в Торонто
• Новинарски бюлетин за предложения за работа с Ruby →
• Помощник-инструктори за седмични учебни групи, случващи се в init Lab

• Ще бъде тази неделя, 16 ноември
• Срещата ни е на последната спирка на трамвай №5 в Княжево, 10:00 сутринта
• Има новина, тема във форума с още детайли и събитие във Facebook
• Трябва да знаем кой ще идва, отбележете се във Facebook или форума, когато разберете
• Отбележете се само на едно място

• RubyMonk е колекция от интерактивни уроци за Ruby
• Минете поне първия урок
• Ще ви е полезно за затвърждаване на знанията

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

.../irb/ruby-lex.rb:232:in `catch'
.../irb/ruby-lex.rb:232:in `each_top_level_statement'
.../irb.rb:488:in `eval_input'
.../irb.rb:397:in `block in start'
.../irb.rb:396:in `catch'
.../irb.rb:396:in `start'
.../bin/irb:11:in `<main>'

Кои изключения обикновено е добра идея да хващаме и кои не?

За какво служат throw и catch в Ruby?

Какво правеше клас-макрото include?

module Bar
  def public_method() end
  private
  def private_method() end
end

class Foo
  include Bar
end

Помните Module#include, нали?

module Introductions
  def ahoy() "Ahoy my mate, I'm #{name}!" end
  def hi()   "Hey there, I'm #{name}!" end
end

class Person
  include Introductions
  attr_accessor :name

  def initialize(name) @name = name end
end

Person.new('Silver').ahoy # "Ahoy my mate, I'm Silver!"
Person.new('Silver').hi   # "Hey there, I'm Silver!"

Module#extend добавя методите на дадения модул като класови методи:

module Introductions
  def ahoy() "Ahoy my mate, I'm #{name}!" end
  def hi()   "Hey there, I'm #{name}!" end
end

class Person
  extend Introductions
end

Person.ahoy # "Ahoy my mate, I'm Person!"
Person.hi   # "Hey there, I'm Person!"

Аналогично на include, може да ползвате extend и в модули:

module Person
  extend Creation
  extend Traversing
  extend Reflection
end

Може дори да include-нете и да extend-нете с един и същи модул:

class Person
  include Introductions
  extend Introductions
end

Person.new('Why').hi # "Hey there, I'm Why!"
Person.hi            # "Hey there, I'm Person!"

Долното работи и се ползва понякога:

module UrlHelpers
  extend self

  def encode(url)
  end

  def decode(url)
  end
end

UrlHelpers.encode('foo bar')
UrlHelpers.decode('foo%20bar')

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

• Начин програмно да инспектирате свойства на код
• Още: рефлекция (reflection)
• Необходимост, за да може да се метапрограмира на даден език

• Внимание: употребяват се много внимателно и предимно в специфични случаи
• Ако мислите, че имате нужда да ползвате нещо от това, коeто ще ви покажем, помислете пак
• Възможно е да има друг, много по-чист и елегантен начин да решите поставения проблем
• Третирайте тези неща като code smell и прибягвайте до тях само в краен случай

• Най-простата форма на интроспекция
• Много от тези методи вече сте виждали в действие, или поне сте чували за тях:
• class ви дава класа на даден обект; всеки обект има клас, дори класовете
• superclass - родителският клас
• kind_of? (със синоним is_a?)
• instance_of?
• ancestors - списъкът от класове и модули, в който се търси метод при извикване на такъв

• methods - списък с методите, на които отговаря дадена инстанция
• Забележете, че foo.methods != foo.class.methods
• Горното е следствие на факта, че и класовете са инстанции и си имат собствени методи
• Например:

'foo'.methods.size  # 165
String.methods.size # 101

• Може да видите какви методи дефинира даден клас за своите инстанции
• Следните имена са очевидни:
• private_instance_methods
• protected_instance_methods
• public_instance_methods
• singleton_methods ви връща класовите методи

• Културната проверка дали даден обект има определен метод:
• object.respond_to?(:method_name)
• Ще върне true, ако можете безопасно да изпълните object.method_name
• Тук е подходящо да подадете символ като :method_name
• Връща false за private и protected методи
• Ако му подадете true като втори аргумент, ще игнорира видимостта на метода

• Можете да инспектирате и манипулирате инстанционни променливи на обекти с тези методи:
• instance_variables
• instance_variable_get
• instance_variable_set
• instance_variable_defined?
• remove_instance_variable - този метод е private
• Забележете, че трябва да включите и @ в името на променливата

• Имената на класове и модули са константи
• Константи могат да бъдат дефинирани в класове и модули
• Top-level константите отиват в Object
• Съществуват методи за интроспекция и манипулирание на константи

• Методите за интроспекция на константи идват от Module (Class < Module)
• constants връща списък с константите, дефинирани в дадения клас/модул
• const_get ви връща стойността на дадена константа от име, подадено като низ или символ
• Object.const_get('String').new е интересен начин да запишете ''
• const_set ви дава възможност да създадете (или промените) константа в класа/модула
• const_defined? - проверка дали дадена константа съществува в класа/модула
• remove_const - премахва константа от клас/модул

Regexp.constants          # [:IGNORECASE, :EXTENDED, :MULTILINE, :FIXEDENCODING, :NOENCODING]
Object.constants.take(5)  # [:Object, :Module, :Class, :BasicObject, :Kernel]
Object.constants.size     # 145

• Object.constants е списък на всички top-level константи, дефинирани към момента

Kernel#global_variables ще ви върне списък с всички глобални променливи,
дефинирани към момента. Например:

puts global_variables.map { |var| var.to_s.ljust(16) }
                     .each_slice(4)
                     .map { |vars_per_line| vars_per_line.join(' ') }
                     .join("\n")

$;               $-F              $@               $!
$SAFE            $~               $&               $`
$'               $+               $=               $KCODE
$-K              $,               $/               $-0
$\               $_               $stdin           $stdout
$stderr          $>               $<               $.
$FILENAME        $-i              $*               $?
$$               $:               $-I              $LOAD_PATH
$"               $LOADED_FEATURES $VERBOSE         $-v
$-w              $-W              $DEBUG           $-d
$0               $PROGRAM_NAME    $-p              $-l
$-a              $binding         $1               $2
$3               $4               $5               $6
$7               $8               $9

• Подобно на Kernel#global_variables, има метод Kernel#local_variables
• Връща списък с локалните променливи, регистрирани към момента в текущия scope

foo          = :bar
die_antwoord = 42

local_variables # [:foo, :die_antwoord, :_xmp_1421262103_16916_232677]

• Ключова дума, за разлика от всички методи, показани до момента
• "Аргументът", който приема, е произволен Ruby израз
• Работи на ниво parser (синтаксис)
• Връща ви низ, описващ типа на израза, който сте подали на defined?
• Ако подадете несъществуващо име (напр. недефинирана локална променлива), ще получите nil
• Така може да проверите дали дадена локална променлива съществува

• Примерна употреба - задаване на стойност по подразбиране на локална променлива
• Идиоматично е следното: foo ||= default_value
• Ще работи дори foo да не е била дефинирана към момента. Проблемът с този код?
• Ако foo е имала стойност false и това е валидно за вашия случай, ще я презапишете
• Ако попаднете в тази рядка ситуация, може да направите следното:

unless defined? cache
  cache = true
end

x = 42 unless defined? x
x # nil

• Защо?
• Постфиксната форма на условието води до дефиниране на всички имена, срещани на реда
• Т.е. преди още defined? да се изпълни, x ще се дефинира и ще има стойност nil

Можете да ползвате Kernel#block_given?, за да проверите дали
някой ви е подал блок, например:

def block_or_no_block
  if block_given?
    'We got a block, go this way...'
  else
    'No block man, go that way...'
  end
end

block_or_no_block     # "No block man, go that way..."
block_or_no_block {}  # "We got a block, go this way..."

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

Пример с Proc.new:

def foo
  Proc.new if block_given?
end

foo         # nil
foo {}      # #<Proc:0x426af0e4@-:6>

proc = foo { "hello" }
proc.call   # "hello"

• Класът ObjectSpace ви дава прост интерфейс за манипулация на обектите в паметта
• ObjectSpace.each_object ще yield-ва на подадения му блок всеки такъв обект
• Приема опционален аргумент - от какъв клас да бъде дадения обект
• ObjectSpace.each_object(String) ще обходи всички низове, заредени в паметта в момента
• ObjectSpace.each_object(Class) - всички класове
• Обхожда всичко без Fixnum, Symbol, true, false и nil, тъй като те се интернират
• Ако не му подадете блок, ще ви върне Enumerator

Дава проста статистика на бройките обекти в паметта по типове. Връща хеш. Например:

puts ObjectSpace.count_objects
      .map { |type, count| "#{type}:".ljust(10) + count.to_s.rjust(7) }
      .each_slice(3)
      .map { |counts_per_row| counts_per_row.join('    ') }
      .join("\n")

TOTAL:     419019    FREE:      289687    T_OBJECT:   12958
T_CLASS:      880    T_MODULE:      34    T_FLOAT:        8
T_STRING:   85708    T_REGEXP:     175    T_ARRAY:    21544
T_HASH:       707    T_STRUCT:       1    T_BIGNUM:       6
T_FILE:         7    T_DATA:      2188    T_MATCH:      643
T_COMPLEX:      1    T_NODE:      4436    T_ICLASS:      36

• Помните ли Object#object_id?
• ObjectSpace._id2ref е обратният му метод
• Пример:

id = 'larodi'.object_id   # 550842600
ObjectSpace._id2ref(id)   # "larodi"

• Невъзможно и ненужно
• Или?
• ObjectSpace.define_finalizer(object, proc)
• Вика proc когато object бъде garbage collect-нат
• Много подобно на деструктор...

• Позволява ви да вземете референция към метод на даден обект
• Връща обект от тип Method
• Ако такъв метод няма, хвърля изключение (NameError)
• Инстанциите на Method се държат като closure

class Person
  def name
    'Matz'
  end
end

Person.new.method(:name) # #<Method: Person#name>

• Интерфейсът му донякъде наподобява анонимни функции и proc-ове, с малко екстри
• call ще извика въпросния метод
• name ще ви даде името на метода
• owner - класът или модулът, откъдето е дошъл този метод
• receiver - обектът получател на този метод (инстанцията, обвързана с метода)
• arity връща колко аргумента приема метода (с врътки за променлив брой аргументи)
• parameters - детайлна информация за приеманите аргументи - имена, дали са задължителни и т.н.
• source_location - в кой файл и на кой ред е дефиниран този метод; много полезно
• unbind - "разкача" този метод от получателя му; връща ви инстанция на UnboundMethod (пример след няколко слайда)

• Подобно на call, и Proc-обектите имат метод arity със същото действие
• Това важи за анонимни функции, блокове и всякакви инстанции на Proc
• Например:

Proc.new { |x| }.arity      # 1
lambda { |x, y| }.arity     # 2

• Работи само за методи, дефинирани на Ruby
• Полезно при дебъг на непознат код (вкл. и такъв, идващ от gem-ове)
• Връща списък с два елемента - път до Ruby файл и ред в този файл

require 'set'
Set.new.method(:to_a).source_location # ["/Users/.../ruby-1.9.3/lib/ruby/1.9.1/set.rb", 144]

class Set; def to_a; super; end; end
Set.new.method(:to_a).source_location # ["-", 4]

• Инстанции на UnboundMethod
• Имат почти същите методи като oбвързаните (т.е. инстанциите на Method)
• Не могат да бъдат извиквани
• Mогат да бъдат обвързани впоследствие към други инстанции

Следва продължение...

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

• Не позволиха парсването да се напише само в един метод
• Това е добре - накара ви да помислите как да разделите логиката
• Не е достатъчно просто да заобиколим ограничението - то е там с конкретна цел

• Получихме сравнително малко въпроси
• Има хора, които не са написали parse
• Означава ли, че сте имали проблем, но не сте попитали?

Да си дефинираме нов клас Parser със следния публичен интерфейс:

• initialize(serialized_string)
• each - yield-ва последователност от файлове или директории
• Parser#each ще ползва и следните два private метода:
• read_next_record - чете от низа до първото срещане на : и го връща
• read_next_entity - чете един елемент от формата :

• Разделяйте си кода на възможно най-малки смислови части
• Задавайте (си) въпроси

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