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

Изучение нового языка программирования может занять много времени и может быть крайне скучным. Разработчики.Net точно сейчас рассвирепеют и воскликнут: «Зачем мне вообще это учить, ведь я профессиональный разработчик.Net, и моё ежедневное расписание вряд ли сможет втиснуть в себя процесс изучения нового языка!» Но это будет крайне опрометчивым заявлением, так как при изучении новых языков программирования, вы изучаете много нового и полезного, особенно если этот язык представляет собой обновленную версию уже существовавшего ранее другого языка. Ruby как раз относится к такому типу языков. Я согласен с тем, что процесс перехода от разработчика-новичка до профессиональна в рамках того или иного языка программирования – это наисложнейший процесс, но опыт стоит того. Сейчас я могу лишь ввести вас в курс дела, и я уверен, что вы точно не захотите останавливаться. Отнеситесь к этому проще!

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

Что же такое Ruby?

Ruby, как уже было сказано, - это обновленная комбинация различных подходов в программировании. Ruby – это превосходная смесь простого в понимании подхода к рабочему процессу от Python, утонченность Smalltalk и облегченная стилизация, сопутствующая процессу разработки на Perl. Ruby – это высокий уровень объектно-ориентированного программирования (как и в случае с большинством других языков программирования в наше время), начало которому было положено еще в середине 90-х в Японии. Со временем Ruby распространился и на территорию США и Европы.

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

Основная цель при запуске Ruby заключалась в том, чтобы облегчить людям взаимодействие с машинами и процесс понимания кода. Основатель Ruby, Юкихиро Матсумото (Yukihiro Matsumoto), настаивает на идее о том, что Ruby был разработан для повышения продуктивности программистов, а не для оптимизации приложения со стороны машины.

«Часто люди, особенно компьютерные инженеры, концентрируют свое внимание на машинах. Они думают, что тем самым можно ускорить работу машины, можно повысить ее эффективность, что можно улучшить всё-всё-всё, что касается машины». Они зацикливаются на машинах. Но на самом деле нам нужно фокусировать свое внимание на людях, заботиться о них, облегчая процесс работы с приложениями, посредством машин. Мы настоящие и живые, а машины всего лишь подчиняются нам.

Что же такое Rails?

Rails представляет собой невероятно продуктивное приложение-платформу, написанную на Ruby Дэвидом Ханссоном (David Heinemeier Hansson). Предполагается, что разработка веб-приложения на Rails происходит в 10 раз быстрее, чем на платформе, основанной на Java. Rails представляет собой платформу, основанную на Ruby (конечно же!), и распространяемую с открытым исходным кодом, которую можно использовать для быстрой и легкой интеграции базы данных.

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

Обычная программа Ruby

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

Код:
personal = “I don’t love my girlfriend”
puts personal
На выходе:
I don’t love my girlfriend
Да-да! Никакой инициализации, никаких точек с запятыми и никаких методов.

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

PHP:
strrev(“string”);
Ruby:
“string”.reverse
Вуаля! Мы практически не тратим времени и полноценно переворачиваем последовательность записей. Нужно учитывать разницу в усилиях, проделанных в обоих языках. Язык программирования, основанный на Ruby значительно облегчает процесс написания программы. Это напоминает написание на английском языке, нежели на языке программирования. Это будущее для всех языков.

Преимущества использования Ruby (и Rails)

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

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

* Лаконичность и мощь . Пример, приведенный выше, демонстрирует нам то, каким лаконичным является код Ruby. Он настолько краток, насколько это вообще возможно. К тому же, Ruby представляет собой язык, настолько же мощный, насколько ими могут быть и другие языки, так как он представляет собой язык объектно-ориентированного программирования на высоком уровне.

* Нет нужны изобретать велосипед . Rails (основанный на Ruby) – это один интерфейс программирования, с которым вам больше не придется «изобретать велосипед». Он генерирует код, который может быть использован многократно в различных случаях.

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

* Среды Dev, Test и Prod . Rails позволяет начать ваш проект в трех различных средах, называемых Dev, Test и Prod. Все три среды ведут себя немного по-разному.

Подборка

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

Ruby - мощный и популярный язык программирования. Помимо своей популярности на нём основывается известный фреймворк , который позволяет создавать крутые и динамические веб сайты различной тематики. Если взглянуть на рейтинг TIOBE , то язык входит в двадцатку самых популярных языков мира.

Язык появился в 1995 году и считается молодым языком в сравнении с Си или же C++, которые появились в 1972 и 1983 году соответсвенно. Язык имеет ряд преимуществ и специфичных возможностей, которые реализованы исключительно в нем, если брать в сравнение другие популярные языки программирования.

План курса

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

За курс мы изучим как установить и работать с языком, изучим синтаксис Руби (переменные, циклы, условные операторы), а также более сложные вещи: ООП, работа с файлами, исключения, методы и затронем еще множество других тем.

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

Для установки Руби на Виндовс используйте RubyInstaller , который можно скачать на официальном сайте по этой ссылке . Скачивайте последнюю версию и устанавливайте её как обычную программу. После завершения установки перед вами будет похожее окно:

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

В открывшемся окне введите поочередно 1 и нажмите Enter , дождавшись конца установки нажмите 2 и Enter и в конце выполните третью команду нажав 3 и Enter .

Установка Руби на Мак

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

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

Curl -L https://get.rvm.io | bash -s stable

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

Rvm list known

После перезапуска вы можете установить ту версию, которую пожелаете. В нашем случае была установлена версия 2.4.2:

Rvm install ruby-2.4.2

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

Это руководство раскрывает установку и запуск 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.5.0 или новее. Если номер версии меньше этой, нужно будет установить новую копию 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 6.0.0", можно продолжать.

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 в новом приложении по умолчанию:

Hello, Rails!

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

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

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

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

Сжатие ассетов JavaScript требует среды выполнения JavaScript в вашей системе, и его отсутствие приведет к ошибке execjs во время сжатия ассетов. Обычно macOS и Windows поставляются с установленной средой выполнения JavaScript. 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", вот так:

$ 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 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 для создания новых моделей. Для создания новой модели, запустите эту команду в своем терминале:

$ 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. Запуск миграции

Как вы уже видели, 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 со строковым столбцом и текстовым столбцом. Она также создаст два поля временных меток для отслеживания времени создания и обновления статьи.

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

$ rails db:migrate

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

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

Так как вы работаете по умолчанию в среде development, эта команда будет применена к базе данных, определенной в разделе development вашего файла config/database.yml . Если хотите выполнить миграции в другой среде, например в production, следует явно передать ее при вызове команды: 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.label:title %>
<%= form.text_field:title %>

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

<%= form.submit %>

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

Передача объекта статьи в метод form_with автоматически установит 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 , оставив все другие атрибуты нетронутыми.

И также добавим в шаблон 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? %>

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

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

<%= form.submit %>

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

New article

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

Edit article

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

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

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

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

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

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

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

$ 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, null: false, foreign_key: true t.timestamps end end end

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

$ 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. Генерируем контроллер

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

$ rails generate controller Comments

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

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

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

Title: <%= @article.title %>

Text: <%= @article.text %>

Add a comment:

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

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

<%= form.submit %>

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

Commenter: <%= comment.commenter %>

Comment: <%= comment.body %>

Add a comment:

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

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

<%= form.submit %>

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

Рефакторинг

Теперь, когда у нас есть работающие статьи и комментарии, взглянем на шаблон 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

Add a comment:

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

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

<%= form.submit %>

Теперь это отрендерит партиал 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 %>

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

Title: <%= @article.title %>

Text: <%= @article.text %>

Comments

Add a comment:

Второй 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 как внутреннее хранилище в своей базе данных.

К написанию данного текста автора подтолкнуло изучение ряда найденных в Глобальной Сети материалов, которые вполне можно было бы обозначить одной и той же рубрикой/тегом: Как я выучил 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 откажется у вас работать на новом месте.

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

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

2. Railscasts

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

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

К сожалению, проект в 2013 году перестал обновляться.

3. Rails для Зомби

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

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

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

3. Udemy

Большая коллекция видео-курсов. Среди них множество по ruby и ruby on rails. Нет смысла приводить конкретные ссылки - выбирайте на свой вкус по цене или по популярности.

Формат Udemy предполагает достаточно короткие курсы с акцентом на видео уроки. Не ждите серьезных домашних заданий или оперативной поддержки преподавателей.

4. Ruby Бурса

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

На курсе желательно личное присутствие студента и проходит он только в крупных украинских городах.

5. Разработка на Ruby on Rails от Злых Марсиан

Трехдневный интенсив от одной из самых опытных в России Ruby on Rails команд.

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

6. Онлайн-интенсив Ruby on Rails от «Хорошего программиста»

Свежий проект от команды, известной в Youtube своими курсами по Ruby для новичков.

3-месячная интенсиваная программа рассчитана на полных новичков и обещает сделать из вас junior программиста с портфолио, ни много ни мало, из 12 толковых приложений.

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

Судя по youtube каналу и комментариям пользователей - эти ребята знают что делают и скучать с ними не придется.