Я уже давно хотел изучить Ruby on Rails на каком-то базовом уровне. Без конкретной цели. Скорее просто для себя, чтобы лучше понять, что же в нем такого особенного (в отличие от 100500 других технологий и фреймворков), что позволяет быстро создавать и масштабировать довольно нагруженные интернет-проекты. Вторичной причиной стало желание попробовать новые подходы к обучению. Когда я учился на программиста, у нас были только книги и форумы, где можно спросить совета. Сейчас есть интерактивные учебники и онлайн-школы программистов, огромное количество скринкастов (почти мечта: смотреть, как программируют гуру), базы знаний вроде stackoverflow.com и тонны исходных кодов на GitHub, где можно часами изучать исходники настоящих профи. Следующие несколько ночей (а днем банально некогда) я решил выделить на то, чтобы попробовать новые способы обучения в действии.

Ночь первая

Начинать учить 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 (сейчас смотрю курс по юнит-тестам). И меня чертовски радует то, что изучать технологии стало так просто.

Вы знали, что 40% пользователей покидают сайты с плохим дизайном? Зачем терять прибыль? Выберите и установите прямо сейчас один из 44 тысяч премиум шаблонов для сайтов. Идеальный выбор для вашего бизнеса!

Многие мои друзья-разработчики лестно отзываются о Rails, но я не мог понять почему. Что такое Rails, и чем он отличается, собственно, от Ruby on Rails? Насколько он сложный в изучении? Это вообще язык программирования? Что мне нужно знать, перед тем как учить Ruby on Rails?

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

Вы готовы? Поехали!

13 фактов о Ruby on Rails – Что вам нужно знать?

1. Что такое Rails?

Rails это фреймворк (каркас) веб-приложений, который создан для написания кода на языке Ruby. Звучит запутанно, правда?

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

Позвольте привести пример.

Если я захочу вывести текст на экран на PHP, мне нужно написать

echo “Привет Мир”;

Видите точку с запятой? А этот «echo» – что он вообще значит?

С другой стороны, если мне нужно проделать то же самое на Ruby, мне нужно будет написать следующее:

puts “Hello World”

Никакой точки с запятой, и хотя «puts» может выглядеть немного «по-подростковому», мне эта команда кажется более логичной, чем «echo». Когда вы часами пишете код, такие мелкие детали играют БОЛЬШУЮ роль.

Единственной проблемой Ruby было то, что он не предназначен для создания веб-приложений. То есть, на нем у вас не получится, к примеру, создать сайт. Так было до появления Rails. Я не уверен, был ли Rails первым веб-фреймворком для Ruby, но он ОПРЕДЕЛЕННО стал самым популярным.

Задача Rails заключается в предоставлении платформы и возможностей, которые бы позволили создавать на Ruby приложения, в частности сайт. Пока что это звучит довольно размыто, поэтому попробую объяснить вот так. Если бы я написал

puts “Hello World”

то в HTML-документе, вы бы увидели весь текст целиком. Но я же хочу, чтобы вы видели ТОЛЬКО вот это:

Hello World

Проще говоря, Rails позволяет это сделать. Но это далеко не все.

2. Что такое Ruby on Rails?

Ruby on Rails – это ПОЛНОЕ официальное название фреймворка Rails. Но в разговоре разработчики обычно не говорят первую часть, и просто называют его Rails. Поэтому, если вы хотите быть «в теме» и казаться технически подкованным, вы определенно должны называть его Rails, но при этом ПОМНИТЬ о том, что означает эта первая часть – «Ruby on».

3. Я слышал, что Rails отлично подходит новичкам. Почему?

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

Почему Rails настолько приятен в работе для новичков? Просто он очень стабильный и делает за вас ОГРОМНЫЙ пласт работы.

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

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

По этой причине очень важно изучать Ruby on Rails с нуля. И самое главное – вы должны убедиться в том, что вам действительно удобно работать с Ruby. Иначе вы просто на полпути выйдете из этой фуры и скажете себе: «Погодите, неужели я ехал на этой штуковине?».

4. Чем отличается Rails- от Ruby-разработчика?

Формально отличие заключается в том, что чисто «Ruby-разработчик» будет создавать приложения на Ruby, но не на Rails. Хотя такого, как правило, не бывает. Создавать веб-приложения на Ruby, используя другие фреймворки типа Sinatra, конечно, возможно, но я готов поспорить, что в 99% случаев вас вряд ли будут нанимать как программиста, знающего только Ruby. Поэтому нужно в любом случае изучать и Rails.

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

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

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

6. Зачем мне изучать Rails? Что делает его особенным?

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

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

7. Что можно создавать с помощью Rails?

А что вы хотите создать? Rails подходит для любых веб-приложений. Для наглядности ознакомьтесь с вот этими отличными примерами сайтов, созданных на Rails: Hulu , Airbnb и Basecamp .

8. Могу ли я создавать мобильные приложения на Rails?

И да, и нет. На Rails не получится создавать мобильные приложения, но на Rails вы определенно сможете создать веб-приложение и использовать его в качестве back-end для мобильного приложения.

Также есть инструмент RubyMotion, который позволяет очень просто создавать нативные приложения для iOS и Android на Ruby (но не Rails). То есть, вы не будете КОНКРЕТНО использовать Rails для создания мобильного приложения для App Store, но Rails определенно может стать важной составляющей вашего мобильного проекта. Надеюсь, теперь картина стала более понятной.

9. Ruby on Rails – Какого рода работу я могу получить?

Rails – это один из самых востребованных навыков в настоящее время, поэтому выбор компаний, с которыми можно работать, довольно большой. Особенно Rails любят стартапы, например, такие как Zearn . Это начинающая неприбыльная образовательная ИТ-компания. Также можно выбрать более крупную компанию вроде Bloomberg и принимать участие в разработке сайтов и приложений, которыми пользуются миллионы пользователей. Фриланс тоже неплохой вариант для Rails-разработчиков. Будучи независимым, вы сможете сами выбирать, в каких проектах вы хотите поучаствовать: в небольших и короткосрочных или серьезных и долгосрочных.

10. Я попробовал другой язык программирования, но мне он не понравился. Стоит ли мне пробовать Rails?

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

11. Может мне вместе Rails выучить JavaScript?

Вместо – нет. Дополнительно – НЕСОМНЕННО.

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

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

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

12. Сколько времени займет обучение?

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

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

13. Ruby on Rails – С чего начать?

Рекомендую начать с самого лучшего курса по Ruby on Rails на сeгодняший день. Если вы не писали ни строчки кода в своей жизни, первым делом вам стоит пройти курс «HTML и CSS» . К счастью, найти курсы по HTML и CSS довольно просто. После этого вам нужно будет изучить Ruby, Git и командную строку.

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

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

Александр - основатель проекта сайт «Веб-лаборатория успеха», созданного в поддержку начинающим и продолжающим интернет-предпринимателям.Убежденный трудоголик, за плечами которого профессиональный опыт руководства редакцией интернет-журнала, создания и управления собственным интернет-магазином. Основной род занятий: продвижение бизнесов (в т.ч. интернет-магазинов) через Facebook и Google Adwords. Основное увлечение: монетизация сайтов через инструменты партнерского маркетинга и Google Adsense. Личные подтвержденные рекорды: 3 миллиона посетителей блога в месяц.

13 февраля 2012 в 16:06

Лучший способ изучить Rails

• Ruby on Rails

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

Предисловие

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

Введение

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Что такое Rails?

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

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

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

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

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

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

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

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

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

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

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

$ ruby -v ruby 2.5.0

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

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

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

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

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

$ sqlite3 --version

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

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

$ gem install rails

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

$ rails --version

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

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

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

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

$ rails new blog

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

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

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

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

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

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

Hello, Rails!

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

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

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

$ bin/rails server

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

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

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

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

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

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

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

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

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

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

$ bin/rails generate controller Welcome index

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

$ bin/rails db:migrate

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Editing article

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

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

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

<%= form.submit %>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<% end %>

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

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

<%= form.submit %>

<% end %>

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

New article

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

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

Edit article

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

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

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

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

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

look at this cat!

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

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

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

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

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

Listing Articles

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

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

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

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

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

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

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

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

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

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

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

Class Comment < ApplicationRecord belongs_to:article end

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

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

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

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

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

$ bin/rails db:migrate

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

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

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

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

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

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

Class Comment < ApplicationRecord belongs_to:article end

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

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

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

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

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

Resources:articles do resources:comments end

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

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

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

$ bin/rails generate controller Comments

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

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

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

Title: <%= @article.title %>

Text: <%= @article.text %>

Add a comment:

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

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

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

<%= form.submit %>

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

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

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

Class CommentsController < ApplicationController def create @article = Article.find(params[:article_id]) @comment = @article.comments.create(comment_params) redirect_to article_path(@article) end private def comment_params params.require(:comment).permit(:commenter, :body) end end

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

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

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

Title: <%= @article.title %>

Text: <%= @article.text %>

Comments

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

Commenter: <%= comment.commenter %>

Comment: <%= comment.body %>

<% end %>

Add a comment:

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

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

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

<%= form.submit %>

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

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

Рефакторинг

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

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

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

Commenter: <%= comment.commenter %>

Comment: <%= comment.body %>

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

Title: <%= @article.title %>

Text: <%= @article.text %>

Comments

<%= render @article.comments %>

Add a comment:

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

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

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

<%= form.submit %>

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

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

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

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

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

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

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

<%= form.submit %>

<% end %>

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

Title: <%= @article.title %>

Text: <%= @article.text %>

Comments

<%= render @article.comments %>

Add a comment:

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

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

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

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

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

Commenter: <%= comment.commenter %>

Comment: <%= comment.body %>

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

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

Class CommentsController < ApplicationController def create @article = Article.find(params[:article_id]) @comment = @article.comments.create(comment_params) redirect_to article_path(@article) end def destroy @article = Article.find(params[:article_id]) @comment = @article.comments.find(params[:id]) @comment.destroy redirect_to article_path(@article) end private def comment_params params.require(:comment).permit(:commenter, :body) end end

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

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

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

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

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

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

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

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

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

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

Class ArticlesController < ApplicationController http_basic_authenticate_with name: "dhh", password: "secret", except: [:index, :show] def index @articles = Article.all end # пропущено для краткости

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

Class CommentsController < ApplicationController http_basic_authenticate_with name: "dhh", password: "secret", only: :destroy def create @article = Article.find(params[:article_id]) # ... end # пропущено для краткости

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

root:to => «index#index»

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

Index#index

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

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

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

Index#index

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

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

<% end %>

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

Index#index

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

andrey
vasiliy

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

Спасибо!

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