rubysl-set 0.0.1 → 1.0.0

data/lib/{rubysl-set → rubysl/set}/version.rb

@@ -1,5 +1,5 @@
 module RubySL
   module Set
-    VERSION = "0.0.1"
+    VERSION = "1.0.0"
   end
 end

data/lib/set.rb

@@ -0,0 +1 @@
+require "rubysl/set"

data/rubysl-set.gemspec

@@ -1,22 +1,23 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../lib/rubysl-set/version', __FILE__)
+# coding: utf-8
+require './lib/rubysl/set/version'
 
-Gem::Specification.new do |gem|
-  gem.authors       = ["Brian Shirai"]
-  gem.email         = ["brixen@gmail.com"]
-  gem.description   = %q{Ruby Standard Library - set}
-  gem.summary       = %q{Ruby Standard Library - set}
-  gem.homepage      = ""
+Gem::Specification.new do |spec|
+  spec.name          = "rubysl-set"
+  spec.version       = RubySL::Set::VERSION
+  spec.authors       = ["Brian Shirai"]
+  spec.email         = ["brixen@gmail.com"]
+  spec.description   = %q{Ruby standard library set.}
+  spec.summary       = %q{Ruby standard library set.}
+  spec.homepage      = "https://github.com/rubysl/rubysl-set"
+  spec.license       = "BSD"
 
-  gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.name          = "rubysl-set"
-  gem.require_paths = ["lib"]
-  gem.version       = RubySL::Set::VERSION
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
 
-  gem.add_runtime_dependency "redcard", "~> 1.0"
-
-  gem.add_development_dependency "rake",  "~> 10.0"
-  gem.add_development_dependency "mspec", "~> 1.5"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "mspec", "~> 1.5"
+  spec.add_development_dependency "rubysl-prettyprint", "~> 1.0"
 end

data/spec/add_spec.rb

@@ -0,0 +1,26 @@
+require 'set'
+require File.expand_path('../shared/add', __FILE__)
+
+describe "Set#add" do
+  it_behaves_like :set_add, :add
+end
+
+describe "Set#add?" do
+  before :each do
+    @set = Set.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/append_spec.rb

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

data/spec/classify_spec.rb

@@ -0,0 +1,34 @@
+require 'set'
+
+describe "Set#classify" do
+  before(:each) do
+    @set = Set["one", "two", "three", "four"]
+  end
+
+  it "yields each Object in self" do
+    res = []
+    @set.classify { |x| res << x }
+    res.sort.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 => Set["one", "two"], 4 => Set["four"], 5 => Set["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 => Set["one", "two"], 4 => Set["four"], 5 => Set["three"] }
+  end
+end

data/spec/clear_spec.rb

@@ -0,0 +1,16 @@
+require 'set'
+
+describe "Set#clear" do
+  before(:each) do
+    @set = Set["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/collect_spec.rb

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

data/spec/constructor_spec.rb

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

data/spec/delete_if_spec.rb

@@ -0,0 +1,45 @@
+require 'set'
+
+describe "Set#delete_if" do
+  before(:each) do
+    @set = Set["one", "two", "three"]
+  end
+
+  it "yields every element of self" do
+    ret = []
+    @set.delete_if { |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.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/delete_spec.rb

@@ -0,0 +1,36 @@
+require 'set'
+
+describe "Set#delete" do
+  before(:each) do
+    @set = Set["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 "Set#delete?" do
+  before(:each) do
+    @set = Set["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/difference_spec.rb

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

data/spec/divide_spec.rb

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

data/spec/each_spec.rb

@@ -0,0 +1,33 @@
+require 'set'
+
+describe "Set#each" do
+  before(:each) do
+    @set = Set[1, 2, 3]
+  end
+
+  it "yields each Object in self" do
+    ret = []
+    @set.each { |x| ret << x }
+    ret.sort.should == [1, 2, 3]
+  end
+
+  it "returns self" do
+    @set.each { |x| x }.should equal(@set)
+  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/empty_spec.rb

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

data/spec/enumerable/to_set_spec.rb

@@ -0,0 +1,18 @@
+require 'set'
+
+describe "Emumerable#to_set" do
+  it "returns a new Set created from self" do
+    [1, 2, 3].to_set.should == Set[1, 2, 3]
+    {:a => 1, :b => 2}.to_set.should == Set[[:b, 2], [:a, 1]]
+  end
+
+  it "allows passing an alternate class for Set" do
+    sorted_set = [1, 2, 3].to_set(SortedSet)
+    sorted_set.should == SortedSet[1, 2, 3]
+    sorted_set.instance_of?(SortedSet).should == true
+  end
+
+  it "passes down passed blocks" do
+    [1, 2, 3].to_set { |x| x * x }.should == Set[1, 4, 9]
+  end
+end

data/spec/eql_spec.rb

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

data/spec/equal_value_spec.rb

@@ -0,0 +1,37 @@
+require 'set'
+
+describe "Set#==" do
+  it "returns true when the passed Object is a Set and self and the Object contain the same elements" do
+    Set[].should == Set[]
+    Set[1, 2, 3].should == Set[1, 2, 3]
+    Set["1", "2", "3"].should == Set["1", "2", "3"]
+
+    Set[1, 2, 3].should_not == Set[1.0, 2, 3]
+    Set[1, 2, 3].should_not == [1, 2, 3]
+  end
+
+  it "does not depend on the order of the elements" do
+    Set[1, 2, 3].should == Set[3, 2, 1]
+    Set[:a, "b", ?c].should == Set[?c, "b", :a]
+  end
+
+  ruby_version_is "" ... "1.8.7" do
+    it "does depend on the order of nested Sets" do
+      Set[Set[1], Set[2], Set[3]].should_not == Set[Set[3], Set[2], Set[1]]
+
+      set1 = Set[Set["a", "b"], Set["c", "d"], Set["e", "f"]]
+      set2 = Set[Set["c", "d"], Set["a", "b"], Set["e", "f"]]
+      set1.should_not == set2
+    end
+  end
+
+  ruby_version_is "1.8.7" do
+    it "does not depend on the order of nested Sets" do
+      Set[Set[1], Set[2], Set[3]].should == Set[Set[3], Set[2], Set[1]]
+
+      set1 = Set[Set["a", "b"], Set["c", "d"], Set["e", "f"]]
+      set2 = Set[Set["c", "d"], Set["a", "b"], Set["e", "f"]]
+      set1.should == set2
+    end
+  end
+end

data/spec/exclusion_spec.rb

@@ -0,0 +1,17 @@
+require 'set'
+
+describe "Set#^" do
+  before :each do
+    @set = Set[1, 2, 3, 4]
+  end
+
+  it "returns a new Set containing elements that are not in both self and the passed Enumberable" do
+    (@set ^ Set[3, 4, 5]).should == Set[1, 2, 5]
+    (@set ^ [3, 4, 5]).should == Set[1, 2, 5]
+  end
+
+  it "raises an ArgumentError when passed a non-Enumerable" do
+    lambda { @set ^ 3 }.should raise_error(ArgumentError)
+    lambda { @set ^ Object.new }.should raise_error(ArgumentError)
+  end
+end

data/spec/flatten_merge_spec.rb

@@ -0,0 +1,22 @@
+require 'set'
+
+describe "Set#flatten_merge" do
+  it "is protected" do
+    Set.should have_protected_instance_method("flatten_merge")
+  end
+
+  it "flattens the passed Set and merges it into self" do
+    set1 = Set[1, 2]
+    set2 = Set[3, 4, Set[5, 6]]
+
+    set1.send(:flatten_merge, set2).should == Set[1, 2, 3, 4, 5, 6]
+  end
+
+  it "raises an ArgumentError when trying to flatten a recursive Set" do
+    set1 = Set[1, 2, 3]
+    set2 = Set[5, 6, 7]
+    set2 << set2
+
+    lambda { set1.send(:flatten_merge, set2) }.should raise_error(ArgumentError)
+  end
+end