opal 0.4.4 → 0.5.0

data/spec/rubyspec/core/hash/default_proc_spec.rb

@@ -1,20 +0,0 @@
-describe "Hash#default_proc" do
-  it "returns the block passed to Hash.new" do
-    h = Hash.new { |i| 'Paris' }
-    p = h.default_proc
-    p.call(1).should == 'Paris'
-  end
-
-  it "returns nil if no block was passed to proc" do
-    {}.default_proc.should == nil
-  end
-end
-
-describe "Hash#default_proc=" do
-  it "replaces the block passed to Hash.new" do
-    h = Hash.new { |i| 'Paris' }
-    h.default_proc = Proc.new { 'Montreal' }
-    p = h.default_proc
-    p.call(1).should == 'Montreal'
-  end
-end

data/spec/rubyspec/core/hash/default_spec.rb

@@ -1,17 +0,0 @@
-describe "Hash#default" do
-  it "returns the default value" do
-    h = Hash.new 5
-    h.default.should == 5
-    h.default(4).should == 5
-    Hash.new.default.should == nil
-    Hash.new.default(4).should == nil
-  end
-end
-
-describe "Hash#default=" do
-  it "sets the default value" do
-    h = {}
-    h.default = 99
-    h.default.should == 99
-  end
-end

data/spec/rubyspec/core/hash/delete_if_spec.rb

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

data/spec/rubyspec/core/hash/delete_spec.rb

@@ -1,11 +0,0 @@
-describe "Hash#delete" do
-  it "removes the entry and returns the deleted value" do
-    h = {a: 5, b: 2}
-    h.delete(:b).should == 2
-    h.should == {a: 5}
-  end
-
-  it "returns nil if the key is not found" do
-    {}.delete(:a).should == nil
-  end
-end

data/spec/rubyspec/core/hash/dup_spec.rb

@@ -1,10 +0,0 @@
-describe "Hash#dup" do
-  it "copies instance variable but not the objects they refer to" do
-    hash = {'key' => 'value'}
-
-    clone = hash.dup
-
-    clone.should == hash
-    clone.object_id.should_not == hash.object_id
-  end
-end

data/spec/rubyspec/core/hash/each_key_spec.rb

@@ -1,15 +0,0 @@
-describe "Hash#each_key" do
-  it "calls block once for each key, passing key" do
-    r = {}
-    h = {1 => -1, 2 => -2, 3 => -3, 4 => -4}
-    h.each_key { |k| r[k] = k }.should equal(h)
-    r.should == {1 => 1, 2 => 2, 3 => 3, 4 => 4}
-  end
-
-  it "processes keys in the same order as keys()" do
-    keys = []
-    h = {1 => -1, 2 => -2, 3 => -3, 4 => -4}
-    h.each_key { |k| keys << k }
-    keys.should == h.keys
-  end
-end

data/spec/rubyspec/core/hash/each_pair_spec.rb

@@ -1,30 +0,0 @@
-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/spec/rubyspec/core/hash/each_spec.rb

@@ -1,36 +0,0 @@
-describe "Hash#each" do
-  it "yields a [[key, value]] Array for each pair to a block expecting |*args|" do
-    all_args = []
-    {1 => 2, 3 => 4}.each { |*args| all_args << args }
-    all_args.sort.should == [[[1, 2]], [[3, 4]]]
-  end
-
-  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/spec/rubyspec/core/hash/each_value_spec.rb

@@ -1,15 +0,0 @@
-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/spec/rubyspec/core/hash/element_reference_spec.rb

@@ -1,41 +0,0 @@
-describe "Hash#[]" do
-  it "returns the value for the key" do
-    obj = Object.new
-    h = {1 => 2, 3 => 4, "foo" => "bar", obj => obj, [] => "baz"}
-    h[1].should == 2
-    h[3].should == 4
-    h["foo"].should == "bar"
-    h[obj].should == obj
-  end
-
-  it "returns nil as default default value" do
-    {0 => 0}[5].should == nil
-  end
-
-  it "returns the default (immediate) 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
-
-  it "returns the default (dynamic) value for missing keys" do
-    h = Hash.new { |hsh, k| k.kind_of?(Numeric) ? hsh[k] = k + 2 : hsh[k] = k }
-    h[1].should == 3
-    h['this'].should == 'this'
-    h.should == {1 => 3, 'this' => 'this'}
-
-    i = 0
-    h = Hash.new { |hsh, key| i += 1 }
-    h[:foo].should == 1
-    h[:foo].should == 2
-    h[:bar].should == 3
-  end
-end

data/spec/rubyspec/core/hash/element_set_spec.rb

@@ -1,7 +0,0 @@
-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/spec/rubyspec/core/hash/empty_spec.rb

@@ -1,10 +0,0 @@
-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/spec/rubyspec/core/hash/fetch_spec.rb

@@ -1,24 +0,0 @@
-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/spec/rubyspec/core/hash/flatten_spec.rb

@@ -1,46 +0,0 @@
-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/spec/rubyspec/core/hash/has_key_spec.rb

@@ -1,24 +0,0 @@
-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/spec/rubyspec/core/hash/has_value_spec.rb

@@ -1,12 +0,0 @@
-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/spec/rubyspec/core/hash/include_spec.rb

@@ -1,24 +0,0 @@
-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/spec/rubyspec/core/hash/index_spec.rb

@@ -1,13 +0,0 @@
-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/spec/rubyspec/core/hash/indexes_spec.rb

@@ -1,9 +0,0 @@
-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/spec/rubyspec/core/hash/indices_spec.rb

@@ -1,9 +0,0 @@
-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/spec/rubyspec/core/hash/invert_spec.rb

@@ -1,12 +0,0 @@
-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/spec/rubyspec/core/hash/keep_if_spec.rb

@@ -1,18 +0,0 @@
-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