• Още за класове и константи
• case в Ruby
• require
• Структура на простички gem-ове
• Enumerator-и
• И други...

• Ще ви я пуснем до края на деня
• Проверете на обичайното място
• Ще има и тема във форумите
• Напомняме, че имате и пето предизвикателство

• OpenFest този уикенд
• Разгледайте програмата
• Входът е свободен
• Освен това...

• Знаем, че всичко в 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:0x41089738>:0x41089710>
Class.new.new       # #<#<Class:0x410894f4>:0x410894cc>
Module.new          # #<Module:0x41089300>

Можем да подадем блок на 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:0x421bcb7c>
Person = Class.new  # Person

Module.new          # #<Module:0x421bc71c>
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

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
• Списъкът не е изчерпателен...
• По подразбиране се оценява като ==

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

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

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

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

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

#!/bin/sh

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

В 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

.
├── README.rdoc
├── Rakefile
├── bin
│   └── skeptic
├── features
├── lib
│   ├── skeptic
│   │   ├── rules.rb
│   │   └── scope.rb
│   └── skeptic.rb
├── skeptic.gemspec
└── spec 

• lib/ обикновено съдържа foo.rb и lib/foo/
• foo.rb обикновено е единственото нещо в lib/
• Всичко останало е в lib/foo
• lib/ се добавя в load path
• Така вече може да правите require 'foo' или require 'foo/something'
• По този начин не замърсявате require областта
• RubyGems прави това "автомагично"

• Разгледайте github.com/skanev/skeptic за повече подробности
• После разгледайте някой друг gem
• После си поиграйте малко с require и $LOAD_PATH и вижте какво се случва
• Вижте ръководствата в RubyGems

• load е много сходен с require, но има няколко разлики
• Иска разширение на файл - load 'foo.rb'
• Повторни load-ове изпълняват файла
• load не може да зарежда .so/.dll библиотеки
• load има опционален параметър, с който може да обвие файла в анонимен модул
• Последното дава известна изолация

Имате ли въпроси по require, load, gem-ове в Ruby?

Някои методи на Enumerable могат да не вземат блок.

numbers = []
1.upto(5) { |x| numbers << x }

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

other = 1.upto(5)
other                 # #<Enumerator: 1:upto(5)>
other.to_a            # [1, 2, 3, 4, 5]

1.upto(5).map(&:succ) # [2, 3, 4, 5, 6]

Енумераторите могат да се държат като итератори.

numbers = 1.upto(3)

numbers.next   # 1
numbers.next   # 2
numbers.next   # 3
numbers.next   # error: StopIteration

loop прави безкраен цикъл. Спира на StopIteration.

numbers = 1.upto(3)

loop do
  puts numbers.next
end

Енумераторите имат някои интересни методи.

numbers = 1.upto(3)

numbers.with_index.to_a      # [[1, 0], [2, 1], [3, 2]]
numbers.with_object(:x).to_a # [[1, :x], [2, :x], [3, :x]]

Може да извадите енумератор от произволен метод с enum_for.

class Numbers
  def primes
    yield 2
    yield 3
    yield 5
    yield 7
  end
end

first_four_primes = Numbers.new.enum_for(:primes)
first_four_primes.to_a     # [2, 3, 5, 7]

Ако ви се е случвало да ви трябва индекс в map:

words = %w( foo bar baz ).map.with_index do |word, index|
  "#{index}: #{word.upcase}"
end

words # ["0: FOO", "1: BAR", "2: BAZ"]

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