scaruby 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+gem "rspec"
+
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/array_to_scaruby.rb

@@ -0,0 +1,10 @@
+# -*- 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

@@ -0,0 +1,10 @@
+# -*- 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/lib/scaruby/appliable_proc.rb

@@ -0,0 +1,8 @@
+# -*- encoding: utf-8 -*-
+
+module Scaruby
+  class AppliableProc < Proc
+    alias_method :apply, :call
+  end
+end
+

data/lib/scaruby/map.rb

@@ -0,0 +1,126 @@
+# -*- encoding: utf-8 -*-
+
+module Scaruby
+  class Map
+
+    def self.empty
+      {}
+    end
+
+    def initialize(hash)
+      @hash = hash
+    end
+
+    def to_hash
+      @hash
+    end
+
+    def to_a
+      @hash.to_a
+    end
+
+    def contains(key)
+      @hash.include?(key)
+    end
+
+    def count(&predicate)
+      count = 0
+      @hash.each do |k,v|
+        if yield k, v then 
+          count += 1
+        end
+      end
+      count
+    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
+      }
+    end
+
+    def filter(&predicate)
+      Map.new(@hash.reject {|k,v| ! yield k, v })
+    end
+
+    def filter_keys(&predicate)
+      Map.new(@hash.reject {|k,v| ! yield k })
+    end
+
+    def filter_not(&predicate)
+      Map.new(@hash.reject {|k,v| yield k, v })
+    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])
+    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
+      }
+    end
+
+    def foreach(&block)
+      @hash.each do |k,v| yield k, v end
+    end
+
+    def get_or_else(key, default_value)
+      value = @hash[key]
+      value.nil? ? default_value : value
+    end
+
+    def is_empty
+      @hash.nil? || @hash.empty?
+    end
+
+    def key_set
+      @hash.keys
+    end
+
+    def lift
+      AppliableProc.new {|k| Option.new(@hash[k]) }
+    end
+
+    def map(&block)
+      Map.new(Hash[*@hash.to_a.map {|k,v| yield k, v }.flatten])
+    end
+
+    def mk_string(*args)
+      case args.size
+      when 0
+        start_part, sep, end_part = '{', ', ', '}'
+      when 1
+        start_part, sep, end_part = '', args[0], ''
+      when 2
+        raise 'Illegal number of arguments'
+      else
+        start_part, sep, end_part = args[0], args[1], args[2]
+      end
+      #start_part + @hash.to_a.collect {|k,v| k.to_s + '=>' + v.to_s }.join(sep) + end_part
+      start_part + @hash.to_a.map {|k,v| k.to_s + '=>' + v.to_s }.join(sep) + end_part
+    end
+
+    def non_empty
+      ! is_empty
+    end
+
+  end
+end
+

data/lib/scaruby/no_such_element_exception.rb

@@ -0,0 +1,6 @@
+# -*- encoding: utf-8 -*-
+
+module Scaruby
+  class NoSuchElementException < Exception
+  end
+end

data/lib/scaruby/option.rb

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+
+require 'scaruby/no_such_element_exception'
+
+module Scaruby
+  class Option
+
+    def self.apply(value)
+      Option.new(value)
+    end
+
+    def initialize(value)
+      @value = value
+    end
+
+    def is_defined
+      @value != nil
+    end
+
+    def get
+      if is_defined then @value 
+      else raise NoSuchElementException 
+      end
+    end
+
+    def get_or_else(default_value)
+      is_defined ? get : default_value
+    end
+
+    def map(&block) 
+      is_defined ? Option.new(yield @value) : self
+    end
+
+  end
+end
+

data/lib/scaruby/seq.rb

@@ -0,0 +1,338 @@
+# -*- encoding: utf-8 -*-
+
+module Scaruby
+  class Seq
+  
+    def self.apply(enumerable)
+      Seq.new(enumerable)
+    end
+
+    def initialize(enumerable)
+      if enumerable.nil? || enumerable.is_a?(Enumerable) then
+        @array = enumerable.to_a
+      else 
+        raise ArgumentError, 'Invalid argument (' + enumerable.to_s + ')'
+      end
+    end
+
+    def to_a
+      @array
+    end
+  
+    def count(&predicate)
+      filter(&predicate).size
+    end
+  
+    def diff(that)
+      filter {|e| ! that.include?(e) }
+    end
+  
+    def distinct 
+      Seq.new(@array.uniq)
+    end
+  
+    def drop(n)
+      Seq.new(@array.drop(n))
+    end
+  
+    def drop_right(n)
+      Seq.new(@array.reverse.drop(n).reverse)
+    end
+  
+    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)] 
+        end
+      }[1])
+    end
+
+    def ends_with(that)
+      if that.nil? || that.length > @array.length then 
+        return false
+      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] 
+        end
+      }
+    end
+
+    def exists(&predicate)
+      @array.inject(false) {|found,e| 
+        if found then true
+        else yield e 
+        end
+      }
+    end
+
+    def filter(&predicate)
+      Seq.new(@array.select {|e| yield e })
+    end
+
+    def filter_not(&predicate)
+      Seq.new(@array.select {|e| ! yield e })
+    end
+
+    def find(&predicate)
+      Option.new(@array.find(&predicate))
+    end
+
+    def flat_map(&block)
+      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 
+          applied.is_defined ? z.push(applied.get) : z
+        else z.push(applied) 
+        end
+      })
+    end
+ 
+    def flatten
+      Seq.new(@array.inject([]) {|z,x|
+        if x.is_a?(Enumerable) then
+          x.inject(z) {|z,elm| z.push(elm) }
+        elsif x.is_a?(Option) then 
+          x.is_defined ? z.push(x.get) : z
+        else 
+          z.push(x) 
+        end
+      })
+    end
+ 
+    def fold_left(z, &block)
+      @array.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 
+        end
+      }
+    end
+
+    def foreach(&block)
+      @array.each do |e| yield e end
+    end
+  
+    def head
+      @array.first
+    end
+  
+    def head_option
+      Option.new(@array.first)
+    end
+
+    def indices
+      Seq.new(0.upto @array.length-1)
+    end
+
+    def init
+      Seq.new(@array.take(@array.length - 1))
+    end
+
+    def intersect(that)
+      Seq.new(@array.inject([]) {|z,x|
+        that.include?(x) ? z.push(x) : z
+      })
+    end
+
+    def is_empty
+      @array.nil? || @array.empty?
+    end
+
+    def last
+      @array.last
+    end
+
+    def last_option
+      Option.new(@array.last)
+    end
+
+    def length
+      @array.length
+    end
+
+    def lift
+      AppliableProc.new {|i| Option.new(@array[i]) }
+    end
+
+    def map(&block)
+      #Seq.new(@array.collect {|e| yield e })
+      Seq.new(@array.map {|e| yield e })
+    end
+  
+    def max 
+      @array.max
+    end
+  
+    def min 
+      @array.min
+    end
+
+    def mk_string(*args)
+      case args.length
+      when 0
+        start_part, sep, end_part = '', '', ''
+      when 1
+        start_part, sep, end_part = '', args[0], ''
+      when 2
+        raise ArgumentError, 'Illegal number of arguments (' + args.length.to_s + ')'
+      else
+        start_part, sep, end_part = args[0], args[1], args[2]
+      end
+      start_part + @array.join(sep) + end_part
+    end
+
+    def non_empty
+      ! is_empty
+    end
+
+    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)] 
+        end
+      })
+    end
+
+    def patch(from, patch, replaced) 
+      Seq.new(
+        @array.take(from)
+          .concat(patch)
+          .concat(@array.drop(from).drop(replaced)))
+    end
+
+    def reverse
+      Seq.new(@array.reverse)
+    end
+
+    def reverse_map(&block)
+      #Seq.new(@array.reverse.collect {|e| yield e })
+      Seq.new(@array.reverse.map {|e| yield e })
+    end
+
+    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] 
+        end
+      }
+    end
+
+    def scan_left(n, &block)
+      Seq.new(@array.inject([n,[n]]) {|last_and_array,x|
+        last, array = last_and_array[0], last_and_array[1]
+        applied = yield last, x
+        [applied, array.push(applied)]
+      }[1])
+    end
+
+    def scan_right(n, &block)
+      Seq.new(@array.reverse.inject([n,[n]]) {|last_and_array,x|
+        last, array = last_and_array[0], last_and_array[1]
+        applied = yield last, x
+        [applied, array.push(applied)]
+      }[1].reverse)
+    end
+
+    def size
+      @array.length
+    end
+
+    def slice(from, until_n)
+      Seq.new(@array.drop(from).take(until_n - from))
+    end
+
+    def sliding(len)
+      result = []
+      @array.each_with_index do |e,idx|
+        if idx < (@array.length - len + 1) then 
+          result.push(@array.slice(idx, len))
+        end
+      end
+      Seq.new(result)
+    end
+
+    def sort_with(&predicate)
+      @array.sort(&predicate)
+    end
+
+    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)] 
+        end
+      }
+      Seq.new([result[1],result[2]])
+    end
+
+    def split_at(n)
+      Seq.new([@array.take(n),@array.drop(n)])
+    end
+
+    def starts_with(that)
+      if that.nil? || that.length > @array.length then 
+        return false
+      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]
+        end
+      }
+    end
+
+    def sum
+      @array.inject(0) {|z,x| z + x }
+    end
+
+    def tail
+      Seq.new(@array.drop(1))
+    end
+
+    def take(n)
+      Seq.new(@array.take(n))
+    end
+
+    def take_right(n)
+      Seq.new(@array.reverse.take(n).reverse)
+    end
+
+    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] 
+        end
+      }[1])
+    end
+
+    def union(that)
+      Seq.new(@array.concat(that))
+    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
+      with_index
+    end
+  
+  end  
+end 

data/lib/scaruby/version.rb

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

data/lib/scaruby.rb

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+require 'scaruby/appliable_proc'
+require 'scaruby/map'
+require 'scaruby/no_such_element_exception'
+require 'scaruby/option'
+require 'scaruby/seq'
+require 'scaruby/version'
+
+module Scaruby
+end
+
+# alias
+class AppliableProc < Scaruby::AppliableProc
+end
+class Map < Scaruby::Map
+end
+class Option < Scaruby::Option
+end
+class Seq < Scaruby::Seq 
+end
+

data/readme.md

@@ -0,0 +1,53 @@
+# Ruby reference for Scala programmers
+
+Surely it works fine. But it mainly serves as a Ruby reference for Scala programmers.
+
+## Setup
+
+```sh
+git clone git://github.com/seratch/scaruby.git
+cd scaruby
+gem install bundler
+bundle install
+```
+
+## Trying on irb
+
+```sh
+bundle console
+```
+
+```ruby
+irb(main):001:0> require 'scaruby'
+=> false
+
+irb(main):003:0> Option.new(nil).is_defined
+=> false
+irb(main):004: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
+=> [1]
+
+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):003:0> Seq.new([1,2,3]).fold_left(0) {|z,x| z + x }
+=> 6
+
+irb(main):001:0> require 'enumerable_to_scaruby'
+=> true
+irb(main):002:0> [[1,2,3],[4,5],[6]].flat_map {|e| e }
+=> [1, 2, 3, 4, 5, 6]
+```
+
+## Testing
+
+```sh
+bundle exec rspec
+```

data/scaruby.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "scaruby/version"
+
+Gem::Specification.new do |s|
+  s.name        = "scaruby"
+  s.version     = Scaruby::VERSION
+  s.authors     = ["Kazuhiro Sera"]
+  s.email       = ["seratch@gmail.com"]
+  s.homepage    = "https://github.com/seratch/scaruby"
+  s.summary     = %q{Scala API in Ruby}
+  s.description = %q{Scala API in Ruby}
+
+  s.rubyforge_project = "scaruby"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  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"
+end

data/spec/array_to_scaruby_spec.rb

@@ -0,0 +1,23 @@
+# -*- 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

@@ -0,0 +1,58 @@
+# -*- 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
+

data/spec/scaruby/map_spec.rb

@@ -0,0 +1,81 @@
+# -*- encoding: utf-8 -*-
+
+require 'scaruby'
+
+describe Map do
+
+  hash = {123 => 'abc', 234 => 'bcd', 345 => 'cde', 4 => 'd', 56 => 'ef', 7 => 'g', 89 => 'hi' }
+
+  it 'has self.new' do
+    map = Map.new({1 => 'a', 2 => 'b'})
+    map.should_not eq(nil)
+  end 
+  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| 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
+    Map.new(hash).foreach do |k,v| 
+      hash.include?(k).should eq(true)
+    end
+  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 #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
+end
+
+
+

data/spec/scaruby/option_spec.rb

@@ -0,0 +1,43 @@
+# -*- 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
+
+
+

data/spec/scaruby/seq_spec.rb

@@ -0,0 +1,263 @@
+# -*- encoding: utf-8 -*-
+
+require 'scaruby'
+
+describe Seq do
+
+  one_to_five = 1.upto 5
+  one_to_five_shuffled = one_to_five.sort_by {rand}
+
+  it 'does not accept invalid args' do
+    begin
+      Seq.new('aaaa').should eq(nil)
+    rescue ArgumentError
+    end
+    begin
+      Seq.new(12345).should eq(nil)
+    rescue ArgumentError
+    end
+  end
+  it 'has #to_a' do
+    Seq.new(one_to_five).to_a.should eq([1,2,3,4,5])
+  end
+  it 'has #count' do
+    Seq.new(one_to_five).count {|i| i > 2 }.should eq(3)
+  end
+  it 'has #diff' do
+    Seq.new([1,2,3]).diff([2,3,4]).to_a.should eq([1])
+  end
+  it 'has #distinct' do
+    Seq.new([1,2,4,1,3,3,3,2,4,1]).distinct.to_a.should eq([1,2,4,3])
+  end
+  it 'has #drop' do
+    Seq.new(one_to_five).drop(3).to_a.should eq([4,5])
+    Seq.new(one_to_five).drop(7).to_a.should eq([])
+  end
+  it 'has #drop_right' do
+    Seq.new(one_to_five).drop_right(3).to_a.should eq([1,2])
+    Seq.new(one_to_five).drop_right(7).to_a.should eq([])
+  end
+  it 'has #drop_while' do
+    Seq.new([5,3,2,4,1]).drop_while {|e| e > 2 }.to_a.should eq([2,4,1])
+  end
+  it 'has #ends_with' do
+    Seq.new([1,2,3]).ends_with([1,2]).should eq(false)
+    Seq.new([1,2,3]).ends_with([1,2,3]).should eq(true)
+    Seq.new([1,2,3]).ends_with([1,1,2,3]).should eq(false)
+    Seq.new([1,2,3]).ends_with([2,3]).should eq(true)
+    Seq.new([1,2,3]).ends_with([3]).should eq(true)
+  end
+  it 'has #exists' do
+    Seq.new([1,2,3]).exists {|i| i < 2 }.should eq(true)
+    Seq.new([1,2,3]).exists {|i| i < 4 }.should eq(true)
+    Seq.new([2,3,4]).exists {|i| i > 4 }.should eq(false)
+  end
+  it 'has #filter' do
+    Seq.new(one_to_five).filter {|i| i > 3 }.to_a.should eq([4,5])
+    Seq.new(one_to_five).filter {|i| i > 10 }.to_a.should eq([])
+  end
+  it 'has #filter_not' do
+    Seq.new(one_to_five).filter_not {|i| i > 3 }.to_a.should eq([1,2,3])
+    Seq.new(one_to_five).filter_not {|i| i > 10 }.to_a.should eq([1,2,3,4,5])
+  end
+  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)
+  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])
+  end
+  it 'has #flat_map and it works with Option elements' 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)
+  end
+  it 'has #flatten' do
+    Seq.new([[1,2],[3,4],[5]]).flatten.to_a.should eq([1,2,3,4,5])
+    Seq.new(
+      [Option.new(1),
+       Option.new(2),
+       Option.new(nil),
+       Option.new(3)]
+    ).flatten.to_a.should eq([1,2,3])
+  end
+  it 'has #forall' do
+    Seq.new([1,2,3]).forall {|i| i > 0 }.should eq(true)
+    Seq.new([1,2,3]).forall {|i| i > 1 }.should eq(false)
+  end
+  it 'has #foreach' do
+    count = 0
+    Seq.new([1,2,3]).foreach do |i| 
+      count += 1
+    end
+    count.should eq(3)
+  end
+  it 'has #head' do
+    Seq.new(one_to_five).head.should eq(1)
+  end
+  it 'has #head_option and it works with Some' do
+    some = Seq.new(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 = Seq.new([]).head_option
+    none.get_or_else(999).should eq(999)
+  end
+  it 'has #indices' do
+    Seq.new([1,2,3]).indices.to_a.should eq([0,1,2])
+  end
+  it 'has #init' do
+    Seq.new([1,2,3]).init.to_a.should eq([1,2])
+  end
+  it 'has #intersect' do
+    Seq.new([1,2,3]).intersect([2,3,4]).to_a.should eq([2,3])
+  end
+  it 'has #is_empty' do
+    Seq.new([1,2,3]).is_empty.should eq(false)
+    Seq.new([nil]).is_empty.should eq(false)
+    Seq.new([]).is_empty.should eq(true)
+    Seq.new(nil).is_empty.should eq(true)
+  end
+  it 'has #last' do
+    Seq.new([1,2,3]).last.should eq(3)
+  end
+  it 'has #last_option' do
+    some = Seq.new([1,2,3]).last_option
+    some.get.should eq(3)
+    none = Seq.new([]).last_option
+    none.is_defined.should eq(false)
+  end
+  it 'has #lift' do
+    seq_lift = Seq.new([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
+    Seq.new([1,2,3]).map {|i| i + i }.to_a.should eq([2,4,6])
+  end
+  it 'has #max' do
+    Seq.new(one_to_five_shuffled).max.should eq(5)
+  end
+  it 'has #min' do
+    Seq.new(one_to_five_shuffled).min.should eq(1)
+  end
+  it 'has #mk_string' do
+    Seq.new(one_to_five).mk_string.should eq('12345')
+    Seq.new(one_to_five).mk_string(',').should eq('1,2,3,4,5')
+    Seq.new(one_to_five).mk_string('^',',','$').should eq('^1,2,3,4,5$')
+    begin
+      Seq.new(one_to_five).mk_string('a','b').should eq(nil)
+    rescue ArgumentError
+    end
+    Seq.new(one_to_five).mk_string('^',',','$','zzz').should eq('^1,2,3,4,5$')
+  end
+  it 'has #non_empty' do
+    Seq.new(one_to_five).non_empty.should eq(true)
+    Seq.new([]).non_empty.should eq(false)
+    Seq.new(nil).non_empty.should eq(false)
+  end
+  it 'has #partition' do
+    Seq.new([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
+    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
+  it 'has #same_elements' do
+    Seq.new([1,2,3]).same_elements([1,2,3]).should eq(true)
+    Seq.new([1,2,3]).same_elements([1,3,2]).should eq(false)
+    Seq.new([1,2,3]).same_elements([1,2]).should eq(false)
+  end
+  it 'has #scan_left' do
+    Seq.new([1,2,3]).scan_left(1) {|a,b| a + b }.to_a.should eq([1,2,4,7])
+  end
+  it 'has #scan_right' do
+    Seq.new([1,2,3]).scan_right(1) {|a,b| a + b }.to_a.should eq([7,6,4,1])
+  end
+  it 'has #slice' do
+    Seq.new([1,2,3,4,5]).slice(1,1).to_a.should eq([])
+    Seq.new([1,2,3,4,5]).slice(1,2).to_a.should eq([2])
+    Seq.new([1,2,3,4,5]).slice(1,3).to_a.should eq([2,3])
+    Seq.new([1,2,3,4,5]).slice(1,4).to_a.should eq([2,3,4])
+  end
+  it 'has #sliding' do
+    Seq.new([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
+    Seq.new([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
+    Seq.new([1,2,3,2,1]).span {|i| i < 3 }.to_a.should eq([[1,2],[3,2,1]])
+  end
+  it 'has #split_at' do
+    Seq.new([1,2,3,2,1]).split_at(3).to_a.should eq([[1,2,3],[2,1]])
+  end
+  it 'has #starts_with' do
+    Seq.new([1,2,3]).starts_with([1]).should eq(true)
+    Seq.new([1,2,3]).starts_with([1,2]).should eq(true)
+    Seq.new([1,2,3]).starts_with([1,2,3]).should eq(true)
+    Seq.new([1,2,3]).starts_with([1,2,3,4]).should eq(false)
+    Seq.new([1,2,3]).starts_with([2,3]).should eq(false)
+    Seq.new([1,2,3]).starts_with([4,1,2,3]).should eq(false)
+  end
+  it 'has #sum' do
+    Seq.new([1,2,3]).sum.should eq(6)
+  end
+  it 'has #tail' do
+    Seq.new([1,2,3]).tail.to_a.should eq([2,3])
+    Seq.new([]).tail.to_a.should eq([])
+  end
+  it 'has #take' do
+    Seq.new([1,2,3]).take(0).to_a.should eq([])
+    Seq.new([1,2,3]).take(1).to_a.should eq([1])
+    Seq.new([1,2,3]).take(2).to_a.should eq([1,2])
+    Seq.new([1,2,3]).take(3).to_a.should eq([1,2,3])
+    Seq.new([1,2,3]).take(4).to_a.should eq([1,2,3])
+  end
+  it 'has #take_right' do
+    Seq.new([1,2,3]).take_right(0).to_a.should eq([])
+    Seq.new([1,2,3]).take_right(1).to_a.should eq([3])
+    Seq.new([1,2,3]).take_right(2).to_a.should eq([2,3])
+    Seq.new([1,2,3]).take_right(3).to_a.should eq([1,2,3])
+    Seq.new([1,2,3]).take_right(4).to_a.should eq([1,2,3])
+  end
+  it 'has #take_while' do
+    Seq.new([5,3,2,4,1]).take_while {|e| e > 2 }.to_a.should eq([5,3])
+  end
+  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 #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]])
+    Seq.new([1,2,3]).zip([2,3,4,5]).to_a.should eq([[1,2],[2,3],[3,4]])
+  end
+  it 'has #zip_with_index' 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
+
+
+
+

data/spec/scaruby_spec.rb

@@ -0,0 +1,7 @@
+# -*- encoding: utf-8 -*-
+
+describe Scaruby do
+  it 'is available' do
+  end
+end
+

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: scaruby
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Kazuhiro Sera
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-03-02 00:00:00 Z
+dependencies: []
+
+description: Scala API in Ruby
+email: 
+- seratch@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- lib/array_to_scaruby.rb
+- lib/enumerable_to_scaruby.rb
+- lib/scaruby.rb
+- lib/scaruby/appliable_proc.rb
+- lib/scaruby/map.rb
+- lib/scaruby/no_such_element_exception.rb
+- lib/scaruby/option.rb
+- lib/scaruby/seq.rb
+- lib/scaruby/version.rb
+- readme.md
+- scaruby.gemspec
+- spec/array_to_scaruby_spec.rb
+- spec/enumerable_to_scaruby_spec.rb
+- spec/scaruby/map_spec.rb
+- spec/scaruby/option_spec.rb
+- spec/scaruby/seq_spec.rb
+- spec/scaruby_spec.rb
+homepage: https://github.com/seratch/scaruby
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: scaruby
+rubygems_version: 1.8.15
+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/map_spec.rb
+- spec/scaruby/option_spec.rb
+- spec/scaruby/seq_spec.rb
+- spec/scaruby_spec.rb