jactive_support 1.0.2

data/spec/java_ext/iterable/clear_spec.rb

@@ -0,0 +1,56 @@
+require 'jactive_support/java_ext/iterable'
+require File.expand_path('../shared/fixtures', __FILE__)
+
+describe "java::lang::Iterable#clear" do
+  it "removes all elements" do
+    a = Itr[1, 2, 3, 4]
+    a.clear.should equal(a)
+    a.should == Itr[]
+  end
+
+  it "returns self" do
+    a = Itr[1]
+    oid = a.object_id
+    a.clear.object_id.should == oid
+  end
+
+  it "leaves the Iterable empty" do
+    a = Itr[1]
+    a.clear
+    a.empty?.should == true
+  end
+
+  it "keeps tainted status" do
+    a = Itr[1]
+    a.taint
+    a.tainted?.should be_true
+    a.clear
+    a.tainted?.should be_true
+  end
+
+  it "does not accept any arguments" do
+    lambda { Itr[1].clear(true) }.should raise_error(ArgumentError)
+  end
+
+  ruby_version_is '1.9' do
+    it "keeps untrusted status" do
+      a = Itr[1]
+      a.untrust
+      a.untrusted?.should be_true
+      a.clear
+      a.untrusted?.should be_true
+    end
+  end
+
+  ruby_version_is '' ... '1.9' do
+    it "raises a TypeError on a frozen iterable" do
+      lambda { IterableSpecs.frozen_iterable.clear }.should raise_error(TypeError)
+    end
+  end
+
+  ruby_version_is '1.9' do
+    it "raises a RuntimeError on a frozen iterable" do
+      lambda { IterableSpecs.frozen_iterable.clear }.should raise_error(RuntimeError)
+    end
+  end
+end

data/spec/java_ext/iterable/delete_if_spec.rb

@@ -0,0 +1,71 @@
+require 'jactive_support/java_ext/iterable'
+require File.expand_path('../shared/fixtures', __FILE__)
+require File.expand_path('../shared/enumeratorize', __FILE__)
+
+describe "java::lang::Iterable#delete_if" do
+  before do
+    @a = Itr[ "a", "b", "c" ]
+  end
+
+  it "removes each element for which block returns true" do
+    @a = Itr[ "a", "b", "c" ]
+    @a.delete_if { |x| x >= "b" }
+    @a.should == Itr["a"]
+  end
+
+  it "returns self" do
+    @a.delete_if{ true }.equal?(@a).should be_true
+  end
+
+  it_behaves_like :enumeratorize, :delete_if
+
+  it "returns self when called on an Iterable emptied with #shift" do
+    iterable = Itr[1]
+    iterable.shift
+    iterable.delete_if { |x| true }.should equal(iterable)
+  end
+
+  ruby_version_is '1.8.7' do
+    it "returns an Enumerator if no block given, and the enumerator can modify the original iterable" do
+      enum = @a.delete_if
+      enum.should be_an_instance_of(enumerator_class)
+      @a.should_not be_empty
+      enum.each { true }
+      @a.should be_empty
+    end
+  end
+
+  ruby_version_is '' ... '1.9' do
+    it "raises a TypeError on a frozen iterable" do
+      lambda { IterableSpecs.frozen_iterable.delete_if {} }.should raise_error(TypeError)
+    end
+    it "raises a TypeError on an empty frozen iterable" do
+      lambda { IterableSpecs.empty_frozen_iterable.delete_if {} }.should raise_error(TypeError)
+    end
+  end
+
+  ruby_version_is '1.9' do
+    it "raises a RuntimeError on a frozen iterable" do
+      lambda { IterableSpecs.frozen_iterable.delete_if {} }.should raise_error(RuntimeError)
+    end
+    it "raises a RuntimeError on an empty frozen iterable" do
+      lambda { IterableSpecs.empty_frozen_iterable.delete_if {} }.should raise_error(RuntimeError)
+    end
+  end
+
+  it "keeps tainted status" do
+    @a.taint
+    @a.tainted?.should be_true
+    @a.delete_if{ true }
+    @a.tainted?.should be_true
+  end
+
+  ruby_version_is '1.9' do
+    it "keeps untrusted status" do
+      @a.untrust
+      @a.untrusted?.should be_true
+      @a.delete_if{ true }
+      @a.untrusted?.should be_true
+    end
+  end
+end

data/spec/java_ext/iterable/empty_spec.rb

@@ -0,0 +1,10 @@
+require 'jactive_support/java_ext/iterable'
+require File.expand_path('../shared/fixtures', __FILE__)
+
+describe "java::lang::Iterable#empty?" do
+  it "returns true if the iterable has no elements" do
+    Itr[].empty?.should == true
+    Itr[1].empty?.should == false
+    Itr[1, 2].empty?.should == false
+  end
+end

data/spec/java_ext/iterable/reject_spec.rb

@@ -0,0 +1,76 @@
+require 'jactive_support/java_ext/iterable'
+require File.expand_path('../shared/fixtures', __FILE__)
+require File.expand_path('../shared/enumeratorize', __FILE__)
+
+describe "java::lang::Iterable#reject!" do
+  it "removes elements for which block is true" do
+    a = Itr[3, 4, 5, 6, 7, 8, 9, 10, 11]
+    a.reject! { |i| i % 2 == 0 }.should equal(a)
+    a.should == Itr[3, 5, 7, 9, 11]
+    a.reject! { |i| i > 8 }
+    a.should == Itr[3, 5, 7]
+    a.reject! { |i| i < 4 }
+    a.should == Itr[5, 7]
+    a.reject! { |i| i == 5 }
+    a.should == Itr[7]
+    a.reject! { true }
+    a.should == Itr[]
+    a.reject! { true }
+    a.should == Itr[]
+  end
+
+  it "properly handles recursive iterables" do
+    empty = IterableSpecs.empty_recursive_iterable
+    empty_dup = empty.dup
+    empty.reject! { false }.should == nil
+    empty.should == empty_dup
+
+    empty = IterableSpecs.empty_recursive_iterable
+    empty.reject! { true }.should == Itr[]
+    empty.should == Itr[]
+
+    iterable = IterableSpecs.recursive_iterable
+    iterable_dup = iterable.dup
+    iterable.reject! { false }.should == nil
+    iterable.should == iterable_dup
+
+    iterable = IterableSpecs.recursive_iterable
+    iterable.reject! { true }.should == Itr[]
+    iterable.should == Itr[]
+  end
+
+  it "returns nil when called on an Iterable emptied with #shift" do
+    iterable = Itr[1]
+    iterable.shift
+    iterable.reject! { |x| true }.should == nil
+  end
+
+  it "returns nil if no changes are made" do
+    a = Itr[1, 2, 3]
+
+    a.reject! { |i| i < 0 }.should == nil
+
+    a.reject! { true }
+    a.reject! { true }.should == nil
+  end
+
+  ruby_version_is "" ... "1.9" do
+    it "raises a TypeError on a frozen iterable" do
+      lambda { IterableSpecs.frozen_iterable.reject! {} }.should raise_error(TypeError)
+    end
+    it "raises a TypeError on an empty frozen iterable" do
+      lambda { IterableSpecs.empty_frozen_iterable.reject! {} }.should raise_error(TypeError)
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises a RuntimeError on a frozen iterable" do
+      lambda { IterableSpecs.frozen_iterable.reject! {} }.should raise_error(RuntimeError)
+    end
+    it "raises a RuntimeError on an empty frozen iterable" do
+      lambda { IterableSpecs.empty_frozen_iterable.reject! {} }.should raise_error(RuntimeError)
+    end
+  end
+
+  it_behaves_like :enumeratorize, :reject!
+end

data/spec/java_ext/iterable/shared/enumeratorize.rb

@@ -0,0 +1,12 @@
+shared_examples_for :enumeratorize do |method|
+  ruby_version_is '' ... '1.8.7' do
+    it 'raises a LocalJumpError if no block given' do
+      lambda{ Itr[1,2].send(method) }.should raise_error(LocalJumpError)
+    end
+  end
+  ruby_version_is '1.8.7' do
+    it 'returns an Enumerator if no block given' do
+      Itr[1,2].send(method).should be_an_instance_of(enumerator_class)
+    end
+  end
+end

data/spec/java_ext/iterable/shared/fixtures.rb

@@ -0,0 +1,90 @@
+require File.expand_path('../../../../shared/version', __FILE__)
+require File.expand_path('../../../../shared/fixtures', __FILE__)
+require 'jactive_support/core_ext/to_java'
+require 'jactive_support/core_ext/to_java_list'
+
+class Itr
+  class Iterator
+    include java::util::Iterator
+    
+    def initialize(array)
+      @array = array
+      @next = 0
+    end
+    
+    def hasNext
+      @next < @array.size
+    end
+    
+    def next
+      raise java::util::NoSuchElementException.new('No next element available') unless hasNext
+      @next += 1
+      @array[@next-1]
+    end
+    
+    def remove
+      raise java::lang::IllegalStateException.new('Can not remove until after next is called') if @next == 0
+      @next -= 1
+      @array.delete_at(@next)
+    end
+  end
+  
+  def self.[](*args)
+    new(args)
+  end
+  
+  attr_reader :value 
+  
+  def initialize(arr)
+    @value = arr
+  end
+  
+  include java::lang::Iterable
+  
+  def iterator
+    Iterator.new(@value)
+  end
+  
+  def ==(o)
+    o = o.to_a if o.respond_to?(:to_a)
+    to_a == o
+  end
+  
+  def to_a
+    value
+  end
+  
+  def <<(o)
+    value << o
+  end
+  
+  def [](*args)
+    Itr.new(value[*args])
+  end
+end
+
+module IterableSpecs
+  def self.frozen_iterable
+    frozen_array = Itr[1,2,3]
+    frozen_array.freeze
+    frozen_array
+  end
+
+  def self.empty_frozen_iterable
+    frozen_array = Itr[]
+    frozen_array.freeze
+    frozen_array
+  end
+
+  def self.recursive_iterable
+    a = Itr[1, 'two', 3.0]
+    5.times { a << a }
+    a
+  end
+
+  def self.empty_recursive_iterable
+    a = Itr[]
+    a << a
+    a
+  end
+end

data/spec/java_ext/iterable/shift_spec.rb

@@ -0,0 +1,160 @@
+require 'jactive_support/java_ext/iterable'
+require File.expand_path('../shared/fixtures', __FILE__)
+
+describe "java::lang::Iterable#shift" do
+  it "removes and returns the first element" do
+    a = Itr[5, 1, 1, 5, 4]
+    a.shift.should == 5
+    a.should == Itr[1, 1, 5, 4]
+    a.shift.should == 1
+    a.should == Itr[1, 5, 4]
+    a.shift.should == 1
+    a.should == Itr[5, 4]
+    a.shift.should == 5
+    a.should == Itr[4]
+    a.shift.should == 4
+    a.should == Itr[]
+  end
+
+  it "returns nil when the iterable is empty" do
+    Itr[].shift.should == nil
+  end
+
+  it "properly handles recursive iterables" do
+    empty = IterableSpecs.empty_recursive_iterable
+    empty.shift.should == Itr[]
+    empty.should == Itr[]
+
+    iterable = IterableSpecs.recursive_iterable
+    iterable.shift.should == 1
+    iterable[0..2].should == Itr['two', 3.0, iterable]
+  end
+
+  ruby_version_is "" ... "1.9" do
+    it "raises a TypeError on a frozen iterable" do
+      lambda { IterableSpecs.frozen_iterable.shift }.should raise_error(TypeError)
+    end
+    it "raises a TypeError on an empty frozen iterable" do
+      lambda { IterableSpecs.empty_frozen_iterable.shift }.should raise_error(TypeError)
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises a RuntimeError on a frozen iterable" do
+      lambda { IterableSpecs.frozen_iterable.shift }.should raise_error(RuntimeError)
+    end
+    it "raises a RuntimeError on an empty frozen iterable" do
+      lambda { IterableSpecs.empty_frozen_iterable.shift }.should raise_error(RuntimeError)
+    end
+  end
+
+  ruby_version_is '' ... '1.8.7' do
+    it "raises an ArgumentError if passed an argument" do
+      lambda{ Itr[1, 2].shift(1) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "passed a number n as an argument" do
+    ruby_version_is '1.8.7' do
+      it "removes and returns an iterable with the first n element of the iterable" do
+        a = Itr[1, 2, 3, 4, 5, 6]
+
+        a.shift(0).should == []
+        a.should == Itr[1, 2, 3, 4, 5, 6]
+
+        a.shift(1).should == [1]
+        a.should == Itr[2, 3, 4, 5, 6]
+
+        a.shift(2).should == [2, 3]
+        a.should == Itr[4, 5, 6]
+
+        a.shift(3).should == [4, 5, 6]
+        a.should == Itr[]
+      end
+
+      it "does not corrupt the iterable when shift without arguments is followed by shift with an argument" do
+        a = Itr[1, 2, 3, 4, 5]
+
+        a.shift.should == 1
+        a.shift(3).should == [2, 3, 4]
+        a.should == Itr[5]
+      end
+
+      it "returns a new empty iterable if there are no more elements" do
+        a = Itr[]
+        popped1 = a.shift(1)
+        popped1.should == []
+        a.should == Itr[]
+
+        popped2 = a.shift(2)
+        popped2.should == []
+        a.should == Itr[]
+
+        popped1.should_not equal(popped2)
+      end
+
+      it "returns whole elements if n exceeds size of the iterable" do
+        a = Itr[1, 2, 3, 4, 5]
+        a.shift(6).should == [1, 2, 3, 4, 5]
+        a.should == Itr[]
+      end
+
+      it "does not return self even when it returns whole elements" do
+        a = Itr[1, 2, 3, 4, 5]
+        a.shift(5).should_not equal(a)
+
+        a = Itr[1, 2, 3, 4, 5]
+        a.shift(6).should_not equal(a)
+      end
+
+      it "raises an ArgumentError if n is negative" do
+        lambda{ Itr[1, 2, 3].shift(-1) }.should raise_error(ArgumentError)
+      end
+
+      it "tries to convert n to an Integer using #to_int" do
+        a = Itr[1, 2, 3, 4]
+        a.shift(2.3).should == [1, 2]
+
+        obj = mock('to_int')
+        obj.should_receive(:to_int).and_return(2)
+        a.should == Itr[3, 4]
+        a.shift(obj).should == [3, 4]
+        a.should == Itr[]
+      end
+
+      it "raises a TypeError when the passed n can be coerced to Integer" do
+        lambda{ Itr[1, 2].shift("cat") }.should raise_error(TypeError)
+        lambda{ Itr[1, 2].shift(nil) }.should raise_error(TypeError)
+      end
+
+      it "raises an ArgumentError if more arguments are passed" do
+        lambda{ Itr[1, 2].shift(1, 2) }.should raise_error(ArgumentError)
+      end
+
+      it "returns ruby arrays" do
+        Itr[1, 2, 3].shift(2).should be_kind_of(Array)
+      end
+
+      it "returns an untainted iterable even if the iterable is tainted" do
+        ary = Itr[1, 2].taint
+        ary.shift(2).tainted?.should be_false
+        ary.shift(0).tainted?.should be_false
+      end
+
+      it "keeps taint status" do
+        a = Itr[1, 2].taint
+        a.shift(2)
+        a.tainted?.should be_true
+        a.shift(2)
+        a.tainted?.should be_true
+      end
+
+      ruby_version_is '' ... '1.9' do
+        it "raises a TypeError on a frozen iterable" do
+          lambda { IterableSpecs.frozen_iterable.shift(2) }.should raise_error(TypeError)
+          lambda { IterableSpecs.frozen_iterable.shift(0) }.should raise_error(TypeError)
+        end
+      end
+    end
+  end
+end