Ruby on Rails - Краткое руководство

Что такое Руби?

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

Рубин - это удачное сочетание -

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

Рубин - это -

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

Почему Руби?

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

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

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

Performance Issues - Несмотря на то, что он конкурирует с Perl и Python, он по-прежнему является интерпретируемым языком, и мы не можем сравнивать его с языками программирования высокого уровня, такими как C или C ++.
Threading model- Ruby не использует собственные потоки. Потоки Ruby моделируются в виртуальной машине, а не выполняются как собственные потоки ОС.

Пример кода Ruby

Вот пример кода Ruby для вывода «Hello Ruby»

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

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

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

# Output "Hello Ruby!"
h.salute

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

Hello Ruby!

Встроенный Ruby

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

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

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

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

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

<html>

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

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

tp> erb erbdemo.rb

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

<html>

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

Что такое Rails?

Чрезвычайно производительный фреймворк для веб-приложений.
Написано на Ruby Дэвидом Хайнемайером Ханссоном.
Вы можете разработать веб-приложение с помощью Rails как минимум в десять раз быстрее, чем с помощью типичной среды Java.
Платформа Ruby с открытым исходным кодом для разработки веб-приложений на базе баз данных.
Настройте свой код с помощью схемы базы данных.
Фаза компиляции не требуется.

Фреймворк полного стека

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Три среды

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

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

Ruby
Фреймворк Rails
Веб-сервер
Система баз данных

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

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

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

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

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

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

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

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

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

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

Install Rails - После загрузки Rubygems вы можете установить все Rails и его зависимости, используя следующую команду в командной строке -

C:\> gem install rails

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

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

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

C:\> rails -v

Output

Rails 4.2.4

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

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

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

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

Шаг 1. Установите необходимые зависимости

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

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

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

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

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

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

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

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

tp> rbenv install -v 2.2.3

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

tp> rbenv global 2.2.3

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

tp> ruby -v

Output

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

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

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

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

tp> gem install bundler

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

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

tp> install rails -v 4.2.4

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

tp> rbenv rehash

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

tp> rails -v

Output

tp> Rails 4.2.4

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

Шаг 5. Установите среду выполнения JavaScript

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

tp> sudo yum -y install epel-release

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

tp> sudo yum install nodejs

Поздравляю! Теперь вы используете Rails поверх Linux.

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

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

tp> sudo yum install postgresql-server postgresql-contrib

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

tp> sudo postgresql-setup initdb

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

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

Поддержание актуальности Rails

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

tp> gem update rails

Output

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

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

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

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

tp> rails new demo

Output

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

tp> cd demo
tp> rails server

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

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

http://localhost:3000

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

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

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

Describe and model your application's domain- Домен - это вселенная вашего приложения. Доменом может быть музыкальный магазин, университет, служба знакомств, адресная книга или инвентарь оборудования. Итак, здесь вы должны выяснить, что в нем, какие сущности существуют в этой вселенной и как элементы в ней соотносятся друг с другом. Это эквивалентно моделированию структуры базы данных для сохранения сущностей и их взаимосвязей.
Specify what can happen in this domain- Модель предметной области статична; вы должны сделать его динамичным. Адреса можно добавлять в адресную книгу. Музыкальные партитуры можно приобрести в музыкальных магазинах. Пользователи могут войти в службу знакомств. Студенты могут записаться на занятия в университете. Вам необходимо определить все возможные сценарии или действия, в которых могут участвовать элементы вашего домена.
Choose and design the publicly available views of the domain- На этом этапе вы можете начать думать в терминах веб-браузера. После того, как вы решили, что в вашем домене есть студенты и что они могут зарегистрироваться для занятий, вы можете представить себе страницу приветствия, страницу регистрации, страницу подтверждения и т. Д. Каждая из этих страниц или представлений показывает пользователю, как обстоят дела стоять в определенной точке.

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

Ruby on Rails MVC Framework

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

Модель (ActiveRecord)

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

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

Просмотр (ActionView)

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

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

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

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

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

Графическое представление MVC Framework

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

Представление в каталоге MVC Framework

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

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

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

actionpack-x.y.z
activerecord-x.y.z
rails-x.y.z

При установке Windows вы можете найти их вот так -

tp>cd ruby\lib\ruby\gems\2.2.0\gems
ruby\lib\ruby\gems\2.2.0\gems\>dir

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

ActionView и ActionController объединены в ActionPack.

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

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

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

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

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

tp> cd demo
demo> dir

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

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

app- Он организует компоненты вашего приложения. У него есть подкаталоги, которые содержат представление (представления и помощники), контроллер (контроллеры) и внутреннюю бизнес-логику (модели).
app/controllers- В подкаталоге контроллеров Rails ищет классы контроллеров. Контроллер обрабатывает веб-запрос от пользователя.
app/helpers- Подкаталог helpers содержит все вспомогательные классы, используемые для поддержки классов модели, представления и контроллера. Это помогает сделать модель, представление и код контроллера небольшими, сфокусированными и незагроможденными.
app/models- Подкаталог models содержит классы, которые моделируют и обертывают данные, хранящиеся в базе данных нашего приложения. В большинстве фреймворков эта часть приложения может стать довольно запутанной, утомительной, многословной и подверженной ошибкам. Rails делает это очень просто!
app/view - Подкаталог views содержит шаблоны отображения для заполнения данными из нашего приложения, преобразования в HTML и возврата в браузер пользователя.
app/view/layouts- Содержит файлы шаблонов для макетов, которые будут использоваться с представлениями. Это моделирует общий метод упаковки представлений в верхнем и нижнем колонтитулах. В ваших представлениях определите макет с помощью <tt> layout: default </tt> и создайте файл с именем default.html.erb. Внутри default.html.erb вызовите <% yield%> для визуализации представления с использованием этого макета.
components - Этот каталог содержит компоненты, крошечные автономные приложения, которые объединяют модель, представление и контроллер.
config- Этот каталог содержит небольшой объем кода конфигурации, который потребуется вашему приложению, включая конфигурацию вашей базы данных (в database.yml), структуру вашей среды Rails (environment.rb) и маршрутизацию входящих веб-запросов (routes.rb). Вы также можете настроить поведение трех сред Rails для тестирования, разработки и развертывания с помощью файлов, находящихся в каталоге сред.
db- Обычно ваше приложение Rails имеет объекты модели, которые обращаются к таблицам реляционной базы данных. Вы можете управлять реляционной базой данных с помощью скриптов, которые вы создаете и помещаете в этот каталог.
doc- В Ruby есть фреймворк под названием RubyDoc, который может автоматически генерировать документацию для кода, который вы создаете. Вы можете помочь RubyDoc с комментариями в вашем коде. В этом каталоге хранятся все сгенерированные RubyDoc Rails и документация по приложениям.
lib - Вы будете помещать сюда библиотеки, если они явно не принадлежат другому месту (например, библиотеки поставщика).
log- Журналы ошибок находятся здесь. Rails создает сценарии, которые помогают вам управлять различными журналами ошибок. Вы найдете отдельные журналы для сервера (server.log) и каждой среды Rails (development.log, test.log и production.log).
public - Подобно общедоступному каталогу для веб-сервера, в этом каталоге есть веб-файлы, которые не изменяются, такие как файлы JavaScript (общедоступные / javascripts), графика (общедоступные / изображения), таблицы стилей (общедоступные / таблицы стилей) и файлы HTML (общедоступные ).
script- Этот каталог содержит сценарии для запуска и управления различными инструментами, которые вы будете использовать с Rails. Например, есть сценарии для генерации кода (генерации) и запуска веб-сервера (сервера).
test- Все тесты, которые вы пишете, и те, которые создает для вас Rails, находятся здесь. Вы увидите подкаталог для mocks (макеты), модульных тестов (unit), fixture (фикстуры) и функциональных тестов (функциональных).
tmp - Rails использует этот каталог для хранения временных файлов для промежуточной обработки.
vendor - Библиотеки, предоставляемые сторонними поставщиками (например, библиотеки безопасности или утилиты баз данных, помимо базового дистрибутива Rails), находятся здесь.

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

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

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

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

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

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

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

Используйте команду rails, чтобы создать базовый каркас приложения.
Создайте базу данных на сервере PostgreSQL для хранения ваших данных.
Настройте приложение, чтобы знать, где находится ваша база данных, и учетные данные для нее.
Создавайте Rails Active Records (модели), потому что это бизнес-объекты, с которыми вы будете работать в своих контроллерах.
Создавайте миграции, которые упрощают создание и обслуживание таблиц и столбцов базы данных.
Напишите код контроллера, чтобы оживить ваше приложение.
Создавайте представления для представления данных через пользовательский интерфейс.

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

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

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

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

tp> rails new library

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

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

В подкаталоге controllers Rails ищет классы контроллеров. Контроллер обрабатывает веб-запрос от пользователя.
Просмотры подкаталог имеет шаблоны отображения для заполнения данных из нашего приложения, конвертировать в HTML, и вернуться в браузер пользователя.
Модели подкаталог имеет классы, модель и завернуть данные , хранящиеся в базе данных нашего приложения. В большинстве фреймворков эта часть приложения может стать довольно запутанной, утомительной, многословной и подверженной ошибкам. Rails делает это невероятно простым.
Хелпер подкаталог имеет какие - либо вспомогательные классы , используемые для оказания помощи классов модели, вида и контроллера. Это помогает сделать модель, представление и код контроллера небольшими, сфокусированными и незагроможденными.

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

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

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

tp> cd ruby\library 
tp\ruby\library\> Rails server

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

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

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

Что следующее?

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

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

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

library_development
library_production
library_test

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

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

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

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

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

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

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

Настройка database.yml

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

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

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

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

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

tp> sudo -u postgres createuser rubyuser -s

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

tp> sudo -u postgres psql

postgres=# \password rubyuser

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

postgres=# CREATE DATABASE library_development OWNER rubyuser; 

CREATE DATABASE

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

postgres=# CREATE DATABASE library_production OWNER rubyuser; 

CREATE DATABASE

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

postgres=# CREATE DATABASE library_test OWNER rubyuser; 

CREATE DATABASE

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

Настройка database.yml

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

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

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

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

Что следующее?

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

Rails Active Record - это уровень объектно-реляционного отображения (ORM), поставляемый с Rails. Он полностью соответствует стандартной модели ORM, которая выглядит следующим образом:

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

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

Каждый объект Active Record имеет CRUD (Cповторять Read Update и Delete) методы доступа к базе данных. Эта стратегия позволяет создавать простые конструкции и прямые сопоставления между таблицами базы данных и объектами приложения.

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

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

Каждая сущность (например, книга) получает таблицу в базе данных, названную в ее честь, но во множественном числе (книги).
Каждая такая таблица сопоставления сущностей имеет поле с именем id , которое содержит уникальное целое число для каждой записи, вставленной в таблицу.
Для сущности x и сущности y, если сущность y принадлежит сущности x, то таблица y имеет поле с именем x_id.
Большая часть полей в любой таблице хранит значения простых свойств этой сущности (всего, что является числом или строкой).

Создание файлов (моделей) Active Record

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

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

Выше rails generate model book команды генерируют автоматический код, как показано ниже -

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

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

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

Контент доступен в book.rb -

class Book < ActiveRecord::Base
end

Контент доступен в subject.rb -

class Subject < ActiveRecord::Base
end

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

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

one-to-one- Отношения "один к одному" существуют, когда один элемент имеет ровно один из другого элемента. Например, у человека ровно один день рождения или у собаки ровно один хозяин.
one-to-many- Отношение «один ко многим» существует, когда один объект может быть членом многих других объектов. Например, по одному предмету может быть много книг.
many-to-many - Отношение "многие ко многим" существует, когда первый объект связан с одним или несколькими объектами второго объекта, а второй объект связан с одним или несколькими объектами первого объекта.

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

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

class Book < ActiveRecord::Base
   belongs_to :subject
end

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

class Subject < ActiveRecord::Base
   has_many :books
end

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

Внедрение валидации моделей

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

Подтверждения -

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

открыто book.rb в app\model подкаталог и поместите следующие проверки -

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

validates_presence_of - защищает поля "NOT NULL" от пропуска ввода пользователем.
validates_numericality_of - предотвращает ввод пользователем нечисловых данных.

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

Что следующее?

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

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

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

Teams of developers - Если один человек вносит изменения в схему, другим разработчикам нужно просто обновить и запустить «rake migrate».
Production servers - Выполните «rake migrate» при развертывании нового выпуска, чтобы обновить базу данных.
Multiple machines - Если вы разрабатываете и на настольном компьютере, и на ноутбуке, или в нескольких местах, миграции могут помочь вам синхронизировать их все.

Что может сделать миграция на Rails?

create_table (имя, параметры)
drop_table(name)
rename_table (старое_имя, новое_имя)
add_column (имя_таблицы, имя_столбца, тип, параметры)
rename_column (имя_таблицы, имя_столбца, имя_нового_столбца)
change_column (имя_таблицы, имя_столбца, тип, параметры)
remove_column (имя_таблицы, имя_столбца)
add_index (имя_таблицы, имя_столбца, тип_индекса)
remove_index (имя_таблицы, имя_столбца)

Migrations support all the basic data types - Ниже приводится список типов данных, которые поддерживает миграция.

string - для небольших типов данных, таких как заголовок.
text - для более длинных текстовых данных, таких как описание.
integer - для целых чисел.
float - для десятичных знаков.
datetime and timestamp - сохранить дату и время в столбце.
date and time - сохранять только дату или только время.
binary - для хранения таких данных, как изображения, аудио или фильмы.
Boolean - для хранения истинных или ложных значений.

Valid column options are - Ниже приведен список допустимых параметров столбца.

limit (: limit => «50»)
default (: по умолчанию => «бла»)
null(: null => false подразумевает НЕ NULL )

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

Подробнее об этом см. В Rails API .

Создайте миграции

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

application_dir> rails generate migration table_name

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

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

Мы создадим две миграции, соответствующие нашим трем таблицам - books and subjects.

Перенос книг должен быть следующим -

tp> cd library
library> rails generate migration books

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

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

tp> cd library
library> rails generate migration subjects

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

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

Редактировать код

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

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

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

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

   def self.down
      drop_table :books
   end
end

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

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

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

   def self.down
      drop_table :subjects
   end
end

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

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

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

library> rake db:migrate

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

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

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

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

Например -

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

NOTE- В Windows используйте команду «set RAILS_ENV = production» вместо команды экспорта .

Что следующее?

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

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

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

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

Процесс создания контроллера очень прост и похож на процесс, который мы уже использовали для создания модели. Здесь мы создадим только один контроллер -

library\> rails generate controller Book

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

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

Он создает файл с именем app/controllers/book_controller.rb

Если вы посмотрите book_controller.rb, вы найдете следующее:

class BookController < ApplicationController
end

Классы контроллеров наследуются от ApplicationController, который является другим файлом в папке контроллеров:application.rb.

ApplicationController содержит код , который может быть запущен во всех контроллерах , и он наследует от Rails ActionController :: Base класса.

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

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

class BookController < ApplicationController
   def list
   end
   
   def show
   end
   
   def new
   end
   
   def create
   end
   
   def edit
   end
   
   def update
   end
   
   def delete
   end
   
end

Теперь давайте реализуем все методы один за другим.

Реализация метода списка

Метод list дает вам список всех книг в базе данных. Эта функциональность будет достигнута с помощью следующих строк кода. Отредактируйте следующие строки в файле book_controller.rb.

def list
   @books = Book.all
end

@Books = Book.all строка в методе списка говорит Rails для поиска в таблице книги и хранить каждую строку он находит в объекте @books экземпляра.

Реализация метода шоу

Метод show отображает только дополнительные сведения об одной книге. Эта функциональность будет достигнута с помощью следующих строк кода.

def show
   @book = Book.find(params[:id])
end

Строка @book = Book.find (params [: id]) метода show указывает Rails найти только ту книгу, идентификатор которой определен в params [: id].

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

Реализация нового метода

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

def new
   @book = Book.new
   @subjects = Subject.all
end

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

Реализация метода create

После того, как вы введете пользовательский ввод с помощью HTML-формы, пора создать запись в базе данных. Для этого отредактируйте метод create в book_controller.rb, чтобы он соответствовал следующему:

def create
   @book = Book.new(book_params)
	
   if @book.save
      redirect_to :action => 'list'
   else
      @subjects = Subject.all
      render :action => 'new'
   end
   
end

def book_params
   params.require(:books).permit(:title, :price, :subject_id, :description)
end

Первая строка создает новую переменную экземпляра с именем @book, которая содержит объект Book, созданный на основе данных, отправленных пользователем. Вbook_params метод используется для сбора всех полей из объекта :books. Данные были переданы из нового метода для создания с использованием объекта params.

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

Тогда @subjects = Subject.all требуется в случае, если он не сохраняет данные успешно и становится аналогичным случаю с новой опцией.

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

Метод редактирования выглядит почти идентично методу show. Оба метода используются для получения одного объекта на основе его идентификатора и отображения его на странице. Единственная разница в том, что метод show не редактируется.

def edit
   @book = Book.find(params[:id])
   @subjects = Subject.all
end

Этот метод будет вызываться для отображения данных на экране, которые пользователь может изменить. Вторая строка берет все предметы из базы данных и помещает их в массив с именем @subjects.

Реализация метода обновления

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

def update
   @book = Book.find(params[:id])
	
   if @book.update_attributes(book_param)
      redirect_to :action => 'show', :id => @book
   else
      @subjects = Subject.all
      render :action => 'edit'
   end
   
end

def book_param
   params.require(:book).permit(:title, :price, :subject_id, :description)
end

Метод update_attributes похож на метод save, используемый create, но вместо создания новой строки в базе данных он перезаписывает атрибуты существующей строки.

Тогда строка @subjects = Subject.all обязательна, если она не сохраняет данные успешно, тогда она становится похожей на вариант редактирования.

Реализация метода удаления

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

def delete
   Book.find(params[:id]).destroy
   redirect_to :action => 'list'
end

Первая строка находит классифицированное на основе параметра, переданного через объект params, а затем удаляет его с помощью метода destroy. Вторая строка перенаправляет пользователя к методу списка с помощью вызова redirect_to.

Дополнительные методы отображения предметов

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

def show_subjects
   @subject = Subject.find(params[:id])
end

Наконец твой book_controller.rb файл будет выглядеть следующим образом -

class BooksController < ApplicationController

   def list
      @books = Book.all
   end

   def show
      @book = Book.find(params[:id])
   end
  
   def new
      @book = Book.new
      @subjects = Subject.all
   end

   def book_params
      params.require(:books).permit(:title, :price, :subject_id, :description)
   end

   def create
      @book = Book.new(book_params)

      if @book.save
         redirect_to :action => 'list'
      else
         @subjects = Subject.all
         render :action => 'new'
      end
   end
   
   def edit
      @book = Book.find(params[:id])
      @subjects = Subject.all
   end
   
   def book_param
      params.require(:book).permit(:title, :price, :subject_id, :description)
   end
   
   def update
      @book = Book.find(params[:id])
      
      if @book.update_attributes(book_param)
         redirect_to :action => 'show', :id => @book
      else
         @subjects = Subject.all
         render :action => 'edit'
      end
   end
   
   def delete
      Book.find(params[:id]).destroy
      redirect_to :action => 'list'
   end
   
   def show_subjects
      @subject = Subject.find(params[:id])
   end

end

Теперь сохраните файл вашего контроллера.

Что следующее?

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

Модуль маршрутизации обеспечивает перезапись URL в родном Ruby. Это способ перенаправления входящих запросов на контроллеры и действия. Он заменяет правила mod_rewrite. Лучше всего то, что Rails 'Routing работает с любым веб-сервером. Маршруты определены в app / config / routes.rb.

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

Rails.application.routes.draw do
   Pattern 1 tells some request to go to one place
   Pattern 2 tell them to go to another
   ...
end

пример

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

Откройте файл routes.rb в каталоге library / config / и отредактируйте его следующим образом.

Rails.application.routes.draw do
   get 'book/list'
   get 'book/new'
   post 'book/create'
   patch 'book/update'
   get 'book/list'
   get 'book/show'
   get 'book/edit'
   get 'book/delete'
   get 'book/update'
   get 'book/show_subjects'
end

Файл routes.rb определяет действия, доступные в приложениях, и тип действия, например получение, публикация и исправление.

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

library> rake routes

Что следующее?

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

Rails View - это ERb-программа, которая обменивается данными с контроллерами через взаимно доступные переменные.

Если вы посмотрите в каталог app / views приложения библиотеки, вы увидите по одному подкаталогу для каждого из созданных нами контроллеров: book. Каждый из этих подкаталогов был создан автоматически при создании одноименного контроллера с помощью сценария создания.

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

Итак, давайте создадим файлы просмотра для всех методов, которые мы определили в book_controller.rb. Выполняя эти представления, одновременно проверяйте, применимы ли эти действия к базе данных или нет.

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

Создайте файл с именем list.html.erbс помощью вашего любимого текстового редактора и сохраните его в app / views / book. После создания и сохранения файла обновите свой веб-браузер. Вы должны увидеть пустую страницу; если вы этого не сделаете, проверьте написание вашего файла и убедитесь, что оно точно такое же, как и метод вашего контроллера.

Теперь отобразите фактическое содержимое. Поместим следующий код в list.html.erb.

<% if @books.blank? %>
<p>There are not any books currently in the system.</p>
<% else %>
<p>These are the current books in our system</p>

<ul id = "books">
   <% @books.each do |c| %>
   <li><%= link_to c.title, {:action => 'show', :id => c.id} -%></li>
   <% end %>
</ul>

<% end %>
<p><%= link_to "Add new Book", {:action => 'new' }%></p>

Выполняемый код должен проверить, есть ли в массиве @books какие-либо объекты. В.blank?Метод возвращает true, если массив пуст, и false, если он содержит какие-либо объекты. Этот объект @books был создан в контроллере внутри метода списка.

Код между тегами <% =%> - это link_toвызов метода. Первый параметр link_to - это текст, отображаемый между тегами <a>. Второй параметр - какое действие вызывается при нажатии на ссылку. В данном случае это метод шоу. Последний параметр - это идентификатор книги, который передается через объект params.

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

Создание файла просмотра для нового метода

До сих пор в нашей библиотеке нет ни одной книги. Нам нужно создать в системе несколько книг. Итак, давайте создадим представление, соответствующееnew метод, определенный в book_controller.rb.

Создайте файл с именем new.html.erb с помощью вашего любимого текстового редактора и сохраните его в app / views / book. Добавьте следующий код в файл new.html.erb.

<h1>Add new book</h1>

<%= form_tag :action => 'create' do %>
<p><label for = "book_title">Title</label>:

<%= text_field 'books', 'title' %></p>
<p><label for = "book_price">Price</label>:

<%= text_field 'books', 'price' %></p>
<p><label for = "book_subject_id">Subject</label>:

<%= collection_select(:books, :subject_id, @subjects, :id, :name, prompt: true) %></p>
<p><label for = "book_description">Description</label><br/>

<%= text_area 'books', 'description' %></p>
<%= submit_tag "Create" %>

<% end -%>
<%= link_to 'Back', {:action => 'list'} %>

Вот form_tagМетод интерпретирует код Ruby в обычный тег HTML <form>, используя всю предоставленную ему информацию. Этот тег, например, выводит следующий HTML-код:

<form action = "/book/create" method = "post">

Следующий метод text_fieldвыводит текстовое поле <input>. Параметры для text_field - это объект и имя поля. В этом случае объект - книга, а имя - заглавие .

Метод Rails называется collection_select, создает HTML-меню выбора, построенное из массива, такого как @books. Есть пять параметров, а именно:

:book - Объект, которым вы управляете. В данном случае это объект-книга.
:subject_id - Поле, которое заполняется при сохранении книги.
@books - Массив, с которым вы работаете.
:id- Значение, хранящееся в базе данных. С точки зрения HTML, это параметр значения тега <option>.
:name- Вывод, который пользователь видит в раскрывающемся меню. Это значение между тегами <option>.

Следующий используемый - submit_tag, который выводит кнопку <input>, которая отправляет форму. Наконец, естьend метод, который просто переводится в </form>.

Зайдите в свой браузер и посетите http://localhost:3000/book/new. Это даст вам следующий экран.

Введите данные в эту форму и нажмите кнопку «Создать». Здесь я добавил следующие данные в поля -

Title: Advance Physics
Price: 390
Subject: Physics
Description: This is test to create new book

Когда вы нажимаете Create кнопку, он вызовет create метод, который не нуждается в представлении, потому что этот метод использует либо list или же newметоды для просмотра результатов. Итак, когда вы нажимаете кнопку «Создать», данные должны быть успешно отправлены и перенаправлять вас на страницу списка, на которой теперь у вас есть один элемент, указанный ниже:

Если вы щелкните ссылку, вы должны увидеть ошибку «Отсутствует другой шаблон», поскольку вы еще не создали файл шаблона для метода show.

Создание файла просмотра для метода шоу

Этот метод отобразит полную информацию о любой книге, доступной в библиотеке. Создайте файл show.html.erb в папке app / views / book и заполните его следующим кодом -

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

<p>
   <strong>Price: </strong> $<%= @book.price %><br />
   <strong>Subject :</strong> <%= @book.subject.name %><br />
   <strong>Created Date:</strong> <%= @book.created_at %><br />
</p>

<p><%= @book.description %></p>

<hr />

<%= link_to 'Back', {:action => 'list'} %>

Это первый раз, когда вы в полной мере воспользовались ассоциациями, которые позволяют легко извлекать данные из связанных объектов.

Используемый формат @variable.relatedObject.column. В этом случае вы можете получить значение имени субъекта через переменную @book, используяbelongs_toассоциации. Если щелкнуть любую запись в списке, появится следующий экран.

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

Создайте новый файл с именем edit.html.erb и сохраните его в app / views / book. Заполните его следующим кодом -

<h1>Edit Book Detail</h1>

<%= form_for @book, :url =>{:action => "update", :id =>@book} do |f| %>

<p>Title: <%= f.text_field 'title' %></p>
<p>Price: <%= f.text_field  'price' %></p>
<p>Subject: <%= f.collection_select :subject_id, Subject.all, :id, :name %></p>
<p>Description<br/>

<%= f.text_area 'description' %></p>
<%= f.submit "Save changes" %>
<% end %>

<%= link_to 'Back', {:action => 'list' } %>

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

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

На этом этапе нам нужно внести некоторые изменения в list method'sпосмотреть файл. Перейдите к элементу <li> </li> и измените его, чтобы он выглядел следующим образом:

<li>
   <%= link_to c.title, {:action => "show", :id => c.id} -%>
   <b> <%= link_to 'Edit', {:action => "edit",
   :id => c.id} %></b>
</li>

Теперь попробуйте просматривать книги с помощью http://localhost:3000/book/list. Это даст вам список всех книг вместе с Editвариант. Когда вы нажмете опцию Edit, у вас появится следующий экран:

Теперь вы редактируете эту информацию, а затем нажимаете кнопку « Сохранить изменения» . Это приведет к вызовуupdateдоступный в файле контроллера, и он обновит все измененные атрибуты. Обратите внимание, чтоupdate методу не нужен файл представления, потому что он использует либо show или же edit методы, чтобы показать его результаты.

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

Удаление информации из базы данных с помощью Ruby on Rails почти слишком просто. Вам не нужно писать код представления для метода удаления, потому что этот метод используетlistметод для отображения результата. Итак, давайте снова изменим list.html.erb и добавим ссылку для удаления.

Перейдите к элементу <li> </li> и измените его, чтобы он выглядел следующим образом:

<li>
   <%= link_to c.title, {:action => 'show', :id => c.id} -%>
   <b> <%= link_to 'Edit', {:action => 'edit', :id => c.id} %></b>
   <b> <%= link_to "Delete", {:action => 'delete', :id => c.id},
   :confirm => "Are you sure you want to delete this item?" %></b>
</li>

В :confirmпредставляет собой окно подтверждения JavaScript с вопросом, действительно ли вы хотите выполнить действие. Если пользователь нажимает кнопку «ОК», действие продолжается, и элемент удаляется.

Теперь попробуйте просматривать книги с помощью http://localhost:3000/book/list. Это даст вам список всех книг вместе с Edit и Delete следующие варианты -

Теперь, используя опцию Удалить, вы можете удалить любую запись в списке.

Создание файла представления для метода show_subjects

Создайте новый файл show_subjects.html.erb в каталоге app / views / book и добавьте в него следующий код:

<h1><%= @subject.name -%></h1>

<ul>
   <% @subject.books.each do |c| %>
   <li><%= link_to c.title, :action => "show", :id => c.id -%></li>
   <% end %>
</ul>

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

Теперь измените строку Subject: файла show.html.erb так, чтобы в списке тем была ссылка.

<strong>Subject: </strong> <%= link_to @book.subject.name,
:action => "show_subjects", :id => @book.subject.id %><br />

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

Изменить list.html.erb чтобы добавить следующее в начало файла -

<ul id = "subjects">
   <% Subject.find(:all).each do |c| %>
   <li><%= link_to c.name, :action => "show_subjects", :id => c.id %></li>
   <% end %>
</ul>

Теперь попробуйте просмотреть книги, используя http: // localhost: 3000 / book / list. Он отобразит все темы со ссылками, так что вы сможете просмотреть все книги, относящиеся к этой теме.

Что следующее?

Надеюсь, теперь вы чувствуете себя комфортно со всеми операциями Rails.

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

Макет определяет окружение HTML-страницы. Это место, где можно определить общий вид вашего окончательного результата. Файлы макета находятся в app / views / layouts.

Процесс включает определение шаблона макета, а затем сообщение контроллеру о его существовании и его использование. Сначала создадим шаблон.

Добавьте новый файл с именем standard.html.erb в app / views / layouts. Вы сообщаете контроллерам, какой шаблон использовать, по имени файла, поэтому рекомендуется использовать ту же схему именования.

Добавьте следующий код в новый файл standard.html.erb и сохраните изменения -

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns = "http://www.w3.org/1999/xhtml">

   <head>
      <meta http-equiv = "Content-Type" content = "text/html; charset = iso-8859-1" />
      <meta http-equiv = "Content-Language" content = "en-us" />
      <title>Library Info System</title>
      <%= stylesheet_link_tag "style" %>
   </head>

   <body id = "library">
      <div id = "container">
         
         <div id = "header">
            <h1>Library Info System</h1>
            <h3>Library powered by Ruby on Rails</h3>
         </div>

         <div id = "content">
            <%= yield -%>
         </div>

         <div id = "sidebar"></div>
         
      </div>
   </body>
   
</html>

Все, что вы только что добавили, было стандартными элементами HTML, кроме двух строк. Вstylesheet_link_tagвспомогательный метод выводит таблицу стилей <link>. В этом случае мы связываем таблицу стилей style.css. Вyield сообщает Rails, что он должен поместить html.erb для вызываемого здесь метода.

Теперь откройте book_controller.rb и добавьте следующую строку чуть ниже первой строки -

class BookController < ApplicationController
layout 'standard'
def list
@books = Book.all
end
...................

Он сообщает контроллеру, что мы хотим использовать макет, доступный в файле standard.html.erb. Теперь попробуйте просмотреть книги, после чего появится следующий экран.

Добавление таблицы стилей

До сих пор мы не создавали никаких таблиц стилей, поэтому Rails использует таблицу стилей по умолчанию. Теперь давайте создадим новый файл с именем style.css и сохраним его в / public / stylesheets. Добавьте в этот файл следующий код.

body {
   font-family: Helvetica, Geneva, Arial, sans-serif;
   font-size: small;
   font-color: #000;
   background-color: #fff;
}

a:link, a:active, a:visited {
   color: #CD0000;
}

input { 
   margin-bottom: 5px;
}

p { 
   line-height: 150%;
}

div#container {
   width: 760px;
   margin: 0 auto;
}

div#header {
   text-align: center;
   padding-bottom: 15px;
}

div#content {
   float: left;
   width: 450px;
   padding: 10px;
}

div#content h3 {
   margin-top: 15px;
}

ul#books {
   list-style-type: none;
}

ul#books li {
   line-height: 140%;
}

div#sidebar {
   width: 200px;
   margin-left: 480px;
}

ul#subjects {
   width: 700px;
   text-align: center;
   padding: 5px;
   background-color: #ececec;
   border: 1px solid #ccc;
   margin-bottom: 20px;
}

ul#subjects li {
   display: inline;
   padding-left: 5px;
}

Теперь обновите свой браузер и посмотрите на разницу -

Что следующее?

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

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

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

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

Пример строительных лесов

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

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

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

tp> rails new cookbook

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

Вот способ создания базы данных -

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

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

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

Чтобы указать Rails, как найти базу данных, отредактируйте файл конфигурации cookbook \ config \ database.yml и измените имя базы данных на cookbook. Оставьте пароль пустым. Когда вы закончите, это должно выглядеть следующим образом -

development:
   adapter: mysql
   database: cookbook
   username: root
   password: [password]
   host: localhost
	
test:
   adapter: mysql
   database: cookbook
   username: root
   password: [password]
   host: localhost
	
production:
   adapter: mysql
   database: cookbook
   username: root
   password: [password]
   host: localhost

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

Сгенерированный код скаффолда

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

Итак, давайте снова начнем с генерации кода Scaffold вручную с помощью вспомогательного скрипта scaffold -

cookbook> rails generate scaffold recipe

Он генерирует автоматические файлы, как показано ниже -

Контроллер

Давайте посмотрим на код контроллера. Этот код генерируетсяscaffoldгенератор. Если вы откроете app / controllers / recipes_controller.rb, вы найдете следующее:

class RecipesController < ApplicationController
   before_action :set_recipe, only: [:show, :edit, :update, :destroy]
   
   # GET /recipes
   # GET /recipes.json
   def index
      @recipes = Recipe.all
   end
   
   # GET /recipes/1
   # GET /recipes/1.json
   def show
   end
   
   # GET /recipes/new
   def new
      @recipe = Recipe.new
   end
   
   # GET /recipes/1/edit
   def edit
   end
   
   # POST /recipes
   # POST /recipes.json
   def create
      @recipe = Recipe.new(recipe_params)
      
      respond_to do |format|
         if @recipe.save
            format.html { redirect_to @recipe, notice: 'Recipe was successfully created.' }
            format.json { render :show, status: :created, location: @recipe }
         else
            format.html { render :new }
            format.json { render json: @recipe.errors, status: :unprocessable_entity }
         end
      end
      
   end
   
   # PATCH/PUT /recipes/1
   # PATCH/PUT /recipes/1.json
   def update
      respond_to do |format|
         if @recipe.update(recipe_params)
            format.html { redirect_to @recipe, notice: 'Recipe was successfully updated.' }
            format.json { render :show, status: :ok, location: @recipe }
         else
            format.html { render :edit }
            format.json { render json: @recipe.errors, status: :unprocessable_entity }
         end
      end
      
   end
   
   # DELETE /recipes/1
   # DELETE /recipes/1.json
   def destroy
      @recipe.destroy
         respond_to do |format|
         format.html { redirect_to recipes_url, notice: 'Recipe was successfully destroyed.' }
         format.json { head :no_content }
      end
   end
   
   private
   
   # Use callbacks to share common setup or constraints between actions.
   def set_recipe
      @recipe = Recipe.find(params[:id])
   end
   
   # Never trust parameters from the scary internet, only allow the white list through.
   def recipe_params
      params.require(:recipe).permit(:tittle, :instructions)
   end
end

Когда пользователь приложения Rails выбирает действие, например «Показать» - контроллер выполнит любой код в соответствующем разделе - «def show» - а затем по умолчанию отобразит шаблон с тем же именем - «show.html». эрб ". Это поведение по умолчанию можно перезаписать.

Контроллер использует методы ActiveRecord, такие как find, find_all, new, save, update_attributes и destroy для перемещения данных в таблицы базы данных и из них. Обратите внимание, что вам не нужно писать никаких операторов SQL, rails позаботится об этом автоматически.

Эта единственная строка кода оживит таблицу базы данных. Он предоставит простой интерфейс для ваших данных и способы -

Создание новых записей
Редактирование текущих записей
Просмотр текущих записей
Удаление текущих записей

При создании или редактировании записи scaffold выполнит всю тяжелую работу, такую как создание и обработка форм, и даже обеспечит умную генерацию форм, поддерживая следующие типы входных данных:

Простые текстовые строки
Текстовые области (или большие блоки текста)
Селекторы даты
Селекторы даты и времени

Вы можете использовать Rails Migrations для создания и обслуживания таблиц.

rake db:migrate RAILS_ENV=development

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

cookbook> rails server

Теперь откройте браузер и перейдите по адресу http://127.0.0.1:3000/recipe/new. Это предоставит вам экран для создания новых записей в таблице рецептов. Снимок экрана показан ниже -

Как только вы нажмете Create кнопку, чтобы создать новый рецепт, ваша запись будет добавлена в таблицу рецептов, и она покажет следующий результат -

Вы можете увидеть возможность редактировать, отображать и уничтожать записи. Итак, поэкспериментируйте с этими вариантами.

Вы также можете перечислить все рецепты, доступные в таблице рецептов, используя URL-адрес http://127.0.0.1:3000/recipe/list.

Улучшение модели

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

Измените app / models / recipe.rb следующим образом, а затем протестируйте свое приложение -

class Recipe < ActiveRecord::Base
   validates_length_of :title, :within => 1..20
   validates_uniqueness_of :title, :message => "already exists"
end

Эти записи будут автоматически проверяться.

validates_length_of - поле не пустое и не слишком длинное.
validates_uniqueness_of- дублирующиеся значения улавливаются. Вместо стандартного сообщения об ошибке Rails здесь мы привели собственное сообщение.

Альтернативный способ создания строительных лесов

Создайте приложение, как показано выше, и The Generated Scaffold Code как показано ниже

rails g scaffold Recipe tittle:string instructions:text

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

нам нужно перенести базу данных, используя синтаксис ниже.

$ rake db:migrate RAILS_ENV=development

Наконец, запустите приложение, используя следующую командную строку -

rails server

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

Виды

Все представления и соответствующие все методы контроллера создаются scaffold и они доступны в каталоге app / views / recipes.

Чем отличаются строительные леса?

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

Ajax означает Aсинхронный JavaScript и XML. Ajax - это не отдельная технология; это набор нескольких технологий. Ajax включает в себя следующее -

XHTML для разметки веб-страниц
CSS для стилизации
Динамическое отображение и взаимодействие с использованием DOM
Управление данными и обмен с помощью XML
Получение данных с помощью XMLHttpRequest
JavaScript как клей, который объединяет все это воедино

Ajax позволяет получать данные для веб-страницы без необходимости обновлять содержимое всей страницы. В базовой веб-архитектуре пользователь щелкает ссылку или отправляет форму. Форма отправляется на сервер, который затем отправляет ответ. Затем ответ отображается для пользователя на новой странице.

Когда вы взаимодействуете с веб-страницей на базе Ajax, она загружает движок Ajax в фоновом режиме. Движок написан на JavaScript, и в его обязанности входит как взаимодействие с веб-сервером, так и отображение результатов пользователю. Когда вы отправляете данные с помощью формы на основе Ajax, сервер возвращает фрагмент HTML, который содержит ответ сервера и отображает только новые или измененные данные, а не обновляет всю страницу.

Чтобы получить полную информацию об AJAX, вы можете ознакомиться с нашим учебным пособием по AJAX.

Как Rails реализует Ajax

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

Some trigger fires - Этим триггером может быть пользователь, нажимающий кнопку или ссылку, пользователь, вносящий изменения в данные в форме или в поле, или просто периодический триггер (на основе таймера).
The web client calls the server- Метод JavaScript, XMLHttpRequest , отправляет данные, связанные с триггером, в обработчик действий на сервере. Данные могут быть идентификатором флажка, текстом в поле ввода или всей формой.
The server does processing - Обработчик действий на стороне сервера (действие контроллера Rails) - что-то делает с данными и возвращает фрагмент HTML веб-клиенту.
The client receives the response - Клиентский JavaScript, который Rails создает автоматически, получает фрагмент HTML и использует его для обновления указанной части HTML текущей страницы, часто содержимого тега <div>.

Эти шаги - самый простой способ использовать Ajax в приложении Rails, но с небольшой дополнительной работой вы можете заставить сервер возвращать любые данные в ответ на запрос Ajax, и вы можете создать собственный JavaScript в браузере, чтобы выполнять больше вовлеченные взаимодействия.

Пример AJAX

Этот пример работает на основе scaffold, концепция Destroy работает на основе ajax.

В этом примере мы предоставим, перечислим, покажем и создадим операции над таблицей пони. Если вы не разбираетесь в технологии скаффолда, мы рекомендуем вам сначала пройти через предыдущие главы, а затем продолжить работу с AJAX on Rails.

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

Начнем с создания приложения. Это будет сделано следующим образом -

rails new ponies

Приведенная выше команда создает приложение, теперь нам нужно вызвать каталог приложения с помощью команды cd. Он войдет в каталог приложения, тогда нам нужно вызвать команду scaffold. Это будет сделано следующим образом -

rails generate scaffold Pony name:string profession:string

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

rake db:migrate

Теперь запустите приложение Rails с помощью следующей команды

rails s

Теперь откройте веб-браузер и вызовите URL-адрес как http: // localhost: 3000 / ponies / new. Результат будет следующим.

Создание Ajax

Теперь откройте app / views / ponies / index.html.erb с подходящими текстовыми редакторами. Обновите строку уничтожения с помощью: remote => true,: class => 'delete_pony'. Наконец, это выглядит следующим образом.

Создайте файл destroy.js.erb, поместите его рядом с другими вашими файлами .erb (в app / views / ponies). Это должно выглядеть так -

Теперь введите код, как показано ниже, в destroy.js.erb

$('.delete_pony').bind('ajax:success', function() {
   $(this).closest('tr').fadeOut();
});

Теперь откройте файл контроллера, который находится в app / controllers / ponies_controller.rb, и добавьте следующий код в метод уничтожения, как показано ниже -

# DELETE /ponies/1
# DELETE /ponies/1.json
def destroy
   @pony = Pony.find(params[:id])
   @pony.destroy
   
   respond_to do |format|
      format.html { redirect_to ponies_url }
      format.json { head :no_content }
      format.js   { render :layout => false }
   end
   
end

Наконец, страница контроллера выглядит как показано на рисунке.

Теперь запустите приложение, вывод вызывается из http: // localhost: 3000 / ponies / new, он будет выглядеть как на следующем изображении

Нажмите кнопку создания пони, результат будет следующим:

Теперь нажмите кнопку «Назад», появится вся созданная пони информация, как показано на рисунке.

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

Если нажать кнопку «ОК», запись будет удалена с пони. Здесь я нажал кнопку ОК. Окончательный результат будет следующим -

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

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

tp> rails new testfile

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

gem install carrierwave
gem install bootstrap-sass

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

После добавления драгоценных камней в файл гемов нам нужно выполнить следующую команду на консоли -

bundle install

Создание модели

Нам нужно создать модель с двумя строками в качестве имени и вложения, как показано ниже -

rails g model Resume name:string attachment:string

Нам нужно создать миграцию базы данных, как показано ниже -

rake db:migrate

Нам нужно сгенерировать контроллер, как показано ниже -

rails g controller Resumes index new create destroy

Большой! Теперь у нас есть базовая структура. Теперь нам нужно создать загрузчика. Загрузчик пришёл из драгоценного камня carrierwave и сообщает carrierwave, как обрабатывать файлы. Короче говоря, он содержал все функции обработки файлов. Запустите команду, чтобы создать загрузчика, как показано ниже.

rails g uploader attachment

Теперь откройте модель резюме и вызовите загрузчик, как показано ниже. Модель резюме размещена в app / models / resume.rb -

class Resume < ActiveRecord::Base
   mount_uploader :attachment, AttachmentUploader # Tells rails to use this uploader for this model.
   validates :name, presence: true # Make sure the owner's name is present.
end

Перед работой с контроллером нам нужно изменить наш config / routes.db, как показано ниже -

CarrierWaveExample::Application.routes.draw do
   resources :resumes, only: [:index, :new, :create, :destroy]
   root "resumes#index"
end

Давайте отредактируем контроллер, как показано ниже.

class ResumesController < ApplicationController
   def index
      @resumes = Resume.all
   end
   
   def new
      @resume = Resume.new
   end
   
   def create
      @resume = Resume.new(resume_params)
      
      if @resume.save
         redirect_to resumes_path, notice: "The resume #{@resume.name} has been uploaded."
      else
         render "new"
      end
      
   end
   
   def destroy
      @resume = Resume.find(params[:id])
      @resume.destroy
      redirect_to resumes_path, notice:  "The resume #{@resume.name} has been deleted."
   end
   
   private
      def resume_params
      params.require(:resume).permit(:name, :attachment)
   end
   
end

Давайте добавим реализацию начальной загрузки в файл css. Файл css может находиться в app / assets / stylesheets / resumes.css.scss

@import "bootstrap";

Теперь откройте app / views / layouts / application.html.erb и добавьте коды, как показано ниже -

<!DOCTYPE html>
<html>
   
   <head>
      <title>Tutorialspoint</title>
      <%= stylesheet_link_tag "application", media: "all", "data-turbolinks-track" => true %>
      <%= javascript_include_tag "application", "data-turbolinks-track" => true %>
      <%= csrf_meta_tags %>
   </head>
   
   <body>
      <div class = "container" style = "padding-top:20px;">
         <%= yield %>
      </div>
   </body>

</html>

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

<% if !flash[:notice].blank? %>
   <div class = "alert alert-info">
      <%= flash[:notice] %>
   </div>
<% end %>

<br />

<%= link_to "New Resume", new_resume_path, class: "btn btn-primary" %>
<br />
<br />

<table class = "table table-bordered table-striped">
   <thead>.
      <tr>
         <th>Name</th>
         <th>Download Link</th>
         <th> </th>
      </tr>
   </thead>
   
   <tbody>
      <% @resumes.each do |resume| %>
         
         <tr>
            <td><%= resume.name %></td>
            <td><%= link_to "Download Resume", resume.attachment_url %></td>
            <td><%= button_to "Delete",  resume, method: :delete, class: "btn btn-danger", confirm: "Are you sure that you wish to delete #{resume.name}?" %></td>
         </tr>
         
      <% end %>
   </tbody>
   
</table>

Теперь давайте отредактируем new.html.erb и добавим код нашей формы.

<% if [email protected]? %>
   <div class = "alert alert-error">
      
      <ul>
         <% @resume.errors.full_messages.each do |msg| %>
            <li><%= msg %></li>
         <% end %>
      </ul>
      
   </div>
<% end %>

<div class = "well">
   <%= form_for @resume, html: { multipart: true } do |f| %>
      <%= f.label :name %>
      <%= f.text_field :name %>
      <%= f.label :attachment %>
      <%= f.file_field :attachment %>
      <%= f.submit "Save", class: "btn btn-primary" %>
   <% end %>
</div>

Теперь запустите сервер и посетите http: // localhost: 3000. Это создаст экран, подобный следующему -

Последнее, что нам нужно сделать, это отфильтровать список разрешенных типов файлов. Для этого нам нужно добавить простой код, как показано ниже, в app / uploaders / attachment_uploader.rb.

class AttachmentUploader < CarrierWave::Uploader::Base
   storage :file
   
   def store_dir
      "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
   end
   
   def extension_white_list
      %w(pdf doc htm html docx)
   end
end

Теперь запустите сервер и посетите http: // localhost: 3000. Теперь введите неправильный формат; он сгенерирует неправильное сообщение, как показано ниже -

Для полной информации о File объект, вам нужно пройти через Ruby Reference Manual.

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

tp> rails new mailtest

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

Действие Mailer - Конфигурация

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

Перейдите в папку config вашего проекта электронной почты, откройте файл environment.rb и добавьте следующую строку в конец этого файла.

config.action_mailer.delivery_method = :smtp

Он сообщает ActionMailer, что вы хотите использовать SMTP-сервер. Вы также можете установить его как: sendmail, если вы используете операционную систему на основе Unix, такую как Mac OS X или Linux.

Также добавьте следующие строки кода в конец файла environment.rb.

config.action_mailer.smtp_settings = {
   address:              'smtp.gmail.com',
   port:                 587,
   domain:               'example.com',
   user_name:            '<username>',
   password:             '<password>',
   authentication:       'plain',
   enable_starttls_auto: true  
}

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

Вы также можете изменить формат сообщения электронной почты по умолчанию. Если вы предпочитаете отправлять электронную почту в формате HTML вместо обычного текстового формата, добавьте также следующую строку в config / environment.rb:

ActionMailer::Base.default_content_type = "text/html"

ActionMailer :: Base.default_content_type может иметь значение «text / plain», «text / html» и «text / enriched». Значение по умолчанию - «текст / обычный».

Следующим шагом будет создание почтовой программы

Создать почтовую программу

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

tp> cd emails
emails> rails generate mailer Usermailer

Это создаст файл user_mailer.rb в каталоге app \ mailer. Проверьте содержимое этого файла следующим образом -

class Emailer < ActionMailer::Base
end

Давайте создадим один метод следующим образом -

class UserMailer < ApplicationMailer
   default from: '[email protected]'
   
   def welcome_email(user)
      @user = user
      @url  = 'http://www.gmail.com'
      mail(to: @user.email, subject: 'Welcome to My Awesome Site')
   end
   
end

default Hash- Это хэш значений по умолчанию для любого электронного письма, которое вы отправляете из этой почтовой программы. В этом случае мы устанавливаем заголовок: from в значение для всех сообщений в этом классе. Это можно изменить для каждого электронного письма.
mail - Фактическое сообщение электронной почты, в котором мы передаем заголовки: to и: subject.

Создайте файл с именем welcome_email.html.erb в app / views / user_mailer /. Это будет шаблон электронного письма в формате HTML -

<html>
   
   <head>
      <meta content = 'text/html; charset = UTF-8' http-equiv = 'Content-Type' />
   </head>
   
   <body>
      <h1>Welcome to example.com, <%= @user.name %></h1>
      
      <p>
         You have successfully signed up to example.com,your username is: 
         <%= @user.login %>.<br>
      </p>
      
      <p>
         To login to the site, just follow this link: 
         <%= @url %>.
      </p>
      
      <p>Thanks for joining and have a great day!</p>
      
   </body>
</html>

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

Welcome to example.com, <%= @user.name %>
===============================================
 
You have successfully signed up to example.com,
your username is: <%= @user.login %>.
 
To login to the site, just follow this link: <%= @url %>.
 
Thanks for joining and have a great day!

Вызов почтовой программы

Во-первых, давайте создадим простой шаблон пользователя.

$ bin/rails generate scaffold user name email login
$ bin/rake db:migrate

Action Mailer прекрасно интегрирован с Active Job, поэтому вы можете отправлять электронные письма вне цикла запрос-ответ, поэтому пользователю не нужно ждать его -

class UsersController < ApplicationController
   # POST /users
   # POST /users.json
   def create
   @user = User.new(params[:user])
   
      respond_to do |format|
         if @user.save
            # Tell the UserMailer to send a welcome email after save
            UserMailer.welcome_email(@user).deliver_later
            
            format.html { redirect_to(@user, notice: 'User was successfully created.') }
            format.json { render json: @user, status: :created, location: @user }
         else
            format.html { render action: 'new' }
            format.json { render json: @user.errors, status: :unprocessable_entity }
         end
         
      end
      
   end
end

Теперь протестируйте свое приложение, используя http://127.0.0.1:3000/users/new. Он отображает следующий экран, и с его помощью вы сможете отправить свое сообщение кому угодно.

Это отправит ваше сообщение и отобразит текстовое сообщение «Сообщение успешно отправлено» и выведет его следующим образом:

sent mail to [email protected] (2023.Sms)
[ActiveJob] [ActionMailler::DeliveryJob] [2cfde3c-260e-4a33-1a6ada13a9b] Date: Thu, 09 Jul 2015 11:44:05 +0530
From: [email protected]
To: [email protected]
Message-Id: <[email protected]>
Subject: Welcome to My Awesome Site
Mime-Version: 1.0
Content-Type: multipart/alternative;
boundary="--mimepart_559e112d601c8_f1031e7f20233f5";
charset=UTF-8
Content-Transfer-Encoding:7bit

Для получения дополнительной информации о том, как отправлять электронные письма с помощью Rails, перейдите в ActionMailer .