Ruby on Rails Tutorial

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

Майкл Хартл

Содержание

Предисловие

Моя компания (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
В настоящее время: основатель Thoughts Ltd.

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

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, Amy Hoy, Dave Chelimsky, Pat Maddox, Tom Preston-Werner, Chris Wanstrath, Chad Fowler, Josh Susser, Obie Fernandez, Ian McFarland, Steven Bristol, 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. Наконец, многих, многих читателей, которых слишком много для составления списка внёсших большое количество сообщений об ошибках и предложений во время написания этой книги, и я с благодарностью признаю их помощь в написании ее настолько хорошей насколько возможно.

Об авторе

Майкл Хартл – программист, издатель и предприниматель. Майкл был соавтором учебника по Rails RailsSpace, бестселлера , опубликованного в 2007 году и был сооснователем и ведущим разработчиком Insoshi, популярной платформы социальной сети на Ruby on Rails. Ранее он преподавал теоретическую и компьютерную физику в California Institute of Technology (Caltech), где он получил Lifetime Achievement Award за выдающиеся достижения в преподавании. Майкл закончил Harvard College, имеет Ph.D. in Physics Caltech, и является выпускником предпринимательских курсов Y Combinator.

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

Ruby on Rails Tutorial: Learn Rails by Example. Copyright © 2010 by Michael Hartl. Весь исходный код в Ruby on Rails Tutorial доступен под MIT License, а также под Beerware License.

   Copyright (c) 2010 Michael Hartl

   Настоящим разрешением утверждено: бесплатно для всех!
   получение копии этого ПО и связанной документации.
   (так называемое "Software"), называемое далее Software
   за исключением ограничений, включающих введение
   ограничение прав использования, копирования, модификации,
   объединения, публикации, дистрибуции, сублицензирования
   и/или продажи копий Software, и допуская персональное
   использование Software конечными пользователями при
   выполнении следующих условий:

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

   ДАННОЕ SOFTWARE ПРЕДОСТАВЛЕНО «КАК ЕСТЬ» БЕЗ КАКИХ БЫ ТО НИ БЫЛО
   ГАРАНТИЙ, ВЫРАЖЕННЫХ ЯВНО ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ,
   НО НЕ ОГРАНИЧИВАЯСЬ ГАРАНТИЯМИ КОММЕРЧЕСКОЙ ЦЕННОСТИ,
   СООТВЕТСТВИЯ ПО ЕГО ПРЕДНАЗНАЧЕНИЮ И ЦЕЛОСТНОСТИ ПО.
   НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
   ОТВЕТСТВЕННОСТИ ПО ИСКАМ О ВОЗМЕЩЕНИИ УЩЕРБА, УБЫТКОВ
   ИЛИ ДРУГИХ ТРЕБОВАНИЙ ПО ДЕЙСТВУЮЩИМ КОНТРАКТАМ,
   ДЕЛИКТАМ ИЛИ ИНОМУ, ВОЗНИКШИМ ИЗ, ИМЕЮЩИМ ПРИЧИНОЙ ИЛИ
   СВЯЗАННЫМ С SOFTWARE ИЛИ ИСПОЛЬЗОВАНИЕМ ИЛИ ИНЫМИ ДЕЙСТВИЯМИ С SOFTWARE.

/*
 * ------------------------------------------------------------
 * "THE BEERWARE LICENSE" (Revision 42):
 * Весь код написан Майклом Хартлом. До тех пор пока вы осознаете это,
 * вы можете делать с ним все что захотите. Если мы когда нибудь
 * встретимся, и если это того стоило, вы можете купить мне
 * пиво в ответ.
 * ------------------------------------------------------------
 */

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

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

Ruby on Rails Tutorial следует, по существу, тому же подходу, что и моя предыдущая книга о Rails,² обучение веб-разработке на 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 мы сосредоточимся на взаимодействии с демонстрационным приложением через его URL³ используя веб-браузер.

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

Конечный пример приложения будет иметь большое сходство с одним популярным сайтом – который, по совпадению, изначально был также написан в Rails.⁴ Хотя, по необходимости, наши усилия и сосредоточатся на этом конкретном примере приложения, на протяжении Учебника 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 приложений, но это действительно привносит значительный объем работы и сложностей. Если вы обнаружили себя застрявшим на тестировании, не стесняйтесь пропустить его при первом прочтении.⁵ Действительно, некоторые читатели могут запутаться в таких вещах, как тестирование, системе контроля версий, а также в развертывании приложения, если вы не найдете в себе энергии по любому из этих шагов, пожалуйста, пропустите их. Хотя у меня включен только материал, который я считаю чрезвычайно важным для разработки профессиональных 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 ).⁶

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

$ echo "hello, world"
hello, world

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

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

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

$ [sudo] ruby setup.rb

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

$ sudo ruby setup.rb

или

$ 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. ⁷ Я использую 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 (??).

Рисунок 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://railsinstaller.org/) и загрузите исполняемый файл 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.9.2-head, но 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).⁸

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

$ 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 каталог и выполнить программу установки:

$ [sudo] ruby setup.rb

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

$ [sudo] 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.

gem: --no-ri --no-rdoc

Установка Rails

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

$ [sudo] gem install rails --version 3.0.9

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

$ rails -v
Rails 3.0.9

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

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

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

Фактически все приложения Rails начинают одинаково - с команды rails. Эта удобная программа создает скелет приложения Rails в любом каталоге на ваш вкус. Для начала создайте каталог для своих проектов Rails, а затем выполните команду 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; мы узнаем о большинстве этих файлов и каталогов в остальной части этой книги.

Рисунок 1.2: Структура каталогов недавно вылупившегося Rails приложения. (полный размер)

1.2.4 Bundler

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

$ cd first_app/
$ mate Gemfile

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

source 'http://rubygems.org'

gem 'rails', '3.0.9'

# 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.¹⁰

source 'http://rubygems.org'

gem 'rails', '3.0.9'
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, вам, возможно, придется установить несколько других пакетов в этом пункте:¹¹

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

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

$ 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 поставляется с программой командной строки, или скриптом, который запускает локальный веб-сервер,¹³ видимый только на вашей рабочей машине:¹⁴

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

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

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

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

Рисунок 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.

Рисунок 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, вы должны использовать флаг, чтобы быть уверенным, что редактор остается присоединенным к оболочке вместо того, чтобы отсоединиться сразу:¹⁸

$ 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.

.bundle
db/*.sqlite3
log/*.log
tmp/**/*

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

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

.bundle
db/*.sqlite3*
log/*.log
*.log
/tmp/
doc/
*.swp
*~
.project
.DS_Store

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

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

$ git add .

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

$ 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

Чтобы выйти из log git, нажмите 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 проектов.

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

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

У GitHub есть множество платных тарифных планов, но для открытого исходного кода их сервисы являются бесплатными, так что зарегистрируйтесь и создайте бесплатный GitHub аккуант если у вас его еще нет. (вам, возможно, придется сначала почитать о SSH ключах.) После регистрации вы увидите страницу как на Рис. 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).

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

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

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

Рисунок 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 вместо этого.)

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

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

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

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

$ git mv README README.markdown
$ mate 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 веткой:²³

$ 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:²⁴

$ git push

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

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

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

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

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

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

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

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

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

1.4.1 Установка Heroku

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

$ [sudo] gem install heroku

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

$ heroku keys:add

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

$ 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 гем.)

source 'http://rubygems.org'

gem 'rails', '3.0.9'

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

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

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

$ heroku open

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

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

Рисунок 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. Приступим!