• Синоними на методи
• Именовани пространства
• Класови методи
• Паралелно присвояване

• OpenFest този уикенд (5/6 ноември)
• Програмата е много богата
• Лекциите са интересни, но хората (публика и лектори) са още по-интересни
• Входът е свободен, Зала "България"
• Може да идвате и да си тръгвате когато искате

• Ще я пуснем днес
• Срок до сряда, 17:30 - за да отидете на OpenFest
• Цел – да упражните класове

Какво ще има в ancestors chain-a?

module Foo; end
module Bar; end
module Baz; end

module Qux
  include Foo
  include Bar
end

class Garply
  include Foo
  include Qux
end

class Waldo < Garply
  include Foo
  include Baz
  include Bar
end

Waldo.ancestors # =>

"Всичко наследява от Object"

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

• Очевидно, не е съвсем така – Object не наследява от Object
• Родителят му е BasicObject
• Родителят на BasicObject е nil
• BasicObject е минималистичен клас, подходящ за проксита

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

• Kernel е миксиран в Object
• "Глобалните методи" са дефинирани в Kernel (#puts, #eval и т.н.)
• Общите методи за всички инстанции са в Object (#inspect, #tap, #methods и т.н.)
• Ако дефинирате методи извън модул или клас, той отива като private метод на Object
• Всеки път като правите това, котенце някъде умира

Само обекти от същия клас могат да викат protected методи

class Vector
  def initialize(x, y) @x, @y = x, y          end
  def inspect()        "Vector.new(#@x, #@y)" end

  def +(other)
    Vector.new(*coords.zip(other.coords).map { |a, b| a + b })
  end

  protected
  def coords() [@x, @y] end
end

vector = Vector.new(1, 2) + Vector.new(3, 4)
vector        # => Vector.new(4, 6)
vector.coords # => error: NoMethodError

• private се ползва постоянно
• protected почти никога
• Има school of thought, който предпочита protected, защото могат да се викат със self. отпред
• Ние не сме от тази клика
• Има и public. Не го ползваме, а просто слагаме публичните методи отгоре
• Впрочем, не са ключови думи, а методи на Module и Class

Понеже private и protected са методи:

class Person
  def name() end
  def age()  end

  private :name, :age
end

Или дори:

class String
  private :upcase!, :downcase!
end

"Foo".upcase! # => error: NoMethodError

Помните ли, че дефиницията на метод връща името на метод като символ?

def foo() end # :foo

Значи може да направите така:

class Person
  private def name
    "My name is a secret."
  end

  private def age
    "I'm feeling feminine, so my age is a secret, too."
  end
end

• Можете да дефинирате синоними на методи в Ruby, посредством:
• Ключовата дума alias
• Метода Module#alias_method (клас макро)
• И двете правят достъпно копие на тялото на даден метод под друго име
• Използват се много във вградените в Ruby-методи, например String#size и String#length

• С ключовата дума alias: alias :new_method :old_method
• Или: alias new_method old_method (забележете, че това не са символи или низове, a идентификатори)
• С метода от стандартната библиотека Module#alias_method:
• alias_method :new_method, :old_method
• Или: alias_method 'new_method', 'old_method'

• Alias-ите не са обикновени синоними, symlink-ове, указатели и прочее
• Това, което се случва при "alias"-ване на методи, е приблизително еквивалентно на копиране на тялото на оригиналния метод
• Ако модифицирате тялото на оригиналния метод след като сте го "alias"-нали, alias-ът ще запази старото тяло

Въпреки името си, alias прави копие на метод.

class Array
  alias old_reduce reduce

  def reduce(*args, &block)
    puts "I see you are using #reduce. Let me help!"
    old_reduce(*args, &block) * 0.01
  end
end

[1, 2, 3, 4, 5, 6].reduce { |a, b| a + b } # => 0.21

Пример за реална употреба:

def to_s
  to_html
end

alias_method :to_s, :to_html

alias to_s to_html

• На първо място, alias е ключова дума, докато alias_method е обикновен метод от Module (клас макро)
• От горното следват и повечето разлики между двете:
• При alias може да подавате като аргументи направо идентификатори на методи, например:
• alias original_to_s to_s ще направи нов синоним на to_s под името original_to_s
• alias_method original_to_s, to_s ще интерпретира original_to_s и to_s като имена на променливи
• Зад тези имена трябва да стои низ или символ, указващ име на метод
• По този начин може да правите синоними на методи динамично, докато с alias това не става

• Някои инструменти, които генерират документация от вашия код, имат проблеми с тази техника
• Тъй като alias е ключова дума и подлежи на статичен синтактичен анализ, такива инструменти разпознават тези синоними
• За разлика от това, Module#alias_method обикновено не се разпознава в тези случаи, понеже не може да ползвате статичен синтактичен анализ за целта

Класовете и модулите могат да служат като именувани пространства.

module Useless
  class Thing
  end
end

class Grandfather
  class StraightRazor
  end
end

Useless::Thing.new             # => #<Useless::Thing:0x002b3e0ec017b0>
Grandfather::StraightRazor.new # => #<Grandfather::StraightRazor:0x002b3e0ec01328>

Ако се намирате в модул, няма нужда да ползвате пълния път до константите:

module Useless
  class Thing
  end

  Thing.new         # => #<Useless::Thing:0x002b563b230958>
end

Useless::Thing.new  # => #<Useless::Thing:0x002b563b2304f8>
Thing.new           # => error: NameError

• Променливите в Ruby се търсят лексикално, докато не се стигне до "scope gate".
• Scope gate-ове в Ruby са def, module и class
• Важи и за полета (@foo)

bacon = 2

def foo
  chunky = 10

  1.times do
    chunky       # 10
    chunky = 44
  end

  chunky         # 44
  bacon          # error: NameError
end

foo()

• Константите и променливите в Ruby се търсят по различен начин
• Константите са организирани в дървовидна структура
• Всеки ред код се намира някъде в тази дървовидна структура
• Когато напишете константа, тя се търси първо в текущия клон, след което в родителите
• module и class ви местят из дървото на константите
• Може да достъпите константа в "корена" с :: отпред (::Foo)
• "Коренът" на константите са тези, дефинирани в Object

Може да дефинирате класови методи така:

class Something
  def Something.answer
    42
  end
end

Something.answer   # => 42

Не може да ги викате неквалифицирано от инстанцията:

class Something
  def Something.answer
    42
  end

  def do_stuff
    answer             # => error: NameError
    Something.answer   # => 42
  end
end

thing = Something.new
thing.answer           # => error: NoMethodError
Something.answer       # => 42

thing.do_stuff

Достъпни са в наследниците:

class Base
  def Base.answer() 42 end
end

class Derived < Base
  def Derived.say_answer
    answer         # => 42
    Base.answer    # => 42
  end
end

Derived.answer     # => 42
Base.answer        # => 42

Derived.say_answer

Има и други начини за дефиниция на класови методи:

• Този начин, който ви показахме, е неканоничният
• Кои са другите начини, ще разберете в следващите лекции

• Показахме ви как се дефинират и викат
• Не ви показахме как са реализирани и къде стоят
• Имат доста оплетена семантика в Ruby
• Засега се опитвайте да не ползвате класови методи

• answer = 42
• Тривиално, нали?
• Всяко присвояване е израз и има върната стойност
• Може да правите "паралелно присвояване"

a, b = 1, 2
a              # => 1
b              # => 2

a, b = b, a
a              # => 2
b              # => 1

Има няколко различни случая, които ще разгледаме.

a = 1, 2, 3
a # => [1, 2, 3]

Практически същото като a = [1, 2, 3]

a, b = [1, 2, 3]
a # => 1
b # => 2

a, b = 1, 2, 3
a # => 1
b # => 2

• Излишните аргументи вдясно се игнорират
• Скобите са "опционални" в този случай
• Ако вляво имате повече променливи отколкото вдясно, те ще получат стойност nil

head, *tail = [1, 2, 3]
head   # => 1
tail   # => [2, 3]

first, *middle, last = 1, 2, 3, 4
first  # => 1
middle # => [2, 3]
last   # => 4

• middle и tail обират всичко останало
• Очевидно, може да имате само една splat-променлива на присвояване

head, (title, body) = [1, [2, 3]]
head   # => 1
title  # => 2
body   # => 3

• Скобите ви позволяват да влезете едно ниво "навътре" и да разбиете подаден списък на променливи
• Не сте ограничени само до две нива (това работи: head, (title, (body,)) = [1, [2, [3]]])
• Можете да ги комбинирате с паралелното присвояване, за да правите сложни магарии

head, (title, *sentences) = 1, [2, 3, 4, 5, 6]
head      # => 1
title     # => 2
sentences # => [3, 4, 5, 6]

• Може да имате по една звездичка на "ниво" (т.е. скоби)

Бележка за реда на оценка при присвояване — първо отдясно, след това отляво:

x = 0
a, b, c = x, (x += 1), (x += 1)
x # => 2
a # => 0
b # => 1
c # => 2

• Носи семантика на placeholder ("този аргумент не ми трябва")
• Освен тази семантика, в Ruby е и малко по-специална

Може да ползвате едно име само един път, когато то се среща в списък с параметри на метод, блок и прочее.

Proc.new { |a, b, a| } # SyntaxError: duplicated argument name
Proc.new { |_, b, _| } # => #<Proc:0x007f818af68de0@(irb):23>

Горното важи не само за блокове, но и за методи.

• Очевидно, при нормално присвояване
• Това включва и връщана стойност от метод, например success, message = execute(job)
• При разгъване на аргументи на блокове, например:

[[1, [2, 3]], [4, [5, 6]], [7, [8, 9]]].each do |a, (b, c)|
  puts "#{a}, #{b}, #{c}"
end
# 1, 2, 3
# 4, 5, 6
# 7, 8, 9

• Донякъде и при разгъване на аргументи на методи (бройката трябва да отговаря)
• Запомнете ги

Имате ли въпроси по тази тема?

Може да пуснете quine-а от предния слайд като го запазите във файл quine.rb и ползвате това скриптче:

#!/bin/sh

while true
do
  ruby quine.rb | tee quine_result
  mv quine_result quine.rb
  sleep 0.2
done

• Константите са наглед дребна част от езика, но всъщност дълбока
• За интересуващите се от Rails, там работите стават още по-сложни заради autoloading-а
• Повече по темата за константите и autoloading-а им в Rails може да видите в тази лекция:
• "Constant Autoloading in Rails" by Xavier Noria
• Ще продължим да разгледаме именованите пространства и таблиците с константите в следващата лекция

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