Ruby on Rails Tutorial

Изучение Rails на Примерах

Майкл Хартл

Содержание

  1. Предисловие к русскому изданию
  2. Глава 1 От нуля к развертыванию
    1. 1.1 Введение
      1. 1.1.1 Комментарии для разных читателей
      2. 1.1.2 “Масштабирование” Rails
      3. 1.1.3 Соглашения в этой книге
    2. 1.2 За работу
      1. 1.2.1 Среда разработки
        1. IDE
        2. Текстовые редакторы и командная строка
        3. Браузеры
        4. Примечание об инструментах
      2. 1.2.2 Ruby, RubyGems, Rails, и Git
        1. Rails Installer (Windows)
        2. Установка Git
        3. Установка Ruby
        4. Установка RubyGems
        5. Установка Rails
      3. 1.2.3 Первое приложение
      4. 1.2.4 Bundler
      5. 1.2.5 rails server
      6. 1.2.6 Модель-представление-контроллер (MVC)
    3. 1.3 Управление версиями с Git
      1. 1.3.1 Установка и настройка
        1. Первоначальная настройка системы
        2. Первоначальная настройка репозитория
      2. 1.3.2 Добавление и фиксация
      3. 1.3.3 Что хорошего Git делает для вас?
      4. 1.3.4 GitHub
      5. 1.3.5 Ветвление, редактирование, фиксация, объединение
        1. Ветвление
        2. Редактирование
        3. Фиксация
        4. Объединение
        5. Отправка
    4. 1.4 Развертывание
      1. 1.4.1 Установка Heroku
      2. 1.4.2 Развертывание на Heroku, шаг первый
      3. 1.4.3 Развертывание на Heroku, шаг второй
      4. 1.4.4 Команды Heroku
    5. 1.5 Заключение
  3. Глава 2 demo app
    1. 2.1 Планирование приложения
      1. 2.1.1 Моделирование пользователей
      2. 2.1.2 Моделирование микросообщений
    2. 2.2 Ресурс Users
      1. 2.2.1 Обзор пользователя
      2. 2.2.2 MVC в действии
      3. 2.2.3 Недостатки данного ресурса Users
    3. 2.3 Ресурс Microposts
      1. 2.3.1 Микрообзор микросообщений
      2. 2.3.2 Помещение micro в микросообщения
      3. 2.3.3 Пользователь has_many микросообщений
      4. 2.3.4 Иерархия наследования
      5. 2.3.5 Развертывание демонстрационного приложения
    4. 2.4 Заключение
  4. Глава 3 В основном статические страницы
    1. 3.1 Статические страницы
      1. 3.1.1 Истинно статические страницы
      2. 3.1.2 Статические страницы с Rails
    2. 3.2 Наши первые тесты
      1. 3.2.1 Инструменты тестирования
        1. Autotest
      2. 3.2.2 TDD: Красный, Зеленый, Refaktor (реорганизация)
        1. Spork
        2. Красный
        3. Зеленый
        4. Refactor (реорганизация)
    3. 3.3 Немного динамические страницы
      1. 3.3.1 Тестирование изменения заголовка
      2. 3.3.2 Прохождение тестов заголовка
      3. 3.3.3 Переменные экземпляра и Embedded (встроенный) Ruby
      4. 3.3.4 Устранение дублирования шаблонами
    4. 3.4 Заключение
    5. 3.5 Упражнения
  5. Глава 4 Rails-приправленный Ruby
    1. 4.1 Причины
      1. 4.1.1 title хелпер
      2. 4.1.2 Каскадные Таблицы Стилей
    2. 4.2 Строки и методы
      1. 4.2.1 Комментарии
      2. 4.2.2 Строки
        1. Печать
        2. Строки в одинарных кавычках
      3. 4.2.3 Объекты и передача сообщений
      4. 4.2.4 Определение метода
      5. 4.2.5 Возвращение к title хелперу
    3. 4.3 Другие структуры данных
      1. 4.3.1 Массивы и диапазоны
      2. 4.3.2 Блоки
      3. 4.3.3 Хэши и символы
      4. 4.3.4 Вновь CSS
    4. 4.4 Ruby классы
      1. 4.4.1 Конструкторы
      2. 4.4.2 Наследование классов
      3. 4.4.3 Изменение встроенных классов
      4. 4.4.4 Класс контроллер
      5. 4.4.5 User класс
    5. 4.5 Упражнения
  6. Глава 5 Заполнение шаблона
    1. 5.1 Добавление некоторых структур
      1. 5.1.1 Навигация по сайту
      2. 5.1.2 Пользовательские CSS
      3. 5.1.3 Частичные шаблоны (partials)
    2. 5.2 Ссылки в шаблоне
      1. 5.2.1 Интеграционные тесты
      2. 5.2.2 Rails маршруты
      3. 5.2.3 Именованные маршруты
    3. 5.3 Регистрация пользователей: первый шаг
      1. 5.3.1 Users контроллер
      2. 5.3.2 Signup URL
    4. 5.4 Заключение
    5. 5.5 Упражнения
  7. Глава 6 Моделирование и просмотр пользователей, часть I
    1. 6.1 Модель User
      1. 6.1.1 Миграции базы данных
      2. 6.1.2 Файл модели
        1. Аннотация модели
        2. Доступные атрибуты
      3. 6.1.3 Создание объектов user
      4. 6.1.4 Поиск объектов user
      5. 6.1.5 Обновление объектов user
    2. 6.2 Валидации User
      1. 6.2.1 Валидация наличия
      2. 6.2.2 Валидация длины
      3. 6.2.3 Валидация формата
      4. 6.2.4 Валидация уникальности
        1. Предостережение уникальности
    3. 6.3 Просмотр пользователей
      1. 6.3.1 Отладка и окружения Rails
      2. 6.3.2 User модель, представление, контроллер
      3. 6.3.3 Ресурс Users
        1. params в debug
    4. 6.4 Заключение
    5. 6.5 Упражнения
  8. Глава 7 Моделирование и просмотр пользователей, часть II
    1. 7.1 Небезопасные пароли
      1. 7.1.1 Валидации пароля
      2. 7.1.2 Миграция пароля
      3. 7.1.3 Обратный вызов Active Record
    2. 7.2 Безопасные пароли
      1. 7.2.1 Тест безопасного пароля
      2. 7.2.2 Немного теории безопасных паролей
      3. 7.2.3 Реализация has_password?
      4. 7.2.4 Метод аутентификации
    3. 7.3 Улучшение отображения пользователя
      1. 7.3.1 Тестирование страницы просмотра пользователя (с factories)
      2. 7.3.2 Имя и Gravatar
        1. Gravatar хелпер
      3. 7.3.3 Боковая панель пользователя
    4. 7.4 Заключение
      1. 7.4.1 Git commit
      2. 7.4.2 Развертывание Heroku
    5. 7.5 Упражнения
  9. Глава 8 Регистрация
    1. 8.1 Регистрационная форма
      1. 8.1.1 Использование form_for
      2. 8.1.2 HTML формы
    2. 8.2 Сбой регистрации
      1. 8.2.1 Тестирование сбоя
      2. 8.2.2 Работающая форма
      3. 8.2.3 Сообщения об ошибках при регистрации
      4. 8.2.4 Фильтрация логгируемых параметров
    3. 8.3 Успешная регистрация
      1. 8.3.1 Тестирование успешной регистрации
      2. 8.3.2 Завершение формы регистрации
      3. 8.3.3 Флэш
      4. 8.3.4 Первая регистрация
    4. 8.4 RSpec интеграционные тесты
      1. 8.4.1 Интеграционные тесты со стилем
      2. 8.4.2 Сбой регистрации пользователей не должен создавать нового пользователя
      3. 8.4.3 Успешная регистрация пользователя должна создавать нового пользователя
    5. 8.5 Заключение
    6. 8.6 Упражнения
  10. Глава 9 Войти, выйти
    1. 9.1 Сессии
      1. 9.1.1 Sessions контроллер
      2. 9.1.2 Форма для входа
    2. 9.2 Сбой входа
      1. 9.2.1 Обзор отправки формы
      2. 9.2.2 Ошибка входа (тест и код)
    3. 9.3 Успешный вход
      1. 9.3.1 Завершение create действия
      2. 9.3.2 Запомнить меня
      3. 9.3.3 Текущий пользователь
    4. 9.4 Выход
      1. 9.4.1 Уничтожение сессий
      2. 9.4.2 Вход после регистрации
      3. 9.4.3 Изменение ссылок шаблона
      4. 9.4.4 Интеграционные тесты для входа и выхода
    5. 9.5 Заключение
    6. 9.6 Упражнения
  11. Глава 10 Обновление, демонстрация, и удаление пользователей
    1. 10.1 Обновление пользователей
      1. 10.1.1 Форма для редактирования
      2. 10.1.2 Включение редактирования
    2. 10.2 Защита страниц
      1. 10.2.1 Требование входа пользователей
      2. 10.2.2 Требование правильного пользователя
      3. 10.2.3 Дружелюбная переадресация
    3. 10.3 Просмотр всех пользователей сайта
      1. 10.3.1 Список пользователей
      2. 10.3.2 Образцы пользователей
      3. 10.3.3 Пагинация
        1. Тестирование пагинации
      4. 10.3.4 Частичный рефакторинг
    4. 10.4 Уничтожение пользователей
      1. 10.4.1 Административные пользователи
        1. Возвращение к attr_accessible
      2. 10.4.2 Destroy действие
    5. 10.5 Заключение
    6. 10.6 Упражнения
  12. Глава 11 Микросообщения пользователей
    1. 11.1 Модель Micropost
      1. 11.1.1 Базовая модель
        1. Доступные атрибуты
      2. 11.1.2 Ассоциации Пользователь/Микросообщения
      3. 11.1.3 Улучшение микросообщений
        1. Дефолтное упорядочивание
        2. Dependent: destroy
      4. 11.1.4 Валидации микросообщений
    2. 11.2 Просмотр микросообщений
      1. 11.2.1 Дополнение страницы показывающей пользователя
      2. 11.2.2 Образцы микросообщений
    3. 11.3 Манипулирование микросообщениями
      1. 11.3.1 Контроль доступа
      2. 11.3.2 Создание микросообщений
      3. 11.3.3 Предварительная реализация потока сообщений
      4. 11.3.4 Уничтожение микросообщений
      5. 11.3.5 Тестирование новой home страницы
    4. 11.4 Заключение
    5. 11.5 Упражнения
  13. Глава 12 Слежение за сообщениями пользователей
    1. 12.1 Модель Relationship
      1. 12.1.1 Проблема с моделью данных (и ее решение)
      2. 12.1.2 Ассоциации пользователь/взаимоотношение
      3. 12.1.3 Валидации
      4. 12.1.4 Читаемые пользователи
      5. 12.1.5 Читатели пользователя
    2. 12.2 Веб-интерфейс для читаемых и читателей
      1. 12.2.1 Образцы данных
      2. 12.2.2 Статистика и форма для слежения за сообщениями пользователя
      3. 12.2.3 Страницы с читаемыми и читателями
      4. 12.2.4 Стандартный способ реализации кнопки follow
      5. 12.2.5 Реализация кнопки follow с Ajax
    3. 12.3 Лента сообщений
      1. 12.3.1 Мотивация и стратегия
      2. 12.3.2 Первая реализация потока сообщений
      3. 12.3.3 Пространства, подзапросы и лямбда
      4. 12.3.4 Новая лента сообщений
    4. 12.4 Заключение
      1. 12.4.1 Расширения к примеру приложения
        1. Реплики
        2. Обмен сообщениями
        3. Уведомления о новых читателях
        4. Напоминание пароля
        5. Подтверждение регистрации
        6. RSS канал
        7. REST API
        8. Поиск
      2. 12.4.2 Руководство по дальнейшим ресурсам
    5. 12.5 Упражнения
  14. Глава 13 Rails 3.1
    1. 13.1 Обновление примера приложения
      1. 13.1.1 Установка и настройка Rails 3.1
      2. 13.1.2 Получить Красный
      3. 13.1.3 Незначительные проблемы
        1. will_paginate
        2. Тест пагинации
      4. 13.1.4 Значительные отличия
        1. Каталоги активов (ресурсов)
        2. Замена Prototype на jQuery
    2. 13.2 Новые функции в Rails 3.1
      1. 13.2.1 Asset pipeline
      2. 13.2.2 Самообратимые миграции
      3. 13.2.3 Sass и CoffeeScript
    3. 13.3 Упражнения

Предисловие

Моя компания (CD Baby) была одной из первых громко перешедших на Ruby on Rails, а затем еще громче вернувшейся обратно на PHP (Google расскажет вам об этой драме). Эту книгу, написанную Майклом Хартлом так высоко рекомендовали, что я должен был попробовать её, и Ruby on Rails Tutorial это всё, что я использовал, чтобы вернуться к Rails.

Хотя я уже прошел через много книг по Rails, это одна из немногих, что, наконец, зацепила меня. Было много написано книг типа «Путь Rails» — после которых я чувствовал себя неестественно, но после этой книги я наконец почувствовал себя естественно. Это также единственная книга по Rails, которая соблюдает методику «разработка через тестирование» на всем своем протяжении, этот подход строго рекомендуется специалистами, но он никогда не был так чётко продемонстрирован ранее. Наконец, Git, GitHub и Heroku присутствуют в демо-примерах, автор действительно дает вам почувствовать, что он хотел сделать реальный проект. Учебный код примеров не изолирован.

Линейное повествование — отличный формат. Лично я прошел Rails Tutorial в течении трёх долгих дней, делая все примеры и задачи в конце каждой главы. Делайте всё от начала до конца, не прыгая, и вы получите максимальную пользу.

Наслаждайтесь!

Derek Sivers (sivers.org)
Основатель CD Baby

Благодарности

Ruby On Rails Учебник во многом обязан моей предыдущей книге по Rails, RailsSpace и, следовательно, моему соавтору Aurelius Prochazka. Я хотел бы поблагодарить Aure как за работу, которую он проделал над прошлой книгой, так и за поддержку этой. Я также хотел бы поблагодарить Debra Williams Cauley, редактора обеих книг RailsSpace и Rails Tutorial; до тех пор, пока она не прекратит брать меня на бейсбол, я буду продолжать писать книги для нее.

Я хотел бы поблагодарить огромное количество Рубистов учивших и вдохновлявших меня на протяжении многих лет: David Heinemeier Hansson, Yehuda Katz, Carl Lerche, Jeremy Kemper, Xavier Noria, Ryan Bates, Geoffrey Grosenbach, Peter Cooper, Matt Aimonetti, Gregg Pollack, Wayne E. Seguin, Amy Hoy, Dave Chelimsky, Pat Maddox, Tom Preston-Werner, Chris Wanstrath, Chad Fowler, Josh Susser, Obie Fernandez, Ian McFarland, Steven Bristol, Pratik Naik, Sarah Mei, Sarah Allen, Wolfram Arnold, Alex Chaffee, Giles Bowkett, Evan Dorn, Long Nguyen, James Lindenbaum, Adam Wiggins, Tikhon Bernstam, Ron Evans, Wyatt Greene, Miles Forrest, хороших людей из Pivotal Labs, команду Heroku, thoughtbot ребят, и команду GitHub. Наконец, многих, многих читателей - слишком много чтобы перечислять их здесь - внёсших большое количество предложений по улучшению и сообщивших об ошибках во время написания этой книги, и я с благодарностью признаю их помощь в написании ее настолько хорошей, насколько это было возможно.

Об авторе

Майкл Хартл – автор Ruby on Rails Tutorial, лидирующего введения в веб разработку на Ruby on Rails. Его предыдущий опыт включает в себя написание и разработку RailsSpace - чрезвычайно устаревшего учебника по Rails и разработку Insoshi - некогда популярной, а ныне устаревшей платформы для социальных сетей написанной на Ruby on Rails. В 2011, Майкл получил Ruby Hero Award за его вклад в Ruby сообщество. Он закончил Harvard College, имеет степень Кандидата Физических Наук присвоенную в Caltech и является выпускником предпринимательских курсов Y Combinator.

Копирайт и лицензия

Ruby on Rails Tutorial: Learn Web Development with Rails. Copyright © 2012 by Michael Hartl. Весь исходный код в Ruby on Rails Tutorial доступен под MIT License и Beerware License.

Лицензия MIT

Copyright (c) 2013 Michael Hartl

Данная лицензия разрешает лицам, получившим копию данного программного
обеспечения и сопутствующей документации (в дальнейшем именуемыми
«Программное Обеспечение»), безвозмездно использовать Программное
Обеспечение без ограничений, включая неограниченное право на использование,
копирование, изменение, добавление, публикацию, распространение,
сублицензирование и/или продажу копий Программного Обеспечения, также
как и лицам, которым предоставляется данное Программное Обеспечение,
при соблюдении следующих условий:

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

ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ, НО НЕ ОГРАНИЧИВАЯСЬ
ГАРАНТИЯМИ ТОВАРНОЙ ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И
ОТСУТСТВИЯ НАРУШЕНИЙ ПРАВ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ
НЕСУТ ОТВЕТСТВЕННОСТИ ПО ИСКАМ О ВОЗМЕЩЕНИИ УЩЕРБА, УБЫТКОВ ИЛИ ДРУГИХ
ТРЕБОВАНИЙ ПО ДЕЙСТВУЮЩИМ КОНТРАКТАМ, ДЕЛИКТАМ ИЛИ ИНОМУ, ВОЗНИКШИМ ИЗ,
ИМЕЮЩИМ ПРИЧИНОЙ ИЛИ СВЯЗАННЫМ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ ИЛИ ИСПОЛЬЗОВАНИЕМ
ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ ИЛИ ИНЫМИ ДЕЙСТВИЯМИ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
/*
 * ----------------------------------------------------------------------------
 * "ПИВНАЯ ЛИЦЕНЗИЯ" (Ревизия 42):
 * Весь код написан Майклом Хартлом. До тех пор пока вы осознаете это,
 * вы можете делать с ним все что захотите. Если мы когда нибудь
 * встретимся, и если это того стоило, вы можете купить мне
 * пиво в ответ.
 * ----------------------------------------------------------------------------
 */

Глава 1 От нуля к развертыванию

Добро пожаловать в Ruby on Rails Tutorial: Изучаем Rails на примерах. Цель этой книги состоит в том, чтобы стать лучшим ответом на вопрос: «Если я хочу изучить веб-разработку на Ruby on Rails, с чего я должен начать?». К тому времени, когда вы завершите Ruby on Rails Tutorial, вы будете иметь все знания необходимые для разработки и разворачивания собственных веб-приложений. Вы также будете готовы извлечь выгоду из многих более продвинутых книг, блогов и видеороликов, которые являются частью процветающей образовательной экосистемы Rails. Наконец, так как Учебное руководство Ruby on Rails использует Rails 3, информация, которую вы получаете здесь, будет полностью актуализирована с самой последней версией Rails.1

Ruby on Rails Tutorial следует, по существу, тому же подходу, что и моя предыдущая книга о Rails,2 обучение веб-разработке на Rails путём создания реального приложения с нуля. Как отмечает Дерек Сиверс в предисловии, эта книга представляет из себя линейное повествование, поэтому ее следует читать от начала до конца. Если вы привыкли прыгать в технических книгах, применение этого линейного подхода может потребовать от вас некоторой корректировки, но я предлагаю попробовать. Вы можете думать о Ruby on Rails Tutorial как о видео-игре, где вы – главный герой, получающий новый уровень, как Rails разработчик, в каждой главе. (упражнения – это минибоссы)

В этой первой главе мы начнем изучение Ruby on Rails, с установки всего необходимого программного обеспечения и инсталляции нашей среды разработки (Раздел 1.2). Затем мы создадим наше первое приложение Rails, названное (достаточно подходяще) first_app. Rails Tutorial прививает хорошие навыки программирования, так что сразу после создания нашего свежего нового проекта Rails, мы поместим его в управление версиями с Git (Раздел 1.3). И, верите вы в это или нет, в этой главе, мы даже разместим наше первое приложение в веб, развернув его в продакшен (Раздел 1.4).

В Главе 2, мы сделаем второй проект, целью которого будет демонстрация основ работы Rails приложения. Чтобы быстро стартануть, мы создадим это демонстрационное приложение (названное demo_app) используя scaffolding (Блок 1.1) для генерации кода; так как этот код и уродлив и сложен, в Главе 2 мы сосредоточимся на взаимодействии с демонстрационным приложением через его URL3 используя веб-браузер.

В Главе 3, мы создадим пример приложения (названного sample_app), на сей раз написав весь код с нуля. Мы разработаем демонстрационное приложение, используя разработку через тестирование (test-driven development) (TDD), начнем Главу 3 созданием статических страниц, затем добавим немного динамического контента. В Главе 4 мы немного познакомимся с языком программирования Ruby, лежащем в основе Rails. Затем, с Главы 5 по Главу 10, мы завершим основу для примера приложения, сделав макет сайта, модель данных пользователя, и полные регистрационную и аутентификационную системы. Наконец, в Главе 11 и Главе 12 мы добавим микроблогинг и социальные функции, чтобы сделать рабочий пример сайта.

Конечный пример приложения будет иметь большое сходство с одним популярным сайтом – который, по совпадению, изначально был также написан в Rails.4 Хотя, по необходимости, наши усилия и сосредоточатся на этом конкретном примере приложения, на протяжении Учебника Rails акцент будет на общих принципах, так, чтобы у вас был прочный фундамент независимо от того, какие виды веб-приложений вы хотите создавать.

1.1 Введение

Со времен своего дебюта в 2004 году, Ruby on Rails быстро стал одним из самых мощных и популярных фреймворков для построения динамических веб-приложений. Пользователи Rails охватывают широкий диапазон задач, начиная со стартапов и заканчивая огромными компаниями: Posterous, UserVoice, 37signals, Shopify, GitHub, Scribd, Hulu, Yellow Pages—вот список сайтов, использующих Rails и он все пополняется и пополняется. Также существуют веб-магазины по разработке, специализирующиеся на Rails, такие как ENTP, thoughtbot, Pivotal Labs, и Hashrocket, плюс бесчисленные независимые консультанты, преподаватели и контрагенты.

Что же делает Rails таким замечательным? Во-первых, Ruby on Rails на сто процентов открыт, доступен в силу MIT License, и, как результат, его можно загружать и использовать бесплатно. Rails также обязан своим успехом своему изящному и компактному дизайну; используя податливость лежащего в его основе языка Ruby, Rails фактически создает предметно-ориентированный язык (domain-specific language) для написания веб-приложений. В результате много общих задач веб-программирования – таких как генерирование HTML, создание моделей данных и маршрутизация URL – легки с Rails, а результирующий код программ краток и читаем.

Rails также быстро адаптируется к новым тенденциям в веб-технологиях. Например, Rails был одним из первых, кто полностью реализовал архитектурный стиль REST для веб-приложений. И когда другие фреймворки успешно разрабатывают новые техники, создатель Rails David Heinemeier Hansson и рабочая группа Rails не стесняются использовать их идеи. Пожалуй, наиболее ярким примером является слияние Rails и Merb (конкурирующая веб-платформа), так что Rails теперь получает преимущества от модульной конструкции Merb, стабильного API, а также повышенной производительности.(Любой, кто следил за переговорами между разработчиком Merb и членом рабочей группы Rails Yehuda Katz не может не заметить, что чрезвычайно хорошей идеей было принять на борт команду Merb.)

Наконец, Rails выигрывает от необычайно увлечённого и разнообразного сообщества. Результаты: сотни open-source соразработчиков, хорошо посещаемые конференции, огромное количество плагинов и гемов (автономные решения конкретных проблем, таких как постраничный вывод, и загрузка изображений), богатый набор информативных блогов, и рог изобилия форумов и каналов IRC. Большое количество активных программистов Rails также облегчает обработку неизбежных ошибок приложений: алгоритм – “Ищи в Google сообщение об ошибке” – почти всегда добывает соответствующее сообщение в блоге или ветке форума.

1.1.1 Комментарии для разных читателей

Учебник Rails содержит интегрированные учебники не только по Rails, но и по лежащему в его основе Ruby, а также HTML, CSS, немного JavaScript, и даже чуть чуть SQL. Это означает, что, независимо от ваших знаний веб-разработки, к моменту завершения этого учебника вы будете готовы для более продвинутых Rails ресурсов, а также к более систематичной проработке других упомянутых тем.

Rails получает большую часть своей силы от «магии», то есть от функций платформы (таких, как автоматическое добавление атрибутов объекта из столбцов базы данных), совершающих чудеса, но чьи механизмы могут быть весьма таинственными. Учебник Ruby on Rails не ставит своей целью объяснение всех этих чудес - главным образом, потому что большинству разработчиков приложений Rails никогда не понадобится знать, что находится за занавесом. (В конце концов, сам Ruby главным образом (по большей части) пишется на языке программирования C, но вы не должны копаться в исходниках C, чтобы использовать Ruby.) Если вы - неисправимый "сдергиватель занавесов", я рекомендую книгу The Rails 3 Way Оби Фернандеса в качестве сопроводительной литературы к Ruby on Rails Tutorial.

Хотя у этой книги нет никаких формально обязательных требований, вы должны иметь, по крайней мере некоторый опыт работы с компьютером. Если вы никогда раньше не использовали даже текстовый редактор, будет тяжело, но если у вас достаточно решимости вы, вероятно, дойдёте до конца. Если, с другой стороны, ваш .emacs файл настолько сложен, что может заставить плакать взрослого мужчину, есть все еще много материалов, для вашего развития. Rails Tutorial предназначен для обучения разработке на Rails вне зависимости от ваших знаний, но ваш путь и впечатление от чтения будут зависеть от ваших индивидуальных обстоятельств.

Все читатели: Один общий вопрос при изучении Rails состоит в том, изучить ли Ruby сначала. Ответ зависит от вашего персонального стиля обучения. Если вы предпочитаете изучать все систематически и с нуля, то вам возможно стоит начать с изучения Ruby и в этом разделе есть несколько книжных рекомендаций для вас. С другой стороны, много начинающих Rails разработчиков вдохновляются созданием веб-приложений, и скорее всего не станут сидеть над книгой в 500 страниц о чистом Ruby прежде чем написать единственную веб-страницу. Кроме того, приёмы, необходимые для Rails разработчиков отличаются от тех, что вы найдете во введении в язык Ruby, тогда как Rails Tutorial посвящен именно приёмам работы с Rails. Если ваш основной интерес заключается в написании веб-приложений, то я рекомендую начать с Rails Tutorial, а затем уже браться за книги по чистому Ruby. Это не бескомпромиссное предложение: если вы начнете читать Учебное руководство Rails и почувствуете что ваше (отсутствующее) знание Ruby, сдерживает вас, без опасений переключайтесь на книгу по Ruby и возвращайтесь, когда почувствуете себя готовым. Вы можете также познакомиться с Ruby, следуя коротким онлайновым учебным руководствам, вроде тех что могут быть найдены на http://www.ruby-lang.org/ или http://rubylearning.com/.

Другой распространенный вопрос, состоит в том, стоит ли использовать тестирование с самого начала. Как было отмечено во введении, Rails Tutorial использует разработку через тестирование (также называемую "сначала тест" разработкой), которая по моему мнению является лучшим способом разработки Rails приложений, но это действительно привносит значительный объем работы и сложностей. Если вы обнаружили себя застрявшим на тестировании, не стесняйтесь пропустить его при первом прочтении.5 Действительно, некоторые читатели могут запутаться в таких вещах, как тестирование, системе контроля версий, а также в развертывании приложения, если вы не найдете в себе энергии по любому из этих шагов, пожалуйста, пропустите их. Хотя у меня включен только материал, который я считаю чрезвычайно важным для разработки профессиональных Rails приложений, только код основного приложения является строго необходимым в первое время.

Неопытные программисты (не дизайнеры): Учебник Rails не предполагает наличие других знаний, кроме общей компьютерной грамотности, поэтому, если у вас ограниченный опыт программирования, то эта книга является хорошим стартом. Пожалуйста, имейте в виду, что это только первый шаг на долгом пути; веб-разработка включает в себя множество вопросов, таких как HTML / CSS, JavaScript, базы данных (включая SQL), системы контроля версиями и развертывание. Эта книга содержит лишь краткое введение в эти вопросы, но еще многое нужно изучать дополнительно.

Неопытные программисты (веб дизайнеры): ваши навыки веб дизайна будут вам большим подспорьем, поскольку вы уже, вероятно, знаете HTML и CSS. После прочтения этой книги вы будете готовы работать с увлекательными проектами Rails и у вас будет возможность начать собственный проект. Вы можете обнаружить материал программирования непростым, но язык Ruby необычайно дружелюбен к новичкам, особенно к тем, у кого есть художественные наклонности.

После окончания Ruby on Rails Учебника, я рекомендую, малознакомое программистам чтиво Beginning Ruby Питера Купера, который отчасти использует ту же самую основную концепцию обучения что и Rails Учебник. Я также рекомендую The Ruby Way Хэла Фултона. Наконец, чтобы получить более глубокое понимание Rails, я рекомендую The Rails 3 Way Оби Фернандеса.

Веб-приложения, даже относительно простые, по своей природе довольно сложны. Если вы абсолютный новичок в веб-программировании и Учебник Rails для вас слишком сложен, вполне возможно, что вы все же не совсем готовы к созданию веб-приложений. В этом случае я предложил бы вам изучить основы HTML и CSS, а затем дать Учебнику Rails еще один шанс. (К сожалению, здесь у меня нет персональной рекомендации, но Head First HTML выглядит многообещающе, и один читатель рекомендовал CSS: The Missing Manual (автор - David Sawyer McFarland). Вы могли бы также рассмотреть чтение первых нескольких глав Beginning Ruby, которое начинается с примеров, намного меньших нежели развитое веб-приложение.

Опытные программисты, плохо знакомые с веб-разработкой: ваш предшествующий опыт означает, что вы, вероятно, уже понимаете такие идеи как классы, методы, структуры данных, и т.д., что является большим преимуществом. Предупреждаю, что, если вы ранее программировали на C/C ++ или Java, вы можете найти Ruby немного странным, и может потребоваться некоторое время, чтобы привыкнуть к нему; в конце концов вы справитесь. (Ruby даже позволит вам помещать точки с запятой в конце строк, если вы сильно по ним скучаете.) Учебное руководство Rails освещает все веб-специфичные идеи, которые вам нужны, так что не волнуйтесь, что не знаете в настоящий момент чем отличается PUT от POST.

Опытные веб-разработчики, плохо знакомые с Rails: у вас есть большое преимущество, особенно если вы ранее использовали динамический язык, такой как PHP или (даже лучше) Python. Основа того, что мы освещаем, вероятно, будет знакома, но разработка через тестирование может оказаться в новинку для вас, как может быть и структурно оформленный REST стиль, излюбленный Рельсами. У Ruby есть свои собственные характерные особенности, так что они, вероятно, также будут в новинку.

Опытные Ruby программисты: группа Ruby программистов, которые не знают Rails, является в настоящее время довольно малочисленной, но если вы - член этой элитной группы, можете пролистать эту книгу, а затем перейти к The Rails 3 Way Оби Фернандеса.

Неопытные программисты Rails: вы, возможно, читали некоторые другие учебные руководства и сделали несколько небольших Rails приложений самостоятельно. Основываясь на отзывах читателей, я уверен, что вы можете многое почерпнуть из этой книги. Между прочим, методы здесь могут оказаться более актуальными чем те, которые вы добыли, когда первоначально изучали Rails.

Опытные программисты Rails: Эта книга не нужна вам, но многие опытные разработчики Rails удивляются тому сколько нового они узнают из этой книги, к тому же вам может понравиться посмотреть на Rails с другой точки зрения.

После прочтения Учебника Ruby on Rails я рекомендую опытным (не-Ruby) программистам почитать The Well-Grounded Rubyist автора David A. Black, это отличный глубокий материал, описывающий Rails с самых основ, или The Ruby Way Хэла Фултона, который также имеет высокий уровень, но проявляет более актуальный подход. Затем переходите на The Rails 3 Way для углубления ваших знаний о Rails.

В конце этого процесса, независимо от того где вы начали, вы будете готовы к более-менее продвинутым ресурсам Rails. Вот некоторые из тех, что я особенно рекомендую:

  • Railscasts: Замечательные бесплатные Rails скринкасты (# очень рекомендую их качественный перевод на русский на http://www.railscasts.ru/ )
  • PeepCode, Pragmatic.tv, EnvyCasts: Замечательные платные скринкасты
  • Rails Guides: Хорошие актуальные и обновленные Rails руководства. Учебник Rails часто рекомендует Rails Guides для более углубленного изучения определенных тем.( # их перевод можно найти на http://www.rusrails.ru/ )
  • Rails блоги: Слишком много, чтобы составить их список, но там содержатся тонны полезной информации.

1.1.2 “Масштабирование” Rails

Прежде чем двигаться дальше, я хотел бы воспользоваться моментом для решения одного вопроса, преследовавшего Rails прежде всего в первые дни его существования: мнимая неспособность Rails к «масштабируемости», то есть к обработке большого трафика. Частично этот вопрос опирается на заблуждение; вы масштабируете сайт, а не фреймворк, и Rails, каким бы обалденным не был – лишь фреймворк. Таким образом, реальный вопрос должен звучать так: «Может ли сайт построенный на Rails масштабироваться?» В любом случае, на этот вопрос теперь можно окончательно ответить утвердительно: некоторые из наиболее нагруженных сайтов в мире используют Rails. Вообще масштабирование выходит за рамки Rails, но будьте уверены, что если вашему приложению нужно будет справиться с нагрузкой как у Hulu либо как у Yellow Pages, Rails не помешает вам покорить мир.

1.1.3 Соглашения в этой книге

Соглашения в этой книге главным образом очевидны; в этом разделе я упомяну лишь те которые, возможно, таковыми не являются.

И HTML и PDF выпуски этой книги полны ссылками, как к внутренним разделам (таким как Раздел 1.2) так и к внешним сайтам (таким как основная страница загрузки Ruby on Rails ).6

Много примеров в этой книге используют командную строку. Для простоты, все примеры командной строки используют приглашение командной строки в Unix-стиле (знак доллара):

$ echo "hello, world"
hello, world

Пользователи Windows должны понимать, что их системы будут использовать в качестве приглашения угловую скобку >:

C:\Sites>echo hello, world
hello, world

В Unix системах некоторые команды должны быть выполнены с sudo (от “substitute user do”). По умолчанию, команда выполняемая с sudo выполняется как команда администратора у которого есть доступ к файлам и каталогам которые недоступны обычному пользователю, таким как в этом примере из Раздела 1.2.2:

$ sudo ruby setup.rb

Большинство систем Unix/Linux/OS X требует sudo по умолчанию, за исключением использования Ruby Version Manager как рекомендуется в Разделе 1.2.2.3; в этом случае вы можете писать:

$ ruby setup.rb

Rails поставляется с большим количеством команд, которые можно запустить в командной строке. Например, в Разделе 1.2.5 мы запускаем локальный веб-сервер разработки следующим образом:

$ rails server

Как и с приглашением командной строки, Учебник Rails использует конвенцию Unix для разделителей каталога (то есть, косую черту наклоненную вправо /). Мой пример приложения из Учебника Rails, например, живет в

/Users/mhartl/rails_projects/sample_app

На Windows аналогичный каталог выглядел бы

C:\Sites\sample_app

Корневой каталог для любого приложения называется Rails root, и впредь все каталоги будут относительно этого каталога. (Отметьте в особенности, что “Rails root” не является корневым каталогом для Rails непосредственно.) Например, каталог config моего примера приложения это

/Users/mhartl/rails_projects/sample_app/config

Корень Rails здесь - все что перед config, то есть,

/Users/mhartl/rails_projects/sample_app

Для краткости, при обращении к файлу

/Users/mhartl/rails_projects/sample_app/config/routes.rb

я пропущу корень Rails и просто запишу config/routes.rb.

Наконец, Учебник Rails часто показывает вывод из различных программ (команды оболочки, статус управления версиями, программ Ruby, и т.д.). Из-за неисчислимых небольших различий между различными компьютерными системами, вывод, который вы увидите, возможно, не всегда совпадет в точности с тем, который показывают в тексте, но это не повод для беспокойства. Кроме того, некоторые команды могут вызывать ошибки зависящие от вашей системы; вместо того, чтобы пытаться выполнить Сизифову задачу документирования всех таких погрешностей в этом учебном руководстве, я делегирую к алгоритму “Ищи в Google сообщение об ошибке”, который между прочим является весьма хорошей практикой для реального программирования.

1.2 За работу

Пришло время, чтобы взяться за дело со средой разработки Ruby on Rails и нашим первым приложением. Здесь будет немного лишних действий, особенно если у вас нет большого опыта программирования, так что не разочаровывайтесь, если вам понадобится потратить какое-то время прежде чем вы сможете начать работу. Это не только вы; каждый разработчик проходит через это (часто не раз), но будьте уверены, что эти усилия будут щедро вознаграждены.

1.2.1 Среда разработки

Принимая во внимание различные своеобразные настройки и предпочтения, вероятно, существует столько вариантов сред разработки, сколько и Rails программистов, но есть, по крайней мере, две общие темы: текстовый редактор/командная строка и интегрированная среда разработки (IDE). Рассмотрим последнюю первой.

IDE

В IDE для Rails дефицита нет, основные – RadRails, RubyMine, и 3rd Rail. Все они кросс-платформенные, и я слышал хорошие вещи о некоторых из них. Я призываю вас попробовать их и посмотреть, подходят ли они вам, но признаюсь: я ниразу не встречал IDE, которая удовлетворяла бы все мои потребности в сфере разработки на Rails - а некоторые IDE я даже не смог запустить.

Текстовые редакторы и инструменты командной строки

Чем же мы должны пользоваться для разработки приложений Rails, если не какой-либо из грозных IDE все-в-одном? Я думаю, большинство Rails разработчиков выбирают то же, что и я: использовать текстовый редактор для редактирования текста, а командную строку для выполнения команд (Рис. 1.1). Их комбинация зависит от ваших предпочтений и платформы:

  • Macintosh OS X: Подобно многим разработчикам на Rails, я предпочитаю TextMate. Другие дополнительные варианты включают Emacs и MacVim (запускаемый командой mvim), великолепную Макинтош-версию Vim. 7 Я использую iTerm для терминала командной строки; другие превосходно довольствуются встроенным приложением Terminal.
  • Linux: ваш выбор редакторов в основном аналогичен OS X, за исключением TextMate. Я рекомендовал бы графический Vim (gVim), gedit (с плагинами GMate), или Kate. Что касается командной строки - вы полностью упакованы: каждый дистрибутив Linux идет, по крайней мере, с одним терминальным приложением командной строки (а часто и с несколькими).
  • Windows: Есть несколько многообещающих редакторов для Windows включая Vim, E Text Editor, Komodo Edit, и Sublime Text. Для командной строки я рекомендую использовать ту, которая идет с Rails Installer (Раздел 1.2.2.1).

Если вы поклонник Vim, не забудьте присоединиться к процветающему сообществу использующих Vim Rails хакеров. Особенно обратите внимание на rails.vim расширение и NERD tree project drawer (??).

editor_shell
Рисунок 1.1: Среда разработки «текстовый редактор /командная строка« (TextMate/iTerm). (полный размер)

Браузеры

Хотя среди веб-браузеров есть из чего выбрать, подавляющее большинство программистов Rails используют Firefox, Safari, или Chrome, при разработке. Скриншоты в Учебнике Rails обычно сделаны в браузере Firefox. Если вы используете Firefox, я советую использовать Firebug надстройку, которая позволяет выполнять все виды магии, такие как динамическая проверка (и даже редактирование) структуры HTML и CSS правил на любой странице. Для тех, кто не использует Firefox, Firebug Lite работает с большинством других браузеров, а у Safari и Chrome есть встроенная, «Просмотр кода элемента» функция, доступная по щелчку правой кнопкой мыши на любой части страницы.

Примечание об инструментах

В процессе становления и запуска вашей среды разработки, вы можете обнаружить, что вы тратите много времени, на получение правильных навыков работы. Процесс обучения для редакторов и IDE особенно длинен; можно потратить недели на TextMate или одни только учебные руководства Vim. Если вы плохо знакомы с этим делом, я хочу уверить вас, что тратить время на изучение инструментов - это нормально. Все проходят через это. Иногда это печалит, и раздражает, особенно когда у вас в голове есть потрясающее веб-приложение, и вы просто хотите выучить Rails, но тратите неделю изучая некий таинственный древний редактор Unix только чтобы начать. Но мастер должен знать свои инструменты; в итоге усилия будут вознаграждены.

1.2.2 Ruby, RubyGems, Rails, и Git

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

Rails Installer (Windows)

Установка Rails на Windows применялась раньше как орудие пыток, но благодаря усилиям хороших людей в Engine Yard—особенно Dr. Nic Williams и Wayne E. Seguin—установка Rails и связанного программного обеспечения на Windows, теперь невероятно легка. Если вы используете Windows, перейдите на Rails Installer (http://rubyforge.org/frs/download.php/75114/railsinstaller-1.3.0.exe) и загрузите исполняемый файл Rails Installer. Дважды кликните исполняемый файл и следуйте инструкциям, чтобы установить Git (таким образом, можете пропустить Раздел 1.2.2.2), Ruby (пропустите Раздел 1.2.2.3), RubyGems (пропустите Раздел 1.2.2.4), и, непосредственно, Rails (пропустите Раздел 1.2.2.5). Как только установка закончится, можете перейти к созданию первого приложения в Разделе 1.2.3.

Установка Git

Большая часть экосистемы Rails так или иначе зависит от системы управления версиями называемой Git (освещаемой более подробно в Разделе 1.3). Поскольку его использование является повсеместным, следует установить Git даже на этой ранней стадии; я предлагаю следовать инструкциям по установке для вашей платформы в разделе Установка Git (Pro Git).

Установка Ruby

Следующий шаг это установка Ruby. Возможно, он уже есть в вашей системе; попытайтесь выполнить

$ ruby -v
ruby 1.9.2

чтобы увидеть номер версии. Rails 3 требует Ruby 1.8.7 или выше и работает лучше всего с Ruby 1.9.2. Это учебное руководство предполагает, что бОльшая часть читателей использует самую свежую стабильную версию Ruby 1.9.2, но Ruby 1.8.7 также должен работать. В частности, пользователи Windows запустившие Rails Installer 1.3.0 получат Ruby 1.8.7 как часть их установки.

Ветка Ruby 1.9 находится в интенсивной разработке, поэтому, к сожалению, установка последней версии может оказаться непростой задачей. Вам придётся полагаться на интернет чтобы найти самые современные инструкции. Ниже приводится ряд шагов, после которых я привёл всё в рабочее состояние на моей системе (Macintosh OS X), но вам, возможно, придётся повозиться.

Как часть установки Ruby, если вы используете OS X или Linux, я строго рекомендую устанавливать Ruby с использованием Ruby Version Manager (RVM), который позволит вам устанавливать и управлять различными версиями Ruby на одной машине. (Проект Pik совершает подобный подвиг для Windows.) Это особенно важно, если вы хотите запускать Rails 3 и Rails 2.3 на одной машине. Если вы хотите пойти этим маршрутом, я предлагаю использовать RVM для установки двух Ruby/Rails комбинаций: Ruby 1.8.7/Rails 2.3.10 и Ruby 1.9.2/Rails 3. Если вы столкнетесь с какими-либо проблемами с RVM, вы часто можете найти его создателя, Wayne E. Seguin, на канале IRC RVM (#rvm на freenode.net).8

После установки RVM, вы можете установить Руби следующим образом:9

$ rvm get head
$ rvm reload
$ rvm install 1.8.7
$ rvm install 1.9.2
<придется немного подождать>

Здесь первые две команды обновляют и перезагружают сам RVM, что является полезной практикой так как RVM часто обновляется. Финальные две команды выполняют установку Ruby; в зависимости от вашей системы они могут потребовать времени для загрузки и компиляции, так что не волнуйтесь, если покажется, что это займет целую вечность. (Также предостерегу, что много маленьких вещей может пойти не так. Например, на моей системе самая последняя версия Ruby 1.8.7 не захотела компилироваться; вместо этого, после большого поиска и рукоприкладства, я обнаружил, что нуждался в “patchlevel” номер 302:

$ rvm install 1.8.7-p302

Когда вещи вроде этой происходят с вами, это всегда расстраивает, но теперь вы, по крайней мере, знаете, что это происходит со всеми…)

Программы Ruby обычно распространяются посредством гемов, которые являются автономными пакетами Ruby-кода. Так как гемы с различными номерами версий иногда конфликтуют, часто удобно создать отдельные gemsets, которые являются автономными пакетами гемов. В частности Rails распространяется как гем, и есть конфликты между Rails 2 и Rails 3, поэтому, если вы хотите использовать различные версии Rails на одной системе, вы должны создать отдельный gemset для каждого:

$ rvm --create 1.8.7-p302@rails2tutorial
$ rvm --create use 1.9.2@rails3tutorial

Здесь первая команда создает gemset rails2tutorial связанный с Ruby 1.8.7-p302 , в то время как вторая команда создает gemset rails3tutorial связанный с Ruby 1.9.2 и одновременно запускает его (посредством команды use). RVM поддерживает много различных команд для того, чтобы манипулировать gemsets; см. документацию в http://rvm.beginrescueend.com/gemsets/.

В этом учебном руководстве мы хотим, чтобы наша система использовала Ruby 1.9.2 и Rails 3 по умолчанию, чего мы можем добиться следующим образом:

$ rvm --default use 1.9.2@rails3tutorial

Что одновременно устанавливает использование Ruby 1.9.2 и gemset rails3tutorial к нему по умолчанию.

Кстати, если вы когда-либо застрянете с RVM, выполнение этих команд может помочь вам:

$ rvm --help
$ rvm gemset --help

Установка RubyGems

RubyGems это диспетчер пакетов для проектов Ruby, и есть тонны замечательных библиотек (включая Rails) доступных как пакеты Ruby, или gem. Установка RubyGems должна быть легкой, раз уж вы установили Ruby. Фактически, если вы установили RVM, у вас уже есть RubyGems, так как RVM включает его автоматически:

$ which gem
/Users/mhartl/.rvm/rubies/ruby-head/bin/gem

Если у вас еще нет его, следует загрузить RubyGems, извлечь его, и затем перейти в rubygems каталог и выполнить программу установки:

$ ruby setup.rb

(Если вы получили здесь ошибку связанную с правами доступа (permissions error), вспомните про Раздел 1.1.3 где написано что вам может потребоваться команда sudo.)

Если вы уже устанавливали RubyGems, вы можете захотеть обновить свою систему до версии, используемой в этом учебнике:

$ gem update --system 1.8.5

Если вы используете Linux Ubuntu, вы можете захотеть посмотреть Ubuntu/Rails 3.0 сообщение в блоге Toran Billups для изучения полных инструкций по установке.

При установке гемов, RubyGems по умолчанию генерирует два различных вида документации (так называемые ri и rdoc), но многие Ruby и Rails разработчики считают, что время, затрачиваимое на их установку не стоит выгоды. (Многие программисты полагаются на онлайн-документацию, а не на нативные ri и rdoc документы.) Для предотвращения автоматической генерации документации, я рекомендую создать файл конфигурации, называемый .gemrc (находится (located) в вашем домашнем каталоге) со строкой из Листинга 1.1.

Листинг 1.1. Подавление ri и rdoc документации с помощью .gemrc.
gem: --no-ri --no-rdoc

Установка Rails

Поскольку вы уже установили RubyGems, установка Rails 3 должна быть легкой. Этот учебник использует Rails 3.0.12 и мы можем установить их следующим образом:

$ gem install rails --version 3.0.12

Чтобы проверить, что это работает, выполните следующую команду:

$ rails -v
Rails 3.0.12

Последней версией Rails на данный момент является Rails 3.2. Для целей этого учебника, Rails 3.0 в настоящий момент является более предпочтительным, в основном это связано с тем что экосистеме всегда требуется некоторое время для того чтобы адаптироваться к новой версии фреймворка. Кроме того, для целей начального обучения Rails, Rails 3.0 и 3.2 практически идентичны, так что почти все что вы узнаете здесь будет применимо и к Rails 3.2 приложениям.

Есть несколько обратно-несовместимых изменений в Rails 3.1, о которых вы можете узнать в Главе 13. В Rails 3.1 есть также некоторые новые возможности и они вкратце описаны в Главе 13, которая также содержит ссылки на ресурсы, рассказывающие о них более подробно. Наконец, будущее издание этой книги (и новая версия сопутствующих скринкастов) будет использовать Rails 3.1 с самого начала, предположительно, включая введение в его новые фичи (такие как Sass и CoffeeScript).

1.2.3 Первое приложение

Фактически все приложения Rails начинают одинаково - с команды rails. Эта удобная программа создает скелет приложения Rails в любом каталоге на ваш вкус. Для начала создайте каталог для своих проектов Rails, а затем выполните команду rails, чтобы создать первое приложение:

Листинг 1.2. Запуск rails скрипта , для генерации нового приложения.
$ mkdir rails_projects
$ cd rails_projects
$ rails new first_app
      create  
      create  README
      create  .gitignore
      create  Rakefile
      create  config.ru
      create  Gemfile
      create  app
      create  app/controllers/application_controller.rb
      create  app/helpers/application_helper.rb
      create  app/views/layouts/application.html.erb
      create  app/models
      create  config
      create  config/routes.rb
      create  config/application.rb
      create  config/environment.rb
      .
      .
      .

Отметьте, сколько файлов и каталогов создает команда rails. Эта стандартная структура файлов и каталогов (Рис. 1.2) является одним из многих преимуществ Rails; это немедленно переносит вас от нуля к действующему (минимально) приложению. Кроме того, так как эта структура является общей для всех приложений Rails, можно сразу сориентироваться, глядя на чей-либо код. Обзор дефолтных Rails файлов представлен в Таблице 1.1; мы узнаем о большинстве этих файлов и каталогов в остальной части этой книги.

directory_structure_rails_3
Рисунок 1.2: Структура каталогов недавно вылупившегося Rails приложения. (полный размер)
Файл/КаталогНазначение
app/Базовый код приложения, включает модели, представления, контроллеры, и помощники (хелперы)
config/Конфигурация приложения
db/Файлы для манипуляций с базой данных
doc/Документация для приложения
lib/Модули библиотек
log/log файлы приложения
public/Публично доступные данные (например, веб-браузерам), такие как изображения и каскадные таблицы стилей (CSS)
script/railsСценарии, предоставляемые Rails для генерирования кода, открытия консольных сессий, или запуска локального веб-сервера
test/Тесты приложения (ему на смену придет spec/ директория в Разделе 3.1.2)
tmp/Временные файлы
vendor/Сторонний код, такой как плагины и гемы
READMEКраткое описание (инструкция по использованию) приложения
RakefileСлужебные задачи, доступные через rake-команду
GemfileГемы необходимые для этого приложения
config.ruКонфигурационный файл для Rack middleware
.gitignoreПеречень файлов, которые должны игнорироваться Git
Таблица 1.1: Обзор дефолтной структуры каталогов Rails.

1.2.4 Bundler

После создания нового Rails приложения следующий шаг – использование Bundler, для установки и включения гемов, необходимых приложению. Что подразумевает открытие Gemfile в вашем любимом текстовом редакторе:

$ cd first_app/
$ mate Gemfile

Результат должен выглядеть примерно как Листинг 1.3.

Листинг 1.3. Дефолтный Gemfile в first_app каталоге.
source 'http://rubygems.org'

gem 'rails', '3.0.12'

# Bundle edge Rails instead:
# gem 'rails', :git => 'git://github.com/rails/rails.git'

gem 'sqlite3'

# Use unicorn as the web server
# gem 'unicorn'

# Deploy with Capistrano
# gem 'capistrano'

# To use debugger
# gem 'ruby-debug'

# Bundle the extra gems:
# gem 'bj'
# gem 'nokogiri', '1.4.1'
# gem 'sqlite3'
# gem 'aws-s3', :require => 'aws/s3'

# Bundle gems for certain environments:
# gem 'rspec', :group => :test
# group :test do
#   gem 'webrat'
# end

Большинство этих строк закомментированы символом хеш #; они здесь для того, чтобы показать вам некоторые обычно необходимые гемы и дать примеры синтаксиса Bundler. Сейчас нам не понадобятся никакие гемы кроме дефолтных: Rails как таковой, и гем для взаимодействия Ruby с базой данных SQLite.

Если вы не укажете номер версии gem-команде, Bundler автоматически установит самую последнюю версию. К сожалению, обновления гемов часто вызывают незначительные, но потенциально сбивающие с толку поломки, так что, в этом учебном руководстве мы обычно будем явно включать номер версии известной как работавшей, как видно в Листинге 1.4.10

Листинг 1.4. Gemfile с явной версией sqlite3 гема.
source 'http://rubygems.org'

gem 'rails', '3.0.12'
gem 'sqlite3', '1.3.3'

Это преобразует строку

gem 'sqlite3'

из Листинга 1.3 в

gem 'sqlite3', '1.3.3'

что принуждает Bundler, к установке версии 1.3.3 гема sqlite3. (Отметьте, что вам нужна версия 1.2.5 гема sqlite3-ruby если вы используете OS X Leopard:

gem 'sqlite3-ruby', '1.2.5', :require => 'sqlite3'

Это связано с тем, что последняя версия гема, теперь называемая просто sqlite3, требуется для компиляции Snow Leopard или более поздним версиям.)

Если вы используете Linux Ubuntu, вам, возможно, придется установить несколько других пакетов в этом пункте:11

$ sudo apt-get install libxslt-dev libxml2-dev libsqlite3-dev    # Linux only

Как только вы составили надлежащий Gemfile, установите гемы, используя bundle install:12

$ bundle install
Fetching source index for http://rubygems.org/
.
.
.

Это может занять некоторое время, но когда это будет сделано, наше приложение, будет готово к работе.

1.2.5 rails server

Благодаря выполнению rails new в Разделе 1.2.3 и bundle install в Разделе 1.2.4, у нас уже есть приложение, которое мы можем запустить—но как? К счастью, Rails поставляется с программой командной строки, или скриптом, который запускает локальный веб-сервер,13 видимый только на вашей рабочей машине:14

$ rails server
=> Booting WEBrick
=> Rails 3.0.12 application starting on http://0.0.0.0:3000
=> Call with -d to detach
=> Ctrl-C to shutdown server

Это говорит нам, что приложение запущено в порту номер 300015 по адресу 0.0.0.0. Этот адрес говорит компьютеру прослушивать каждый доступный IP-адрес, сконфигурированный на этой конкретной машине; в частности мы можем просмотреть приложение, используя специальный адрес 127.0.0.1, который также известен как localhost. Мы можем видеть результат посещения http://localhost:3000/ на Рис. 1.3.16

riding_rails_3
Рисунок 1.3: Дефолтная страница Rails (http://localhost:3000/). (полный размер)

Чтобы увидеть информацию о нашем первом приложении, щелкните по ссылке “About your application’s environment”. Результат показан на Рис. 1.4.17

riding_rails_3_environment
Рисунок 1.4: Дефолтная страница Rails (http://localhost:3000/) со средой приложения. (полный размер)

Очевидно, что, в конечном итоге, дефолтная страница Rails нам не нужна, но сейчас приятно видеть, ее работающей. Мы удалим эту дефолтную страницу (и заменим ее пользовательской домашней страницей), в Разделе 5.2.2.

1.2.6 Модель-представление-контроллер (MVC)

Даже на этой ранней стадии, полезно получить общее представление о том, как работают приложения Rails (Рис. 1.5). Вы, возможно, заметили, что в стандартной структуре приложения Rails (Рис. 1.2) есть папка приложения, названная app/ с тремя подкаталогами: models, views, и controllers. Это намек на то, что Rails следует архитектурной схеме модель-представление-контроллер (MVC), которая осуществляет разделение между “логикой предметной области” (также называемой “бизнес-логикой”) от логики ввода и логики представления, связанной с графическим интерфейсом пользователя (GUI). В случае веб-приложений, “логика предметной области” обычно состоит из модели данных для таких вещей как пользователи, статьи, продукты, а GUI это просто веб-страница в браузере.

Взаимодействуя с приложением Rails, браузер отправляет запрос, который принимается веб-сервером и передается контроллеру Rails, отвечающему за то, что делать дальше. В некоторых случаях контроллер сразу визуализирует представление, которое является шаблоном, конвертирующим полученное в HTML и отсылающим назад к браузеру. Более обычно для динамичных сайтов, когда контроллер взаимодействует с моделью, которая является объектом Ruby, который представляет собой элемент сайта (такой как пользователь) и отвечает за коммуникацию с базой данных. После вызова модели, контроллер затем визуализирует представление и возвращает полную веб-страницу браузеру как HTML.

mvc_schematic
Рисунок 1.5: Схематичное изображение модель-представление-контроллер (MVC) архитектуры.

Если это обсуждение кажется сейчас немного абстрактным, не беспокойтесь; мы будем часто возвращаться к этому разделу. В дополнение, в Разделе 2.2.2 есть более детальное обсуждение MVC в контексте демонстрационного приложения. Наконец, пример приложения будет использовать все аспекты MVC; мы осветим контроллеры и представления, в Разделе 3.1.2, модели начнутся в Разделе 6.1, и мы увидим, совместную работу триады в Разделе 6.3.2.

1.3 Управление версиями с Git

Теперь, когда у нас есть новое и рабочее приложение Rails, мы займем одну минуту для шага, который, хотя технически необязателен, видится многим разработчиками Rails как фактически обязательный, а именно, помещение исходного кода нашего приложения в систему управление версиями. Системы управления версиями позволяют нам отслеживать изменения кода нашего проекта, облегчают совместную работу, и могут откатывать любые непреднамеренные погрешности (такие как случайное удаление файлов). Грамотное использование системы управления версиями - необходимый навык для каждого разработчика программного обеспечения.

Есть много возможностей для управления версиями, но сообщество Rails в значительной степени стандартизировано под Git, распределенную систему управления версиями, первоначально разработанную Линусом Торвальдсом (Linus Torvalds), для размещения ядра Linux. Git – большая тема, и мы лишь слегка коснемся ее в этой книге, но есть много хороших бесплатных онлайн ресурсов; я особенно рекомендую Pro Git автора Scott Chacon (Apress, 2009). Помещение вашего исходного кода в систему управления версиями с Git строго рекомендуется, не только потому, что это почти универсальная практика в мире Rails, но также и потому что это позволит вам легко открыть доступ к вашему коду (Раздел 1.3.4) и развернуть ваше приложение прямо здесь в первой главе (Раздел 1.4).

1.3.1 Установка и настройка

Первый шаг это установка Git, если вы еще не выполнили шаги в Разделе 1.2.2.2. (Как отмечено в том разделе, это подразумевает следование инструкциям в Installing Git разделе Pro Git.)

Первоначальная настройка системы

После установки Git следует выполнить ряд разовых настроек. Это системные настройки, что означает, что их необходимо сделать лишь единожды:

$ git config --global user.name "Your Name"
$ git config --global user.email youremail@example.com

Мне также нравится использовать co вместо более громоздкой checkout команды, мы можем сделать это следующим образом:

$ git config --global alias.co checkout

Этот учебник будет обычно использовать полную checkout команду, которая работает на системах не имеющих co конфигурации, но в реальной жизни я почти всегда использую git co.

В качестве финального шага установки, можно дополнительно установить редактор который Git будет использовать для сообщений о фиксации (коммите). Если вы используете графический редактор, такой как TextMate, gVim, или MacVim, вы должны использовать флаг, чтобы быть уверенным, что редактор остается присоединенным к оболочке вместо того, чтобы отсоединиться сразу:18

$ git config --global core.editor "mate -w"

Замените "mate -w" на "gvim -f" для gVim или "mvim -f" для MacVim.

Первоначальная настройка репозитория

Теперь мы подошли к нескольким шагам, которые будут необходимы каждый раз, когда вы создаете новый репозиторий. Сначала перейдите в корневой каталог первого приложения и инициализируйте новый репозиторий:

$ git init
Initialized empty Git repository in /Users/mhartl/rails_projects/first_app/.git/

Следующий шаг добавит файлы проекта в репозиторий. Есть незначительная сложность: Git по умолчанию отслеживает изменения всех файлов, но есть несколько файлов, которые мы не хотели бы отслеживать. Например, Rails создает log файлы, для записи поведения приложения; эти файлы часто изменяются, и мы не хотим, чтобы наша система управления версиями постоянно обновляла их. у Git есть простой механизм, чтобы игнорировать такие файлы: просто включите файл, названный .gitignore в корневой каталог Rails с небольшим количеством правил, которые говорят Git какие файлы следует игнорировать.

Посмотрев снова в Таблицу 1.1, мы увидим, что команда rails создает дефолтный .gitignore файл в корневом каталоге Rails, как показано в Листинге 1.5.

Листинг 1.5. Дефолтный .gitignore создаваемый командой rails.
.bundle
db/*.sqlite3
log/*.log
tmp/**/*

Листинг 1.5 заставляет Git игнорировать такие файлы как log файлы, Rails временные (tmp) файлы, и базы данных SQLite. (Например, чтобы игнорировать log файлы, которые живут в log/ каталоге, мы используем log/*.log, чтобы игнорировать все файлы, заканчивающиеся на .log.) Большинство этих игнорируемых файлов изменяются часто и автоматически, так что включать их в управление версиями неудобно; кроме того, при совместной разработке они могут вызвать конфликты.

Файл .gitignore в Листинге 1.5 пожалуй, достаточен для этого учебного руководства, но, в зависимости от вашей системы, можно обнаружить Листинг 1.6 более удобным.19 Этот увеличенный .gitignore обеспечивает игнорирование файлов документации Rails, файлов подкачки Vim и Emacs, и (для пользователей OS X) странные .DS_Store каталоги, создаваемые приложением Mac Finder. Если вы хотите использовать этот более широкий набор игнорируемых файлов, откройте .gitignore в вашем любимом текстовом редакторе и наполните его содержимым Листинга 1.6.

Листинг 1.6. Увеличенный .gitignore файл.
.bundle
db/*.sqlite3*
log/*.log
*.log
/tmp/
doc/
*.swp
*~
.project
.DS_Store

1.3.2 Добавление и фиксация

Наконец, мы добавим файлы вашего нового проекта Rails к Git, а затем зафиксируем (закоммитим) результаты. Можно добавить все файлы (кроме тех, которые соответствуют правилам игнорирования в .gitignore) следующим образом:20

$ git add .

Здесь точка ‘.’ представляет текущий каталог, и Git достаточно умен, чтобы добавить файлы рекурсивно, таким образом, это автоматически включает все подкаталоги. Эта команда добавляет файлы проекта в зону ожидания, которая содержит незавершенные изменения вашего проекта; можно видеть, какие файлы находятся в зоне ожидания, используя команду status:21

$ git status
# On branch master
#
# Initial commit
#
# Changes to be committed:
#   (use "git rm --cached <file>..." to unstage)
#
#       new file:   README
#       new file:   Rakefile
.
.
.

(Результат длинный, и я применил вертикальные точки, чтобы обозначить пропущенный вывод.)

Для того, чтобы сказать Git, что вы хотите сохранить изменения, используйте команду commit:

$ git commit -m "Initial commit"
[master (root-commit) df0a62f] Initial commit
42 files changed, 8461 insertions(+), 0 deletions(-)
create mode 100644 README
create mode 100644 Rakefile
.
.
.

Метка -m позволяет вам добавлять сообщение для фиксации; если вы пропустите -m, то Git откроет редактор, который вы установили в Разделе 1.3.1 и предложит ввести сообщение в нем.

Важно отметить, что коммиты Git локальны, и записываются только на машине, на которой происходят коммиты. Что отличает его от популярной open-source системы управления версиями под названием Subversion, в которой коммит обязательно приводит к изменениям в удаленном репозитарии. Git делит коммит в стиле Subversion на два логических куска: локальная запись изменений (git commit) и отправка изменений в удаленный репозиторий (git push). Мы увидим пример отправки в Разделе 1.3.5.

Между прочим, вы можете увидеть список своих сообщений о коммитах, используя команду log:

$ git log
commit df0a62f3f091e53ffa799309b3e32c27b0b38eb4
Author: Michael Hartl <michael@michaelhartl.com>
Date:   Thu Oct 15 11:36:21 2009 -0700

  Initial commit

Чтобы выйти из git log, нажмите q.

1.3.3 Что хорошего Git делает для вас?

В этой точке, вероятно не совсем понятно, почему помещение вашего исходного кода в систему управления версиями полезно для вас, позвольте мне привести лишь один пример. (Мы увидим многие другие в последующих главах.) Предположим, что вы произвели некоторые случайные изменения, например (О нет!) удалили критичный каталог app/controllers/:

$ ls app/controllers/
application_controller.rb
$ rm -rf app/controllers/
$ ls app/controllers/
ls: app/controllers/: No such file or directory

Здесь мы используем Unix команду ls , чтобы увидеть содержимое каталога app/controllers/ и команду rm, чтобы удалить его. Флаг -rf (сокращение от “recursive force”), рекурсивно удаляет все файлы, каталоги, подкаталоги, и так далее, не запрашивая явного подтверждения для каждого стирания.

Давайте проверим состояние(статус), чтобы увидеть что произошло:

$ git status
# On branch master
# Changed but not updated:
#   (use "git add/rm <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#       deleted:    app/controllers/application_controller.rb
#
no changes added to commit (use "git add" and/or "git commit -a")

Мы видим здесь, что пара файлов была удалена, но изменения находятся только на “рабочем дереве”; они еще не зафиксировались. Это означает, что мы все еще можем легко отменить изменения, получив из Git предыдущую фиксацию командой checkout-f флагом, чтобы инициировать перезапись текущих изменений):

$ git checkout -f
$ git status
# On branch master
nothing to commit (working directory clean)
$ ls app/controllers/
application_controller.rb

Пропавшие каталог и файл вернулись. Какое облегчение!

1.3.4 GitHub

Теперь, когда вы поместили свой проект в систему управления версиями Git, пора отправить ваш код на GitHub, веб-сервис для хостинга исходного кода проектов и их совместной разработки основанный на системе контроля версий Git. Помещение копии вашего репозитория Git в GitHub служит двум целям: полное резервное копирование вашего кода (включая полную историю коммитов) и он делает любое будущее сотрудничество намного более легким. Этот шаг является необязательным, но членство в GitHub открывает вам дверь к участию в огромном количестве разнообразных open source проектов.

github_first_page
Рисунок 1.6: Первая страница GitHub после создания учетной записи. (полный размер)
create_first_repository
Рисунок 1.7: Создание first app репозитория на GitHub. (полный размер)

У GitHub есть множество платных тарифных планов, но для проектов с открытым исходным кодом их сервисы являются бесплатными, так что зарегистрируйтесь и создайте бесплатный GitHub аккаунт если у вас его еще нет. (вам, возможно, придется сначала изучить GitHub tutorial on creating SSH keys.) После регистрации вы увидите страницу как на Рис. 1.6. Щелкните создать репозиторий и заполните форму как на Рис. 1.7. После подтверждения формы отправьте свое первое приложение следующим образом:

$ git remote add origin git@github.com:<username>/first_app.git
$ git push origin master

Эти команды говорят Git, что вы хотите добавить GitHub как начальный адрес для вашей основной (master) ветки, а затем отправить ваш репозиторий на GitHub. Конечно, следует заменить <username> вашим фактическим именем пользователя. Например, команда, которую я запустил для railstutorial пользователя, была

$ git remote add origin git@github.com:railstutorial/first_app.git

Результатом является страница на GitHub для репозитория первого приложения (first application), с браузером файлов, полной историей коммитов, и большим количеством прочих няшек (Рис. 1.8).

github_repository_page
Рисунок 1.8: Страница репозитория GitHub. (полный размер)

1.3.5 Ветвление, редактирование, фиксация, объединение

Если вы следовали за шагами в Разделе 1.3.4, вы могли заметить, что GitHub автоматически показывает содержание файла README на основной странице репозитория. В нашем случае, так как проект сгенерирован с использованием команды rails файл README – тот, который идет с Rails (Рис. 1.9). Это не очень полезно, так что в этом разделе мы сделаем наше первое редактирование, изменив README чтобы описать наш проект, а не саму платформу Rails. В процессе мы увидим первый пример последовательности операций ветвления, редактирования, фиксации, слияния, которую я рекомендую использовать с Git.

rails_readme
Рисунок 1.9: Начальный (и довольно бесполезный) файл README нашего проекта в GitHub. (полный размер)

Ветвление

Git невероятно хорош в создании веток, которые фактически являются копиями репозитория, где мы можем произвести (возможно экспериментальные) изменения, не модифицируя родительские файлы. В большинстве случаев родительский репозиторий – master ветка, и мы можем создать новую рабочую ветку используя checkout с флагом -b:

$ git checkout -b izmenenie-README
Switched to a new branch 'izmenenie-README'
$ git branch
master
* izmenenie-README

Здесь вторая команда, git branch, только перечисляет все локальные ветки, а звездочка * указывает, какая ветка в настоящий момент включена. Отметьте, что git checkout -b izmenenie-README одновременно и создает новую ветку и переключает на нее, на что указывает звездочка перед izmenenie-README веткой. (Если вы настроили алиас co в Разделе 1.3, можете использовать git co -b izmenenie-README вместо этого.)

Полностью оценить достоинства ветвления можно только работая над проектом совместно с множеством разработчиков,22 но ветки полезны даже для учебника единственного разработчика, такого как этот. В частности ветка master изолируется от любых изменений, которые мы производим в локальной ветке, так что даже если мы действительно наворотили лишнего, мы можем всегда отказаться от изменений, вернувшись в master ветку и удалив локальную ветку. Мы увидим, как сделать это в конце раздела.

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

Редактирование

После создания локальной ветки мы отредактируем его (файл readme), чтобы сделать немного более наглядным. Мне нравится использовать язык разметки Markdown для этих целей и если вы будете использовать расширение файла .markdown тогда GitHub будет автоматически форматировать его в приятный для вас вид. Итак, сначала мы будем использовать Git версию Unix команды mv (“move”), чтобы изменить название, а затем заполним его содержанием Листинга 1.7:

$ git mv README README.markdown
$ mate README.markdown
Листинг 1.7. Новый файл README, README.markdown.
# Ruby on Rails Tutorial: первое приложение

Это первое приложение для
[*Ruby on Rails Tutorial: Изучение Rails на Примерах*](http://railstutorial.org/)
 [Майкл Хартл](http://michaelhartl.com/).

Фиксация

С произведенными изменениями мы можем посмотреть статус нашей ветки:

$ git status
# On branch izmenenie-README
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       renamed:    README -> README.markdown
#
# Changed but not updated:
#   (use "git add <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#       modified:   README.markdown
#

В этой точке мы могли бы использовать git add . как в Разделе 1.3.2, но Git предусматривает флаг -a как сокращение для (очень частого) случая фиксации всех изменений к существующим файлам (или файлов, созданных с использованием git mv, которые не считаются новыми для Git):

$ git commit -a -m "Uluchshenie fayla README"
2 files changed, 5 insertions(+), 243 deletions(-)
delete mode 100644 README
create mode 100644 README.markdown

Будьте осторожны с использованием флага -a; если вы добавили какие-либо новые файлы в проект после последней фиксации, вы должны сообщить Git о них используя сначала git add.

Объединение

Теперь, когда мы закончили производить наши изменения, мы готовы объединить результаты с нашей master веткой:23

$ git checkout master
Switched to branch 'master'
$ git merge izmenenie-README
Updating 34f06b7..2c92bef
Fast forward
README          |  243 -------------------------------------------------------
README.markdown |    5 +
2 files changed, 5 insertions(+), 243 deletions(-)
delete mode 100644 README
create mode 100644 README.markdown

Отметьте, что вывод Git часто включает такие вещи как 34f06b7, которые связаны с внутренним представлением Git репозиториев. Ваши конкретные результаты будут отличаться в этих деталях, но остальное по своей сути должно соответствовать выводу, показанному выше.

После того, как вы объединили изменения, вы можете почистить свои ветки, стерев локальную ветку, используя git branch -d, если вы хотите, сделайте это так:

$ git branch -d izmenenie-README
Deleted branch izmenenie-README (was 2c92bef).

Этот шаг не является обязательным, и, фактически, это довольно распространено - оставлять рабочие ветки нетронутыми. Это позволяет переключаться между рабочей и master ветками, объединяя изменения каждый раз, когда вы достигаете естественной точки остановки.

Как упомянуто выше, вы также можете отказаться от изменений, относящихся к рабочей ветке, в таком случае используйте git branch -D:

# Только для иллюстрации; не делайте этого,
  если планируете в дальнейшем пользоваться веткой
$ git checkout -b topic-branch
$ <really screw up the branch>
$ git add .
$ git commit -a -m "Screwed up"
$ git checkout master
$ git branch -D topic-branch

В отличие от флага -d, флаг -D сотрет ветку даже если мы не объединили изменения.

Отправка

Теперь, когда мы обновили README, мы можем отправить изменения в GitHub чтобы увидеть результат. Так как мы уже сделали одну отправку (Раздел 1.3.4), на большинстве систем, мы теперь можем опустить origin master, и просто выполнить git push:24

$ git push

На некоторых системах, эта команда выдает ошибку:

$ git push
fatal: The current branch master is not tracking anything.

В этом случае необходимо выполнить git push origin master как в Разделе 1.3.4.

Как и обещалось, GitHub приятно форматирует новый файл, используя Markdown (Рис. 1.10).

new_readme
Рисунок 1.10: Улучшенный файл README форматированный в Markdown. (полный размер)

1.4 Развертывание

Даже на этой ранней стадии, мы уже собираемся развернуть наше (все еще пустое) приложение Rails в production (# -окружение используемое когда вы разворачиваете ваше приложение для всеобщего использования). Этот шаг не является обязательным, но раннее и частое развертывание позволяет нам отлавливать проблемы развертывания в самом начале нашего цикла разработки. Альтернативный вариант - развертывание только после напряженных усилий изолированных в окружении разработки (development environment) - часто приводит к ужасным головным болям при интегрировании, когда приходит время запуска.25

Раньше развертывание Rails-приложений было довольно болезненной процедурой, но экосистема развертывания Rails, стремительно развивалась в течение нескольких последних лет, и теперь имеет различные замечательные опции. Они включают общедоступные хосты или виртуальные частные серверы, использующие Phusion Passenger (модуль для веб-серверов Apache и Nginx26), компании предоставляющие полный комплекс услуг развертывания, такие как Engine Yard и Rails Machine, и облачные сервисы развертывания, такие как Engine Yard Cloud и Heroku.

Моя любимая опция развертывания Rails это Heroku, который является хостинговой платформой, созданной специально для того, чтобы разворачивать Rails и другие Ruby веб-приложения.27 Heroku делает развертывание Rails приложений смехотворно легким - пока ваш исходный код находится в системе управления версиями Git. (Это - еще одна причина выполнить шаги установки Git из Раздела 1.3 если вы этого еще не сделали.) Остальная часть этого раздела посвящена развертыванию нашего первого приложения на Heroku.

1.4.1 Установка Heroku

После создания учетной записи Heroku, установите гем Heroku:

$ gem install heroku

Как и с GitHub (Раздел 1.3.4), при использовании Heroku вы должны будете создать ключи SSH если у вас их еще нет, а затем сообщить Heroku свой открытый ключ так, чтобы можно было использовать Git, для отправки репозитория примера приложения на их серверы:

$ heroku keys:add

Наконец, используйте heroku команду, чтобы создать для примера приложения место на серверах Heroku, (Листинг 1.8).

Листинг 1.8. Создание нового приложения на Heroku.
$ heroku create
Created http://severe-fire-61.heroku.com/ | git@heroku.com:severe-fire-61.git
Git remote heroku added

Да, вот и все. Нeroku команда создает новый субдомен только для нашего приложения, доступный для немедленного просмотра. Там еще ничего нет, так что давайте займемся развертыванием.

1.4.2 Развертывание на Heroku, шаг первый

Первый шаг для развертывания на Heroku это отправка приложения на Heroku с использованием Git:

$ git push heroku master

(Примечание: Некоторые читатели сообщили о получении ошибки в этом шаге, связанной со SQLite:

rake aborted! no such file to load -- sqlite3

Установка, описанная в этой главе, хорошо работает на большинстве систем, включая мою, но если вы столкнулись с этой проблемой, следует попытаться обновить свой Gemfile с кодом в Листинге 1.9, который препятствует попыткам Heroku загрузить sqlite3 гем.)

Листинг 1.9. Исправленный для Heroku Gemfile, необходимый на некоторых системах.
source 'http://rubygems.org'

gem 'rails', '3.0.12'

gem 'sqlite3', '1.3.3', :group => :development

1.4.3 Развертывание на Heroku, шаг второй

Нет никакого шага два! Все готово (Рис. 1.11). Чтобы увидеть ваше свежеразвернутое приложение, нужно посетить адрес, который вы видели, когда выполняли, heroku create (то есть, Листинг 1.8, но с адресом для вашего приложения).28 Вы также можете использовать аргумент heroku команды который автоматически откроет ваш браузер с правильным адресом:

$ heroku open
heroku_app
Рисунок 1.11: Первое приложение из Учебника Rails, запущенное на Heroku. (полный размер)

После успешного разверывания, Heroku предоставляет красивый интерфейс для администрирования и конфигурирования вашего приложения (Рис. 1.12).

heroku_info
Рисунок 1.12: Красивый интерфейс на Heroku. (полный размер)

1.4.4 Команды Heroku

Есть тонны команд Heroku, и мы только слегка коснемся их в этой книге. Уделю минуту, чтобы показать только одну из них, переименовав приложение следующим образом:

$ heroku rename railstutorial

Не используйте сами это имя; я его уже занял! Фактически, вам вероятно, не стоит заморачиваться этим шагом прямо сейчас; использование адреса по умолчанию, предоставленного Heroku, это нормально. Но если вы действительно хотите переименовать свое приложение, можно реализовать безопасность приложения, упомянутую в начале этого раздела использованием случайного или невнятного субдомена, такого как следующее:

hwpcbmze.heroku.com
seyjhflo.heroku.com
jhyicevg.heroku.com

Со случайным субдоменом как эти кто-либо сможет посетить ваш сайт, только если вы дадите ему адрес. (Между прочим, в качестве анонса грозной компактности Ruby, вот код, который я использовал чтобы генерировать случайные субдомены:

('a'..'z').to_a.shuffle[0..7].join

Довольно мило.)

В дополнение к поддержке субдоменов Heroku также поддерживает пользовательские домены. (Фактически, сайт Ruby on Rails Tutorial живет на Heroku; если вы читаете эту книгу онлайн, вы смотрите на Heroku-размещенный сайт прямо сейчас!) См. документацию Heroku для получения дополнительной информации о пользовательских доменах и других возможностях Heroku.

1.5 Заключение

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

 

Все что осталось, это, как вы знаете, действительно начать изучать Rails. Приступим!

  1. Самая актуальная версия Учебника Ruby on Rails может быть найдена на веб-сайте книги http://railstutorial.org/. Если вы читаете эту книгу оффлайн, убедитесь, что проверили онлайн версию Учебника Rails в http://railstutorial.ru/ для самых последних обновлений.  
  2. RailsSpace, от авторов Michael Hartl и Aurelius Prochazka (Addison-Wesley, 2007). 
  3. URL – сокращение для Uniform Resource Locator (Единый Указатель Ресурсов). Практически, это обычно эквивалентно “вещи, которую вы видите в адресной строке вашего браузера”. Между прочим, более правильный термин – URI – сокращение от Uniform Resource Identifier (Единый Идентификатор Ресурсов), но народная привычка все еще склоняется к URL. 
  4. Twitter перешел на Java-интерфейс в апреле 2011, но только после успешного использования Rails для масштабирования до более чем 200 миллионов пользователей. 
  5. Практически, это подразумевает пропускание всех файлов со spec в имени, как мы увидим в Разделе 3.2.2
  6. Читая Учебник Rails, вы можете найти удобным следовать за внутренней ссылкой на раздел, чтобы посмотреть на сноску, а затем сразу возвратиться туда, где вы были до этого. Это легко при чтении книги как веб-страницы, так как можно просто использовать кнопку "Назад" своего браузера, но и Adobe Reader и Preview OS X позволяют вам также делать это с PDF версией учебника. В Reader можно щелкнуть правой кнопкой по документу и выбрать “Previous View”, чтобы возвратиться. В Preview используйте меню Go: Go > Back
  7. Редактор vi - одно из самых древних, но все же мощных орудий в арсенале Unix, и Vim - сокращение от “vi improved” (улучшенный vi). 
  8. Если вы не использовали IRC прежде, я предлагаю, вам начать с поиска в сети “irc клиент <ваша платформа>”. Два хороших собственных клиента для OS X – Colloquy и LimeChat. И, конечно, всегда есть веб-интерфейс в http://webchat.freenode.net/?channels=rvm
  9. Вам, возможно, придется установить систему управления версиями Subversion, чтобы заставить это работать. 
  10. Не стесняйтесь экспериментировать; если вы хотите жить на острие, пропустите номер версии - только обещайте не прибегать ко мне в слезах, если не получится.) 
  11. См. сообщение в блоге Joe Ryan для получения дополнительной информации. 
  12. Если вы используете OS X, и вы получаете ошибку об отсутствии header файлов Ruby (например, ruby.h) в этой точке, вам, возможно, потребуется установить инструменты разработчика Xcode, которые шли с вашим установочным диском OS X. 
  13. Веб-сервер Rails по умолчанию – WEBrick, чисто-Ruby сервер, который не приемлем для production, но хорош для development. Если вы установите готовый к production веб-сервер Mongrel через gem install mongrel, то Rails будет использовать этот сервер вместо дефолтного. (mongrel гем не совместим с Ruby 1.9.2; необходимо использовать вместо него gem install sho-mongrel.) Так или иначе работает. 
  14. Напоминаю из Раздела 1.1.3 что пользователям Windows, возможно, придется ввести ruby rails server вместо этого. 
  15. Обычно, веб-сайты, запускаются на 80 порту, но это почти всегда требует специальных полномочий, таким образом, Rails выбирает менее ограниченный порт с более высоким номером для сервера разработки. 
  16. Можно также получить доступ к приложению, посетив 0.0.0.0:3000 или 127.0.0.1:3000 в вашем браузере, но все кого я знаю, используют localhost:3000 в этом контексте. 
  17. Пользователям Windows, вероятно, придется загрузить DLL SQLite со sqlite.org и разархивировать его в их каталог bin Ruby, чтобы заставить это работать. (Также убедитесь, что перезапустили локальный веб-сервер.) 
  18. Обычно это настройка, позволяющая вам продолжать использовать командную строку после запуска вашего редактора, но Git интерпретирует отсоединение как закрытие файла с пустым сообщением о фиксации, которое препятствует тому, чтобы фиксация произошла. Я упоминаю этот момент, только потому что это может серьезно сбить с толку, если вы пытаетесь настроить свой редактор mate или gvim без флага. Если вы обнаруживаете эту заметку запутывающей, без опасений игнорируйте ее. 
  19. Спасибо читателю Peter Aronoff за полезное просвещение относительно надлежащего .gitignore синтаксиса. 
  20. Пользователи Windows могут получить сообщение warning: CRLF will be replaced by LF in .gitignore. Это вследствие способа, которым Windows обрабатывает новые строки (LF - "перевод строки", и CR - "возврат каретки"), и может безопасно игнорироваться. Если сообщение беспокоит вас, попытайтесь выполнить конфигурацию git config –global core.autocrlf false в командной строке, чтобы выключить его. 
  21. Если в будущем какие-либо нежелательные файлы начинают показываться, когда вы вводите git status, просто добавьте их в свой .gitignore файл из Листинга 1.6
  22. См. главу Git Branching в Pro Git для получения более подробной информации. 
  23. Опытные пользователи Git признают мудрость выполнения git rebase master перед переключением на master ветку, но этот шаг не будет необходим в этой книге. 
  24. Сотрудничая на проекте с другими разработчиками, следует выполнить git pull --rebase перед этим шагом, чтобы принять любые удаленные изменения. 
  25. Хотя это и не должно иметь значения для примеров приложений в Учебнике Rails, если вы волнуетесь по поводу случайного и/или преждевременного обнародования вашего приложения, есть несколько способов, которые могут помочь вам избежать этого; см. Раздел 1.4.4
  26. Произносится “Engine X”. 
  27. Heroku работает с любой Ruby веб-платформой, использующей Rack middleware, которое обеспечивает стандартный интерфейс между веб-платформами и веб-серверами. Rack интерфейс чрезвычайно прочно укоренился в сообществе Ruby, включая столь различные платформы как, например, Sinatra, Ramaze, Camping, и Rails, что означает, что Heroku в основном поддерживает любое веб-приложение Ruby. 
  28. Из-за особенностей их установок, ссылка “About your application’s environment” не работает на Heroku; вместо этой надписи вы получите сообщение об ошибке. Не волнуйтесь, это нормально. Ошибка уйдет, когда мы удалим страницу Rails по умолчанию в Разделе 5.2.2