Choosing a task

1. если ваши таски реопенед, применяете комменты
2. если есть свободные ревью таски (Pending review, assigned to Dilyara), берете себе и делаете ревью
3. если ни комментов, ни ревью нет, но есть незаконченный таск, то продолжаете его
4. если ни комментов, ни ревью нет и все таски закончили, то берете новый таск (assigned to Dilyara)
5. если новых тасков нет, то думаете, что можно изменить/улучшить

Working on a story

• нажимаем “Start” (или “Accept bug”)
• стори делаем в отдельной ветке
• ветку называем feature/{номер стори}-{тайтл стори маленькими буквами с минусами вместо пробелов, спецсимволов и camel case} (например feature/123-update-media-type-tagged-text-selection для #123 Update MediaType::TaggedTextSelection)
  • если стори зависит от другой незаревьювленной стори – ветку форкаем от ветки той стори
  • иначе от develop
• как сделали стори:
  • нажимаем “Assign for review” и ассигним на Диляру
• когда делаем ревью
  • нажимаем “Start review”
  • используем команду git review {story number} (TBD)
  • нажимаем “Assign for test” и ассигним на автора стори или на Фила; или
  • нажимаем “Fail review”
• после того, как вашу стори заревьювили и протестили:
  • делаем rebase и squash с develop – сливаем все коммиты в один
  • коммит месседж должен быть в виде [GD-{номер стори}] {тайтл стори} (например [GD-123] Update MediaType::TaggedTextSelection)
  • мерджим ветку в develop
  • удаляем ветку локально и из github (!!!)
  • нажимаем “Merged to Develop”

От нашего “Райффайзенбанка” есть приятные новости!
От них поступила следующая информация, предлагаю к ознакомлению:

“Уважаемые сотрудники компании Флэтсофт, добрый день!

Рады сообщить, что для сотрудников Вашей компании Райффайзенбанк
предлагает льготные условия по следующим программам кредитования:

Ипотека

Потребительский кредит

Кредитные карты

Просим Вас донести данную информацию до коллектива.

Будем рады ответить на Ваши вопросы в нашем офисе по адресу: г.
Казань, ул. Ершова 35А или по телефону: (843) 567 59 00.

С уважением,
Дина Акулова

Специалист группы ипотечного кредитования
ОО “Казанский” ЗАО “Райффайзенбанк”
г. Казань, ул. Ершова 35А
т. (843) 567-59-16, вн. 2602″

Блоки
Блоки, процедуры и лямбды — замыкания (closures) — являются важным аспектом языка Ruby, с одной стороны, и малопонятным с другой. Малопонятным в основном из-за того, что Ruby подходит к замыканиям в значительной степени уникальным образом, к тому же в Ruby существуют разные способы использования замыканий.

Способ первый. Proc / Lambda
Любой кусок кода в руби можно выделить в особой тип объекта - блок. Блок кода явялется объектом класса Proc. для его создания необходимо выполнить

some_block = Proc.new { puts 'from some blcok' }
или
some_block = lambda do
puts 'from lambda'
end

Сохраненный таким образом код можно использовать по разному. можно передвать в функции в качестве параметров, можно просто вызвать. Для передачи параметров в блок нужно определить его принимающим параметры. Список переменных в |аргумент1| будет определять параметры блока.
some_block_with_parameter = lambda do |name|
puts 'from lambda'
end

для исполнения кода нужно вызвать метод .call объекта Proc, в зависимости от блока - с параметрами или без.
some_block.call
some_block_with_parameter.call :argument

а вот пример работы функции с блоков
def my_func(block)
puts 'before block called'
block.call
puts 'after block called'
end
some_block = Proc.new { puts 'from some blcok' }
my_func(block)
=>
before block called
from some blcok
after block called


Блок, переданный таким способом ничем не отличается от параметра, и значит мы можем передвать любое количество в любом порядке.

Способ второй. блоки
В отличие от от lambda/proc, блоки кода можно использовать только один раз, но и процедура их записи на порядок короче.
def my_func(&block)
puts 'before block called'
block.call
puts 'after block called'
end

# другой способ передачи блока
my_func do
puts 'code from block'
end

или с параметром

def my_func(&block)
puts 'before block called'
block.call 'some name'
puts 'after block called'
end
my_func do |name|
puts 'code from block ' + name
end

# можно и Proc передать, при необходимости

block = Proc.new { puts 'proc' }
my_func(&block)

В сокращенном виде это можно писать и так:

def my_func
# это проверка пришел ли блок
return unless block_given?
puts 'before block called'
yield 'some name'
puts 'after block called'
end


my_func { |name| puts 'called in function ' + name }

В завершении приведу примерную реализацию итератора по массиву
class Array
def my_each
i = 0;
while i < self.size
yield self[i]
i+=1
end
end
end
(1..10).to_a.my_each { |element| puts element }

Отметим, что замыкания широко используются в ruby, более того, ни одна программа не обходится без них.

Вопросы на дом
- найти отличия между lambda и proc
- разница между передачей блока как block и как &block

Модули. Классы
Наиболее очевидное применение модулей - в качестве неймспейсов.
module Mathic
def self.abs
puts 'calculate abs'
end
end


module Party
def self.abs
puts 'some drinking to absolute drinking state'
end
end
def abs
puts 'another method to_s'
end
abs
Mathic.abs
Party::abs


использование различных модулей позволяет разделить эти методы и переписать случайно какой либо из них.

Второе, и более частое использование модулей - в качестве примесей ( mixins ). Mixins - это механизм, с помощью которого в руби реализуется добавление общих методов классы. Механизм более удобный и простой по сравнению с наследованием, особенно множественным или многоуровневым.

module Movable
def move
puts self.name + ' moved'
end
end


class Tank
include Movable

def name
'ship'
end
end
Ship.new.move
Tank.new.move

Как видно, добавленеи модуля через include расширяет функциональность объекта класса. для расширения функциональности самого класса необходимо воспользоваться ключевым словом extend. Продемонстрирую разницу между extend/example:

module Foo
def foo
puts 'foo'
puts self.inspect
end
end

Unit.foo
Unit.new.bar


А теперь более реальный пример. Расширение функциональности происходит в нужный момент в нужном классе.

module Movable
# метод вызывается момент include Movable
def self.included(base)
# расширяем функциональность класса методом acts_as_movable_object
base.send :extend, ClassMethods
end

a = Unit.new
a.name = 'unit'
a.move
a.stop

легко продолжить данный способ до любого количества модулей в меру своей фантазии.

class Unit
include Movable
include Shootable
include Flyable
include Swimable
end

class Ship < Unit
acts_as_shootable
acts_as_swimable
end

class Plane < Unit
acts_as_flyable
end

Футболки будем дарить не только нашим сотрудникам, работающим в штате, но и тем, кто посещает наши курсы по “RubyOnRails”!

Ждем ваших пожеланий по поводу надписи, особое внимание тем, кто придумает нечто оригинальное, связанное с Ruby, как например:

“Ruby - друг человека”

“Ruby, коси и забивай”

Со спины, футболка будет выглядеть примерно так:

0) запуск из консоли.
1) переменные
2) основные классы
3) методы. определение и вызов.
4) rubykoans

Ру́би — интерпретируемый язык программирования высокого уровня. Обладает независимой от операционной системы реализацией многопоточности, строгой динамической типизацией, «сборщиком мусора» и многими другими возможностями, поддерживающими много разных парадигм программирования, прежде всего классово-объектную.

( http://ru.wikibooks.org/wiki/Ruby )

Запуск
Для руби существуюет интерактивная консоль irb - очень похожа на консоль из rails ( rails console), но без многих встроенных в рельсы библиотек. Удобно если надо протестировать небольшой кусок кода или отдельные выражения. Запуск из консоли ( shell или cmd) : irb.

Файлы программ на ruby имеют расширение *.rb. Что бы запустить программу, надо выполнить комадну ruby file.rb, где file.rb - имя программы. для *nix систем существует возможность сделать программу исполняемой. для этого необходимо в самом начале программы указать интерепретатор “#!/usr/bin/env ruby” или “#!/usr/bin/ruby”, а потом дать права файлу на исполнение “chmod u+x ./file.rb”. после этого программу можно запускать как обычный выполняемый скприпт /path/to/file.rb

Вывод на экран

В Ruby есть много методов вывода: print, printf, p, puts, .display и другие.
* метод puts. После вывода строки осуществляет переход на новую. Если приходится выводить объект, не являющийся строкой, то puts вызывает метод .to_s для преобразования его к строке;
* метод p. Имеет самое короткое название, из-за чего часто используется для отладки. Так же, как и puts, делает перевод на новую строку после вывода. Перед выводом любого объекта (в том числе и строки) на экран, вызывает метод .inspect.
* метод print. Выводит на экран без перевода каретки, в остальном аналогичен методу puts

Примеры вывода на экран:
puts [1, 2, 3, 4] #=> 1n2n3n4 n означает перевод строки
p [1, 2, 3, 4] #=> [1, 2, 3, 4]
puts “Hello!” #=> Hello!
p “Hello!” #=> “Hello!”
puts 5 #=> 5

В руби существует два способа комментирования текста # - закомментирует все до конца строки, многострочный комментарий отмечается как
=begin ( обязательно с начала строки)
=end

Переменные.
В ruby приняты следующие способы именования переменных:
variable_name
variable_2
ClassName
ModuleName
CONSTANT

в руби переменная объявляется при первом присвоении ей значения. переменные класс ( содержат @ в начале имени - @variable_name ) объявляются при первом их упоминании, и содержат nil по умолчанию. Все переменные указывают на объект. Стандартные объекты nil, true, false - тоже являются объектами ( уточнить класс можно через variable.class )

Базовые классы руби.
Целые числа
Целые числа в Ruby не ограничены по величине, то есть могут хранить сколь угодно большие значения. Для обеспечения такого волшебного свойства было создано два класса. Один из них хранит числа меньшие 230 (по модулю), а второй — всё, что больше. По сути, для больших чисел создаётся массив из маленьких, а раз массив не имеет ограничений по длине, то и число получается неограниченным по значению. К сожалению, эти ограничения налагаются используемой базой данных - впрочем, можно хранить числа как строки.

Числа с плавающей запятой
Числа с плавающей запятой задаются только в десятичной системе счисления, при этом для отделения дробной части используется символ . (точка). Для задания чисел с плавающей запятой может быть применена и экспоненциальная форма записи: два различных представления 0.1234e2 и 1234e-2 задают одно и тоже число 12.34.

Арифметические операции в Ruby обычны: сложение (+), вычитание (-), умножение (*), деление (/), получение остатка от деления (%), возведение в степень (**). Если все аргументы арифметического выражения целые числа, то результат будет целым, если хотя бы одно число с плавающей запятой, то результат будет числом с плавающей запятой.

Строка.
Строка — это упорядоченная последовательность символов, которая располагается между ограничительными символами.
Строковый тип является самым популярным в любом языке программирования. Ведь без него невозможно написать любую программу (особенно учитывая, что любая программа — это строка). При выводе на экран или записи в файл, любой тип данных преобразуется к строке (явно или неявно). Это значит, что в конечном итоге всё сводится к строковому типу. Кстати, и ввод данных тоже осуществляется в виде строки (и только потом преобразуется в другие типы).

Способы создания строки
Строка создаётся при помощи ограничительных символов. Для этих целей чаще всего используются ” (программистская кавычка) и ‘ (машинописный апостроф). Их смысл различен. Строка в апострофах гарантирует, что в ней будет содержаться тот же текст, что и в коде программы, без изменений. Строка в кавычках будет проходить предварительное преобразование. Внутри строки с ” можно использовать спец символы , экранируя их , и вставку кода руби - через “hello, #{user.name}”. внутри строки ‘ нельзя использовать спец символы и #{}.

Массивы.
Массив создаётся как минимум трёмя способами. Первый способ:
[1, 2, 3, 4, 5, 6]
Вы просто перечисляете элементы массива через запятую, а границы массива обозначаете квадратными скобками. С таким методом создания массива мы уже встречались. А теперь попробуем второй способ, через вызов метода .new класса Array:
Array.new(6){ |index| index + 1 } #=> [1, 2, 3, 4, 5, 6]
Параметром метода .new является количество элементов будущего массива (в данном случае это число 6). В фигурных скобках указано, как мы будем заполнять массив. В данном случае значение элемента массива будет больше на единицу его индекса. Третий способ заключается в создании объекта типа Range (диапазон) и вызове метода .to_a:
(1..6).to_a #=> [1, 2, 3, 4, 5, 6]
Класс Array содержит обширную библиотеку методов. Итераторы, логические методы, работа с каждым элементом или работа со всем массивом в целом. Наиболее часто используются методы .each - проходит по всем элементам массива и выполняет некоторую операцию. и метод map ( collect ) - выполняет некоторый код с каждым элементом и возвращает новый массив, состоящий из результатов работы каждого блока.
[1,2,3,4,5].map{|element| element * element} # => [1,4,9,16,25]

Различают два типа массивов: индексные, у которых в качестве индекса только целое число и ассоциативные, где индексом может быть любой объект.
Хеши можно представить как массив пар: ключ=>значение. Но в отличие от массива, хеш неупорядочен: нельзя заранее сказать, какая пара будет первой, а какая последней. Правда, удобство использования массива это шибко не умаляет. Более того, поскольку в Ruby переменные не типизированы и методам с похожей функциональностью дают похожие имена, то использование хеша чаще всего равносильно использованию массива.
Хеш обозначается как {}.
{”март”=>400, “январь”=>350, “февраль”=>200}

методы.
Все функции в Ruby являются методами, то есть свойственны обьектам. При программировании на это можно не обращать внимания, поскольку любая программа на Ruby уже является определением класса. У методов могут быть обязательные или необязательные параметры. Методы разграничиваются фигурными скобками или ключевыми словами def и end.

def method_name(firstname, nickname = ‘undefined’, options = {})
Определения говорит о том что аргумент метода имеет базовое значение ‘undefined’, а аргумент options имеет значение по умолчанию - пустой хеш. данный метод можно вызвать следующими способомаи
* method_name ‘code’ # передаем одно значение, остальные будут использоваться дефолтовые.
* method_name(’code’) # то же самое, скобки желательно использовать для улучшения читабельности
* method_name ‘code’, ‘anonimous’
* method_name ‘code’, ‘anonimous’, :as_troll => true
* method_name(’code’, ‘anonimous’, { :as_troll => true })

Результат работы находится на Github — https://github.com/evgeniypetrov/seminar4shop

Прочитайте Readme, чтобы повторить ход работы.

5 день изучения Ruby on Rails был посвящен хорошим практикам работы с git и улучшением нашего магазина.

Cегодня мы вели нашу разработку в отдельной ветке, создали главную страницу магазина, разобрались с отображением (Layouts, partial, view), сделали контроллер для продуктов. В конце разработки, мы соединили мастер ветку с новой веткой, разрешили конфликты.

Приведу здесь некоторые ссылки:

Полезно прочитать про git:
1. Git Workflow
2. Git Wizardry
3. A successful Git branching model
4. http://book.git-scm.com/ главу Intermediate Usag

По отображению в Ruby on Rails:
http://guides.rubyonrails.org/layouts_and_rendering.html

Дома вам необходимо сделать так, чтоб на главной странице отображались только товары, которые есть в наличие. (Использовать scope)
Добавить ссылки на категории и сделать так, чтобы при переходе в категорию, отображались только те товары, которые в ней находятся.
Ну и попробуйте сделать наше оформление более красивым :) Сделайте layout для главной страницы и продуктов отдельные.

Код держите на github и делитесь друг с другом ссылками в комментариях.

Вот основные темы, которые были рассмотрены:

• Интегрирование капчи в rails3 приложение (что бы пользователь при регистрации вводил текст с картинки). За основу взято приложение rails3-base в котором в качестве решения для аутентификации используется гем devise
• HTML5, Drag and drop файлов между браузером и ОС.
• MySQL replications
• Применение rvm, rspec+shoulda для тестирования моделей, cucumber, formtastic, tebletastic, flutie, devise;
• Что такое scrumboard. Органиция работы с помощью утилиты screen.

Кроме озвученных выше пунктов, мы замечательно пообщались и на множество других, интересных для нас тем.

Было бы здорово услышать отзывы тех, кто приходил к нам впервые! Может у вас есть предложения, какие темы хотелось бы рассмотреть в следующий раз?

Ждем ваших предложений! Будем рады комментариям!

Вчера на баркампе я обещал выложить краткий конспект своего доклада по теме “Масштабирование БД: репликации в MySQL”.

В своем докладе в плане теории я опирался на следующие скринкасты, очень рекомендую вам их посмотреть:

• http://railslab.newrelic.com/2009/07/16/episode-17-scaling-your-database-part-1
• http://railslab.newrelic.com/2009/07/24/episode-18-scaling-your-database-part-2
• http://railslab.newrelic.com/2009/02/19/episode-9-taylor-weibley-databases

Для того, чтобы настроить репликации в MySQL по самой распространенной схеме Master/Slave, есть замечательные гайды на официальном сайте MySQL и на сайте cowboycoded.com

• http://dev.mysql.com/doc/refman/5.0/en/replication-howto.html
• http://www.cowboycoded.com/2009/08/19/mysql-master-slave-replication-tutorial/

Адекватного решения этой задачи “из коробки” для Rails 3 пока не нашлось. Предлагаю обратить внимание на существующие решения для вторых рельсов, попробовать их и, возможно, помочь в поиске (или создании) решения для третьих рельсов.

• http://github.com/technoweenie/masochism
• http://github.com/mauricio/master_slave_adapter

Итак, закончился 3 день изучения Ruby on Rails.

Мы прошли следующие темы:

• Git базовые навыки: init, add, commit
• Создание модели “Категория”
• Связи между моделями
• Миграции
• Валидация

Конспектирую здесь, что необходимо повторить.

1. Git

Рекомендую прочитать The Git Community Book, как минимум главу “3. Basic Usage”.
И посмотрите главу про Git из Ruby on Rails Tutorial

Будет здорово, если Вы зарегистрируетесь на github.com и будете держать свой проект там.

Для удобства работы, привожу алиасы

Пропишите их в ~/.bashrc

Еще будет очень удобно, если в консоле будет указано в какой ветке вы в данный момент находитесь.
Для этого в .bashrc надо добавить

2. Связи между моделями

Необходимо прочитать Rails Guides .

Самим указать в нашем учебном проекте, что product belongs_to category, category has_many products и т.д.

Попробуйте придумать свои примеры, чтобы отработать все типы ассоциаций.

Если останутся силы, посмотрите polymorphic-association.

Включите отображение SQL запросов в консоле.
Введите в консоле: ActiveRecord::Base.logger = Logger.new(STDOUT)

Посмотрите, какие запросы выполняются.

3. Валидация

Опять же отправляю вас к Ruby Guides.

Сделайте проверку, что у продукта есть имя, положительная цена, что у категории есть имя, что оно уникальное и т.д.

Я еще обещал рассказать почему у нас не получилось сделать
1. has_one :something, :after_add => :some_method
2. Рассказать про Lazy Loading

И я забыл рассказать вам про Баркамп.
Напишите, пожалуйста, в комментариях кто планирует прийти.

Прошел второй день курсов Ruby on Rails. Несмотря на то, что занятие получилось слегка сумбурным - много информации, привыкание к окружению разработки, маленькие технические неувязки и т.д., мы все же подготовили конспект  и сейчас представим ее вам.

1. Создание нового рельсового приложения

rails new project_path
Настройки соединия с базой данных хранятся в config/database.yml. Нетбинс бывает переписывает данный файл. В общем, часть development должна выглядеть примерно так.
development:
adapter: sqlite3
database: db/development.sqlite3
pool: 5
timeout: 5000

В составе rails по умолчанию есть много разных полезных фичей.

2. Генераторы кода

для просмотра всех наберите rails generate, или rails generate *generator* для просмотра помощи по конкретному генератору. Рассмотренные на занятии генераторы

rails generate model
rails generate migration
rails generate scaffold


3. rake - таски.

Rake - аналог make, только на ruby.
для просмотра всех тасков необходимо выполнитть rake -T или rake -T [ключевое слово]. На занятии использовались следующие таски.

rake db:migrate
rake db:rollback
rake db:migrate VERSION=version
rake db:seed

4. Model

Рельсы используют ActiveRecord для работы с базой. AR  отображает состояние таблицы, поэтому для добавления или удаления полей из класса наследованного от AR необходимо менять саму таблицу в базе данных. Для этого в рельсах есть миграции.
[вставить картинку отображения схемы работы AR]

5. Migration.

Миграции, это классы наследованные от ActiveRecord::Migration. Миграция должны содержать два основных метода ( методы класса) - up / down. Метод up выполняет нужные изменения в базе данных - метод down производит откат изменений сделанных методом up при “откате” - rollback миграции. Все изменения в базе должны делаться через миграции.
Команда
rails generate model Product name:string price:integer
создаст нам модель Product ( местонахождение app/models/product ) и миграцию create_products cледующего вида.

class CreateProducts < ActiveRecord::Migration
def self.up
create_table :products do |t|
t.string :name
t.integer :price

t.timestamps
end
end

def self.down
drop_table :products
end
end

метод create_table  создает таблицу. через переменную t мы задаем поля этой таблицы. кроме create_table, существуют подобные методы drop_table и change_table.
Формат задания полей. Миграции понимают следующие типа полей
:primary_key, :string, :text, :integer, :float, :decimal, :datetime, :timestamp, :time, :date, :binary, :boolean.

следующие способы записи равносильны
t.column :name, :string
t.string :name
разница в том что t.string может создать сразу несколько полей
t.string :name, :title, :first_name, :short_description

строка t.timestamps равносильна следующему
t.column  :created_at, :datetime
t.column  :updated_at, :datetime

Для создание отдельной миграции, добавляющей ссылку на модель Category, необходимо выполнить следующую комаднду
rails generate migration add_category_to_products category:string.
Формат имени говорит рельсам что мы хотим создать миграцию для добавления (add) поля category в таблицу products. category:string задает тип этого поля. Впрочем, ничего не мешат создать миграцию с произвольным именем, а потом руками добавить следующие строки.

def self.up
add_column :products, :category, :string
end

def self.down
remove_column :products, :category
end

вместо add_column можно использовать конструкцию
change_table :products do |t|
t.string :category
end
а вместо remove_column
change_table :products do |t|
t.remove :category
end

полный список методов миграции.
* create_table
* change_table
* drop_table
* add_column
* change_column
* change_column_default
* rename_column
* remove_column
* add_index
* remove_index

что бы запустить миграцию необходимо выполнить команду rake db:migrate
что бы откатить - rake db:rollback ( откатится последний мигрейт ). Команда redo сначала откатит, а потом снова накатит мигрейт. Полезно бывает проверить откатываемость миграции.
rake db:migrate
rake db:migrate:rollback
rake db:migrate:redo
rake db:migrate:rollback STEP=3
rake db:migrate:redo STEP=3
rake db:migrate:up VERSION=xxxxxxxxxxxxx
rake db:migrate:down VERSION=xxxxxxxxxxxx

с параметром VERSION rake db:migrate прогонит миграции до указанной версии, с указанием направления - только в указанном.
параметр STEP задает количество миграций.Так например rake db:migrate:redo STEP=3 откатит последние три миграции, а потом накатит их в обратном порядке.

6. Работа с данными.

После создания таблица не содержит записей ( проверить можно выполнив Product.count в  rails консоли ). Создать новые записи можно как вручную через консоль, так и через rake db:seed. Данный таск предназначен для первоначального заполнения таблицы данными, при его запуске он выполняет код из db:seed. Пускай он выглядит примерно так
db/seed.rb
product = Product.new
product.name = 'red ball'
product.price = 10
product.save

product1 = Product.new(:name => 'yellow ball', :price => 15)
product1.save

product2 = Product.create(:name => 'blue ball', :price => 20)

# and create many other products
Product.create(:name => 'blue ball', :price => 10)
Product.create(:name => 'blue ball', :price => 15)

Product.create(:name => 'red ball', :price => 25)
Product.create(:name => 'green ball', :price => 15)

После выполнения rake db:seed у нас в базе будет 7 записей о товарах.
Особо отмечу, что после выполнения Product.new(:name => ‘ball’, :price => 10) строка в таблице не создается! Запись будет создана только после того  как вы вызовете метод save или save!.

7. Основы работы с моделями.

Для поиска продукта по известному ключу надо выполнить Product.find(primary_key) - где primary_key - первичный ключ, в нашем случае это id объекта.
кроме этого, есть методы Product.first - вернет первый объект в таблице и Product.last - последний. Эти методы принимают в качестве аргумента количество объектов которых надо вренуть. к примеру, Product.last(5) вернет последние 5 записей. метод Product.all вернет все записи из таблицы.

для поиска объектов можно использовать метод where. его можно использовать в следующие вариантах
Product.where(”name = ‘blue ball’”) - не очень красивый вариант, этот код не будет заэскейплен и будет напрямую выполнени.
Product.where(:name => ‘blue ball’) - в этом случае рельсы возьмут на себя проверку содержания переменной.
Product.where(”name = ?”, ‘blue ball’) - совмещенный вариант
Product.where(”name = :name or title = :name or some_field = :name”, :name => ‘blue ball’) -  вариант используется если в условии надо испольовать одну переменную несколько раз.

Рельсы так же позволяют использвать диапазоны значений.
Product.where(:price => [10, 15]) - продукты с ценой 10 или 15
Product.where(:price => (10..15)) - продукты с ценой от 10 до 15. Использовать следует с осторожностью, поскольку sql код будет выглядить как where price in (10, 11, 12, 13, 14, 15).  Если задать диапазон как  (1.year.ago..1.year.from_now) можно получить запрос где будут перечислены ВСЕ возможные даты за два года.

Помимо этого, есть методы
select(:name) для выборки только имен продуктов ну или любых полей какие захотите
order(”price desc”) - для задания порядка продуктов - обычный sql порядок, можно использовать несколько “price desc, name asc, created_at desc”
limit(5) - для задания количества элементов. можно 5, можно 100
offset - для задания сдвига. к примеру offset(2) пропустит первые два найденные элемента
group(name) - группировка по имени. все понятно

Product.group(:name).select(”avg(price) as avg_price, name”).order(:name).offset(1).limit(1)
найдет среднюю цену зеленого шара. просто пример как комбинировать, особого смысла нет)

Приложение 1. Необходимые линуксовые команды

mkdir cat_name - создание каталога
ls path - список элементов
cd path - Change Directory смена каталога

info - выдаст содержание справки.

Всем удачи!

PS. Для заинтересованных, приходите с большими флешками - можем скинуть настроенный образ railsdev на CentOS’е. Как разработчикам - очень пригодится