rubysl-set 0.0.1 → 1.0.0

data/spec/shared/add.rb

@@ -0,0 +1,14 @@
+describe :set_add, :shared => true do
+  before :each do
+    @set = Set.new
+  end
+
+  it "adds the passed Object to self" do
+    @set.send(@method, "dog")
+    @set.should include("dog")
+  end
+
+  it "returns self" do
+    @set.send(@method, "dog").should equal(@set)
+  end
+end

data/spec/shared/collect.rb

@@ -0,0 +1,20 @@
+describe :set_collect_bang, :shared => true do
+  before(:each) do
+    @set = Set[1, 2, 3, 4, 5]
+  end
+
+  it "yields each Object in self" do
+    res = []
+    @set.send(@method) { |x| res << x }
+    res.sort.should == [1, 2, 3, 4, 5].sort
+  end
+
+  it "returns self" do
+    @set.send(@method) { |x| x }.should equal(@set)
+  end
+
+  it "replaces self with the return values of the block" do
+    @set.send(@method) { |x| x * 2 }
+    @set.should == Set[2, 4, 6, 8, 10]
+  end
+end

data/spec/shared/difference.rb

@@ -0,0 +1,15 @@
+describe :set_difference, :shared => true do
+  before :each do
+    @set = Set[:a, :b, :c]
+  end
+
+  it "returns a new Set containting self's elements excluding the elements in the passed Enumerable" do
+    @set.send(@method, Set[:a, :b]).should == Set[:c]
+    @set.send(@method, [:b, :c]).should == Set[:a]
+  end
+
+  it "raises an ArgumentError when passed a non-Enumerable" do
+    lambda { @set.send(@method, 1) }.should raise_error(ArgumentError)
+    lambda { @set.send(@method, Object.new) }.should raise_error(ArgumentError)
+  end
+end

data/spec/shared/include.rb

@@ -0,0 +1,7 @@
+describe :set_include, :shared => true do
+  it "returns true when self contains the passed Object" do
+    set = Set[:a, :b, :c]
+    set.send(@method, :a).should be_true
+    set.send(@method, :e).should be_false
+  end
+end

data/spec/shared/intersection.rb

@@ -0,0 +1,15 @@
+describe :set_intersection, :shared => true do
+  before :each do
+    @set = Set[:a, :b, :c]
+  end
+
+  it "returns a new Set containing only elements shared by self and the passed Enumerable" do
+    @set.send(@method, Set[:b, :c, :d, :e]).should == Set[:b, :c]
+    @set.send(@method, [:b, :c, :d]).should == Set[:b, :c]
+  end
+
+  it "raises an ArgumentError when passed a non-Enumerable" do
+    lambda { @set.send(@method, 1) }.should raise_error(ArgumentError)
+    lambda { @set.send(@method, Object.new) }.should raise_error(ArgumentError)
+  end
+end

data/spec/shared/length.rb

@@ -0,0 +1,6 @@
+describe :set_length, :shared => true do
+  it "returns the number of elements in the set" do
+    set = Set[:a, :b, :c]
+    set.send(@method).should == 3
+  end
+end

data/spec/shared/union.rb

@@ -0,0 +1,15 @@
+describe :set_union, :shared => true do
+  before :each do
+    @set = Set[:a, :b, :c]
+  end
+
+  it "returns a new Set containing all elements of self and the passed Enumerable" do
+    @set.send(@method, Set[:b, :d, :e]).should == Set[:a, :b, :c, :d, :e]
+    @set.send(@method, [:b, :e]).should == Set[:a, :b, :c, :e]
+  end
+
+  it "raises an ArgumentError when passed a non-Enumerable" do
+    lambda { @set.send(@method, 1) }.should raise_error(ArgumentError)
+    lambda { @set.send(@method, Object.new) }.should raise_error(ArgumentError)
+  end
+end

data/spec/size_spec.rb

@@ -0,0 +1,6 @@
+require File.expand_path('../shared/length', __FILE__)
+require 'set'
+
+describe "Set#size" do
+  it_behaves_like :set_length, :size
+end

data/spec/sortedset/add_spec.rb

@@ -0,0 +1,34 @@
+require 'set'
+require File.expand_path('../shared/add', __FILE__)
+
+describe "SortedSet#add" do
+  it_behaves_like :sorted_set_add, :add
+
+  ruby_bug "redmine #118", "1.9.1" do
+    it "takes only values which responds <=>" do
+      obj = mock('no_comparison_operator')
+      obj.should_receive(:respond_to?).with(:<=>).and_return(false)
+      lambda { SortedSet["hello"].add(obj) }.should raise_error(ArgumentError)
+    end
+  end
+end
+
+describe "SortedSet#add?" do
+  before :each do
+    @set = SortedSet.new
+  end
+
+  it "adds the passed Object to self" do
+    @set.add?("cat")
+    @set.should include("cat")
+  end
+
+  it "returns self when the Object has not yet been added to self" do
+    @set.add?("cat").should equal(@set)
+  end
+
+  it "returns nil when the Object has already been added to self" do
+    @set.add?("cat")
+    @set.add?("cat").should be_nil
+  end
+end

data/spec/sortedset/append_spec.rb

@@ -0,0 +1,6 @@
+require 'set'
+require File.expand_path('../shared/add', __FILE__)
+
+describe "SortedSet#<<" do
+  it_behaves_like :sorted_set_add, :<<
+end

data/spec/sortedset/classify_spec.rb

@@ -0,0 +1,34 @@
+require 'set'
+
+describe "SortedSet#classify" do
+  before(:each) do
+    @set = SortedSet["one", "two", "three", "four"]
+  end
+
+  it "yields each Object in self in sorted order" do
+    res = []
+    @set.classify { |x| res << x }
+    res.should == ["one", "two", "three", "four"].sort
+  end
+
+  ruby_version_is "" ... "1.8.8" do
+    it "raises a LocalJumpError when passed no block" do
+      lambda { @set.classify }.should raise_error(LocalJumpError)
+    end
+  end
+
+  ruby_version_is "1.8.8" do
+    it "returns an Enumerator when passed no block" do
+      enum = @set.classify
+      enum.should be_an_instance_of(enumerator_class)
+
+      classified = enum.each { |x| x.length }
+      classified.should == { 3 => SortedSet["one", "two"], 4 => SortedSet["four"], 5 => SortedSet["three"] }
+    end
+  end
+
+  it "classifies the Objects in self based on the block's return value" do
+    classified = @set.classify { |x| x.length }
+    classified.should == { 3 => SortedSet["one", "two"], 4 => SortedSet["four"], 5 => SortedSet["three"] }
+  end
+end

data/spec/sortedset/clear_spec.rb

@@ -0,0 +1,16 @@
+require 'set'
+
+describe "SortedSet#clear" do
+  before(:each) do
+    @set = SortedSet["one", "two", "three", "four"]
+  end
+
+  it "removes all elements from self" do
+    @set.clear
+    @set.should be_empty
+  end
+
+  it "returns self" do
+    @set.clear.should equal(@set)
+  end
+end

data/spec/sortedset/collect_spec.rb

@@ -0,0 +1,6 @@
+require 'set'
+require File.expand_path('../shared/collect', __FILE__)
+
+describe "SortedSet#collect!" do
+  it_behaves_like :sorted_set_collect_bang, :collect!
+end

data/spec/sortedset/constructor_spec.rb

@@ -0,0 +1,14 @@
+require 'set'
+
+describe "SortedSet[]" do
+  it "returns a new SortedSet populated with the passed Objects" do
+    set = SortedSet[1, 2, 3]
+
+    set.instance_of?(SortedSet).should be_true
+    set.size.should eql(3)
+
+    set.should include(1)
+    set.should include(2)
+    set.should include(3)
+  end
+end

data/spec/sortedset/delete_if_spec.rb

@@ -0,0 +1,47 @@
+require 'set'
+
+describe "SortedSet#delete_if" do
+  before(:each) do
+    @set = SortedSet["one", "two", "three"]
+  end
+
+  ruby_bug "http://redmine.ruby-lang.org/projects/ruby-18/issues/show?id=115", "1.8.7.7" do
+    it "yields each Object in self in sorted order" do
+      ret = []
+      @set.delete_if { |x| ret << x }
+      ret.should == ["one", "two", "three"].sort
+    end
+  end
+
+  it "deletes every element from self for which the passed block returns true" do
+    @set.delete_if { |x| x.size == 3 }
+    @set.size.should eql(1)
+
+    @set.should_not include("one")
+    @set.should_not include("two")
+    @set.should include("three")
+  end
+
+  it "returns self" do
+    @set.delete_if { |x| x }.should equal(@set)
+  end
+
+  ruby_version_is "" ... "1.8.8" do
+    it "raises a LocalJumpError when passed no block" do
+      lambda { @set.delete_if }.should raise_error(LocalJumpError)
+    end
+  end
+
+  ruby_version_is "1.8.8" do
+    it "returns an Enumerator when passed no block" do
+      enum = @set.delete_if
+      enum.should be_an_instance_of(enumerator_class)
+
+      enum.each { |x| x.size == 3 }
+
+      @set.should_not include("one")
+      @set.should_not include("two")
+      @set.should include("three")
+    end
+  end
+end

data/spec/sortedset/delete_spec.rb

@@ -0,0 +1,36 @@
+require 'set'
+
+describe "SortedSet#delete" do
+  before(:each) do
+    @set = SortedSet["a", "b", "c"]
+  end
+
+  it "deletes the passed Object from self" do
+    @set.delete("a")
+    @set.should_not include("a")
+  end
+
+  it "returns self" do
+    @set.delete("a").should equal(@set)
+    @set.delete("x").should equal(@set)
+  end
+end
+
+describe "SortedSet#delete?" do
+  before(:each) do
+    @set = SortedSet["a", "b", "c"]
+  end
+
+  it "deletes the passed Object from self" do
+    @set.delete?("a")
+    @set.should_not include("a")
+  end
+
+  it "returns self when the passed Object is in self" do
+    @set.delete?("a").should equal(@set)
+  end
+
+  it "returns nil when the passed Object is not in self" do
+    @set.delete?("x").should be_nil
+  end
+end

data/spec/sortedset/difference_spec.rb

@@ -0,0 +1,6 @@
+require 'set'
+require File.expand_path('../shared/difference', __FILE__)
+
+describe "SortedSet#difference" do
+  it_behaves_like :sorted_set_difference, :difference
+end

data/spec/sortedset/divide_spec.rb

@@ -0,0 +1,33 @@
+require 'set'
+
+describe "SortedSet#divide" do
+  it "divides self into a set of subsets based on the blocks return values" do
+    set = SortedSet["one", "two", "three", "four", "five"].divide { |x| x.length }
+    set.map { |x| x.to_a }.to_a.sort.should == [["five", "four"], ["one", "two"], ["three"]]
+  end
+
+  it "yields each Object in self in sorted order" do
+    ret = []
+    SortedSet["one", "two", "three", "four", "five"].divide { |x| ret << x }
+    ret.should == ["one", "two", "three", "four", "five"].sort
+  end
+
+  # BUG: Does not raise a LocalJumpError, but a NoMethodError
+  #
+  # it "raises a LocalJumpError when not passed a block" do
+  #   lambda { SortedSet[1].divide }.should raise_error(LocalJumpError)
+  # end
+end
+
+describe "SortedSet#divide when passed a block with an arity of 2" do
+  it "divides self into a set of subsets based on the blocks return values" do
+    set = SortedSet[1, 3, 4, 6, 9, 10, 11].divide { |x, y| (x - y).abs == 1 }
+    set.map { |x| x.to_a }.to_a.sort.should == [[1], [3, 4], [6], [9, 10, 11]]
+  end
+
+  it "yields each two Objects to the block" do
+    ret = []
+    SortedSet[1, 2].divide { |x, y| ret << [x, y] }
+    ret.should == [[1, 1], [1, 2], [2, 1], [2, 2]]
+  end
+end

data/spec/sortedset/each_spec.rb

@@ -0,0 +1,35 @@
+require 'set'
+
+describe "SortedSet#each" do
+  before(:each) do
+    @set = SortedSet[1, 2, 3]
+  end
+
+  it "yields each Object in self in sorted order" do
+    ret = []
+    SortedSet["one", "two", "three"].each { |x| ret << x }
+    ret.should == ["one", "two", "three"].sort
+  end
+
+  ruby_bug "http://redmine.ruby-lang.org/issues/show/116", "1.8.7.7" do
+    it "returns self" do
+      @set.each { |x| x }.should equal(@set)
+    end
+  end
+
+  ruby_version_is "1.8.7" do
+    it "returns an Enumerator when not passed a block" do
+      enum = @set.each
+
+      ret = []
+      enum.each { |x| ret << x }
+      ret.sort.should == [1, 2, 3]
+    end
+  end
+
+  ruby_version_is "" ... "1.8.7" do
+    it "raises a LocalJumpError when not passed a block" do
+      lambda { @set.each }.should raise_error(LocalJumpError)
+    end
+  end
+end

data/spec/sortedset/empty_spec.rb

@@ -0,0 +1,9 @@
+require 'set'
+
+describe "SortedSet#empty?" do
+  it "returns true if self is empty" do
+    SortedSet[].empty?.should be_true
+    SortedSet[1].empty?.should be_false
+    SortedSet[1,2,3].empty?.should be_false
+  end
+end

data/spec/sortedset/eql_spec.rb

@@ -0,0 +1,17 @@
+require 'set'
+
+ruby_version_is "1.8.7" do
+  describe "SortedSet#eql?" do
+    it "returns true when the passed argument is a SortedSet and contains the same elements" do
+      SortedSet[].should eql(SortedSet[])
+      SortedSet[1, 2, 3].should eql(SortedSet[1, 2, 3])
+      SortedSet[1, 2, 3].should eql(SortedSet[3, 2, 1])
+
+#      SortedSet["a", :b, ?c].should eql(SortedSet[?c, :b, "a"])
+
+      SortedSet[1, 2, 3].should_not eql(SortedSet[1.0, 2, 3])
+      SortedSet[1, 2, 3].should_not eql(SortedSet[2, 3])
+      SortedSet[1, 2, 3].should_not eql(SortedSet[])
+    end
+  end
+end

data/spec/sortedset/equal_value_spec.rb

@@ -0,0 +1,12 @@
+require 'set'
+
+describe "SortedSet#==" do
+  it "returns true when the passed Object is a SortedSet and self and the Object contain the same elements" do
+    SortedSet[].should == SortedSet[]
+    SortedSet[1, 2, 3].should == SortedSet[1, 2, 3]
+    SortedSet["1", "2", "3"].should == SortedSet["1", "2", "3"]
+
+    SortedSet[1, 2, 3].should_not == SortedSet[1.0, 2, 3]
+    SortedSet[1, 2, 3].should_not == [1, 2, 3]
+  end
+end