jactive_support 1.0.0-universal-java-1.6

data/lib/jactive_support.rb

@@ -0,0 +1,5 @@
+require 'jactive_support/java_ext'
+require 'jactive_support/core_ext'
+require 'jactive_support/json'
+require 'jactive_support/rescuable'
+require 'jactive_support/constantize'

data/spec/constantize_spec.rb

@@ -0,0 +1,57 @@
+require 'java'
+require 'active_support'
+require 'jactive_support/constantize'
+
+class InflectorTest
+  def call_constantize(name)
+    ActiveSupport::Inflector.constantize(name)
+  end
+end
+module Ace
+  module Base
+    class Case
+    end
+  end
+end
+
+describe "constantize with jruby" do
+
+  it "should find named ruby constants" do
+    ActiveSupport::Inflector.constantize("Ace::Base::Case").should be(Ace::Base::Case)
+    ActiveSupport::Inflector.constantize("::Ace::Base::Case").should be(Ace::Base::Case)
+    ActiveSupport::Inflector.constantize("::InflectorTest").should be(InflectorTest)
+  end
+  
+  it "raises a NameError on invalid ruby constants" do
+    expect { ActiveSupport::Inflector.constantize("UnknownClass") }.to raise_error(NameError, 'uninitialized constant UnknownClass')
+    expect { ActiveSupport::Inflector.constantize("An invalid string") }.to raise_error(NameError, 'wrong constant name An invalid string')
+    expect { ActiveSupport::Inflector.constantize("InvalidClass\n") }.to raise_error(NameError, "wrong constant name InvalidClass\n")
+  end
+
+  it "should do lexical lookup" do
+    expect{ puts InflectorTest.new.call_constantize("::Ace::Base::InflectorTest").inspect }.to raise_error(NameError, 'uninitialized constant Ace::Base::InflectorTest')
+  end
+  
+  it "should find a java class" do
+    ActiveSupport::Inflector.constantize("Java::JavaLang::Thread").should be(java.lang.Thread);
+  end
+  
+  it "should be able to lookup the canonical name of a java class" do
+    ActiveSupport::Inflector.constantize(java.lang.Thread.name).should be(java.lang.Thread);
+  end
+
+  it "should raise a NameError when trying to lookup an unknown java class" do
+    expect{ ActiveSupport::Inflector.constantize("Java::ComMuh::Miav") }.to raise_error(NameError, 'cannot load Java class com.muh.Miav')
+  end
+  
+#=begin comment
+  #Java packages currently don't have a should method with the normal setup
+  it "should find a java package" do
+    ActiveSupport::Inflector.constantize("Java::JavaLang").should be(java.lang);
+  end
+
+  it "should find an unknown java package" do
+    ActiveSupport::Inflector.constantize("Java::ComMuh").should be(nil)
+  end
+#=end
+end

data/spec/core_ext/hash_spec.rb

@@ -0,0 +1,34 @@
+require 'jactive_support/core_ext/hash'
+
+describe Hash do
+  describe "assert_valid_params" do
+    it "should not raise an error when assert_valid_params is called with correct parameters" do
+      { :failure => "stuff", :funny => "business" }.assert_valid_params([ :failure, :funny ])
+      { :failure => "stuff", :funny => "business" }.assert_valid_params(:failure, :funny)
+    end
+
+    it "should raise an error when assert_valid_params is called with incorrect parameters" do
+      expect{ 
+        { :failore => "stuff", :funny => "business" }.assert_valid_params([ :failure, :funny ])
+      }.to raise_error(JactiveSupport::InvalidParameter, "Unknown key(s): failore")
+  
+      expect{ 
+        { :failore => "stuff", :funny => "business" }.assert_valid_params(:failure, :funny) 
+      }.to raise_error(JactiveSupport::InvalidParameter, "Unknown key(s): failore")
+    end
+  end
+  
+  describe "supports with_keys_values" do
+    it "should make a new Hash with arguments as keys and values" do
+      Hash.with_keys_values([:one, :two], [1, 2]).should eq(:one=>1, :two=>2)
+    end
+    
+    it "should support empty arrays" do
+      Hash.with_keys_values([], []).should eq({})
+    end
+    
+    it "raises ArgumentError when keys and values don't have same size" do
+      expect { Hash.with_keys_values([:one, :two], [1]) }.to raise_error(ArgumentError, "Unmatching sizes 2 != 1")
+    end
+  end
+end

data/spec/core_ext/module_spec.rb

@@ -0,0 +1,19 @@
+require 'jactive_support/core_ext/module'
+
+class Base
+  def self.inherited(other)
+    other.instance_variable_set('@thename', other.name || '')
+  end
+end
+
+Test2 = Class.new(Base)
+
+describe Module, 'define_class' do
+  it "normal dynamic class does not have access to name in inherited" do
+    Test2.instance_variable_get('@thename').should eq('')
+  end
+  
+  it "should have access to name even in inherited" do
+    Object.define_class('Test', Base).instance_variable_get('@thename').should eq('Test')
+  end
+end

data/spec/core_ext/ordering_spec.rb

@@ -0,0 +1,12 @@
+require 'jactive_support/core_ext/ordering'
+
+describe "ordering" do
+  it "has an order" do
+    (nil <=> nil).should be(0)
+    (nil <=> 1).should be(-1)
+    (true <=> true).should be(0)
+    (true <=> 1).should be(-1)
+    (false <=> false).should be(0)
+    (false <=> 1).should be(1)
+  end
+end

data/spec/enum_spec.rb

@@ -0,0 +1,67 @@
+require 'java'
+require 'active_support'
+require 'jactive_support/core_ext/enum'
+
+describe 'enum' do
+
+  it 'returns matching enum object when calling find_value_of with exact named symbol or string' do
+    java::lang::Thread::State.find_value_of(:NEW).should be(java::lang::Thread::State::NEW)
+    java::lang::Thread::State.find_value_of('NEW').should be(java::lang::Thread::State::NEW)
+  end
+  
+  it 'returns matching enum object when calling find_value_of with underscored symbol or string' do
+    java::lang::Thread::State.find_value_of(:n_e_w).should be(java::lang::Thread::State::NEW)
+    java::lang::Thread::State.find_value_of('n_e_w').should be(java::lang::Thread::State::NEW)
+  end
+
+  it 'fails when calling find_value_of with value not in enum' do
+    expect {
+      java::lang::Thread::State.find_value_of(:MISSING)
+    }.to raise_error(NativeException, "java.lang.IllegalArgumentException: No enum const class java.lang.Thread$State.MISSING")
+
+    expect {
+      java::lang::Thread::State.find_value_of(:missing_link)
+    }.to raise_error(NativeException, "java.lang.IllegalArgumentException: No enum const class java.lang.Thread$State.missing_link")
+  end
+
+  it 'should be comparable with a symbol when using ===' do
+    t = java::lang::Thread::State::NEW
+    t.should === :NEW
+    :NEW.should === t
+  end
+
+  it 'should be comparable with an underscored symbol when using ===' do
+    t = java::lang::Thread::State::NEW
+    t.should === :n_e_w
+    :n_e_w.should === t
+  end
+
+  it 'should be comparable with a string when using ===' do
+    t = java::lang::Thread::State::NEW
+    t.should === 'NEW'
+    'NEW'.should === t
+  end
+
+
+  it 'should be comparable with an underscored string when using ===' do
+    t = java::lang::Thread::State::NEW
+    t.should === 'n_e_w'
+    'n_e_w'.should === t
+  end
+  
+  it 'should return the enum object when calling to_java on a symbol or string with enum class as argument' do
+    :NEW.to_java(java::lang::Thread::State).should be(java::lang::Thread::State::NEW)
+    'NEW'.to_java(java::lang::Thread::State).should be(java::lang::Thread::State::NEW)
+    :n_e_w.to_java(java::lang::Thread::State).should be(java::lang::Thread::State::NEW)
+    'n_e_w'.to_java(java::lang::Thread::State).should be(java::lang::Thread::State::NEW)
+  end
+
+  it 'fails when calling to_java on a symbol or string whose value can not be found in the provided enum class' do
+    expect {
+      :MISSING.to_java(java::lang::Thread::State)
+      }.to raise_error(TypeError, "No enum const class java.lang.Thread$State.MISSING")
+    expect {
+      'MISSING'.to_java(java::lang::Thread::State)
+    }.to raise_error(TypeError, "No enum const class java.lang.Thread$State.MISSING")
+  end
+end

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