scaruby 0.0.5 → 0.0.6

data/spec/scaruby/core_ext/hash_spec.rb

@@ -1,92 +1,92 @@
-# -*- encoding: utf-8 -*-
-
-require 'scaruby/core_ext'
-
-describe Hash do
-
-  hash = {123 => 'abc', 234 => 'bcd', 345 => 'cde', 4 => 'd', 56 => 'ef', 7 => 'g', 89 => 'hi' }
-
-  it 'has #contains' do
-    hash.contains(123).should eq(true)
-    hash.contains(999).should eq(false)
-  end
-  it 'has #count' do
-    hash.count {|k,v| k.to_s.length >= 2 }.should eq(5)
-  end
-  it 'hash Map.empty' do
-    Map.empty.should eq({})
-  end
-  it 'has #exists' do
-    hash.exists {|k,v| k.to_s.length == 1 }.should eq(true)
-  end
-  it 'has #filter' do
-    hash.filter {|k,v| k.to_s.length < 3 }.to_hash.size.should eq(4)
-  end
-  it 'has #filter_keys' do
-    hash.filter_keys {|k| k.to_s.length < 3 }.to_hash.size.should eq(4)
-  end
-  it 'has #filter_not' do
-    hash.filter_not {|k,v| k.to_s.length < 3 }.to_hash.to_s.should eq('{123=>"abc", 234=>"bcd", 345=>"cde"}')
-  end
-  it 'has #find' do
-    # the already defined method is called
-    #hash.find {|k,v| k.to_s.length == 2 }.get[1].should eq('ef')
-    hash.find {|k,v| k.to_s.length == 2 }[1].should eq('ef')
-  end
-  it 'has #forall' do
-    hash.forall {|k,v| k.to_s.length <= 3 }.should eq(true)
-    hash.forall {|k,v| k.to_s.length >= 2 }.should eq(false)
-  end
-  it 'has #foreach' do
-    hash.foreach do |k,v| 
-      hash.include?(k).should eq(true)
-    end
-  end
-  it 'has #get_or_else' do
-    hash.get_or_else(123, 'xxx').should eq('abc')
-    hash.get_or_else(999, 'xxx').should eq('xxx')
-  end
-  it 'has #is_empty' do
-    hash.is_empty.should eq(false)
-    {}.is_empty.should eq(true)
-  end
-  it 'has #key_set' do
-    hash.key_set.should eq(hash.keys)
-  end
-  it 'has #lift' do
-    lifted = hash.lift
-    lifted.apply(123).get.should eq('abc')
-    lifted.apply(999).is_defined.should eq(false)
-    lifted.call(123).get.should eq('abc')
-    lifted.call(999).is_defined.should eq(false)
-  end
-  it 'has #map' do
-    # the already defined method is called
-    #new_map = hash.map {|k,v| [k+k,v] }.to_hash
-    #new_map.include?(246).should eq(true)
-    seq = hash.map {|k,v| [k+k,v] }
-    seq.include?([246,'abc']).should eq(true)
-  end
-  it 'has #minus' do
-    hash.minus(123,234,345).to_hash.should eq({4=>'d',56=>'ef',7=>'g',89=>'hi'})
-  end
-  it 'has #mk_string' do
-    hash.mk_string().should eq('{123=>abc, 234=>bcd, 345=>cde, 4=>d, 56=>ef, 7=>g, 89=>hi}')
-  end
-  it 'has #non_empty' do
-    hash.non_empty.should eq(true)
-    {}.non_empty.should eq(false)
-  end
-  it 'has #plus' do
-    {123=>'abc',234=>'bcd'}.plus([[345,'cde']]).to_hash.should eq({123=>'abc',234=>'bcd',345=>'cde'})
-  end
-  it 'has #updated' do
-    {123=>'abc',234=>'bcd'}.updated(345,'cde').to_hash.should eq({123=>'abc',234=>'bcd',345=>'cde'})
-  end
-  it 'has #unzip' do
-    unzipped = {123=>'abc',234=>'bcd'}.unzip.to_a
-    unzipped[0].should eq([123,234])
-    unzipped[1].should eq(['abc','bcd'])
-  end
-end
-
+# -*- encoding: utf-8 -*-
+
+require 'scaruby/core_ext'
+
+describe Hash do
+
+  hash = {123 => 'abc', 234 => 'bcd', 345 => 'cde', 4 => 'd', 56 => 'ef', 7 => 'g', 89 => 'hi'}
+
+  it 'has #contains' do
+    hash.contains(123).should eq(true)
+    hash.contains(999).should eq(false)
+  end
+  it 'has #count' do
+    hash.count { |k, v| k.to_s.length >= 2 }.should eq(5)
+  end
+  it 'hash Map.empty' do
+    Map.empty.should eq({})
+  end
+  it 'has #exists' do
+    hash.exists { |k, v| k.to_s.length == 1 }.should eq(true)
+  end
+  it 'has #filter' do
+    hash.filter { |k, v| k.to_s.length < 3 }.to_hash.size.should eq(4)
+  end
+  it 'has #filter_keys' do
+    hash.filter_keys { |k| k.to_s.length < 3 }.to_hash.size.should eq(4)
+  end
+  it 'has #filter_not' do
+    hash.filter_not { |k, v| k.to_s.length < 3 }.to_hash.to_s.should eq('{123=>"abc", 234=>"bcd", 345=>"cde"}')
+  end
+  it 'has #find' do
+    # the already defined method is called
+    #hash.find {|k,v| k.to_s.length == 2 }.get[1].should eq('ef')
+    hash.find { |k, v| k.to_s.length == 2 }[1].should eq('ef')
+  end
+  it 'has #forall' do
+    hash.forall { |k, v| k.to_s.length <= 3 }.should eq(true)
+    hash.forall { |k, v| k.to_s.length >= 2 }.should eq(false)
+  end
+  it 'has #foreach' do
+    hash.foreach do |k, v|
+      hash.include?(k).should eq(true)
+    end
+  end
+  it 'has #get_or_else' do
+    hash.get_or_else(123, 'xxx').should eq('abc')
+    hash.get_or_else(999, 'xxx').should eq('xxx')
+  end
+  it 'has #is_empty' do
+    hash.is_empty.should eq(false)
+    {}.is_empty.should eq(true)
+  end
+  it 'has #key_set' do
+    hash.key_set.should eq(hash.keys)
+  end
+  it 'has #lift' do
+    lifted = hash.lift
+    lifted.apply(123).get.should eq('abc')
+    lifted.apply(999).is_defined.should eq(false)
+    lifted.call(123).get.should eq('abc')
+    lifted.call(999).is_defined.should eq(false)
+  end
+  it 'has #map' do
+    # the already defined method is called
+    #new_map = hash.map {|k,v| [k+k,v] }.to_hash
+    #new_map.include?(246).should eq(true)
+    seq = hash.map { |k, v| [k+k, v] }
+    seq.include?([246, 'abc']).should eq(true)
+  end
+  it 'has #minus' do
+    hash.minus(123, 234, 345).to_hash.should eq({4 => 'd', 56 => 'ef', 7 => 'g', 89 => 'hi'})
+  end
+  it 'has #mk_string' do
+    hash.mk_string().should eq('{123=>abc, 234=>bcd, 345=>cde, 4=>d, 56=>ef, 7=>g, 89=>hi}')
+  end
+  it 'has #non_empty' do
+    hash.non_empty.should eq(true)
+    {}.non_empty.should eq(false)
+  end
+  it 'has #plus' do
+    {123 => 'abc', 234 => 'bcd'}.plus([[345, 'cde']]).to_hash.should eq({123 => 'abc', 234 => 'bcd', 345 => 'cde'})
+  end
+  it 'has #updated' do
+    {123 => 'abc', 234 => 'bcd'}.updated(345, 'cde').to_hash.should eq({123 => 'abc', 234 => 'bcd', 345 => 'cde'})
+  end
+  it 'has #unzip' do
+    unzipped = {123 => 'abc', 234 => 'bcd'}.unzip.to_a
+    unzipped[0].should eq([123, 234])
+    unzipped[1].should eq(['abc', 'bcd'])
+  end
+end
+

data/spec/scaruby/io_spec.rb

@@ -1,56 +1,56 @@
-# -*- encoding: utf-8 -*-
-
-require 'scaruby'
-
-describe Scaruby::IO::Source do
-
-  http_url = 'http://seratch.github.com/'
-  https_url = 'https://github.com/seratch/scaruby'
-
-  it 'has from_file' do
-    file = 'spec/scaruby_spec.rb'
-    source = Source.from_file(file)
-    source.to_seq.foreach do |c|
-      line.is_a?(String).should eq(true)
-    end
-    lines = source.get_lines
-    lines.is_a?(Enumerable).should eq(true)
-    lines.foreach do |line|
-      line.is_a?(String).should eq(true)
-    end
-  end
-  it 'has from_bytes' do
-    str = 'zzz 日本語を含む文字列 999'
-    bytes = str.bytes.to_a
-    source = Source.from_bytes(bytes)
-    source.to_seq.foreach do |c|
-      c.is_a?(String).should eq(true)
-    end
-    source.get_lines.mk_string.should eq(str)
-  end
-  it 'has from_url with a http url' do
-    source = Source.from_url(http_url)
-    source.to_seq.foreach do |c|
-      c.is_a?(String).should eq(true)
-    end
-  end
-  it 'has from_url with a https url' do
-    source = Source.from_url(https_url)
-    source.to_seq.foreach do |c|
-      c.is_a?(String).should eq(true)
-    end
-  end
-  it 'has #get_lines' do
-    source = Source.from_url(http_url,'Shift_JIS')
-    source.get_lines.foreach do |line|
-      line.is_a?(String).should eq(true)
-    end
-  end
-  it 'has #to_seq' do
-    source = Source.from_url(http_url)
-    source.to_seq.foreach do |c|
-      c.is_a?(String).should eq(true)
-    end
-  end
-
-end
+# -*- encoding: utf-8 -*-
+
+require 'scaruby'
+
+describe Scaruby::IO::Source do
+
+  http_url = 'http://seratch.github.com/'
+  https_url = 'https://github.com/seratch/scaruby'
+
+  it 'has from_file' do
+    file = 'spec/scaruby_spec.rb'
+    source = Source.from_file(file)
+    source.to_seq.foreach do |c|
+      line.is_a?(String).should eq(true)
+    end
+    lines = source.get_lines
+    lines.is_a?(Enumerable).should eq(true)
+    lines.foreach do |line|
+      line.is_a?(String).should eq(true)
+    end
+  end
+  it 'has from_bytes' do
+    str = 'zzz 日本語を含む文字列 999'
+    bytes = str.bytes.to_a
+    source = Source.from_bytes(bytes)
+    source.to_seq.foreach do |c|
+      c.is_a?(String).should eq(true)
+    end
+    source.get_lines.mk_string.should eq(str)
+  end
+  it 'has from_url with a http url' do
+    source = Source.from_url(http_url)
+    source.to_seq.foreach do |c|
+      c.is_a?(String).should eq(true)
+    end
+  end
+  it 'has from_url with a https url' do
+    source = Source.from_url(https_url)
+    source.to_seq.foreach do |c|
+      c.is_a?(String).should eq(true)
+    end
+  end
+  it 'has #get_lines' do
+    source = Source.from_url(http_url, 'UTF-8')
+    source.get_lines.foreach do |line|
+      line.is_a?(String).should eq(true)
+    end
+  end
+  it 'has #to_seq' do
+    source = Source.from_url(http_url)
+    source.to_seq.foreach do |c|
+      c.is_a?(String).should eq(true)
+    end
+  end
+
+end

data/spec/scaruby/map_spec.rb

@@ -1,117 +1,117 @@
-# -*- encoding: utf-8 -*-
-
-require 'scaruby'
-
-describe Map do
-
-  hash = {123 => 'abc', 234 => 'bcd', 345 => 'cde', 4 => 'd', 56 => 'ef', 7 => 'g', 89 => 'hi' }
-
-  it 'does not accept invalid args' do
-    begin
-      map = Map.new(1234)
-      raise 'Expected exception did not be raised!'
-    rescue AssertionError
-    end
-  end
-
-  it 'has self.new' do
-    map = Map.new({1 => 'a', 2 => 'b'})
-    map.should_not eq(nil)
-  end 
-
-  # as a sub type of Hash
-  it 'has #each' do
-    expected_key = 1
-    expected_value = 10
-    returned = Map.new({1=>10,2=>20}).each do |k,v|
-      k.should eq(expected_key)
-      v.should eq(expected_value)
-      expected_key += 1
-      expected_value += 10
-    end
-    returned.should eq(nil)
-  end
-
-  # defined
-  it 'has #contains' do
-    Map.new(hash).contains(123).should eq(true)
-    Map.new(hash).contains(999).should eq(false)
-  end
-  it 'has #count' do
-    Map.new(hash).count {|k,v| k.to_s.length >= 2 }.should eq(5)
-  end
-  it 'hash Map.empty' do
-    Map.empty.should eq({})
-  end
-  it 'has #exists' do
-    Map.new(hash).exists {|k,v| k.to_s.length == 1 }.should eq(true)
-  end
-  it 'has #filter' do
-    Map.new(hash).filter {|k,v| k.to_s.length < 3 }.to_hash.size.should eq(4)
-  end
-  it 'has #filter_keys' do
-    Map.new(hash).filter_keys {|k| k.to_s.length < 3 }.to_hash.size.should eq(4)
-  end
-  it 'has #filter_not' do
-    Map.new(hash).filter_not {|k,v| k.to_s.length < 3 }.to_hash.to_s.should eq('{123=>"abc", 234=>"bcd", 345=>"cde"}')
-  end
-  it 'has #find' do
-    Map.new(hash).find {|k,v| k.to_s.length == 2 }.get[1].should eq('ef')
-  end
-  it 'has #forall' do
-    Map.new(hash).forall {|k,v| k.to_s.length <= 3 }.should eq(true)
-    Map.new(hash).forall {|k,v| k.to_s.length >= 2 }.should eq(false)
-  end
-  it 'has #foreach' do
-    returned = Map.new(hash).foreach do |k,v| 
-      hash.include?(k).should eq(true)
-    end
-    returned.should eq(nil)
-  end
-  it 'has #get_or_else' do
-    Map.new(hash).get_or_else(123, 'xxx').should eq('abc')
-    Map.new(hash).get_or_else(999, 'xxx').should eq('xxx')
-  end
-  it 'has #is_empty' do
-    Map.new(hash).is_empty.should eq(false)
-    Map.new({}).is_empty.should eq(true)
-    Map.new(nil).is_empty.should eq(true)
-  end
-  it 'has #key_set' do
-    Map.new(hash).key_set.should eq(hash.keys)
-  end
-  it 'has #lift' do
-    lifted = Map.new(hash).lift
-    lifted.apply(123).get.should eq('abc')
-    lifted.apply(999).is_defined.should eq(false)
-    lifted.call(123).get.should eq('abc')
-    lifted.call(999).is_defined.should eq(false)
-  end
-  it 'has #map' do
-    new_map = Map.new(hash).map {|k,v| [k+k,v] }.to_hash
-    new_map.include?(246).should eq(true)
-  end
-  it 'has #minus' do
-    Map.new(hash).minus(123,234,345).to_hash.should eq({4=>'d',56=>'ef',7=>'g',89=>'hi'})
-  end
-  it 'has #mk_string' do
-    Map.new(hash).mk_string().should eq('{123=>abc, 234=>bcd, 345=>cde, 4=>d, 56=>ef, 7=>g, 89=>hi}')
-  end
-  it 'has #non_empty' do
-    Map.new(hash).non_empty.should eq(true)
-    Map.new({}).non_empty.should eq(false)
-    Map.new(nil).non_empty.should eq(false)
-  end
-  it 'has #plus' do
-    Map.new({123=>'abc',234=>'bcd'}).plus([[345,'cde']]).to_hash.should eq({123=>'abc',234=>'bcd',345=>'cde'})
-  end
-  it 'has #updated' do
-    Map.new({123=>'abc',234=>'bcd'}).updated(345,'cde').to_hash.should eq({123=>'abc',234=>'bcd',345=>'cde'})
-  end
-  it 'has #unzip' do
-    unzipped = Map.new({123=>'abc',234=>'bcd'}).unzip.to_a
-    unzipped[0].should eq([123,234])
-    unzipped[1].should eq(['abc','bcd'])
-  end
-end
-
+# -*- encoding: utf-8 -*-
+
+require 'scaruby'
+
+describe Map do
+
+  hash = {123 => 'abc', 234 => 'bcd', 345 => 'cde', 4 => 'd', 56 => 'ef', 7 => 'g', 89 => 'hi'}
+
+  it 'does not accept invalid args' do
+    begin
+      map = Map.new(1234)
+      raise 'Expected exception did not be raised!'
+    rescue AssertionError
+    end
+  end
+
+  it 'has self.new' do
+    map = Map.new({1 => 'a', 2 => 'b'})
+    map.should_not eq(nil)
+  end
+
+  # as a sub type of Hash
+  it 'has #each' do
+    expected_key = 1
+    expected_value = 10
+    returned = Map.new({1 => 10, 2 => 20}).each do |k, v|
+      k.should eq(expected_key)
+      v.should eq(expected_value)
+      expected_key += 1
+      expected_value += 10
+    end
+    returned.should eq(nil)
+  end
+
+  # defined
+  it 'has #contains' do
+    Map.new(hash).contains(123).should eq(true)
+    Map.new(hash).contains(999).should eq(false)
+  end
+  it 'has #count' do
+    Map.new(hash).count { |k, v| k.to_s.length >= 2 }.should eq(5)
+  end
+  it 'hash Map.empty' do
+    Map.empty.should eq({})
+  end
+  it 'has #exists' do
+    Map.new(hash).exists { |k, v| k.to_s.length == 1 }.should eq(true)
+  end
+  it 'has #filter' do
+    Map.new(hash).filter { |k, v| k.to_s.length < 3 }.to_hash.size.should eq(4)
+  end
+  it 'has #filter_keys' do
+    Map.new(hash).filter_keys { |k| k.to_s.length < 3 }.to_hash.size.should eq(4)
+  end
+  it 'has #filter_not' do
+    Map.new(hash).filter_not { |k, v| k.to_s.length < 3 }.to_hash.to_s.should eq('{123=>"abc", 234=>"bcd", 345=>"cde"}')
+  end
+  it 'has #find' do
+    Map.new(hash).find { |k, v| k.to_s.length == 2 }.get[1].should eq('ef')
+  end
+  it 'has #forall' do
+    Map.new(hash).forall { |k, v| k.to_s.length <= 3 }.should eq(true)
+    Map.new(hash).forall { |k, v| k.to_s.length >= 2 }.should eq(false)
+  end
+  it 'has #foreach' do
+    returned = Map.new(hash).foreach do |k, v|
+      hash.include?(k).should eq(true)
+    end
+    returned.should eq(nil)
+  end
+  it 'has #get_or_else' do
+    Map.new(hash).get_or_else(123, 'xxx').should eq('abc')
+    Map.new(hash).get_or_else(999, 'xxx').should eq('xxx')
+  end
+  it 'has #is_empty' do
+    Map.new(hash).is_empty.should eq(false)
+    Map.new({}).is_empty.should eq(true)
+    Map.new(nil).is_empty.should eq(true)
+  end
+  it 'has #key_set' do
+    Map.new(hash).key_set.should eq(hash.keys)
+  end
+  it 'has #lift' do
+    lifted = Map.new(hash).lift
+    lifted.apply(123).get.should eq('abc')
+    lifted.apply(999).is_defined.should eq(false)
+    lifted.call(123).get.should eq('abc')
+    lifted.call(999).is_defined.should eq(false)
+  end
+  it 'has #map' do
+    new_map = Map.new(hash).map { |k, v| [k+k, v] }.to_hash
+    new_map.include?(246).should eq(true)
+  end
+  it 'has #minus' do
+    Map.new(hash).minus(123, 234, 345).to_hash.should eq({4 => 'd', 56 => 'ef', 7 => 'g', 89 => 'hi'})
+  end
+  it 'has #mk_string' do
+    Map.new(hash).mk_string().should eq('{123=>abc, 234=>bcd, 345=>cde, 4=>d, 56=>ef, 7=>g, 89=>hi}')
+  end
+  it 'has #non_empty' do
+    Map.new(hash).non_empty.should eq(true)
+    Map.new({}).non_empty.should eq(false)
+    Map.new(nil).non_empty.should eq(false)
+  end
+  it 'has #plus' do
+    Map.new({123 => 'abc', 234 => 'bcd'}).plus([[345, 'cde']]).to_hash.should eq({123 => 'abc', 234 => 'bcd', 345 => 'cde'})
+  end
+  it 'has #updated' do
+    Map.new({123 => 'abc', 234 => 'bcd'}).updated(345, 'cde').to_hash.should eq({123 => 'abc', 234 => 'bcd', 345 => 'cde'})
+  end
+  it 'has #unzip' do
+    unzipped = Map.new({123 => 'abc', 234 => 'bcd'}).unzip.to_a
+    unzipped[0].should eq([123, 234])
+    unzipped[1].should eq(['abc', 'bcd'])
+  end
+end
+

data/spec/scaruby/option_spec.rb

@@ -1,43 +1,50 @@
-# -*- encoding: utf-8 -*-
-
-require 'scaruby'
-
-describe Option do
-  it 'has self.new' do
-    some = Option.new(123)
-    some.is_defined.should eq(true)
-  end 
-  it 'has #get and it works with Some' do
-    some = Option.new(123)
-    some.get.should eq(123)
-  end
-  it 'has #get and it works with None' do
-    none = Option.new(nil)
-    begin
-      none.get
-      violated "NoSuchElementException should be thorwn!"
-    rescue Scaruby::NoSuchElementException => e
-    end
-  end
-  it 'has #get_or_else and it works with Some' do
-    some = Option.new(123)
-    some.get_or_else(999).should eq(123)
-  end
-  it 'has #get_or_else and it works with None' do
-    none = Option.new(nil)
-    none.get_or_else(999).should eq(999)
-  end
-  it 'has #map and it works with Some' do
-    some = Option.new(123)
-    some_result = some.map {|v| v + v }
-    some_result.get_or_else(999).should eq(246)
-  end 
-  it 'has #map and it works with None' do
-    none = Option.new(nil)
-    none_result = none.map {|v| v + v }
-    none_result.get_or_else(999).should eq(999)
-  end
-end
-
-
-
+# -*- encoding: utf-8 -*-
+
+require 'scaruby'
+
+describe Option do
+  it 'has self.new' do
+    some = Option.new(123)
+    some.is_defined.should eq(true)
+    some.is_empty.should eq(false)
+  end
+  it 'has #get and the method works with Some' do
+    some = Option.new(123)
+    some.get.should eq(123)
+  end
+  it 'has #get and the method works with None' do
+    none = Option.new(nil)
+    begin
+      none.get
+      violated "NoSuchElementException should be thorwn!"
+    rescue Scaruby::NoSuchElementException => e
+    end
+  end
+  it 'has #get_or_else and the method works with Some' do
+    some = Option.new(123)
+    some.get_or_else(999).should eq(123)
+  end
+  it 'has #get_or_else and the method works with None' do
+    none = Option.new(nil)
+    none.get_or_else(999).should eq(999)
+  end
+  it 'has #map and the method works with Some' do
+    some = Option.new(123)
+    some_result = some.map { |v| v + v }
+    some_result.get_or_else(999).should eq(246)
+  end
+  it 'has #map and the method works with None' do
+    none = Option.new(nil)
+    none_result = none.map { |v| v + v }
+    none_result.get_or_else(999).should eq(999)
+  end
+  it 'has #fold and the method works with Some' do
+    some = Option.new(123)
+    some.fold(999){ |v| v +v }.should eq(246)
+  end
+  it 'has #fold and the method works with None' do
+    none = Option.new(nil)
+    none.fold(999){ |v| v +v }.should eq(999)
+  end
+end
+