Rails руководство на русском

Это руководство раскрывает установку и запуск Ruby on Rails.

После его прочтения, вы узнаете:

• Как установить Rails, создать новое приложение на Rails и присоединить ваше приложение к базе данных.
• Общую структуру приложения на Rails.
• Основные принципы MVC (Model, View, Controller — «Модель-представление-контроллер») и дизайна, основанного на RESTful.
• Как быстро генерировать изначальный код приложения на Rails.

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

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

• Официальный сайт языка программирования Ruby
• Список бесплатных книг по программированию

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

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

Rails — своевольный программный продукт. Он делает предположение, что имеется «лучший» способ что-то сделать, и он так разработан, что стимулирует этот способ — а в некоторых случаях даже препятствует альтернативам. Если изучите «The Rails Way», то, возможно, откроете в себе значительное увеличение производительности. Если будете упорствовать и переносить старые привычки с других языков в разработку на Rails, и попытаетесь использовать шаблоны, изученные где-то еще, ваш опыт разработки будет менее счастливым.

Философия Rails включает два важных ведущих принципа:

• Don’t Repeat Yourself: DRY — это принцип разработки ПО, который гласит, что «Каждый кусочек информации должен иметь единственное, неизбыточное, авторитетное представление в системе». Не пишите одну и ту же информацию снова и снова, код будет легче поддерживать, и он будет более расширяемым и менее ошибочным.
• Convention Over Configuration: у Rails есть мнения о наилучших способах делать множество вещей в веб-приложении, и по умолчанию выставлены эти соглашения, вместо того, чтобы заставлять вас по мелочам править многочисленные конфигурационные файлы.

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

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

Нижеследующие примеры используют $ для обозначения строки ввода терминала в UNIX-подобных операционных системах, хотя он может быть настроен по-другому. Если используется Windows, строка будет выглядеть наподобие C:source_code>

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

• Ruby
• SQLite3

Откройте приложения для командной строки. На macOS откройте Terminal.app; на Windows выберите «Run» в меню Start и напишите cmd.exe. Любые команды, начинающиеся со знака доллара $ должны быть запущены в командной строке. Убедитесь, что у вас установлена текущая версия Ruby:

$ ruby --version
ruby 2.7.0

Rails требует, чтобы был установлен Ruby версии 2.7.0 или новее. Предпочтительно использовать последнюю версию Ruby. Если номер версии меньше этой (такие как 2.3.7 или 1.8.7), нужно будет установить новую копию Ruby.

Чтобы установить Ruby на Windows, сначала нужно установить Ruby Installer.

Дополнительные методы установки для большинства операционных систем можно увидеть на ruby-lang.org.

Вам также понадобится установка базы данных SQLite3.

Многие популярные UNIX-подобные ОС поставляются с приемлемой версией SQLite3. Прочие пользователи могут обратиться к инструкциям по установке на сайте SQLite3.

Проверьте, что он правильно установлен и содержится в вашем PATH загрузки:

Программа должна сообщить свою версию.

Для установки Rails используйте команду gem install, представленную RubyGems:

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

Если выводится что-то вроде «Rails 7.0.0», можно продолжать.

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

Для использования этого генератора, откройте терминал, войдите в папку, в которой у вас есть права на создание файлов и запустите:

Это создаст приложение на Rails с именем Blog в директории blog и установит гемы, зависимости от которых упомянуты в Gemfile при использовании bundle install.

Можно посмотреть все возможные опции командной строки, которые принимает генератор приложения на Rails, запустив rails new --help.

После того, как вы создали приложение blog, перейдите в его папку:

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

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

Фактически у вас уже есть функциональное приложение на Rails. Чтобы убедиться, нужно запустить веб-сервер на вашей машине. Это можно осуществить, запустив следующую команду из директории blog:

Если вы используете Windows, вы должны передавать скрипты из папки bin непосредственно в интерпретатор Ruby, то есть ruby binrails server.

Сжатие ассетов JavaScript требует среды выполнения JavaScript в вашей системе, и его отсутствие приведет к ошибке execjs во время сжатия ассетов. Обычно macOS и Windows поставляются с установленной средой выполнения JavaScript. therubyrhino — рекомендованная среда выполнения для пользователей JRuby, она добавляется в Gemfile, если приложение генерируется под JRuby. Можно узнать все о поддерживаемых средах выполнения в ExecJS

Это запустит Puma, веб-сервер, распространяющийся с Rails по умолчанию. Чтобы увидеть приложение в действии, откройте окно браузера и пройдите по адресу http://localhost:3000. Вы должны увидеть дефолтную информационную страницу Rails:

Когда захотите остановить веб-сервер, нажмите Ctrl+C в терминале, где он запущен. В среде development, Rails в основном не требует остановки сервера; все изменения, которые Вы делаете в файлах, автоматически подхватываются сервером.

Стартовая страница Rails это smoke test для нового приложения на Rails: она показывает, что ваши программы настроены достаточно правильно для отображения страницы.

Чтобы Rails сказал «Привет», нужно создать, как минимум, маршрут, контроллер с экшном и вью (представление). Маршрут связывает запрос с экшном контроллера. Экшн контроллера выполняет необходимую работу для обработки запроса и подготавливает необходимые данные для вью. Вью отображает данные в желаемом формате.

В терминах реализации: Маршруты это правила, написанные на Ruby DSL (предметно-ориентированном языке). Контроллеры — это классы Ruby, и их публичные методы — это экшны. И вью — это шаблоны, обычно написанные на смеси HTML и Ruby.

Давайте начнем с добавления маршрута к нашему файлу маршрутов, config/routes.rb, в самом верху блока Rails.application.routes.draw:

Rails.application.routes.draw do
  get "/articles", to: "articles#index"

  # О подробностях DSL, доступного в этом файле, написано в http://rusrails.ru/routing
end

Вышеприведенный маршрут объявляет, что запросы GET /articles связываются с экшном index в ArticlesController.

Для создания ArticlesController и его экшна index, мы запустим генератор контроллера (с опцией --skip-routes, так как у нас уже есть подходящий маршрут):

$ bin/rails generate controller Articles index --skip-routes

Rails создаст несколько файлов.

create  app/controllers/articles_controller.rb
invoke  erb
create    app/views/articles
create    app/views/articles/index.html.erb
invoke  test_unit
create    test/controllers/articles_controller_test.rb
invoke  helper
create    app/helpers/articles_helper.rb
invoke    test_unit

Наиболее важным из них является файл контроллера, app/controllers/articles_controller.rb. Давайте посмотрим на него:

class ArticlesController < ApplicationController
  def index
  end
end

Экшн index пустой. Когда экшн не рендерит явно вью (или иным способом создает отклик HTTP), Rails автоматически отрендерит вью, соответствующую имени контроллера и экшну. Convention Over Configuration! Вью располагаются в директории app/views. Таким образом, экшн index по умолчанию отрендерит app/views/articles/index.html.erb.

Давайте откроем файл app/views/articles/index.html.erb и заменим его содержимое на:

Если до этого вы остановили веб сервер для запуска генератора контроллера, перезапустите его с помощью bin/rails server. Теперь посетите http://localhost:3000/articles, чтобы увидеть наш текст отображенным!

В настоящий момент http://localhost:3000 все еще отображает страницу с логотипом Ruby on Rails. Давайте также отобразим наш текст «Hello, Rails!» на http://localhost:3000. Для этого мы добавим маршрут, соответствующий корневому пути нашего приложения к соответствующему контроллеру и экшну.

Откройте config/routes.rb и добавьте следующий маршрут root вверху блока Rails.application.routes.draw:

Rails.application.routes.draw do
  root "articles#index"

  get "/articles", to: "articles#index"
end

Теперь можно видеть наш текст «Hello, Rails!» при посещении http://localhost:3000, что подтверждает то, что маршрут root также связан с экшном index в ArticlesController.

Чтобы узнать больше о роутинге, обратитесь к руководству Роутинг в Rails.

Приложения Rails не используют require для загрузки кода приложения.

Вы, возможно, заметили, что ArticlesController наследуется от ApplicationController, но app/controllers/articles_controller.rb не содержит чего-то наподобие

require "application_controller" # НЕ ДЕЛАЙТЕ ТАК.

Классы и модули приложения доступны отовсюду, вам не нужно и не следует загружать что-то из app с помощью require. Эта особенность называется автоматическая загрузка, и о ней можно узнать подробнее в Автозагрузка и перезагрузка констант.

Вызовы require нужны только в двух случаях:

• Чтобы загружать файлы из директории lib.
• Чтобы загружать зависимости гемов, у которых require: false в Gemfile.

Только что мы обсудили маршруты, контроллеры, экшны и вью. Это все типичные части веб приложения, соответствующего паттерну MVC (Model-View-Controller). MVC это шаблон проектирования, разделяющий ответственности приложения для его упрощения. Rails по соглашению следует этому шаблону проектирования.

Поскольку у нас уже есть контроллер и вью, давайте сгенерируем следующую часть: модель.

Модель это класс Ruby, используемый для представления данных. Кроме этого, модели могут взаимодействовать с базой данных приложения с помощью особенности Rails, называемой Active Record.

Для определения модели используем генератор модели:

$ bin/rails generate model Article title:string body:text

Имена моделей в единственном числе, так как инициализированная модель представляет единственную запись данных. Чтобы запомнить это соглашение, думайте о том, как вы хотели вызвать конструктор модели: мы хотим писать Article.new(...), а не Articles.new(...).

Это создаст несколько файлов:

invoke  active_record
create    db/migrate/<timestamp>_create_articles.rb
create    app/models/article.rb
invoke    test_unit
create      test/models/article_test.rb
create      test/fixtures/articles.yml

Два файла, на которых мы сфокусируемся, это файл миграции (db/migrate/<timestamp>_create_articles.rb) и файл модели (app/models/article.rb).

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

Давайте посмотрим на содержимое нового файла миграции:

class CreateArticles < ActiveRecord::Migration[7.0]
  def change
    create_table :articles do |t|
      t.string :title
      t.text :body

      t.timestamps
    end
  end
end

Вызов create_table указывает, как должна быть сконструирована таблица articles. По умолчанию метод create_table добавляет столбец id в качестве автоматически увеличивающегося первичного ключа. Таким образом, у первой записи в таблице будет id 1, у следующей записи id 2, и так далее.

В блоке для create_table определены два столбца: title и body. Они были добавлены генератором, так как мы включили их в команду генерации (bin/rails generate model Article title:string body:text).

В последней строчке блока вызывается t.timestamps. Этот метод определяет два дополнительных столбца с именами created_at и updated_at. Как мы увидим, Rails позаботится о них, устанавливая значения при создании или обновлении объекта модели.

Давайте запустим нашу миграцию с помощью следующей команды:

Эта команда выведет, что таблица была создана:

==  CreateArticles: migrating ===================================
-- create_table(:articles)
   -> 0.0018s
==  CreateArticles: migrated (0.0018s) ==========================

Теперь мы можем взаимодействовать с этой таблицей с помощью нашей модели.

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

Давайте запустим консоль с помощью команды:

Вы должны увидеть интерфейс irb наподобие:

Loading development environment (Rails 7.0.0)
irb(main):001:0>

В этом интерфейсе можно инициализировать новый объект Article:

irb> article = Article.new(title: "Hello Rails", body: "I am on Rails!")

Важно отметить, что мы только инициализировали этот объект. Этот объект вообще не сохранен в базе данных. В настоящий момент он доступен только в консоли. Чтобы сохранить его в базу данных, нужно вызвать save:

irb> article.save
(0.1ms)  begin transaction
Article Create (0.4ms)  INSERT INTO "articles" ("title", "body", "created_at", "updated_at") VALUES (?, ?, ?, ?)  [["title", "Hello Rails"], ["body", "I am on Rails!"], ["created_at", "2020-01-18 23:47:30.734416"], ["updated_at", "2020-01-18 23:47:30.734416"]]
(0.9ms)  commit transaction
=> true

Вышеуказанный вывод показывает запрос базы данных INSERT INTO "articles" .... Это показывает, что статья была вставлена в нашу таблицу. И если мы снова взглянем на объект article, то увидим, что произошло нечто интересное:

irb> article
=> #<Article id: 1, title: "Hello Rails", body: "I am on Rails!", created_at: "2020-01-18 23:47:30", updated_at: "2020-01-18 23:47:30">

Теперь у объекта установлены атрибуты id, created_at и updated_at. Rails сделал это, когда мы сохранили объект.

Когда мы хотим извлечь эту статью из базы данных, можно вызвать find на модели и передать id в качестве аргумента:

irb> Article.find(1)
=> #<Article id: 1, title: "Hello Rails", body: "I am on Rails!", created_at: "2020-01-18 23:47:30", updated_at: "2020-01-18 23:47:30">

И когда мы хотим извлечь все статьи из базы данных, можно вызвать all на модели:

irb> Article.all
=> #<ActiveRecord::Relation [#<Article id: 1, title: "Hello Rails", body: "I am on Rails!", created_at: "2020-01-18 23:47:30", updated_at: "2020-01-18 23:47:30">]>

Этот метод возвращает объект ActiveRecord::Relation, о котором можно думать, как о массиве с особыми способностями.

Модели это последний кусочек пазла MVC. Далее мы соединим все кусочки вместе.

Давайте вернемся к нашему контроллеру в app/controllers/articles_controller.rb и изменим экшн index, чтобы он извлекал все статьи из базы данных:

class ArticlesController < ApplicationController
  def index
    @articles = Article.all
  end
end

К переменным экземпляра контроллера можно получить доступ из вью. Это означает, что мы можем ссылаться на @articles в app/views/articles/index.html.erb. Давайте откроем этот файл и заменим его содержимое на:

<h1>Articles</h1>

<ul>
  <% @articles.each do |article| %>
    <li>
      <%= article.title %>
    </li>
  <% end %>
</ul>

Вышеприведенный код это смесь HTML и ERB. ERB это система шаблонирования, которая вычисляет код Ruby, вложенный в документ. Тут мы видим два типа тегов ERB: <% %> и <%= %>. Тег <% %> означает «вычислить заключенный код Ruby». Тег <%= %> означает «вычислить заключенный код Ruby и вывести значение, которое он возвратит». Все, что можно написать в обычной программе на Ruby, можно вложить в эти теги ERB, хотя обычно лучше сохранять содержимое тегов ERB кратким, для читаемости.

Так как мы не хотим вывести значение, возвращаемое @articles.each, мы заключили этот код в <% %>. Но, поскольку мы хотим вывести значение, возвращаемое article.title (для каждой статьи), мы заключили этот код в <%= %>.

Окончательный результат можно увидеть, посетив http://localhost:3000. (Помните, что bin/rails server должен быть запущен!) Вот что произойдет при этом:

• Браузер сделает запрос: GET http://localhost:3000.
• Наше приложение Rails получит этот запрос.
• Роутер Rails свяжет корневой маршрут с экшном index в ArticlesController.
• Экшн index использует модель Article для извлечения всех статей из базы данных.
• Rails автоматически отрендерит вью app/views/articles/index.html.erb.
• Вычисляется код ERB во вью для вывода HTML.
• Сервер отправит отклик, содержащий HTML, обратно браузеру.

Мы соединили все кусочки MVC вместе, и теперь у нас есть наш первый экшн контроллера! Далее мы двинемся ко второму экшну.

Почти все веб приложения используют операции CRUD (Create, Read, Update, and Delete). Можно обнаружить, что большая часть работы вашего приложения это CRUD. Rails знает об этом и предоставляет много особенностей для упрощения кода, осуществляющего CRUD.

Давайте исследуем эти возможности, добавив больше функционала в наше приложение.

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

Начнем с добавления нового маршрута, направляющего на новый экшн контроллера (который затем тоже добавим). Откройте config/routes.rb и вставьте последний маршрут, показанный тут:

Rails.application.routes.draw do
  root "articles#index"

  get "/articles", to: "articles#index"
  get "/articles/:id", to: "articles#show"
end

Новый маршрут является еще одним маршрутом get, но есть кое-что дополнительное в его пути: :id. Это означает параметр маршрута. Параметр маршрута захватывает сегмент пути запроса, и кладет это значение в хэш params, доступный в экшне контроллера. Например, при обработке запроса GET http://localhost:3000/articles/1, 1 будет захвачено как значение для :id, и будет доступно как params[:id] в экшне show в ArticlesController.

Теперь давайте добавим этот экшн show, ниже экшна index в app/controllers/articles_controller.rb:

class ArticlesController < ApplicationController
  def index
    @articles = Article.all
  end

  def show
    @article = Article.find(params[:id])
  end
end

Экшн show вызывает Article.find (упомянутый ранее) с ID, захваченным параметром маршрута. Возвращаемая статья хранится в переменной экземпляра @article, поэтому она доступна во вью. По умолчанию экшн show отрендерит app/views/articles/show.html.erb.

Давайте создадим app/views/articles/show.html.erb со следующим содержимым:

<h1><%= @article.title %></h1>

<p><%= @article.body %></p>

Теперь можно увидеть статью при посещении http://localhost:3000/articles/1!

В завершении, давайте добавим удобный способ перейти на страницу статьи. Мы свяжем заголовок каждой статьи в app/views/articles/index.html.erb с ее страницей:

<h1>Articles</h1>

<ul>
  <% @articles.each do |article| %>
    <li>
      <a href="/articles/<%= article.id %>">
        <%= article.title %>
      </a>
    </li>
  <% end %>
</ul>

К этому моменту мы раскрыли «R» (Read) из CRUD. Со временем мы раскроем «C» (Create), «U» (Update) и «D» (Delete). Как вы, возможно, догадались, мы сделаем это, добавив новые маршруты, экшны контроллера и вью. Всякий раз, когда у нас есть такая комбинация маршрутов, экшнов контроллера и вью, работающих вместе для выполнения операций CRUD на сущности, мы называем эту сущность ресурсом. Например, в нашем приложении, мы бы назвали статью ресурсом.

Rails предоставляет маршрутный метод resources, который связывает все общепринятые маршруты для коллекции ресурсов, таких как статьи. Поэтому, до того, как мы перейдем к разделам «C», «U» и «D», давайте заменим два маршрута get в config/routes.rb на resources:

Rails.application.routes.draw do
  root "articles#index"

  resources :articles
end

Можно посмотреть, какие маршруты связаны, запустив команду bin/rails routes:

$ bin/rails routes
      Prefix Verb   URI Pattern                  Controller#Action
        root GET    /                            articles#index
    articles GET    /articles(.:format)          articles#index
 new_article GET    /articles/new(.:format)      articles#new
     article GET    /articles/:id(.:format)      articles#show
             POST   /articles(.:format)          articles#create
edit_article GET    /articles/:id/edit(.:format) articles#edit
             PATCH  /articles/:id(.:format)      articles#update
             DELETE /articles/:id(.:format)      articles#destroy

Метод resources также настраивает вспомогательные методы URL и путей, которые можно использовать для предотвращения зависимостей нашего кода от настроек определенного маршрута. Значения выше в столбце «Prefix» плюс суффикс _url или _path формируют имена этих хелперов. Например, хелпер article_path возвращает "/articles/#{article.id}" для заданной статьи. Его можно использовать для приведения в порядок наших ссылок в app/views/articles/index.html.erb:

<h1>Articles</h1>

<ul>
  <% @articles.each do |article| %>
    <li>
      <a href="<%= article_path(article) %>">
        <%= article.title %>
      </a>
    </li>
  <% end %>
</ul>

Однако, мы сделаем еще один шаг вперед и используем хелпер link_to. Хелпер link_to создает ссылку с первым аргументом в качестве текста ссылки и вторым аргументом в качестве адреса ссылки. Если мы передадим объект модели как второй аргумент, link_to вызовет подходящий хелпер пути для преобразования объекта в путь. Например, если мы передадим статью, link_to вызовет article_path. Таким образом, app/views/articles/index.html.erb станет:

<h1>Articles</h1>

<ul>
  <% @articles.each do |article| %>
    <li>
      <%= link_to article.title, article %>
    </li>
  <% end %>
</ul>

Отлично!

Теперь мы подходим к «C» (Create) из CRUD. Обычно, в веб приложениях, создание нового ресурса это многошаговый процесс. Сначала пользователь запрашивает форму для заполнения. Затем пользователь отправляет форму. Если нет ошибок, то ресурс создается, и отображается некоторое подтверждение. Иначе, форма снова отображается с сообщениями об ошибке, и процесс повторяется.

В приложении Rails эти шаги традиционно обрабатываются экшнами контроллера new и create. Давайте добавим типичную реализацию этих экшнов в app/controllers/articles_controller.rb, ниже экшна show:

class ArticlesController < ApplicationController
  def index
    @articles = Article.all
  end

  def show
    @article = Article.find(params[:id])
  end

  def new
    @article = Article.new
  end

  def create
    @article = Article.new(title: "...", body: "...")

    if @article.save
      redirect_to @article
    else
      render :new, status: :unprocessable_entity
    end
  end
end

Экшн new инициализирует новую статью, но не сохраняет ее. Эта статья будет использована во вью при построении формы. По умолчанию экшн new будет рендерить app/views/articles/new.html.erb, которую мы создадим далее.

Экшн create инициализирует новую статью со значениями для заголовка и содержимого и пытается сохранить ее. Если статью успешно сохранена, экшн перенаправляет браузер на страницу статьи "http://localhost:3000/articles/#{@article.id}". Иначе экшн отображает форму заново, отрендерив app/views/articles/new.html.erb с кодом статуса 422 Unprocessable Entity. Тут title и body фиктивные значения. После того, как мы создадим форму, мы вернемся и изменим их.

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

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

Давайте создадим app/views/articles/new.html.erb со следующим содержимым:

<h1>New Article</h1>

<%= form_with model: @article do |form| %>
  <div>
    <%= form.label :title %><br>
    <%= form.text_field :title %>
  </div>

  <div>
    <%= form.label :body %><br>
    <%= form.text_area :body %>
  </div>

  <div>
    <%= form.submit %>
  </div>
<% end %>

Вспомогательный метод form_with инициализирует построитель форм. В блоке form_with мы вызываем на построителе форм методы, такие как label и text_field для вывода подходящих элементов формы.

Результирующий вывод от вызова form_with будет выглядеть так:

<form action="/articles" accept-charset="UTF-8" method="post">
  <input type="hidden" name="authenticity_token" value="...">

  <div>
    <label for="article_title">Title</label><br>
    <input type="text" name="article[title]" id="article_title">
  </div>

  <div>
    <label for="article_body">Body</label><br>
    <textarea name="article[body]" id="article_body"></textarea>
  </div>

  <div>
    <input type="submit" name="commit" value="Create Article" data-disable-with="Create Article">
  </div>
</form>

Отправленные данные формы вкладываются в хэш params, вместе с захваченными параметрами маршрута. Таким образом, экшн create имеет доступ к отправленному заголовку как params[:article][:title] и к отправленному содержимому как params[:article][:body]. Эти значения можно передать в Article.new отдельно, но это может быть некрасиво и подвержено ошибкам. И это будет еще хуже, когда мы добавим больше полей.

Вместо этого, мы передадим единственный хэш, содержащий значения. Однако, мы все еще должны указать, какие значения допустимы в этом хэше. В противном случае, злоумышленник потенциально может отправить дополнительные поля формы и перезаписать конфиденциальные данные. Фактически, если мы передадим нефильтрованный хэш params[:article] непосредственно в Article.new, Rails вызовет ForbiddenAttributesError, чтобы предупредить нас о проблеме. Таким образом, мы будем использовать особенность Rails, названную Strong Parameters, для фильтрации params. Представьте это как сильную типизацию для params.

Давайте добавим приватный метод внизу app/controllers/articles_controller.rb, названный article_params, фильтрующий params. И давайте изменим create, чтобы использовать его:

class ArticlesController < ApplicationController
  def index
    @articles = Article.all
  end

  def show
    @article = Article.find(params[:id])
  end

  def new
    @article = Article.new
  end

  def create
    @article = Article.new(article_params)

    if @article.save
      redirect_to @article
    else
      render :new, status: :unprocessable_entity
    end
  end

  private
    def article_params
      params.require(:article).permit(:title, :body)
    end
end

Как мы видели, создание ресурса это многоступенчатый процесс. Обработка неправильного пользовательского ввода это еще один шаг этого процесса. Rails предоставляет особенность валидации, чтобы помочь нам разобраться с неправильным пользовательским вводом. Валидации это правила, проверяемые до сохранения объекта модели. Если любая из проверок провалится, сохранение будет прервано, и соответствующие сообщения об ошибке будут добавлены в атрибут errors у объекта модели.

Давайте добавим некоторые валидации в нашу модель в app/models/article.rb:

class Article < ApplicationRecord
  validates :title, presence: true
  validates :body, presence: true, length: { minimum: 10 }
end

Первая валидация объявляет, что должно присутствовать значение title. Так как title строка, это означает, что значение title должно содержать как минимум один не пробельный символ.

Вторая валидация объявляет, что значение body также должно присутствовать. Кроме этого, она объявляет, что длина значения body должно быть как минимум 10 символов.

Возможно, вам интересно, где определены атрибуты title и body. Active Record автоматически определяет атрибуты модели для каждого столбца таблицы, таким образом, не нужно объявлять эти атрибуты в файле модели.

С имеющимися валидациями, давайте изменим app/views/articles/new.html.erb для отображения любых сообщений об ошибке для title и body:

<h1>New Article</h1>

<%= form_with model: @article do |form| %>
  <div>
    <%= form.label :title %><br>
    <%= form.text_field :title %>
    <% @article.errors.full_messages_for(:title).each do |message| %>
      <div><%= message %></div>
    <% end %>
  </div>

  <div>
    <%= form.label :body %><br>
    <%= form.text_area :body %><br>
    <% @article.errors.full_messages_for(:body).each do |message| %>
      <div><%= message %></div>
    <% end %>
  </div>

  <div>
    <%= form.submit %>
  </div>
<% end %>

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

Чтобы понять, как это все работает, давайте снова взглянем на экшны new и create контроллера:

  def new
    @article = Article.new
  end

  def create
    @article = Article.new(article_params)

    if @article.save
      redirect_to @article
    else
      render :new, status: :unprocessable_entity
    end
  end

При посещении http://localhost:3000/articles/new, запрос GET /articles/new направляется на экшн new. Экшн new не пытается сохранить @article. Следовательно, валидации не проверяются, и сообщений об ошибке не будет.

При отправке формы, запрос POST /articles направляется на экшн create. Экшн create пытается сохранить @article. Следовательно, валидации проверяются. Если любая из валидаций падает, @article не будет сохранена, и app/views/articles/new.html.erb будет отрендерена с сообщением об ошибке.

Теперь мы можем создать статью, посетив http://localhost:3000/articles/new. Для завершения давайте добавим ссылку на эту страницу внизу app/views/articles/index.html.erb:

<h1>Articles</h1>

<ul>
  <% @articles.each do |article| %>
    <li>
      <%= link_to article.title, article %>
    </li>
  <% end %>
</ul>

<%= link_to "New Article", new_article_path %>

Мы покрыли «CR» от CRUD. Теперь перейдем к «U» (Update). Обновление ресурса очень похоже на создание ресурса. Они оба многоступенчатые процессы. Во-первых, пользователь запрашивает форму для редактирования данных. Затем пользователь отправляет форму. Затем, если не было ошибок, ресурс обновляется. В противном случае, форма снова отображается с сообщениями об ошибке, и процесс повторяется.

По соглашениям, эти шаги обрабатываются экшнами edit и update контроллера. Давайте добавим типичную реализацию этих экшнов в app/controllers/articles_controller.rb, ниже экшнаcreate:

class ArticlesController < ApplicationController
  def index
    @articles = Article.all
  end

  def show
    @article = Article.find(params[:id])
  end

  def new
    @article = Article.new
  end

  def create
    @article = Article.new(article_params)

    if @article.save
      redirect_to @article
    else
      render :new, status: :unprocessable_entity
    end
  end

  def edit
    @article = Article.find(params[:id])
  end

  def update
    @article = Article.find(params[:id])

    if @article.update(article_params)
      redirect_to @article
    else
      render :edit, status: :unprocessable_entity
    end
  end

  private
    def article_params
      params.require(:article).permit(:title, :body)
    end
end

Обратите внимание, как похожи экшны edit и update на экшны new и create.

Экшн edit извлекает статью из базы данных и сохраняет ее в @article, таким образом ее можно использовать при построении формы. По умолчанию экшн edit отрендерит app/views/articles/edit.html.erb.

Экшн update (пере)извлекает статью из базы данных и пытается обновить ее с помощью отправленных данных формы, фильтрованных в article_params. Если ни одна валидация не упадет, и обновление будет успешным, этот экшн перенаправит браузер на страницу статьи. В противном случае, экшн повторно отобразит форму — с сообщениями об ошибке — отрендерив app/views/articles/edit.html.erb.

Форма edit будет выглядеть такой же, как форма new. Даже код будет тем же, благодаря построителю форм Rails и ресурсному роутингу. Построитель форм автоматически настроит форму для осуществления подходящего типа запроса, основываясь на том, был ли объект модели ранее сохранен.

Так как код будет тем же самым, мы собираемся рефакторить его в совместную вью, называемую партиал. Давайте создадим app/views/articles/_form.html.erb со следующим содержимым:

<%= form_with model: article do |form| %>
  <div>
    <%= form.label :title %><br>
    <%= form.text_field :title %>
    <% article.errors.full_messages_for(:title).each do |message| %>
      <div><%= message %></div>
    <% end %>
  </div>

  <div>
    <%= form.label :body %><br>
    <%= form.text_area :body %><br>
    <% article.errors.full_messages_for(:body).each do |message| %>
      <div><%= message %></div>
    <% end %>
  </div>

  <div>
    <%= form.submit %>
  </div>
<% end %>

Вышеприведенный код тот же самый, что и форма в app/views/articles/new.html.erb, за исключением того, что все случаи @article заменены на article. Так как партиалы являются совместным кодом, хорошим тоном является не делать их зависимыми от определенных переменных экземпляра, установленных экшном контроллера. Вместо этого, мы передадим статью в партиал как локальную переменную.

Давайте обновим app/views/articles/new.html.erb, чтобы использовать этот партиал с помощью render:

<h1>New Article</h1>

<%= render "form", article: @article %>

Имя файла партиала должно начинаться на подчеркивание, т.е. _form.html.erb. Но при рендеринге ссылаемся на него без подчеркивания, т.е. render "form".

И теперь давайте создадим очень похожий app/views/articles/edit.html.erb:

<h1>Edit Article</h1>

<%= render "form", article: @article %>

Теперь мы можем обновлять статью, посетив страницу ее редактирования, т.е. http://localhost:3000/articles/1/edit. Для завершения, давайте добавим ссылку на страницу редактирования внизу app/views/articles/show.html.erb:

<h1><%= @article.title %></h1>

<p><%= @article.body %></p>

<ul>
  <li><%= link_to "Edit", edit_article_path(@article) %></li>
</ul>

Наконец, мы добрались до «D» (Delete) из CRUD. Удаление ресурса это более простой процесс, чем создание или обновление. Он требует только маршрут и экшн контроллера. И наш ресурсный роутинг (resources :articles) уже предоставляет этот маршрут, связывающий запросы DELETE /articles/:id с экшном destroy в ArticlesController.

Итак, давайте добавим типичный экшн destroy в app/controllers/articles_controller.rb ниже экшна update:

class ArticlesController < ApplicationController
  def index
    @articles = Article.all
  end

  def show
    @article = Article.find(params[:id])
  end

  def new
    @article = Article.new
  end

  def create
    @article = Article.new(article_params)

    if @article.save
      redirect_to @article
    else
      render :new, status: :unprocessable_entity
    end
  end

  def edit
    @article = Article.find(params[:id])
  end

  def update
    @article = Article.find(params[:id])

    if @article.update(article_params)
      redirect_to @article
    else
      render :edit, status: :unprocessable_entity
    end
  end

  def destroy
    @article = Article.find(params[:id])
    @article.destroy

    redirect_to root_path, status: :see_other
  end

  private
    def article_params
      params.require(:article).permit(:title, :body)
    end
end

Экшн destroy извлекает статью из базы данных, и вызывает destroy на ней. Затем он перенаправляет браузер на корневой путь со статусом кода 303 See Other.

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

Теперь давайте добавим ссылку внизу app/views/articles/show.html.erb, чтобы мы могли удалить статью с ее страницы:

<h1><%= @article.title %></h1>

<p><%= @article.body %></p>

<ul>
  <li><%= link_to "Edit", edit_article_path(@article) %></li>
  <li><%= link_to "Destroy", article_path(@article), data: {
                    turbo_method: :delete,
                    turbo_confirm: "Are you sure?"
                  } %></li>
</ul>

В вышеприведенном коде мы используем опцию data для установки HTML-атрибутов data-turbo-method и data-turbo-confirm ссылки «Destroy». Оба этих атрибута подключаются к Turbo, который по умолчанию включен в новые приложения Rails. data-turbo-method="delete" заставит ссылку сделать запрос DELETE вместо запроса GET. data-turbo-confirm="Are you sure?" приведет к появлению диалогового окна подтверждения при нажатии на ссылку. Если пользователь отменит диалог, запрос будет прерван.

Вот и все! Теперь можно просматривать, создавать, обновлять и удалять статьи!

Настало время добавить вторую модель в приложение. Вторая модель будет обрабатывать комментарии к статьям.

Мы намереваемся использовать тот же генератор, что мы использовали ранее при создании модели Article. В этот раз мы создадим модель Comment, содержащую ссылку на статью. Запустите следующую команду в терминале:

$ bin/rails generate model Comment commenter:string body:text article:references

Эта команда генерирует четыре файла:

Сначала взглянем на app/models/comment.rb:

class Comment < ApplicationRecord
  belongs_to :article
end

Это очень похоже на модель Article, которую мы видели ранее. Разница в строчке belongs_to :article, которая устанавливает связь Active Record. Вы ознакомитесь со связями в следующем разделе руководства.

Ключевое слово (:references), использованное в команде консоли, это специальный тип данных для моделей. Он создает новый столбец в вашей базе данных с именем представленной модели с добавленным _id, который может содержать числовые значения. Чтобы лучше понять, проанализируйте файл db/schema.rb после выполнения миграции.

В дополнение к модели, Rails также сделал миграцию для создания соответствующей таблицы базы данных:

class CreateComments < ActiveRecord::Migration[7.0]
  def change
    create_table :comments do |t|
      t.string :commenter
      t.text :body
      t.references :article, null: false, foreign_key: true

      t.timestamps
    end

  end
end

Строчка t.references создает числовой столбец с именем article_id, индекс для него, и ограничение внешнего ключа, указывающего на столбец id таблицы articles. Далее запускаем миграцию:

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

==  CreateComments: migrating =================================================
-- create_table(:comments)
   -> 0.0115s
==  CreateComments: migrated (0.0119s) ========================================

Связи Active Record позволяют Вам легко объявлять отношения между двумя моделями. В случае с комментариями и статьями, вы можете описать отношения следующим образом:

• Каждый комментарий принадлежит одной статье.
• Одна статья может иметь много комментариев.

Фактически, это очень близко к синтаксису, который использует Rails для объявления этой связи. Вы уже видели строчку кода в модели Comment (app/models/comment.rb), которая делает каждый комментарий принадлежащим статье:

class Comment < ApplicationRecord
  belongs_to :article
end

Вам нужно отредактировать app/models/article.rb, добавив другую сторону связи:

class Article < ApplicationRecord
  has_many :comments

  validates :title, presence: true
  validates :body, presence: true, length: { minimum: 10 }
end

Эти два объявления автоматически делают доступным большое количество возможностей. Например, если у вас есть переменная экземпляра @article, содержащая статью, вы можете получить все комментарии, принадлежащие этой статье, в массиве, вызвав @article.comments.

Как в случае с контроллером articles, нам нужно добавить маршрут, чтобы Rails знал, по какому адресу мы хотим пройти, чтобы увидеть комментарии. Снова откройте файл config/routes.rb и отредактируйте его следующим образом:

Rails.application.routes.draw do
  root "articles#index"

  resources :articles do
    resources :comments
  end
end

Это создаст comments как вложенный ресурс в articles. Это другая сторона захвата иерархических отношений, существующих между статьями и комментариями.

Более подробно о роутинге написано в руководстве Роутинг в Rails.

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

$ bin/rails generate controller Comments

Создадутся три файла и пустая директория:

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

Сначала мы расширим шаблон Article show (app/views/articles/show.html.erb), чтобы он позволял добавить новый комментарий:

<h1><%= @article.title %></h1>

<p><%= @article.body %></p>

<ul>
  <li><%= link_to "Edit", edit_article_path(@article) %></li>
  <li><%= link_to "Destroy", article_path(@article), data: {
                    turbo_method: :delete,
                    turbo_confirm: "Are you sure?"
                  } %></li>
</ul>

<h2>Add a comment:</h2>
<%= form_with model: [ @article, @article.comments.build ] do |form| %>
  <p>
    <%= form.label :commenter %><br>
    <%= form.text_field :commenter %>
  </p>
  <p>
    <%= form.label :body %><br>
    <%= form.text_area :body %>
  </p>
  <p>
    <%= form.submit %>
  </p>
<% end %>

Это добавит форму на страницу отображения статьи, создающую новый комментарий при вызове экшна create в CommentsController. Тут вызов form_with использует массив, что создаст вложенный маршрут, такой как /articles/1/comments.

Давайте напишем create в app/controllers/comments_controller.rb:

class CommentsController < ApplicationController
  def create
    @article = Article.find(params[:article_id])
    @comment = @article.comments.create(comment_params)
    redirect_to article_path(@article)
  end

  private
    def comment_params
      params.require(:comment).permit(:commenter, :body)
    end
end

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

Кроме того, код пользуется преимуществом некоторых методов, доступных для связей. Мы используем метод create на @article.comments, чтобы создать и сохранить комментарий. Это автоматически связывает комментарий так, что он принадлежит к определенной статье.

Как только мы создали новый комментарий, мы возвращаем пользователя обратно на оригинальную статью, используя хелпер article_path(@article). Как мы уже видели, он вызывает экшн show в ArticlesController, который, в свою очередь, рендерит шаблон show.html.erb. В этом месте мы хотим отображать комментарии, поэтому давайте добавим следующее в app/views/articles/show.html.erb.

<h1><%= @article.title %></h1>

<p><%= @article.body %></p>

<ul>
  <li><%= link_to "Edit", edit_article_path(@article) %></li>
  <li><%= link_to "Destroy", article_path(@article), data: {
                    turbo_method: :delete,
                    turbo_confirm: "Are you sure?"
                  } %></li>
</ul>

<h2>Comments</h2>
<% @article.comments.each do |comment| %>
  <p>
    <strong>Commenter:</strong>
    <%= comment.commenter %>
  </p>

  <p>
    <strong>Comment:</strong>
    <%= comment.body %>
  </p>
<% end %>

<h2>Add a comment:</h2>
<%= form_with model: [ @article, @article.comments.build ] do |form| %>
  <p>
    <%= form.label :commenter %><br>
    <%= form.text_field :commenter %>
  </p>
  <p>
    <%= form.label :body %><br>
    <%= form.text_area :body %>
  </p>
  <p>
    <%= form.submit %>
  </p>
<% end %>

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

Теперь, когда у нас есть работающие статьи и комментарии, взглянем на шаблон app/views/articles/show.html.erb. Он стал длинным и неудобным. Давайте воспользуемся партиалами, чтобы разгрузить его.

Сначала сделаем партиал для комментариев, показывающий все комментарии для статьи. Создайте файл app/views/comments/_comment.html.erb и поместите в него следующее:

<p>
  <strong>Commenter:</strong>
  <%= comment.commenter %>
</p>

<p>
  <strong>Comment:</strong>
  <%= comment.body %>
</p>

Затем можно изменить app/views/articles/show.html.erb вот так:

<h1><%= @article.title %></h1>

<p><%= @article.body %></p>

<ul>
  <li><%= link_to "Edit", edit_article_path(@article) %></li>
  <li><%= link_to "Destroy", article_path(@article), data: {
                    turbo_method: :delete,
                    turbo_confirm: "Are you sure?"
                  } %></li>
</ul>

<h2>Comments</h2>
<%= render @article.comments %>

<h2>Add a comment:</h2>
<%= form_with model: [ @article, @article.comments.build ] do |form| %>
  <p>
    <%= form.label :commenter %><br>
    <%= form.text_field :commenter %>
  </p>
  <p>
    <%= form.label :body %><br>
    <%= form.text_area :body %>
  </p>
  <p>
    <%= form.submit %>
  </p>
<% end %>

Теперь это отрендерит партиал app/views/comments/_comment.html.erb по разу для каждого комментария в коллекции @article.comments. Так как метод render перебирает коллекцию @article.comments, он назначает каждый комментарий локальной переменной с именем, как у партиала, в нашем случае comment, которая нам доступна в партиале для отображения.

Давайте также переместим раздел нового комментария в свой партиал. Опять же, создайте файл app/views/comments/_form.html.erb, содержащий:

<%= form_with model: [ @article, @article.comments.build ] do |form| %>
  <p>
    <%= form.label :commenter %><br>
    <%= form.text_field :commenter %>
  </p>
  <p>
    <%= form.label :body %><br>
    <%= form.text_area :body %>
  </p>
  <p>
    <%= form.submit %>
  </p>
<% end %>

Затем измените app/views/articles/show.html.erb следующим образом:

<h1><%= @article.title %></h1>

<p><%= @article.body %></p>

<ul>
  <li><%= link_to "Edit", edit_article_path(@article) %></li>
  <li><%= link_to "Destroy", article_path(@article), data: {
                    turbo_method: :delete,
                    turbo_confirm: "Are you sure?"
                  } %></li>
</ul>

<h2>Comments</h2>
<%= render @article.comments %>

<h2>Add a comment:</h2>
<%= render 'comments/form' %>

Второй render всего лишь определяет шаблон партиала, который мы хотим рендерить, comments/form. Rails достаточно сообразительный, чтобы подставить подчеркивание в эту строку и понять, что Вы хотели рендерить файл _form.html.erb в директории app/views/comments.

Объект @article доступен в любых партиалах, рендерящихся во вью, так как мы определили его как переменную экземпляра.

Concerns — это способ упростить большие контроллеры или модели для лучшего понимания и управления. У этого также есть преимущество повторного использования, когда несколько моделей (или контроллеров) разделяют те же самые concerns. Concerns реализуются с помощью модулей, содержащих методы, представляющие четко очерченный срез функциональности, за которую ответственны модель или контроллер. В других языках модули часто называются миксинами (mixin).

В контроллере или модели concerns можно использовать так же, как вы бы использовали другой модуль. Когда вы только создали свое приложение с помощью rails new blog, среди прочего в app/ были созданы две папки:

app/controllers/concerns
app/models/concerns

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

У статьи в блоге могут быть различные статусы — к примеру, она может быть видимой для всех (т.е. public) или только видимой для автора (т.е. private). Она также может быть скрытой, но все еще доступной (т.е. archived). Комментарии схожим образом могут быть скрытыми или видимыми. Это может быть представлено с помощью столбца status в каждой модели.

Сначала давайте запустим следующие миграции для добавления status в Articles и Comments:

$ bin/rails generate migration AddStatusToArticles status:string
$ bin/rails generate migration AddStatusToComments status:string

А затем давайте обновим базу данных с помощью сгенерированных миграций:

Чтобы выбрать статус для существующих статей и комментариев, можно добавить значение по умолчанию в сгенерированные файлы миграции, добавив опцию default: "public" и запустив миграции заново. Также можно вызвать в консоли rails Article.update_all(status: "public") и Comment.update_all(status: "public").

Также нужно разрешить ключ :status, как часть strong parameter, в app/controllers/articles_controller.rb:

  private
    def article_params
      params.require(:article).permit(:title, :body, :status)
    end

и в app/controllers/comments_controller.rb:

  private
    def comment_params
      params.require(:comment).permit(:commenter, :body, :status)
    end

В модель article, после запуска миграции для добавления столбца status с помощью bin/rails db:migrate, можно добавить:

class Article < ApplicationRecord
  has_many :comments

  validates :title, presence: true
  validates :body, presence: true, length: { minimum: 10 }

  VALID_STATUSES = ['public', 'private', 'archived']

  validates :status, inclusion: { in: VALID_STATUSES }

  def archived?
    status == 'archived'
  end
end

и в модель Comment:

class Comment < ApplicationRecord
  belongs_to :article

  VALID_STATUSES = ['public', 'private', 'archived']

  validates :status, inclusion: { in: VALID_STATUSES }

  def archived?
    status == 'archived'
  end
end

Затем, в шаблоне экшна index (app/views/articles/index.html.erb) мы могли бы использовать метод archived?, чтобы избежать отображения любой архивированной статьи:

<h1>Articles</h1>

<ul>
  <% @articles.each do |article| %>
    <% unless article.archived? %>
      <li>
        <%= link_to article.title, article %>
      </li>
    <% end %>
  <% end %>
</ul>

<%= link_to "New Article", new_article_path %>

Схожим образом в нашем партиале (app/views/comments/_comment.html.erb) мы могли бы использовать метод archived?, чтоб избежать отображения любого архивированного комментария:

<% unless comment.archived? %>
  <p>
    <strong>Commenter:</strong>
    <%= comment.commenter %>
  </p>

  <p>
    <strong>Comment:</strong>
    <%= comment.body %>
  </p>
<% end %>

Однако, если посмотреть на наши модели, можно заметить, что логика дублируется. Если в будущем мы улучшим функционал нашего блога — включим приватные сообщения, к примеру — мы можем снова начать дублировать логику. Вот тут-то и пригодятся concerns.

Concern ответственен только за конкретную часть ответственности модели; все методы нашего concern будут относиться к видимости модели. Давайте назовем новый concern (модуль) Visible. Можно создать новый файл в app/models/concerns с именем visible.rb, и хранить все методы статуса, которые продублированы в моделях.

app/models/concerns/visible.rb

module Visible
  def archived?
    status == 'archived'
  end
end

Также можно добавить наши валидации статуса в concern, но это немного сложнее, так как валидации — это методы, вызванные на уровне класса. ActiveSupport::Concern (руководство по API) предоставляет нам более простой способ включить их:

module Visible
  extend ActiveSupport::Concern

  VALID_STATUSES = ['public', 'private', 'archived']

  included do
    validates :status, inclusion: { in: VALID_STATUSES }
  end

  def archived?
    status == 'archived'
  end
end

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

В app/models/article.rb:

class Article < ApplicationRecord
  include Visible

  has_many :comments

  validates :title, presence: true
  validates :body, presence: true, length: { minimum: 10 }
end

и в app/models/comment.rb:

class Comment < ApplicationRecord
  include Visible

  belongs_to :article
end

Методы класса также можно добавить в concern. Если нам нужно отображать количество публичных статей или комментариев на главной странице, можно добавить метод класса в Visible следующим образом:

module Visible
  extend ActiveSupport::Concern

  VALID_STATUSES = ['public', 'private', 'archived']

  included do
    validates :status, inclusion: { in: VALID_STATUSES }
  end

  class_methods do
    def public_count
      where(status: 'public').count
    end
  end

  def archived?
    status == 'archived'
  end
end

Затем во вью его можно вызвать как любой другой метод класса:

<h1>Articles</h1>

Our blog has <%= Article.public_count %> articles and counting!

<ul>
  <% @articles.each do |article| %>
    <% unless article.archived? %>
      <li>
        <%= link_to article.title, article %>
      </li>
    <% end %>
  <% end %>
</ul>

<%= link_to "New Article", new_article_path %>

Наконец, добавим список выбора в формы и разрешим пользователю выбирать статус при создании новой статьи или публикации нового комментария. Также можно указать статус по умолчанию как public. В app/views/articles/_form.html.erb можно добавить:

<div>
  <%= form.label :status %><br>
  <%= form.select :status, ['public', 'private', 'archived'], selected: 'public' %>
</div>

и в app/views/comments/_form.html.erb:

<p>
  <%= form.label :status %><br>
  <%= form.select :status, ['public', 'private', 'archived'], selected: 'public' %>
</p>

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

Поэтому сначала добавим ссылку для удаления в партиал app/views/comments/_comment.html.erb:

<% unless comment.archived? %>
  <p>
    <strong>Commenter:</strong>
    <%= comment.commenter %>
  </p>

  <p>
    <strong>Comment:</strong>
    <%= comment.body %>
  </p>

  <p>
    <%= link_to "Destroy Comment", [comment.article, comment], data: {
                  turbo_method: :delete,
                  turbo_confirm: "Are you sure?"
                } %>
  </p>
<% end %>

Нажатие этой новой ссылки «Destroy Comment» запустит DELETE /articles/:article_id/comments/:id в нашем CommentsController, который затем будет использоваться для нахождения комментария, который мы хотим удалить, поэтому давайте добавим экшн destroy в наш контроллер (app/controllers/comments_controller.rb):

class CommentsController < ApplicationController

  def create
    @article = Article.find(params[:article_id])
    @comment = @article.comments.create(comment_params)
    redirect_to article_path(@article)
  end

  def destroy
    @article = Article.find(params[:article_id])
    @comment = @article.comments.find(params[:id])
    @comment.destroy
    redirect_to article_path(@article), status: :see_other
  end

  private
    def comment_params
      params.require(:comment).permit(:commenter, :body, :status)
    end
end

Экшн destroy найдет статью, которую мы просматриваем, обнаружит комментарий в коллекции @article.comments и затем уберет его из базы данных и вернет нас обратно на просмотр статьи.

Если удаляете статью, связанные с ней комментарии также должны быть удалены, в противном случае они будут просто занимать место в базе данных. Rails позволяет использовать опцию dependent на связи для достижения этого. Модифицируйте модель Article, app/models/article.rb, следующим образом:

class Article < ApplicationRecord
  include Visible

  has_many :comments, dependent: :destroy

  validates :title, presence: true
  validates :body, presence: true, length: { minimum: 10 }
end

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

Rails предоставляет аутентификационную систему HTTP, которая хорошо работает в этой ситуации.

В ArticlesController нам нужен способ блокировать доступ к различным экшнам, если пользователь не аутентифицирован. Тут мы можем использовать метод Rails http_basic_authenticate_with, разрешающий доступ к требуемым экшнам, если метод позволит это.

Чтобы использовать систему аутентификации, мы определим ее вверху нашего ArticlesController в app/controllers/articles_controller.rb. В нашем случае, мы хотим, чтобы пользователь был аутентифицирован для каждого экшна, кроме index и show, поэтому напишем так:

class ArticlesController < ApplicationController

  http_basic_authenticate_with name: "dhh", password: "secret", except: [:index, :show]

  def index
    @articles = Article.all
  end

  # пропущено для краткости

Мы также хотим позволить только аутентифицированным пользователям удалять комментарии, поэтому в CommentsController (app/controllers/comments_controller.rb) мы напишем:

class CommentsController < ApplicationController

  http_basic_authenticate_with name: "dhh", password: "secret", only: :destroy

  def create
    @article = Article.find(params[:article_id])
    # ...
  end

  # пропущено для краткости

Теперь, если попытаетесь создать новую статью, то встретитесь с вызовом базовой аутентификации HTTP:

После ввода правильного имени пользователя и пароля, вы останетесь аутентифицированным, пока не потребуется другое имя пользователя и пароль, или браузер будет закрыт.

Также для приложений на Rails доступны иные методы аутентификации. Двумя популярными дополнениями для Rails, среди прочих, являются Devise и Authlogic.

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

После того, как вы создали свое первое приложение на Rails, можете свободно его модифицировать и экспериментировать на свое усмотрение.

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

• Ruby on Rails Guides
• Ruby on Rails mailing list

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

Если вы допускаете ошибку в этой области, наиболее обычным симптомом является черный ромбик со знаком вопроса внутри, появляющийся в браузере. Другим обычным симптомом являются символы, такие как «Ã¼» появляющиеся вместо «ü». Rails предпринимает ряд внутренних шагов для смягчения общих случаев тех проблем, которые могут быть автоматически обнаружены и исправлены. Однако, если имеются внешние данные, не хранящиеся в UTF-8, это может привести к такого рода проблемам, которые не могут быть автоматически обнаружены Rails и исправлены.

Два наиболее обычных источника данных, которые не в UTF-8:

• Ваш текстовый редактор: Большинство текстовых редакторов (такие как TextMate), по умолчанию сохраняют файлы как UTF-8. Если ваш текстовый редактор так не делает, это может привести к тому, что специальные символы, введенные в ваши шаблоны (такие как é) появятся как ромбик с вопросительным знаком в браузере. Это также касается ваших файлов перевода i18N. Большинство редакторов, не устанавливающие по умолчанию UTF-8 (такие как некоторые версии Dreamweaver) предлагают способ изменить умолчания на UTF-8. Сделайте так.
• Ваша база данных: Rails по умолчанию преобразует данные из вашей базы данных в UTF-8 на границе. Однако, если ваша база данных не использует внутри UTF-8, она может не быть способной хранить все символы, которые введет ваш пользователь. Например, если ваша база данных внутри использует Latin-1, и ваш пользователь вводит русские, ивритские или японские символы, данные будут потеряны как только попадут в базу данных. Если возможно, используйте UTF-8 как внутреннее хранилище в своей базе данных.

В этом руководстве рассказывается о том,как вставать и работать с Ruby on Rails.

Прочитав этот путеводитель,вы узнаете:

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

Chapters

1. Guide Assumptions
2. Что такое Рейлс?
3. Создание проекта «Новые рельсы
   • Installing Rails
   • Создание блог-приложения
4. Hello, Rails!
   • Запуск веб-сервера
   • Скажи «Привет»,Рейлс
   • Настройка Главной страницы приложения
5. Autoloading
6. MVC и вы
   • Генерирование модели
   • Database Migrations
   • Использование модели для взаимодействия с базой данных
   • Отображение списка статей
7. CRUDit там,где должен быть CRUDit
   • Показ отдельной статьи
   • Resourceful Routing
   • Создание новой статьи
   • Обновление статьи
   • Удаление статьи
8. Добавление второй модели
   • Генерирование модели
   • Associating Models
   • Добавление маршрута для комментариев
   • Генерирование контроллера
9. Refactoring
   • Рендеринг частичных коллекций
   • Отнесение частичной формы
   • Using Concerns
10. Deleting Comments
    • Удаление связанных объектов
11. Security
    • Basic Authentication
    • Другие соображения безопасности
12. What’s Next?
13. Configuration Gotchas

1 Предположения руководства

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

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

• Официальный сайт на языке программирования рубин
• Список книг по свободному программированию

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

2 Что такое рельсы?

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

Железнодорожный является самоуверенным программным обеспечением.Оно делает предположение,что есть «лучший» способ делать вещи,и оно предназначено для того,чтобы поощрять этот способ-и в некоторых случаях препятствовать альтернативам.Если вы узнаете «The Rails Way»,вы,вероятно,обнаружите огромный рост производительности.Если вы будете продолжать привносить старые привычки других языков в разработку «Rails Way» и пытаться использовать шаблоны,которые вы выучили в другом месте,то,возможно,у вас будет меньше счастливого опыта.

Философия Rails включает в себя два основных руководящих принципа:

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

3 Создание проекта по строительству новых железных дорог

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

Следуя этому руководству, вы создадите проект Rails под названием blog , (очень) простой блог. Прежде чем вы сможете начать сборку приложения, вам необходимо убедиться, что у вас установлен сам Rails.

В приведенных ниже примерах $ используется для представления приглашения терминала в UNIX-подобной ОС, хотя оно могло быть настроено иначе. Если вы используете Windows, ваше приглашение будет выглядеть примерно так C:source_code> .

3.1 Установка рельсов

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

• Ruby
• SQLite3
• Node.js
• Yarn

3.1.1 Установка Ruby

Откройте командную строку. В macOS откройте Terminal.app; в Windows выберите «Выполнить» в меню «Пуск» и введите cmd.exe . Любые команды, перед которыми стоит знак доллара $ , следует запускать в командной строке. Убедитесь, что у вас установлена ​​текущая версия Ruby:

$ ruby 
ruby 2.7.0

Для работы Rails требуется Ruby версии 2.7.0 или более поздней.Предпочтительно использовать последнюю версию Ruby.Если возвращаемый номер версии меньше этого числа (например,2.3.7 или 1.8.7),вам необходимо установить свежую копию Ruby.

Чтобы установить Rails в Windows, вам сначала нужно установить Ruby Installer .

Чтобы узнать о других методах установки для большинства операционных систем, посетите ruby-lang.org .

3.1.2 Установка SQLite3

Вам также потребуется установка базы данных SQLite3. Многие популярные UNIX-подобные ОС поставляются с приемлемой версией SQLite3. Другие могут найти инструкции по установке на сайте SQLite3 .

Убедитесь, что он правильно установлен и в вашей загрузке PATH :

$ sqlite3 

Программа должна сообщить о своей версии.

3.1.3 Установка Node.js и Yarn

Наконец,вам потребуется установить Node.js и Yarn для управления JavaScript вашего приложения.

Найдите инструкции по установке на веб-сайте Node.js и убедитесь, что он установлен правильно, с помощью следующей команды:

$ node 

Должна быть выведена версия вашей среды выполнения Node.js.Убедитесь,что она больше,чем 8.16.0.

Чтобы установить Yarn, следуйте инструкциям по установке на веб-сайте Yarn .

Выполнение этой команды должно вывести версию Yarn:

$ yarn 

Если там написано что-то вроде «1.22.0»,значит,Yarn был установлен правильно.

3.1.4 Установка Rails

Чтобы установить Rails, используйте команду gem install , предоставленную RubyGems:

$ gem install rails

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

$ rails 

Если там написано что-то вроде «Rails 7.0.0»,вы готовы продолжить.

3.2 Создание блог-приложения

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

Чтобы использовать этот генератор,откройте терминал,перейдите в каталог,где у вас есть права на создание файлов,и выполните команду:

$ rails new blog

Это создаст приложение Rails под названием Blog в каталоге blog и установит зависимости gem, которые уже упомянуты в Gemfile , с помощью bundle install .

Вы можете увидеть все параметры командной строки, которые принимает генератор приложений Rails, запустив rails new --help .

После создания блог-приложения переключитесь на его папку:

$ cd blog

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

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

Прежде чем мы начнем ездить по Rails, давайте вспомним несколько моментов Ruby, который является основой Rails.

Рубин является удачным сочетанием –

• Концептуальная элегантность Smalltalk,
• Простота использования и обучения Python, и
• Прагматизм Perl.

Рубин – это

• Язык программирования высокого уровня.
• Интерпретируется как Perl, Python, Tcl / TK.
• Объектно-ориентированный, как Smalltalk, Eiffel, Ada, Java.

Почему Руби?

Рубин появился в Японии и сейчас набирает популярность и в США, и в Европе. Следующие факторы способствуют его популярности –

• Легко обучаема
• Открытый исходный код (очень либеральная лицензия)
• Богатые библиотеки
• Очень легко продлить
• Действительно объектно-ориентированный
• Меньше кодирования с меньшим количеством ошибок
• Полезное сообщество

Хотя у нас есть много причин использовать Ruby, у вас также есть несколько недостатков, которые вы, возможно, должны рассмотреть, прежде чем внедрять Ruby:

• Проблемы с производительностью. Несмотря на то, что он конкурирует с Perl и Python, он все еще является интерпретируемым языком, и мы не можем сравнить его с языками программирования высокого уровня, такими как C или C ++.

• Модель потоков – Ruby не использует собственные потоки. Потоки Ruby моделируются в виртуальной машине, а не работают как собственные потоки ОС.

Проблемы с производительностью. Несмотря на то, что он конкурирует с Perl и Python, он все еще является интерпретируемым языком, и мы не можем сравнить его с языками программирования высокого уровня, такими как C или C ++.

Модель потоков – Ruby не использует собственные потоки. Потоки Ruby моделируются в виртуальной машине, а не работают как собственные потоки ОС.

Образец кода Ruby

Вот пример кода Ruby для печати “Hello Ruby”

# The Hello Class
class Hello
   
   def initialize( name )
      @name = name.capitalize
   end

   def salute
      puts "Hello #{@name}!"
   end
   
end

# Create a new object
h = Hello.new("Ruby")

# Output "Hello Ruby!"
h.salute

Вывод – это даст следующий результат –

Hello Ruby!

Встроенный рубин

Ruby предоставляет программу ERB (Embedded Ruby), написанную Seki Masatoshi . ERB позволяет помещать коды Ruby в файл HTML. ERB читает слово в слово, а затем в определенный момент, когда он встречает код Ruby, встроенный в документ, он начинает выполнять код Ruby.

Вам нужно знать только две вещи, чтобы подготовить документ ERB –

• Если вы хотите, чтобы какой-нибудь код на Ruby был выполнен, заключите его между <% и %>.

• Если вы хотите, чтобы результат выполнения кода был распечатан как часть вывода, заключите код между <% = и %> .

Если вы хотите, чтобы какой-нибудь код на Ruby был выполнен, заключите его между <% и %>.

Если вы хотите, чтобы результат выполнения кода был распечатан как часть вывода, заключите код между <% = и %> .

Вот пример. Сохраните код в файле erbdemo.rb. Обратите внимание, что файл Ruby будет иметь расширение .rb –

<% page_title = "Demonstration of ERB" %>
<% salutation = "Dear programmer," %>

<html>

   <head>
      <title><%= page_title %></title>
   </head>
	
   <body>
      <p><%= salutation %></p>
      <p>This is an example of how ERB fills out a template.</p>
   </body>
	
</html>

Теперь запустите программу, используя утилиту командной строки erb .

tp> erb erbdemo.rb

Это даст следующий результат –

<html>

   <head>
      <title>Demonstration of ERb</title>
   </head>
	
   <body>
      <p>Dear programmer,</p>
      <p>This is an example  of how ERb fills out a template.</p>
   </body>
	
</html>

Что такое рельсы?

• Чрезвычайно производительный фреймворк для веб-приложений.

• Написано в Ruby Дэвидом Хейнемайером Ханссоном.

• Вы могли бы разработать веб-приложение как минимум в десять раз быстрее с Rails, чем с типичной средой Java.

• Ruby-фреймворк с открытым исходным кодом для разработки поддерживаемых базой данных веб-приложений.

• Настройте свой код с помощью схемы базы данных.

• Фаза компиляции не требуется.

Чрезвычайно производительный фреймворк для веб-приложений.

Написано в Ruby Дэвидом Хейнемайером Ханссоном.

Вы могли бы разработать веб-приложение как минимум в десять раз быстрее с Rails, чем с типичной средой Java.

Ruby-фреймворк с открытым исходным кодом для разработки поддерживаемых базой данных веб-приложений.

Настройте свой код с помощью схемы базы данных.

Фаза компиляции не требуется.

Full Stack Framework

• Включает все необходимое для создания веб-приложения на основе базы данных с использованием шаблона Model-View-Controller.

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

• Требует меньше строк кода, чем другие фреймворки.

Включает все необходимое для создания веб-приложения на основе базы данных с использованием шаблона Model-View-Controller.

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

Требует меньше строк кода, чем другие фреймворки.

Соглашение по конфигурации

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

• Код вашего приложения и работающая база данных уже содержат все, что нужно знать Rails!

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

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

Сильные стороны рельсов

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

Метапрограммирование

Там, где другие фреймворки используют обширную генерацию кода с нуля, Rail Framework использует методы метапрограммирования для написания программ. Ruby – один из лучших языков для метапрограммирования, и Rails хорошо использует эту возможность. Rails также использует генерацию кода, но гораздо больше полагается на метапрограммирование для тяжелой работы.

Активная запись

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

Соглашение по конфигурации

Большинство сред веб-разработки для .NET или Java вынуждают вас писать страницы кода конфигурации. Если вы следуете предлагаемым соглашениям об именах, Rails не требует особой настройки.

подмости

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

Встроенное тестирование

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

Три среды

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

Ruby on Rails – Установка

Для разработки веб-приложения с использованием Ruby on Rails Framework вам необходимо установить следующее программное обеспечение:

• Рубин
• Rails Framework
• Веб-сервер
• Система баз данных

Мы предполагаем, что на вашем компьютере уже установлены веб-сервер и система баз данных. Вы можете использовать веб-сервер WEBrick, который поставляется с Ruby. Однако большинство веб-сайтов используют в своей работе веб-серверы Apache или lightTPD.

Rails работает со многими системами баз данных, включая MySQL, PostgreSQL, SQLite, Oracle, DB2 и SQL Server. Пожалуйста, обратитесь к соответствующему руководству по установке системы баз данных, чтобы настроить вашу базу данных.

Давайте посмотрим на инструкции по установке Rails на Windows и Linux.

Установка Rails в Windows

Следуйте приведенным ниже инструкциям для установки Ruby on Rails.

Шаг 1: Проверьте версию Ruby

Сначала проверьте, установлен ли у вас Ruby. Откройте командную строку и введите ruby -v . Если Ruby отвечает и показывает номер версии 2.2.2 или выше, введите gem –version . Если вы не получили ошибку, пропустите шаг Install Ruby . В противном случае мы установим свежий Ruby.

Шаг 2: Установите Ruby

Если Ruby не установлен, загрузите установочный пакет с rubyinstaller.org . Перейдите по ссылке для загрузки и запустите получившийся установщик. Это исполняемый файл rubyinstaller-2.2.2.x.exe и будет установлен в один клик. Это очень маленький пакет, и вы также получите RubyGems вместе с этим пакетом. Пожалуйста, проверьте примечания к выпуску для более подробной информации.

Шаг 3: Установите Rails

Установить Rails – с загруженными Rubygems вы можете установить все Rails и его зависимости, используя следующую команду через командную строку:

C:> gem install rails

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

Шаг 4: Проверьте версию Rails

Используйте следующую команду, чтобы проверить версию рельсов.

C:> rails -v

Выход

Rails 4.2.4

Поздравляем! Теперь вы находитесь на Rails поверх Windows.

Установка Rails в Linux

Мы устанавливаем Ruby On Rails в Linux, используя rbenv . Это легкий инструмент управления версиями Ruby. Rbenv предоставляет простую процедуру установки для управления различными версиями Ruby и надежную среду для разработки приложений Ruby on Rails.

Следуйте приведенным ниже инструкциям, чтобы установить Ruby on Rails с помощью инструмента rbenv.

Шаг 1: Установите обязательные зависимости

Прежде всего, мы должны установить git-core и некоторые зависимости ruby, которые помогают установить Ruby on Rails. Используйте следующую команду для установки зависимостей Rails с помощью yum .

tp> sudo yum install -y git-core zlib zlib-devel gcc-c++ patch readline readline-devel libyaml-devel libffi-devel openssl-devel make bzip2 autoconf automake libtool bison curl sqlite-devel

Шаг 2: Установите rbenv

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

tp> git clone git://github.com/sstephenson/rbenv.git .rbenv
tp> echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bash_profile
tp> echo 'eval "$(rbenv init -)"' >> ~/.bash_profile
tp> exec $SHELL

tp> git clone git://github.com/sstephenson/ruby-build.git ~/.rbenv/plugins/ruby-build
tp> echo 'export PATH="$HOME/.rbenv/plugins/ruby-build/bin:$PATH"' << ~/.bash_profile
tp> exec $SHELL

Шаг 3: Установите Ruby

Перед установкой Ruby определите, какую версию Ruby вы хотите установить. Мы установим Ruby 2.2.3. Используйте следующую команду для установки Ruby.

tp> rbenv install -v 2.2.3

Используйте следующую команду для настройки текущей версии Ruby по умолчанию.

tp> rbenv global 2.2.3

Используйте следующую команду, чтобы проверить версию Ruby.

tp> ruby -v

Выход

ruby 2.2.3p173 (2015-08-18 revivion 51636) [X86_64-linux]

Ruby предоставляет гем ключевых слов для установки поддерживаемых зависимостей; мы называем их драгоценными камнями . Если вы не хотите устанавливать документацию для Ruby-gems, используйте следующую команду.

tp> echo "gem: --no-document" > ~/.gemrc

После этого лучше установить гем Bundler, потому что он помогает управлять зависимостями вашего приложения. Используйте следующую команду для установки гема компоновщика.

tp> gem install bundler

Шаг 4: Установите Rails

Используйте следующую команду для установки Rails версии 4.2.4.

tp> install rails -v 4.2.4

Используйте следующую команду, чтобы сделать исполняемый файл Rails доступным.

tp> rbenv rehash

Используйте следующую команду для проверки версии рельсов.

tp> rails -v

Выход

tp> Rails 4.2.4

Платформа Ruby on Rails требует JavaScript Runtime Environment (Node.js) для управления функциями Rails. Далее мы увидим, как мы можем использовать Node.js для управления Asset Pipeline, который является функцией Rails.

Шаг 5: Установите JavaScript Runtime

Давайте установим Node.js из репозитория Yum. Мы возьмем Node.js из репозитория EPEL yum. Используйте следующую команду, чтобы добавить пакет EPEL в репозиторий yum.

tp> sudo yum -y install epel-release

Используйте следующую команду для установки пакета Node.js.

tp> sudo yum install nodejs

Поздравляем! Вы сейчас на Rails поверх Linux.

Шаг 6: Установить базу данных

По умолчанию Rails использует sqlite3, но вы можете установить MySQL, PostgreSQL или другую RDBMS. Это необязательно; если у вас установлена ​​база данных, вы можете пропустить этот шаг, и необязательно, чтобы у вас была установлена ​​база данных для запуска сервера rails. Для этого урока мы используем базу данных PostgreSQL. Поэтому используйте следующие команды для установки PostgreSQL.

tp> sudo yum install postgresql-server postgresql-contrib

Примите приглашение, ответив y . Используйте следующую команду для создания кластера базы данных PostgreSQl.

tp> sudo postgresql-setup initdb

Используйте следующую команду для запуска и включения PostgreSQL.

tp> sudo systemctl start postgresql
tp> sudo systemctl enable postgresql

Поддержание рельсов в актуальном состоянии

Предполагая, что вы установили Rails с использованием RubyGems, поддерживать его в актуальном состоянии относительно легко. Мы можем использовать одну и ту же команду на платформе Windows и Linux. Используйте следующую команду –

tp> gem update rails

Выход

На следующем снимке экрана показана командная строка Windows. Терминал Linux также обеспечивает тот же вывод.

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

Проверка установки

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

tp> rails new demo

Выход

Это создаст демонстрационный железнодорожный проект; мы обсудим это позже. В настоящее время мы должны проверить, настроена ли среда или нет. Затем используйте следующую команду для запуска веб-сервера WEBrick на вашем компьютере.

tp> cd demo
tp> rails server

Он сгенерирует авто-код для запуска сервера

Теперь откройте ваш браузер и введите следующее –

http://localhost:3000

На нем должно появиться сообщение типа «Добро пожаловать на борт» или «Поздравления».

Ruby on Rails – Framework

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

Когда вы решили написать приложение на Rails, оставив в стороне конфигурацию и другие домашние дела, вам придется выполнить три основные задачи:

• Опишите и смоделируйте домен вашего приложения. Домен – это юниверс вашего приложения. Доменом может быть музыкальный магазин, университет, служба знакомств, адресная книга или инвентарь оборудования. Итак, здесь вы должны выяснить, что в нем, какие сущности существуют в этой вселенной и как элементы в ней связаны друг с другом. Это эквивалентно моделированию структуры базы данных для сохранения сущностей и их взаимосвязей.

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

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

Опишите и смоделируйте домен вашего приложения. Домен – это юниверс вашего приложения. Доменом может быть музыкальный магазин, университет, служба знакомств, адресная книга или инвентарь оборудования. Итак, здесь вы должны выяснить, что в нем, какие сущности существуют в этой вселенной и как элементы в ней связаны друг с другом. Это эквивалентно моделированию структуры базы данных для сохранения сущностей и их взаимосвязей.

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

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

Основываясь на вышеупомянутых трех задачах, Ruby on Rails работает с платформой Model / View / Controller (MVC).

Ruby on Rails MVC Framework

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

Модель (ActiveRecord)

Он поддерживает отношения между объектами и базой данных и обрабатывает проверки, ассоциации, транзакции и многое другое.

Эта подсистема реализована в библиотеке ActiveRecord, которая обеспечивает интерфейс и связывание между таблицами в реляционной базе данных и программным кодом Ruby, который управляет записями базы данных. Имена методов Ruby автоматически генерируются из имен полей таблиц базы данных.

Просмотр (ActionView)

Это представление данных в определенном формате, инициируемое решением контроллера о представлении данных. Это основанные на сценариях системы шаблонов, такие как JSP, ASP, PHP, и их очень легко интегрировать с технологией AJAX.

Эта подсистема реализована в библиотеке ActionView, которая является системой на основе Embedded Ruby (ERb) для определения шаблонов представления для представления данных. Каждое веб-соединение с приложением Rails приводит к отображению представления.

Контроллер (ActionController)

Средство в приложении, которое направляет трафик, с одной стороны, запрашивая модели для конкретных данных, а с другой стороны, организуя эти данные (поиск, сортировка, обмен сообщениями) в форму, которая соответствует потребностям данного представления.

Эта подсистема реализована в ActionController, который представляет собой посредник данных, расположенный между ActiveRecord (интерфейс базы данных) и ActionView (механизм представления).

Иллюстрированное представление MVC Framework

Ниже приведено графическое представление Ruby on Rails Framework –

Справочное Представление MVC Framework

Предполагая стандартную установку по умолчанию в Linux, вы можете найти их так:

tp> cd /usr/local/lib/ruby/gems/2.2.0/gems
tp> ls

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

• actionpack-хуг
• ActiveRecord-хуг
• Рельсы-хуг

Над установкой Windows вы можете найти их вот так –

tp>cd rubylibrubygems2.2.0gems
rubylibrubygems2.2.0gems>dir

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

ActionView и ActionController связаны вместе в ActionPack.

ActiveRecord предоставляет ряд методов программирования и ярлыков для управления данными из базы данных SQL. ActionController и ActionView предоставляют средства для манипулирования и отображения этих данных. Рельсы связывают все это вместе.

Ruby on Rails – Структура каталогов

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

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

Чтобы понять эту структуру каталогов, давайте использовать демонстрационное приложение, созданное в главе «Установка». Он может быть создан с помощью простой демо- команды rails .

Теперь перейдите в корневой каталог демо-приложения следующим образом:

tp> cd demo
demo> dir

Вы найдете структуру каталогов в Windows следующим образом:

Теперь давайте объясним цель каждого каталога

• приложение – это организует ваши компоненты приложения. У него есть подкаталоги, которые содержат представление (представления и помощники), контроллер (контроллеры) и бэкэнд-бизнес-логику (модели).

• app / controllers – подкаталог controllers, где Rails ищет классы контроллеров. Контроллер обрабатывает веб-запрос от пользователя.

• app / helpers – подкаталог helpers содержит все вспомогательные классы, используемые для поддержки классов модели, представления и контроллера. Это помогает сохранить размер модели, представления и кода контроллера небольшим, сфокусированным и беспрепятственным.

• app / models – подкаталог models содержит классы, которые моделируют и упаковывают данные, хранящиеся в базе данных нашего приложения. В большинстве сред эта часть приложения может стать довольно грязной, утомительной, многословной и подверженной ошибкам. Rails делает его невероятно простым!

• app / view – подкаталог views содержит шаблоны отображения для заполнения данными из нашего приложения, преобразования в HTML и возврата в браузер пользователя.

• app / view / layouts – содержит файлы шаблонов для макетов, которые будут использоваться с представлениями. Это моделирует общий метод заголовка / нижнего колонтитула для представления представлений. В ваших представлениях определите макет с помощью <tt> layout: default </ tt> и создайте файл с именем default.html.erb. Внутри default.html.erb вызовите <% yield%>, чтобы отобразить представление с использованием этого макета.

• компоненты – этот каталог содержит компоненты, крошечные автономные приложения, которые объединяют модель, представление и контроллер.

• config – Этот каталог содержит небольшой объем кода конфигурации, который понадобится вашему приложению, включая конфигурацию базы данных (в файле database.yml), структуру среды Rails (environment.rb) и маршрутизацию входящих веб-запросов (rout.rb). Вы также можете настроить поведение трех сред Rails для тестирования, разработки и развертывания с помощью файлов, находящихся в каталоге сред.

• db – Обычно ваше Rails-приложение имеет объекты модели, которые обращаются к таблицам реляционной базы данных. Вы можете управлять реляционной базой данных с помощью скриптов, которые вы создаете и размещаете в этом каталоге.

• doc – Ruby имеет инфраструктуру под названием RubyDoc, которая может автоматически генерировать документацию для кода, который вы создаете. Вы можете помочь RubyDoc с комментариями в вашем коде. Этот каталог содержит всю сгенерированную RubyDoc Rails и документацию приложения.

• lib – здесь вы разместите библиотеки, если они явно не принадлежат другим местам (например, библиотекам поставщиков).

• log – Журналы ошибок идут сюда. Rails создает скрипты, которые помогают вам управлять различными журналами ошибок. Вы найдете отдельные журналы для сервера (server.log) и каждой среды Rails (development.log, test.log и production.log).

• public – подобно общедоступному каталогу для веб-сервера, в этом каталоге есть неизменяемые веб-файлы, такие как файлы JavaScript (public / javascripts), графика (public / images), таблицы стилей (public / stylesheets) и файлы HTML ( общественности).

• script – Этот каталог содержит скрипты для запуска и управления различными инструментами, которые вы будете использовать с Rails. Например, есть сценарии для генерации кода (генерирования) и запуска веб-сервера (сервера).

• test – тесты, которые вы пишете, и те, которые Rails создает для вас, все идет здесь. Вы увидите подкаталог для макетов (mocks), модульных тестов (unit), приспособлений (fixtures) и функциональных тестов (функциональных).

• tmp – Rails использует этот каталог для хранения временных файлов для промежуточной обработки.

• vendor – библиотеки, предоставляемые сторонними поставщиками (например, библиотеки безопасности или утилиты баз данных вне основного дистрибутива Rails).

приложение – это организует ваши компоненты приложения. У него есть подкаталоги, которые содержат представление (представления и помощники), контроллер (контроллеры) и бэкэнд-бизнес-логику (модели).

app / controllers – подкаталог controllers, где Rails ищет классы контроллеров. Контроллер обрабатывает веб-запрос от пользователя.

app / helpers – подкаталог helpers содержит все вспомогательные классы, используемые для поддержки классов модели, представления и контроллера. Это помогает сохранить размер модели, представления и кода контроллера небольшим, сфокусированным и беспрепятственным.

app / models – подкаталог models содержит классы, которые моделируют и упаковывают данные, хранящиеся в базе данных нашего приложения. В большинстве сред эта часть приложения может стать довольно грязной, утомительной, многословной и подверженной ошибкам. Rails делает его невероятно простым!

app / view – подкаталог views содержит шаблоны отображения для заполнения данными из нашего приложения, преобразования в HTML и возврата в браузер пользователя.

app / view / layouts – содержит файлы шаблонов для макетов, которые будут использоваться с представлениями. Это моделирует общий метод заголовка / нижнего колонтитула для представления представлений. В ваших представлениях определите макет с помощью <tt> layout: default </ tt> и создайте файл с именем default.html.erb. Внутри default.html.erb вызовите <% yield%>, чтобы отобразить представление с использованием этого макета.

компоненты – этот каталог содержит компоненты, крошечные автономные приложения, которые объединяют модель, представление и контроллер.

config – Этот каталог содержит небольшой объем кода конфигурации, который понадобится вашему приложению, включая конфигурацию базы данных (в файле database.yml), структуру среды Rails (environment.rb) и маршрутизацию входящих веб-запросов (rout.rb). Вы также можете настроить поведение трех сред Rails для тестирования, разработки и развертывания с помощью файлов, находящихся в каталоге сред.

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

doc – Ruby имеет инфраструктуру под названием RubyDoc, которая может автоматически генерировать документацию для кода, который вы создаете. Вы можете помочь RubyDoc с комментариями в вашем коде. Этот каталог содержит всю сгенерированную RubyDoc Rails и документацию приложения.

lib – здесь вы разместите библиотеки, если они явно не принадлежат другим местам (например, библиотекам поставщиков).

log – Журналы ошибок идут сюда. Rails создает скрипты, которые помогают вам управлять различными журналами ошибок. Вы найдете отдельные журналы для сервера (server.log) и каждой среды Rails (development.log, test.log и production.log).

public – подобно общедоступному каталогу для веб-сервера, в этом каталоге есть неизменяемые веб-файлы, такие как файлы JavaScript (public / javascripts), графика (public / images), таблицы стилей (public / stylesheets) и файлы HTML ( общественности).

script – Этот каталог содержит скрипты для запуска и управления различными инструментами, которые вы будете использовать с Rails. Например, есть сценарии для генерации кода (генерирования) и запуска веб-сервера (сервера).

test – тесты, которые вы пишете, и те, которые Rails создает для вас, все идет здесь. Вы увидите подкаталог для макетов (mocks), модульных тестов (unit), приспособлений (fixtures) и функциональных тестов (функциональных).

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

vendor – библиотеки, предоставляемые сторонними поставщиками (например, библиотеки безопасности или утилиты баз данных вне основного дистрибутива Rails).

Помимо этих каталогов, в демонстрационном каталоге будет два файла.

• README – Этот файл содержит основную информацию о Rail Application и описание структуры каталогов, описанной выше.

• Rakefile – этот файл похож на Unix Makefile, который помогает при сборке, упаковке и тестировании кода Rails. Это будет использоваться утилитой rake, поставляемой вместе с установкой Ruby.

README – Этот файл содержит основную информацию о Rail Application и описание структуры каталогов, описанной выше.

Rakefile – этот файл похож на Unix Makefile, который помогает при сборке, упаковке и тестировании кода Rails. Это будет использоваться утилитой rake, поставляемой вместе с установкой Ruby.

Ruby on Rails – Примеры

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

Это приложение имеет базовую архитектуру и будет построено с использованием двух моделей ActiveRecord для описания типов хранимых данных:

• Книги, в которых описывается фактическая распечатка.
• Предмет, который используется для группировки книг вместе.

Рабочий процесс для создания приложений Rails

Рекомендуемый рабочий процесс для создания Rails Application выглядит следующим образом:

• Используйте команду rails для создания основного каркаса приложения.

• Создайте базу данных на сервере PostgreSQL для хранения ваших данных.

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

• Создайте активные записи Rails (модели), потому что они являются бизнес-объектами, с которыми вы будете работать в своих контроллерах.

• Создание миграций, которые упрощают создание и ведение таблиц и столбцов базы данных.

• Напишите код контроллера, чтобы жизнь в вашем приложении.

• Создайте представления для представления ваших данных через пользовательский интерфейс.

Используйте команду rails для создания основного каркаса приложения.

Создайте базу данных на сервере PostgreSQL для хранения ваших данных.

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

Создайте активные записи Rails (модели), потому что они являются бизнес-объектами, с которыми вы будете работать в своих контроллерах.

Создание миграций, которые упрощают создание и ведение таблиц и столбцов базы данных.

Напишите код контроллера, чтобы жизнь в вашем приложении.

Создайте представления для представления ваших данных через пользовательский интерфейс.

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

Создание пустого веб-приложения Rails

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

• Перейдите в каталог установки ruby, чтобы создать приложение.

• Выполните следующую команду, чтобы создать каркас для приложения библиотеки. Это создаст структуру каталогов в текущем каталоге.

Перейдите в каталог установки ruby, чтобы создать приложение.

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

tp> rails new library

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

Большая часть наших разработок будет заключаться в создании и редактировании файлов в подкаталогах library / app . Вот краткий обзор того, как их использовать –

• Подкаталог controllers – это место, где Rails ищет классы контроллеров. Контроллер обрабатывает веб-запрос от пользователя.

• Подкаталог views содержит шаблоны отображения для заполнения данными из нашего приложения, преобразования в HTML и возврата в браузер пользователя.

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

• Подкаталог helpers содержит все вспомогательные классы, используемые для поддержки классов модели, представления и контроллера. Это помогает сохранить размер модели, представления и кода контроллера небольшим, сфокусированным и беспрепятственным.

Подкаталог controllers – это место, где Rails ищет классы контроллеров. Контроллер обрабатывает веб-запрос от пользователя.

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

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

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

Запуск веб-сервера

Веб-приложение Rails может работать практически на любом веб-сервере, но наиболее удобный способ разработки веб-приложения на Rails – это использование встроенного веб-сервера WEBrick. Давайте запустим этот веб-сервер, а затем перейдем к нашему пустому приложению библиотеки –

Этот сервер будет запущен из каталога приложений следующим образом. Он работает на порту № 3000.

tp> cd rubylibrary 
tprubylibrary> Rails server

Он генерирует автоматический код для запуска сервера, как показано ниже –

Это запустит ваш веб-сервер WEBrick.

Теперь откройте ваш браузер и перейдите по адресу http://127.0.0.1:3000 . Если все прошло нормально, вы должны увидеть приветственное сообщение от WEBrick, в противном случае что-то не так с вашей настройкой. Если все пойдет хорошо, он сгенерирует вывод следующим образом.

Что дальше?

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

Далее мы увидим, что такое Rails Migration и как она используется для поддержки таблиц базы данных.

Ruby on Rails – Настройка базы данных

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

• library_development
• library_production
• library_test

Вы должны инициализировать все три из них и создать для них пользователя и пароль с полными привилегиями чтения и записи. Мы используем ID пользователя root для нашего приложения.

Настройка базы данных для MySQL

В MySQL мы используем ID пользователя root для нашего приложения. Консольный сеанс MySQL, в котором вы это делаете, выглядит примерно так:

mysql> create database library_development;
Query OK, 1 row affected (0.01 sec)

mysql> grant all privileges on library_development.*
to 'root'@'localhost' identified by 'password';
Query OK, 0 rows affected (0.00 sec)

mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

Вы можете сделать то же самое для еще двух баз данных library_production и library_test .

Конфигурирование database.yml

На этом этапе вам необходимо сообщить Rails об имени пользователя и пароле для баз данных. Вы делаете это в файле database.yml , который находится в подкаталоге library config созданного вами Rails-приложения. Этот файл содержит разделы конфигурации для баз данных MySQL. В каждом из используемых вами разделов необходимо изменить строки имени пользователя и пароля, чтобы отразить разрешения для созданных вами баз данных.

Когда вы закончите, это должно выглядеть примерно так –

development:
   adapter: mysql
   database: library_development
   username: root
   password: [password]
   host: localhost
	
test:
   adapter: mysql
   database: library_test
   username: root
   password: [password]
   host: localhost
   
production:
   adapter: mysql
   database: library_production
   username: root
   password: [password]
   host: localhost

Настройка базы данных для PostgreSQL

По умолчанию PostgreSQL не предоставляет никаких пользователей. Мы должны создавать новых пользователей. Используйте следующую команду, чтобы создать пользователя с именем rubyuser .

tp> sudo -u postgres createuser rubyuser -s

Если вы хотите создать пароль для нового пользователя, используйте следующую команду.

tp> sudo -u postgres psql

postgres=# password rubyuser

Используйте следующую команду для создания базы данных library_development .

postgres=# CREATE DATABASE library_development OWNER rubyuser; 

CREATE DATABASE

Используйте следующую команду для создания базы данных library_production .

postgres=# CREATE DATABASE library_production OWNER rubyuser; 

CREATE DATABASE

Используйте следующую команду для создания базы данных library_test .

postgres=# CREATE DATABASE library_test OWNER rubyuser; 

CREATE DATABASE

Нажмите Ctrl + D, чтобы завершить работу PosgreSQL.

Конфигурирование database.yml

На этом этапе вам необходимо сообщить Rails имя пользователя и пароль для баз данных. Вы делаете это в файле database.yml , который находится в подкаталоге library config созданного вами Rails-приложения. Этот файл содержит разделы конфигурации для баз данных PostgreSQL. В каждом из разделов вам необходимо изменить строки имени пользователя и пароля, чтобы отразить разрешения для созданных вами баз данных.

Когда вы закончите, это должно выглядеть следующим образом –

default: &default
   adapter: postgresql
   encoding: unicode
  
development:
   adapter: postgresql
   encoding: unicode
   database: library_development
   username: rubyuser
   password: <Password for rubyuser>

test:
   adapter: postgresql
   encoding: unicode
   database: library_test
   username: rubyuser
   password: <Password for rubyuser>
 
production:
   adapter: postgresql
   encoding: unicode
   database: library_production
   username: rubyuser
   password: <Password for rubyuser>

Что дальше?

В следующих двух главах объясняется, как моделировать таблицы базы данных и как управлять ими с помощью Rails Migrations.

Ruby on Rails – Активные записи

Rails Active Record – это слой Object / Relational Mapping (ORM), поставляемый с Rails. Это близко следует за стандартной моделью ORM, которая является следующей –

• таблицы отображаются на классы,
• строки отображаются на объекты и
• столбцы сопоставляются с атрибутами объекта.

Rails Active Records предоставляют интерфейс и связывание между таблицами в реляционной базе данных и программным кодом Ruby, который управляет записями базы данных. Имена методов Ruby автоматически генерируются из имен полей таблиц базы данных.

Каждый объект Active Record имеет методы CRUD ( C reate, R ead, U pdate и D elete) для доступа к базе данных. Эта стратегия допускает простой дизайн и прямое сопоставление между таблицами базы данных и объектами приложения.

Перевод модели предметной области в SQL

Перевод модели предметной области в SQL, как правило, прост, если вы помните, что вам нужно писать дружественный к Rails SQL. В практическом плане вы должны следовать определенным правилам –

• Каждый объект (например, книга) получает таблицу в базе данных, названной в его честь, но во множественном числе (книги).

• Каждая такая таблица соответствия сущностей имеет поле с именем id , которое содержит уникальное целое число для каждой записи, вставленной в таблицу.

• Для данной сущности x и сущности y, если сущность y принадлежит сущности x, то таблица y имеет поле с именем x_id.

• Большая часть полей в любой таблице хранит значения для простых свойств этого объекта (все, что является числом или строкой).

Каждый объект (например, книга) получает таблицу в базе данных, названной в его честь, но во множественном числе (книги).

Каждая такая таблица соответствия сущностей имеет поле с именем id , которое содержит уникальное целое число для каждой записи, вставленной в таблицу.

Для данной сущности x и сущности y, если сущность y принадлежит сущности x, то таблица y имеет поле с именем x_id.

Большая часть полей в любой таблице хранит значения для простых свойств этого объекта (все, что является числом или строкой).

Создание файлов активной записи (модели)

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

library> ruby script/generate model Book
library> ruby script/generate model Subject

Выше рельсы генерируют модель книги, команды генерируют автоматический код, как показано ниже –

Вы говорите генератору о создании моделей под названием «Книга» и «Тема» для хранения экземпляров книг и предметов. Обратите внимание, что вы пишете с большой буквы книгу и тему и используете единственную форму. Это парадигма Rails, которой вы должны следовать каждый раз, когда создаете модель.

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

Помимо создания многих других файлов и каталогов, это создаст файлы с именами book.rb и subject.rb, содержащие определение скелета в каталоге app / models .

Содержимое доступно в book.rb –

class Book < ActiveRecord::Base
end

Содержание доступно в subject.rb –

class Subject < ActiveRecord::Base
end

Создание связей между моделями

Когда в вашем приложении rails имеется более одной модели, вам необходимо создать связь между этими моделями. Вы можете сделать это через ассоциации. Active Record поддерживает три типа ассоциаций –

• один-к-одному – отношение один-к-одному существует, когда один элемент имеет ровно один из другого элемента. Например, у человека ровно один день рождения, или у собаки ровно один хозяин.

• «один ко многим». Отношение «один ко многим» существует, когда один объект может быть членом многих других объектов. Например, один предмет может иметь много книг.

• многие ко многим. Отношение многие ко многим существует, когда первый объект связан с одним или несколькими вторыми объектами, а второй объект связан с одним или несколькими первыми объектами.

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

«один ко многим». Отношение «один ко многим» существует, когда один объект может быть членом многих других объектов. Например, один предмет может иметь много книг.

многие ко многим. Отношение многие ко многим существует, когда первый объект связан с одним или несколькими вторыми объектами, а второй объект связан с одним или несколькими первыми объектами.

Вы указываете эти ассоциации, добавляя объявления к своим моделям: has_one, has_many, assign_to и has_and_belongs_to_many.

Теперь вам нужно сообщить Rails, какие отношения вы хотите установить в библиотечной системе данных. Для этого измените book.rb и subject.rb так:

class Book < ActiveRecord::Base
   belongs_to :subject
end

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

class Subject < ActiveRecord::Base
   has_many :books
end

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

Реализация проверок на моделях

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

Проверки –

• Значение поля заголовка не должно быть NULL.

• Значение поля цены должно быть числовым.

Значение поля заголовка не должно быть NULL.

Значение поля цены должно быть числовым.

Откройте book.rb в подкаталоге app model и поместите следующие проверки:

class Book < ActiveRecord::Base
   belongs_to :subject
   validates_presence_of :title
   validates_numericality_of :price, :message=>"Error Message"
end

• validates_presence_of – защищает поля “NOT NULL” от пропущенного пользовательского ввода.

• validates_numericity_of – запрещает пользователю вводить нечисловые данные.

validates_presence_of – защищает поля “NOT NULL” от пропущенного пользовательского ввода.

validates_numericity_of – запрещает пользователю вводить нечисловые данные.

Помимо проверок, упомянутых выше, существуют и другие распространенные проверки. Краткое руководство по Rails .

Что дальше?

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

Ruby on Rails – Миграции

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

Это имеет много применений, в том числе –

• Команды разработчиков – если один человек вносит изменения в схему, другим разработчикам просто нужно обновить и запустить «rake migrate».

• Производственные серверы. Запустите “rake migrate”, когда вы выпускаете новую версию, чтобы обновить базу данных.

• Несколько компьютеров – если вы разрабатываете как на настольном компьютере, так и на ноутбуке, или в нескольких местах, миграции могут помочь вам синхронизировать их все.

Команды разработчиков – если один человек вносит изменения в схему, другим разработчикам просто нужно обновить и запустить «rake migrate».

Производственные серверы. Запустите “rake migrate”, когда вы выпускаете новую версию, чтобы обновить базу данных.

Несколько компьютеров – если вы разрабатываете как на настольном компьютере, так и на ноутбуке, или в нескольких местах, миграции могут помочь вам синхронизировать их все.

Что может сделать Rails Migration?

• create_table (имя, параметры)
• drop_table (имя)
• rename_table (old_name, new_name)
• add_column (имя_таблицы, имя_столбца, тип, параметры)
• переименовать_колонку (имя_таблицы, имя_столбца, имя_столбца_нов)
• change_column (имя_таблицы, имя_столбца, тип, параметры)
• remove_column (имя_таблицы, имя_столбца)
• add_index (имя_таблицы, имя_столбца, тип_индекса)
• remove_index (имя_таблицы, имя_столбца)

Миграции поддерживают все основные типы данных . Ниже приведен список типов данных, которые поддерживает миграция.

• строка – для небольших типов данных, таких как заголовок.

• текст – для более длинных текстовых данных, таких как описание.

• целое число – для целых чисел.

• float – для десятичных дробей.

• datetime and timestamp – сохранить дату и время в столбце.

• дата и время – сохраните только дату или только время.

• двоичный файл – для хранения данных, таких как изображения, аудио или фильмы.

• Boolean – для хранения значений true или false.

строка – для небольших типов данных, таких как заголовок.

текст – для более длинных текстовых данных, таких как описание.

целое число – для целых чисел.

float – для десятичных дробей.

datetime and timestamp – сохранить дату и время в столбце.

дата и время – сохраните только дату или только время.

двоичный файл – для хранения данных, таких как изображения, аудио или фильмы.

Boolean – для хранения значений true или false.

Допустимые параметры столбца . Ниже приведен список допустимых параметров столбца.

• предел (: предел => «50»)

• по умолчанию (: default => «бла»)

• null (: null => false подразумевает, что NOT NULL )

предел (: предел => «50»)

по умолчанию (: default => «бла»)

null (: null => false подразумевает, что NOT NULL )

ПРИМЕЧАНИЕ. – Действия, выполняемые Rails Migration, могут быть выполнены с помощью любого интерфейсного интерфейса или непосредственно по приглашению SQL, но Rails Migration делает все эти действия очень легкими.

Смотрите Rails API для подробностей об этом.

Создать Миграции

Вот общий синтаксис для создания миграции:

application_dir> rails generate migration table_name

Это создаст файл db / migrate / 001_table_name.rb. Файл миграции содержит основной синтаксис Ruby, который описывает структуру данных таблицы базы данных.

ПРИМЕЧАНИЕ. – Перед запуском генератора миграции рекомендуется очистить существующие миграции, сгенерированные генераторами моделей.

Мы создадим две миграции, соответствующие нашим трем таблицам – книги и предметы .

Книги по миграции должны быть следующими –

tp> cd library
library> rails generate migration books

Выше команда генерирует следующий код.

Тема миграции должна быть следующей –

tp> cd library
library> rails generate migration subjects

Выше команда генерирует следующий код.

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

Изменить код

Перейдите в подкаталог db / migrate своего приложения и отредактируйте каждый файл один за другим, используя любой простой текстовый редактор.

Измените 001_books.rb следующим образом –

Столбец ID будет создан автоматически, поэтому не делайте этого и здесь.

class Books < ActiveRecord::Migration
   
   def self.up
      create_table :books do |t|
         t.column :title, :string, :limit => 32, :null => false
         t.column :price, :float
         t.column :subject_id, :integer
         t.column :description, :text
         t.column :created_at, :timestamp
      end
   end

   def self.down
      drop_table :books
   end
end

Метод self.up используется при переходе на новую версию, self.down используется для отката любых изменений, если это необходимо. На данный момент вышеуказанный скрипт будет использоваться для создания таблицы книг .

Измените 002_subjects.rb следующим образом –

class Subjects < ActiveRecord::Migration
   def self.up
      
      create_table :subjects do |t|
         t.column :name, :string
      end
	
      Subject.create :name => "Physics"
      Subject.create :name => "Mathematics"
      Subject.create :name => "Chemistry"
      Subject.create :name => "Psychology"
      Subject.create :name => "Geography"
   end

   def self.down
      drop_table :subjects
   end
end

Приведенный выше скрипт будет использоваться для создания таблицы субъектов и создаст пять записей в таблице субъектов.

Запустите миграцию

Теперь, когда вы создали все необходимые файлы миграции. Настало время выполнить их в отношении базы данных. Для этого перейдите в командную строку и перейдите в каталог библиотеки, в котором находится приложение, а затем введите rake migrate следующим образом:

library> rake db:migrate

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

Rake – это программа сборки Ruby, похожая на Unix make, которую использует Rails для упрощения выполнения сложных задач, таких как обновление структуры базы данных и т. Д.

Запуск миграций для производственных и тестовых баз данных

Если вы хотите указать, какую среду Rails использовать для миграции, используйте переменную оболочки RAILS_ENV.

Например –

library> export RAILS_ENV = production
library> rake db:migrate
library> export RAILS_ENV = test
library> rake db:migrate
library> export RAILS_ENV = development
library> rake db:migrate

ПРИМЕЧАНИЕ. – В Windows вместо команды экспорта используйте «set RAILS_ENV = production».

Что дальше?

Теперь у нас есть база данных и необходимые таблицы. В двух последующих главах мы рассмотрим два важных компонента: Контроллер (ActionController) и Вид (ActionView).

• Создание контроллеров (Action Controller).

• Создание видов (Action View).

Создание контроллеров (Action Controller).

Создание видов (Action View).

Ruby on Rails – Контроллер

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

• Он отвечает за маршрутизацию внешних запросов к внутренним действиям. Он отлично обрабатывает удобные для пользователя URL-адреса.

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

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

• Он управляет сессиями, создавая у пользователей впечатление постоянного взаимодействия с нашими приложениями.

Он отвечает за маршрутизацию внешних запросов к внутренним действиям. Он отлично обрабатывает удобные для пользователя URL-адреса.

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

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

Он управляет сессиями, создавая у пользователей впечатление постоянного взаимодействия с нашими приложениями.

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

library> rails generate controller Book

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

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

• Он создает файл с именем app / controllers / book_controller.rb

Он создает файл с именем app / controllers / book_controller.rb

Если вы посмотрите на book_controller.rb, вы найдете его следующим образом:

class BookController < ApplicationController
end

Классы контроллеров наследуются от ApplicationController, который является другим файлом в папке контроллеров: application.rb .

ApplicationController содержит код, который можно запустить на всех ваших контроллерах, и он наследуется от Rails ActionController :: Base класса.

Вам пока не нужно беспокоиться о ApplicationController , поэтому давайте просто определим несколько заглушек методов в book_controller.rb . Исходя из ваших требований, вы можете определить любое количество функций в этом файле.

Измените файл так, чтобы он выглядел следующим образом, и сохраните изменения. Обратите внимание, что вам решать, какое имя вы хотите дать этим методам, но лучше дать соответствующие имена.

class BookController < ApplicationController
   def list
   end
   
   def show
   end
   
   def new
   end
   
   def create
   end
   
   def edit
   end
   
   def update
   end
   
   def delete
   end
   
end

Теперь давайте реализуем все методы один за другим.

Реализация метода списка

Метод list дает вам список всех книг в базе данных. Эта функциональность будет достигнута с помощью следующих строк кода. Отредактируйте следующие строки в файле book_controller.rb.

def list
   @books = Book.all
end

Строка @books = Book.all в методе list указывает Rails искать в таблице книг и сохранять каждую найденную строку в объекте экземпляра @books.

Реализация метода шоу

Метод show отображает только дополнительную информацию об одной книге. Эта функциональность будет достигнута с помощью следующих строк кода.

def show
   @book = Book.find(params[:id])
end

Строка @book = Book.find (params [: id]) метода show указывает Rails найти только книгу, идентификатор которой определен в params [: id].

Объект params – это контейнер, который позволяет передавать значения между вызовами методов. Например, когда вы находитесь на странице, вызываемой методом list, вы можете щелкнуть ссылку для определенной книги, и она передает идентификатор этой книги через объект params, чтобы show могло найти конкретную книгу.

Внедрение нового метода

Новый метод позволяет Rails знать, что вы создадите новый объект. Так что просто добавьте следующий код в этот метод.

def new
   @book = Book.new
   @subjects = Subject.all
end

Вышеупомянутый метод будет вызван, когда вы отобразите страницу для пользователя, чтобы принять пользовательский ввод. Здесь вторая строка берет все предметы из базы данных и помещает их в массив с именем @subjects.

Реализация метода создания

После того как вы введете пользовательский ввод с помощью формы HTML, самое время создать запись в базе данных. Для этого отредактируйте метод create в book_controller.rb, чтобы он соответствовал следующему:

def create
   @book = Book.new(book_params)
	
   if @book.save
      redirect_to :action => 'list'
   else
      @subjects = Subject.all
      render :action => 'new'
   end
   
end

def book_params
   params.require(:books).permit(:title, :price, :subject_id, :description)
end

Первая строка создает новую переменную экземпляра с именем @book, которая содержит объект Book, созданный из данных, отправленных пользователем. Метод book_params используется для сбора всех полей из объекта : книги . Данные были переданы из нового метода для создания с использованием объекта params.

Следующая строка – это условный оператор, который перенаправляет пользователя в метод списка, если объект правильно сохраняется в базе данных. Если он не сохраняется, пользователь возвращается к новому методу. Метод redirect_to аналогичен мета-обновлению на веб-странице: он автоматически перенаправляет вас к месту назначения без какого-либо взаимодействия с пользователем.

Тогда @subjects = Subject.all требуется в случае, если данные не сохраняются успешно, и это становится аналогичным случаю с новой опцией.

Реализация метода редактирования

Метод edit выглядит практически идентично методу show. Оба метода используются для извлечения одного объекта на основе его идентификатора и отображения его на странице. Разница лишь в том, что метод show недоступен для редактирования.

def edit
   @book = Book.find(params[:id])
   @subjects = Subject.all
end

Этот метод будет вызываться для отображения данных на экране, которые будут изменены пользователем. Вторая строка берет все предметы из базы данных и помещает их в массив с именем @subjects.

Реализация метода обновления

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

def update
   @book = Book.find(params[:id])
	
   if @book.update_attributes(book_param)
      redirect_to :action => 'show', :id => @book
   else
      @subjects = Subject.all
      render :action => 'edit'
   end
   
end

def book_param
   params.require(:book).permit(:title, :price, :subject_id, :description)
end

Метод update_attributes аналогичен методу сохранения, используемому командой create, но вместо создания новой строки в базе данных он перезаписывает атрибуты существующей строки.

Затем требуется строка @subjects = Subject.all, если она не удастся успешно сохранить данные, тогда она станет похожей на опцию редактирования.

Реализация метода удаления

Если вы хотите удалить запись из базы данных, вы будете использовать этот метод. Реализуйте этот метод следующим образом.

def delete
   Book.find(params[:id]).destroy
   redirect_to :action => 'list'
end

Первая строка находит классификацию на основе параметра, переданного через объект params, а затем удаляет его с помощью метода destroy. Вторая строка перенаправляет пользователя в метод списка с помощью вызова redirect_to.

Дополнительные методы для отображения предметов

Предположим, вы хотите предоставить своим пользователям возможность просматривать все книги по заданному предмету. Таким образом, вы можете создать метод внутри book_controller.rb для отображения всех предметов. Предположим, что имя метода – show_subjects –

def show_subjects
   @subject = Subject.find(params[:id])
end

Наконец, ваш файл book_controller.rb будет выглядеть следующим образом:

class BooksController < ApplicationController

   def list
      @books = Book.all
   end

   def show
      @book = Book.find(params[:id])
   end
  
   def new
      @book = Book.new
      @subjects = Subject.all
   end

   def book_params
      params.require(:books).permit(:title, :price, :subject_id, :description)
   end

   def create
      @book = Book.new(book_params)

      if @book.save
         redirect_to :action => 'list'
      else
         @subjects = Subject.all
         render :action => 'new'
      end
   end
   
   def edit
      @book = Book.find(params[:id])
      @subjects = Subject.all
   end
   
   def book_param
      params.require(:book).permit(:title, :price, :subject_id, :description)
   end
   
   def update
      @book = Book.find(params[:id])
      
      if @book.update_attributes(book_param)
         redirect_to :action => 'show', :id => @book
      else
         @subjects = Subject.all
         render :action => 'edit'
      end
   end
   
   def delete
      Book.find(params[:id]).destroy
      redirect_to :action => 'list'
   end
   
   def show_subjects
      @subject = Subject.find(params[:id])
   end

end

Теперь сохраните ваш файл контроллера.

Что дальше?

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

Ruby on Rails – Маршруты

Модуль маршрутизации обеспечивает перезапись URL в родном Ruby. Это способ перенаправить входящие запросы на контроллеры и действия. Он заменяет правила mod_rewrite. Лучше всего то, что Rails Routing работает с любым веб-сервером. Маршруты определены в app / config / rout.rb.

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

Rails.application.routes.draw do
   Pattern 1 tells some request to go to one place
   Pattern 2 tell them to go to another
   ...
end

пример

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

Откройте файл route.rb в каталоге library / config / и отредактируйте его следующим образом.

Rails.application.routes.draw do
   get 'book/list'
   get 'book/new'
   post 'book/create'
   patch 'book/update'
   get 'book/list'
   get 'book/show'
   get 'book/edit'
   get 'book/delete'
   get 'book/update'
   get 'book/show_subjects'
end

Файл route.rb определяет действия, доступные в приложениях, и тип действий, таких как get, post и patch.

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

library> rake routes

Что дальше?

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

Ruby on Rails – Представления

Rails View – это ERb-программа, которая обменивается данными с контроллерами через взаимно доступные переменные.

Если вы загляните в каталог app / views библиотечного приложения, вы увидите один подкаталог для каждого из контроллеров, который мы создали: book. Каждый из этих подкаталогов был создан автоматически при создании контроллера с одноименным названием в сценарии создания.

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

Итак, давайте создадим файлы представлений для всех методов, которые мы определили в book_controller.rb. При выполнении этих представлений одновременно проверяйте, применимы эти действия к базе данных или нет.

Создание файла представления для метода списка

Создайте файл с именем list.html.erb, используя ваш любимый текстовый редактор, и сохраните его в app / views / book. После создания и сохранения файла обновите веб-браузер. Вы должны увидеть пустую страницу; если вы этого не сделаете, проверьте правильность написания вашего файла и убедитесь, что он точно такой же, как метод вашего контроллера.

Теперь отобразите актуальный контент. Давайте поместим следующий код в list.html.erb.

<% if @books.blank? %>
<p>There are not any books currently in the system.</p>
<% else %>
<p>These are the current books in our system</p>

<ul id = "books">
   <% @books.each do |c| %>
   <li><%= link_to c.title, {:action => 'show', :id => c.id} -%></li>
   <% end %>
</ul>

<% end %>
<p><%= link_to "Add new Book", {:action => 'new' }%></p>

Код, который нужно выполнить, должен проверить, есть ли в массиве @books какие-либо объекты. .Blank? Метод возвращает true, если массив пуст, и false, если он содержит какие-либо объекты. Этот объект @books был создан в контроллере внутри метода list.

Код между тегами <% =%> является вызовом метода link_to . Первый параметр link_to – это текст, отображаемый между тегами <a>. Второй параметр – это то, что действие вызывается при нажатии на ссылку. В данном случае это метод show. Последний параметр – это идентификатор книги, которая передается через объект params.

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

Создание файла представления для нового метода

До сих пор в нашей библиотеке нет книг. Мы должны создать несколько книг в системе. Итак, давайте спроектируем представление, соответствующее новому методу, определенному в book_controller.rb.

Создайте файл с именем new.html.erb, используя ваш любимый текстовый редактор, и сохраните его в app / views / book. Добавьте следующий код в файл new.html.erb.

<h1>Add new book</h1>

<%= form_tag :action => 'create' do %>
<p><label for = "book_title">Title</label>:

<%= text_field 'books', 'title' %></p>
<p><label for = "book_price">Price</label>:

<%= text_field 'books', 'price' %></p>
<p><label for = "book_subject_id">Subject</label>:

<%= collection_select(:books, :subject_id, @subjects, :id, :name, prompt: true) %></p>
<p><label for = "book_description">Description</label><br/>

<%= text_area 'books', 'description' %></p>
<%= submit_tag "Create" %>

<% end -%>
<%= link_to 'Back', {:action => 'list'} %>

Здесь метод form_tag интерпретирует код Ruby в обычный тег HTML <form>, используя всю предоставленную ему информацию. Этот тег, например, выводит следующий HTML –

<form action = "/book/create" method = "post">

Следующим методом является text_field, которое выводит текстовое поле <input>. Параметрами для text_field являются имя объекта и поля. В этом случае объект – книга, а имя – заголовок .

Метод Rails, называемый collection_select , создает меню выбора HTML, построенное из массива, такого как @books. Есть пять параметров, которые следующие:

• : book – Объект, которым вы манипулируете. В данном случае это объект книги.

• : subject_id – Поле, которое заполняется при сохранении книги.

• @books – Массив, с которым вы работаете.

• : id – значение, которое хранится в базе данных. С точки зрения HTML, это параметр значения тега <option>.

• : name – вывод, который пользователь видит в выпадающем меню. Это значение между тегами <option>.

: book – Объект, которым вы манипулируете. В данном случае это объект книги.

: subject_id – Поле, которое заполняется при сохранении книги.

@books – Массив, с которым вы работаете.

: id – значение, которое хранится в базе данных. С точки зрения HTML, это параметр значения тега <option>.

: name – вывод, который пользователь видит в выпадающем меню. Это значение между тегами <option>.

Следующим используемым является submit_tag , который выводит кнопку <input>, которая отправляет форму. Наконец, есть метод end, который просто переводится в </ form>.

Перейдите в свой браузер и посетите http: // localhost: 3000 / book / new. Это даст вам следующий экран.

Введите некоторые данные в эту форму и нажмите кнопку «Создать». Здесь я добавил следующие данные в поля –

Title: Advance Physics
Price: 390
Subject: Physics
Description: This is test to create new book

Когда вы нажимаете кнопку « Создать» , он вызывает метод create , который не нуждается ни в каком представлении, поскольку этот метод использует либо список, либо новые методы для просмотра результатов. Поэтому, когда вы нажимаете кнопку «Создать», данные должны быть успешно отправлены и перенаправлены на страницу списка, на которой теперь у вас есть один элемент, перечисленный ниже:

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

Создание файла представления для метода показа

Этот метод отобразит полную информацию о любой книге, доступной в библиотеке. Создайте файл show.html.erb в app / views / book и заполните его следующим кодом –

<h1><%= @book.title %></h1>

<p>
   <strong>Price: </strong> $<%= @book.price %><br />
   <strong>Subject :</strong> <%= @book.subject.name %><br />
   <strong>Created Date:</strong> <%= @book.created_at %><br />
</p>

<p><%= @book.description %></p>

<hr />

<%= link_to 'Back', {:action => 'list'} %>

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

Используемый формат: @ variable.relatedObject.column . В этом случае вы можете получить значение имени субъекта через переменную @book, используя ассоциации own_to . Если щелкнуть любую из перечисленных записей, появится следующий экран.

Создание файла вида для редактирования

Создайте новый файл с именем edit.html.erb и сохраните его в app / views / book. Заполните его следующим кодом –

<h1>Edit Book Detail</h1>

<%= form_for @book, :url =>{:action => "update", :id =>@book} do |f| %>

<p>Title: <%= f.text_field 'title' %></p>
<p>Price: <%= f.text_field  'price' %></p>
<p>Subject: <%= f.collection_select :subject_id, Subject.all, :id, :name %></p>
<p>Description<br/>

<%= f.text_area 'description' %></p>
<%= f.submit "Save changes" %>
<% end %>

<%= link_to 'Back', {:action => 'list' } %>

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

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

На этом этапе нам нужно внести некоторые изменения в файл представления метода list . Перейдите к элементу <li> </ li> и измените его так, чтобы он выглядел следующим образом:

<li>
   <%= link_to c.title, {:action => "show", :id => c.id} -%>
   <b> <%= link_to 'Edit', {:action => "edit",
   :id => c.id} %></b>
</li>

Теперь попробуйте просмотреть книги, используя http: // localhost: 3000 / book / list. Это даст вам список всех книг вместе с опцией редактирования . Когда вы нажмете опцию Edit, у вас будет следующий экран следующим образом –

Теперь вы редактируете эту информацию и затем нажимаете кнопку Сохранить изменения . Это приведет к вызову метода update, доступного в файле контроллера, и обновит все измененные атрибуты. Обратите внимание, что метод обновления не нуждается в каком-либо файле представления, потому что он использует либо методы show, либо edit для отображения своих результатов.

Создание файла представления для метода удаления

Удаление информации из базы данных с использованием Ruby on Rails почти слишком просто. Вам не нужно писать какой-либо код представления для метода удаления, поскольку этот метод использует метод списка для отображения результата. Итак, давайте просто изменим list.html.erb и добавим ссылку для удаления.

Перейдите к элементу <li> </ li> и измените его так, чтобы он выглядел следующим образом:

<li>
   <%= link_to c.title, {:action => 'show', :id => c.id} -%>
   <b> <%= link_to 'Edit', {:action => 'edit', :id => c.id} %></b>
   <b> <%= link_to "Delete", {:action => 'delete', :id => c.id},
   :confirm => "Are you sure you want to delete this item?" %></b>
</li>

Параметр : verify представляет окно подтверждения JavaScript, спрашивающее, действительно ли вы хотите выполнить действие. Если пользователь нажимает кнопку ОК, действие продолжается, и элемент удаляется.

Теперь попробуйте просмотреть книги, используя http: // localhost: 3000 / book / list. Это даст вам список всех книг вместе с опциями Edit и Delete следующим образом –

Теперь, используя опцию Удалить, вы можете удалить любую запись в списке.

Создание файла представления для метода show_subjects

Создайте новый файл show_subjects.html.erb в каталоге app / views / book и добавьте в него следующий код –

<h1><%= @subject.name -%></h1>

<ul>
   <% @subject.books.each do |c| %>
   <li><%= link_to c.title, :action => "show", :id => c.id -%></li>
   <% end %>
</ul>

Вы пользуетесь преимуществами ассоциаций, просматривая многочисленные списки книг одного предмета.

Теперь измените строку Subject: в show.html.erb, чтобы в списке тем отображалась ссылка.

<strong>Subject: </strong> <%= link_to @book.subject.name,
:action => "show_subjects", :id => @book.subject.id %><br />

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

Измените list.html.erb, добавив в начало файла следующее:

<ul id = "subjects">
   <% Subject.find(:all).each do |c| %>
   <li><%= link_to c.name, :action => "show_subjects", :id => c.id %></li>
   <% end %>
</ul>

Теперь попробуйте просмотреть книги, используя http: // localhost: 3000 / book / list. Он будет отображать все предметы со ссылками, чтобы вы могли просматривать все книги, связанные с этим предметом.

Что дальше?

Надеюсь, теперь вы чувствуете себя комфортно во всех операциях Rails.

В следующей главе объясняется, как использовать макеты, чтобы лучше представить ваши данные. Мы покажем вам, как использовать CSS в ваших Rails-приложениях.

Ruby on Rails – Макеты

Макет определяет окружение HTML-страницы. Это место, где можно определить общий вид вашего конечного результата. Файлы макетов находятся в app / views / layouts.

Процесс включает в себя определение шаблона макета и последующее уведомление контроллера о его существовании и его использовании. Сначала давайте создадим шаблон.

Добавьте новый файл с именем standard.html.erb в app / views / layouts. Вы сообщаете контроллерам, какой шаблон использовать по имени файла, поэтому рекомендуется придерживаться той же схемы именования.

Добавьте следующий код в новый файл standard.html.erb и сохраните изменения.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns = "http://www.w3.org/1999/xhtml">

   <head>
      <meta http-equiv = "Content-Type" content = "text/html; charset = iso-8859-1" />
      <meta http-equiv = "Content-Language" content = "en-us" />
      <title>Library Info System</title>
      <%= stylesheet_link_tag "style" %>
   </head>

   <body id = "library">
      <div id = "container">
         
         <div id = "header">
            <h1>Library Info System</h1>
            <h3>Library powered by Ruby on Rails</h3>
         </div>

         <div id = "content">
            <%= yield -%>
         </div>

         <div id = "sidebar"></div>
         
      </div>
   </body>
   
</html>

Все, что вы только что добавили, было стандартными элементами HTML, за исключением двух строк. Вспомогательный метод stylesheet_link_tag выводит таблицу стилей <link>. В этом случае мы связываем таблицу стилей style.css. Команда yield позволяет Rails знать, что для метода, вызываемого здесь, следует поместить html.erb.

Теперь откройте book_controller.rb и добавьте следующую строку чуть ниже первой строки –

class BookController < ApplicationController
layout 'standard'
def list
@books = Book.all
end
...................

Он указывает контроллеру, что мы хотим использовать макет, доступный в файле standard.html.erb. Теперь попробуйте просмотреть книги, которые будут отображать следующий экран.

Добавление таблицы стилей

До сих пор мы не создавали таблицы стилей, поэтому Rails использует таблицу стилей по умолчанию. Теперь давайте создадим новый файл с именем style.css и сохраним его в / public / stylesheets. Добавьте следующий код в этот файл.

body {
   font-family: Helvetica, Geneva, Arial, sans-serif;
   font-size: small;
   font-color: #000;
   background-color: #fff;
}

a:link, a:active, a:visited {
   color: #CD0000;
}

input { 
   margin-bottom: 5px;
}

p { 
   line-height: 150%;
}

div#container {
   width: 760px;
   margin: 0 auto;
}

div#header {
   text-align: center;
   padding-bottom: 15px;
}

div#content {
   float: left;
   width: 450px;
   padding: 10px;
}

div#content h3 {
   margin-top: 15px;
}

ul#books {
   list-style-type: none;
}

ul#books li {
   line-height: 140%;
}

div#sidebar {
   width: 200px;
   margin-left: 480px;
}

ul#subjects {
   width: 700px;
   text-align: center;
   padding: 5px;
   background-color: #ececec;
   border: 1px solid #ccc;
   margin-bottom: 20px;
}

ul#subjects li {
   display: inline;
   padding-left: 5px;
}

Теперь обновите ваш браузер и увидите разницу –

Что дальше?

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

Ruby on Rails – строительные леса

Пока вы разрабатываете Rails-приложения, особенно те, которые в основном предоставляют вам простой интерфейс для данных в базе данных, часто бывает полезно использовать метод scaffold.

Леса предоставляют больше, чем дешевые демонстрационные ощущения. Вот некоторые преимущества –

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

• Вы мотивированы более быстрым успехом.

• Вы можете узнать, как работает Rails, взглянув на сгенерированный код.

• Вы можете использовать строительные леса в качестве основы, чтобы начать разработку.

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

Вы мотивированы более быстрым успехом.

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

Вы можете использовать строительные леса в качестве основы, чтобы начать разработку.

Пример строительных лесов

Чтобы понять леса, давайте создадим базу данных с именем cookbook и таблицу с названием recipes .

Создание пустого веб-приложения Rails

Откройте командное окно и перейдите к месту, где вы хотите создать это веб-приложение кулинарной книги . Итак, выполните следующую команду, чтобы создать полную структуру каталогов.

tp> rails new cookbook

Настройка базы данных

Вот способ создать базу данных –

mysql> create database cookbook;
Query OK, 1 row affected (0.01 sec)

mysql> grant all privileges on cookbook.*
to 'root'@'localhost' identified by 'password';
Query OK, 0 rows affected (0.00 sec)

mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

Чтобы указать Rails, как найти базу данных, отредактируйте файл конфигурации cookbook config database.yml и измените имя базы данных на cookbook. Оставьте пароль пустым. Когда вы закончите, это должно выглядеть следующим образом –

development:
   adapter: mysql
   database: cookbook
   username: root
   password: [password]
   host: localhost
	
test:
   adapter: mysql
   database: cookbook
   username: root
   password: [password]
   host: localhost
	
production:
   adapter: mysql
   database: cookbook
   username: root
   password: [password]
   host: localhost

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

Сгенерированный код лесов

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

Итак, теперь давайте снова начнем генерировать код Scaffold вручную, используя вспомогательный скрипт scaffold –

cookbook> rails generate scaffold recipe

Он генерирует авто-файлы, как показано ниже –

Контроллер

Давайте посмотрим на код за контроллером. Этот код генерируется генератором скаффолдов . Если вы откроете app / controllers / recipes_controller.rb, то найдете следующее:

class RecipesController < ApplicationController
   before_action :set_recipe, only: [:show, :edit, :update, :destroy]
   
   # GET /recipes
   # GET /recipes.json
   def index
      @recipes = Recipe.all
   end
   
   # GET /recipes/1
   # GET /recipes/1.json
   def show
   end
   
   # GET /recipes/new
   def new
      @recipe = Recipe.new
   end
   
   # GET /recipes/1/edit
   def edit
   end
   
   # POST /recipes
   # POST /recipes.json
   def create
      @recipe = Recipe.new(recipe_params)
      
      respond_to do |format|
         if @recipe.save
            format.html { redirect_to @recipe, notice: 'Recipe was successfully created.' }
            format.json { render :show, status: :created, location: @recipe }
         else
            format.html { render :new }
            format.json { render json: @recipe.errors, status: :unprocessable_entity }
         end
      end
      
   end
   
   # PATCH/PUT /recipes/1
   # PATCH/PUT /recipes/1.json
   def update
      respond_to do |format|
         if @recipe.update(recipe_params)
            format.html { redirect_to @recipe, notice: 'Recipe was successfully updated.' }
            format.json { render :show, status: :ok, location: @recipe }
         else
            format.html { render :edit }
            format.json { render json: @recipe.errors, status: :unprocessable_entity }
         end
      end
      
   end
   
   # DELETE /recipes/1
   # DELETE /recipes/1.json
   def destroy
      @recipe.destroy
         respond_to do |format|
         format.html { redirect_to recipes_url, notice: 'Recipe was successfully destroyed.' }
         format.json { head :no_content }
      end
   end
   
   private
   
   # Use callbacks to share common setup or constraints between actions.
   def set_recipe
      @recipe = Recipe.find(params[:id])
   end
   
   # Never trust parameters from the scary internet, only allow the white list through.
   def recipe_params
      params.require(:recipe).permit(:tittle, :instructions)
   end
end

Когда пользователь приложения Rails выбирает действие, например «Показать», контроллер выполнит любой код в соответствующем разделе – «def show» – и затем по умолчанию отобразит шаблон с тем же именем – «show.html». Еврорадио». Это поведение по умолчанию может быть перезаписано.

Контроллер использует методы ActiveRecord, такие как find, find_all, new, save, update_attributes и destroy для перемещения данных в таблицы базы данных и из них. Обратите внимание, что вам не нужно писать какие-либо операторы SQL, rails позаботится об этом автоматически.

Эта единственная строка кода оживит таблицу базы данных. Это обеспечит простой интерфейс для ваших данных и способы –

• Создание новых записей
• Редактирование текущих записей
• Просмотр текущих записей
• Уничтожение текущих записей

При создании или редактировании записи scaffold будет выполнять за вас всю тяжелую работу, такую ​​как генерация и обработка форм, и даже обеспечит умную генерацию форм, поддерживая следующие типы входных данных:

• Простые текстовые строки
• Текстовые области (или большие блоки текста)
• Селекторы даты
• Селекторы даты и времени

Вы можете использовать Rails Migrations для создания и обслуживания таблиц.

rake db:migrate RAILS_ENV=development

Теперь перейдите в каталог поваренной книги и запустите веб-сервер, используя следующую команду:

cookbook> rails server

Теперь откройте браузер и перейдите по адресу http://127.0.0.1:3000/recipe/new. Это предоставит вам экран для создания новых записей в таблице рецептов. Скриншот показан ниже –

После того, как вы нажмете кнопку « Создать» , чтобы создать новый рецепт, ваша запись будет добавлена ​​в таблицу рецептов, и на ней будет показан следующий результат:

Вы можете увидеть возможность редактировать, показывать и уничтожать записи. Итак, поиграйтесь с этими опциями.

Вы также можете перечислить все рецепты, доступные в таблице рецептов, используя URL-адрес http://127.0.0.1:3000/recipe/list.

Улучшение модели

Rails дает вам много обработки ошибок бесплатно. Чтобы понять это, добавьте некоторые правила проверки в пустую модель рецепта –

Измените app / models / recipe.rb следующим образом, а затем протестируйте свое приложение –

class Recipe < ActiveRecord::Base
   validates_length_of :title, :within => 1..20
   validates_uniqueness_of :title, :message => "already exists"
end

Эти записи дадут автоматическую проверку.

• validates_length_of – поле не пустое и не слишком длинное.

• validates_uniqueness_of – повторяющиеся значения перехвачены. Вместо сообщения об ошибке Rails по умолчанию мы дали здесь собственное сообщение.

validates_length_of – поле не пустое и не слишком длинное.

validates_uniqueness_of – повторяющиеся значения перехвачены. Вместо сообщения об ошибке Rails по умолчанию мы дали здесь собственное сообщение.

Альтернативный способ создания лесов

Создайте приложение, как показано выше, и сгенерированный код скаффолда, как показано ниже.

rails g scaffold Recipe tittle:string instructions:text

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

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

$ rake db:migrate RAILS_ENV=development

Наконец, запустите приложение, используя следующую командную строку –

rails server

Результат будет сгенерирован так, как показано на рисунке выше.

Виды

Все представления и соответствующие им методы контроллера создаются командой scaffold, и они доступны в каталоге app / views / recipes.

Чем отличаются строительные леса?

Если вы прошли предыдущие главы, значит, вы уже видели, что мы создали методы для отображения, отображения, удаления и создания данных и т. Д., Но scaffolding выполняет эту работу автоматически.

Ruby on Rails – AJAX

Ajax расшифровывается как A синхронный J avaScript и X ML. Ajax – это не единственная технология; это набор из нескольких технологий. Аякс включает в себя следующее –

• XHTML для разметки веб-страниц
• CSS для стиля
• Динамическое отображение и взаимодействие с использованием DOM
• Обработка и обмен данными с использованием XML
• Извлечение данных с использованием XMLHttpRequest
• JavaScript как клей, который объединяет все это

Ajax позволяет вам получать данные для веб-страницы, не обновляя содержимое всей страницы. В базовой веб-архитектуре пользователь щелкает ссылку или отправляет форму. Форма отправляется на сервер, который затем отправляет ответ. Ответ отображается для пользователя на новой странице.

Когда вы взаимодействуете с веб-страницей на основе Ajax, она загружает движок Ajax в фоновом режиме. Движок написан на JavaScript, и его обязанностью является как связываться с веб-сервером, так и отображать результаты для пользователя. Когда вы отправляете данные с помощью формы на основе Ajax, сервер возвращает фрагмент HTML, который содержит ответ сервера и отображает только новые или измененные данные, а не обновление всей страницы.

Для получения полной информации о AJAX вы можете пройти наш учебник AJAX

Как Rails реализует Ajax

Rails имеет простую, согласованную модель реализации Ajax-операций. После того, как браузер отобразил и отобразил исходную веб-страницу, различные действия пользователя приводят к тому, что он отображает новую веб-страницу (как любое традиционное веб-приложение) или запускает операцию Ajax –

• Некоторые срабатывания триггера. Этот триггер может быть пользователем, нажимающим кнопку или ссылку, пользователем, вносящим изменения в данные в форме или в поле, или просто периодическим триггером (на основе таймера).

• Веб-клиент вызывает сервер – метод JavaScript, XMLHttpRequest , отправляет данные, связанные с триггером, обработчику действий на сервере. Данные могут быть идентификатором флажка, текстом в поле ввода или целой формой.

• Сервер выполняет обработку – обработчик действий на стороне сервера (действие контроллера Rails) – что-то делает с данными и возвращает HTML-фрагмент веб-клиенту.

• Клиент получает ответ – JavaScript-код на стороне клиента, который Rails создает автоматически, получает фрагмент HTML и использует его для обновления определенной части HTML-кода текущей страницы, часто содержимого тега <div>.

Некоторые срабатывания триггера. Этот триггер может быть пользователем, нажимающим кнопку или ссылку, пользователем, вносящим изменения в данные в форме или в поле, или просто периодическим триггером (на основе таймера).

Веб-клиент вызывает сервер – метод JavaScript, XMLHttpRequest , отправляет данные, связанные с триггером, обработчику действий на сервере. Данные могут быть идентификатором флажка, текстом в поле ввода или целой формой.

Сервер выполняет обработку – обработчик действий на стороне сервера (действие контроллера Rails) – что-то делает с данными и возвращает HTML-фрагмент веб-клиенту.

Клиент получает ответ – JavaScript-код на стороне клиента, который Rails создает автоматически, получает фрагмент HTML и использует его для обновления определенной части HTML-кода текущей страницы, часто содержимого тега <div>.

Эти шаги являются простейшим способом использования Ajax в приложении Rails, но с небольшой дополнительной работой вы можете заставить сервер возвращать любые данные в ответ на запрос Ajax, и вы можете создать собственный JavaScript в браузере, чтобы выполнить больше вовлеченные взаимодействия.

Пример AJAX

Этот пример работает на основе скаффолда, концепция Destroy работает на основе ajax.

В этом примере мы предоставим, перечислим, покажем и создадим операции над таблицей пони. Если вы не понимаете технологию скаффолдов, мы советуем вам сначала пройти предыдущие главы, а затем перейти к AJAX on Rails.

Создание приложения

Начнем с создания приложения. Это будет сделано следующим образом –

rails new ponies

Приведенная выше команда создает приложение, теперь нам нужно вызвать каталог приложения с помощью команды cd. Он войдет в каталог приложения, после чего нам нужно вызвать команду scaffold. Это будет сделано следующим образом –

rails generate scaffold Pony name:string profession:string

Команда выше генерирует эшафот с колонкой имени и профессии. Нам нужно перенести базу данных следующим образом

rake db:migrate

Теперь запустите приложение Rails, выполнив следующую команду

rails s

Теперь откройте веб-браузер и вызовите URL-адрес как http: // localhost: 3000 / ponies / new. Вывод будет следующим

Создание Ajax

Теперь откройте app / views / ponies / index.html.erb с подходящими текстовыми редакторами. Обновите строку уничтожения с помощью: remote => true,: class => ‘delete_pony’. Наконец, это выглядит следующим образом.

Создайте файл destroy.js.erb, поместите его рядом с другими файлами .erb (в app / views / ponies). Это должно выглядеть так –

Теперь введите код, как показано ниже в destroy.js.erb

$('.delete_pony').bind('ajax:success', function() {
   $(this).closest('tr').fadeOut();
});

Теперь откройте файл вашего контроллера, который находится в app / controllers / ponies_controller.rb и добавьте следующий код в метод уничтожения, как показано ниже:

# DELETE /ponies/1
# DELETE /ponies/1.json
def destroy
   @pony = Pony.find(params[:id])
   @pony.destroy
   
   respond_to do |format|
      format.html { redirect_to ponies_url }
      format.json { head :no_content }
      format.js   { render :layout => false }
   end
   
end

Наконец, страница контроллера выглядит так, как показано на рисунке.

Теперь запустите приложение, которое вызывается из http: // localhost: 3000 / ponies / new, оно будет выглядеть следующим образом

Нажмите на кнопку создания пони, он будет генерировать результат следующим образом

Теперь нажмите на кнопку назад, она покажет всю созданную пони информацию, как показано на рисунке

До сих пор мы работаем над скаффолдом, теперь нажимаем кнопку уничтожения, он вызывает всплывающее окно, как показано на рисунке ниже, всплывающее окно работает на основе Ajax.

Если нажать кнопку ОК, он удалит запись из пони. Здесь я нажал кнопку ОК. Окончательный результат будет следующим:

Ruby on Rails – загрузка файлов

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

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

tp> rails new testfile

Перед началом разработки приложения мы должны установить gem-файлы, как показано ниже –

gem install carrierwave
gem install bootstrap-sass

Откройте свой гемфайл и добавьте следующие два камня внизу, как показано на следующем рисунке –

После добавления драгоценных камней в файл gem нам нужно выполнить следующую команду в консоли:

bundle install

Создание модели

Нам нужно создать модель с двумя строками в качестве имени и вложения, как показано ниже –

rails g model Resume name:string attachment:string

Нам нужно создать миграцию базы данных, как показано ниже –

rake db:migrate

Нам нужно сгенерировать контроллер, как показано ниже –

rails g controller Resumes index new create destroy

Большой! Теперь у нас есть базовая структура. Теперь нам нужно создать загрузчик. Uploader был создан на носителе carrierwave и в нем рассказывается, как обрабатывать файлы. Короче говоря, он содержал все функции обработки файлов. Запустите команду, чтобы создать загрузчик, как показано ниже

rails g uploader attachment

Теперь откройте модель возобновления и вызовите загрузчик, как показано ниже. Резюме модель разместила в app / models / resume.rb –

class Resume < ActiveRecord::Base
   mount_uploader :attachment, AttachmentUploader # Tells rails to use this uploader for this model.
   validates :name, presence: true # Make sure the owner's name is present.
end

Перед работой на контроллере нам нужно изменить наш config / rout.db, как показано ниже –

CarrierWaveExample::Application.routes.draw do
   resources :resumes, only: [:index, :new, :create, :destroy]
   root "resumes#index"
end

Позволяет нам редактировать контроллер, как показано ниже.

class ResumesController < ApplicationController
   def index
      @resumes = Resume.all
   end
   
   def new
      @resume = Resume.new
   end
   
   def create
      @resume = Resume.new(resume_params)
      
      if @resume.save
         redirect_to resumes_path, notice: "The resume #{@resume.name} has been uploaded."
      else
         render "new"
      end
      
   end
   
   def destroy
      @resume = Resume.find(params[:id])
      @resume.destroy
      redirect_to resumes_path, notice:  "The resume #{@resume.name} has been deleted."
   end
   
   private
      def resume_params
      params.require(:resume).permit(:name, :attachment)
   end
   
end

Давайте добавим загрузочную реализацию в файл css file.css в app / assets / stylesheets / resumes.css.scss

@import "bootstrap";

Теперь откройте app / views / layouts / application.html.erb и добавьте коды, как показано ниже –

<!DOCTYPE html>
<html>
   
   <head>
      <title>Tutorialspoint</title>
      <%= stylesheet_link_tag "application", media: "all", "data-turbolinks-track" => true %>
      <%= javascript_include_tag "application", "data-turbolinks-track" => true %>
      <%= csrf_meta_tags %>
   </head>
   
   <body>
      <div class = "container" style = "padding-top:20px;">
         <%= yield %>
      </div>
   </body>

</html>

Теперь нам нужно настроить индексные представления, как показано ниже –

<% if !flash[:notice].blank? %>
   <div class = "alert alert-info">
      <%= flash[:notice] %>
   </div>
<% end %>

<br />

<%= link_to "New Resume", new_resume_path, class: "btn btn-primary" %>
<br />
<br />

<table class = "table table-bordered table-striped">
   <thead>.
      <tr>
         <th>Name</th>
         <th>Download Link</th>
         <th> </th>
      </tr>
   </thead>
   
   <tbody>
      <% @resumes.each do |resume| %>
         
         <tr>
            <td><%= resume.name %></td>
            <td><%= link_to "Download Resume", resume.attachment_url %></td>
            <td><%= button_to "Delete",  resume, method: :delete, class: "btn btn-danger", confirm: "Are you sure that you wish to delete #{resume.name}?" %></td>
         </tr>
         
      <% end %>
   </tbody>
   
</table>

Теперь давайте отредактируем new.html.erb и добавим наш код формы.

<% if !@resume.errors.empty? %>
   <div class = "alert alert-error">
      
      <ul>
         <% @resume.errors.full_messages.each do |msg| %>
            <li><%= msg %></li>
         <% end %>
      </ul>
      
   </div>
<% end %>

<div class = "well">
   <%= form_for @resume, html: { multipart: true } do |f| %>
      <%= f.label :name %>
      <%= f.text_field :name %>
      <%= f.label :attachment %>
      <%= f.file_field :attachment %>
      <%= f.submit "Save", class: "btn btn-primary" %>
   <% end %>
</div>

Теперь запустите сервер и зайдите на http: // localhost: 3000. Это произведет экран, подобный следующему –

Последнее, что нам нужно сделать, это отфильтровать список разрешенных типов файлов. Для этого нам нужно добавить простой код, как показано ниже в app / uploaders / attachment_uploader.rb

class AttachmentUploader < CarrierWave::Uploader::Base
   storage :file
   
   def store_dir
      "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
   end
   
   def extension_white_list
      %w(pdf doc htm html docx)
   end
end

Теперь запустите сервер и зайдите на http: // localhost: 3000. Теперь введите неверный формат; это сгенерирует неправильное сообщение, как показано ниже –

Для получения полной информации об объекте File , вам нужно пройти справочное руководство по Ruby .

Ruby on Rails – отправка электронных писем

Action Mailer – это компонент Rails, который позволяет приложениям отправлять и получать электронную почту. В этой главе мы увидим, как отправить электронное письмо с помощью Rails. Давайте начнем создавать проект электронной почты, используя следующую команду.

tp> rails new mailtest

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

Action Mailer – Конфигурация

Ниже приведены шаги, которые вы должны выполнить, чтобы завершить настройку, прежде чем приступить к реальной работе –

Перейдите в папку config вашего проекта электронной почты и откройте файл environment.rb и добавьте следующую строку внизу этого файла.

config.action_mailer.delivery_method = :smtp

Он сообщает ActionMailer, что вы хотите использовать SMTP-сервер. Вы также можете установить его: sendmail, если вы используете операционную систему на основе Unix, такую ​​как Mac OS X или Linux.

Добавьте также следующие строки кода внизу вашего environment.rb.

config.action_mailer.smtp_settings = {
   address:              'smtp.gmail.com',
   port:                 587,
   domain:               'example.com',
   user_name:            '<username>',
   password:             '<password>',
   authentication:       'plain',
   enable_starttls_auto: true  
}

Замените каждое хеш-значение правильными настройками для вашего SMTP-сервера. Вы можете взять эту информацию у своего интернет-провайдера, если вы уже не знаете. Вам не нужно менять номер порта 25 и тип аутентификации, если вы используете стандартный SMTP-сервер.

Вы также можете изменить формат сообщения электронной почты по умолчанию. Если вы предпочитаете отправлять электронную почту в формате HTML, а не в текстовом формате, добавьте также следующую строку в config / environment.rb:

ActionMailer::Base.default_content_type = "text/html"

ActionMailer :: Base.default_content_type может быть установлен в «text / plain», «text / html» и «text / enriched». Значением по умолчанию является «text / plain».

Следующим шагом будет создание почтовой программы

Создать почтовик

Используйте следующую команду для генерации почтовой программы следующим образом:

tp> cd emails
emails> rails generate mailer Usermailer

Это создаст файл user_mailer.rb в каталоге app mailer. Проверьте содержимое этого файла следующим образом –

class Emailer < ActionMailer::Base
end

Давайте создадим один метод следующим образом –

class UserMailer < ApplicationMailer
   default from: 'notifications@example.com'
   
   def welcome_email(user)
      @user = user
      @url  = 'http://www.gmail.com'
      mail(to: @user.email, subject: 'Welcome to My Awesome Site')
   end
   
end

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

• mail – фактическое сообщение электронной почты, в которое мы передаем заголовки: to и:.

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

mail – фактическое сообщение электронной почты, в которое мы передаем заголовки: to и:.

Создайте файл с именем welcome_email.html.erb в app / views / user_mailer /. Это будет шаблон, используемый для письма, отформатированный в HTML –

<html>
   
   <head>
      <meta content = 'text/html; charset = UTF-8' http-equiv = 'Content-Type' />
   </head>
   
   <body>
      <h1>Welcome to example.com, <%= @user.name %></h1>
      
      <p>
         You have successfully signed up to example.com,your username is: 
         <%= @user.login %>.<br>
      </p>
      
      <p>
         To login to the site, just follow this link: 
         <%= @url %>.
      </p>
      
      <p>Thanks for joining and have a great day!</p>
      
   </body>
</html>

Далее мы создадим текстовую часть для этого приложения следующим образом –

Welcome to example.com, <%= @user.name %>
===============================================
 
You have successfully signed up to example.com,
your username is: <%= @user.login %>.
 
To login to the site, just follow this link: <%= @url %>.
 
Thanks for joining and have a great day!

Звонить по почте

Во-первых, давайте создадим простой пользовательский эшафот

$ bin/rails generate scaffold user name email login
$ bin/rake db:migrate

Action Mailer прекрасно интегрирован с Active Job, так что вы можете отправлять электронные письма вне цикла запрос-ответ, так что пользователю не нужно ждать его –

class UsersController < ApplicationController
   # POST /users
   # POST /users.json
   def create
   @user = User.new(params[:user])
   
      respond_to do |format|
         if @user.save
            # Tell the UserMailer to send a welcome email after save
            UserMailer.welcome_email(@user).deliver_later
            
            format.html { redirect_to(@user, notice: 'User was successfully created.') }
            format.json { render json: @user, status: :created, location: @user }
         else
            format.html { render action: 'new' }
            format.json { render json: @user.errors, status: :unprocessable_entity }
         end
         
      end
      
   end
end

Теперь протестируйте ваше приложение, используя http://127.0.0.1:3000/users/new. Он отображает следующий экран, и с помощью этого экрана вы сможете отправить свое сообщение кому угодно.

Это отправит ваше сообщение и отобразит текстовое сообщение «Сообщение успешно отправлено» и будет выведено следующим образом:

sent mail to kittuprasad700@gmail.com (2023.Sms)
[ActiveJob] [ActionMailler::DeliveryJob] [2cfde3c-260e-4a33-1a6ada13a9b] Date: Thu, 09 Jul 2015 11:44:05 +0530
From: notification@example.com
To: kittuprasad700@gmail.com
Message-Id: <559e112d63c57_f1031e7f23467@kiranPro.mail>
Subject: Welcome to My Awesome Site
Mime-Version: 1.0
Content-Type: multipart/alternative;
boundary="--mimepart_559e112d601c8_f1031e7f20233f5";
charset=UTF-8
Content-Transfer-Encoding:7bit

Для получения дополнительной информации о том, как отправлять электронную почту с помощью Rails, пожалуйста, перейдите через ActionMailer .

Sorry, content not available

Знакомство с 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, вы можете без проблем разобраться в чужом коде.

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 и установке 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. Учебные статьи.

Время на прочтение
7 мин

Количество просмотров 111K

Зачем.

В этой маленькой статье, которую с удовольствием прочитал бы сам неделю назад, я попытался собрать все вещи, которые понадобились бы человеку, задумай он «с нуля» написать приложение на RoR. То есть не углубляясь ни в одну из областей, описать необходимый минимум действий, чтобы установить, настроить и написать своё первое приложение.Здесь собрано, как мне кажется, всё, что нужно и я надеюсь этот текст сэкономит кому-нибудь несколько часов поиска в интернете). Сам изучаю RoR вторую неделю, так что не судите строго).

Установка.

Просто и быстро ror ставится через rvm c rvm.io.

>curl -L https://get.rvm.io | bash -s stable --rails --autolibs=enabled

Запустить rvm:

>source /Путь_к_домашней_директории*/.rvm/scripts/rvm

*$HOME в дальнейшем.
После этого в $HOME/.bash_profile должна появиться строчка:

[[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm" # Load RVM into a shell session *as a function*

и при каждом открытии консоли rvm будет подгружаться, но у меня этого не случилось — пришлось ещё в $HOME/bashrc прописывать:

. ~/.bash_profile

Теперь всё точно должно быть хорошо.
Устанавливаем нужную(скорее всего это будет самая последняя) версию руби (сколько их и в чём отличие можно посмотреть здесь -http://www.ruby-lang.org).

>rvm install 1.9.3

Проверка на успешность создания

>ruby -v

должна вернуть более подробную информацию, вроде

ruby 1.9.2p320 (2012-04-20 revision 35421) [x86_64-linux].

В процессе установки я случайно установил несколько версий, что потом доставило некоторые неприятности). Посмотреть список установленных версий руби можно так:
>rvm list
Если версий несколько, то текущая будет помечена «=>», дефолтная — «*», а текущая и дефолтная — «=*». Поменять на нужную используемую версию можно так:

>rvm use ruby-1.9.2-p320 (любая нужная версия)

Чтобы поменять дефолтную версию руби пишем:

>rvm use ruby-1.9.2-p320 --default

Создание проекта.

Теперь можно перейти непосредственно к созданию проекта. Создаём папку $HOME/ROR/tickets, заходим в неё и делаем следующее.

>sudo gem install bundler
>rails new tickets

При создании проекта будут сгенерированы все необходимые директории(app,config,db,log и т.п.) и конфигурационные файлы в указанной папке. Для работы небольшого тестового проекта нам потребуется, в моём случае, база данных PostgreSQL, пара gem-ов(библиотек) и запущенный rails сервер).
Для запуска сервера нужно, находясь в корне папки с созданным проектом запустить команду:

>rails s -p 3000

где s — команда запуска сервера(server), а -p 3000 -номер порта(port), по которому будет доступен проект. Что бы запустить консоль, нужно набрать:

>rails c

где с- сокращение от console
Список всех команд можно посмотреть, набрав
>rails —h. Теперь по адресу localhost:3000 мы увидем стартовую страницу проекта. Так же можно запускать любое количество серверов других проектов на других, не занятых портах. В ходе работы. у меня в один момент по какой-то неведомой мне причине возникла проблема с запуском сервера — выдавалась ошибка, что сервер уже запущен — для её решения нужно просто удалить файл $HOME/ROR/tickets/config/tmp/pids/server.pid и запустить сервер ещё раз.

База данных.

Чтобы работать с постгресом, добавляем в конец файла Gemfile, который должен находится в корне проекта, строчку
>gem ‘pg’
сохраняем файл и делаем

>bundle install

его мы делаем каждый раз, когда вносим изменения в Gemfile, а потом ещё и перезапускаем сервер. Чтобы сюда больше не возвращаться, сразу же добавляем и
>gem ‘haml-rails’ для быстрой и удобной(после того как привыкнешь)) разметки шаблонов-представлений. Теперь отредактируем атрибуты конекта к постгресу в файле database.yml. Он находится в папке $HOME/ROR/tickets/config/ и должен будет содержать такой блок:

development:
  host: localhost
  adapter: postgresql
  encoding: unicode
  database: tickets
  pool: 5
  username: tickets

с нужными пользователем и именем БД, у меня это tickets и tickets соответственно).

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

Модель.

Создаём модель:

>rails g model user

где g- сокращение от generate
Название модели пишем в единственном числе — таблица в бд будет во множественном. Эта команда создаст файлы модели и миграции в $HOME/ROR/tickets/app/models/user.rb и $HOME/ROR/tickets/app/db/migrate/20130425081208_create_users.rb. все файлы контроллеров и моделей имеют расширение .rb, представлений — .html.haml(в нашем случае использования haml). Посредством миграции мы будем управлять работой с таблицами в БД через консоль, что весьма удобно(опять таки, когда привыкаешь), так же ониобеспечивают простоту переноса приложения, на другой сервер, например. Добавляем нужные поля:

class CreateUsers < ActiveRecord::Migration
  def up
    create_table :users do |t|
      t.string :name, null: false
      t.boolean :role, null: false, default: false
      t.datetime :reg_date
      t.timestamps
    end
  end
  
  def down
     drop_table :users
  end

end

Создаём два метода — up и down, которые используются по умолчанию функциями работы с миграциями — они, соответственно, создают и удаляют нашу таблицу. Названия типы данных будут зависеть от используемой БД. Первичный ключ создаётся по умолчанию и будет называться id, но его можно задать и явно:

create_table :users, :primary_key => :users_id do |t|

А если мы не хотим создавать первмчный ключ вообще, пишем так:

create_table :users, :id => false do |t|

Сохраняем и пишем в консоле:

>rake db:migrate

В результате действия этой команды выполняются все невыполненные методы up из файлов миграций в директории $HOME/ROR/tickets/app/db/migrate/. Все сведения о состоянии таблиц можно посмотреть в файле $HOME/ROR/tickets/app/db/shema.rb.

>rake db:rollback

Запускает метод down последней выполненной миграции, в результате чего таблица удаляется из БД. Чтобы откатить больше миграций, нужно добавить к команде rollback параметр STEP:

>rake db:rollback STEP=3

эта команда откатит три последние миграции. Посмотреть статус всех миграций в консоли:

>rake db:migrate:status

Если нужно запустить какой-то определённый метод из определённой миграции, то добавляем параметр VERSION:

>rake db:migrate:up VERSION=000001

В файле модели ($HOME/ROR/tickets/app/models/user.rb) нам пока нужно сделать только одно — определить поля таблицы, которые будут доступны для изменения из контроллера, в целях безопасности, как я понимаю). Для этого пишем в нём следующее:

class User < ActiveRecord::Base

   attr_accessible :name, :role

end

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

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

>user = User.new(name:"Test",role:"true")

эта команда не сделает запись в таблицу, но создаст объект руюи в памяти со всеми установленными атрибутами. А теперь сделаем запись:

>user.save

в случае успеха должна вернуть true. Запись можно создать и одной командой — create:

>User.create(name:"Test",role:"true")

Чтобы проверить есть ли объект в БД, можно использовать find:

>User.find(1)

вернёт объект или ошибку: «ActiveRecord::RecordNotFound: Couldn’t find User with id=1», а так же и сам сгенерированный sql-запрос к БД.
Искать можно и по конкретным полям:

>User.find_by_name("Test")

Ещё несколько удобных методов, которые наверняка пригодятся на первых порах:
>User.first и User.last -вернут первую и последнюю запись в таблице соответственно, а User.all вернёт массив всех объектов таблицы.

Контроллер.

Создаём контроллер:

>rails g controller users

В результате этой команды будут созданы файл контроллера: $HOME/ROR/tickets/app/controllers/users_controller.rb и директория для представлений:
$HOME/ROR/tickets/app/views/users/. Каждому методу котроллера будет соответствовать представление с таким же названием, в этой папке. Их можно создавать вручную, а можно и сразу при создании контроллера:

>rails g controller users index,list

В этом случае файлы представлений создадутся автоматически в папке $HOME/ROR/tickets/app/views/users/ и будут называться (если вы не забыли подключить haml) index.html.haml и list.html.haml. Удалить контроллер можно так:

>rails d controller users

где d- сокращение от destroy
Определять метод index, который создаётся по умолчанию, не обязательно. Содержимое нашего контроллера users будет таким:

class UsersController < ApplicationController
  def list
     @users_list=User.all
     
  end

end

В users_list будет массив объектов пользователей, которых мы по идее уже понадобавляли из консоли, а «@» означает, что переменная будет передана в шаблон.

Представление.

Теперь создаёи представление, я просто создал этот файл руками в нужной директории:
$HOME/ROR/tickets/app/views/users/list.html.haml
Документацию по HAML можно почитать здесь (http://haml.info/tutorial.html), а пока набо понадобится минимум знаний о нём, например то, что вместо открывающего и закрывающего тега в нём используется «%tag». То есть после рендеринга шаблона, содержащего %html, мы получим страницу с

<html></html>

. Уровень вложенности задаётся табуляцией, атрибуты тегов пишутся «хешеобразно» в фигурных скобках:

 %td{colspan=>"2"}

превратится в

<td colspan="2"></td>

, а содержимое — через пробел: %td test. Таким образом содержимое нашего представления:

%table{:border=>"1"}
	%tr
		%td Логин
		%td Администратор
	- @users_list.each do |users|
		%tr
			%td= users.name
			%td
				%input{:type=>"checkbox",:name=>"role_#{users.id}",:checked=>users.role}
			
				
%br

Дефис — исполняемый код в шаблоне. Здесь мы проходимся по массиву объектов и выводим в цикле его методы — поля name и role и id.

Все представления «оборачиваются» в главный шаблон, который находится в $HOME/ROR/tickets/app/views/layouts/application.html.haml
Удаляем всё, что в нём есть и делаем его максимально простым:

!!!
%html{:lang => "en"}
	%head
		%title Test
	%body
		=yield

Содержимое всех наших сгенерированных шаблонов подставляется вместо =yield. Главное не ошибится с уровнями вложенности, меня это поначалу очень напрягало).

Маршруты.

И остался только один маленький шаг — редактирование файла-конфига маршрутов(url) — routes.rb. Он находится в $HOME/ROR/tickets/config/. В нём описываются все маршруты нашего проекта. Сейчас там будет только две записи:

Tickets::Application.routes.draw do

  root :to => "users#index" 

  #GET Urls
  get "users/list"

end

Это рутовый путь на «главную» страницу(будет показываться содержимое шаблона /users/index.html.haml, даже несмотря на то, что метод index в контроллере не определён) и путь к странице вывода списка пользователей. В случае, если к методу будет пост запрос, он должен будет прописываться так:
post «users/add».
Теперь всё должно работать)