scaruby 0.0.1 → 0.0.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+Copyright (c) 2012 Kazuhiro Sera
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/lib/scaruby/core_ext/enumerable.rb

@@ -0,0 +1,16 @@
+# -*- encoding: utf-8 -*-
+
+require 'scaruby/seq'
+
+module Enumerable
+
+  def method_missing(name, *args, &block)
+    result = Scaruby::Seq.new(self).send(name, *args, &block)
+    if result.is_a?(Scaruby::Seq) then
+      result.to_a
+    else
+      result
+    end
+  end
+end
+

data/lib/scaruby/core_ext/hash.rb

@@ -0,0 +1,15 @@
+# -*- encoding: utf-8 -*-
+
+require 'scaruby/map'
+
+class Hash
+  def method_missing(name, *args, &block)
+    result = Scaruby::Map.new(self).send(name, *args, &block)
+    if result.is_a?(Scaruby::Map) then
+      result.to_hash
+    else
+      result
+    end
+  end
+end
+

data/lib/scaruby/core_ext.rb

@@ -0,0 +1,11 @@
+# -*- encoding: utf-8 -*-
+
+require 'scaruby/core_ext/enumerable.rb'
+require 'scaruby/core_ext/hash.rb'
+
+module Scaruby
+  module CoreExt
+  end
+end
+
+

data/lib/scaruby/map.rb

@@ -59,9 +59,12 @@ module Scaruby
     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,[]]
+        if found then 
+          z
+        elsif yield kv[0], kv[1] then 
+          [true,kv]
+        else 
+          [false,[]]
         end
       }[1])
     end
@@ -99,9 +102,27 @@ module Scaruby
     end
 
     def map(&block)
+      #Map.new(Hash[*@hash.to_a.collect {|k,v| yield k, v }.flatten])
       Map.new(Hash[*@hash.to_a.map {|k,v| yield k, v }.flatten])
     end
 
+    def minus(*keys)
+      copied = @hash.dup
+      keys.each do |key|
+        copied.delete(key)
+      end
+      Map.new(copied)
+    end
+
+    def plus(elems)
+      copied = @hash.dup
+      elems.each do |elm|
+        k,v = elm[0], elm[1]
+        copied[k] = v
+      end
+      Map.new(copied)
+    end
+
     def mk_string(*args)
       case args.size
       when 0
@@ -109,7 +130,7 @@ module Scaruby
       when 1
         start_part, sep, end_part = '', args[0], ''
       when 2
-        raise 'Illegal number of arguments'
+        raise 'Illegal number of arguments (2)'
       else
         start_part, sep, end_part = args[0], args[1], args[2]
       end
@@ -121,6 +142,16 @@ module Scaruby
       ! is_empty
     end
 
+    def updated(k, v)
+      copied = @hash.dup
+      copied[k] = v
+      Map.new(copied)
+    end
+
+    def unzip
+      Seq.new([@hash.keys,@hash.values])
+    end
+
   end
 end
 

data/lib/scaruby/option.rb

@@ -18,8 +18,10 @@ module Scaruby
     end
 
     def get
-      if is_defined then @value 
-      else raise NoSuchElementException 
+      if is_defined then 
+        @value 
+      else 
+        raise NoSuchElementException 
       end
     end
 

data/lib/scaruby/seq.rb

@@ -18,6 +18,18 @@ module Scaruby
     def to_a
       @array
     end
+
+    def corresponds(that, &predicate)
+      @array.zip(that).inject(true) {|still_matched,e| 
+        if ! still_matched then 
+          false
+        elsif yield e[0], e[1] then
+          true
+        else 
+          false
+        end
+      }
+    end
   
     def count(&predicate)
       filter(&predicate).size
@@ -42,9 +54,12 @@ module Scaruby
     def drop_while(&predicate)
       Seq.new(@array.inject([false,[]]) {|passed,x|
         no_need_to_yield, result = passed[0], passed[1]
-        if no_need_to_yield then [true, result.push(x)]
-        elsif yield x then passed
-        else [true, result.push(x)] 
+        if no_need_to_yield then 
+          [true, result.push(x)]
+        elsif yield x then 
+          passed
+        else 
+          [true, result.push(x)] 
         end
       }[1])
     end
@@ -55,17 +70,22 @@ module Scaruby
       end
       this_end = @array.reverse.take(that.length).reverse
       this_end.zip(that).inject(true) {|all_matched,a| 
-        if ! all_matched then false
-        elsif a.length != 2 then false
-        else a[0] == a[1] 
+        if ! all_matched then 
+          false
+        elsif a.length != 2 then 
+          false
+        else 
+          a[0] == a[1] 
         end
       }
     end
 
     def exists(&predicate)
       @array.inject(false) {|found,e| 
-        if found then true
-        else yield e 
+        if found then 
+          true 
+        else 
+          yield e 
         end
       }
     end
@@ -83,13 +103,16 @@ module Scaruby
     end
 
     def flat_map(&block)
-      Seq.new(@array.inject([]) {|z,x| 
+      Seq.new(@array.inject([]) {|z,x|
         applied = yield x
         if applied.is_a?(Enumerable) then
           applied.inject(z) {|z,elm| z.push(elm) }
-        elsif applied.is_a?(Option) then 
+        elsif applied.is_a?(Seq) then
+          applied.to_a.inject(z) {|z,elm| z.push(elm) }
+        elsif applied.is_a?(Option) then
           applied.is_defined ? z.push(applied.get) : z
-        else z.push(applied) 
+        else
+          z.push(applied)
         end
       })
     end
@@ -110,16 +133,35 @@ module Scaruby
       @array.inject(z) {|z,x| yield z, x }
     end
 
+    def fold_right(z, &block)
+      @array.reverse.inject(z) {|z,x| yield z, x }
+    end
+
     def forall(&predicate)
       @array.inject(true) {|all_matched,e|
-        if ! all_matched then false
-        else yield e 
+        if ! all_matched then
+          false
+        else
+          yield e
         end
       }
     end
 
     def foreach(&block)
-      @array.each do |e| yield e end
+      @array.each do |e| 
+        yield e 
+      end
+    end
+
+    def group_by(&block) 
+      Map.new(@array.inject({}) {|z,e|
+        if z[e].nil? then
+          z[e] = [e]
+        else
+          z[e] = z[e].push(e)
+        end
+        z
+      })
     end
   
     def head
@@ -197,8 +239,10 @@ module Scaruby
 
     def partition(&predicate)
       Seq.new(@array.inject([[],[]]) {|z,x|
-        if yield x then [z[0].push(x),z[1]]
-        else [z[0],z[1].push(x)] 
+        if yield x then 
+          [z[0].push(x),z[1]]
+        else 
+          [z[0],z[1].push(x)] 
         end
       })
     end
@@ -221,9 +265,12 @@ module Scaruby
 
     def same_elements(that)
       @array.zip(that).inject(true) {|still_same,a|
-        if ! still_same then false
-        elsif a.length != 2 then false
-        else a[0] == a[1] 
+        if ! still_same then 
+          false
+        elsif a.length != 2 then 
+          false
+        else 
+          a[0] == a[1] 
         end
       }
     end
@@ -269,9 +316,12 @@ module Scaruby
     def span(&predicate)
       result = @array.inject([true,[],[]]) {|z,x|
         still_matched, first, second = z[0], z[1], z[2]
-        if ! still_matched then [false,first,second.push(x)]
-        elsif yield x then [true,first.push(x),second]
-        else [false,first,second.push(x)] 
+        if ! still_matched then 
+          [false,first,second.push(x)]
+        elsif yield x then 
+          [true,first.push(x),second]
+        else 
+          [false,first,second.push(x)] 
         end
       }
       Seq.new([result[1],result[2]])
@@ -287,9 +337,12 @@ module Scaruby
       end
       this_start = @array.take(that.length)
       this_start.zip(that).inject(true) {|all_matched,a|
-        if ! all_matched then false
-        elsif a.length != 2 then false
-        else a[0] == a[1]
+        if ! all_matched then 
+          false
+        elsif a.length != 2 then 
+          false
+        else 
+          a[0] == a[1]
         end
       }
     end
@@ -313,9 +366,12 @@ module Scaruby
     def take_while(&predicate)
       Seq.new(@array.inject([false,[]]) {|passed,x|
         is_already_unmatched, result = passed[0], passed[1]
-        if is_already_unmatched then passed
-        elsif yield x then [false,result.push(x)]
-        else [true, result] 
+        if is_already_unmatched then 
+          passed
+        elsif yield x then 
+          [false,result.push(x)]
+        else 
+          [true, result] 
         end
       }[1])
     end
@@ -324,13 +380,19 @@ module Scaruby
       Seq.new(@array.concat(that))
     end
 
+    def updated(idx, elm)
+      Seq.new(@array.fill(elm,idx,1))
+    end
+
     def zip(that)
       Seq.new(@array.zip(that).select {|a,b| ! a.nil? && ! b.nil? })
     end
 
     def zip_with_index
       with_index = []
-      @array.each_with_index do |v,idx| with_index.push([v,idx]) end
+      @array.each_with_index do |v,idx| 
+        with_index.push([v,idx]) 
+      end
       with_index
     end
   

data/lib/scaruby/version.rb

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

data/readme.md

@@ -1,15 +1,20 @@
-# Ruby reference for Scala programmers
+# Scala API in Ruby
 
-Surely it works fine. But it mainly serves as a Ruby reference for Scala programmers.
+Surely it works fine. 
 
-## Setup
+But it mainly serves as a Ruby reference for Scala programmers.
+
+## Gemfile
 
-```sh
-git clone git://github.com/seratch/scaruby.git
-cd scaruby
-gem install bundler
-bundle install
 ```
+source "http://rubygems.org/"
+
+gem 'scaruby'
+```
+
+## Usage
+
+See specs.
 
 ## Trying on irb
 
@@ -18,36 +23,51 @@ bundle console
 ```
 
 ```ruby
-irb(main):001:0> require 'scaruby'
+irb(main):008:0>  require 'scaruby'
 => false
 
-irb(main):003:0> Option.new(nil).is_defined
+irb(main):009:0> Option.new(nil).is_defined
+=> false
+irb(main):010:0> Option.apply(nil).is_defined
 => false
-irb(main):004:0> Option.new(123).is_defined
+irb(main):011:0> Option.new(123).is_defined
 => true
 
-irb(main):004:0> Seq.new([1,2,3]).map {|e| e * e }
-=> #<Scaruby::Seq:0x9dca2e0 @enumerable=[1, 4, 9]>
-irb(main):005:0> Seq.new([1,2,3]).map {|e| e * e }.to_a
-=> [1, 4, 9]
-
-irb(main):004:0> Seq.new([1,2,3]).filter {|e| e < 2 }.to_a
+irb(main):012:0> Seq.new([1,2,3]).filter {|e| e < 2 }
+=> #<Scaruby::Seq:0x9772424 @array=[1]>
+irb(main):013:0> Seq.new([1,2,3]).filter {|e| e < 2 }.to_a
 => [1]
+irb(main):014:0> Seq.new([1,2,3]).fold_left(0) {|z,x| z + x }
+=> 6
 
-irb(main):002:0> Seq.new([[1,2,3],[4,5],[6]]).flat_map {|e| e }.to_a
-=> [1, 2, 3, 4, 5, 6]
+irb(main):025:0> Map.new({123=>'abc',23=>'bc',345=>'cde'}).filter {|k,v| k.to_s.size == 3 }
+=> #<Scaruby::Map:0x94afa98 @hash={123=>"abc", 345=>"cde"}>
+irb(main):026:0> Map.new({123=>'abc',23=>'bc',345=>'cde'}).filter {|k,v| k.to_s.size == 3 }.to_hash
+=> {123=>"abc", 345=>"cde"}
+```
 
-irb(main):003:0> Seq.new([1,2,3]).fold_left(0) {|z,x| z + x }
-=> 6
+You can extend Ruby with Scaruby. If the method is missing, the method in Scaruby will be invoked.
+
+Already defined methods (i.e. flat_map, find and so on) are never replaced.
 
-irb(main):001:0> require 'enumerable_to_scaruby'
+```ruby
+irb(main):015:0> require 'scaruby/core_ext'
 => true
-irb(main):002:0> [[1,2,3],[4,5],[6]].flat_map {|e| e }
-=> [1, 2, 3, 4, 5, 6]
+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):021:1*   puts i
+irb(main):022:1> end
+1
+2
+=> [1, 2]
+
+irb(main):027:0> {123=>'abc',23=>'bc',345=>'cde'}.filter {|k,v| k.to_s.size == 3 }
+=> {123=>"abc", 345=>"cde"}
 ```
 
-## Testing
+## License
+
+MIT License
+
 
-```sh
-bundle exec rspec
-```

data/spec/scaruby/core_ext/enumerable_spec.rb

@@ -0,0 +1,288 @@
+# -*- encoding: utf-8 -*-
+
+require 'scaruby/core_ext'
+
+describe Seq do
+
+  one_to_five = 1.upto 5
+  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])
+  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)
+  end
+  it 'has #count' do
+    (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])
+  end
+  it 'has #distinct' do
+    ([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([])
+  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([])
+  end
+  it 'has #drop_while' do
+    ([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)
+  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)
+  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([])
+  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])
+  end
+  it 'has #find' do
+    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 }
+    # 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])
+  end
+  it 'has #flat_map and it works with Option elements' do
+    # the already defined method is called
+    #([1,2,nil,3]).flat_map {|i| Option.new(i) }.to_a.should eq([1,2,3])
+    [1,2,nil,3].flat_map {|i| Option.new(i) }.to_a do |opt|
+      opt.is_a?(Option).should eq(true)
+    end
+  end
+  it 'has #fold_left' do
+    input = [1,2,3]
+    expected = [1,2,3]
+    idx = 0
+    (input).fold_left(0) {|z,x| 
+      x.should eq(expected[idx])
+      idx += 1
+      z + x 
+    }.should eq(6)
+  end
+  it 'has #fold_right' do
+    input = [1,2,3]
+    expected = [3,2,1]
+    idx = 0
+    (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),
+      Option.new(2),
+      Option.new(nil),
+      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)
+  end
+  it 'has #foreach' do
+    count = 0
+    ([1,2,3]).foreach do |i| 
+      count += 1
+    end
+    count.should eq(3)
+  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)
+  end
+  it 'has #head' do
+    (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.get_or_else(999).should eq(1)
+  end
+  it 'has #head_option and it works with None' do
+    none = ([]).head_option
+    none.get_or_else(999).should eq(999)
+  end
+  it 'has #indices' do
+    ([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])
+  end
+  it 'has #intersect' do
+    ([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)
+  end
+  it 'has #last' do
+    ([1,2,3]).last.should eq(3)
+  end
+  it 'has #last_option' do
+    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.apply(0).get.should eq(1)
+    seq_lift.apply(1).get.should eq(2)
+    seq_lift.apply(2).get.should eq(3)
+    seq_lift.apply(3).is_defined.should eq(false)
+    seq_lift.call(0).get.should eq(1)
+    seq_lift.call(1).get.should eq(2)
+    seq_lift.call(2).get.should eq(3)
+    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])
+  end
+  it 'has #max' do
+    (one_to_five_shuffled).max.should eq(5)
+  end
+  it 'has #min' do
+    (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$')
+    begin
+      (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$')
+  end
+  it 'has #non_empty' do
+    (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]])
+  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])
+  end
+  it 'has #reverse' do
+    ([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])
+  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)
+  end
+  it 'has #scan_left' do
+    ([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])
+  end
+  it 'has #slice' do
+    # the already defined method is called
+    #[1,2,3,4,5].slice(1,1).to_a.should eq([])
+    #[1,2,3,4,5].slice(1,2).to_a.should eq([2])
+    #[1,2,3,4,5].slice(1,3).to_a.should eq([2,3])
+    #[1,2,3,4,5].slice(1,4).to_a.should eq([2,3,4])
+    [1,2,3,4,5].slice(1,1).should eq([2])
+    [1,2,3,4,5].slice(1,2).should eq([2,3])
+    [1,2,3,4,5].slice(1,3).should eq([2,3,4])
+    [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]])
+  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])
+  end
+  it 'has #span' do
+    ([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]])
+  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)
+  end
+  it 'has #sum' do
+    ([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([])
+  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])
+  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])
+  end
+  it 'has #take_while' do
+    ([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])
+  end
+  it 'has #updated' do
+    ([1,2,3]).updated(1,999).to_a.should eq([1,999,3])
+  end
+  it 'has #zip' do
+    # the already defined method is called
+    #[1,2,3].zip([2,3]).to_a.should eq([[1,2],[2,3]])
+    #[1,2,3].zip([2,3,4]).to_a.should eq([[1,2],[2,3],[3,4]])
+    #[1,2,3].zip([2,3,4,5]).to_a.should eq([[1,2],[2,3],[3,4]])
+    [1,2,3].zip([2,3]).should eq([[1,2],[2,3],[3,nil]])
+    [1,2,3].zip([2,3,4]).should eq([[1,2],[2,3],[3,4]])
+    [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]])
+  end
+
+end

data/spec/scaruby/core_ext/hash_spec.rb

@@ -0,0 +1,92 @@
+# -*- encoding: utf-8 -*-
+
+require 'scaruby/core_ext'
+
+describe Map 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| 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/map_spec.rb

@@ -67,6 +67,9 @@ describe 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
@@ -75,7 +78,16 @@ describe Map do
     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/seq_spec.rb

@@ -20,6 +20,10 @@ describe Seq do
   it 'has #to_a' do
     Seq.new(one_to_five).to_a.should eq([1,2,3,4,5])
   end
+  it 'has #corresponds' do
+    Seq.new([1,2,3]).corresponds([1,2,3]) {|a,b| a == b }.should eq(true)
+    Seq.new([1,2,3]).corresponds([3,1,2]) {|a,b| a == b }.should eq(false)
+  end
   it 'has #count' do
     Seq.new(one_to_five).count {|i| i > 2 }.should eq(3)
   end
@@ -63,8 +67,8 @@ describe Seq do
   it 'has #find' do
     some = Seq.new(one_to_five).find {|i| i < 3 }
     some.get.should eq(1)
-    some = Seq.new(one_to_five).find {|i| i > 10 }
-    some.is_defined.should eq(false)
+    none = Seq.new(one_to_five).find {|i| i > 10 }
+    none.is_defined.should eq(false)
   end
   it 'has #flat_map and it works with nested arrays' do
     Seq.new([[1,2],[3,4],[5]]).flat_map {|i| i }.to_a.should eq([1,2,3,4,5])
@@ -73,7 +77,24 @@ describe Seq do
     Seq.new([1,2,nil,3]).flat_map {|i| Option.new(i) }.to_a.should eq([1,2,3])
   end
   it 'has #fold_left' do
-    Seq.new(one_to_five_shuffled).fold_left(0) {|z,x| z + x }.should eq(15)
+    input = [1,2,3]
+    expected = [1,2,3]
+    idx = 0
+    Seq.new(input).fold_left(0) {|z,x| 
+      x.should eq(expected[idx])
+      idx += 1
+      z + x 
+    }.should eq(6)
+  end
+  it 'has #fold_right' do
+    input = [1,2,3]
+    expected = [3,2,1]
+    idx = 0
+    Seq.new(input).fold_right(0) {|z,x| 
+      x.should eq(expected[idx])
+      idx += 1
+      z + x 
+    }.should eq(6)
   end
   it 'has #flatten' do
     Seq.new([[1,2],[3,4],[5]]).flatten.to_a.should eq([1,2,3,4,5])
@@ -95,6 +116,10 @@ describe Seq do
     end
     count.should eq(3)
   end
+  it 'has #group_by' do
+    expected = {3=>[3,3,3], 1=>[1,1,1], 2=>[2,2]}
+    Seq.new([1,1,1,2,3,2,3,3]).group_by {|i| i }.to_hash.should eq(expected)
+  end
   it 'has #head' do
     Seq.new(one_to_five).head.should eq(1)
   end
@@ -171,15 +196,9 @@ describe Seq do
   it 'has #patch' do
     Seq.new([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 #reduce_left' do
-  end
-  it 'has #reduce_right' do
-  end
   it 'has #reverse' do
     Seq.new([1,2,3]).reverse.to_a.should eq([3,2,1])
   end
-  it 'has #reverse_iterator' do
-  end
   it 'has #reverse_map' do
     Seq.new([1,2,3]).reverse_map {|i| i + i }.to_a.should eq([6,4,2])
   end
@@ -247,6 +266,9 @@ describe Seq do
   it 'has #union' do
     Seq.new([1,2,3]).union([2,3,4]).to_a.should eq([1,2,3,2,3,4])
   end
+  it 'has #updated' do
+    Seq.new([1,2,3]).updated(1,999).to_a.should eq([1,999,3])
+  end
   it 'has #zip' do
     Seq.new([1,2,3]).zip([2,3]).to_a.should eq([[1,2],[2,3]])
     Seq.new([1,2,3]).zip([2,3,4]).to_a.should eq([[1,2],[2,3],[3,4]])
@@ -256,8 +278,5 @@ describe Seq do
     Seq.new([]).zip_with_index.to_a.should eq([])
     Seq.new([1,2,3]).zip_with_index.to_a.should eq([[1,0],[2,1],[3,2]])
   end
-end
-
-
-
 
+end

metadata

@@ -2,7 +2,7 @@
 name: scaruby
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Kazuhiro Sera
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-02 00:00:00 Z
+date: 2012-03-03 00:00:00 Z
 dependencies: []
 
 description: Scala API in Ruby
@@ -25,11 +25,13 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - Gemfile
+- LICENSE.txt
 - Rakefile
-- lib/array_to_scaruby.rb
-- lib/enumerable_to_scaruby.rb
 - lib/scaruby.rb
 - lib/scaruby/appliable_proc.rb
+- lib/scaruby/core_ext.rb
+- lib/scaruby/core_ext/enumerable.rb
+- lib/scaruby/core_ext/hash.rb
 - lib/scaruby/map.rb
 - lib/scaruby/no_such_element_exception.rb
 - lib/scaruby/option.rb
@@ -37,8 +39,8 @@ files:
 - lib/scaruby/version.rb
 - readme.md
 - scaruby.gemspec
-- spec/array_to_scaruby_spec.rb
-- spec/enumerable_to_scaruby_spec.rb
+- spec/scaruby/core_ext/enumerable_spec.rb
+- spec/scaruby/core_ext/hash_spec.rb
 - spec/scaruby/map_spec.rb
 - spec/scaruby/option_spec.rb
 - spec/scaruby/seq_spec.rb
@@ -71,8 +73,8 @@ signing_key:
 specification_version: 3
 summary: Scala API in Ruby
 test_files: 
-- spec/array_to_scaruby_spec.rb
-- spec/enumerable_to_scaruby_spec.rb
+- spec/scaruby/core_ext/enumerable_spec.rb
+- spec/scaruby/core_ext/hash_spec.rb
 - spec/scaruby/map_spec.rb
 - spec/scaruby/option_spec.rb
 - spec/scaruby/seq_spec.rb

data/lib/array_to_scaruby.rb

@@ -1,10 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'scaruby/seq'
-
-class Array
-  def method_missing(name, *args, &block)
-    Scaruby::Seq.new(self).send(name, *args, &block)
-  end
-end
-

data/lib/enumerable_to_scaruby.rb

@@ -1,10 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'scaruby/seq'
-
-module Enumerable
-  def method_missing(name, *args, &block)
-    Scaruby::Seq.new(self).send(name, *args, &block)
-  end
-end
-

data/spec/array_to_scaruby_spec.rb

@@ -1,23 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'array_to_scaruby'
-
-describe Array do
-  it 'has #flat_map' do
-    flatten = [[1,2],[3],[4,5]].flat_map {|i| i }.to_a
-    flatten.should eq([1,2,3,4,5])
-  end
-  it 'has #count' do
-    result = [1,2,3,4,5].count {|i| i > 2 }
-    result.should eq(3)
-  end
-  it 'has #diff' do
-    result = [1,2,3].diff([2,3,4]).to_a
-    result.should eq([1])
-  end
-  it 'has #distinct' do
-    result = [1,2,4,1,3,3,3,2,4,1].distinct.to_a
-    result.should eq([1,2,4,3])
-  end
-end
-

data/spec/enumerable_to_scaruby_spec.rb

@@ -1,58 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'enumerable_to_scaruby'
-
-describe Enumerable do
-  it 'has #count' do
-    [1,2,3,4,5].count {|i| i > 2 }.should eq(3)
-  end
-  it 'has #diff' do
-    [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])
-  end
-  it 'has #drop_right' do
-    1.upto(5).drop_right(3).to_a.should eq([1,2])
-  end
-  it 'has #drop_while' do
-    [1,2,4,3,5].drop_while {|i| i < 3 }.to_a.should eq([4,3,5])
-  end
-  it 'has #ends_with' do
-    1.upto(5).ends_with([4,5]).should eq(true)
-  end
-  it 'has #exists' do
-    1.upto(5).exists {|i| i == 2 }.should eq(true)
-  end
-  it 'has #filter' do
-    1.upto(5).filter {|i| i < 3 }.to_a.should eq([1,2])
-  end
-  it 'has #filter_not' do
-    1.upto(5).filter_not {|i| i < 3 }.to_a.should eq([3,4,5])
-  end
-  it 'has #flat_map' do
-    flatten = [[1,2],[3],[4,5]].flat_map {|i| i }.to_a
-    flatten.should eq([1,2,3,4,5])
-  end
-  it 'has #flatten' do
-    [[1,2,3],[4,5],[6]].flatten.to_a.should eq([1,2,3,4,5,6])
-  end
-  it 'has #fold_left' do
-    1.upto(5).fold_left(0) {|z,x| z + x }.should eq(15)
-  end
-  it 'has #forall' do
-    1.upto(5).forall {|i| i < 10 }.should eq(true)
-  end
-  it 'has #foreach' do
-    1.upto(5).foreach do |i|
-      i.should <= 5
-    end
-  end
-  it 'has #head' do
-    1.upto(5).head.should eq(1)
-  end
-  it 'has #head_option' do
-    1.upto(5).head_option.is_defined.should eq(true)
-  end
-end
-