# プログラム実行
$ ruby sample.rb

# コメント
\# ← 1行

=begin
このように
複数行にわたって
コメントも可能
=end

# 後から戻したりする時
# コメントアウト => 注釈

# 出力
puts "Hello World”

text = "Hello World" # 変数宣言
msg # ローカル変数
$msg # グローバル変数
@msg # インスタンス変数
@@msg # クラス変数
MSG # 定数(コンスタント)

# 変数名は慣習的にスネークケースで書く
special_price

# キャメルは使わない
specialPrice

# 文字列の定義(引用符で囲む)
# 一重引用符 (中にある式や変数を展開しない)
'test'

# 一重引用符で囲むと\nはただの文字列になる
puts' こんにちは\nさようなら'
#=> こんにちは\nさようなら

# 二重引用符 (中にある式や変数を展開する)
"test"

# 二重引用符で囲むと\nが改行文字として機能する
puts "こんにちは\nさようなら"
#=> こんにちは
#   さようなら

# 文字列の式展開(文字連結よりこちらを使用)
first_name = "Michael"    # 変数の代入
"Michael"
"#{first_name} Hartl"     # 文字列の式展開
"Michael Hartl"

# 計算式も埋め込める
puts "#{5*5}"

# 一重引用符か二重引用符どちらを使用するかは、お好きな方で良い。
# チームのコーディング規約に従う

# %記法
# %q! !はシングルクオートで囲んだことと同じになる
puts %q!He said,"Don't speak."! #=> He said,"Don't speak."

# %Q! !はダブルクオートで囲んだことと同じになる(改行文字や式展開が使える)
something = "Hello."
puts %Q!He said,"#{something}"!  #=> He said,"Hello."

# %! !もダブルクオートで囲んだことと同じになる
something = " Bye."
puts %!He said,"#{something}"!  #=> He said,"Bye."

# 演算式
10 + 20 # => 30
100 - 25 # => 75
12 * 5 # => 60
20 / 5 # => 4
8 % 3 # => 2
2 ** 3 # => 8

# 整数同士の割り算は0になる
1 / 2 #=> 0

# 小数まで出したい場合は、片方もしくは両方を小数にする
1.0 / 2 #=> 0.5
1 / 2.0 #=> 0.5
1.0 / 2.0 #=> 0/5

# 配列の生成
array = [1, 2, 3] 

# イテレータ
books.each do |key, val|
  puts "#{key},#{val}円"
end

# mapメソッド(各要素に対してブロックを評価した結果を、新しい配列にして返す)
# numberの各要素を10倍にし、新しい配列new_numbersを返す
numbers = [1, 2, 3, 4, 5]
new_numbers = numbers.map{ |n| n * 10}
puts new_numbers #=> [10, 20, 30, 40, 50]

# selectメソッド(各要素に対して、ブロックを評価し、その戻り値が真の要素を集めた配列を返す)
numbers = [1, 2, 3, 4, 5, 6]
# 偶数の値のみ返す
even_numbers = numbers.select{ |n| n.even?}
even_numbers #=> [2, 4, 6]

# rejectメソッド(各要素に対して、ブロックを評価し、その戻り値が偽の要素を集めた配列を返す)
numbers = [1, 2, 3, 4, 5, 6]
# 偶数の値以外(奇数)のみ返す
even_numbers = numbers.reject{ |n| n.even?}
even_numbers #=> [1, 3, 5]

# 繰り返し計算を行う
# eachメソッドを使用した書き方
numbers = [1, 2, 3, 4]
sum = 0
numbers.each {|n| sum += n}
puts sum #=> 10

# injectメソッドを使用した書き方
numbers = [1, 2, 3, 4]
sum = numbers.inject(0) {|result, n| result + n}
# 1回目 : result=0、n=1で、0+1=1。これが次のresultに入る。 
# 2回目 : result=1、n=2で、1+2=3。この結果が次のresultに入る。
# 3回目 : result=3、n=3で、3+3=6。この結果が次のresultに入る。
# 4回目 : result=6、n=4で、6+4=10。最後の要素に達したのでこれがinjectメソッドの戻り値になる。
puts sum #=> 10

# each_with_index(配列の添字を取得する)
fruits = ['apple', 'orange', 'melon']
# ブロック引数のiには0,1,2...と要素の添字が入る
fruits.each_with_index { |fruit, i| puts "#{i},#{fruit}" }
#=> 0,apple
#=> 1,orange
#=> 2,melon

# map.with_indexでも可能
fruits.map.with_index { |fruit, i| puts "#{i},#{fruit}" }

# Rubyはデータ型が混在する配列も生成可能
person = {
  # 文字列
  name: 'Alice',
  # 数値
  age: 20,
  # 配列
  friends:['Bob','Carol'],
  # ハッシュ
  phones:{home:'1234-0000',mobile:'5678-0000'}
}

# 空のハッシュを作る
{}

# キーと値の組み合わせを3つ格納するハッシュ
{キー1 => 値1, キー2 => 値2, キー3 => 値3}
currencies = {'japan' => 'yen', 'us' => 'dollar', 'india' => 'rupee'}

# 改行可能
currencies = {
  'japan' => 'yen',
  'us' => 'dollar',
  'india' => 'rupee'}

# 要素の追加
ハッシュ[キー] = 値
currencies['italy'] = 'euro'

# 要素の取得
ハッシュ[キー]
currencies['italy'] #=> 'euro'

# 要素の削除
ハッシュ.delete(キー)
currencies.delete('italy')

# ハッシュの繰り返し処理
currencies.each do |key, value|
  puts "#{key} : #{value}"
end

# ハッシュ及び各要素の凍結
SOME_NAMES = ['Foo','Bar','Baz'].map(&:freeze).freeze

:シンボルの名前
:apple

################
# 文字列との違い
################
# クラス
'apple'.class #=> String
:apple.class #=> Symbol

# 文字列はStringオブジェクト
# シンボルはRuby内部の整数

# シンボルは文字列よりも高速に処理できる
'apple' == 'apple'
:apple == :apple

# ハッシュのキーによく使用される(文字列をキーにするよりも高速)
currencies = {
  :japan => 'yen',
  :us => 'dollar',
  :india => 'rupee'}

currencies[:italy] 

#  シンボルは「キー:値」での書き方でもハッシュを生成できる(「:コロン」の位置が逆になる)
currencies = {
  japan :'yen',
  us :'dollar',
  india :'rupee'}

# 文字列は同じ文字列でも別オブジェクト
# シンボルは同じシンボルであれば同じオブジェクトになるためメモリ効率がよい
'apple'.object_id #=> 70363037037880
'apple'.object_id #=> 70363036621920
'apple'.object_id #=> 70363044179100

:apple.object_id #=> 1159068
:apple.object_id #=> 1159068
:apple.object_id #=> 1159068

# 文字列は破壊的変更が可能(ミュータブル)
string = 'apple'
string.upcase!
string

# シンボルは破壊的変更が不可能(イミュータブル)
symbol = :apple
symbol.upcase!

# if文
if 条件A
    条件に一致した場合の処理
elsif 条件B
    条件Aと一致せず、条件Bに一致したの時の処理
else
    条件A, Bのどちらにも一致しない時の処理
end

# 通常if
point = 7
day = 1
# 1日であればポイント5倍
if day == 1
    point *= 5
end
point #=> 35

# 後値if
point = 7
day = 1
# 1日であればポイント5倍
point *= 5 if day == 1
point #=> 35

# for文(Rubyではあまり使わない)
for 変数 in オブジェクト do #doは複数行記述であれば省略可
    処理
end

# while文(Rubyではあまり使わない)
while 条件式 do #doは複数行記述であれば省略可
    処理１
end

# break文 (ループを抜ける(内側のループのみ))
numbers = [1, 2, 3, 4, 5].shuffle
numbers.each do |n|
  puts n
  # 5が出力されたらループを抜ける
  break if n == 5
end

# throw/catch文(ループを抜ける(大外のループまで抜ける))(例外処理とは関係ないので注意)
fruits = ['apple','melon','orange']
numbers = [1,2,3]
catch :done do
  fruits.shuffle.each do |fruit|
    numbers.shuffle.each do |n|
      puts "#{fruits}, #{n}"
      # 'orange'と3の組み合わせの場合
      if fruit == 'orange' && n ==3
        # 全ての処理を抜ける
        throw :done
      end
    end
  end
end

# falseまたはnilであれば偽
# それ以外は全て真

# falseまたはnil以外は真なので以下のような制御構文がかける
data = find_data 
if data
  'データがあります'
else
  'データはありません'
end

t1 = true
t2 = true
f1 = false

# OR
t1 || t2 #=> true
t1 || f1 #=> true

# AND
t1 && t2 #=> true
t1 && f1 #=> false

# !演算子で反転
!t1 #=> false

# メソッド呼び出し
オブジェクト.メソッド(引数1,引数2,引数3)

# 括弧省略可
オブジェクト.メソッド 引数1,引数2,引数3

# メソッド
def メソッド名(引数) #引数は呼び出し側からメソッドに渡される値のこと
    処理
    return 戻り値 #必要な場合のみ記述 Rubyでは主流ではない
end

# メソッド名はスネークケースで
def hello_world
   'Hello Wolrd'
end

##############################
# メソッドのキーワード引数とハッシュ
##############################
def メソッド名(キーワード引数1:デフォルト値1, キーワード引数2:デフォルト値2)
  # メソッドの実装
end

def buy_burger(menu, drink: true , potato: true)
  # ハンバーガーを購入
　　puts "#{menu}バーガーを買いました"
  if drink
    # ドリンクを購入
    puts "ドリンクを買いました"
  end
  if potato
    # ポテトを購入
    puts "ポテトを買いました"
  end
end

# キーワード引数を使う場合の呼び出し方
buy_burger('チーズ', drink: true, potato: true)
buy_burger('フィッシュ', drink: true, potato: false)

# メソッドチェーンの例
nil.to_s.empty?

# クラス
class クラス名
  メソッドなどを記述
end

# インスタンスの生成
変数 = クラス名.new

# initializeメソッドはnewした時に呼び出される(コンストラクタと同様)
class User
  def initialize
    puts 'initialized'
  end
end

User.new
#=>initialized

# インスタンスメソッドの定義と呼び出し
class User
  def hello
    "Hello!"
  end
end

user = User.new
user.hello

# アクセサメソッド(ゲッター/セッターのメソッド定義が不要になる)
class User
  # @nameを読み書きするメソッドが自動的に定義される
  attr_accessor :name
  # 読み取り専用
  attr_reader :name
  # 書き込み専用
  attr_writer :name

  def initialize(name)
    @name = name
  end
end

# クラスメソッドを定義する方法 その1
class クラス名
  def self.クラスメソッド
    # クラスメソッドの処理
  end
end

# クラスメソッドを定義する方法 その2
class クラス名
  class << self
    def クラスメソッド
      # クラスメソッドの処理
    end
  end
end

# クラスメソッドの呼び出し
クラス名.メソッド名

# クラス定数
class Product
  # 定数名(大文字と数字、アンダースコアで構成)
  DEFAULT_PRICE = 0

  attr_reader :name, :price

  def initialize(name,price = DEFAULT_PRICE)
    @name = name
    @price = price
  end
end

product = Product.new('A free movie')
product.price

# クラスの外部から定数を参照
Product::DEFAULT_PRICE #=> 0

# 継承
class Word < String             # WordクラスはStringクラスを継承する

# スーパークラスの同盟メソッドの呼び出し
class Product
  attr_reader :name, :price

  def initialize(name, price)
    @name = name
    @price = price
  end
end

class DVD < Product
  attr_reader :running_time

  def initialize(name, price, running_time)
    # スーパークラスのinitializeメソッドを呼び出す
    super(name, price)
    @running_time = running_time
  end
end

#############################################
# public => デフォルト。クラス外から自由に呼び出せる。
#############################################
class User
  def hello
    'Hello!'
  end
end

user = User.new
user.hello #=> Hello!

#############################################
# protected => そのメソッドを定義したクラス自身と、サブクラスのインスタンスメソッドからレシーバ付きで呼び出せる
# 外部には公開したくないが、同じクラスやサブクラスの中であればレシーバ付きで呼び出せるようにする時に使用
#############################################

class User
  
  # weightは外部に公開しない
  attr_reader :name

  def initialize(name, weight)
    @name = name
    @weight = weight
  end

  # 自分がother_userより重い場合はtrue
  def heavier_than?(other_user)
    other_user.weight < @weight
  end

  # protectedメソッドなので同じクラスかサブクラスであればレシーバ付きで呼び出せる
  protected
    def weight
      @weight
    end
end

alice = User.new('Alice', 50) 
bob = User.new('Bob', 60)

alice.heavier_than?(bob) #=> false
bob.heavier_than?(alice) #=> true

# クラスの外ではweightは呼び出せない
alice.weight #=>NoMethodError: protected method `weight' called for #<User:0x007fb3f485b920 @name="Alice", @weight=50>

#############################################
# private => クラス外からは呼び出せず、クラス内部でのみ使えるメソッド。
# 厳密に言うと、レシーバを指定して呼び出す事が出来ないメソッド
#############################################
class User
  private
  def hello
    'Hello!'
  end
end

user = User.new
user.hello #=> NoMethodError: private method `hello' called for #<User:0x007fc9ef130400>

# privateはサブクラスからも呼び出せる
class Product

  private
  def name
    'A great movie'
  end
end

class DVD < Product
  def to_s
    # nameはスーパークラスのprivateメソッド
    "name: #{name}"
  end
end

dvd = DVD.new
dvd.to_s #=> "name: A great movie"

# privateになるのはインスタンスメソッドだけで、クラスメソッドはprivateにならない
class User
  private

  def self.hello
    'Hello!'
  end
end

User.hello #==> "Hello!"

# ブロックによる繰り返し処理
numbers = [1,2,3,4]
sum = 0
numbers.each do |n|
  sum += n
end
puts sum #=> 10

# do...endの替わりに{}も使用できる(1行などコンパクトに書きたい時)
numbers = [1,2,3,4]
sum = 0
numbers.each {|n| sum += n}
puts sum #=> 10

# ブロック記法の例
%w[A B C].map { |char| char.downcase }
=> ["a", "b", "c"]
 %w[A B C].map(&:downcase)
=> ["a", "b", "c”]

###############################
# 基本構文
###############################
begin
  # 例外が起きうる処理
rescue => 例外オブジェクトを格納する変数
  # 例外が発生した場合の処理
ensure
  # 例外の有無関わらず実行する処理
end

###############################
# 例外オブジェクトから情報を取得したい時の構文
###############################
begin
  1 / 0
rescue => e
  puts "エラークラス: #{e.class}"
  puts "エラーメッセージ: #{e.message}"
  puts "バックトレース -----"
  puts e.backtrace
  puts "-----"
end

###############################
# クラスを指定して、補足する例外を限定
###############################
begin
  # 例外が起きうる処理
rescue 補足したい例外のクラス
  # 例外が発生した場合の処理
end

begin
  1 / 0
rescue ZeroDivisionError
  puts "0で除算しました"
end
#=> 0で除算しました

###############################
# 例外発生時に処理をやり直すretry
###############################
begin
  # 例外が起きうる処理
rescue
  retry # 処理をやりなおす
end

# 無限ループを防ぐためretryの回数は制限する
retry_count = 0
begin
  puts '処理を開始します。'
  # わざと例外を発生させる
  1 / 0
rescue
  retry_count += 1
  if retry_count <= 3
    puts "retryします。（#{retry_count}回目）"
    retry
  else
    puts 'retryに失敗しました。'
  end
end
#=> 処理を開始します。
#   retryします。（1回目）
#   処理を開始します。
#   retryします。（2回目）
#   処理を開始します。
#   retryします。（3回目）
#   処理を開始します。
#   retryに失敗しました。

###############################
# 意図的に例外を発生させるraise
###############################
def currency_of(country)
  case country
  when :japan
    'yen'
  when :us
    'dollar'
  when :india
    'rupee'
  else
    # 意図的に例外を発生させる
    raise "無効な国名です。#{country}"
  end
end

currency_of(:japan) #=> "yen"
currency_of(:italy) #=> RuntimeError: 無効な国名です。italy
###############################
# ファイル書き込み処理のサンプル
###############################
# 書き込みモードでファイルを開く
file = File.open('some.txt', 'w')

begin
  # ファイルに文字列を書き込む
  file << 'Hello'
ensure
  # 例外の有無にかかわらず必ずファイルをクローズする
  file.close
end

# ブロック付きでオープンすると、メソッドの実行後に自動的にクローズされる
# ファイル処理のように「使用したら必ずリソースを解放する」という処理は、Rubyではブロック付きのメソッドを使うことで自動的に処理できるケースが多い。
# ensureを使用する前にブロック付で処理できないかAPIドキュメントで確認する。
File.open('some.txt', 'w') do |file|
  file << 'Hello'
end

\t # タブ
\n # 改行
\” # 二重引用符
\’ # 一重引用符
\s # スペース
\nnn # 8進数表記
\xnn # 16進数表記

a = <<TEXT
これはヒアドキュメントです。
複数行に渡る長い文字列を作成するのに便利です。
TEXT

puts a

def some_method
  <<-TEXT
  これはヒアドキュメントです。
  <<-を使うと最後の識別子をインデントさせる事が出来ます。
  TEXT
end

puts some_method

# 範囲オブジェクト
a = [1,2,3,4,5]
a[1..3] #=> [2,3,4]
a[1...3] #=> [2,3]

# 条件の範囲も簡単に書き換えられる
def liquid?(temperature)
  0 <= temperature && temperature < 100
end

def liquid?(temperature)
  (0..100).include?(temperature)
end

==　# 等しい
=== # 等しい(case文)
!=　# 等しくない
>   # より大きい
>=  # 等しいか、より大きい
<   # より小さい
<=  # 等しいか、より小さい
<=> # 左 > 右(ー1) 等しい(0)大きい(1)
=~ パターンマッチ(正規表現) 一致
!~ パターンマッチ(正規表現) 一致しない

# 日付
time = Time.now
puts time.strftime("%Y/%m/%d %H:%M:%S")

# 小数
sprintf('%0.3f', 1.2) #=>"1,200"

# 1回のみの読み込み(ライブラリが変更されても、修正が反映されない)
require ライブラリ名

# Dateクラスを使用する時
require 'date'
Date.today

# 自分で作成したクラスを読み込む時
require './sample.rb'
# .rbは省略可
require './sample'

# 毎回無条件に読み込み
load ライブラリ名

# sample.txtを開いて文字列を書き込む(クローズ処理は自動的に行われる)
File.open("./sample.txt", "w") do |file|
  file.puts("1行目のテキストです。")
  file.puts("2行目のテキストです。")
  file.puts("3行目のテキストです。")
end

# モジュールの用途
・ 継承を使わずにインスタンスメソッドを追加する。もしくは上書きする。(ミックスイン)
・ 複数のクラスに対して共通の特異メソッド(クラスメソッド)を追加する(ミックスイン)
・ クラス名や定数名の衝突を防ぐために名前空間を作る。
・ 関数的メソッドを定義する
・ シングルトンオブジェクトのように扱って設定値などを保存する

# モジュールの定義
module モジュール名
  # モジュールの定義(メソッドや定数など)
end

module Greeter
  def hello
    'hello'
  end
end

########################################
# モジュールのincludeして機能を追加(追加機能はクラスのインスタンスメソッドとなる)
########################################
module Loggable
  def log(text)
    puts "[LOG] #{text}"
  end
end

class Product
  include Loggable

  def title
    log 'title is called'
    'A great movie'
  end
end

class User
  include Loggable

  def name
    log 'name is called'
    'Alice'
  end
end

product = Product.new
product.title
# [LOG] title is called
# => "A great movie"

user = User.new
user.name
# [LOG] name is called
# => "Alice"

########################################
# モジュールのextendして機能を追加(追加機能はクラスの特異(クラス)メソッドとなる)
########################################
class Product
  extend Loggable

  def self.create_products(names)
    log 'create_products is called'
  end
end

# クラスメソッド経由でlogメソッドが呼び出される
Product.create_products([])

# Productクラスのクラスメソッドとして直接呼び出す事も可能
Product.log('Hello')

########################################
# 状態を保持するモジュール例
########################################
# AwesomeApiは何らかのWeb APIを利用するライブラリ、という想定
module AwesomeApi
  # 設定値を保持するクラスインスタンス変数を用意する
  @base_url = ""
  @debug_mode = false

  # クラスインスタンス変数を読み書きするための特異メソッドを定義する
  class << self
    def base_url=(value)
      @base_url = value
    end

    def base_url
      @base_url
    end

    def debug_mode=(value)
      @debug_mode = value
    end

    def debug_mode
      @debug_mode
    end
    
    # 本来はこの1行でOK
    # attr_accessor :base_url, :debug_mode
  end
end

# 設定値を保存する
AwesomeApi.base_url = 'http://example.com'
AwesomeApi.debug_mode = true

# 設定値を参照する
AwesomeApi.base_url
AwesomeApi.debug_mode

# 正規表現はスラッシュパターンで囲んで表現
/正規表現/
# =~ でマッチした位置を返す
'123-4567' =~ /\d{3}-\d{4}/
=>0
# マッチしない場合はnilを返す
'hello' =~ /\d{3}-\d{4}/
=>nil

# キャプチャの結果に名前をつける
text = '私の誕生日は1977年7月17日です。'
m = /(?<year>\d+)年(?<month>\d+)月(?<day>\d+)日/.match(text)
m[:year]  #=> "1977"
m[:month] #=> "7"
m[:day]   #=> "17"

# scan
# 正規表現にマッチする部分を配列に入れて返す
'123 456 789'.scan(/\d+/) #=> ["123", "456", "789"]
'1977年7月17日 2016年12月31日'.scan(/\d+年\d+月\d+日/) #=> ["1977年7月17日", "2016年12月31日"]

# []
# 正規表現にマッチした部分を抜き出す
text = '郵便番号は123-4567です'
text[/\d{3}-\d{4}/] #=> "123-4567"
# sliceは[]のエイリアスメソッド
text.slice(/\d{3}-\d{4}/) #=> "123-4567"
# slice!にするとマッチした部分が文字列から破壊的に取り除かれる
text.slice!(/\d{3}-\d{4}/) #=> "123-4567"
text#=> "郵便番号はです"

# split
# マッチ位しいた文字列を区切り文字にして文字列を分解し、配列として返す
text = '123,456-789'
# 文字列で区切り位置を指定する
text.split(',')
text.split(/,|-/)

# gsub
# 第1引数の正規表現にマッチした文字列を第2引数の文字列で置き換える
text = '123,456-789'

text.gsub(',',':')
text.gsub(/,|-/,':')

# case文で正規表現を使う
text = '03-1234-5678'

case text
when /^\d{3}-\d{4}$/
  puts '郵便番号です'
when /^\d{4}\/\d{1,2}\/\d{1,2}$/
  puts '日付です'
when /^\d+-\d+-\d+$/
  puts '電話番号です'
end

####################################
# yield => メソッド時に渡されたブロックの処理を呼び出す
####################################
def greeting
  puts 'おはよう'
  # ここでブロックの処理を呼び出す
  yield
  puts 'こんばんは'
end

greeting do
  puts 'こんにちは'
end
#=> おはよう
#   こんにちは
#   こんばんは

####################################
# ブロックが渡されたかどうかを判断する場合はblock_given?メソッドを使用
####################################
def greeting
  puts 'おはよう'
  # ブロックが渡された場合のみyieldを呼び出す
  if block_given?
    yield
  end
  puts 'こんばんは'
end

greeting
#=> おはよう
#   こんばんは

greeting do
  puts 'こんにちは'
end
#=> おはよう
#   こんにちは
#   こんばんは

####################################
# Proc => ブロックをオブジェクト化するためのクラス
####################################
# "Hello!"という文字列を返すProcオブジェクトを作成する
hello_proc = Proc.new do
  'Hello!'
end

# do ... endのかわりに{}を使ってもよい
hello_proc = Proc.new { 'Hello!' }

# Procオブジェクトを実行する（文字列が返る）
hello_proc.call #=> "Hello!"

####################################
# ブロックの代わりにProcオブジェクトをメソッドの引数に渡す
####################################
def greeting(&block)
  puts 'おはよう'
  text = block.call('こんにちは')
  puts text
  puts 'こんばんは'
end

# Procオブジェクトを作成し、それをブロックの代わりとしてgreetingメソッドに渡す
repeat_proc = proc { |text| text * 2 }
greeting(&repeat_proc)
#=> おはよう
#   こんにちはこんにちは
#   こんばんは

####################################
# Proc.newとラムダの違い
####################################
# Proc.newの場合
# 引数がnilでも加算できるようにto_iメソッドを使う
add_proc = Proc.new { |a, b| a.to_i + b.to_i }
# Proc.newは引数が1つまたは3つでも呼び出しが可能
add_proc.call(10)          #=> 10
add_proc.call(10, 20, 100) #=> 30

# ラムダの場合
add_lambda = ->(a, b) { a.to_i + b.to_i }
# ラムダは個数について厳密なので、引数2個でなければエラーになる
add_lambda.call(10)
#=> ArgumentError: wrong number of arguments (given 1, expected 2)
add_lambda.call(10, 20, 30)
#=> ArgumentError: wrong number of arguments (given 3, expected 2)

# Timeクラスで日時を表すオブジェクトを作成する
# requireなしで手軽に使える。サマータイム、閏年が扱える。2038年問題解決済。
time = Time.new(2017, 1, 31, 23, 30, 59) #=> 2017-01-31 23:30:59 +0900

# dateライブラリをrequireするとDateクラスとDateTimeクラスが使えるようになる
require 'date'

# Dateクラスで日付を表すオブジェクトを作成する
date = Date.new(2017, 1, 31) #=> #<Date: 2017-01-31 ((2457785j,0s,0n),+0s,2299161j)>

# DateTimeクラスで日時を表すオブジェクトを作成する
date_time = DateTime.new(2017, 1, 31, 23, 30, 59)
#=> #<DateTime: 2017-01-31T23:30:59+00:00 ((2457785j,84659s,0n),+0s,2299161j)>

# カレントディレクトリに"secret.txt"が存在するか？
File.exists?('./secret.txt')

# カレントディレクトリに"secret_folder"が存在するか？
Dir.exists?('./secret_folder')

###################################
# FileUtilsは基本的なファイル操作をあつめたモジュール
###################################
require 'fileutils'

# libディレクトリのhello_world.txtをhello_world.rbに移動（リネーム）する
FileUtils.mv('./lib/hello_world.txt', './lib/hello_world.rb')

###################################
# PathNameはパス名をオブジェクト指向らしく扱うクラス
###################################
require 'pathname'

# カレントディレクトリ配下にあるlibディレクトリを表すオブジェクトを作る
lib = Pathname.new('./lib')

# ファイルか？
lib.file?      #=> false

# ディレクトリか？
lib.directory? #=> true

# libディレクトリ配下にあるsample.txtへのパス文字列を作る
# （区切り文字のスラッシュは自動的に付与される）
lib.join('sample.txt').to_s #=> "./lib/sample.txt"

##############
# CSV
##############
require 'csv'

# CSVファイルの出力
CSV.open('./lib/sample.csv', 'w') do |csv|
  # ヘッダ行を出力する
  csv << ['Name', 'Email', 'Age']
  # 明細行を出力する
  csv << ['Alice', '[email protected]', 20]
end

# タブ区切りのCSV(TSV)ファイルを読み込む
CSV.foreach('./lib/sample.tsv', col_sep: "\t") do |row|
  # 各行について、1列目から3列目の値をターミナルに表示する
  puts "1: #{row[0]}, 2: #{row[1]}, 3: #{row[2]}"
end

##############
# JSON
##############
# jsonライブラリをrequireすると配列やハッシュでto_jsonメソッドが使えるようになる
require 'json'

user = { name: 'Alice', email: '[email protected]', age: 20 }

# ハッシュをJSON形式の文字列に変換する（Rubyのハッシュに似ているがこれはJSON形式）
user_json = user.to_json
puts user_json #=> {"name":"Alice","email":"[email protected]","age":20}

# JSON文字列をパースしてハッシュに変換する（キーはシンボルではなく文字列になる）
JSON.parse(user_json) #=> {"name"=>"Alice", "email"=>"[email protected]", "age"=>20}

##############
# YAML
##############
require 'yaml'

# YAML形式のテキストデータを用意する
yaml = <<TEXT
alice:
  name: 'Alice'
  email: '[email protected]'
  age: 20
TEXT

# YAMLテキストをパースしてハッシュに変換する
users = YAML.load(yaml) #=> {"alice"=>{"name"=>"Alice", "email"=>"[email protected]", "age"=>20}}

# ハッシュに新しい要素を追加する
users['alice']['gender'] = :female

# ハッシュからYAMLテキストに変換する
puts YAML.dump(users)
#=> ---
#   alice:
#     name: Alice
#     email: [email protected]
#     age: 20
#     gender: :female

# byebugのインストール
gem install byebug

# この行を定義した以降がデバッグされる
require 'byebug'
byebug

# Byebugコマンド
eval + (式) 変数の値やメソッドの戻り値を表示する
s ステップイン
n ステップオーバー
fin ステップアウト
c 処理再開
help 使用可能コマンドと説明の表示
q Byebug終了