opal 0.3.18 → 0.3.19

data/test/core/hash/each_pair_spec.rb

@@ -0,0 +1,30 @@
+describe "Hash#each_pair" do
+  it "yields the key and value of each pair to a block expecting |key, value|" do
+    r = {}
+    h = {:a => 1, :b => 2, :c => 3, :d => 5}
+    h.each_pair { |k,v| r[k.to_s] = v.to_s }.should equal(h)
+    r.should == {"a" => "1", "b" => "2", "c" => "3", "d" => "5"}
+  end
+
+  # FIXME: should be: h.each { |k,| ary << k }
+  it "yields the key only to a block expecting |key,|" do
+    ary = []
+    h = {"a" => 1, "b" => 2, "c" => 3}
+    h.each_pair { |k| ary << k }
+    ary.should == ["a", "b", "c"]
+  end
+
+  it "uses the same order as keys() and values()" do
+    h = {:a => 1, :b => 2, :c => 3, :d => 5}
+    keys = []
+    values = []
+
+    h.each_pair do |k, v|
+      keys << k
+      values << v
+    end
+
+    keys.should == h.keys
+    values.should == h.values
+  end
+end

data/test/core/hash/each_spec.rb

@@ -0,0 +1,30 @@
+describe "Hash#each" do
+  it "yields the key and value of each pair to a block expecting |key, value|" do
+    r = {}
+    h = {:a => 1, :b => 2, :c => 3, :d => 5}
+    h.each { |k,v| r[k.to_s] = v.to_s }.should equal(h)
+    r.should == {"a" => "1", "b" => "2", "c" => "3", "d" => "5"}
+  end
+
+  # FIXME: should be: h.each { |k,| ary << k }
+  it "yields the key only to a block expecting |key,|" do
+    ary = []
+    h = {"a" => 1, "b" => 2, "c" => 3}
+    h.each { |k| ary << k }
+    ary.should == ["a", "b", "c"]
+  end
+
+  it "uses the same order as keys() and values()" do
+    h = {:a => 1, :b => 2, :c => 3, :d => 5}
+    keys = []
+    values = []
+
+    h.each do |k, v|
+      keys << k
+      values << v
+    end
+
+    keys.should == h.keys
+    values.should == h.values
+  end
+end

data/test/core/hash/each_value_spec.rb

@@ -0,0 +1,15 @@
+describe "Hash#each_value" do
+  it "calls block once for each key, passing value" do
+    r = []
+    h = {:a => -5, :b => -3, :c => -2, :d => -1, :e => -1}
+    h.each_value { |v| r << v }.should equal(h)
+    r.should == [-5, -3, -2, -1, -1]
+  end
+
+  it "processes values in the same order as values()" do
+    values = []
+    h = {:a => -5, :b => -3, :c => -2, :d => -1, :e => -1}
+    h.each_value { |v| values << v }
+    values.should == h.values
+  end
+end

data/{core/spec → test}/core/hash/element_reference_spec.rb

@@ -11,4 +11,18 @@ describe "Hash#[]" do
   it "returns nil as default default value" do
     {0 => 0}[5].should == nil
   end
+
+  it "returns the default (imediate) value for missing keys" do
+    h = Hash.new 5
+    h[:a].should == 5
+    h[:a] = 0
+    h[:a].should == 0
+    h[:b].should == 5
+  end
+
+  it "does not return default values for keys with nil values" do
+    h = Hash.new 5
+    h[:a] = nil
+    h[:a].should == nil
+  end
 end

data/{core/spec → test}/core/hash/element_set_spec.rb

@@ -2,5 +2,6 @@ describe "Hash#[]=" do
   it "associates the key with the value and return the value" do
     h = {:a => 1}
     (h[:b] = 2).should == 2
+    h.should == {:b => 2, :a => 1}
   end
 end

data/test/core/hash/empty_spec.rb

@@ -0,0 +1,10 @@
+describe "Hash#empty?" do
+  it "returns true if the hash has no entries" do
+    {}.empty?.should == true
+    {1 => 1}.empty?.should == false
+  end
+
+  it "returns true if the hash has no entires and has a default value" do
+    Hash.new(5).empty?.should == true
+  end
+end

data/test/core/hash/fetch_spec.rb

@@ -0,0 +1,24 @@
+describe "Hash#fetch" do
+  it "returns the value for key" do
+    {:a => 1, :b => -1}.fetch(:b).should == -1
+  end
+
+  it "raises and KeyError if key is not found" do
+    lambda { Hash.new.fetch(:a) }.should raise_error(KeyError)
+    lambda { Hash.new(5).fetch(:a) }.should raise_error(KeyError)
+  end
+
+  it "returns default if key is not found when passed a default" do
+    Hash.new.fetch(:a, nil).should == nil
+    Hash.new.fetch(:a, 'not here!').should == "not here!"
+    {:a => nil}.fetch(:a, 'not here!').should == nil
+  end
+
+  it "returns value of block if key is not found when passed a block" do
+    {}.fetch('a') { |k| k + '!' }.should == "a!"
+  end
+
+  it "gives precedence to the default block over the default argument when passed both" do
+    {}.fetch(9, :foo) { |i| i * i }.should == 81
+  end
+end

data/test/core/hash/flatten_spec.rb

@@ -0,0 +1,46 @@
+describe "Hash#flatten" do
+  before(:each) do
+    @h = {:plato => :greek,
+          :witgenstein => [:austrian, :british],
+          :russell => :welsh}
+  end
+
+  it "returns an Array" do
+    {}.flatten.should be_kind_of(Array)
+  end
+
+  it "returns an empty Array for an empty Hash" do
+    {}.flatten.should == []
+  end
+
+  it "sets each even index of the Array to a key of the hash" do
+    a = @h.flatten
+    a[0].should == :plato
+    a[2].should == :witgenstein
+    a[4].should == :russell
+  end
+
+  it "sets each odd index of the Array to the value corresponding to the previous element" do
+    a = @h.flatten
+    a[1].should == :greek
+    a[3].should == [:austrian, :british]
+    a[5].should == :welsh
+  end
+
+  it "does not recursively flatten Array values when called without arguments" do
+    a = @h.flatten
+    a[3].should == [:austrian, :british]
+  end
+
+  it "does not recursivley flatten Hash values when called without arguments" do
+    @h[:russell] = {:born => :wales, :influenced_by => :mill}
+    a = @h.flatten
+    a[5].should_not == {:born => :wales, :influenced_by => :mill}.flatten
+  end
+
+  it "recursively flattens Array values when called with an argument >= 2" do
+    a = @h.flatten(2)
+    a[3].should == :austrian
+    a[4].should == :british
+  end
+end

data/test/core/hash/has_key_spec.rb

@@ -0,0 +1,24 @@
+describe "Hash#has_key?" do
+  it "returns true if the argument is a key" do
+    h = {:a => 1, :b => 2, :c => 3, 4 => 0}
+    h.has_key?(:a).should == true
+    h.has_key?(:b).should == true
+    h.has_key?(:B).should == false
+    h.has_key?(2).should == false
+    h.has_key?(4).should == true
+    h.has_key?(42).should == false
+  end
+
+  it "returns true if the key's matching value was nil" do
+    {:xyz => nil}.has_key?(:xyz).should == true
+  end
+
+  it "returns true if the key's matching value was false" do
+    {:xyz => false}.has_key?(:xyz).should == true
+  end
+
+  it "returns true if the key is nil" do
+    {nil => 'b'}.has_key?(nil).should == true
+    {nil => nil}.has_key?(nil).should == true
+  end
+end

data/test/core/hash/has_value_spec.rb

@@ -0,0 +1,12 @@
+describe "Hash#has_value?" do
+  it "returns true if the value exists in the hash" do
+    {:a => :b}.has_value?(:a).should == false
+    {1 => 2}.has_value?(2).should == true
+    h = Hash.new 5
+    h.has_value?(5).should == false
+  end
+
+  it "uses == semantics for comparing values" do
+    {5 => 2.0}.has_value?(2).should == true
+  end
+end

data/test/core/hash/include_spec.rb

@@ -0,0 +1,24 @@
+describe "Hash#include?" do
+  it "returns true if the argument is a key" do
+    h = {:a => 1, :b => 2, :c => 3, 4 => 0}
+    h.include?(:a).should == true
+    h.include?(:b).should == true
+    h.include?(:B).should == false
+    h.include?(2).should == false
+    h.include?(4).should == true
+    h.include?(42).should == false
+  end
+
+  it "returns true if the key's matching value was nil" do
+    {:xyz => nil}.include?(:xyz).should == true
+  end
+
+  it "returns true if the key's matching value was false" do
+    {:xyz => false}.include?(:xyz).should == true
+  end
+
+  it "returns true if the key is nil" do
+    {nil => 'b'}.include?(nil).should == true
+    {nil => nil}.include?(nil).should == true
+  end
+end

data/test/core/hash/index_spec.rb

@@ -0,0 +1,13 @@
+describe "Hash#index" do
+  it "returns the corresponding key for value" do
+    {2 => 'a', 1 => 'b'}.index('b').should == 1
+  end
+
+  it "returns nil if the value is not found" do
+    {:a => -1, :b => 3.14, :c => 2.718}.index(1).should be_nil
+  end
+
+  it "doesn't return default value if the value isn't found" do
+    Hash.new(5).index(5).should be_nil
+  end
+end

data/test/core/hash/indexes_spec.rb

@@ -0,0 +1,9 @@
+describe "Hash#indexes" do
+  it "returns an array of values for the given keys" do
+    h = {:a => 9, :b => 'a', :c => -10, :d => nil}
+    h.indexes.should be_kind_of(Array)
+    h.indexes.should == []
+    h.indexes(:a, :d, :b).should be_kind_of(Array)
+    h.indexes(:a, :d, :b).should == [9, nil, 'a']
+  end
+end

data/test/core/hash/indices_spec.rb

@@ -0,0 +1,9 @@
+describe "Hash#indices" do
+  it "returns an array of values for the given keys" do
+    h = {:a => 9, :b => 'a', :c => -10, :d => nil}
+    h.indices.should be_kind_of(Array)
+    h.indices.should == []
+    h.indices(:a, :d, :b).should be_kind_of(Array)
+    h.indices(:a, :d, :b).should == [9, nil, 'a']
+  end
+end

data/test/core/hash/invert_spec.rb

@@ -0,0 +1,12 @@
+describe "Hash#invert" do
+  it "returns a new hash where keys are values and vice versa" do
+    {1 => 'a', 2 => 'b', 3 => 'c'}.invert.should ==
+      {'a' => 1, 'b' => 2, 'c' => 3}
+  end
+
+  it "handles collisions by overriding with the key coming later in keys()" do
+    h = {:a => 1, :b => 1}
+    override_key = h.keys.last
+    h.invert[1].should == override_key
+  end
+end

data/test/core/hash/keep_if_spec.rb

@@ -0,0 +1,18 @@
+describe "Hash#keep_if" do
+  it "yields two arguments: key and value" do
+    all_args = []
+    {1 => 2, 3 => 4}.keep_if { |*args| all_args << args }
+    all_args.should == [[1, 2], [3, 4]]
+  end
+
+  it "keeps every entry for which block is true and returns self" do
+    h = {:a => 1, :b => 2, :c => 3, :d => 4}
+    h.keep_if { |k,v| v % 2 == 0 }.should equal(h)
+    h.should == {:b => 2, :d => 4}
+  end
+
+  it "returns self even if unmodified" do
+    h = {1 => 2, 3 => 4}
+    h.keep_if { true }.should equal(h)
+  end
+end

data/test/core/hash/key_spec.rb

@@ -0,0 +1,24 @@
+describe "Hash#key?" do
+  it "returns true if the argument is a key" do
+    h = {:a => 1, :b => 2, :c => 3, 4 => 0}
+    h.key?(:a).should == true
+    h.key?(:b).should == true
+    h.key?(:B).should == false
+    h.key?(2).should == false
+    h.key?(4).should == true
+    h.key?(42).should == false
+  end
+
+  it "returns true if the key's matching value was nil" do
+    {:xyz => nil}.key?(:xyz).should == true
+  end
+
+  it "returns true if the key's matching value was false" do
+    {:xyz => false}.key?(:xyz).should == true
+  end
+
+  it "returns true if the key is nil" do
+    {nil => 'b'}.key?(nil).should == true
+    {nil => nil}.key?(nil).should == true
+  end
+end

data/test/core/hash/keys_spec.rb

@@ -0,0 +1,10 @@
+describe "Hash#keys" do
+  it "returns an array with the keys in the order they were inserted" do
+    {}.keys.should == []
+    {}.keys.should be_kind_of(Array)
+    Hash.new(5).keys.should == []
+    Hash.new { 5 }.keys.should == []
+    # {1 => 2, 2 => 8, 4 => 4}.keys.should == [1, 4, 2]
+    {nil => nil}.keys.should == [nil]
+  end
+end

data/test/core/hash/length_spec.rb

@@ -0,0 +1,10 @@
+describe "Hash#length" do
+  it "returns the number of entries" do
+    {:a => 1, :b => 'c'}.length.should == 2
+    {:a => 1, :b => 2, :a => 2}.length.should == 2
+    {:a => 1, :b => 1, :c => 1}.length.should == 3
+    Hash.new.length.should == 0
+    Hash.new(5).length.should == 0
+    Hash.new { 5 }.length.should == 0
+  end
+end

data/test/core/hash/member_spec.rb

@@ -0,0 +1,24 @@
+describe "Hash#member?" do
+  it "returns true if the argument is a key" do
+    h = {:a => 1, :b => 2, :c => 3, 4 => 0}
+    h.member?(:a).should == true
+    h.member?(:b).should == true
+    h.member?(:B).should == false
+    h.member?(2).should == false
+    h.member?(4).should == true
+    h.member?(42).should == false
+  end
+
+  it "returns true if the key's matching value was nil" do
+    {:xyz => nil}.member?(:xyz).should == true
+  end
+
+  it "returns true if the key's matching value was false" do
+    {:xyz => false}.member?(:xyz).should == true
+  end
+
+  it "returns true if the key is nil" do
+    {nil => 'b'}.member?(nil).should == true
+    {nil => nil}.member?(nil).should == true
+  end
+end

data/test/core/hash/rassoc_spec.rb

@@ -0,0 +1,34 @@
+describe "Hash#rassoc" do
+  before :each do
+    @h = {:apple => :green, :orange => :orange, :grape => :green, :banana => :yellow}
+  end
+
+  it "returns an Array if the argument is a value of the Hash" do
+    @h.rassoc(:green).should be_kind_of(Array)
+  end
+
+  it "returns a 2-element Array if the argument is a valud of the Hash" do
+    @h.rassoc(:orange).size.should == 2
+  end
+
+  it "sets the first element of the Array to the key of the located value" do
+    @h.rassoc(:yellow).first.should == :banana
+  end
+
+  it "sets the last element of the Array to the located value" do
+    @h.rassoc(:yellow).last.should == :yellow
+  end
+
+  it "only returns the first matching key-value pair" do
+    @h.rassoc(:green).should == [:apple, :green]
+  end
+
+  it "returns nil if the argument is not a value of the Hash" do
+    @h.rassoc(:banana).should be_nil
+  end
+
+  it "returns nil if the argument is not a value of the Hash even when there is a default" do
+    Hash.new(42).merge!( :foo => :bar ).rassoc(42).should be_nil
+    Hash.new{|h, k| h[k] = 42}.merge!( :foo => :bar ).rassoc(42).should be_nil
+  end
+end

data/test/core/hash/replace_spec.rb

@@ -0,0 +1,7 @@
+describe "Hash#replace" do
+  it "replaces the contents of self with other" do
+    h = {:a => 1, :b => 2}
+    h.replace(:c => -1, :d => -2).should equal(h)
+    h.should == {:c => -1, :d => -2}
+  end
+end