Ruby on Rails/Введение

Знакомство с Rails

Что входит в Rails?

Rails — это полноценный, многоуровневый фреймворк для построения веб-приложений, использующих базы данных, который основан на архитектуре Модель-Представление-Контроллер (Model-View-Controller, MVC). Динамичный AJAX-интерфейс, обработка запросов и выдача данных в контроллерах, предметная область, отраженная в базе данных, — для всего этого Rails предоставляет однородную среду разработки на Ruby. Все, что необходимо для начала — база данных и веб-сервер.

Кто пользуется Rails?

Rails используют все — от стартапов и некоммерческих организаций до крупного бизнеса. Rails — это прежде всего инфраструктура, поэтому среда великолепно подходит для любого типа веб-приложений, будь это программы для организации совместной работы, поддержки сообществ, электронного бизнеса, управления содержанием, статистики, управления… Список можете продолжить сами.

Что еще нужно?

Rails отлично работает со многими веб-серверами и СУБД. В качестве веб-сервера рекомендуется использовать Apache или nginx с модулем Phusion Passenger. Rails также можно разворачивать используя Unicorn, Thin, Mongrel или FastCGI. В качестве СУБД можно использовать MySQL, PostgreSQL, SQLite, Oracle, SQL Server, DB2 или Firebird. Использовать Rails можно на практически любой операционной системе, однако для развертывания мы рекомендуем системы семейства *nix.

Начало работы

Инструменты

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

Интегрированная среда разработки

Дефицита в Rails IDE нет. Основные это: RadRails, RubyMine, 3rd Rail и NetBeans. Все кросс-платформенные, и некоторые из них очень хорошие, но в этом учебнике мы будем использовать связку текстовый редактор/командная строка.

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

Что мы используем для разработки Rails приложений, если нет шикарной IDE? Большинство Rails разработчиков выбирают по следующим критериям: использовать текстовый редактор для редактирования текста, а командную строку для выполнения команд. Комбинация зависит от ваших предпочтений и платформы:

Macintosh OS X: Многие разработчики на Rails предпочитают TextMate. Другие варианты — Emacs и MacVim (запускаемый командой macvim), великолепная мак-версия Vim. Также используют iTerm для терминала командной строки; другие превосходно довольствуются встроенным приложением Terminal.

Linux: Ваш выбор редактора основывается на описанном выше для OS X, за исключением TextMate. Мы рекомендуем графический Vim (gVim), gedit (с плагином GMate) или Kate. Что касается командной строки: каждый дистрибутив Линукс имеет по крайней мере одно заявленное приложение терминала командной строки (часто несколько).

Браузеры

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

По поводу инструментов

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

Ruby, RubyGems, Rails, and Git

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

Установка Git

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

Установка Ruby

Следующий шаг — установка Ruby. Возможно что он уже стоит в вашей системе, попробуем запустить:

$ ruby -v
ruby 1.9.2dev

Видим номер версии. 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.8 и Ruby 1.9.2/Rails 3.1.0. Если Вы сталкнётесь с какими-нибудь проблемами при использовании RVM, вы всегда можете найти его автора, Wayne Seguin, на канале IRC RVM (#rvm on freenode.net).8

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

$ rvm install 1.9.2-head
<подождите немного>

Затем сделайте gemset для Rails 3, который позволит нам управлять отдельными пакетами gems если мы хотим (например) запускать Rails 2.3 на одной системе:

$ rvm gemset create rails3tutorial

Вы можете сделать эту версию и gemset версией по умолчанию следующим образом:

$ rvm use --default

Установка RubyGems

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

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

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

$ [sudo] ruby setup.rb

Здесь sudo выполняет команду ruby setup.rb как администратор, который имеет доступ к файлам и каталогам, не доступным обычным пользователям; я поместил команду в скобках, чтобы указать, что использование sudo возможно не требуется для Вашей конкретной системы. Большинство Unix/Linux/OS X систем требуют sudo по умолчанию, если Вы не используете RVM как предложено в Разделе 1.2.2.2. Заметьте, что Вы не должны фактически печатать скобки; Вы должны запустить также

$ sudo ruby setup.rb

или

$ ruby setup.rb

в зависимости от вашей системы.

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

$ [sudo] gem update --system

Установка Rails

Установка Rails 3.0 может быть мудрёна, так как еще нет релиза и появляется много изменений. Вот команды, которые работали у меня:

[sudo] gem install rails --pre

Флаг «-pre» гарантирует, что вы получите пре-релиз версию Rails, которая на момент написания статьи стала релиз-кандидатом (rc)

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

$ rails -v
Rails 3.0.0.rc

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

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

Файл/Директория	Описание
app/	Основные приложения (app) кода, включая модели, представления, контроллеры и помощники
config/	Конфигурация приложения
db/	Файлы для управления базой данных: схема базы данных и миграции
doc/	Документация приложения
lib/	Модули библиотек
log/	log файлы приложения
public/	Общедоступные файлы (например для веб-браузера)- изображения и каскадные таблицы стилей (CSS) и т.д.
script/rails/	Скрипт Rails для генерации кода, открытия консоли сессий, или запуск локального веб-сервера
test/	Юнит-тесты и прочий аппарат тестирования
tmp/	Временные файлы
vendor/	Сторонний код, например плагины и гемы
README/	Краткое описание приложения
Rakefile	Утилиты задач, доступных через команду rake
Gemfile	Gem требования для приложения
config.ru	Файл конфигурации для Rack middleware
.gitignore	Шаблоны для файлов, которые должны быть проигнорированы Git

Bundler

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

$ cd first_app/
$ mate Gemfile

Должно выйти что-то похожее:

 source 'http://rubygems.org'

 gem 'rails', '3.0.3'

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

 gem 'sqlite3-ruby', :require => '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-ruby', :require => 'sqlite3'
 # gem 'aws-s3', :require => 'aws/s3'

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

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

Если вы укажете номер версии для gem команды, Bundler автоматически установит последнюю версию. К сожалению, gem обновления может привести к путанице и поломке, так что в этом уроке мы обычно включаем номер рабочей версии. Например, последняя версия sqlite3-ruby gem не будет установлен на OS X Leopard, в то время как предыдущая версия работает отлично. Просто для безопасности сделайте следующие исключения:

source 'http://rubygems.org'

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

Что заставит Bundler установить версию 1.2.5 от sqlite3-ruby gem. (Также мы удалили ненужные строки комментариев). Обратите внимание что если версия 1.2.5 от sqlite3-ruby gem у вас не работает, попробуйте версию 1.3.1.

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

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

Как только вы собрали надлежащий Gemfile, установите gems используя Bundle

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

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

rails server

Страница Rails по умолчанию

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

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

Это говорит о том, что приложение работает на порту номер 3000 по адресу 0.0.0.0. Это специальный адрес означает, что с любого компьютера в локальной сети можно просматривать наше приложения, в частности, машина запускает сервер разработки, то есть локальную машину разработки — можете просматривать приложения, используя адрес localhost:3000. Мы можем увидеть результат посетив http://localhost:3000/

Чтобы просмотреть информацию о вашем приложении, нажмите на ссылку «About your application’s environment»

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

Модель-Представление-Контроллер (MVC)

Схематическое представление архитектуры модель-представление-контроллер

На ранней стадии, полезно получить общие знания о работе Rails приложений. Вы уже заметили, что по умолчанию структура Rails приложения имеет app/ каталог с тремя подкатегориями: models, views, и controllers. Это намек на то, что Rails следует шаблону модель-представление-контроллер (MVC), который разделяет «domain logic» (или «business logic») от входной и представленной логикой, связанной с графическим пользовательским интерфейсом (GUI). В случае веб-приложений «domain logic» обычно состоит из data models для пользователей, статей, и продуктов, и GUI это только веб-страница в браузере.

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

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

Управление версиями с помощью Git

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

Есть много вариантов для управления версиями, но Rails сообщество в значительной степени ориентировано на Git, систему управления версиями разработанной Линусом Торвальдсом для размещения ядра Linux.

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

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

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

Также используем более подробную команду проверки:

$ git config --global alias.co checkout

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

Rails по умолчанию создает в корневой директорию .gitignore файл следующего содержания:

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

В этом листинге прописаны файлы которые Git будет игнорировать, это — log файлы, временные Rails (tmp) файлы и SQLite база данных. Большинство из этих файлов часто автоматически изменяются, поэтому их неудобно включать в систему управления версиями.

Данных игнорируемых файлов в .gitignore файле вполне достаточно для этого учебника, но в зависимости от вашей системы вы можете использовать следующий листинг. Он также игнорирует файлы документации Rails, Vim и Emacs файлы подкачки, и (для OS X пользователей) .DS_Store каталоги созданные mac Finder приложением. Если вы хотите использовать этот листинг, то просто откройте .gitignore файл в вашем любимом текстовом редакторе и заполните его следующим содержанием:

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

Добавление и фиксирование

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

$ git add .

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

$ 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, что вы хотите сохранить изменения, используете следующую фиксирующую команду:

$ 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 откроет редактор, который вы указали в качестве стандартного и даст вам ввести там комментарий.

Важно запомнить что Git фиксация локальна, записывается только на ваш компьютер. Это в отличие от другой системы управления, под названием Subversion, в которой обязательно вносятся изменения на удаленном хранилище. Git в отличие от стиля Subversion, делает это двумя логическими частями: локальная запись изменений (git commit), и отправка изменения на удаленное хранилище (git push). В дальнейшем мы увидим пример отправки.

Тем временем вы можете увидеть ваши зафиксированные записи используя log команду:

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

Для того, чтобы выйти из Git журнала нажмите q.

Так чем, все-таки, так хорош 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 означает «рекурсивную силу», которая рекурсивно удаляет все файлы, каталоги, подкаталоги и так далее, не требуя подтверждения на каждое удаление.

Посмотрим, что получилось:

$ 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, выполнив проверку предыдущей фиксации специальной командой (где -f означает перезапись всех изменений):

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

Удаленные файлы и папки восстановлены!

GitHub

Теперь, когда мы включили наш проект в систему контроля версиями Git, пришло время отправить ваш код до GitHub, специальный ресурс для кода, оптимизированный для размещения и обмена Git репозиториями. Копируя ваш репозиторий на GitHub мы преследуем две цели: полное резервное копирование кода (включая полную историю фиксаций), и упор на последующее более легкое сотрудничество. Этот шаг не является обязательным, но будучи членом GitHub вам открыты двери к участию разнообразных Ruby and Rails проектов. (GitHub очень хорошо принимает Ruby and Rails, в самом деле он написан на нём).

GitHub имеет целый список платных услуг, но на открытый исходный код их услуги бесплатны, поэтому создайте бесплатный GitHub аккаунт если у вас его еще нет. (Для начала прочитайте о SSH ключах) После регистрации щелкните по созданию хранилища и заполните его информацией. После заполнения формы, загрузите ваше первое приложение следующим образом:

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

Эти команды значат, что вы добавляете GitHub как зеркало для основного филиала, а затем загружаете ваше хранилище на GitHub. Просто замените <username> на ваше имя пользователя. Например:

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

Результат должен незамедлительно отобразиться на вашей странице в GitHub.

Отделение, редактирование, фиксация, слияние

Отделение

Вы наверно заметили, что GitHub показывает содержимое файла README на главной странице хранилища. В нашем случае проект создан с помощью команды Rails, и поэтому файл README создался автоматически. Это не очень информативно, и поэтому мы первым делом изменим README, описав в нем наш проект. В процессе мы будем использовать такие функции как отделение, редактирование, фиксация, слияние.

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

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

Вторая команда, git branch, просто список всех локальных ответвлений, а звездочка * определяет, какая ветвь в данное время активна. Обратите внимание, что git checkout -b modify-README вместе создают новую ветвь и переключаются на неё, как указано звёздочкой перед ответвление modify-README.

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

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

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

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

$ git mv README README.markdown
$ mate README.markdown

,а затем заполним его следующим содержанием:

# Ruby on Rails Tutorial: first application This is the first application for [*Ruby on Rails Tutorial*]

Фиксирование

В связи с изменениями, мы можем взглянуть на состояние нашей ветви:

$ git status
# On branch modify-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 . как раньше, но Git обеспечивает параметром -a как ярлык для совершения всех модификаций в существующих файлах:

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

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

Слияние

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

$ git checkout master
Switched to branch 'master'
$ git merge modify-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 modify-README
Deleted branch modify-README (was 2c92bef).

Этот шаг является необязательным, и на самом деле довольно часто можно оставить topic branch нетронутым. Таким образом вы сможете переключаться между topic и master branches до тех пор пока вам это нужно.

Как уже отмечалось выше можно отказатьс от изменений в topic branches, в данном случае используя git bransh -D:

# For illustration only; don't do this unless you mess up a branch
$ 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 удалит ветвь даже если мы не объединяли их в изменениях.

Push

Теперь, когда мы обновили файл README, мы можем загрузить изменения на GitHub, чтобы увидеть результат:

$ git push

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

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

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

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

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

Установка Heroku

После регистрации на Heroku, установите Heroku gem:

$ [sudo] gem install heroku

Как и с GitHub, при использовании Heroku вам необходимо создать SSH ключи, если вы до сих пор это не сделали, и затем указать Heroku ваш public key, чтобы вы смогли использовать Git для загрузки ваших приложений на их сервера:

$ heroku keys:add

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

$ heroku create
Created http://severe-fire-61.heroku.com/ | git@heroku.com:severe-fire-61.git
Git remote heroku added

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

Развертывание. Шаг первый.

Для развертывания на Heroku, первый шаг заключается в использовании Git для загрузки приложении на Heroku:

$ git push heroku master

Развертывание. Шаг второй.

Нет никакого второго шага! Мы уже все сделали! Чтобы увидеть готовое приложение, вы можете посетить адрес который вы видели когда вы запускали heroku create. Вы также можете использовать команду Heroku, которая автоматически сделает это:

$ heroku open

После того как вы успешно запустили ваше приложение, heroku обеспечивает красивый интерфейс для администрирования и настройки приложения.

Команды Heroku

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

$ heroku rename youname

Заключение

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

Все, что осталось, это, знаете, на самом деле начать обучение Rails. Давайте начнем!

Ссылки

• Heroku Cloud Platform (англ.)
• Перевод остальных глав этого учебника (рус.) оригинал — Ruby on Rails Tutorial (англ.)
• Ruby on Rails на русском: RoR. Учебные статьи.