rubysl-set 0.0.1 → 1.0.0

data/spec/flatten_spec.rb

@@ -0,0 +1,39 @@
+require 'set'
+
+describe "Set#flatten" do
+  it "returns a copy of self with each included Set flattened" do
+    set = Set[1, 2, Set[3, 4, Set[5, 6, Set[7, 8]]], 9, 10]
+    flattened_set = set.flatten
+
+    flattened_set.should_not equal(set)
+    flattened_set.should == Set[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  end
+
+  it "raises an ArgumentError when self is recursive" do
+    (set = Set[]) << set
+    lambda { set.flatten }.should raise_error(ArgumentError)
+  end
+end
+
+describe "Set#flatten!" do
+  it "flattens self" do
+    set = Set[1, 2, Set[3, 4, Set[5, 6, Set[7, 8]]], 9, 10]
+    set.flatten!
+    set.should == Set[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  end
+
+  it "returns self when self was modified" do
+    set = Set[1, 2, Set[3, 4]]
+    set.flatten!.should equal(set)
+  end
+
+  it "returns nil when self was not modified" do
+    set = Set[1, 2, 3, 4]
+    set.flatten!.should be_nil
+  end
+
+  it "raises an ArgumentError when self is recursive" do
+    (set = Set[]) << set
+    lambda { set.flatten! }.should raise_error(ArgumentError)
+  end
+end

data/spec/hash_spec.rb

@@ -0,0 +1,14 @@
+require 'set'
+
+ruby_version_is "1.8.7" do
+  describe "Set#hash" do
+    it "is static" do
+      Set[].hash.should == Set[].hash
+      Set[1, 2, 3].hash.should == Set[1, 2, 3].hash
+      Set[:a, "b", ?c].hash.should == Set[?c, "b", :a].hash
+
+      Set[].hash.should_not == Set[1, 2, 3].hash
+      Set[1, 2, 3].hash.should_not == Set[:a, "b", ?c].hash
+    end
+  end
+end

data/spec/include_spec.rb

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

data/spec/initialize_copy_spec.rb

@@ -0,0 +1,17 @@
+require 'set'
+
+describe "Set#initialize_copy" do
+  before(:each) do
+    @set = Set[1, 2, 3]
+  end
+
+  it "is private" do
+    Set.should have_private_instance_method(:initialize_copy)
+  end
+
+  it "replaces all elements of self with the elements of the passed Set" do
+    other = Set["1", "2", "3"]
+    @set.send(:initialize_copy, other)
+    @set.should == Set["1", "2", "3"]
+  end
+end

data/spec/initialize_spec.rb

@@ -0,0 +1,23 @@
+require 'set'
+
+describe "Set#initialize" do
+  it "is private" do
+    Set.should have_private_instance_method(:initialize)
+  end
+
+  it "adds all elements of the passed Enumerable to self" do
+    s = Set.new([1, 2, 3])
+    s.size.should eql(3)
+    s.should include(1)
+    s.should include(2)
+    s.should include(3)
+  end
+
+  it "preprocesses all elements by a passed block before adding to self" do
+    s = Set.new([1, 2, 3]) { |x| x * x }
+    s.size.should eql(3)
+    s.should include(1)
+    s.should include(4)
+    s.should include(9)
+  end
+end

data/spec/inspect_spec.rb

@@ -0,0 +1,17 @@
+require 'set'
+
+describe "Set#inspect" do
+  it "returns a String representation of self" do
+    Set[].inspect.should be_kind_of(String)
+    Set[nil, false, true].inspect.should be_kind_of(String)
+    Set[1, 2, 3].inspect.should be_kind_of(String)
+    Set["1", "2", "3"].inspect.should be_kind_of(String)
+    Set[:a, "b", Set[?c]].inspect.should be_kind_of(String)
+  end
+
+  it "correctly handles self-references" do
+    (set = Set[]) << set
+    set.inspect.should be_kind_of(String)
+    set.inspect.should include("#<Set: {...}>")
+  end
+end

data/spec/intersection_spec.rb

@@ -0,0 +1,10 @@
+require File.expand_path('../shared/intersection', __FILE__)
+require 'set'
+
+describe "Set#intersection" do
+  it_behaves_like :set_intersection, :intersection
+end
+
+describe "Set#&" do
+  it_behaves_like :set_intersection, :&
+end

data/spec/keep_if_spec.rb

@@ -0,0 +1,39 @@
+require 'set'
+
+ruby_version_is "1.9" do
+  describe "Set#keep_if" do
+    before(:each) do
+      @set = Set["one", "two", "three"]
+    end
+
+    it "yields every element of self" do
+      ret = []
+      @set.keep_if { |x| ret << x }
+      ret.sort.should == ["one", "two", "three"].sort
+    end
+
+    it "keeps every element from self for which the passed block returns true" do
+      @set.keep_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.keep_if {}.should equal(@set)
+    end
+
+    it "returns an Enumerator when passed no block" do
+      enum = @set.keep_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/length_spec.rb

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

data/spec/map_spec.rb

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

data/spec/member_spec.rb

@@ -0,0 +1,6 @@
+require File.expand_path('../shared/include', __FILE__)
+require 'set'
+
+describe "Set#member?" do
+  it_behaves_like :set_include, :member?
+end

data/spec/merge_spec.rb

@@ -0,0 +1,18 @@
+require 'set'
+
+describe "Set#merge" do
+  it "adds the elements of the passed Enumerable to self" do
+    Set[:a, :b].merge(Set[:b, :c, :d]).should == Set[:a, :b, :c, :d]
+    Set[1, 2].merge([3, 4]).should == Set[1, 2, 3, 4]
+  end
+
+  it "returns self" do
+    set = Set[1, 2]
+    set.merge([3, 4]).should equal(set)
+  end
+
+  it "raises an ArgumentError when passed a non-Enumerable" do
+    lambda { Set[1, 2].merge(1) }.should raise_error(ArgumentError)
+    lambda { Set[1, 2].merge(Object.new) }.should raise_error(ArgumentError)
+  end
+end

data/spec/minus_spec.rb

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

data/spec/plus_spec.rb

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

data/spec/pretty_print_cycle_spec.rb

@@ -0,0 +1,9 @@
+require 'set'
+
+describe "Set#pretty_print_cycle" do
+  it "passes the 'pretty print' representation of a self-referencing Set to the pretty print writer" do
+    pp = mock("PrettyPrint")
+    pp.should_receive(:text).with("#<Set: {...}>")
+    Set[1, 2, 3].pretty_print_cycle(pp)
+  end
+end

data/spec/pretty_print_spec.rb

@@ -0,0 +1,16 @@
+require 'set'
+
+describe "Set#pretty_print" do
+  it "passes the 'pretty print' representation of self to the pretty print writer" do
+    pp = mock("PrettyPrint")
+    set = Set[1, 2, 3]
+
+    pp.should_receive(:text).with("#<Set: {")
+    pp.should_receive(:text).with("}>")
+
+    pp.should_receive(:nest).with(1).and_yield
+    pp.should_receive(:seplist).with(set)
+
+    set.pretty_print(pp)
+  end
+end

data/spec/proper_subset_spec.rb

@@ -0,0 +1,33 @@
+require 'set'
+
+describe "Set#proper_subset?" do
+  before(:each) do
+    @set = Set[1, 2, 3, 4]
+  end
+
+  it "returns true if passed a Set that self is a proper subset of" do
+    Set[].proper_subset?(@set).should be_true
+    Set[].proper_subset?(Set[1, 2, 3]).should be_true
+    Set[].proper_subset?(Set["a", :b, ?c]).should be_true
+
+    Set[1, 2, 3].proper_subset?(@set).should be_true
+    Set[1, 3].proper_subset?(@set).should be_true
+    Set[1, 2].proper_subset?(@set).should be_true
+    Set[1].proper_subset?(@set).should be_true
+
+    Set[5].proper_subset?(@set).should be_false
+    Set[1, 5].proper_subset?(@set).should be_false
+    Set[nil].proper_subset?(@set).should be_false
+    Set["test"].proper_subset?(@set).should be_false
+
+    @set.proper_subset?(@set).should be_false
+    Set[].proper_subset?(Set[]).should be_false
+  end
+
+  it "raises an ArgumentError when passed a non-Set" do
+    lambda { Set[].proper_subset?([]) }.should raise_error(ArgumentError)
+    lambda { Set[].proper_subset?(1) }.should raise_error(ArgumentError)
+    lambda { Set[].proper_subset?("test") }.should raise_error(ArgumentError)
+    lambda { Set[].proper_subset?(Object.new) }.should raise_error(ArgumentError)
+  end
+end

data/spec/proper_superset_spec.rb

@@ -0,0 +1,33 @@
+require 'set'
+
+describe "Set#proper_superset?" do
+  before(:each) do
+    @set = Set[1, 2, 3, 4]
+  end
+
+  it "returns true if passed a Set that self is a proper superset of" do
+    @set.proper_superset?(Set[]).should be_true
+    Set[1, 2, 3].proper_superset?(Set[]).should be_true
+    Set["a", :b, ?c].proper_superset?(Set[]).should be_true
+
+    @set.proper_superset?(Set[1, 2, 3]).should be_true
+    @set.proper_superset?(Set[1, 3]).should be_true
+    @set.proper_superset?(Set[1, 2]).should be_true
+    @set.proper_superset?(Set[1]).should be_true
+
+    @set.proper_superset?(Set[5]).should be_false
+    @set.proper_superset?(Set[1, 5]).should be_false
+    @set.proper_superset?(Set[nil]).should be_false
+    @set.proper_superset?(Set["test"]).should be_false
+
+    @set.proper_superset?(@set).should be_false
+    Set[].proper_superset?(Set[]).should be_false
+  end
+
+  it "raises an ArgumentError when passed a non-Set" do
+    lambda { Set[].proper_superset?([]) }.should raise_error(ArgumentError)
+    lambda { Set[].proper_superset?(1) }.should raise_error(ArgumentError)
+    lambda { Set[].proper_superset?("test") }.should raise_error(ArgumentError)
+    lambda { Set[].proper_superset?(Object.new) }.should raise_error(ArgumentError)
+  end
+end

data/spec/reject_spec.rb

@@ -0,0 +1,49 @@
+require 'set'
+
+describe "Set#reject!" do
+  before(:each) do
+    @set = Set["one", "two", "three"]
+  end
+
+  it "yields every element of self" do
+    ret = []
+    @set.reject! { |x| ret << x }
+    ret.sort.should == ["one", "two", "three"].sort
+  end
+
+  it "deletes every element from self for which the passed block returns true" do
+    @set.reject! { |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 when self was modified" do
+    @set.reject! { |x| true }.should equal(@set)
+  end
+
+  it "returns nil when self was not modified" do
+    @set.reject! { |x| false }.should be_nil
+  end
+
+  ruby_version_is "" ... "1.8.8" do
+    it "raises a LocalJumpError when passed no block" do
+      lambda { @set.reject! }.should raise_error(LocalJumpError)
+    end
+  end
+
+  ruby_version_is "1.8.8" do
+    it "returns an Enumerator when passed no block" do
+      enum = @set.reject!
+      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/replace_spec.rb

@@ -0,0 +1,16 @@
+require 'set'
+
+describe "Set#replace" do
+  before :each do
+    @set = Set[:a, :b, :c]
+  end
+
+  it "replaces the contents with other and returns self" do
+    @set.replace(Set[1, 2, 3]).should == @set
+    @set.should == Set[1, 2, 3]
+  end
+
+  it "accepts any enumerable as other" do
+    @set.replace([1, 2, 3]).should == Set[1, 2, 3]
+  end
+end

data/spec/select_spec.rb

@@ -0,0 +1,43 @@
+require 'set'
+
+ruby_version_is "1.9" do
+  describe "Set#select!" do
+    before(:each) do
+      @set = Set["one", "two", "three"]
+    end
+
+    it "yields every element of self" do
+      ret = []
+      @set.select! { |x| ret << x }
+      ret.sort.should == ["one", "two", "three"].sort
+    end
+
+    it "keeps every element from self for which the passed block returns true" do
+      @set.select! { |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 when self was modified" do
+      @set.select! { false }.should equal(@set)
+    end
+
+    it "returns nil when self was not modified" do
+      @set.select! { true }.should be_nil
+    end
+
+    it "returns an Enumerator when passed no block" do
+      enum = @set.select!
+      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