• Enumerator-и и мързел
• Още за класови методи
• Замразяване на обекти
• Ruby Gems, load path, require
• Code spelunking из skeptic

Изпълнението на кода по-долу ще предизвика ли грешка или ще изведе нещо на екрана:

def foo(klass = Class.new { def bar() 'Roll the dice' end })
  puts klass.new.bar
  def foo() puts 'You feel it running through your bones' end
end

foo
foo

Roll the dice
You feel it running through your bones 

Какво ще се случи при изпълнение на следния код (и защо):

Object::String = Class.new
puts String.new('bar').upcase

Какво ще се случи при изпълнение на следния код (и защо):

PIE = 'Apple'
module Foo
  PIE = 'Strawberry'
end

module Foo::Bar
  puts PIE
end

Какво ще се случи при изпълнение на следния код (и защо):

class Proc
  def ===(testable)
    call testable
  end
end

case 42
  when String         then 'This is a string'
  when :odd?.to_proc  then 'This is an odd number'
  when :even?.to_proc then 'This is an even number'
  else                     'I have no f*cking idea what this is.'
end

• Обмяна на опит, попълване на знанията, тренинг в говоренето
• Харесайте си тема, дори да не е пряко свързанa с Ruby, и ни пишете
• Последната седмица на ноември Георги ще говори за Git

Някои методи на 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

• Методите на Enumerable връщат Enumerator, ако ги извикате без блок
• Това позволява да "навръзвате" enumerator-и
• Ако дефинирате обект, който е Enumerable, помислете и за съвместимост с enumerator-и

Може да извадите енумератор от произволен метод с 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]

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

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]]

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

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

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

data = "Some really long\ntext with new lines."

# Решение 1
data.lines.map(&:split).map(&:size) # [3, 4]

# Решение 2
data.lines.map { |line| line.split.size } # [3, 4]

Решение 1 създава междинен масив с всички елементи

• Методът Enumerable#lazy връща "мързелив" енумератор
• Има и Enumerator#lazy
• Дадената стойност се оценява само когато потрябва

[
  ' a ',
  ' b ',
  ' c ',
].lazy.map { |x| p x.strip }.map { |x| p x.upcase }.take(1).to_a

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

"a"
"A" 

И ще върне списъка ["A"].

Методи имплементирани в Enumerator::Lazy (документация) към момента:

• map / collect
• flat_map / collect_concat
• select / find_all
• reject
• grep
• zip
• take
• take_while
• drop
• drop_while

Методи, които "материализират" lazy колекцията:

• to_a / force
• each
• next

• Условието на трета задача изисква създаването на класови метод
• Миналия път ви показахме един от начините да дефинирате такъв
• Този начин не е единствен и не е "каноничният"
• Без да навлизаме в детайли, днес ще ви покажа двата други начина

Неканоничният и праволинеен начин за дефиниране на класов метод:

module RBFS
  class File
    def File.parse(string_data)
      # Solution lost.
    end
  end
end

Този начин е еквивалентен на предишния слайд:

module RBFS
  class File
    def self.parse(string_data)
      # Solution lost.
    end
  end
end

Това работи, понеже:

• Тялото на класа е изпълним код
• Както във всеки друг контекст в Ruby, и там имаме self
• self и RBFS::File в тялото на класа реферират към един и същ обект

Използва се при нужда да се дефинират няколко класови метода:

module RBFS
  class File
    class << self
      def parse(string_data)
        # Solution lost.
      end
    end
  end
end

• Какъв е този синтаксис и защо работи, ще си говорим по-нататък

• Първият начин не се ползва (def ClassName.method_name() end)
• При дефиниране на един, максимум два класови метода, ползваме втория начин
• При дефиниране на повече от един класов метод, обикновено ползваме третия начин
• За справка – ръководството по стил

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

• Реално превръща mutable-обекти в immutable
• Замразяването става с Object#freeze (Мутира обекта!)
• Можете да проверите дали обект е замразен с Object#frozen?
• Веднъж замразен, даден обект не може да бъде размразен
• Не можете да променяте вече замразени обекти (Workaround е да направите dup.)
• Често се ползва, когато присвоявате mutable-типове на константи

Тъй като низовете в Ruby са mutable, всяко срещане на низ = нов обект:

''.object_id                 # 549133130
''.object_id                 # 549132850
''.object_id == ''.object_id # false

• Това е performance проблем
• Символите го решават, но те не са заместител на низове

class HTTP
  attr_reader :method
  METHOD_POST = 'POST'

  def post?
    method == METHOD_POST
  end
end

Това е досадно. Затова в Ruby 2.1 има и по-добро решение.

''.freeze.object_id                        # 551882650
''.freeze.object_id                        # 551882650
''.freeze.object_id == ''.freeze.object_id # true

• Границата между freeze-нати низове и символи се размива в последните версии на Ruby

• "Chunky bacon".freeze се оптимизира от Ruby и връща един и същи обект
• Ако вече има такъв обект, с такова съдържание, той ще бъде преизползван
• Важи само при първо дефиниране на низ с литерален синтаксис

• Полезно и интересно е да знаете за оптимизацията
• Не замразявайте низове под път и над път заради това
• Това е микро-оптимизация
• Замразявайте неща, ако ви е страх от промени :)

Каква е разликата между require './foo' и require_relative 'foo'?

require './foo'        # Релативно спрямо Dir.pwd
require_relative 'foo' # Релативно спрямо __FILE__

cd /home
ruby /foo/bar/baz.rb # Dir.pwd ще е: /home

• require 'foo' търси файл foo.rb в $LOAD_PATH
• Може да реферира и директно към файлове ако пътят започва с ., ~ или /
• Зарежда файла, като го изпълнява (само веднъж)
• Всичко от файла е достъпно, с изключение на локалните променливи (отделен binding)

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

.
├── 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?

Демонстрация с цел да усвоим основни пещернячески умения.

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