• Enumerable (преговор)
• Наследяване
• Ancestor chain
• Синоними на методи
• Класови методи

Кой (и как) може да вика private методи?

class Something
  private

  def foo
  end
end

Какви са конвенциите за имена на методи, променливи, константи и имена на класове?

На какво могат да завършват методите в Ruby?

Как можем да направим наш клас-колекция, която да има всички методи на Enumerable?

Избройте поне две разлики в поведението на lambda и Proc.new.

• Много, много основен модул в Ruby
• Array, Hash, Range, Set и други са все Enumerable
• В комбинация с блокове се получава много приятен код
• Ще припомним някои полезни и често използвани методи

#all?/#any? връщат истина, ако всички/един елемент(и) от колекцията отговарят на някакво условие.

[1, 2, 3, 4].all? { |x| x.even? } # => false
[1, 2, 3, 4].any? { |x| x.even? } # => true

[2, 4, 6, 8].all? { |x| x.even? } # => true
[2, 4, 6, 8].any? { |x| x.odd? }  # => false

# И разбира се:
[1, 2, 3, 4].any?(&:even?)        # => true

#all? и #any? могат да работят и без блок:

[1, 2, 3, nil].all?     # => false
[1, 2, 3, :nil].all?    # => true
[1, 2, 3, false].any?   # => true

Аналогични на #all? и #any?. Също могат да работят без блок.

%w(foo bar larodi).one? { |word| word.length == 6 }  # => true
%w(foo bar larodi).one? { |word| word.length == 3 }  # => false

[1, 5, 3].none? { |number| number.even? }   # => true
[1, 2, 3].none? { |number| number.even? }   # => false

[1, 2, 3].one?     # => false
[1, nil, nil].one? # => true

#each_with_index yield-ва всеки елемент с индекса му в масива:

%w[foo bar baz].each_with_index do |word, index|
  puts "#{index}. #{word}"
end

Горното извежда:

0. foo
1. bar
2. baz 

Няма #map_with_index.

Затова пък има нещо по-общо:

%w[foo bar baz].map.with_index do |word, index|
  [index, word]
end

# => [[0, "foo"], [1, "bar"], [2, "baz"]]

Името казва всичко, което ви е нужно да знаете.

words  = %w(foo bar plugh larodi)
groups = words.group_by { |word| word.length }

groups # => {3=>["foo", "bar"], 5=>["plugh"], 6=>["larodi"]}

#each_slice(n) yield-ва елементите на части по n:

%w(a b c d e f g h).each_slice(3) do |slice|
  p slice
end

Извежда

["a", "b", "c"]
["d", "e", "f"]
["g", "h"] 

#each_cons(n) yield "подмасиви" с n елемента:

[1, 2, 3, 4, 5].each_cons(3) do |cons|
  p cons
end

Извежда

[1, 2, 3]
[2, 3, 4]
[3, 4, 5] 

Вече знаете какво прави:

[1, 2, 3, 4].include? 3   # => true
[1, 2, 3, 4].member? 5    # => false

Двете са синоними.

all?        any?          chunk       collect          collect_concat
count       cycle         detect      drop             drop_while
each_cons   each_entry    each_slice  each_with_index  each_with_object
entries     find          find_all    find_index       first
flat_map    grep          group_by    include?         inject
lazy        map           max         max_by           member?
min         min_by        minmax      minmax_by        none?
one?        partition     reduce      reject           reverse_each
select      slice_before  sort        sort_by          take
take_while  to_a          zip 

Enumerable.instance_methods.
  sort.
  map { |name| name.to_s.ljust(16) }.
  each_slice(5) { |row| puts row.join '' }

Disclaimer: Леко е редактиран whitespace-а, за да се събере в слайд.

След това ще продължим с наследяване.

Наследяването в Ruby става така:

class Person
  def name() 'The Doctor' end
end

class PolitePerson < Person
  def introduction
    "Hi, I am #{name}"
  end
end

PolitePerson.new.introduction # => "Hi, I am The Doctor"

• Може да наследите най-много от един родител
• В наследника имате достъп до всички методи
• В наследника имате достъп до всички полета
• Ако не определите родител, класът наследява от Object
• Всеки клас в Ruby наследява от Object (с изключение на родителя на Object...)

Имате достъп до private методите:

class Person
  private
  def name() 'The Doctor' end
end

class PolitePerson < Person
  def introduction() "Hi, I am #{name}" end
end

PolitePerson.new.introduction # => "Hi, I am The Doctor"

#is_a? има синоним #kind_of?

class Base; end
class SpaceStation < Base; end

base    = Base.new
station = SpaceStation.new

base.kind_of? Base            # => true
station.kind_of? SpaceStation # => true
station.kind_of? Base         # => true

• Ползвайте #is_a? по принцип.
• Ползвайте #instance_of? само когато искате да не бъде наследник.
• Гледайте да не ги ползвате въобще — duck typing

Може да предефинирате метод и да извикате версията на родителя със super.

class Person
  def introduction_to(other)
    "Hello #{other}."
  end
end

class PolitePerson < Person
  def introduction_to(other)
    super("Mr. #{other}") + " How do you do?"
  end
end

queen = PolitePerson.new
queen.introduction_to('Smith') # => "Hello Mr. Smith. How do you do?"

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

class Person
  def introduction_to(other)
    "Hello #{other}."
  end
end

class PolitePerson < Person
  def introduction_to(other)
    super + " How do you do?"
  end
end

queen = PolitePerson.new
queen.introduction_to('Smith') # => "Hello Smith. How do you do?"

super и super() са различни:

class Person
  def introduction_to(other)
    "Hello #{other}."
  end
end

class PolitePerson < Person
  def introduction_to(other)
    super() + " How do you do?"
  end
end

queen = PolitePerson.new
queen.introduction_to('Smith') # => error: ArgumentError

• Методи могат да се дефинират само в класове и модули
• Всеки клас има родител и миксирани модули
• Ако един метод не се намери в класа, той се търси в миксираните модули
• Модулите се претърсват обратно на реда, в който са include-нати
• Ако не се намери в тях, се търси в родителя
• Ако го няма там, се търси в неговите модули и после в неговия родител
• Рекурсия, брат
• Този списък от модули и класове, в които се търси, се нарича ancestor chain

Има само една версия на метода:

module Talking
  def greeting() "Hello, #{name}" end
end

class Base
  include Talking
  def name()        'Base'   end
  def say_hi_base() greeting end
end

class Derived < Base
  include Talking
  def name()           'Derived' end
  def say_hi_derived() greeting  end
end

derived = Derived.new
derived.say_hi_base    # => "Hello, Derived"
derived.say_hi_derived # => "Hello, Derived"
derived.ancestors      # => # ~> -:20:in `<main>': undefined method `ancestors' for #<Derived:0x002b152b3da2f0> (NoMethodError)

• Можете да дефинирате синоними на методи в 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_inject inject

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

[1, 2, 3, 4, 5, 6].inject { |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 обикновено не се разпознава в тези случаи, понеже не може да ползвате статичен синтактичен анализ за целта

Интересен gem:

• Помага ви да търсите методи
• MethodFinder.find('abc', 'ABC')
• %w[a b c].find_method { |a| a.unknown(1) ; a == %w[a c] }
• Внимавайте, вика всички методи
• github.com/citizen428/methodfinder

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

• Очевидно, не е съвсем така – Object не наследява от Object
• Родителят му е BasicObject
• Родителят на BasicObject е nil
• 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

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