© 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
• Scaffolding
• REST
• Web APIs
• Today's exercises

MVC and Scaffolding

• We have created controllers (with actions and views) and models (with field:type instructions)
• Scaffolding creates all of MVC, in a way that makes basic operations on the data easy.
• The command for scaffolding is:
  rails generate scaffold wrestler field1:type1 field2:type2 ...
• Fields and types are exactly the same as for the rails generate model command.
• ... scaffold wrestler ... generates:
  • The controller in app/controllers/wrestlers_controlller.rb
    with 7 actions and some private methods
  • The model in app/models/wrestler.rb (class Wrestler)
  • 4 view files (edit/index/new/show.html.erb) and one common template (_form.html.erb) in the app/views/wrestlers directory
  • Other files e.g. for testing

Scaffolding and CRUD

Scaffolding creates actions that correspond to the database CRUD operations:

Scaffolding additionally creates the following actions:

• index for showing all data of a model
• new to show a form for entering data for a new model item
• edit to show a form to edit existing data

Scaffolding and REST

• REST: Representational state transfer
• Proposed as a model for Web architecture by Roy Fielding in 2000
• Core: Uniform access to resorces via representations
• HTTP can be used as an 'implementation' of REST
• Uniform access is obtained via the HTTP methods GET, POST, PUT, and DELETE
• Sometimes the methods are 'faked' (browsers e.g. do not allow a real DELETE)

HTTP: GET vs. POST

HTTP: POST vs. PUT

Resource Routing

• Rails easily allows to define routes to a resource, with a single line in routes.rb:
  resources :wrestlers
• This creates 8 routes, as show in the table below.
• Routes can be checked with rails routes.
• Such consistent URIs for all resources are part of Convention over Configuration.
• Such consistent URIs are very important for a good Web application architecture.

Example Flow for Update

• Browser requests /wrestlers/123/edit with GET
• Controller sets @wrestler with data for wrestler 123
• View edit.html.erb creates form that PUTs to /wrestlers/123
• Form submission is routed to update action
• update action redirects to /wrestlers/123, using show.html.erb

Web APIs

• A Web site can be accessed by a browser
• A Web site can also be accessed by another program to:
  • Download HTML (this is often called scraping or crawling)
  • Download data (data formats: XML, JSON)
• The data access point is called Web API (application programming interface)
• Using REST to structure Web API is highly recommended
• It is easy to create Web APIs using Rails

XML and JSON

<items>
  <item>
    <id>1</id>
    <title>Buy bread</title>
  </item>
</items>

Resource vs. Representation

• Examples of resources:
  • (data on) a wrestler, an actor/actress
  • (data on) today's weather
• Examples of representations:
  • A wrestler's data expressed in HTML, in a Japanese Web page
  • An actor's/actress' data expressed in JSON
  • The weather on June 10, 2019, expressed in XML
• Representations of the same resource can vary by:
  • Time (weather)
  • Format (HTML/XML/JSON/...)
  • Language (English/Japanese/...)
  • ...
• Content negotiation allows the requester to indicate which representation is desired:
  • Accept header for formats
  • Accept-Language header for language
• The URI should stay the same for different representations (useful for bookmarks,...)
• The URI should be different for different resources

How to Use builder with Rails

• Code goes into files show.xml.builder,... in app/views/...s subdirectory
• No need for require in view file
• Builder object is available as variable xml
• Data is available e.g. as @wrestler (in show....) or @wrestlers (in index....)
• Use xml.instruct! at the start
• For nesting elements, use xml.element_name do ... end
• For elements with string content, use xml.element_name string_content
• For URIs, use item_url(..., format: :xml)
• For examples, see https://richonrails.com/articles/outputting-xml-using-ruby-on-rails

How to Use Net::HTTP

• There are many libraries to access Web pages and Web APIs from programs
• Net::HTTP is such a library
• Connections to a Web site can be created with Net::HTTP.start(host [, port])
• Request objects can be created with request = Net::HTTP::Get.new('/...')
• Request headers (header fields) can be set with request[header_name] = header_value
• The response can be obtained with http.request(request)
• Response code, message, and body are available with response.code,...

Exercise 9a: Use Scaffold to Create a Todo Application

• Create a new rails application named todo.
• Generate a scaffold for items. Each item has a title (string), a description (text), and a due_time (datetime).
• Initialize the database with rails db:migrate.
• Start the server.
• Use a browser to check out all the functionality generated by scaffold. Create, modify, and delete some items.
• Make sure you have 5 realistic todo items in your database.
• Access the .json versions of some of your items with your browser.
• Access and download the .json version of all your items, and submit it to Moodle as the file 9a_items.json (deadline: 17:00).

Exercise 9b: Create an XML API

• Remove the file Gemfile.lock in your application.
• Add the line gem 'builder' to the Gemfile (preferably just after jbuilder).
• Run the command bundler install.
• In items_controller.rb, add the necessary code for .xml in parallel to .json.
• Create the view files show.xml.builder and index.xml.builder. Make sure you output all the data (same data as .json).
• Access the xml views with a browser. (There may be a message about missing style information. You can ignore it.)
• Submit the files items_controller.rb, show.xml.builder, and index.xml.builder to Moodle (deadline: 17:45).

Exercise 9c: Use the JSON API

• Create a Ruby program in a file 9c_todo_api.rb in a folder separate from your todo application.
• This program downloads and displays todo item data:
  • Without command line parameter, it displays all items.
  • With an integer as a command line parameter, it displays the item with the number as the id.
• Require the net/http and json libraries.
• Do NOT use a .json extension. Use the request header Accept: application/json to request data in JSON.
• Print out the response code and the response message.
• If the response code is not 200, print an error message and exit the program.
• Use JSON.parse to convert the response body to a JSON object, which can be accesses as a hash or an array of hashes.
• Print all information in the JSON, in a way that is easy to understand.
• Submit the file 9c_todo_api.rb to Moodle (deadline: 18:30).

Homework

• Carefully study the files generated by scaffold, in particular items_controller.rb. Be ready to explain each and every single line in that file.
• Prepare for a ~30 minute written test.