Ruby начал разрабатываться 23 февраля 1993 года и вышел в свет в 1995 году. Название навеяно языком Perl, многие особенности синтаксиса и семантики из которого заимствованы в Ruby (pearl - «жемчужина», ruby - «рубин»). Целью разработки было создание «настоящего объектно-ориентированного», лёгкого в разработке, интерпретируемого языка программирования.
Язык обладает независимой от операционной системы реализацией многопоточности, строгой динамической типизацией, сборщиком мусора и многими другими возможностями. Кроссплатформенная реализация интерпретатора языка является полностью свободной.
Ruby on Rails (RoR) - фреймворк, написанный на языке программирования Ruby. Он реализует архитектурный шаблон Model-View-Controller для веб-приложений, а также обеспечивает их интеграцию с веб-сервером и сервером баз данных. Является открытым программным обеспечением и распространяется под лицензией MIT.
Чтобы помочь вам в изучении этих технологий, мы собрали подборку книг. Как всегда, если вы знаете книгу, которая не попала в этот материал, делитесь ей в комментариях.
Эта книга предназначена для тех, кто хочет писать на Ruby как профи. В ней рассказывается, как проектировать красивые API и работать с приёмами функционального программирования. Новичкам книга не подойдёт, а вот тем, кто уже разбирается в Ruby, она точно пригодится.
Цель данной книги - научить читателей эффективно использовать язык Ruby. В книге рассматривается версия Ruby 2.1. Издание содержит около 400 различных примеров, сопровождающихся четкой постановкой задачи и ее решением с подробными комментариями.
Книга отличается достаточно низким входным порогом. Для ее изучения необязательно знать основы веб-разработки. В книге материал о Ruby on Rails, популярного фреймворка для разработки веб-приложений, дается с нуля. Автор Майкл Хартл, помимо Ruby on Rails, знакомит читателя с основами самого языка Ruby, языка запросов SQL, CSS, HTML. В книге много внимания уделено практическому использованию возможностей фреймворка. Также можно ознакомиться с фрагментом книги.
А эта книга пригодится именно начинающим. Её сложность увеличивается по нарастающей, и в каждом следующем разделе используются навыки, полученные в предыдущих.
С «Изучаем Ruby» вы в легкой и увлекательной форме на практике освоите все возможности этого языка, который сначала стремительно захватил сердца программистов Калифорнии, а затем и России.
Прочитав эту книгу, вы научитесь писать элегантный код с применением всех его уникальных особенностей.
В этой книге подробное разбирается внутреннее устройство языка Ruby. Знать сам Ruby читателю не обязательно, но вот знание C и, в особенности, принципов ООП будет огромным плюсом.
Эта книга отлично подойдёт для знакомства с Ruby. В ней разбираются все необходимые основы: от установки языка до обработки файлов и ООП. Каждая тема снабжена понятными примерами.
В этой книге рассказывается об одной из самых интересных фич Ruby - блоках. Они похожи на замыкания и лямбды и используются как в простых структурах языка вроде блоков, так и в сложных приёмах.
Эта книга разбита на несколько секций, различающихся по сложности. Сперва рассказывается о настройке и основных возможностях Ruby, а затем речь идёт о стандартной библиотеке и темах для продвинутых.
К написанию данного текста автора подтолкнуло изучение ряда найденных в Глобальной Сети материалов, которые вполне можно было бы обозначить одной и той же рубрикой/тегом: Как я выучил 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 откажется у вас работать на новом месте.
Это руководство раскрывает установку и запуск 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 в новом приложении по умолчанию:
| Файл/Папка | Назначение |
|---|---|
| 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:
Если вы используете 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 в текстовом редакторе. Удалите весь существующий в файле код и замените его на следующую строчку кода:
Если еще раз отправить форму, вы увидите что-то вроде следующего:
Теперь этот экшн отображает параметры для статьи, пришедшие из формы. Однако, это все еще бесполезно. Да, вы видите параметры, но по сути ничего не делаете с ними.
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_with(model: @article, local: true) do |form| %> <% if @article.errors.any? %><%= pluralize(@article.errors.count, "error") %>
-
<% @article.errors.full_messages.each do |msg| %>
- <%= msg %> <% end %>
<%= form.label:title %>
<%= form.text_field:title %>
<%= form.label:text %>
<%= form.text_area:text %>
<%= form.submit %>
<% end %> <%= link_to "Back", articles_path %>Сейчас мы указываем форме на экшн 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 , оставив все другие атрибуты нетронутыми.
| 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? %>
<%= pluralize(@article.errors.count, "error") %> prohibited this article from being saved:
-
<% @article.errors.full_messages.each do |msg| %>
- <%= msg %> <% 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, маршрут для удаления статей в результатах вывода 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 %>| 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 , содержащую ссылку на статью. Запустите следующую команду в терминале:
$ 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_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 как внутреннее хранилище в своей базе данных.
Ночь первая
Начинать учить Ruby on Rails без хотя бы минимального знания непосредственно Ruby было бы странным. Я уже когда-то брался за интерактивный гид ruby-lang.org . Но как прошел его, так и сразу все забыл. Его создатели обещают, что на прохождение и усвоение синтаксиса Ruby уйдет пятнадцать минут. У меня ушло тридцать. Правда, с постоянным отвлечением на Twitter. Процесс выглядит примерно так. Тебе говорят: «Массивы в Ruby объявляются так, а данные из массивов извлекают вот так. Теперь давай попробуй сделать массив и извлечь из него N элементов. А мы проверим». Читаешь, как все устроено, и сразу пробуешь. Ruby ты так, конечно, не выучишь. Лучше это воспринимать как супер-экспресс-курс, который работает. И все-таки сам Ruby - это очень далеко от фреймворка Ruby on Rails. Хотелось освоить именно рельсы. Из нашей статьи про образование онлайн я точно помнил о нашумевшем курсе Zombie for Rails railsforzombies.org . Это так же, как и Try Ruby, интерактивный учебник, который прямо с места в карьер начинает тебя учить готовить рельсовые приложения. Сначала тебе читают мини-лекцию (на английском, но все предельно понятно - включи субтитры) о структуре файлов рельсового приложения, CRUD-подходе для работы с данными, объясняют, как реализована модель MVC в рельсах, и так далее. После каждого видео тебе предлагают выполнить задания на закрепление материала. Все кажется простым и понятным, курс пролетает незаметно за час-другой (он небольшой). Но! Почувствовал ли я после курса, что смогу написать рельсовое приложение? Увы, нет!Ночь вторая
Одна из причин, почему после Rails for Zombies появляются некоторые базовые знания, но не появляется уверенности, - это виртуальная среда, в которой проходит обучение. С одной стороны, она до предела уменьшает порог входа: можно не заботиться об окружении. С другой стороны, ничего реального по ходу дела ты не создаешь - никакого тебе «Hello World» на выходе. И главное, с какой стороны подступаться к его созданию, непонятно. С этого момента я хотел попробовать Ruby on Rails в деле, реально установив его в системе (до этого можно было даже не стараться), и с нуля создать простое приложение. Уже не помню как, но совершенно случайно я наткнулся на очень удачный курс скринкастов на русском языке rails.hasbrains.org . Спасибо автору за грамотное изложение: он методично объясняет принципы работы рельсового приложения в деталях, по ходу погружая тебя во все необходимые тонкости. Короче говоря, всю вторую ночь эксперимента я смотрел первую половину из более чем тридцати эпизодов этих скринкастов. В голове окончательно закрепилась картинка, как генерируется приложение, как работать с рельсовой консолью, как создать модели и миграции, как обновлять модели и как валидировать в них данные, RESTful- контроллеры и так далее. Смотря каждый из эпизодов, я сразу пробовал все в действии, выстраивая полностью рабочее рельсовое приложение. Стало понятно, как в принципе устроены рельсы.Ночь третья
На третью ночь остались последние эпизоды скринкастов, которые удалось посмотреть в один присест: работа с рельсами уже не казалось такой дикой. В этот момент мне кто-то рассказал о том, что у курса Rails for Zombies есть толковое и гораздо более глубокое продолжение. Правда, курс уже платный и хостится в рамках школы программирования Code School www.codeschool.com . Отдать 25 баксов, чтобы получить доступ ко всем курсам школы, было не жалко. Это стоимость на месяц, поэтому, если не понравится, не забудь отменить подписку. Курс Rails for Zombies 2 действительно оказался очень удачным. Правда, многое стало повторением того, что я увидел в скринкастах, - но это было даже отчасти приятно. Пять уровней и пять блоков упражнений, которые делаешь прямо в интерактивной консоли. К этому моменту рельсы уже казались логичными, понятными и пригодными к использованию. В Code School можно программировать прямо в браузере, выполняя задания курсаЧто дальше?
Научился ли я делать сложные проекты? Нет. Но точно осознал подходы, используемые в рельсах, и понял их удобство. Научился быстро создавать простые приложения и в суперкороткий срок наращивать его функционал с помощью гемов, написанных сообществом. Я поймал кураж и дальше с удовольствием учусь лучшим практикам по программам Code School (сейчас смотрю курс по юнит-тестам). И меня чертовски радует то, что изучать технологии стало так просто.Сегодня в интернетах я нашел историю о том, как некто Джеймс Фенд учился Ruby on Rails в течение 12 недель. Ниже вы можете прочитать относительно точный перевод этой истории, и, надеюсь, вдохновиться на изучение этого прекрасного фреймворка (и прекрасного языка).
Прежде чем начать, я хотел бы представить Джоша Криуса (http://joshcrews.com) и поблагодарить его за то, что убедил меня начать изучать Ruby on Rails; без него, его помощи и без часов, которые он потратил на то, чтобы быть моим наставником, я не писал бы это сегодня. Спасибо.
23 января я запустил идею своей мечты, Freelancify.com . Ровно 12 недель назад я был техническим предпринимателем (tech entrepreneur), который тратил тысячи долларов, чтобы создать приличный MVP (минимально жизнеспособный продукт), потому что мне недоставало знаний. Одной из причин (как я тогда думал) было то, что обучение было для меня слишком сложным или заняло бы чрезмерно много времени. Я думал (как и многие другие), что программисты (и некоторые действительно) рождаются с набором волшебных навыков в решении проблем и математике, которые делают их гениями программирования. И именно 12 недель назад я принял лучшее решение за долгое, по-настоящему долгое время . Больше ни одна из моих идей не останется не более чем идеей. Теперь у меня есть возможность запускать рабочие версии, тратя деньги лишь на хостинг и прилагая некоторые усилия. На сегодняшний день этот набор навыков - это примерно как пригнать кучу тракторов во времена калифорнийской золотой лихорадки, пока все остальные используют простые лопаты. Я предлагаю каждому научиться писать код . Здесь я хотел бы добавить уточнение: ранее, назвал пост “Как я изучил Rails за 8 недель”, однако, если быть точным, то учитывая дату запуска, получается 12 недель. Однако за 8 недель я почувствовал, что знаю достаточно, а следующие четыре недели были потрачены в большей степени на то, чтобы заставить полученные знания работать, а не на обучение.
Какие навыки я имел прежде, чем начал изучать Rails?
Я был веб-дизайнером, обладающим познаниями в HTML и CSS, и, в основном, фокусировался на дизайне UI и UX. Самое сложное, что я делал с реальным кодом (не считая HTML) - это возможность настраивать Wordpress. Одним словом, я абсолютно не имел представления ни о том, что такое MVC-фреймворк, ни о том, как в целом работают базы данных. Дизайн, макет и HTML для Freelancify были созданы мной за две недели в июне 2011-го.
Почему я принял решение учиться?
Возвращаясь в июнь 2011-го, когда макет был готов, я начал поиски кодера, который сделал бы макет функционирующим. Макет был практически готов: у меня были текстовые поля, выпадающие меню, формы, кнопки, ссылки, ведущие куда необходимо, и так далее. Нашел разработчика, и, если в двух словах, то парень мне не подошел. Я остался с кучей долгов и даже не близким к завершению продуктом. Тогда я связался с Джошем Криусом (с ним я познакомился на встрече, посвященной Ruby on Rails, которую он организовал в Нэшвилле), и встретился с ним, чтобы понять, можно ли сделать хоть что-то из того, что у меня осталось от разработчика. К сожалению, починка и доработка кода заняла бы не меньше времени, чем разработка с нуля грамотным программистом. Я упал духом, понимая, что не смогу позволить себе снова тратить тысячи долларов на разработку с нуля. И тогда Джош сказал… “Почему бы тебе просто не научиться обращаться с Ruby on Rails, этот проект был бы прекрасным способом ” и затем “Я могу даже встречаться с тобой дважды в неделю и помогать тебе в обучении ”. Я потратил целую ночь на раздумья. Моими вариантами было: найти комфортную работу и оплатить счета ИЛИ рискнуть всем, чтобы научиться Rails и, в конце концов, лакомиться лучшим раменом, который только готовят в Италии. Я решил. Позвонил Джошу на следующее утро. Я поставил все. Я выделил деньги из оставшихся сбережений и разделил их на три месяца (для неженатого парня, живущего в одиночестве и без детей одной тысячи долларов на месяц вполне достаточно). Время приниматься за работу, теперь я ученик на полном рабочем дне. Держу в уме: поиск в Google, Stackoverflow, IRC #RubyOnRails и сообщество Rails будут прикрывать меня, когда я застряну, уверен, что их будет достаточно.
Мои следующие три месяца - Миссия : получить MVP, получить достаточно, чтобы работать, но не “отстойно-достаточно”, чтобы оставить ужасное первое впечатление.
Недели 1 - 3
Это была, пожалуй, сложнейшая кривая обучения, но я НЕ сдавался.
Стены созданы для людей, которые, на самом деле, не хотят их покидать.
Установка рабочего окружения Rails для полного новичка может оказаться невероятно раздражающей. Подсказка #1: заимейте Mac. Подсказка #2: используйте Homebrew, RVM, Git и Heroku (на самом деле это все, что вам нужно, чтобы начать). Я потратил пару дней на установку, затем все удалил и снова установил. Достаточно повторить несколько раз, и вы привыкните к использованию командной строки терминала (консоли) и поймете, почему вещи работают так, как они работают. Затем, первая вещь, которой я занялся, были уроки TryRuby , Rails for Zombies и Rails Tutorial Майкла Хартла. Не беспокойтесь о том, чтобы на 120% понять материал, этого не случится, пока вы не начнете по-настоящему учиться. Я закончил Rails Tutorial и создал это похожее на Twitter приложение примерно за неделю, не совсем понимая, что я сделал. Позднее, по мере продвижения, я стал понимать, что все начинает обретать смысл.
Недели 3 - 6
С Twitter-приложением, созданным при помощи Rails Tutorial, я обрел некоторую уверенность. Руководство не сделало меня разработчиком, но теперь я знаю общие шаги в создании приложений, с создания самого приложения, и до установки его на Heroku. Все, что было между тем временем оставалось размытым. Как мне теперь ПО-НАСТОЯЩЕМУ начать учиться? Работая над реальным проектом, который что-то для меня значит . Джош и я решили, что мне стоит свободно поработать над Freelancify и посмотреть, что я смогу сделать. Первым, что я сделал, был перенос всего HTML с каркаса и организация его в файлы видов(views) и парциалов(partials). Я создал(scaffolded) шаблонные платформы для Пользователей(Users) и Проектов(Projects). Затем я начал изучать мой первый реальный гем Devise. Затем, возможность иметь отношения, например каждый Пользователь будет иметь портфолио. Но пользователи могут иметь множество портфолио, в то время как каждое портфолио может принадлежать лишь одному Пользователю. Когда вы поймете, как работают отношения между моделями и как вызывать/отображать вещи, которые принадлежат чему-то еще, жизнь станет намного проще. Если в какой-то части вы застряли и не можете сдвинуться с места, пропустите её, велика вероятность того, что пока вы разрабатываете другую возможность, вы так же поймете, как реализовать и то, что вы пропустили.
Недели 6 - 9
Шажок за шажком, я продолжал учиться, копируя и повторяя. Я мог заставлять какие-то вещи работать, а затем - бац - и я втыкался в стену и абсолютно не представлял, что же делать дальше. Заходя на Stackoverflow , IRC-чат #RubyOnRails, RailsCasts или дергая Джоша , в конце концов, я понимал, как действовать. Делайте то же самое снова и снова, и вы научитесь всему довольно быстро. Тратить раздражающие часы, тестируя чей-то ответ со Stackoverflow, чтобы понять, что он не работает - это, на самом деле, полезно. Вы понимаете, чего не следует делать. И когда вы найдете ответ, вы начнете понимать, ПОЧЕМУ последнее не работало. Примерно в это время я начал осознавать, насколько велика картина вещей, и по-настоящему понимать, ПОЧЕМУ все работает именно так, как работает. Я чувствовал себя идиотом, возвращался назад и рефакторил код, который написал ранее, делая его более эффективным. И в какой-то момент я достиг стадии, когда все начало становиться на свои места.
Недели 9 - 12
Я был в режиме невероятной энергичности, дорабатывая Freelancify до стадии запуска. На этой стадии я чувствовал себя так, словно лечу, претворяя функции в жизнь. Последняя неделя была потрачена на отладку различных багов и ляпов. В этот понедельник я запустил сайт. Но я по-прежнему далек от завершения обучения… Вот так. Я опустил (во имя краткости поста) мелкие детали и технические моменты. Тем не менее, не стесняйтесь задавать вопросы в комментариях, я определенно постараюсь ответить. Джеймс Фенд.
P.S. - Несмотря на то, что мне сильно помогла помощь наставника, с которым я мог встречаться, вы определенно можете изучить Rails и без него. Или же попробуйте найти себе такого человека, многие Rails-разработчики любят вносить свой вклад в сообщество. Поищите локальные конференции и встречи.
Этой записи уже более двух лет (опубликована 27 января 2012-го года), но она, тем не менее, не утратила своей актуальности. Джеймс Фенд за это время успел продать Freelancify и вложиться в новый стартап, запись об этом он оставил 27 февраля 2013. Я считаю, что эта статья - прекрасный пример того, как человек может идти к поставленной цели. Достаточно лишь начать. :)
Обзор Samsung Galaxy A7 (2017): не боится воды и экономии Стоит ли покупать samsung a7
Делаем бэкап прошивки на андроиде
Как настроить файл подкачки?
Установка режима совместимости в Windows
Резервное копирование и восстановление драйверов Windows