• Класовете като обекти
• require
• Enumerator-и
• Code spelunking!

• Ще е на линия след края на лекцията
• Срокът ще е по-дълъг от обикновено, до понеделник, 10 ноември, 17:00

• OpenFest този уикенд (1-2 ноември)
• Програмата е много богата
• Има и light conferences/unconferences и уъркшопи
• Лекциите са интересни, но хората (публика и лектори) са още по-интересни
• Входът е свободен, мястото е Интерпред
• Може да идвате и да си тръгвате когато искате

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

class Something
  def name() 'baba' end
  alias relative name
  def name() 'dyado' end
end

p Something.new.relative

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

Каква е разликата между alias и alias_method?

class Something
  1.upto(5).each do |index|
    alias_method "to_s_#{index}", :to_s
  end
end

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

module Outer
  class String
    def the_answer() '42' end
  end

  module Inner
    String.new.the_answer
  end
end

В следния примерен код, по какви начини бихме могли да достъпим константата TREASURE от мястото, отбелязано с коментар?

module Deep
  module Down
    module Below
      TREASURE = 'Ya fools.'
    end
  end

  # =>
end

Down::Below::TREASURE
Deep::Down::Below::TREASURE
Object::Deep::Down::Below::TREASURE
::Deep::Down::Below::TREASURE
::Object::Deep::Down::Below::TREASURE

• Обмяна на опит
• Попълване на дупки в знанията
• Структуриране на мисълта
• Трениране на комуникационни умения
• Слава!
• Харесайте си тема, дори да не е пряко свързанa с Ruby и ни пишете

• Знаем, че всичко в Ruby е обект
• Класовете не правят изключение
• Можем да викаме методи на тях (напр. String.methods)
• Обектите тип "клас" си имат клас (String.class) и той е Class
• Тоест, са негови инстанции

Долното работи:

a_hash_class = Hash
a_hash_class.new # {}

• Можем да създаваме динамично обекти тип "клас" с Class.new
• Тези класове се наричат анонимни класове
• Абсолютно аналогично е за модули
• Module.new ще създаде инстанция на анонимен модул

anonymous_class = Class.new
anonymous_class.new # #<#<Class:0x424a7684>:0x424a7648>
Class.new.new       # #<#<Class:0x424a73f0>:0x424a73c8>
Module.new          # #<Module:0x424a7224>

Можем да подадем блок на Class.new:

duck = Class.new do
  def quack_to(creature_name)
    "Quack, #{creature_name}, quack!"
  end
end

duck.new.quack_to("swan") # "Quack, swan, quack!"

class Person
end

• С оглед на това, class е просто синтаксис, който прави обект от тип "клас"
• Припомняме за scope gate-овете – class е scope gate, докато блоковете не са
• Освен да създаде обект, class го присвоява и на константа
• Тоест, примерът по-горе може да се разглежда като присвояване на константа
• А "имената" на класове са просто константи, сочещи към някакъв обект

Когато присвоим анонимен клас на константа, попадаме в специален случай:

Person = Class.new

Class.new           # #<Class:0x42702a8c>
Person = Class.new  # Person

Module.new          # #<Module:0x42702690>
Larodi = Module.new # Larodi

• Миналия път говорихме за root scope-а на константите
• Той е достъпен със синтаксиса ::
• Също така, той се намира в Object
• Тоест, Object::FOO и ::FOO в (почти) всички случаи са едно и също
• Кога може да не са?
• ::Object::FOO и ::FOO са едно и също винаги

• Защо си говорим всичко това?
• Защото механизмът за търсене на константи не се интересува накъде сочат те
• Влагането на константи работи по един и същи начин винаги

• Понякога познаването на вътрешната имплементация помага за разбирането
• Всяка константа-клас или модул си има хеш-таблица с вложените непосредствено в нея константи
• Root scope-ът се пази в константата Object
• Така работи влагането и така работи constant resolution-ът

Можете да видите тази "таблица" през constants:

module MyLibrary
  class Object
  end
end

MyLibrary.constants         # [:Object]
MyLibrary::Object == Object # false

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

#!/bin/sh

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

Да кажем, че имаме следния код:

CURRENCY_NAMES = {
  BGN: 'Bulgarian lev',
  EUR: 'Euro',
  USD: 'United States dollar',
  CHF: 'Swiss frank',
}.freeze

[:BGN, :CHF, :EUR].map { |currency_code| CURRENCY_NAMES[currency_code] }
# => ["Bulgarian lev", "Swiss frank", "Euro"]

Нека предположим, че имаме следната имплементация на Hash#to_proc:

class Hash
  def to_proc
    proc { |key| self[key] }
  end
end

• По идея на (1) и (2)

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

CURRENCY_NAMES = {
  BGN: 'Bulgarian lev',
  EUR: 'Euro',
  USD: 'United States dollar',
  CHF: 'Swiss frank',
}.freeze

[:BGN, :CHF, :EUR].map &CURRENCY_NAMES
# => ["Bulgarian lev", "Swiss frank", "Euro"]

Удобни изглеждат и следните хипотетични употреби:

VALID_CURRENCIES = {
  BGN: true,
  EUR: true,
  USD: true,
  CHF: true,
}.freeze

valid_currencies = [:BGN, :CHF, :EUR].select(&VALID_CURRENCIES)

# Or:
if currencies.any? &VALID_CURRENCIES
end

# Or:
words.reject(&FORBIDDEN_WORDS)

class Foo::Bar
  # In the Bar scope, but not in the Foo scope
end

• Съществува понятието "текущ scope"
• Той се гледа, ако използвате "релативен" път до дадена константа
• Сменя се с ключовите думи class и module

В този пример:

class Foo::Bar
  Larodi
end

• Създаваме константа (клас) Bar и я записваме в таблицата с константи на Foo
• Foo трябва да съществува предварително; може да бъде или модул, или клас
• Константата Larodi ще се търси в таблицата на Bar и след това в root scope-а
• Няма да се търси в таблицата на Foo

module A::B
  module C::D
    Foo # Where does Ruby look for Foo?
  end
end

1. В таблицата на D
2. В таблицата на B
3. В root scope-а (т.е. в таблицата на Object)

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

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

В Ruby има "switch". Казва се case.

def quote(name)
  case name
    when 'Yoda'
      puts 'Do or do not. There is no try.'
    when 'Darth Vader'
      puts 'The Force is strong with this one.'
    when 'R2-D2'
      puts 'Beep. Beep. Beep.'
    else
      puts 'Dunno what to say'
  end
end

• Няма fall-through. Не се пише break
• Ако нито един when не мине, изпълнява се else
• Ако нито един when не мине, и няма else, не става нищо
• case е израз, което значи, че връща стойност

На какво ще се оцени следният код?

case 'Wat?'
  when 'watnot' then puts "I'm on a horse."
end

case не сравнява с ==. Може да напишете следното:

def qualify(age)
  case age
    when 0..12
      'still very young'
    when 13..19
      'a teenager! oh no!'
    when 33
      'the age of jesus'
    when 90..200
      'wow. that is old!'
    else
      'not very interesting'
    end
end

case сравнява с ===. Няколко класа го имплементират:

• Range
• Regexp
• Class
• Списъкът не е изчерпателен...
• По подразбиране се оценява като ==

Ruby позволява да обедините проверката за няколко възможни стойности в един when, дори да не са от един и същи тип.

case number
  when (42+0i)  then 'This is too complex for me!'
  when 42, 42.0 then 'This is more like it!'
end

• Можете да слагате и цели изрази в when
• Изпуска се параметърът след case, например:

thing = 42
case
  when thing == 1 then 1
  else 'no_idea'
end

• Не го правете.
• Ако ви се налага, ползвайте обикновени if-ове

Сега е моментът.

В Ruby, код от други файлове се импортира с require.

require 'bigdecimal'
require 'bigdecimal/util'

• require 'foo' търси файл foo.rb в "пътя за зареждане"
• Още известен като load path
• Той съдържа няколко "системни" пътища, плюс пътища от gem-ове, които сте си инсталирали
• Очевидно, require 'foo/bar' търси директория foo с файл bar.rb
• Разширението .rb отзад не е задължително да присъства
• require './foo' търси foo.rb в текущата директория
• Разбира се, абсолютни пътища също работят: require '/home/skanev/foo.rb'

• Обикновено във вашия load path текущата директория не присъства
• Някои хора се осмеляват да си я добавят, променяйки load path
• Адът се отваря и ги поглъща
• Ползвайте релативен път, т.е. require './foo'

• Алтернатива на горното е require_relative
• require_relative 'foo' зарежда 'foo' спрямо директорията на изпълняващия се файл
• require './foo' зарежда спрямо текущата директория на изпълняващия процес

• Достъпен е като $LOAD_PATH
• Още $:
• Може да го променяте. Стандартно с $:.unshift(path)
• Не е много добра практика да го правите

• Изпълнява файла
• Константите, класове, глобални променливи и прочее са достъпни отвън
• Няма абстракция. Все едно сте inline-нали файла на мястото на require-а. Почти
• Файлът е изпълнен с друг binding. Демек, локалните му променливи са изолирани. Но само те
• Не, че има значение, но main обектът е същият
• Файлът се изпълнява само веднъж. Повторни require-и не правят нищо
• Последното може да се излъже по няколко начина
• require може да зарежда .so и .dll файлове

• Знаете, че се наричат gem-ове
• Де-факто стандартна репозитория за библиотеки е RubyGems
• Един gem е просто zip-ната папка с файлове
• Инсталация на gem представлява сваляне на този zip и разархивирането му някъде
• Това "някъде" е папка на вашия компютър, намираща се в $LOAD_PATH

Следващия път ще продължим с разглеждане структурата на един gem и ще пробваме да се спуснем в пещерата на skeptic. Ще демонстрираме основни пещернячески умения.

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