scaruby 0.0.3 → 0.0.4

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+#  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+#  - jruby-18mode # JRuby in 1.8 mode
+#  - jruby-19mode # JRuby in 1.9 mode
+#  - rbx-18mode
+#  - rbx-19mode
+script: bundle exec rspec spec
+

data/lib/scaruby/core_ext.rb

@@ -8,4 +8,3 @@ module Scaruby
   end
 end
 
-

data/lib/scaruby/map.rb

@@ -7,6 +7,7 @@ module Scaruby
       @hash.each do |k,v|
         yield k, v
       end
+      nil
     end
 
     def self.empty
@@ -30,24 +31,11 @@ module Scaruby
     end
 
     def count(&predicate)
-      count = 0
-      @hash.each do |k,v|
-        if yield k, v then 
-          count += 1
-        end
-      end
-      count
+      @hash.count(&predicate)
     end
 
     def exists(&predicate)
-      @hash.to_a.inject(false) {|found,kv|
-        if found then 
-          true
-        else 
-          k, v = kv[0], kv[1]
-          yield k, v
-        end
-      }
+      @hash.any?(&predicate)
     end
 
     def filter(&predicate)
@@ -63,31 +51,18 @@ module Scaruby
     end
 
     def find(&predicate)
-      Option.new(@hash.inject([false,[]]) {|z,kv|
-        found, matched_kv = z[0], z[1]
-        if found then 
-          z
-        elsif yield kv[0], kv[1] then 
-          [true,kv]
-        else 
-          [false,[]]
-        end
-      }[1])
+      Option.new(@hash.find(&predicate))
     end
 
     def forall(&predicate)
-      @hash.inject(true) {|still_matched,kv|
-        if !still_matched then 
-          false
-        else 
-          k, v = kv[0], kv[1]
-          yield k, v
-        end
-      }
+      @hash.all?(&predicate)
     end
 
     def foreach(&block)
-      @hash.each do |k,v| yield k, v end
+      @hash.each do |k,v| 
+        yield k, v 
+      end
+      nil
     end
 
     def get_or_else(key, default_value)

data/lib/scaruby/seq.rb

@@ -8,6 +8,7 @@ module Scaruby
       @array.each do |e|
         yield e
       end
+      nil
     end
   
     def self.apply(enumerable)
@@ -146,6 +147,7 @@ module Scaruby
       @array.each do |e| 
         yield e 
       end
+      nil
     end
 
     def group_by(&block) 
@@ -244,10 +246,9 @@ module Scaruby
     end
 
     def patch(from, patch, replaced) 
-      Seq.new(
-        @array.take(from)
-          .concat(patch)
-          .concat(@array.drop(from).drop(replaced)))
+      # -- compatible with Ruby 1.8.7
+      #Seq.new(@array.take(from).concat(patch).concat(@array.drop(from).drop(replaced)))
+      Seq.new(@array.take(from) + patch + @array.drop(from).drop(replaced))
     end
 
     def reverse

data/lib/scaruby/version.rb

@@ -1,6 +1,6 @@
 # -*- encoding: utf-8 -*-
 
 module Scaruby
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end
 

data/readme.md

@@ -1,9 +1,17 @@
 # Scala API in Ruby
 
+https://rubygems.org/gems/scaruby
+
 Surely it works fine. 
 
 But it mainly serves as a Ruby reference for Scala programmers.
 
+
+## Supported Ruby versions
+
+Scaruby runs on Ruby 1.9.2, 1.9.3.
+
+
 ## Gemfile
 
 ```
@@ -12,10 +20,12 @@ source "http://rubygems.org/"
 gem 'scaruby'
 ```
 
+
 ## Usage
 
 See specs.
 
+
 ## Trying on irb
 
 ```sh
@@ -23,7 +33,7 @@ bundle console
 ```
 
 ```ruby
-irb(main):008:0>  require 'scaruby'
+irb(main):008:0> require 'scaruby'
 => false
 
 irb(main):009:0> Option.new(nil).is_defined
@@ -73,9 +83,9 @@ In this case, the methods already defined (i.e. flat_map, find and so on) are ne
 ```ruby
 irb(main):015:0> require 'scaruby/core_ext'
 => true
-irb(main):016:0>  1.upto(5).filter {|i| i < 3 }
+irb(main):016:0> 1.upto(5).filter {|i| i < 3 }
 => [1, 2]
-irb(main):020:0>  1.upto(5).filter {|i| i < 3 }.foreach do |i|
+irb(main):020:0> 1.upto(5).filter {|i| i < 3 }.foreach do |i|
 irb(main):021:1*   puts i
 irb(main):022:1> end
 1
@@ -86,6 +96,12 @@ irb(main):027:0> {123=>'abc',23=>'bc',345=>'cde'}.filter {|k,v| k.to_s.size == 3
 => {123=>"abc", 345=>"cde"}
 ```
 
+
+## Build Status
+
+[![Build Status](https://secure.travis-ci.org/seratch/scaruby.png)](http://travis-ci.org/seratch/scaruby)
+
+
 ## License
 
 MIT License

data/scaruby.gemspec

@@ -18,7 +18,6 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  # specify any dependencies here; for example:
-  # s.add_development_dependency "rspec"
-  # s.add_runtime_dependency "rest-client"
+  s.required_ruby_version = '>= 1.9.2'
+
 end

data/spec/scaruby/core_ext/enumerable_spec.rb

@@ -8,64 +8,64 @@ describe Enumerable do
   one_to_five_shuffled = one_to_five.sort_by {rand}
 
   it 'has #to_a' do
-    (one_to_five).to_a.should eq([1,2,3,4,5])
+    one_to_five.to_a.should eq([1,2,3,4,5])
   end
   it 'has #corresponds' do
-    ([1,2,3]).corresponds([1,2,3]) {|a,b| a == b }.should eq(true)
-    ([1,2,3]).corresponds([3,1,2]) {|a,b| a == b }.should eq(false)
+    [1,2,3].corresponds([1,2,3]) {|a,b| a == b }.should eq(true)
+    [1,2,3].corresponds([3,1,2]) {|a,b| a == b }.should eq(false)
   end
   it 'has #count' do
-    (one_to_five).count {|i| i > 2 }.should eq(3)
+    one_to_five.count {|i| i > 2 }.should eq(3)
   end
   it 'has #diff' do
-    ([1,2,3]).diff([2,3,4]).to_a.should eq([1])
+    [1,2,3].diff([2,3,4]).to_a.should eq([1])
   end
   it 'has #distinct' do
-    ([1,2,4,1,3,3,3,2,4,1]).distinct.to_a.should eq([1,2,4,3])
+    [1,2,4,1,3,3,3,2,4,1].distinct.to_a.should eq([1,2,4,3])
   end
   it 'has #drop' do
-    (one_to_five).drop(3).to_a.should eq([4,5])
-    (one_to_five).drop(7).to_a.should eq([])
+    one_to_five.drop(3).to_a.should eq([4,5])
+    one_to_five.drop(7).to_a.should eq([])
   end
   it 'has #drop_right' do
-    (one_to_five).drop_right(3).to_a.should eq([1,2])
-    (one_to_five).drop_right(7).to_a.should eq([])
+    one_to_five.drop_right(3).to_a.should eq([1,2])
+    one_to_five.drop_right(7).to_a.should eq([])
   end
   it 'has #drop_while' do
-    ([5,3,2,4,1]).drop_while {|e| e > 2 }.to_a.should eq([2,4,1])
+    [5,3,2,4,1].drop_while {|e| e > 2 }.to_a.should eq([2,4,1])
   end
   it 'has #ends_with' do
-    ([1,2,3]).ends_with([1,2]).should eq(false)
-    ([1,2,3]).ends_with([1,2,3]).should eq(true)
-    ([1,2,3]).ends_with([1,1,2,3]).should eq(false)
-    ([1,2,3]).ends_with([2,3]).should eq(true)
-    ([1,2,3]).ends_with([3]).should eq(true)
+    [1,2,3].ends_with([1,2]).should eq(false)
+    [1,2,3].ends_with([1,2,3]).should eq(true)
+    [1,2,3].ends_with([1,1,2,3]).should eq(false)
+    [1,2,3].ends_with([2,3]).should eq(true)
+    [1,2,3].ends_with([3]).should eq(true)
   end
   it 'has #exists' do
-    ([1,2,3]).exists {|i| i < 2 }.should eq(true)
-    ([1,2,3]).exists {|i| i < 4 }.should eq(true)
-    ([2,3,4]).exists {|i| i > 4 }.should eq(false)
+    [1,2,3].exists {|i| i < 2 }.should eq(true)
+    [1,2,3].exists {|i| i < 4 }.should eq(true)
+    [2,3,4].exists {|i| i > 4 }.should eq(false)
   end
   it 'has #filter' do
-    (one_to_five).filter {|i| i > 3 }.to_a.should eq([4,5])
-    (one_to_five).filter {|i| i > 10 }.to_a.should eq([])
+    one_to_five.filter {|i| i > 3 }.to_a.should eq([4,5])
+    one_to_five.filter {|i| i > 10 }.to_a.should eq([])
   end
   it 'has #filter_not' do
-    (one_to_five).filter_not {|i| i > 3 }.to_a.should eq([1,2,3])
-    (one_to_five).filter_not {|i| i > 10 }.to_a.should eq([1,2,3,4,5])
+    one_to_five.filter_not {|i| i > 3 }.to_a.should eq([1,2,3])
+    one_to_five.filter_not {|i| i > 10 }.to_a.should eq([1,2,3,4,5])
   end
   it 'has #find' do
-    some = (one_to_five).find {|i| i < 3 }
+    some = one_to_five.find {|i| i < 3 }
     # the already defined method is called
     #some.get.should eq(1)
     some.should eq(1)
-    none = (one_to_five).find {|i| i > 10 }
+    none = one_to_five.find {|i| i > 10 }
     # the already defined method is called
     #none.is_defined.should eq(false)
     none.should eq(nil)
   end
   it 'has #flat_map and it works with nested arrays' do
-    ([[1,2],[3,4],[5]]).flat_map {|i| i }.to_a.should eq([1,2,3,4,5])
+    [[1,2],[3,4],[5]].flat_map {|i| i }.to_a.should eq([1,2,3,4,5])
   end
   it 'has #flat_map and it works with Option elements' do
     # the already defined method is called
@@ -78,7 +78,7 @@ describe Enumerable do
     input = [1,2,3]
     expected = [1,2,3]
     idx = 0
-    (input).fold_left(0) {|z,x| 
+    input.fold_left(0) {|z,x| 
       x.should eq(expected[idx])
       idx += 1
       z + x 
@@ -88,42 +88,42 @@ describe Enumerable do
     input = [1,2,3]
     expected = [3,2,1]
     idx = 0
-    (input).fold_right(0) {|z,x| 
+    input.fold_right(0) {|z,x| 
       x.should eq(expected[idx])
       idx += 1
       z + x 
     }.should eq(6)
   end
   it 'has #flatten' do
-    ([[1,2],[3,4],[5]]).flatten.to_a.should eq([1,2,3,4,5])
-    ([Option.new(1),
+    [[1,2],[3,4],[5]].flatten.to_a.should eq([1,2,3,4,5])
+    [Option.new(1),
       Option.new(2),
       Option.new(nil),
-      Option.new(3)]
-    ).flatten.to_a.each do |opt|
+      Option.new(3)].flatten.to_a.each do |opt|
       opt.is_a?(Option).should eq(true)
     end
   end
   it 'has #forall' do
-    ([1,2,3]).forall {|i| i > 0 }.should eq(true)
-    ([1,2,3]).forall {|i| i > 1 }.should eq(false)
+    [1,2,3].forall {|i| i > 0 }.should eq(true)
+    [1,2,3].forall {|i| i > 1 }.should eq(false)
   end
   it 'has #foreach' do
     count = 0
-    ([1,2,3]).foreach do |i| 
+    returned = ([1,2,3]).foreach do |i| 
       count += 1
     end
     count.should eq(3)
+    returned.should eq(nil)
   end
   it 'has #group_by' do
     expected = {3=>[3,3,3], 1=>[1,1,1], 2=>[2,2]}
-    ([1,1,1,2,3,2,3,3]).group_by {|i| i }.to_hash.should eq(expected)
+    [1,1,1,2,3,2,3,3].group_by {|i| i }.to_hash.should eq(expected)
   end
   it 'has #head' do
-    (one_to_five).head.should eq(1)
+    one_to_five.head.should eq(1)
   end
   it 'has #head_option and it works with Some' do
-    some = (one_to_five).head_option
+    some = one_to_five.head_option
     some.get_or_else(999).should eq(1)
   end
   it 'has #head_option and it works with None' do
@@ -131,30 +131,30 @@ describe Enumerable do
     none.get_or_else(999).should eq(999)
   end
   it 'has #indices' do
-    ([1,2,3]).indices.to_a.should eq([0,1,2])
+    [1,2,3].indices.to_a.should eq([0,1,2])
   end
   it 'has #init' do
-    ([1,2,3]).init.to_a.should eq([1,2])
+    [1,2,3].init.to_a.should eq([1,2])
   end
   it 'has #intersect' do
-    ([1,2,3]).intersect([2,3,4]).to_a.should eq([2,3])
+    [1,2,3].intersect([2,3,4]).to_a.should eq([2,3])
   end
   it 'has #is_empty' do
-    ([1,2,3]).is_empty.should eq(false)
-    ([nil]).is_empty.should eq(false)
-    ([]).is_empty.should eq(true)
+    [1,2,3].is_empty.should eq(false)
+    [nil].is_empty.should eq(false)
+    [].is_empty.should eq(true)
   end
   it 'has #last' do
-    ([1,2,3]).last.should eq(3)
+    [1,2,3].last.should eq(3)
   end
   it 'has #last_option' do
-    some = ([1,2,3]).last_option
+    some = [1,2,3].last_option
     some.get.should eq(3)
     none = ([]).last_option
     none.is_defined.should eq(false)
   end
   it 'has #lift' do
-    seq_lift = ([1,2,3]).lift
+    seq_lift = [1,2,3].lift
     seq_lift.apply(0).get.should eq(1)
     seq_lift.apply(1).get.should eq(2)
     seq_lift.apply(2).get.should eq(3)
@@ -165,50 +165,50 @@ describe Enumerable do
     seq_lift.call(3).is_defined.should eq(false)
   end
   it 'has #map' do
-    ([1,2,3]).map {|i| i + i }.to_a.should eq([2,4,6])
+    [1,2,3].map {|i| i + i }.to_a.should eq([2,4,6])
   end
   it 'has #max' do
-    (one_to_five_shuffled).max.should eq(5)
+    one_to_five_shuffled.max.should eq(5)
   end
   it 'has #min' do
-    (one_to_five_shuffled).min.should eq(1)
+    one_to_five_shuffled.min.should eq(1)
   end
   it 'has #mk_string' do
-    (one_to_five).mk_string.should eq('12345')
-    (one_to_five).mk_string(',').should eq('1,2,3,4,5')
-    (one_to_five).mk_string('^',',','$').should eq('^1,2,3,4,5$')
+    one_to_five.mk_string.should eq('12345')
+    one_to_five.mk_string(',').should eq('1,2,3,4,5')
+    one_to_five.mk_string('^',',','$').should eq('^1,2,3,4,5$')
     begin
-      (one_to_five).mk_string('a','b').should eq(nil)
+      one_to_five.mk_string('a','b').should eq(nil)
     rescue ArgumentError
     end
-    (one_to_five).mk_string('^',',','$','zzz').should eq('^1,2,3,4,5$')
+    one_to_five.mk_string('^',',','$','zzz').should eq('^1,2,3,4,5$')
   end
   it 'has #non_empty' do
-    (one_to_five).non_empty.should eq(true)
-    ([]).non_empty.should eq(false)
+    one_to_five.non_empty.should eq(true)
+    [].non_empty.should eq(false)
   end
   it 'has #partition' do
-    ([5,2,3,1,4,2,3]).partition {|i| i < 3 }.to_a.should eq([[2,1,2],[5,3,4,3]])
+    [5,2,3,1,4,2,3].partition {|i| i < 3 }.to_a.should eq([[2,1,2],[5,3,4,3]])
   end
   it 'has #patch' do
-    ([5,2,3,1,4,2,3]).patch(3,[111,222],3).to_a.should eq([5,2,3,111,222,3])
+    [5,2,3,1,4,2,3].patch(3,[111,222],3).to_a.should eq([5,2,3,111,222,3])
   end
   it 'has #reverse' do
-    ([1,2,3]).reverse.to_a.should eq([3,2,1])
+    [1,2,3].reverse.to_a.should eq([3,2,1])
   end
   it 'has #reverse_map' do
-    ([1,2,3]).reverse_map {|i| i + i }.to_a.should eq([6,4,2])
+    [1,2,3].reverse_map {|i| i + i }.to_a.should eq([6,4,2])
   end
   it 'has #same_elements' do
-    ([1,2,3]).same_elements([1,2,3]).should eq(true)
-    ([1,2,3]).same_elements([1,3,2]).should eq(false)
-    ([1,2,3]).same_elements([1,2]).should eq(false)
+    [1,2,3].same_elements([1,2,3]).should eq(true)
+    [1,2,3].same_elements([1,3,2]).should eq(false)
+    [1,2,3].same_elements([1,2]).should eq(false)
   end
   it 'has #scan_left' do
-    ([1,2,3]).scan_left(1) {|a,b| a + b }.to_a.should eq([1,2,4,7])
+    [1,2,3].scan_left(1) {|a,b| a + b }.to_a.should eq([1,2,4,7])
   end
   it 'has #scan_right' do
-    ([1,2,3]).scan_right(1) {|a,b| a + b }.to_a.should eq([7,6,4,1])
+    [1,2,3].scan_right(1) {|a,b| a + b }.to_a.should eq([7,6,4,1])
   end
   it 'has #slice' do
     # the already defined method is called
@@ -222,54 +222,54 @@ describe Enumerable do
     [1,2,3,4,5].slice(1,4).should eq([2,3,4,5])
   end
   it 'has #sliding' do
-    ([1,2,3,4,5]).sliding(2).to_a.should eq([[1,2],[2,3],[3,4],[4,5]])
+    [1,2,3,4,5].sliding(2).to_a.should eq([[1,2],[2,3],[3,4],[4,5]])
   end
   it 'has #sort_with' do
-    ([1,3,2,4,5]).sort_with {|a,b| b <=> a }.to_a.should eq([5,4,3,2,1])
+    [1,3,2,4,5].sort_with {|a,b| b <=> a }.to_a.should eq([5,4,3,2,1])
   end
   it 'has #span' do
-    ([1,2,3,2,1]).span {|i| i < 3 }.to_a.should eq([[1,2],[3,2,1]])
+    [1,2,3,2,1].span {|i| i < 3 }.to_a.should eq([[1,2],[3,2,1]])
   end
   it 'has #split_at' do
-    ([1,2,3,2,1]).split_at(3).to_a.should eq([[1,2,3],[2,1]])
+    [1,2,3,2,1].split_at(3).to_a.should eq([[1,2,3],[2,1]])
   end
   it 'has #starts_with' do
-    ([1,2,3]).starts_with([1]).should eq(true)
-    ([1,2,3]).starts_with([1,2]).should eq(true)
-    ([1,2,3]).starts_with([1,2,3]).should eq(true)
-    ([1,2,3]).starts_with([1,2,3,4]).should eq(false)
-    ([1,2,3]).starts_with([2,3]).should eq(false)
-    ([1,2,3]).starts_with([4,1,2,3]).should eq(false)
+    [1,2,3].starts_with([1]).should eq(true)
+    [1,2,3].starts_with([1,2]).should eq(true)
+    [1,2,3].starts_with([1,2,3]).should eq(true)
+    [1,2,3].starts_with([1,2,3,4]).should eq(false)
+    [1,2,3].starts_with([2,3]).should eq(false)
+    [1,2,3].starts_with([4,1,2,3]).should eq(false)
   end
   it 'has #sum' do
-    ([1,2,3]).sum.should eq(6)
+    [1,2,3].sum.should eq(6)
   end
   it 'has #tail' do
-    ([1,2,3]).tail.to_a.should eq([2,3])
-    ([]).tail.to_a.should eq([])
+    [1,2,3].tail.to_a.should eq([2,3])
+    [].tail.to_a.should eq([])
   end
   it 'has #take' do
-    ([1,2,3]).take(0).to_a.should eq([])
-    ([1,2,3]).take(1).to_a.should eq([1])
-    ([1,2,3]).take(2).to_a.should eq([1,2])
-    ([1,2,3]).take(3).to_a.should eq([1,2,3])
-    ([1,2,3]).take(4).to_a.should eq([1,2,3])
+    [1,2,3].take(0).to_a.should eq([])
+    [1,2,3].take(1).to_a.should eq([1])
+    [1,2,3].take(2).to_a.should eq([1,2])
+    [1,2,3].take(3).to_a.should eq([1,2,3])
+    [1,2,3].take(4).to_a.should eq([1,2,3])
   end
   it 'has #take_right' do
-    ([1,2,3]).take_right(0).to_a.should eq([])
-    ([1,2,3]).take_right(1).to_a.should eq([3])
-    ([1,2,3]).take_right(2).to_a.should eq([2,3])
-    ([1,2,3]).take_right(3).to_a.should eq([1,2,3])
-    ([1,2,3]).take_right(4).to_a.should eq([1,2,3])
+    [1,2,3].take_right(0).to_a.should eq([])
+    [1,2,3].take_right(1).to_a.should eq([3])
+    [1,2,3].take_right(2).to_a.should eq([2,3])
+    [1,2,3].take_right(3).to_a.should eq([1,2,3])
+    [1,2,3].take_right(4).to_a.should eq([1,2,3])
   end
   it 'has #take_while' do
-    ([5,3,2,4,1]).take_while {|e| e > 2 }.to_a.should eq([5,3])
+    [5,3,2,4,1].take_while {|e| e > 2 }.to_a.should eq([5,3])
   end
   it 'has #union' do
-    ([1,2,3]).union([2,3,4]).to_a.should eq([1,2,3,2,3,4])
+    [1,2,3].union([2,3,4]).to_a.should eq([1,2,3,2,3,4])
   end
   it 'has #updated' do
-    ([1,2,3]).updated(1,999).to_a.should eq([1,999,3])
+    [1,2,3].updated(1,999).to_a.should eq([1,999,3])
   end
   it 'has #zip' do
     # the already defined method is called
@@ -281,8 +281,8 @@ describe Enumerable do
     [1,2,3].zip([2,3,4,5]).should eq([[1,2],[2,3],[3,4]])
   end
   it 'has #zip_with_index' do
-    ([]).zip_with_index.to_a.should eq([])
-    ([1,2,3]).zip_with_index.to_a.should eq([[1,0],[2,1],[3,2]])
+    [].zip_with_index.to_a.should eq([])
+    [1,2,3].zip_with_index.to_a.should eq([[1,0],[2,1],[3,2]])
   end
 
 end

data/spec/scaruby/core_ext/hash_spec.rb

@@ -7,54 +7,54 @@ 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)
+    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)
+    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)
+    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)
+    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)
+    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| k.to_s.length < 3 }.to_hash.to_s.should eq('{123=>"abc", 234=>"bcd", 345=>"cde"}')
+    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')
+    #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)
+    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.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')
+    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)
+    hash.is_empty.should eq(false)
+    {}.is_empty.should eq(true)
   end
   it 'has #key_set' do
-    (hash).key_set.should eq(hash.keys)
+    hash.key_set.should eq(hash.keys)
   end
   it 'has #lift' do
-    lifted = (hash).lift
+    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')
@@ -62,29 +62,29 @@ describe Hash do
   end
   it 'has #map' do
     # the already defined method is called
-    #new_map = (hash).map {|k,v| [k+k,v] }.to_hash
+    #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 = 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'})
+    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}')
+    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)
+    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'})
+    {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'})
+    {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 = {123=>'abc',234=>'bcd'}.unzip.to_a
     unzipped[0].should eq([123,234])
     unzipped[1].should eq(['abc','bcd'])
   end

data/spec/scaruby/map_spec.rb

@@ -15,12 +15,13 @@ describe Map do
   it 'has #each' do
     expected_key = 1
     expected_value = 10
-    Map.new({1=>10,2=>20}).each do |k,v|
+    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
@@ -44,7 +45,7 @@ describe Map 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| k.to_s.length < 3 }.to_hash.to_s.should eq('{123=>"abc", 234=>"bcd", 345=>"cde"}')
+    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')
@@ -54,9 +55,10 @@ describe Map do
     Map.new(hash).forall {|k,v| k.to_s.length >= 2 }.should eq(false)
   end
   it 'has #foreach' do
-    Map.new(hash).foreach do |k,v| 
+    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')

data/spec/scaruby/seq_spec.rb

@@ -21,10 +21,11 @@ describe Seq do
   # as a sub type of Enumerable
   it 'has #each' do
     expected = 0
-    Seq.new([0,1,2,3]).each do |e|
+    returned = Seq.new([0,1,2,3]).each do |e|
       e.should eq(expected)
       expected += 1
     end
+    returned.should eq(nil)
   end
   it 'has #all?' do
     Seq.new([1,2,3]).all? {|e| e < 4 }.should eq(true)
@@ -126,10 +127,11 @@ describe Seq do
   end
   it 'has #foreach' do
     count = 0
-    Seq.new([1,2,3]).foreach do |i| 
+    returned = Seq.new([1,2,3]).foreach do |i| 
       count += 1
     end
     count.should eq(3)
+    returned.should eq(nil)
   end
   it 'has #group_by' do
     expected = {3=>[3,3,3], 1=>[1,1,1], 2=>[2,2]}

metadata

@@ -1,29 +1,25 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: scaruby
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.0.4
   prerelease: 
-  version: 0.0.3
 platform: ruby
-authors: 
+authors:
 - Kazuhiro Sera
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-03-03 00:00:00 Z
+date: 2012-03-05 00:00:00.000000000 Z
 dependencies: []
-
 description: Scala API in Ruby
-email: 
+email:
 - seratch@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - Rakefile
@@ -49,32 +45,29 @@ files:
 - spec/scaruby_spec.rb
 homepage: https://github.com/seratch/scaruby
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: scaruby
-rubygems_version: 1.8.15
+rubygems_version: 1.8.17
 signing_key: 
 specification_version: 3
 summary: Scala API in Ruby
-test_files: 
+test_files:
 - spec/scaruby/converter_spec.rb
 - spec/scaruby/core_ext/enumerable_spec.rb
 - spec/scaruby/core_ext/hash_spec.rb