© 2019 Martin J. Dürst 青山学院大学

ミニテスト

• デスクトップPC (強く推薦) 又はノートPCで https://moo.sw.it.aoyama.ac.jp/ にログイン済み
• ナビゲーションは左に畳み、ブラウザは全画面に拡大
• もう片方のマシーンで電源を切る (ノートPCの場合、鞄に)
• 授業開始まで教科書、資料、筆箱、財布などを鞄に入れ、鞄は床に
• テスト終了後はマウス・キーボードに一切触らないこと

Today's Schedule

• Minitest
• Last week's exercises and homework
• Creating a Rails application
• MVC: Model-View-Controller
• Rails Controllers and Views
• Today's exercises

Last Lecture's Exercise 6b:
Web Page with Wrestler Table

• Create an ERB template in a file 6b_wrestler_table.html.erb that outputs a table of wrestlers from the database.
• Start webrick and test your Web page while you develop it.
• Use a query parameter (sort=stable, sort=division, sort=weight, sort=height) to be able to select the sort order.
• Use links on the page to select sort orders with a single click (e.g. <a href='?sort=weight'>Sort by weight</a>)
• For sorting, do not use the Ruby sort method as in exercise 5c, but use the ActiveRecord order method.
• A page with all wrestlers will be quite long. You can limit the output to the first 100 wrestlers with the ActiveRecord limit method.
• Save the source (HTML only) of your Web page and validate it. Fix any validation errors.
• Submit the program 6b_wrestler_table.html.erb to Moodle (deadline: May 22 (Wednesday), 19:00).

Problem: Many different parts of processing are mixed up. This may work for such a small example, but will not scale.

Course Overview

• Lecture 5: ERB templates
• Lecture 6: Database access with ORM
• This lecture:
  • First time to use Ruby on Rails
  • Controllers connect data and presentation
  • MVC as a way to organize an interactive application

Creating a Rails Application

• Rails applications are created with the command rails new application-name
  (application-name is the name of your application)
• Creates many directories, subdirectories and files
• Uses bundler to check and complete gem dependencies and create file Gemfile.lock
• Gemfile.lock makes sure that exactly the same gems are used for development, test, and production

Rails Directory Structure

• When you create a Rails application, rails new creates many directories, subdirectories and files.
• This has two purposes:
  • Save work (you do not have to do this by hand)
  • Convention over configuration (every Rails application has the same structure, so things are easy to find)
• The main directories are:
  • app: The main application files
  • config: Configuration files
  • db: Database-related files
  • public: Files that are served directly
  • test: Files for testing
• Other directories: lib, log, storage, tmp, vendor

The app Directory

• Contains application itself
• Main subdirectories:
  • models: Models (ActiveRecord) used by the application
  • views: Views (ERB) used by the application
  • controllers: Controllers used by the application
• Other subdirectories: assets, channels, helpers, jobs, mailers

MVC - Model-View-Controller

• Widely used paradigm for interactive applications (standalone and Web)
• Makes big applications easier to understand
• Model: Data access and storage, data integrity, calculations on data
• View: Presentation to the user
• Controller: Control of model and view, connection between models and views

MVC Limits

• Many times, it may not be clear where some functionality should go
• Example: Sorting
  • Sorting sorts data, so it should be done in the model
  • Sorting affects presentation, so it should be done in the view
  • Sorting is affected by input (sort order), so it should be in the controller
• Think about it, but don't worry too much
• You will get better at this with experience

MVC in Rails

• Rails uses MVC to organize an application
• The other main components needed are routing (inside Rails) and a database (outside Rails)
• Models, views, and controllers go into different subdirectories of the app directory
• Usually the following go together:
  • One controller (with several actions)
  • One model
  • Several views (one view per action)
• Today, we will only use a controller and some views, no models

Rails Controller

• Each controller is a subclass of ApplicationController
  (which is a subclass of ActionController::Base)
• The file for ExampleController is at app/controllers/example_controller.rb
• Each controller has one or more actions
• Each action is a method
• Roughly, each action corresponds to a Web page of the application
• Each action checks inputs (e.g. URI query parameters)
  and prepares output (e.g. by accessing a model, providing data, doing calculations,...)
• Data for output is stored in instance variables (e.g. @var), which can be accessed by the view

Rails View

• One file per action
• Files in app/view, with subdirectory for each controller (class)
• Example: app/view/controller/action.html.erb
• Uses ERB
• Contain only HTML body content (head, <body>/</body> tags added automatically)
• Can access the same instance variables as the controller

Rails Routing

• Routing maps URIs to controller actions and back
• Routes are defined in file config/routes.rb
• Routes can be checked with rails routes
• We will learn more about routes in the next weeks

Rails Commands Used Today

• rails new: create a new rails application
• rails generate: generate some files (e.g. for a controller and associated view,...)
• rails server: start the rails server
• rails routes: show the routes for this application

All commands except rails new have to be executed in the application directory.

Why is Rails So Slow?

• When developing, it is very inconvenient if we have to stop and restart the server every time we change a file
• When changing a file, changes should up immediately
• Rails automatically checks for changed files and reloads them
• This is called the development environment (see config/environments)
• This makes Rails a bit slow, but convenient for development
• The development environment also shows detailled error messages.
  Please have a careful look at them (or check the logs).
• There are two other environment: test and production
• These environments are faster

Exercise 7a: Create a Rail Application

• Create a new Rails application called "hello" with rails new hello
• Change to the new directory: cd hello
• Start the server (puma) with: rails server
  (can be abbreviated to rails s)
• With a browser, go to http://localhost:3000/
• Verify that you see "Yay! You're on Rails!"
• Write down the versions you see in that page:

  Rails version: . . . . . . . . . . . .

  Ruby version: . . . . . . . . . . . . . . . .

• Have a look at the HTML source of the "Yay! You're on Rails!" page, in particular the two data: URIs
• Save the HTML (only!) source of the page in a file yay.html
• Submit the file yay.html to Moodle (deadline 17:00)

Exercise 7b: Say Hello

• (you do not have to shut down and restart the server)
• In your hello directory, create a controller (with a view) with the following command:
  rails generate controller Say hello
• Point your browser to http://localhost:3000/say/hello
• Write down the controller method and the location of the view file that are shown:

  Controller method: . . . . . . . . . . # . . . . . . . . . .

  Location of view file: . . . . . . . . . . . . . . . . . . . . . . . .

• Change the view file to use a main heading (h1) of Hello from [your name here]!
• Use the browser to check that this change worked
• In the controller (at app/controllers/say_controller.rb), set the instance variable @time to the current time (Time.now)
• In the view file, use the instance variable @time to output The current time is .....
  (do not worry about the formatting details of the time string)
• Check your page repeatedly, verifying that the time changes when you reload it
• Submit the files say_controller.rb and hello.html.erb to Moodle (deadline 17:45)

Exercise 7c: Say Goodbye

• Create a new action (method) named goodbye in the Say controller
• Copy the hello.html.erb file to goodbye.html.erb
• Change the main heading of that page to Goodbye from [your name here]!
• In the file config/routes.rb, add an additional line
  get 'say/goodbye'
• Check your goodbye page at http://localhost:3000/say/goodbye
• In the main application directory, use the command rails routes to show the routes in your application.
  
  • The routes for hello and goodbye should show up first (two lines each)
  • You can ignore the rest (after rails_service_blob)
  • Output the routes to a file routes.txt with a redirect
• Replace the time in the goodbye page with a number of paragraphs all saying Goodbye!:
  
  • In the action (method), use params[:count] to access the count URI parameter
  • Set the @count instance variable to the integer value of the count parameter
  • If there is no count parameter, or the value of count is 0 or smaller, set @count to 1
  • In the goodbye.html.erb file, use the @count instance variable to repeat Goodbye! count times
  • Test your goodbye page with http://localhost:3000/say/goodbye?count=5, many other count values (incl. negative and non-numeric), and with no count parameter
• Submit the files say_controller.rb, goodbye.html.erb, and routes.txt to Moodle (deadline 18:20)

Homework

Find at least 3 explanations on the Web about MVC. Read and compare them.