サンプルコードでわかる！Ruby 2.4の新機能と変更点

# aはbに等しい
assert_equal b, a

# aはnil
assert_nil a

# aは真（true、またはnilでもfalseでもない値）
assert a

# aは偽（nilまたはfalse）
refute a

# a.foo() を実行するとFooErrorが発生する
assert_raises(FooError) { a.foo() }

# 呼び出された時点でテストを失敗させる
flunk

def some_method_returning_array_or_nil(flag)
  flag ? [1, 2] : nil
end

def test_multiple_assignment_in_conditional_expression
  # 配列が返ると真と判定される
  if (a, b = some_method_returning_array_or_nil(true))
    assert true
  else
    flunk 'should be true'
  end
  
  # nilが返ると偽と判定される
  if (a, b = some_method_returning_array_or_nil(false))
    flunk 'should be false'
  else
    assert true
  end
end

def test_unify_Fixnum_and_Bignum_into_Integer
  assert_equal Integer, 1.class
  assert_equal Integer, -1.class
  assert_equal Integer, 10000000000000000000000000000.class
  assert_equal Integer, -10000000000000000000000000000.class
end

Fixnum
#=> Integer

Bignum
#=> Integer

def test_unify_Fixnum_and_Bignum_into_Integer
  a = 1
  
  assert a.kind_of?(Integer)
  assert a.kind_of?(Fixnum)
  assert a.kind_of?(Bignum)
  
  assert a.is_a?(Integer)
  assert a.is_a?(Fixnum)
  assert a.is_a?(Bignum)
  
  assert Integer === a
  assert Fixnum === a
  assert Bignum === a
end

class ::Fixnum
  def foo
    'foo'
  end
  def baz
    'baz'
  end
end

class ::Bignum
  def bar
    'bar'
  end
  def baz
    'baz!!'
  end
end

def test_extend_Integer
  a = 1
  assert_equal 'foo', a.foo
  assert_equal 'bar', a.bar
  assert_equal 'baz!!', a.baz
end

irb(main):001:0> Fixnum
(irb):1: warning: constant ::Fixnum is deprecated
=> Integer
irb(main):002:0> Bignum
(irb):2: warning: constant ::Bignum is deprecated
=> Integer

[1, 2, 3, 4].sum
#=> 10

[].sum
#=> 0

[1, 2, 3, 4].sum(5)
#=> 15

[0.1, 0.1, 0.1].sum
#=> 0.30000000000000004

# 要素が3の場合、誤差は同じ
[0.1, 0.1, 0.1].sum
#=> 0.30000000000000004
0.1 + 0.1 + 0.1
#=> 0.30000000000000004

# 要素が6の場合は+の方が誤差がない
[0.1, 0.1, 0.1, 0.1, 0.1, 0.1].sum
#=> 0.6000000000000001
0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1
#=> 0.6

# 要素が10の場合はsumの方が誤差がない
array = Array.new(10, 0.1)
array.sum
#=> 1.0
# 素直に+で書くとコードが長くなるのでinjectで代用
array.inject(:+)
#=> 0.9999999999999999

# 要素が99999の場合はsumの方が誤差が小さい
array = Array.new(99999, 0.1)
array.sum
#=> 9999.900000000001
array.inject(:+)
#=> 9999.900000018848

['foo', 'bar'].sum('')
#=> 'foobar'

['foo', 'bar'].sum('>>')
#=> '>>foobar'

[[1, 2], [3, 1, 5]].sum([])
#=> [1, 2, 3, 1, 5]

def test_non_ascii_upcase_downcase_swapcase_capitalize
  assert_equal 'TÜRKIYE', 'Türkiye'.upcase
  assert_equal 'türkiye', 'Türkiye'.downcase
  assert_equal 'tÜRKIYE', 'Türkiye'.swapcase
  assert_equal 'Ürkiye', 'ürkiye'.capitalize

  # 破壊的メソッドも同じ挙動になる
  a = 'Türkiye'
  a.upcase!
  assert_equal 'TÜRKIYE', a
end

'Türkiye'.upcase(:ascii)
#=> "TüRKIYE"

:"".match(//) 
# => 0

m = :"".match(//) 
#=> #<MatchData "">
m[0]
#=> ""

def test_date_time_to_time
  require 'date'
  cet_date_time = DateTime.strptime('2015-11-12 CET', '%Y-%m-%d %Z')
  assert_equal '2015-11-12 00:00:00 +0100', cet_date_time.to_time.to_s
end

def test_time_to_time
  cet_time = Time.new(2005, 2, 21, 10, 11, 12, '+01:00')
  assert_equal '2005-02-21 10:11:12 +0100', cet_time.to_time.to_s
end

# 実行環境がJSTだと、to_timeの結果もJSTになる（Ruby 2.3以前）
DateTime.strptime('2015-11-12 CET', '%Y-%m-%d %Z').to_time.to_s
#=> "2015-11-12 08:00:00 +0900"

Time.new(2005, 2, 21, 10, 11, 12, '+01:00').to_time.to_s
#=> "2005-02-21 18:11:12 +0900"

require 'benchmark/ips'

Benchmark.ips do |bench|
  NUMS = 1_000_000.times.map { rand }

  # By binding the Enumerable method to our array
  # we can bench the previous speed in Ruby 2.3
  ENUM_MIN  = Enumerable.instance_method(:min).bind(NUMS)

  # Bind the `#min` method to our test array also
  # so our benchmark code is as similar as possible
  ARRAY_MIN = Array.instance_method(:min).bind(NUMS)

  bench.report('Array#min') do
    ARRAY_MIN.call
  end

  bench.report('Enumerable#min') do
    ENUM_MIN.call
  end

  bench.compare!
end

# >> Warming up --------------------------------------
# >>            Array#min     3.000  i/100ms
# >>       Enumerable#min     2.000  i/100ms
# >> Calculating -------------------------------------
# >>            Array#min     35.147  (± 2.8%) i/s -    177.000  in   5.039133s
# >>       Enumerable#min     21.839  (± 4.6%) i/s -    110.000  in   5.040531s
# >> Comparison:
# >>            Array#min:       35.1 i/s
# >>       Enumerable#min:       21.8 i/s - 1.61x slower

def test_comparable_clamp
  # 下限が1、上限が3で2が渡された場合 => 範囲内なのでそのまま2を返す
  assert_equal 2, 2.clamp(1, 3)
  # 下限が1、上限が3で0が渡された場合 => 下限値の1を返す
  assert_equal 1, 0.clamp(1, 3)
  # 下限が-2、上限が-1で0が渡された場合 => 上限値の-1を返す
  assert_equal -1, 0.clamp(-2, -1)
  # 下限が'a'、上限が'b'で'c'が渡された場合 => 上限値の'b'を返す
  assert_equal 'b', 'c'.clamp('a', 'b')
end

2.clamp(3, 1)
#=> ArgumentError: min argument must be smaller than max argument

def test_clone_with_freeze_keyword_option
  a = 'A'.freeze
  assert a.frozen?
  # デフォルトではfreeze状態もcloneされる
  assert a.clone.frozen?
  # cloneはするがfreezeはしない
  refute a.clone(freeze: false).frozen?
end

def test_ceil_floor_truncate
  # 切り上げ
  assert_equal 2, 1.11.ceil
  assert_equal -1, -1.11.ceil
  assert_equal 1.2, 1.11.ceil(1)
  assert_equal -1.1, -1.11.ceil(1)
  # 負の値も指定可能
  assert_equal 11120, 11111.ceil(-1)
  assert_equal -11110, -11111.ceil(-1)

  # 切り下げ
  assert_equal 1, 1.99.floor
  assert_equal -2, -1.99.floor
  assert_equal 1.9, 1.99.floor(1)
  assert_equal -2, -1.99.floor(1)
  # 負の値も指定可能
  assert_equal 11110, 11119.floor(-1)
  assert_equal -11120, -11119.floor(-1)

  # 切り捨て（0から自身までの数値で、自身にもっとも近い整数または小数を返す）
  assert_equal 1, 1.99.truncate
  assert_equal -1, -1.99.truncate
  assert_equal 1.9, 1.99.truncate(1)
  assert_equal -1.9, -1.99.truncate(1)
  # 負の値も指定可能
  assert_equal 190, 199.truncate(-1)
  assert_equal -190, -199.truncate(-1)
end

123.digits
#=> [3, 2, 1]

0x7b.digits(16)
#=> [11, 7]

123.digits(16)
#=> [11, 7]

-123.digits
#=> Math::DomainError: out of domain

def test_regexp_match?
  # match?メソッドはグローバル変数の$~を変更しない
  assert /\d+-\d+-\d+/.match?('2016-09-01')
  assert_nil $~

  # 以下のメソッドは$~を変更する
  assert /\d+-\d+-\d+/.match('2016-09-01')
  assert_equal '2016-09-01', $~[0]

  assert /\d+-\d+-\d+/ =~ '2016-09-02'
  assert_equal '2016-09-02', $~[0]

  assert /\d+-\d+-\d+/ === '2016-09-03'
  assert_equal '2016-09-03', $~[0]
end

'2016-09-01'.match?(/\d+-\d+-\d+/)
#=> true

:hello_world.match?(/\w+_\w+/)
#=> true

def test_match_data_named_captures
  m = /(?<year>\d+)-(?<month>\d+)-(?<day>\d+)/.match('2016-09-01')
  assert_equal(
      {'year' => '2016', 'month' => '09', 'day' => '01'},
      m.named_captures
  )
end

def test_match_data_values_at
  m = /(?<year>\d+)-(?<month>\d+)-(?<day>\d+)/.match('2016-09-01')
  assert_equal(['2016', '01'], m.values_at(1, 3))
  # Ruby 2.4からは文字列またはシンボルで名前を指定可能
  assert_equal(['2016', '01'], m.values_at('year', 'day'))
  assert_equal(['2016', '01'], m.values_at(:year, :day))
end

require 'benchmark/ips'

Benchmark.ips do |bench|
  bench.report("Without capacity") do
    append_me = ' ' * 1_000
    template  = String.new

    100.times { template << append_me }
  end

  bench.report("With capacity") do
    append_me = ' ' * 1_000
    template  = String.new(capacity: 100_000)

    100.times { template << append_me }
  end

  bench.compare!
end

# >> Warming up --------------------------------------
# >>     Without capacity     1.690k i/100ms
# >>        With capacity     3.204k i/100ms
# >> Calculating -------------------------------------
# >>     Without capacity     16.031k (± 7.4%) i/s -    160.550k in  10.070740s
# >>        With capacity     37.225k (±18.0%) i/s -    362.052k in  10.005530s
# >>
# >> Comparison:
# >>        With capacity:    37225.1 i/s
# >>     Without capacity:    16031.3 i/s - 2.32x slower

def test_string_with_capacity
  a = String.new(capacity: 1)
  a << '12345'
  assert_equal '12345', a
end

def test_unicode_9_0
  assert "A\u{17000}B".match(/\p{Tangut}/)
end

def test_enumerable_uniq
  # 値に'Athens'が2回登場している
  olimpics = {
      1896 => 'Athens',
      1900 => 'Paris',
      1904 => 'Chikago',
      1906 => 'Athens',
      1908 => 'Rome'
  }
  # 同じ値なら重複していると見なす
  each_city_first_time = olimpics.uniq { |k, v| v }
  # 1896の'Athens'だけが残る
  assert_equal [
      [1896, "Athens"],
      [1900, "Paris"],
      [1904, "Chikago"],
      [1908, "Rome"]
  ], each_city_first_time
end

olimpics.uniq! { |k, v| v }
#=> undefined method `uniq!' for #<Hash:0x007fa9f505bb48>

# 2乗して10で割った余りを重複の判定条件にする
(1..Float::INFINITY).lazy.uniq { |x| (x**2) % 10 }.first(6)
#=> [1, 2, 3, 4, 5, 10]

def test_hash_transform_values
  x = {a: 1, b: 2, c: 3}
  # ハッシュの値を2乗する
  y = x.transform_values {|v| v ** 2 }
  assert_equal({a: 1, b: 4, c: 9}, y)
  # 変数xの中身は変わっていない
  assert_equal({a: 1, b: 2, c: 3}, x)

  # 破壊的メソッドを適用すると変数xの中身が変わる
  x.transform_values! {|v| v ** 2 }
  assert_equal({a: 1, b: 4, c: 9}, x)
end

def test_dir_empty?
  Dir.mktmpdir do |dir|
    assert Dir.empty?(dir)
  end
end

def test_file_empty?
  require 'tempfile'
  Tempfile.create("foo") do |f|
    assert File.zero?(f)
    # empty?はzero?のエイリアスメソッド
    assert File.empty?(f)
  end
end

"Johnson, Dwayne",Dwayne "The Rock" Johnson

"Johnson, Dwayne","Dwayne ""The Rock"" Johnson"

def test_csv_liberal_parsing_option
  require 'csv'
  
  # ダブルクオートを使った不正なフォーマットのCSVデータを用意する
  input = '"Johnson, Dwayne",Dwayne "The Rock" Johnson'
  
  # liberal_parsingオプションなしだとエラー
  assert_raises(CSV::MalformedCSVError) { CSV.parse_line(input) }
  
  # liberal_parsingオプションありだとパース可能
  assert_equal(
      ['Johnson, Dwayne', 'Dwayne "The Rock" Johnson'],
      CSV.parse_line(input, liberal_parsing: true)
  )
end

def test_logger_options
  require 'logger'
  formatter = proc { |severity, timestamp, progname, msg| "#{severity}:#{msg}\n\n" }
  logger = Logger.new(
      STDERR,
      level: :info,
      progname: :progname,
      formatter: formatter,
      datetime_format: "%d%b%Y@%H:%M:%S"
  )
  assert_equal Logger::INFO, logger.level
  assert_equal :progname, logger.progname
  assert_equal formatter, logger.formatter
  assert_equal "%d%b%Y@%H:%M:%S", logger.datetime_format
end

logger = Logger.new($stdout)
logger.level = :info

require 'logger'
# development.log.2016-09-01
# development.log.2016-09-01.1
# development.log.2016-09-01.2
# のような名前のログファイルを出力する
logger = Logger.new('development.log', shift_period_suffix: '%Y-%m-%d')

def test_optparse_into_option
  require 'optparse'
  require 'optparse/date'
  require 'optparse/uri'

  cli =
      OptionParser.new do |options|
        options.define '--from=DATE',    Date
        options.define '--url=ENDPOINT', URI
        options.define '--names=LIST',   Array
      end

  config = {}

  args = %w[
    --from  2016-02-03
    --url   https://blog.blockscore.com/
    --names John,Daniel,Delmer
  ]

  # パースした結果を変数configに格納する
  cli.parse(args, into: config)

  assert_equal(
      {
          from: Date.parse('2016-02-03'),
          url: URI('https://blog.blockscore.com/'),
          names: %w(John Daniel Delmer)
      },
      config
  )
end

def without_flag
  puts 'Starting some parallel work'
  thread =
      Thread.new do
        sleep 0.1
        fail 'something very bad happened!'
      end
  sleep 0.2
  puts 'Done!'
end
# フラグ無しで実行すると、エラーが報告されない
without_flag
#=> Starting some parallel work
#=> Done!

def with_flag
  # フラグにtrueをセットする
  Thread.report_on_exception = true
  
  puts 'Starting some parallel work'
  thread =
      Thread.new do
        sleep 0.1
        fail 'something very bad happened!'
      end
  sleep 0.2
  puts 'Done!'
end
# フラグありで実行すると、エラーが報告される
with_flag
#=> Starting some parallel work
#=> #<Thread:0x007fe1731faf20@(irb):66 run> terminated with exception:
#=> (irb):68:in `block in bar': something very bad happened! (RuntimeError)
#=> Done!

Thread.current.name = "MainThread!"
z = Thread.new{Thread.stop}
a, b = Thread.new { 1 until b; b.join }, Thread.new { 1 until a; a.join }
a.name = "aaaaa"
b.name = "bbbbb"
z.name = "zzzz"
a.join

fatal: No live threads left. Deadlock?
4 threads, 4 sleeps current:0x007fd8c1c06b30 main thread:0x007fd8c1c06b30
* #<Thread:0x007fd8c207cce8@MainThread! sleep_forever>
   rb_thread_t:0x007fd8c1c06b30 native:0x007fff776aa000 int:0
   (irb):7:in `join'
   (irb):7:in `irb_binding'
   /Users/jit/.rbenv/versions/2.4.0-preview2/lib/ruby/2.4.0/irb/workspace.rb:87:in `eval'
   /Users/jit/.rbenv/versions/2.4.0-preview2/lib/ruby/2.4.0/irb/workspace.rb:87:in `evaluate'
   (省略)
* #<Thread:0x007fd8c3843070@zzzz@(irb):2 sleep_forever>
   rb_thread_t:0x007fd8c3029b10 native:0x00700000108000 int:0
   (irb):2:in `stop'
   (irb):2:in `block in irb_binding'
* #<Thread:0x007fd8c284a7e0@aaaaa@(irb):3 sleep_forever>
   rb_thread_t:0x007fd8c1f34170 native:0x0070000020b000 int:0
    depended by: tb_thread_id:0x007fd8c1c06b30
    depended by: tb_thread_id:0x007fd8c1de2060
   (irb):3:in `join'
   (irb):3:in `block in irb_binding'
* #<Thread:0x007fd8c284a6f0@bbbbb@(irb):3 sleep_forever>
   rb_thread_t:0x007fd8c1de2060 native:0x0070000030e000 int:0
    depended by: tb_thread_id:0x007fd8c1f34170
   (irb):3:in `join'
   (irb):3:in `block in irb_binding'

	from (irb):7:in `join'
	from (irb):7
	from /Users/jit/.rbenv/versions/2.4.0-preview2/bin/irb:11:in `<main>'

fatal: No live threads left. Deadlock?
	from (irb):19:in `join'
	from (irb):19
	from /Users/jit/.rbenv/versions/2.3.1/bin/irb:11:in `<main>'

# rescue修飾子付きのコードを ( ) で囲んでメソッドの引数として渡す
p (nil.split rescue nil)
#=> nil

# デフォルト（0.5は必ず切り上げ）
12.5.round
# => 13
13.5.round
#=> 14

# 偶数丸め
12.5.round(half: :even)
#=> 12
13.5.round(half: :even)
#=> 14

# Ruby 2.4
125.round(-1, half: :even)
#=> 120
135.round(-1, half: :even)
#=> 140

(125r / 10).round(half: :even)
#=> 12
(135r / 10).round(half: :even)
#=> 14

# irbをrequireする
require 'irb'

s = 'hello'
puts s

# ここでirbを開く
binding.irb

puts 'bye'

def test_finite_infinite
  assert 1.finite?
  refute 1.infinite?

  assert 1.0.finite?
  refute 1.0.infinite?

  assert 1r.finite?
  refute 1r.infinite?

  assert Complex(1).finite?
  refute Complex(1).infinite?
end

def test_array_concat
  assert [1, 2, 3, 4, 5, 6], [1, 2].concat([3, 4], [5, 6])
end

def test_hash_compact
  hash = { a: 1, b: nil, c: 2 }
  
  assert_equal({ a: 1, c: 2 }, hash.compact)
  assert_equal({ a: 1, b: nil, c: 2 }, hash)
  
  assert_equal({ a: 1, c: 2 }, hash.compact!)
  assert_equal({ a: 1, c: 2 }, hash)
end

def test_numerable_chunk
  assert_instance_of Enumerator, [1, 2, 3].chunk
end

def test_set_compare_by_identity
  require 'set'
  
  set = Set.new
  values = ['a', 'a', 'b', 'b']
  set.merge(values)
  refute set.compare_by_identity?
  assert_equal ['a', 'b'], set.to_a

  set = Set.new
  values = ['a', 'a', 'b', 'b']
  set.compare_by_identity
  set.merge(values)
  assert set.compare_by_identity?
  assert_equal ['a', 'a', 'b', 'b'], set.to_a
end

def test_string_concat
  s = 'a'
  assert_equal 'abc', s.concat('b', 'c')
  assert_equal 'abc', s

  s = 'z'
  assert_equal 'xyz', s.prepend('x', 'y')
  assert_equal 'xyz', s
end

def test_casecmp?
  assert 'abc'.casecmp?('ABC')
  refute 'abc'.casecmp?('DEF')
  
  assert :abc.casecmp?(:ABC)
  refute :abc.casecmp?(:DEF)
end

assert_equal 0, 'abc'.casecmp('ABC')
assert_equal -1, 'abc'.casecmp('DEF')
assert_equal 0, :abc.casecmp(:ABC)
assert_equal -1, :abc.casecmp(:DEF)

def test_unpack1
  # unpackは配列を返す
  assert_equal [65, 66, 67], "ABC".unpack("C*")
  
  # unpackは1要素目だけを返す
  assert_equal 65, "ABC".unpack1("C*")
end

def test_pathname_empty?
  require 'tempfile'
  require 'pathname'
  
  Dir.mktmpdir do |dir|
    assert Pathname(dir).empty?
  end
  
  Tempfile.create("foo") do |f|
    assert Pathname(f).empty?
  end
end

def test_io_readlines
  require 'tempfile'
  tf = Tempfile.new("foo")
  tf.print "abc\ndef\nghi\n"
  tf.close

  File.open(tf.path) do |f|
    # chompせずに読み込む
    assert_equal ["abc\n", "def\n", "ghi\n"], f.readlines
    
    f.rewind
    
    # chompして読み込む
    assert_equal ["abc", "def", "ghi"], f.readlines(chomp: true)
  end
ensure
  tf&.unlink
end

# refineされるモジュール
module Awesome
  def xxx
    'awesome'
  end
end

# モジュールをrefineするモジュール
module SuperAwesome
  refine Awesome do
    def xxx
      # superは元のモジュールのメソッドを呼び出す
      "not #{super} but super-awesome"
    end
  end
end

using SuperAwesome

class Person
  include Awesome

  def say
    "I am #{xxx}!"
  end
end

class RefinementsTest < Minitest::Test
  def test_module_refinements
    person = Person.new
    assert_equal 'I am not awesome but super-awesome!', person.say
  end
end

module StringPugs
  refine String do
    def pugs
      "Pugs!"
    end
  end
end

using StringPugs

class RefinementsTest < Minitest::Test
  def test_symbol_to_proc
    assert_equal ['Pugs!', 'Pugs!'], ['a', 'b'].map(&:pugs)
  end
end

require 'minitest/autorun'

module StringPugs
  refine String do
    def pugs
      "Pugs!"
    end
  end
end

using StringPugs

class RefinementsTest < Minitest::Test
  def test_send
    assert_equal 'Pugs!', 'a'.send(:pugs)
  end
end

module StringPugs
  refine String do
    def pugs
      "Pugs!"
    end
  end
end

# Refinementsで使った1つ目のモジュール
using StringPugs

module Awesome
  def xxx
    'awesome'
  end
end

module SuperAwesome
  refine Awesome do
    def xxx
      "not #{super} but super-awesome"
    end
  end
end

# Refinementsで使った2つ目のモジュール
using SuperAwesome

class Person
  include Awesome

  def say
    "I am #{xxx}!"
  end
end

class RefinementsTest < Minitest::Test
  def test_used_modules
    assert_equal [StringPugs, SuperAwesome], Module.used_modules
  end
end

module Warning
  # これはRuby 2.4で追加されたメソッドのオーバーライド
  def self.warn(msg)
    warnings << msg
    super
  end

  # これは独自に追加したクラスメソッド
  def self.warnings
    @warnings ||= []
  end
end

class WarningTest < Minitest::Test
  def setup
    Warning.warnings.clear
  end

  def test_warn
    # 警告を発生させるため、わざとFixnumクラスを参照する
    assert Fixnum == Integer
    
    # 出力された警告をちゃんと保持しているかどうかの検証
    assert_equal 1, Warning.warnings.size
    msg = Warning.warnings.first
    assert msg.include?('warning: constant ::Fixnum is deprecated')
  end
end

# Ruby 2.4
class Warning
end
#=> TypeError: Warning is not a class

# Ruby 2.3
require 'shellwords'

# この結果はおかしい
Shellwords.shellsplit(%q|printf "%s\\n"|)
#=> ["printf", "%sn"]

# これはOK
Shellwords.shellsplit(%q|printf '%s\\n'|)
#=> ["printf", "%s\\n"]

# Ruby 2.4
require 'shellwords'

# どちらもOK
Shellwords.shellsplit(%q|printf "%s\\n"|)
#=> ["printf", "%s\\n"]

Shellwords.shellsplit(%q|printf '%s\\n'|)
#=> ["printf", "%s\\n"]

def test_ipaddr_compare
  require 'ipaddr'
  # Ruby 2.3以前ではIPAddr::InvalidAddressErrorが発生していた
  refute IPAddr.new("1.1.1.1") == "sometext"
end