Ruby on Rails 事始め

# Ruby on Rails 事始め

Ruby on Rails が流行ってから名前は聞いていたものの全くイメージが分からず、とりあえずチュートリアルがあると分かったので勉強することにした。

参考情報：https://railstutorial.jp/

中身は非常に素晴らしい内容である。これを無料で開放してくれていることに感謝。

## Ruby on Rails とは

Ruby on Rails （単に Rails とも呼ぶ）とは WEB アプリケーション開発のためのフレームワークである。

特徴は次のとおり。

- Rails は WEB アプリケーションを構築するために有用なツールを多数兼ね備えている。
- Rails は MVC (Model-View-Controller) アーキテクチャパターンを採用している。
- Rails はブラウザからアクセスを Router で受け、Controller へ渡し（ルーティングし）、Controller が Model から取得したデータを View へ渡す。また、View から WEB レスポンスを受けてブラウザへ渡す。
- Rails ではクライアントと WEB アプリケーション間は REST を使ってデータを受け渡す。
- ```rails console``` を使うことでコマンドラインから Rails アプリケーションとやり取りできる
- ```rails test``` コマンドを使うことで Web サーバと Web アプリケーションを立ち上げて仮想 HTTP リクエストを発行するといったテストが出来る。
    - テスト駆動開発では「RED・GREEN・REFACTOR」サイクルを繰り返すが、Guard によって開発コードの変更時に即時テストを実行することが出来る。
- Rails は development, test, production の 3 種類の環境を定義しており、必要な gem パッケージやバージョンをそれぞれ設定することが出来る。
- Ruby が基本クラスを拡張定義可能であるため、Rails は基本クラスに幾つかの拡張を加えている。
    - ```blank?``` メソッド 等
- Rails は Ruby で書かれているが既に Ruby とは別物である。

実装に関する内容で、頭の整理のためにまとめた内容を記載する。

- Rails Router の動作は config/routes.rb で定義される。
- Rails では MVC は次のとおり定義される。
    - コントローラ SomeController クラスを定義する場合、some_controller.rb ファイルを作成して定義する
    - コントローラは ApplicationController クラスを継承する（Ruby では継承関係を```<```記号で表現する）
    - ApplicationController クラスは ActiveControll::Base クラスを継承している。（ActiveControll::Base クラスは Active Pack ライブラリが提供するコントローラの基本クラスである）
    - コントローラではモデルをインスタンス変数として定義できる。インスタンス変数はビューで利用できる。
        - 例えば、コントローラで ```@users = User.all``` を定義した場合、
        - ビューで ```<% @users.each do |user| %>``` 等と利用できる。
    - ビューは ERB(Embedded Ruby) と呼ばれる HTML に Ruby が埋め込まれたファイルで定義される。
    - ビューのファイル名は _アクション名.html.erb_ である。
    - モデルは ApplicationRecord クラスを継承する（Ruby では継承関係を```<```記号で表現する）
    - ApplicationRecord クラスは ActiveRecord::Base クラスを継承している。（ActiveRecord::Base クラスは Active Record が提供するモデルの基本クラスである）
- REST で主に利用する HTTP リクエストは次のとおり。
    - GET はモデルを一覧表示する
    - POST は新規でモデルを作成する
    - PATCH は既存のモデルを更新する
    - DELETE は既存のモデルを削除する
    - REST では HTTP リクエストにより操作方法（作成・更新・削除）を指定し、対象となるデータは URL のパス（/somemodel/1 はモデルのid=1を指す等）及び HTTP ペイロードで表す。
- Rails ではモデル定義を元に ```db:migrate``` コマンドにより DB とテーブルを作成できる。
- Active Record によりモデルの関連を示すことが出来る。それにより、モデルの関係を利用した値の参照を行うと、それに対応する DB のテーブルに対するクエリ発行を行うことが出来る。
- Rails ではモデルにデータのバリデーションチェックが設定できる

## Ruby

## Rails におけるファイル構造早見表

_<>_で括った箇所は WEB アプリケーションによって変わる。
定義される元となるデータは括弧内に記述する。

- app/ ： WEB アプリケーションの MVC やヘルパーなどの主要なアプリケーションコードを格納するディレクトリ
    - assets/ ： アプリケーションで使う CSS, JavaScript ファイル、画像等の資源（アセット）を保管するディレクトリ
    - views/ ： MVC のビューを定義する ERB ファイルを保管するディレクトリ
        - layout/ ： ビューの各レイアウトを格納するディレクトリ
            - application.html.erb ： 全ファイル共通のレイアウトファイルを記載するファイル
        - _<コントローラ名>_ ： コントローラ名はクラス名から Controller を除いたもの。
            - \__<部分テンプレート名>_.html.erb ： 部分テンプレート（アンダースコアから始まるファイル名）
            - \__<部分テンプレート名>_.html.erb
            - ・・・
            - \__<テンプレート名>_.html.erb ： テンプレート名は要するにビューファイル（ERB 形式）。ファイル名は暗黙的に対応するコントローラのアクション名となる。コントローラで render メソッドを使って明示可能。
        - _<コントローラ名>_
- bin/ ： バイナリ実行可能ファイルを保管するディレクトリ
    - rails/ ： コード生成、コンソールの起動、ローカルの WEB サーバの立ち上げなどで使う Rails スクリプト
- config/ ： WEB アプリケーションの設定を保管するディレクトリ
- db/ ： データベース関連のファイルを保管するディレクトリ
- doc/ ： マニュアルなど、アプリケーションのドキュメントを保管するディレクトリ
- lib/ ： ライブラリモジュールを保管するディレクトリ
    - assets/ ： ライブラリで使う CSS, JavaScript ファイル、画像等の資源（アセット）を保管するディレクトリ
- log/ ： アプリケーションのログファイル
- public ： エラーページ等、Webブラウザ等に直接公開するデータ
- test/ ： アプリケーションテストのための設定を保管するディレクトリ
    - controllers/ ： コントローラテストのための設定を保管するディレクトリ
        - _<コントローラ名>_ ： コントローラ名はクラス名のファイル名の最後に _test が付いたもの。（拡張子は .rb）
        - ・・・
- tmp/ ： 一時ファイルを保管するディレクトリ
- vendor ： サードパーティ製のプラグインや gem 等を保管するディレクトリ
    - assets ： サードパーティ製のプラグインや gem で使う CSS, JavaScript ファイル、画像等の資源（アセット）を保管するディレクトリ
- README.md ： アプリケーションの簡単な説明（Mark Down 形式。GitHub 等でリポジトリブラウズすると MarkDown を解釈して HTML 表示される）
- Rakefile ： rake コマンドで使えるタスク
- Gemfile ： このアプリケーションに必要な Gem の定義ファイル
- Gemfile.lock ： アプリケーションで使われる gem のバージョンを確認するためのリスト
- config.ru ： Rack ミドルウェア用の設定ファイル
- .gitignore ： Git に取り込みたくないファイルを指定するためのパターンファイル


### Rails Router について

Rails Router はブラウザからのアクセスを受けて、適切なコントローラのアクションを実行する（ディスパッチする）役割を担う。

ファイルは config/routes.rb で定義される。

```rb:URLパスをルートで指定された場合のアクセスをコントローラのindexメソッドへ渡す場合
Rails.application.routes.draw do
  root 'application#index'
end
```

```rb:URLパス/micropost/*をMicropostsコントローラへ渡したい場合
Rails.application.routes.draw do
  resource :microposts
  root 'application#index'
end
```

REST を使いたい場合は ```resource``` を使い、表示するだけであれば get と覚えておくとよい。

get リクエストを受けた場合等、リクエストコードを指定する場合は get と記述する。

```rb:HTTPのGETメソッドでURLのパスを指定してコントローラにディスパッチする例
Rails.application.routes.draw do
  get 'static_pages/home'
  get 'static_pages/help'
```

上記は、URLのパス/static_pages/homeへアクセスした場合は、StaticPages コントローラの home メソッドを実行する。また、URLのパス/static_pages/helpへアクセスした場合は、StaticPages コントローラの help メソッドを実行する。




### ビューの render メソッドについて

コントローラでも render メソッドが使える。コントローラで render メソッドを使う方法は、本ページ内 [コントローラの render メソッドについて](#render_method_for_controller) を参照のこと。

ビュー内の render メソッドは部分テンプレートを呼び出すために使う。部分テンプレートとは共通のビューの表示を別ファイルとしてまとめておいたものである。

部分テンプレートはファイル名がアンダースコア ```_``` から始まり、html.erb で終わる。

例）部分テンプレートを form とする場合、ファイル名は ```_form.html.erb``` となり、render からは ```<%= render 'form', user: @user %>``` で呼び出される。

#### render メソッドでオブジェクトを渡す

部分テンプレートへ ```user``` オブジェクトを渡す。

```erb:edit.html.erb(ビューからform部分テンプレートを呼び出す例)
<h1>Editing User</h1>

<%= render 'form', user: @user %>

<%= link_to 'Show', @user %> |
<%= link_to 'Back', users_path %>
```

```erb:_form.html.erb(form部分テンプレートの例)
<%= form_with(model: user, local: true) do |form| %>
  <% if user.errors.any? %>
    <div id="error_explanation">
      <h2><%= pluralize(user.errors.count, "error") %> prohibited this user from being saved:</h2>

      <ul>
      <% user.errors.full_messages.each do |message| %>
        <li><%= message %></li>
      <% end %>
      </ul>
    </div>
  <% end %>

  <div class="field">
    <%= form.label :name %>
    <%= form.text_field :name, id: :user_name %>
  </div>

  <div class="field">
    <%= form.label :email %>
    <%= form.text_field :email, id: :user_email %>
  </div>

  <div class="actions">
    <%= form.submit %>
  </div>
<% end %>
```



### ビューの link_to メソッドについて

★未記載

### コントローラの before_action メソッドについて

before_action メソッドでは、アクションを実行する前に特定のメソッドを実行することが出来る。
例えば、ユーザがログインする前にログイン画面へ遷移する等を行う等、
アクションを実行するための前提となる処理を記述することが出来る。

```rb:before_actionの記述方法（コントローラ名がUserControllerの場合）
class UserController < ApplicationController
  before_action :<メソッド名>
  ・・・
  def <メソッド名>
  ・・・
  end
end
```

上記により、UserController のアクションを実行する前に <メソッド名> を実行することが出来る。アクションを実行するメソッドは外部から実行されないことが多く、その場合は private でスコープをクラス内に閉じるとよい。

全てのアクションに対して before_action を実行させたくない場合は only, except フィルタを使って対象を絞る。
尚、将来的にメソッドが追加された場合を考慮して、only, except を使い分けるとよい。

_※ only で指定すると将来的にメソッドが追加された場合に、そのメソッドに対して before\_action は実行されない。_

_※ except で指定すると将来的にメソッドが追加された場合に、そのメソッドに対して before\_action は実行される。_

```rb:before_actionの記述方法（コントローラ名がUserControllerの場合）
class UserController < ApplicationController
  before_action :set_user, only: [:show, :edit, :update, :destroy]
  ・・・
  def <メソッド名>
  ・・・
  end
end
```

_※TIPS：アクションとはルーティング時においてコントローラの機能を実行する時の機能名である。アクションは、コントローラクラスにおいて同一名のメソッドとして定義される。_

<a name="render_method_for_controller"></a>
### コントローラの render メソッドについて

コントローラの render メソッドは、ビューを指定する場合に使用する。
render メソッドは省略することも可能であり、その場合、暗黙的にビュー名はコントローラのアクション名となる。

```rb:viewアクションで使用するビュー名をapp/views/hello/special.html.erbファイルを指定する
class UsersController < ApplicationController
  ・・・
  def view
    @msg = 'こんにちは、世界！'
    render 'hello/special'
  end
  ・・・
end
```

```rb:viewアクションで使用するビュー名はapp/views/users/view.html.erbファイルを指定する
class UsersController < ApplicationController
  ・・・
  def view
    @msg = 'こんにちは、世界！'
  end
  ・・・
end
```


### Rails コマンドについて

```rails generate``` コマンドでコントローラやモデル等を作成することが出来る。失敗したら ```rails destroy``` コマンドで削除できる。

尚、*コントローラを削除するときには作成時の引数を正確に指定する*こと。モデルの削除では作成時の引数は不要。

```shell-session:StaticPagesコントローラをhome,helpアクション付きで生成
$ rails generate controller StaticPages home help
```

```shell-session:StaticPagesコントローラをhome,helpアクション付きで生成したものを削除
$ rails destroy controller StaticPages home help
```

```shell-session:Userモデルをname(文字列),email(文字列)プロパティを持つよう生成
$ rails generate model User name:string email:string
```

```shell-session:Userモデルを削除
$ rails destroy model User
```


DB のマイグレーションは実行する度にバージョン番号が採番されるため、一番初めに戻す場合は VERSION=0 を指定する。直近に戻すには rollback を使う。

```shell:モデルからDB構造を作成する
$ rails db:migration
```

```shell:DBを元に戻す
$ rails db:rollback
```

```shell:DBを初期化する（VERSIONで任意の世代に戻す）
$ rails db:migration VERSION=0
```


### Rails 環境の構築方法について

やったこと（Vagrant で Ubuntu Desktop 環境を利用）

- vagrant box から Ubuntu Desktop 環境を用意
    - ```vagrant init yuki-takei/ubuntu-xenial64-ja```
    - ```vagrant up```
- Rails 実行に必要なパッケージをインストール
    - ```apt-get install zlib1g-dev```
    - ```apt-get install ruby-full```
        - 先に ruby-full をインストールして zlib が足りないと言われたら再インストールする。（参考情報：https://qiita.com/aTaroAsari/items/9be9f905772637fecef6）
    - ```apt-get install git```
    - ```apt-get install libsqlite3-dev```
        - rails new 実行時に必要。実行時に足りない
- JavaScript 実行環境をインストールする。
    - ExecJS から辿って JavaScript ランタイムをインストールする
        - Node.js をインストールすることにした。
            - ```curl -sL https://deb.nodesource.com/setup_8.x | sudo -E bash -```
            - ```sudo apt-get install -y nodejs```
- VS Code をインストールする（必要に応じて）
    - ```curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.gpg```
    - ```sudo mv microsoft.gpg /etc/apt/trusted.gpg.d/microsoft.gpg```
    - ```sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/vscode stable main" > /etc/apt/sources.list.d/vscode.list'```
    - 拡張機能で ```ruby``` をインストールする。（補間機能や、クラス・メソッド定義箇所へ移動することが出来る）



### minitest/reporters について

minitest/reporters によりテスト結果表示を変更することが出来る。

### ヘルパーについて

#### カスタムヘルパーについて

Rails のビューでは組み込み関数が既定されているが、自作することもできる。自作した関数をカスタムヘルパーと呼ぶ。

ヘルパー関数は ```app/helpers/application_helper.rb``` ファイルで定義する。

```rb:app/helpers/application_helper.rb
・・・
module ApplicationHelper

  # ページごとの完全なタイトルを返します。
  def full_title(page_title = '')
    base_title = "Ruby on Rails Tutorial Sample App"
    if page_title.empty?
      base_title
    else
      page_title + " | " + base_title
    end
  end
end
・・・
```

module は関連したメソッドをまとめる方法の1つであり、include メソッドを使って module を読み込むことが出来る。Rails では自動的にヘルパーモジュールを読み込んでくれるため、include を書く必要はない。


### Ruby Console について

Ruby Console は Rails アプリケーションを対話的に操作するためのコマンドラインツールである。

Ruby Console は IRB: Interactive RuBy を拡張して作られているため、Ruby の機能を全て使うことが出来る。

```rails console``` コマンドを実行すると Rails Console を起動できる。

起動するとシェルのようなプロンプト画面が表示される。
このプロンプト画面で Ruby を実行することで Rails アプリケーションを操作できる。

- 文字列はダブルクォートまたはシングルクォートの組み合わせで括ることで表せる
    - シングルクォートで括ると式の展開は行われない。
- シャープ(#)以降は改行までをコメントと解釈する
- 文字列の結合は + で行う。
- 文字列内で変数を展開する場合は「#{変数名}」を使う
- ```=>``` 以降に戻り値が出力される。


```rb:Rails_Console実行例
vagrant@vagrant:~/Projects/rails-sample_app$ rails console
Running via Spring preloader in process 22672
Loading development environment (Rails 5.1.2)
>> 17 + 42   # 整数の足し算
=> 59
>> ""         # 空の文字列
=> ""
>> "foo"      # 空ではない文字列
=> "foo"
>> "foo" + "bar"    # 文字列の結合
=> "foobar"
>> first_name = "Michael"    # 変数の代入
=> "Michael"
>> "#{first_name} Hartl"     # 文字列の式展開
=> "Michael Hartl"
>> first_name = "Michael"
=> "Michael"
>> last_name = "Hartl"
=> "Hartl"
>> first_name + " " + last_name    # 苗字と名前の間に空白を入れた結合
=> "Michael Hartl"
>> "#{first_name} #{last_name}"    # 式展開を使って結合 (上と全く同じ)
=> "Michael Hartl"
>> puts "foo"     # 文字列を出力する
foo
=> nil
>> 
```

### よく使いそうな Ruby のメソッドや制御文

```rb:if文
>> s = "foobar"
=> "foobar"
>> if s.nil?
>>   "The variable is nil"
>> elsif s.empty?
>>   "The string is empty"
>> elsif s.include?("foo")
>>   "The string includes 'foo'"
>> end
=> "The string includes 'foo'"
```

```rb:論理演算子
>> x = "foo"
=> "foo"
>> y = ""
=> ""
>> puts "Both strings are empty" if x.empty? && y.empty?
=> nil
>> puts "One of the strings is empty" if x.empty? || y.empty?
One of the strings is empty
=> nil
>> puts "x is not empty" if !x.empty?
x is not empty
=> nil
```

```rb:nilチェック
>> "foo".nil?
=> false
>> "".nil?
=> false
>> nil.nil?
=> true
```


```rb:文字列の長さを確認
>> "foobar".length
=> 6
```

```rb:文字列が空であるかどうか調べる
>> "foobar".empty?
=> false
>> "".empty?
=> true
>> "".blank?
=> true
```

```rb:メソッドの定義
>> def string_message(str = '')
>>   if str.empty?
>>     "It's an empty string!"
>>   else
>>     "The string is nonempty."
>>   end
>> end
=> :string_message
>> puts string_message("foobar")
The string is nonempty.
>> puts string_message("")
It's an empty string!
>> puts string_message
It's an empty string!
```

メソッドの定義の補足

- 仮引数には初期値を設定できる（str = '' の部分。空文字列を初期値としている。）
- メソッドには暗黙の戻り値があり、最後に評価された式の値が自動的に返される。


```rb:配列
>> a = [42, 8, 17]
=> [42, 8, 17]
>> a[0]               # Rubyでは角カッコで配列にアクセスする
=> 42
>> a[1]
=> 8
>> a[2]
=> 17
>> a[-1]              # 配列の添字はマイナスにもなれる!
=> 17

>> a                  # 配列「a」の内容を確認する
=> [42, 8, 17]
>> a.length           # 配列の長さ（要素数）
=> 3
>> a.first
=> 42
>> a.second
=> 8
>> a.last
=> 17
>> a.last == a[-1]    # == を使って比較する
=> true

>> a
=> [42, 8, 17]
>> a.empty?
=> false
>> a.include?(42)
=> true
>> a.sort
=> [8, 17, 42]
>> a.reverse
=> [17, 8, 42]
>> a.shuffle
=> [17, 42, 8]
>> a
=> [42, 8, 17]

>> a
=> [42, 8, 17]
>> a.sort!           # 配列をソートする（配列自体を変更する破壊的メソッド。慣習として末尾に ! がつく）
=> [8, 17, 42]
>> a
=> [8, 17, 42]

>> a
=> [42, 8, 17]
>> a.push(6)                  # 6を配列に追加する
=> [42, 8, 17, 6]
>> a << 7                     # 7を配列に追加する
=> [42, 8, 17, 6, 7]
>> a << "foo" << "bar"        # 配列に連続して追加する
=> [42, 8, 17, 6, 7, "foo", "bar"]

>> a
=> [42, 8, 17, 6, 7, "foo", "bar"]
>> a.join                       # 単純に連結する
=> "4281767foobar"
>> a.join(', ')                 # カンマ+スペースを使って連結する
=> "42, 8, 17, 6, 7, foo, bar"
```


```rb:文字列を分割して配列に変換（区切り文字のデフォルトは空白文字）
>>  "foo bar     baz".split     # 文字列を3つの要素を持つ配列に分割する
=> ["foo", "bar", "baz"]
>> "fooxbarxbazx".split('x')
=> ["foo", "bar", "baz"]
```


```rb:範囲
>> 0..9
=> 0..9
>> 0..9.to_a              # おっと、9に対してto_aを呼んでしまっていますね
NoMethodError: undefined method `to_a' for 9:Fixnum
>> (0..9).to_a            # 丸カッコを使い、範囲オブジェクトに対してto_aを呼びましょう
=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>> a = %w[foo bar baz quux]         # %wを使って文字列の配列に変換
=> ["foo", "bar", "baz", "quux"]
>> a[0..2]
=> ["foo", "bar", "baz"]

>> a = (0..9).to_a
=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>> a[2..(a.length-1)]               # 明示的に配列の長さを使って選択
=> [2, 3, 4, 5, 6, 7, 8, 9]
>> a[2..-1]                         # 添字に-1を使って選択
=> [2, 3, 4, 5, 6, 7, 8, 9]

>> ('a'..'e').to_a
=> ["a", "b", "c", "d", "e"]
```


```rb:ブロック
>> (1..5).each { |i| puts 2 * i }
2
4
6
8
10
=> 1..5

>> (1..5).each do |i|
?>   puts 2 * i
>> end
2
4
6
8
10
=> 1..5

>> (1..5).each do |number|
?>   puts 2 * number
>>   puts '--'
>> end
2
--
4
--
6
--
8
--
10
--
=> 1..5

>> 3.times { puts "Betelgeuse!" }   # 3.timesではブロックに変数を使っていない
"Betelgeuse!"
"Betelgeuse!"
"Betelgeuse!"
=> 3
>> (1..5).map { |i| i**2 }          # 「**」記法は冪乗 (べき乗) 
=> [1, 4, 9, 16, 25]
>> %w[a b c]                        # %w で文字列の配列を作成
=> ["a", "b", "c"]
>> %w[a b c].map { |char| char.upcase }
=> ["A", "B", "C"]
>> %w[A B C].map { |char| char.downcase }
=> ["a", "b", "c"]

>> %w[A B C].map { |char| char.downcase }
=> ["a", "b", "c"]
>> %w[A B C].map(&:downcase)        # “symbol-to-proc”記法
=> ["a", "b", "c"]
```

_短い1行のブロックには波括弧を使い、長い1行や複数行のブロックには do..end 記法を使うのが Ruby の慣習である。_


```rb:ハッシュ
>> user = {}                          # {}は空のハッシュ
=> {}
>> user["first_name"] = "Michael"     # キーが "first_name" で値が "Michael"
=> "Michael"
>> user["last_name"] = "Hartl"        # キーが "last_name" で値が "Hartl"
=> "Hartl"
>> user["first_name"]                 # 要素へのアクセスは配列の場合と似ている
=> "Michael"
>> user                               # ハッシュのリテラル表記
=> {"last_name"=>"Hartl", "first_name"=>"Michael"}

>> user = { "first_name" => "Michael", "last_name" => "Hartl" }
=> {"last_name"=>"Hartl", "first_name"=>"Michael"}
```

***ハッシュは要素の順序が保証されない***。順序が重要な場合は配列を使うこと。


```rb:シンボル
>> "name".split('')
=> ["n", "a", "m", "e"]
>> :name.split('')
NoMethodError: undefined method `split' for :name:Symbol
>> "foobar".reverse
=> "raboof"
>> :foobar.reverse
NoMethodError: undefined method `reverse' for :foobar:Symbol
>> :foo-bar
NameError: undefined local variable or method `bar' for main:Object
>> :2foo
SyntaxError

>> user = { :name => "Michael Hartl", :email => "michael@example.com" }
=> {:name=>"Michael Hartl", :email=>"michael@example.com"}
>> user[:name]              # :name に対応する値にアクセスする
=> "Michael Hartl"
>> user[:password]          # 未定義のキーに対応する値にアクセスする
=> nil

>> h1 = { :name => "Michael Hartl", :email => "michael@example.com" }
=> {:name=>"Michael Hartl", :email=>"michael@example.com"}
>> h2 = { name: "Michael Hartl", email: "michael@example.com" }  # Ruby 1.9 からサポートされた記法
=> {:name=>"Michael Hartl", :email=>"michael@example.com"}
>> h1 == h2
=> true

>> params = {}        # 'params' というハッシュを定義する ('parameters' の略)。
=> {}
>> params[:user] = { name: "Michael Hartl", email: "mhartl@example.com" }
=> {:name=>"Michael Hartl", :email=>"mhartl@example.com"}
>> params
=> {:user=>{:name=>"Michael Hartl", :email=>"mhartl@example.com"}}
>>  params[:user][:email]
=> "mhartl@example.com"

>> flash = { success: "It worked!", danger: "It failed." }
=> {:success=>"It worked!", :danger=>"It failed."}
>> flash.each do |key, value|
?>   puts "Key #{key.inspect} has value #{value.inspect}"
>> end
Key :success has value "It worked!"
Key :danger has value "It failed."
```

- ```=>``` をハッシュロケットと呼ぶ。
- シンボルは文字列と似ているが、クォートで囲む代わりにコロンが前におかれる。
- Rails では文字列よりシンボルを使う方が普通である。
- シンボルは Ruby 以外ではごく一部の言語にしか採用されていない特殊なデータ形式である。
- シンボル名は文字列と同じく任意の名前を付けることが出来る。（参考情報：[Ruby 2.4.0 リファレンスマニュアル > リテラル](https://docs.ruby-lang.org/ja/2.4.0/doc/spec=2fliteral.html#symbol)）
    - 例）```:name```, ```:"foo-bar"```, ```:"1forAll"```

```rb:様々な省略
stylesheet_link_tag 'application', media: 'all',
                                   'data-turbolinks-track': 'reload'

# メソッド呼び出しの丸カッコは省略可能。
stylesheet_link_tag('application', media: 'all',
                                   'data-turbolinks-track': 'reload')
stylesheet_link_tag 'application', media: 'all',
                                   'data-turbolinks-track': 'reload'

# 最後の引数がハッシュの場合、波カッコは省略可能。
stylesheet_link_tag 'application', { media: 'all',
                                     'data-turbolinks-track': 'reload' }
stylesheet_link_tag 'application', media: 'all',
                                   'data-turbolinks-track': 'reload'


>> s = String.new("foobar")   # 文字列の名前付きコンストラクタ
=> "foobar"
>> s.class
=> String
>> s == "foobar"
=> true
>> s = "foobar"       # ダブルクォートは実は文字列のコンストラクタ
=> "foobar"
>> s.class
=> String

>> a = Array.new([1, 3, 2])
=> [1, 3, 2]
>> a = [1, 3, 2]
=> [1, 3, 2]
```

## Ruby におけるオブジェクト指向

- クラスの継承は ```<``` を使う。
- クラス内で自身のインスタンスにアクセスする場合は self を使う。
- Ruby では組み込みの基本クラスの拡張が可能である。

```rb:Stringクラスにpalindrome?(回文チェック)メソッドを拡張定義する
>> class String
>>   # 文字列が回文であればtrueを返す
>>   def palindrome?
>>     self == self.reverse
>>   end
>> end
=> :String
>> "deified".palindrome?
=> true
```

- クラスをインスタンス化するメソッドは ```initialize``` で定義される。
- インスタンス変数は @ 記号から始まる変数名で示される。
- getter, setter を設定する際、```attr_accessor``` を指定する。

```rb:Userクラスの定義
class User
  attr_accessor :name, :email

  def initialize(attributes = {})
    @name  = attributes[:name]
    @email = attributes[:email]
  end
end
```


----

# 参考情報

Rail についての話に直接関わることはないが、Rails チュートリアルにも書かれているとおり実際の開発現場では Git 等のバージョン管理を行うことは必須である。そこで、参考情報として git の使い方の一連の流れを記載することとする。（Pull Request と呼ばれる優秀な

## git の使い方

リポジトリは GitHub を使い、master は直接いじらずに必ずブランチを切って Pull Request を作成してから master にマージすることを前提とする。

_※GitHub の Hello World の記事を参考にして Pull Request の出し方やリポジトリの作成、ブランチの切り方とコミットの仕方を学ぶとよい。_

1. GitHub でリポジトリを作成する
1. GitHub のリポジトリをクローンする
    - ```git clone 'https://github.com/<github_account>/<repository_name>' <repository_name>```
1. リポジトリのブランチを作成する
    - ```git branch <branch_name>```
    - ブランチ名は接頭辞に次の項目をつけると分かりやすい。
        - feat ： 小・中規模の機能要件を追加
        - imprv ： 改善
        - hotfix ： バグ修正
1. リポジトリのブランチを切り替える
    - ```git checkout <branch_name>```
1. リポジトリを初期化する
    - ```rails new <repository_name>```
1. ソースコードを修正する
1. 修正をコミットしてリポジトリへプッシュする
    - ```git commit -am "Some Comment."```
    - ```git push -u origin <branch_name>```


# 本記事に対するコメントを受けて修正した履歴とお礼

修正した該当箇所に記述しようかとも思いましたが、文章がごちゃごちゃすると思い、また指摘を受けたコメントに近い箇所に修正履歴を載せた方が読みやすいと思ったので、修正履歴を記事の最後に記載することにさせてもらいました。

- 2017/10/23 scivola さんよりシンボル名は文字列と同じく、任意の名前を付けることが出来る（空文字列のシンボルも作れる）とコメントにて指摘を頂いたので、「文字列と違って全ての文字が使える訳ではないので注意が必要。」の記述を修正しました。ご指摘ありがとうございました。