Что такое Ruby on rails и почему его так любят.

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

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

7 китов совершенства ruby on rails

Первый, Ruby On Rails это Ruby
Ruby on Rails - фреймворк написанный на самом лучшем языке программирования Ruby.
Красота и удобность программирования просто не описуема словами. Ruby on Rails дополняет этот совершенный язык новыми методами, классами для взаимодействия объектов, классов.

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

Второй, Ruby on Rails использует MVC

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

Модель содержит математическую логику приложения, здесь указываются ассоциативные связи между моделями, различные callback"и и основной код приложения.
Представления используются для отображения информации пользователю, представлением является, графический интерфейс приложения или веб-интерфейс веб-приложения. Здесь различные html формы, css стили и javascript.
Контроллер занимается связыванием модели с представлением и обработкой запроса пользователя приложения. Здесь вы с помощью раутов(routes) настраиваете маршрутизацию вашего приложения.
Использование MVC позволяет писать более чистый и структурированный код, что значительно ускоряет разработку и при этом облегчает поддержку приложения.

Третий, Ruby on Rails использует CoC
CoC - Convention over Configuration (Соглашение превыше настройки) - вся идея состоит в том, что по умолчанию фреймворк уже отлично настроен. Ruby on Rails поставляется с набором крайне удобных соглашений, которые позволяют начинать разработку приложения сразу же после установки Ruby on Rails и создания нового проекта. При необходимости можно изменить настройки по умолчанию (они то и называются соглашением) и использовать свои, однако это, как правило, не только является лишним, но и зачастую вредным.

Четвертый кит, DRY
DRY - Don’t Repeat Yourself (Не повторяйся!) - еще один принцип разработки положенный в основу веб-фреймворка Ruby on Rails и самого языка ruby. Этот принцип предписывает разработчику выявлять в коде повторяющиеся фрагменты и выносить их в отдельные методы, классы или модули в зависимости от ситуации. В Ruby on Rails этот принцип проявляется во многих местах, что позволяет писать меньше кода, меньше тестов и легче поддерживать разработанный код. Например в представлении доступны к использованию различные partial"ы - это шаблоны для повторения кода, которые просто вызываются в коде например для Форм. Это не только улучшает читаемость кода, но и добавляет гибкость к изменению или добавлению новой информации.

Пятый кит это CRUD

CRUD - create, read, update, delete - «создание, чтение, обновление, удаление») методология используемая для создания контроллеров. Использование стандарта, с помощью которого вы можете четко определить экшены контроллеру для полной манипуляции с любым объектом. Также вы можете без проблем дополнить своими экшенами.
Также в rails используются не только POST и GET запрос, а такие как PUT и DELETE. Давая вам больше возможности манипулирования данными

Шестой кит ORM

ORM (object-relational mapping) - технология программирования, которая помогает работать с базой данных на языке программирования, не используя различный sql языки для манипуляции с базой данных. Здесь использует объектно-ориентированное программирование на языке ruby.
Вся идея в том, что таблица является классом, ее строки это объекты, столбцы - свойства объектов.
Методы классов выполняют операции над таблицами.
Методы объектов выполняют операции над отдельными строками.

Седьмой кит haml sass/less
Идея использовать упрощенные и более функциональные языки такие как haml и sass/less. Которые увеличивают читаемость кода, делая разработку наиболее удобной и автоматически интерпретируются в своих родителей html и css.

А также существует еще множество плюсов, например установка различных дополнительных библиотек (gem"ов) в одну команду. Отличный бесплатный Heroku, дающий вам наблюдать за работоспособностью вашего локального приложения в продакшене на удаленном облаке. Различные готовые решения, из документации Ruby on Rails. И возможность генерации кода, для более быстрой развертывания веб-приложения.

Целью было представить основные возможности фреймворка Ruby on Rails. Надеюсь вас заинтересовало, и в веб мире скоро появиться еще один крутой рубист!

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

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

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

Допущения в этом руководстве

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

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

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

Что такое Rails?

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

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

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

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

Создание нового проекта Rails

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

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

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

3.1. Установка Rails

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

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

$ ruby -v ruby 2.5.0

Rails требует, чтобы был установлен Ruby версии 2.4.1 или новее. Если номер версии меньше этой, нужно будет установить новую копию Ruby.

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

Если работаете в Windows, необходимо установить Ruby Installer Development Kit .

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

Многие популярные UNIX-подобные ОС поставляются с приемлемой версией SQLite3. На Windows, если вы устанавливали Rails с помощью Rails Installer, у вас уже установлен SQLite. Прочие пользователи могут обратиться к инструкциям по установке на сайте SQLite3 . Проверьте, что он правильно установлен и содержится в вашем PATH:

$ sqlite3 --version

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

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

$ gem install rails

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

$ rails --version

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

3.2. Создание приложения Blog

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

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

$ rails new blog

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

При использовании Windows Subsystem for Linux, имеются некоторые ограничения на сообщения файловой системы, означающие, что следует отключить гемы spring и listen , что можно сделать, запустив rails new blog --skip-spring --skip-listen .

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

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

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

Файл/Папка	Назначение
app/	Содержит контроллеры, модели, вьюхи, хелперы, рассыльщики, каналы, задания и ассеты вашего приложения. Мы рассмотрим эту папку подробнее далее.
bin/	Содержит Rails скрипты которые стартуют ваше приложение, также директория может содержать другие скрипты которые вы используете для настройки, обновления, деплоя или запуска.
config/	Конфигурации маршрутов, базы данных вашего приложения, и т.д. Более подробно это раскрыто в Конфигурирование приложений на Rails
config.ru	Конфигурация Rack для серверов, основанных на Rack, используемых для запуска приложения. Подробнее о Rack смотрите на сайте Rack .
db/	Содержит текущую схему вашей базы данных, а также миграции базы данных.
Gemfile Gemfile.lock	Эти файлы позволяют указать, какие зависимости от гемов нужны для вашего приложения на Rails. Эти файлы используются гемом Bundler. Подробнее о Bundler смотрите на сайте Bundler .
lib/	Внешние модули для вашего приложения.
log/	Файлы логов приложения.
package.json	Этот файл позволяет указать, какие зависимости npm необходимы для приложения Rails. Этот файл используется Yarn. Подробнее о Yarn смотрите на сайте Yarn .
public/	Единственная папка, которая доступна извне как есть. Содержит статичные файлы и скомпилированные ассеты.
Rakefile	Этот файл находит и загружает задачи, которые могут быть запущены в командной строке. Определенная задача доступна во всех компонентах Rails. Вместо изменения Rakefile , можно добавить свои собственные задачи, добавив файлы в директорию lib/tasks приложения.
README.md	Это вводный мануал для вашего приложения. Его следует отредактировать, чтобы рассказать остальным, что ваше приложение делает, как его настроить, и т.п.
storage/	Файлы Active Storage для сервиса Disk. Это раскрывается в руководстве Обзор Active Storage .
test/	Юнит-тесты, фикстуры и прочий аппарат тестирования. Это раскрывается в руководстве Тестирование приложений на Rails
tmp/	Временные файлы (такие как файлы кэша и pid)
vendor/	Место для кода сторонних разработчиков. В типичном приложении на Rails включает внешние гемы.
.gitignore	Этот файл сообщает git, какие файлы (явно или по шаблону) ему следует игнорировать. Подробнее об игнорировании файлов смотрите GitHub - Ignoring files .
.ruby-version	Этот файл содержит дефолтную версию Ruby.

Hello, Rails!

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

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

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

$ bin/rails server

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

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

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

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

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

4.2. Скажите "привет", Рельсы

Чтобы Rails сказал "Привет", нужно создать, как минимум, контроллер и вьюху (представление).

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

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

Для создания нового контроллера, нужно запустить генератор "controller" и сказать ему, что вы хотите контроллер с именем "Welcome" с экшном по имени "index", вот так:

$ bin/rails generate controller Welcome index

Rails создаст несколько файлов и маршрут.

Create app/controllers/welcome_controller.rb route get "welcome/index" invoke erb create app/views/welcome create app/views/welcome/index.html.erb invoke test_unit create test/controllers/welcome_controller_test.rb invoke helper create app/helpers/welcome_helper.rb invoke test_unit invoke assets invoke coffee create app/assets/javascripts/welcome.coffee invoke scss create app/assets/stylesheets/welcome.scss

Наиболее важными из них являются, разумеется, контроллер, расположенный в app/controllers/welcome_controller.rb , и вьюха, расположенная в app/views/welcome/index.html.erb .

Откройте файл app/views/welcome/index.html.erb в текстовом редакторе. Удалите весь существующий в файле код и замените его на следующую строчку кода:

Если еще раз отправить форму, вы увидите что-то вроде следующего:

"First Article!", "text"=>"This is my first article."} permitted: false>

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

5.4. Создание модели Article

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

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

С помощью этой команды мы сообщаем Rails, что хотим модель Article с атрибутом title строкового типа и атрибутом text текстового типа. Эти атрибуты автоматически добавятся в таблицу articles и привяжутся к модели Article .

Rails в ответ создаст ряд файлов. Сейчас нам интересны только app/models/article.rb и db/migrate/20140120191729_create_articles.rb (у вас имя может немного отличаться). Последний ответственен за создание структуры базы данных, поэтому мы и рассмотрим его далее.

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

5.5. Запуск миграции

Как вы уже видели, bin/rails generate model создал файл миграции базы данных в директории db/migrate . Миграции - это класс Ruby, разработанный для того, чтобы было просто создавать и модифицировать таблицы базы данных. Rails использует команды rake для запуска миграций, и возможна отмена миграции после того, как она была применена к вашей базе данных. Имя файла миграции включает временную метку, чтобы быть уверенным, что они выполняются в той последовательности, в которой они создавались.

Если Вы заглянете в файл db/migrate/YYYYMMDDHHMMSS_create_articles.rb (помните, у вас файл имеет немного другое имя), вот что там обнаружите:

Class CreateArticles < ActiveRecord::Migration def change create_table:articles do |t| t.string:title t.text:text t.timestamps end end end

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

Сейчас нам нужно использовать команду bin/rails, чтобы запустить миграцию:

$ bin/rails db:migrate

Rails выполнит эту команду миграции и сообщит, что он создал таблицу Articles.

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

Так как вы работаете по умолчанию в среде development, эта команда будет применена к базе данных, определенной в разделе development вашего файла config/database.yml . Если хотите выполнить миграции в другой среде, например в production, следует явно передать ее при вызове команды: bin/rails db:migrate RAILS_ENV=production .

5.6. Сохранение данных в контроллере

Возвратимся к ArticlesController , нам нужно изменить экшн create , чтобы использовать новую модель Article для сохранения данных в базе данных. Откройте app/controllers/articles_controller.rb и измените экшн create следующим образом:

Def create @article = Article.new(params[:article]) @article.save redirect_to @article end

Вот что тут происходит: каждая модель Rails может быть инициализирована с помощью соответствующих атрибутов, которые будут автоматически привязаны к соответствующим столбцам базы данных. В первой строчке мы как раз это и делаем (помните, что params[:article] содержит интересующие нас атрибуты). Затем @article.save ответственен за сохранение модели в базу данных. Наконец, мы перенаправляем пользователя на экшн show , который мы определим позже.

Вы, возможно, задаетесь вопросом, почему A в Article.new заглавная, хотя все остальные ссылки на статьи в этом руководстве используют строчное написание. В этом контексте мы ссылаемся на класс по имени Article , который определен в app/models/article.rb . Имена классов в Ruby должны начинаться с заглавной буквы.

Теперь, когда есть валидации, при вызове @article.save на невалидной статье, будет возвращен false . Если снова открыть app/controllers/articles_controller.rb , вы увидите, что мы не проверяем результат вызова @article.save в экшне create . Если в этой ситуации @article.save не удастся, нам нужно снова показать форму пользователю. Для этого замените экшны new и create в app/controllers/articles_controller.rb на эти:

Def new @article = Article.new end def create @article = Article.new(article_params) if @article.save redirect_to @article else render "new" end end private def article_params params.require(:article).permit(:title, :text) end

Теперь экшн new создает новую переменную экземпляра по имени @article , и вы увидите, зачем это, через пару абзацев.

Отметьте, что в экшне create мы использовали render вместо redirect_to , когда save возвращает false . Метод render использован, чтобы объект @article был передан назад в шаблон new , когда он будет отрендерен. Этот рендеринг выполняется в рамках того же запроса, что и отправка формы, в то время как redirect_to сообщает браузеру выполнить другой запрос.

5.11. Обновление статей

Мы раскрыли часть "CR" от CRUD. Теперь сфокусируемся на части "U", обновлении (updating) статей.

Первым шагом следует добавить экшн edit в ArticlesController , как правило между экшнами new и create , как показано.

Def new @article = Article.new end def edit @article = Article.find(params[:id]) end def create @article = Article.new(article_params) if @article.save redirect_to @article else render "new" end end

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

Editing article

<%= form_with(model: @article, local: true) do |form| %> <% if @article.errors.any? %> <% end %>

<%= form.label:title %>
<%= form.text_field:title %>

<%= form.label:text %>
<%= form.text_area:text %>

<%= form.submit %>

<% end %> <%= link_to "Back", articles_path %>

Сейчас мы указываем форме на экшн update , который пока не определен, но скоро мы это сделаем.

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

Затем нужно создать экшн update в app/controllers/articles_controller.rb . Добавьте его между экшном create и методом private:

Def create @article = Article.new(article_params) if @article.save redirect_to @article else render "new" end end def update @article = Article.find(params[:id]) if @article.update(article_params) redirect_to @article else render "edit" end end private def article_params params.require(:article).permit(:title, :text) end

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

Мы заново использовали метод article_params , который определили ранее для экшна create.

Не обязательно передавать все атрибуты в update . К примеру, если был вызван @article.update(title: "A new title") , Rails обновит только атрибут title , оставив все другие атрибуты нетронутыми.

<% @articles.each do |article| %> <% end %>

Title	Text
<%= article.title %>	<%= article.text %>	<%= link_to "Show", article_path(article) %>	<%= link_to "Edit", edit_article_path(article) %>

И также добавим в шаблон app/views/articles/show.html.erb , чтобы ссылка "Edit" также была на странице статьи. Добавьте следующее в конце шаблона:

... <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

И вот как выглядит наше приложение сейчас:

5.12. Использование партиалов для очистки повторения во вьюхах

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

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

<%= form_with model: @article, local: true do |form| %> <% if @article.errors.any? %>

<% end %>

<%= form.label:title %>
<%= form.text_field:title %>

<%= form.label:text %>
<%= form.text_area:text %>

<%= form.submit %>

<% end %>

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

New article

<%= render "form" %> <%= link_to "Back", articles_path %>

И то же самое для вьюхи app/views/articles/edit.html.erb:

Edit article

<%= render "form" %> <%= link_to "Back", articles_path %>

5.13. Удаление статей

Теперь мы готовы раскрыть часть "D" от CRUD, удаление (deleting) из базы данных. Следуя соглашению REST, маршрут для удаления статей в результатах вывода bin/rails routes следующий:

DELETE /articles/:id(.:format) articles#destroy

Метод роутинга delete должен быть использован для маршрутов, уничтожающих ресурсы. Если бы его оставить обычным маршрутом get , станет возможным создавать следующие злонамеренные URL:

look at this cat!

Мы используем метод delete для уничтожения ресурсов, и этот маршрут связывается с экшном destroy в app/controllers/articles_controller.rb , который еще не существует. Метод destroy обычно последний экшн CRUD в контроллере, и подобно остальным публичным экшнам CRUD, он должен быть расположен перед любыми private или protected методами. Давайте его добавим:

Def destroy @article = Article.find(params[:id]) @article.destroy redirect_to articles_path end

Полностью ArticlesController в файле app/controllers/articles_controller.rb должен выглядеть теперь так:

Class ArticlesController < ApplicationController def index @articles = Article.all end def show @article = Article.find(params[:id]) end def new @article = Article.new end def edit @article = Article.find(params[:id]) end def create @article = Article.new(article_params) if @article.save redirect_to @article else render "new" end end def update @article = Article.find(params[:id]) if @article.update(article_params) redirect_to @article else render "edit" end end def destroy @article = Article.find(params[:id]) @article.destroy redirect_to articles_path end private def article_params params.require(:article).permit(:title, :text) end end

Можно вызывать destroy на объектах Active Record, когда вы хотите удалить их из базы данных. Отметьте, что нам не нужно добавлять вьюху для этого экшна, так как мы перенаправляем на экшн index .

Listing Articles

<%= link_to "New article", new_article_path %> <% @articles.each do |article| %> <% end %>

Title	Text
<%= article.title %>	<%= article.text %>	<%= link_to "Show", article_path(article) %>	<%= link_to "Edit", edit_article_path(article) %>	<%= link_to "Destroy", article_path(article), method: :delete, data: { confirm: "Are you sure?" } %>

Тут мы используем link_to другим образом. Мы передаем именованный маршрут как второй аргумент, и опции как иной аргумент. Опции method: :delete и data: { confirm: "Are you sure?" } используются как атрибуты html5, поэтому при нажатии ссылки, Rails сначала покажет пользователю диалог подтверждения, а затем отправит ссылку с помощью метода delete . Это выполняется с помощью файла JavaScript rails-ujs , который автоматически включается в макет приложения (app/views/layouts/application.html.erb) при генерации приложения. Без этого файла диалог подтверждения не будет показан.

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

Добавляем вторую модель

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

6.1. Генерируем модель

Мы намереваемся использовать тот же генератор, что мы использовали ранее при создании модели 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), использованное в команде bash, это специальный тип данных для моделей. Он создает новый столбец в вашей базе данных с именем представленной модели с добавленным _id , который может содержать числовые значения. Чтобы лучше понять, проанализируйте файл db/schema.rb после выполнения миграции.

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

Class CreateComments < ActiveRecord::Migration def change create_table:comments do |t| t.string:commenter t.text:body t.references:article, foreign_key: true t.timestamps end end end

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

$ bin/rails db:migrate

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

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

6.2. Связываем модели

Связи 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, length: { minimum: 5 } [...] end

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

6.3. Добавляем маршрут для комментариев

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

Resources:articles do resources:comments end

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

6.4. Генерируем контроллер

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

$ bin/rails generate controller Comments

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

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

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

Title: <%= @article.title %>

Text: <%= @article.text %>

Add a comment:

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Это добавит форму на страницу отображения статьи, создающую новый комментарий при вызове экшна 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 .

Title: <%= @article.title %>

Text: <%= @article.text %>

Comments

<% @article.comments.each do |comment| %>

Commenter: <%= comment.commenter %>

Comment: <%= comment.body %>

<% end %>

Add a comment:

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

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

Рефакторинг

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

7.1. Рендеринг коллекций партиалов

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

Commenter: <%= comment.commenter %>

Comment: <%= comment.body %>

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

Title: <%= @article.title %>

Text: <%= @article.text %>

Comments

<%= render @article.comments %>

Add a comment:

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

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

7.2. Рендеринг формы в партиале

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

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %>

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

Title: <%= @article.title %>

Text: <%= @article.text %>

Comments

<%= render @article.comments %>

Add a comment:

<%= render "comments/form" %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

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

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

Удаление комментариев

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

Commenter: <%= comment.commenter %>

Comment: <%= comment.body %>

<%= link_to "Destroy Comment", , method: :delete, data: { confirm: "Are you sure?" } %>

Нажатие этой новой ссылки "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) end private def comment_params params.require(:comment).permit(:commenter, :body) end end

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

8.1. Удаление связанных объектов

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

Class Article < ApplicationRecord has_many:comments, dependent: :destroy validates:title, presence: true, length: { minimum: 5 } [...] end

Безопасность

9.1. Базовая аутентификация

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

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 .

9.2. Прочие мысли о безопасности

Безопасность, особенно в веб-приложениях, это обширная и детализированная область. Безопасность вашего приложения Rails раскрывается более детально в руководстве Безопасность приложений на Rails Простейший способ работы с 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 как внутреннее хранилище в своей базе данных.

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

Итак, для работы нам необходима установленные рельсы и rubygems. С последними у меня вчера была проблема, поэтому пришлось удалить пакет rubygems1.8 не понятно как оказавшийся в системе и поставить rubygems1.9 Напомню, что разрабатываю я на Ubuntu, хотя для Windows команды консоли Rails думаю будут теми же. В качестве среды разработки использую NetBeans с плагином для Ruby on Rails. Про установку неплохо написано в моего коллеги.

Проверка ссылок

Необходимо убедиться, что каталог /usr/bin содержит символические ссылки rails, rake, ruby, bundler на файлы из каталога /usr/local/ruby/bin. Дл просмотра ссылок используйте команду:

в зависимости от того, что хотите отфильтровать.

Создаем приложение

Я создал специальный каталог для своих ruby-приложений.

mkdir /home/andrey/ruby
cd /home.andrey/ruby

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

app — это название нашего нового приложения. После выполнения команды мы увидим, как rails сделал нам каркас будущего приложения.

root@vaio:~/ruby# rails new app -d mysql
create
create README
create Rakefile
create config.ru
create .gitignore
create Gemfile
create app
create app/controllers/application_controller.rb
create app/helpers/application_helper.rb
create app/mailers
create app/models
create app/views/layouts/application.html.erb
create config
create config/routes.rb
create config/application.rb
create config/environment.rb
create config/environments
create config/environments/development.rb
create config/environments/production.rb
create config/environments/test.rb
create config/initializers
create config/initializers/backtrace_silencers.rb
create config/initializers/inflections.rb
create config/initializers/mime_types.rb
create config/initializers/secret_token.rb
create config/initializers/session_store.rb
create config/locales
create config/locales/en.yml
create config/boot.rb
create config/database.yml
create db
create db/seeds.rb
create doc
create doc/README_FOR_APP
create lib
create lib/tasks
create lib/tasks/.gitkeep
create log
create log/server.log
create log/production.log
create log/development.log
create log/test.log
create public
create public/404.html
create public/422.html
create public/500.html
create public/favicon.ico
create public/index.html
create public/robots.txt
create public/images
create public/images/rails.png
create public/stylesheets
create public/stylesheets/.gitkeep
create public/javascripts
create public/javascripts/application.js
create public/javascripts/controls.js
create public/javascripts/dragdrop.js
create public/javascripts/effects.js
create public/javascripts/prototype.js
create public/javascripts/rails.js
create script
create script/rails
create test
create test/fixtures
create test/functional
create test/integration
create test/performance/browsing_test.rb
create test/test_helper.rb
create test/unit
create tmp
create tmp/sessions
create tmp/sockets
create tmp/cache
create tmp/pids
create vendor/plugins
create vendor/plugins/.gitkeep

Заходим в папку с ним и устанавливаем необходимые гемы. Гемы — это подключаемые библиотеки, необходимые для проекта (аналог PHP’шных PECL и PEAR).

После этого, в консоли будет что-то вроде этого:

andrey@vaio:~/ruby/app> sudo bundle install
Using rake (0.8.7)
Using abstract (1.0.0)
Using activesupport (3.0.0)
Using builder (2.1.2)
Using i18n (0.4.2)
Using activemodel (3.0.0)
Using erubis (2.6.6)
Using rack (1.2.1)
Using rack-mount (0.6.13)
Using rack-test (0.5.6)
Using tzinfo (0.3.23)
Using actionpack (3.0.0)
Using mime-types (1.16)
Using polyglot (0.3.1)
Using treetop (1.4.8)
Using mail (2.2.9)
Using actionmailer (3.0.0)
Using arel (1.0.1)
Using activerecord (3.0.0)
Using activeresource (3.0.0)
Using bundler (1.0.3)
Using mysql2 (0.2.6)
Using thor (0.14.4)
Using railties (3.0.0)
Using rails (3.0.0)
Your bundle is complete! Use `bundle show ` to see where a bundled gem is installed.

Это значит, что все гемы установлены и подключены. Если чего-то не хватает, то bundle сам скачает их с rubygems и установит. Вот этого мне долгое время не хватало в php, по сути получается установщик проекта. Список зависимых гемов находится в файле Gemfile в корне проекта.

Конфигурирование

Теперь надо укаать реквизиты доступа к БД нашего проекта. Открываем проект в NetBeans: New Project -> Ruby -> Ruby on Rails application with existing source. Указываем путь, в моем случае это будет (/home/andrey/ruby/app) и название проекта(app). В качестве Ruby Platform выбираем установленную в системе, а не встроенную в NetBeans. Нажимаем Finish и проект создался. Открываем псевдо-папку Configuration и файл database.yml. Здесь надо указать логин и пароль для доступа к базе, желательно сразу для всех трех окружений (development, test, production). Окружение — это среда в которой будет запускаться наше приложение,

• development — компьютер разработчика,
• production — сервер промышленной эксплуатации,
• test — работа в режиме тестирования на сервере непрерывной интеграции или компьютере тестировщика.

rails generate model User name:string hashed_password:string salt:string

Сразу видно, чего нагенерил нам Rails:

invoke active_record
create db/migrate/20101107054200_create_users.rb
create app/models/user.rb
invoke test_unit
create test/unit/user_test.rb
create test/fixtures/users.yml

Отлично, теперь нам надо создать базу данных. Выполняем для этого:

andrey@vaio:~/ruby/app$ rake db:create
(in /home/andrey/ruby/app)
andrey@vaio:~/ruby/app$ rake db:migrate
(in /home/andrey/ruby/app)
== CreateUsers: migrating ====================================================
— create_table(:users)
-> 0.0061s
== CreateUsers: migrated (0.0063s) ===========================================

Консоль выводит добавленные данные. Смотрим в phpmyadmin и видим новые базы app_development и app_test, а также таблицы в них. Теперь настала очередь добавить реальные данные. Для этого запускаем консоль rails

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

andrey@vaio:~/ruby/app$ rails console
Loading development environment (Rails 3.0.0)
irb(main):001:0> user1 = User.new
=> #
irb(main):002:0> user1.name = «andrey»
=> «andrey»
irb(main):003:0> user1.save
=> true
irb(main):004:0> user2 = User.new
=> #
irb(main):005:0> user2.name = «vasiliy»
=> «vasiliy»
irb(main):006:0> user2.save
=> true

irb(main):007:0> exit
andrey@vaio:~/ruby/app$

Посмотрим в базу, и действительно у нас появились два пользователя. Хочется отметить, что Rails сам добавил столбцы первичного ключа и поля created_at (дата создания) и updated_at (дата изменения) модели.

Модель у нас есть, данные тоже. Пора запустить наше приложение.

andrey@vaio:~/ruby/app$ rails server
=> Booting WEBrick
=> Rails 3.0.0 application starting in development on http://0.0.0.0:3000
=> Call with -d to detach
=> Ctrl-C to shutdown server
INFO WEBrick 1.3.1
INFO ruby 1.9.2 (2010-08-18)
INFO WEBrick::HTTPServer#start: pid=4193 port=3000

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

Отлично, приложение работает. Но оно показывает обычную HTML-страничку из папки /public/index.html. А мы хотим динамическую. Открываем второе окно консоли (т.к. в первом у нас запущен вер-сервер руби — WebRick), заходим в папку с проектом и набираем там следующую команду:

andrey@vaio:~/ruby/app$ rails generate controller index index
create app/controllers/index_controller.rb
route get «index/index»
invoke erb
create app/views/index
create app/views/index/index.html.erb
invoke test_unit
create test/functional/index_controller_test.rb
invoke helper
create app/helpers/index_helper.rb
invoke test_unit
create test/unit/helpers/index_helper_test.rb
andrey@vaio:~/ruby/app$

Этим мы создали коонтроллер Index, в нём действие Index и вид этого действия index.html.erb Делаем Refresh(F5) в NetBeans и смотрим наши файлы. Замечательно. Теперь нам надо как-то перенаправить маршрут для главной страницы на созданное нам действие контроллера. Открываем файл маршрутов (Configuration/routes.rb) и раскомментируем там следующую строчку:

# You can have the root of your site routed with «root»
# just remember to delete public/index.html.
root:to => «welcome#index»

Только вместо welcome пишем тоже index. Ну привык я по Zend Framework’у, что контроллер и действие по-умолчанию называются index Не забыавем удалить (или переименовать) файл public/index.html).

root:to => «index#index»

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

Index#index

Отлично. Теперь можно кодить Заходим в наш вновь созданный контроллер (Controllers -> index_controller.rb) и пишем там такой текст действия:

class IndexController < ApplicationController
def index
@users = User.find(:all)
end
end

Тепеь открываем вид Views/index/index.html.erb и пишем там такой код:

Index#index

Find me in app/views/index/index.html.erb

<% for user in @users -%>
<%=user.name%>

<% end %>

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

Index#index

Find me in app/views/index/index.html.erb

andrey
vasiliy

Отлично! Приложение создано!

Спасибо!

Если вам помогла статья, или вы хотите поддержать мои исследования и блог - вот лучший способ сделать это:

Доброго времени суток!

Предисловие

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

Введение

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

Однако, изучение Ruby on Rails является достаточно простым занятием. Это невероятно мощный фреймворк, который имеет огромное сообщество, продвигающее его вперёд. Итак, у нас возникает вопрос: какой способ изучить Rails является лучшим? Вот он - план занятий.

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

Пункт 1: работа с упражнениями в «Try Ruby»

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

Наиболее рекомендуемым инструментом для погружения в синтаксис Ruby является сайт TryRuby . Он представляет собой интерактивную среду, которая позволяет попробовать синтаксис в действии. Если вы наберёте help , то будете приглашены ознакомиться с пятнадцатиминутным руководством, который обучит вас базису. Не стоит забывать, что у руководства две главы, с которой вы можете ознакомиться набрав help 2 .

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

Пункт 2: установка Ruby и Ruby on Rails

Если вы хотите изучить Rails, то вам без сомнений придётся установить его на ваш компьютер. Здесь представлено несколько решений, исходя из того, какая у вас ОС. Если у вас Mac или Linux-based компьютер, то я рекомендую вам использовать RVM. Это великолепный инструмент, предназначенный для установки Ruby. Собственно, вот инструкция по самой установке. Если же у вас Windows, то вам придётся воспользоваться RubyInstaller.

Следующим шагом является установка самого Rails. Для этого вам необходимо установить RubyGems. Если же вы используете RVM, то примите мои поздравления - у вас RubyGems уже установлен. Если же у вас Windows, то советую проследовать сюда. Чтобы установить Rails, вам необходимо воспользоваться командой gem install rails и, тада, всё сделано!

Пункт 3: ознакомление с введением в Rails от Jeffrey Way

В этом 40-минутном скринкасте Jeffrie Way расскажет вам о том, что необходимо знать для того, чтобы использовать Rails. В нём вы найдёте много полезной информации, включая такие темы, как:

• Models and generators
• Test-driven development (TDD)
• ActiveRecord
• RSpec and Capybara
• Partials

а также многое другое…

Пункт 4: изучите курс Rails For Zombies

Я всегда думал, что изучение по примерам является самым лучшим способом изучить язык или фреймворк. Бесплатный и невероятно мощный курс, с которым вы должны обязательно ознакомиться - Rails For Zombies, созданный ребятами из EnvyLabs. Данный курс является интерактивным, что означает, что после просмотра каждого видео вы будете работать над полезными и интересными упражнениями.

До этого времени я рассказывал вам об инструментах интерактивных и бесплатных. Время халявы прошло! Сейчас вам следует приобрести книгу под названием Agile Web Development with Rails . Она призвана научить вас использовать Rails путём строения веб сайта с нуля. Она проходит базовые основы, такие как контроллёры, модели, «scaffolding», функциональное тестирование, а также немного AJAX. Приобретите хотя бы последнее издание.

Пункт 6: постройте простой блог

Я знаю, что это звучит довольно скучно (покрайней мере для меня), но это великолепный пример, который используется везде по причине того, что он является довольно простым и быстрым для написания. Пойдя таким путём, вы будете способствовать закреплению ваших знаний и навыков. Но я предлагаю вам не заниматься копипастом (этим вы ничего не добъетесь, разве что 10 минут лишней траты электроэнергии), а попытаться написать его постепенно, по памяти, иногда лишь подглядывая в книгу затем, чтобы посмотреть как работает тот или иной метод.

Пункт 7: добавьте новые возможности в ваш блог

Великолепно! Вы всё-таки построили свой собственный блог. Но всё-таки в нём нет полновесного функционала, а лишь представлены базовые функции, присущие каждому блогу. Хорошо, давайте чуть-чуть поработаем и добавим систему аутентификации.

На самом деле я не хочу сейчас заставлять вас делать что-либо сложное, ведь вы уже порядочно потрудились. В качестве системы аутентификации вы можете использовать какой-нибудь готовый гем (Omniauth, например). Заодно и с имплементацией гемов в ваш проект разберётесь.

Также советую посмотреть этот скринкаст от Ryan Bates, в котором описывается создание простой системы аутентификации с нуля. После имплементации системы, следует добавить возможность удаления/редактирования постов, если вы ещё не сделали этого. Если же задание уже выполнено, то пора переходить к следующему пункту.

Пункт 8: создание чего-нибудь своего

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

К написанию данного текста автора подтолкнуло изучение ряда найденных в Глобальной Сети материалов, которые вполне можно было бы обозначить одной и той же рубрикой/тегом: Как я выучил Ruby (или Ruby on Rails, PHP, JS, C++, etc) за три дня .

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

Рабочий пример описанного в статье кода, в числе других Rails Examples - всегда возможно найти в тестовом блоге автора на herokuapp.com , welcome.

Методика проста, и автор совершенно не претендует здесь на лавры первооткрывателя: необходимо, чтобы было интересно, а результаты бы не заставили себя ждать. Не мешает таже попробовать поиграть на собственных слабостях, порой ведь и тщеславие способно быть на пользу делу; итоги разработки должны быть таковы, чтобы их можно было с гордостью предъявить читателям, друзьям и коллегам в Сети, задеплоив куда-нибудь на Heroku или Amazon , также - чтоб можно было вновь и вновь к ним возвращаться, перестраивая и усовершенствуя, форумы и StackOwerflow нам всем в помощь. Вот я и говорю, почему бы не написать, для начала, свой блог на Ruby on Rails ?

Оттолкнуться предлагаю от отличной доки Getting Started with Rails либо его русскоязычной адаптации Rails для начинающих , также Build a Blog with Ruby on Rails , также в помощь материалы этого блога, ссылки на которые легко находятся в левом сайдбаре. А дальше - все, дальше магия, на первых порах все расписано как по нотам, открываем консоль - и вперед... автор считает своим долгом сделать лишь несколько пояснений и технических рекомендаций, призванных облегчить адепту поиск и обретение Светлой Стороны Силы, и не более того. Это - только ваш бой, смелее вперед и возвращайтесь с победой.

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

Начнем с утверждения, что вот эти методы вполне способны (как вариант) выглядеть так, как показано далее, но никоим образом не так, как в оригинале:

app/controllers/posts_controller.rb

# Update action updates the post with the new information def update if @post.update_attributes(post_params) flash[:notice] = "Successfully updated post!" redirect_to posts_path else flash[:alert] = "Error updating post!" render:edit end end # The show action renders the individual post after retrieving the the id def show end # The destroy action removes the post permanently from the database def destroy @post = Post.find(params[:id]) if @post.destroy flash[:notice] = "Successfully deleted post!" redirect_to posts_path else flash[:alert] = "Error updating post!" end end

А впрочем, попробуйте и так и эдак, почему нет. Идем далее.

Второй блог, хотя и более сложный (добавлены редактор статей CKEditor и devise , гибкое средство для аутентификации в rails-приложениях), почему-то лишен в оригинале возможности оставлять комментарии. Вам придется собственноручно восполнить этот недостаток: действуйте по аналогии с описанием создания первого блога, потребуются лишь совсем незначительные изменения: попросту говоря, вместо article и articles первого блога будут у вас post и posts в блоге втором, вот и вся, по сути, разница. Будьте внимательны, и все получится.

Recaptcha к комментариям привязать придется также самостоятельно: да-да, это вам тут не Joomla, привыкайте. Впрочем, титанических усилий не потребуется, процесс подключения Recaptcha подробно описан в статье Подключаем Recaptcha в Rails application . Далее совсем нелишне отрегулировать devise таким образом, чтобы блог работал (хотя бы на первых порах!) в однопользовательском режиме, позволяя многочисленным своим читателя режим READ ONLY, иными словами - запретим для начала регистрацию новых пользователей. В Сети достаточно самых разных рецептов на предмет того, как это сделать, но, на мой взгляд, самый грамотный хак такого рода находится в Wiki devise, в материале под названием How To: Set up devise as a single user system . А именно: создаем новый контроллер:

app/controllers/registrations_controller.rb:

Class RegistrationsController < Devise::RegistrationsController before_action:one_admin_registered?, only: [:new, :create] protected def one_admin_registered? if ((Admin.count == 1) & (admin_signed_in?)) redirect_to root_path elsif Admin.count == 1 redirect_to new_admin_session_path end end end

затем переопределяем его в routes.rb, и это все:

#devise_for:admins devise_for:admins, controllers: { registrations: "registrations"}

CKEDITOR.editorConfig = function(config) { // config.enterMode = 2; //disabled

Completely config.enterMode = CKEDITOR.ENTER_BR // pressing the ENTER KEY input
config.shiftEnterMode = CKEDITOR.ENTER_P; //pressing the SHIFT + ENTER KEYS input

Config.autoParagraph = false; // stops automatic insertion of

On focus };

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

config/application.rb

Config.assets.precompile += Ckeditor.assets config.assets.precompile += %w(ckeditor/*) config.autoload_paths += %W(#{config.root}/app/models/ckeditor)

Иначе CKEditor откажется у вас работать на новом месте.