jactive_support 1.0.0-universal-java-1.6

data/spec/java_ext/map/shared/update.rb

@@ -0,0 +1,95 @@
+shared_examples_for :hash_update do |method|
+  before { @method = method }
+
+=begin self
+  it "returns self" do
+    h = new_hash(:_1 => 'a', :_2 => '3')
+    h.send(@method, :_1 => '9', :_9 => 2).should equal(h)
+  end
+=end
+
+  it "adds the entries from other, overwriting duplicate keys" do
+    h = new_hash(:_1 => 'a', :_2 => '3')
+    h.send(@method, :_1 => '9', :_9 => 2)
+    h.should == new_hash(:_1 => "9", :_2 => "3", :_9 => 2)
+  end
+
+=begin self
+  it "returns self with block" do
+    h1 = new_hash(:a => 2, :b => -1)
+    h2 = new_hash(:a => -2, :c => 1)
+    h1.send(@method, h2) { |k,x,y| 3.14 }.should equal(h1)
+  end
+=end
+
+=begin nil
+  it "sets any duplicate key to the value of block if passed a block" do
+    h1 = new_hash(:a => 2, :b => -1)
+    h2 = new_hash(:a => -2, :c => 1)
+    h1.send(@method, h2) { |k,x,y| 3.14 }
+    h1.should == new_hash(:c => 1, :b => -1, :a => 3.14)
+
+    h1.send(@method, h1) { nil }
+    h1.should == new_hash(:a => nil, :b => nil, :c => nil)
+  end
+=end
+
+  it "tries to convert the passed argument to a hash using #to_hash" do
+    obj = mock('{1=>2}')
+    obj.should_receive(:to_hash).and_return(new_hash(1 => 2).to_hash)
+    new_hash(3 => 4).send(@method, obj).should == new_hash(1 => 2, 3 => 4)
+  end
+
+  it "does not call to_hash on hash subclasses" do
+    new_hash(3 => 4).send(@method, ToHashHash[1 => 2]).should == new_hash(1 => 2, 3 => 4)
+  end
+
+=begin nil
+  it "processes entries with same order as merge()" do
+    h = new_hash(1 => 2, 3 => 4, 5 => 6, "x" => nil, nil => 5, [] => [])
+    merge_bang_pairs = []
+    merge_pairs = []
+    h.merge(h) { |*arg| merge_pairs << arg }
+    h.send(@method, h) { |*arg| merge_bang_pairs << arg }
+    merge_bang_pairs.should == merge_pairs
+  end
+=end
+
+=begin frozen
+  ruby_version_is ""..."1.9" do
+    it "raises a TypeError if called on a non-empty, frozen instance" do
+      lambda { HashSpecs.frozen_hash.send(@method, 1 => 2) }.should raise_error(TypeError)
+    end
+
+    it "does not raise an exception on a frozen instance that would not be modified" do
+      hash = HashSpecs.frozen_hash.send(@method, HashSpecs.empty_frozen_hash)
+      hash.should == HashSpecs.frozen_hash
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises a RuntimeError on a frozen instance that is modified" do
+      lambda do
+        HashSpecs.frozen_hash.send(@method, 1 => 2)
+      end.should raise_error(RuntimeError)
+    end
+
+    it "checks frozen status before coercing an object with #to_hash" do
+      obj = mock("to_hash frozen")
+      # This is necessary because mock cleanup code cannot run on the frozen
+      # object.
+      def obj.to_hash() raise Exception, "should not receive #to_hash" end
+      obj.freeze
+
+      lambda { HashSpecs.frozen_hash.send(@method, obj) }.should raise_error(RuntimeError)
+    end
+
+    # see redmine #1571
+    it "raises a RuntimeError on a frozen instance that would not be modified" do
+      lambda do
+        HashSpecs.frozen_hash.send(@method, HashSpecs.empty_frozen_hash)
+      end.should raise_error(RuntimeError)
+    end
+  end
+=end
+end

data/spec/java_ext/map/shared/value.rb

@@ -0,0 +1,16 @@
+shared_examples_for :hash_value_p do |method|
+  before { @method = method }
+
+  it "returns true if the value exists in the hash" do
+    new_hash(:a => :b).send(@method, :a).should == false
+    new_hash(1 => 2).send(@method, 2).should == true
+    h = new_hash 5
+    h.send(@method, 5).should == false
+    h = new_hash { 5 }
+    h.send(@method, 5).should == false
+  end
+
+  it "uses == semantics for comparing values" do
+    new_hash(5 => 2.0).send(@method, 2).should == true
+  end
+end

data/spec/java_ext/map/shared/values_at.rb

@@ -0,0 +1,12 @@
+shared_examples_for :hash_values_at do |method|
+  before { @method = method }
+
+  it "returns an array of values for the given keys" do
+    h = new_hash(:a => 9, :b => 'a', :c => -10, :d => nil)
+    h.send(@method).should be_kind_of(Array)
+    h.send(@method).should == []
+    h.send(@method, :a, :d, :b).should be_kind_of(Array)
+    h.send(@method, :a, :d, :b).should == [9, nil, 'a']
+  end
+end
+

data/spec/java_ext/map/shift_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Hash#shift" do
+=begin shift
+  it "removes a pair from hash and return it" do
+    h = new_hash(:a => 1, :b => 2, "c" => 3, nil => 4, [] => 5)
+    h2 = h.dup
+
+    h.size.times do |i|
+      r = h.shift
+      r.should be_kind_of(Array)
+      h2[r.first].should == r.last
+      h.size.should == h2.size - i - 1
+    end
+
+    h.should == new_hash
+  end
+
+  it "returns nil from an empty hash " do
+    new_hash.shift.should == nil
+  end
+
+  it "returns (computed) default for empty hashes" do
+    new_hash(5).shift.should == 5
+    h = new_hash { |*args| args }
+    h.shift.should == [h, nil]
+  end
+
+  ruby_version_is "" ... "1.9" do
+    it "raises a TypeError if called on a frozen instance" do
+      lambda { HashSpecs.frozen_hash.shift  }.should raise_error(TypeError)
+      lambda { HashSpecs.empty_frozen_hash.shift }.should raise_error(TypeError)
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises a RuntimeError if called on a frozen instance" do
+      lambda { HashSpecs.frozen_hash.shift  }.should raise_error(RuntimeError)
+      lambda { HashSpecs.empty_frozen_hash.shift }.should raise_error(RuntimeError)
+    end
+  end
+=end
+end

data/spec/java_ext/map/size_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/length', __FILE__)
+
+describe "Hash#size" do
+  it_behaves_like(:hash_length, :size)
+end

data/spec/java_ext/map/sort_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Hash#sort" do
+  it "converts self to a nested array of [key, value] arrays and sort with Array#sort" do
+    new_hash('a' => 'b', '1' => '2', 'b' => 'a').sort.should ==
+      [["1", "2"], ["a", "b"], ["b", "a"]]
+  end
+
+  it "works when some of the keys are themselves arrays" do
+    new_hash([1,2] => 5, [1,1] => 5).sort.should == [[[1,1],5], [[1,2],5]]
+  end
+
+  it "uses block to sort array if passed a block" do
+    new_hash(1 => 2, 2 => 9, 3 => 4).sort { |a,b| b <=> a }.should == [[3, 4], [2, 9], [1, 2]]
+  end
+end

data/spec/java_ext/map/store_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/store', __FILE__)
+
+describe "Hash#store" do
+  it_behaves_like(:hash_store, :store)
+end

data/spec/java_ext/map/to_a_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Hash#to_a" do
+  it "returns a list of [key, value] pairs with same order as each()" do
+    h = new_hash(:a => 1, 1 => :a, 3 => :b, :b => 5)
+    pairs = []
+
+    h.each_pair do |key, value|
+      pairs << [key, value]
+    end
+
+    h.to_a.should be_kind_of(Array)
+    h.to_a.should == pairs
+  end
+
+  it "is called for Enumerable#entries" do
+    h = new_hash(:a => 1, 1 => :a, 3 => :b, :b => 5)
+    pairs = []
+
+    h.each_pair do |key, value|
+      pairs << [key, value]
+    end
+
+    ent = h.entries
+    ent.should be_kind_of(Array)
+    ent.should == pairs
+  end
+end

data/spec/java_ext/map/to_hash_spec.rb

@@ -0,0 +1,11 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Hash#to_hash" do
+=begin self
+  it "returns self" do
+    h = new_hash
+    h.to_hash.should equal(h)
+  end
+=end
+end

data/spec/java_ext/map/to_s_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/to_s', __FILE__)
+
+describe "Hash#to_s" do
+
+  ruby_version_is "1.9" do
+    it_behaves_like :to_s, :to_s
+  end
+
+  ruby_version_is ""..."1.9" do
+    it "returns a string by calling Hash#to_a and using Array#join with default separator" do
+      h = new_hash(:fun => 'x', 1 => 3, nil => "ok", [] => :y)
+      h.to_a.to_s.should == h.to_s
+      old, $, = $,, ':'
+      h.to_a.to_s.should == h.to_s
+      $, = old
+    end
+  end
+end

data/spec/java_ext/map/try_convert_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+ruby_version_is "1.8.8" do
+  describe "Hash.try_convert" do
+    it "returns the argument if passed a Hash" do
+      h = {:foo => :glark}
+      Hash.try_convert(h).should == h
+    end
+
+    it "returns nil if the argument can't be coerced into a Hash" do
+      Hash.try_convert(Object.new).should be_nil
+    end
+
+    it "does not rescue exceptions raised by #to_hash" do
+      obj = mock("to_hash raises")
+      obj.should_receive(:to_hash).and_raise(RuntimeError)
+      lambda { Hash.try_convert obj }.should raise_error(RuntimeError)
+    end
+
+    it "coerces the argument with #to_hash" do
+      obj = mock('to_hash')
+      obj.should_receive(:to_hash).and_return({:foo => :bar})
+      Hash.try_convert(obj).should == {:foo => :bar}
+    end
+
+    it "raises a TypeError if #to_hash does not return a Hash" do
+      obj = mock("to_hash invalid")
+      obj.should_receive(:to_hash).and_return(:invalid_to_hash)
+      lambda { Hash.try_convert obj }.should raise_error(TypeError)
+    end
+  end
+end

data/spec/java_ext/map/update_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/update', __FILE__)
+
+describe "Hash#update" do
+  it_behaves_like(:hash_update, :update)
+end

data/spec/java_ext/map/value_spec.rb

@@ -0,0 +1,8 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/value', __FILE__)
+
+describe "Hash#value?" do
+  it_behaves_like(:hash_value_p, :value?)
+end
+

data/spec/java_ext/map/values_at_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/values_at', __FILE__)
+
+describe "Hash#values_at" do
+  it_behaves_like(:hash_values_at, :values_at)
+end

data/spec/java_ext/map/values_spec.rb

@@ -0,0 +1,10 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Hash#values" do
+  it "returns an array of values" do
+    h = new_hash(1 => :a, 'a' => :a, 'the' => 'lang')
+    h.values.to_a.should be_kind_of(Array)
+    h.values.sort {|a, b| a.to_s <=> b.to_s}.should == [:a, :a, 'lang']
+  end
+end

data/spec/locale_spec.rb

@@ -0,0 +1,77 @@
+require 'jactive_support/core_ext/locale'
+
+describe Locale do
+  before {java::util::Locale.setDefault(java::util::Locale.new('en'))}
+  subject {Locale.new('en', 'UK')}
+
+  it { Locale.should be(java.util.Locale) }
+
+  it "should have a current locale" do
+    Locale.current_locale.should be(Locale.getDefault)
+  end
+  
+  it "has a human name" do
+    subject.human_name.should eq('English (UK)')
+  end
+
+  it "supports inspect" do
+    subject.inspect.should eq('Locale[English (UK)]')
+  end
+  
+  it "supports to_s" do
+    subject.to_s.should eq('en_UK')
+  end
+
+  it "supports to_str" do
+    subject.to_str.should eq('en_UK')
+  end
+
+  it "supports to_sym" do
+    subject.to_sym.should eq(:en_UK)
+  end
+  
+  it "can convert string to locale" do
+    "en".to_locale.should eq(Locale.new('en'))
+    "en_UK".to_locale.should eq(Locale.new('en', 'UK'))
+    "en-UK".to_locale.should eq(Locale.new('en', 'UK'))
+    "en_UK_Ireland".to_locale.should eq(Locale.new('en', 'UK', 'Ireland'))
+    "en-UK-Ireland".to_locale.should eq(Locale.new('en', 'UK', 'Ireland'))
+    "en_UK-Ireland".to_locale.should eq(Locale.new('en', 'UK', 'Ireland'))
+    "en-UK_Ireland".to_locale.should eq(Locale.new('en', 'UK', 'Ireland'))
+  end
+  
+  it "can convert symbol to locale" do
+    :en.to_locale.should eq(Locale.new('en'))
+    :en_UK.to_locale.should eq(Locale.new('en', 'UK'))
+    :'en-UK'.to_locale.should eq(Locale.new('en', 'UK'))
+    :en_UK_Ireland.to_locale.should eq(Locale.new('en', 'UK', 'Ireland'))
+    :'en-UK-Ireland'.to_locale.should eq(Locale.new('en', 'UK', 'Ireland'))
+    :'en_UK-Ireland'.to_locale.should eq(Locale.new('en', 'UK', 'Ireland'))
+    :'en-UK_Ireland'.to_locale.should eq(Locale.new('en', 'UK', 'Ireland'))
+  end
+
+  it "converting nil to a locale is the same as the default locale" do
+    nil.to_locale.should be(Locale.current_locale)
+  end
+  
+  it "can set current locale" do
+    Locale.current_locale = Locale.new('en')
+    Locale.current_locale.should eq(:en.to_locale)
+  end
+  
+  it "can set current locale to a string" do
+    Locale.current_locale = 'en'
+    Locale.current_locale.should eq(:en.to_locale)
+  end
+  
+  it "can set current locale to a symbol" do
+    Locale.current_locale = :en
+    Locale.current_locale.should eq(:en.to_locale)
+  end
+  
+  it "can set current locale to nil and it has no effect" do
+    old = Locale.current_locale
+    Locale.current_locale = nil
+    Locale.current_locale.should eq(old)
+  end
+end

data/spec/shared/fixtures.rb

@@ -0,0 +1,7 @@
+def enumerator_class
+  [].each.class
+end
+
+def ruby_bug(*args)
+  yield
+end

data/spec/shared/version.rb

@@ -0,0 +1,123 @@
+class SpecVersion
+  # If beginning implementations have a problem with this include, we can
+  # manually implement the relational operators that are needed.
+  include Comparable
+
+  # SpecVersion handles comparison correctly for the context by filling in
+  # missing version parts according to the value of +ceil+. If +ceil+ is
+  # +false+, 0 digits fill in missing version parts. If +ceil+ is +true+, 9
+  # digits fill in missing parts. (See e.g. VersionGuard and BugGuard.)
+  def initialize(version, ceil = false)
+    @version = version
+    @ceil    = ceil
+    @integer = nil
+  end
+
+  def to_s
+    @version
+  end
+
+  def to_str
+    to_s
+  end
+
+  # Converts a string representation of a version major.minor.tiny.patchlevel
+  # to an integer representation so that comparisons can be made. For example,
+  # "1.8.6.77" < "1.8.6.123" would be false if compared as strings.
+  def to_i
+    unless @integer
+      major, minor, tiny, patch = @version.split "."
+      if @ceil
+        tiny = 99 unless tiny
+        patch = 9999 unless patch
+      end
+      parts = [major, minor, tiny, patch].map { |x| x.to_i }
+      @integer = ("1%02d%02d%02d%04d" % parts).to_i
+    end
+    @integer
+  end
+
+  def to_int
+    to_i
+  end
+
+  def <=>(other)
+    if other.respond_to? :to_int
+      other = Integer other
+    else
+      other = SpecVersion.new(String(other)).to_i
+    end
+
+    self.to_i <=> other
+  end
+end
+
+class VersionGuard
+  @@ruby_version_override = nil
+
+  def self.ruby_version_override=(version)
+    @@ruby_version_override = version
+  end
+
+  def self.ruby_version_override
+    @@ruby_version_override
+  end
+
+  # Returns a partial Ruby version string based on +which+. For example,
+  # if RUBY_VERSION = 8.2.3 and RUBY_PATCHLEVEL = 71:
+  #
+  #  :major  => "8"
+  #  :minor  => "8.2"
+  #  :tiny   => "8.2.3"
+  #  :teeny  => "8.2.3"
+  #  :full   => "8.2.3.71"
+  def self.ruby_version(which = :minor)
+    case which
+    when :major
+      n = 1
+    when :minor
+      n = 2
+    when :tiny, :teeny
+      n = 3
+    else
+      n = 4
+    end
+
+    patch = RUBY_PATCHLEVEL.to_i
+    patch = 0 if patch < 0
+    version = "#{ruby_version_override || RUBY_VERSION}.#{patch}"
+    version.split('.')[0,n].join('.')
+  end
+  
+  def initialize(version)
+    case version
+    when String
+      @version = SpecVersion.new version
+    when Range
+      a = SpecVersion.new version.first
+      b = SpecVersion.new version.last
+      @version = version.exclude_end? ? a...b : a..b
+    end
+  end
+
+  def ruby_version
+    @ruby_version ||= SpecVersion.new self.class.ruby_version(:full)
+  end
+
+  def match?
+    if Range === @version
+      @version.include? ruby_version
+    else
+      ruby_version >= @version
+    end
+  end
+end
+
+class Object
+  def ruby_version_is(*args)
+    g = VersionGuard.new(*args)
+    yield if g.match?
+  end
+end
+
+puts "Ruby is " + VersionGuard.ruby_version(:full)

data/spec/spec_helper.rb

@@ -0,0 +1,50 @@
+require 'java'
+require File.expand_path('../shared/version', __FILE__)
+require File.expand_path('../shared/fixtures', __FILE__)
+
+require 'jactive_support/java_ext/map/constructor'
+class java::util::HashMap
+  include JactiveSupport::JavaExtensions::Map::Constructor
+end
+
+class Object
+  # The following helpers provide a level of indirection for running the specs
+  # against a Hash implementation that has a different name than Hash.
+
+  # Returns the Hash class.
+  unless method_defined?(:hash_class)
+    def hash_class
+      java::util::LinkedHashMap
+    end
+  end
+
+  unless method_defined?(:ruby_hash_class)
+    def ruby_hash_class
+      Hash
+    end
+  end
+
+  # Returns a new instance of hash_class.
+  def new_hash(*args, &block)
+    if block
+      r = hash_class.new
+      r.default = block
+      r
+    elsif args.size == 1
+      value = args.first
+      if value.is_a?(Hash) or value.is_a?(hash_class)
+        r = hash_class.new
+        r.putAll(value)
+        r
+      else
+        r = hash_class.new
+        r.default = value
+        r
+      end
+    else
+      r = hash_class.new
+      args.each_slice(2) {|key,val| r.put(key,val)}
+      r
+    end
+  end
+end