• case в Ruby
• Трикове с присвояване
• require
• Структура на простички gem-ове
• Замразяване на обекти
• Малко интроспекция
• Разни

В 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-ове

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

• Присвояването в Ruby:
• foo = 'baba'
• Може малко повече от това... :)
• Паралелно присвояване
• Вложено присвояване
• Комбинации между двете

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 и head обират всичко останало
• Очевидно, може да имате само една 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

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

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

В 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 файлове.

.
├── 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 прави това "автомагично".

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

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

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

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