rubysl-set 1.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f85297c049ae95b1ab859180e5f81b7653583a52
-  data.tar.gz: a308eaf5aa2d518adfa3d470e3d3a8b371e63034
+  metadata.gz: 9c403dcc5fa5dfafb5beac4923ffde24d14dda17
+  data.tar.gz: cd3319cbe7a42048b97c4b51767129557d6b138e
 SHA512:
-  metadata.gz: 39cfe578a80a017ab3acc64cc15b2f86f88ef13b69d215083f0c571240c3d1fbbfa5a604f8dcc9797d2c51cada18e0c90c29edc2301f5465baed1c5b8df9a4f0
-  data.tar.gz: c56fb177f7687686f866f29cd2612dd33a461f654fb2dd8b2dd31d801ec1b930fb794f818f026d811f8d7431a2eec4ae46eed10b115c34cdaeb66b3e30f4b380
+  metadata.gz: 4f3c01b3e01847a1dcefdcdf4d22db1a631c30ab8fc9e3698826e526663ab3c97995a2b56e7e4df3e496bb70123eb68cc281f005b5b60f1be9f2e15734e34ce9
+  data.tar.gz: 605c99022766d6f9ef1f2995529dc5372f9cf2d03560f5287c754cdd3d8715b3bde4ab4597522d9f9f7f32e59abe54c93cff50fe9aafd81305181b6ac5bf0fa3

data/.travis.yml

@@ -1,8 +1,6 @@
 language: ruby
-before_install:
-  - gem update --system
-  - gem --version
-  - gem install rubysl-bundler
+env:
+  - RUBYLIB=lib
 script: bundle exec mspec spec
 rvm:
-  - rbx-nightly-18mode
+  - rbx-nightly-19mode

data/lib/rubysl/set.rb

@@ -1,2 +1,2 @@
-require "rubysl/set/set"
 require "rubysl/set/version"
+require "rubysl/set/set"

data/lib/rubysl/set/set.rb

@@ -4,15 +4,15 @@
 #++
 # Copyright (c) 2002-2008 Akinori MUSHA <knu@iDaemons.org>
 #
-# Documentation by Akinori MUSHA and Gavin Sinclair. 
+# Documentation by Akinori MUSHA and Gavin Sinclair.
 #
 # All rights reserved.  You can redistribute and/or modify it under the same
 # terms as Ruby.
 #
-#   $Id: set.rb 17051 2008-06-09 09:20:43Z knu $
+#   $Id: set.rb 28095 2010-05-30 13:15:17Z marcandre $
+#
+# == Overview
 #
-# == Overview 
-# 
 # This library provides the Set class, which deals with a collection
 # of unordered values with no duplicates.  It is a hybrid of Array's
 # intuitive inter-operation facilities and Hash's fast lookup.  If you
@@ -20,7 +20,7 @@
 #
 # The method +to_set+ is added to Enumerable for convenience.
 #
-# See the Set class for an example of usage.
+# See the Set and SortedSet documentation for examples of usage.
 
 
 #
@@ -28,14 +28,13 @@
 # This is a hybrid of Array's intuitive inter-operation facilities and
 # Hash's fast lookup.
 #
-# Several methods accept any Enumerable object (implementing +each+)
-# for greater flexibility: new, replace, merge, subtract, |, &, -, ^.
-#
 # The equality of each couple of elements is determined according to
 # Object#eql? and Object#hash, since Set uses Hash as storage.
 #
-# Finally, if you are using class Set, you can also use Enumerable#to_set
-# for convenience.
+# Set is easy to use with Enumerable objects (implementing +each+).
+# Most of the initializer methods and binary operators accept generic
+# Enumerable objects besides sets and arrays.  An Enumerable object
+# can be converted to Set using the +to_set+ method.
 #
 # == Example
 #
@@ -68,20 +67,49 @@ class Set
   def initialize(enum = nil, &block) # :yields: o
     @hash ||= Hash.new
 
-    return if enum.nil?
+    enum.nil? and return
 
     if block
-      enum.each { |o| add(block[o]) }
+      do_with_enum(enum) { |o| add(block[o]) }
     else
       merge(enum)
     end
   end
 
+  def do_with_enum(enum, &block)
+    if enum.respond_to?(:each_entry)
+      enum.each_entry(&block)
+    elsif enum.respond_to?(:each)
+      enum.each(&block)
+    else
+      raise ArgumentError, "value must be enumerable"
+    end
+  end
+  private :do_with_enum
+
   # Copy internal hash.
   def initialize_copy(orig)
     @hash = orig.instance_eval{@hash}.dup
   end
 
+  def freeze	# :nodoc:
+    super
+    @hash.freeze
+    self
+  end
+
+  def taint	# :nodoc:
+    super
+    @hash.taint
+    self
+  end
+
+  def untaint	# :nodoc:
+    super
+    @hash.untaint
+    self
+  end
+
   # Returns the number of elements.
   def size
     @hash.size
@@ -105,9 +133,8 @@ class Set
     if enum.class == self.class
       @hash.replace(enum.instance_eval { @hash })
     else
-      raise ArgumentError, "value must be enumerable" unless enum.is_a?(Enumerable)
       clear
-      enum.each { |o| add(o) }
+      merge(enum)
     end
 
     self
@@ -121,15 +148,15 @@ class Set
   def flatten_merge(set, seen = Set.new)
     set.each { |e|
       if e.is_a?(Set)
-        if seen.include?(e_id = e.object_id)
-          raise ArgumentError, "tried to flatten recursive Set"
-        end
+	if seen.include?(e_id = e.object_id)
+	  raise ArgumentError, "tried to flatten recursive Set"
+	end
 
-        seen.add(e_id)
-        flatten_merge(e, seen)
-        seen.delete(e_id)
+	seen.add(e_id)
+	flatten_merge(e, seen)
+	seen.delete(e_id)
       else
-        add(e)
+	add(e)
       end
     }
 
@@ -161,28 +188,28 @@ class Set
 
   # Returns true if the set is a superset of the given set.
   def superset?(set)
-    raise ArgumentError, "value must be a set" unless set.is_a?(Set)
+    set.is_a?(Set) or raise ArgumentError, "value must be a set"
     return false if size < set.size
     set.all? { |o| include?(o) }
   end
 
   # Returns true if the set is a proper superset of the given set.
   def proper_superset?(set)
-    raise ArgumentError, "value must be a set" unless set.is_a?(Set)
+    set.is_a?(Set) or raise ArgumentError, "value must be a set"
     return false if size <= set.size
     set.all? { |o| include?(o) }
   end
 
   # Returns true if the set is a subset of the given set.
   def subset?(set)
-    raise ArgumentError, "value must be a set" unless set.is_a?(Set)
+    set.is_a?(Set) or raise ArgumentError, "value must be a set"
     return false if set.size < size
     all? { |o| set.include?(o) }
   end
 
   # Returns true if the set is a proper subset of the given set.
   def proper_subset?(set)
-    raise ArgumentError, "value must be a set" unless set.is_a?(Set)
+    set.is_a?(Set) or raise ArgumentError, "value must be a set"
     return false if set.size <= size
     all? { |o| set.include?(o) }
   end
@@ -191,13 +218,13 @@ class Set
   # the element as parameter.  Returns an enumerator if no block is
   # given.
   def each
-    return enum_for(:each) unless block_given?
+    block_given? or return enum_for(__method__)
     @hash.each_key { |o| yield(o) }
     self
   end
 
   # Adds the given object to the set and returns self.  Use +merge+ to
-  # add several elements at once.
+  # add many elements at once.
   def add(o)
     @hash[o] = true
     self
@@ -215,7 +242,7 @@ class Set
   end
 
   # Deletes the given object from the set and returns self.  Use +subtract+ to
-  # delete several items at once.
+  # delete many items at once.
   def delete(o)
     @hash.delete(o)
     self
@@ -234,12 +261,22 @@ class Set
   # Deletes every element of the set for which block evaluates to
   # true, and returns self.
   def delete_if
+    block_given? or return enum_for(__method__)
     to_a.each { |o| @hash.delete(o) if yield(o) }
     self
   end
 
-  # Do collect() destructively.
+  # Deletes every element of the set for which block evaluates to
+  # false, and returns self.
+  def keep_if
+    block_given? or return enum_for(__method__)
+    to_a.each { |o| @hash.delete(o) unless yield(o) }
+    self
+  end
+
+  # Replaces the elements with ones returned by collect().
   def collect!
+    block_given? or return enum_for(__method__)
     set = self.class.new
     each { |o| set << yield(o) }
     replace(set)
@@ -249,19 +286,28 @@ class Set
   # Equivalent to Set#delete_if, but returns nil if no changes were
   # made.
   def reject!
+    block_given? or return enum_for(__method__)
     n = size
     delete_if { |o| yield(o) }
     size == n ? nil : self
   end
 
+  # Equivalent to Set#keep_if, but returns nil if no changes were
+  # made.
+  def select!
+    block_given? or return enum_for(__method__)
+    n = size
+    keep_if { |o| yield(o) }
+    size == n ? nil : self
+  end
+
   # Merges the elements of the given enumerable object to the set and
   # returns self.
   def merge(enum)
-    if enum.is_a?(Set)
-      @hash.update(enum.instance_eval { @hash })
+    if enum.instance_of?(self.class)
+      @hash.update(enum.instance_variable_get(:@hash))
     else
-      raise ArgumentError, "value must be enumerable" unless enum.is_a?(Enumerable)
-      enum.each { |o| add(o) }
+      do_with_enum(enum) { |o| add(o) }
     end
 
     self
@@ -270,43 +316,38 @@ class Set
   # Deletes every element that appears in the given enumerable object
   # and returns self.
   def subtract(enum)
-    raise ArgumentError, "value must be enumerable" unless enum.is_a?(Enumerable)
-    enum.each { |o| delete(o) }
+    do_with_enum(enum) { |o| delete(o) }
     self
   end
 
   # Returns a new set built by merging the set and the elements of the
   # given enumerable object.
   def |(enum)
-    raise ArgumentError, "value must be enumerable" unless enum.is_a?(Enumerable)
     dup.merge(enum)
   end
-  alias + |                ##
-  alias union |                ##
+  alias + |		##
+  alias union |		##
 
   # Returns a new set built by duplicating the set, removing every
   # element that appears in the given enumerable object.
   def -(enum)
-    raise ArgumentError, "value must be enumerable" unless enum.is_a?(Enumerable)
     dup.subtract(enum)
   end
-  alias difference -        ##
+  alias difference -	##
 
   # Returns a new set containing elements common to the set and the
   # given enumerable object.
   def &(enum)
-    raise ArgumentError, "value must be enumerable" unless enum.is_a?(Enumerable)
     n = self.class.new
-    enum.each { |o| n.add(o) if include?(o) }
+    do_with_enum(enum) { |o| n.add(o) if include?(o) }
     n
   end
-  alias intersection &        ##
+  alias intersection &	##
 
   # Returns a new set containing elements exclusive between the set
   # and the given enumerable object.  (set ^ enum) is equivalent to
   # ((set | enum) - (set & enum)).
   def ^(enum)
-    raise ArgumentError, "value must be enumerable" unless enum.is_a?(Enumerable)
     n = Set.new(enum)
     each { |o| if n.include?(o) then n.delete(o) else n.add(o) end }
     n
@@ -314,20 +355,23 @@ class Set
 
   # Returns true if two sets are equal.  The equality of each couple
   # of elements is defined according to Object#eql?.
-  def ==(set)
-    return true if equal?(set)
-
-    return false unless set.is_a?(Set) && size == set.size
-
-    hash = @hash.dup
-    set.all? { |o| hash.include?(o) }
+  def ==(other)
+    if self.equal?(other)
+      true
+    elsif other.instance_of?(self.class)
+      @hash == other.instance_variable_get(:@hash)
+    elsif other.is_a?(Set) && self.size == other.size
+      other.all? { |o| @hash.include?(o) }
+    else
+      false
+    end
   end
 
-  def hash        # :nodoc:
+  def hash	# :nodoc:
     @hash.hash
   end
 
-  def eql?(o)        # :nodoc:
+  def eql?(o)	# :nodoc:
     return false unless o.is_a?(Set)
     @hash.eql?(o.instance_eval{@hash})
   end
@@ -346,6 +390,8 @@ class Set
   #             #     2001=>#<Set: {"c.rb", "d.rb", "e.rb"}>,
   #             #     2002=>#<Set: {"f.rb"}>}
   def classify # :yields: o
+    block_given? or return enum_for(__method__)
+
     h = {}
 
     each { |i|
@@ -373,26 +419,28 @@ class Set
   #             #            #<Set: {3, 4}>,
   #             #            #<Set: {6}>}>
   def divide(&func)
+    func or return enum_for(__method__)
+
     if func.arity == 2
       require 'tsort'
 
-      class << dig = {}                # :nodoc:
-        include TSort
+      class << dig = {}		# :nodoc:
+	include TSort
 
-        alias tsort_each_node each_key
-        def tsort_each_child(node, &block)
-          fetch(node).each(&block)
-        end
+	alias tsort_each_node each_key
+	def tsort_each_child(node, &block)
+	  fetch(node).each(&block)
+	end
       end
 
       each { |u|
-        dig[u] = a = []
-        each{ |v| func.call(u, v) and a << v }
+	dig[u] = a = []
+	each{ |v| func.call(u, v) and a << v }
       }
 
       set = Set.new()
       dig.each_strongly_connected_component { |css|
-        set.add(self.class.new(css))
+	set.add(self.class.new(css))
       }
       set
     else
@@ -419,88 +467,153 @@ class Set
     end
   end
 
-  def pretty_print(pp)        # :nodoc:
+  def pretty_print(pp)	# :nodoc:
     pp.text sprintf('#<%s: {', self.class.name)
     pp.nest(1) {
       pp.seplist(self) { |o|
-        pp.pp o
+	pp.pp o
       }
     }
     pp.text "}>"
   end
 
-  def pretty_print_cycle(pp)        # :nodoc:
+  def pretty_print_cycle(pp)	# :nodoc:
     pp.text sprintf('#<%s: {%s}>', self.class.name, empty? ? '' : '...')
   end
 end
 
-# SortedSet implements a set which elements are sorted in order.  See Set.
+# 
+# SortedSet implements a Set that guarantees that it's element are
+# yielded in sorted order (according to the return values of their
+# #<=> methods) when iterating over them.
+# 
+# All elements that are added to a SortedSet must respond to the <=>
+# method for comparison.
+# 
+# Also, all elements must be <em>mutually comparable</em>: <tt>el1 <=>
+# el2</tt> must not return <tt>nil</tt> for any elements <tt>el1</tt>
+# and <tt>el2</tt>, else an ArgumentError will be raised when
+# iterating over the SortedSet.
+#
+# == Example
+# 
+#   require "set"
+#   
+#   set = SortedSet.new([2, 1, 5, 6, 4, 5, 3, 3, 3])
+#   ary = []
+#   
+#   set.each do |obj|
+#     ary << obj
+#   end
+#   
+#   p ary # => [1, 2, 3, 4, 5, 6]
+#   
+#   set2 = SortedSet.new([1, 2, "3"])
+#   set2.each { |obj| } # => raises ArgumentError: comparison of Fixnum with String failed
+#   
 class SortedSet < Set
   @@setup = false
 
   class << self
-    def [](*ary)        # :nodoc:
+    def [](*ary)	# :nodoc:
       new(ary)
     end
-  end
-
-  def initialize(*args, &block)
-    @keys = nil
-    super
-  end
-
-  def clear
-    @keys = nil
-    super
-  end
-
-  def replace(enum)
-    @keys = nil
-    super
-  end
 
-  def add(o)
-    raise ArgumentError, "value must respond to <=>" unless o.respond_to?(:<=>)
-    @keys = nil
-    @hash[o] = true
-    self
-  end
-
-  alias << add
+    def setup	# :nodoc:
+      @@setup and return
 
-  def delete(o)
-    @keys = nil
-    @hash.delete(o)
-    self
-  end
-
-  def delete_if
-    n = @hash.size
-    super
-    @keys = nil if @hash.size != n
-    self
-  end
-
-  def merge(enum)
-    @keys = nil
-    super
-  end
-
-  def each
-    return enum_for(:each) unless block_given?
-    to_a.each { |o| yield(o) }
-    self
-  end
+      module_eval {
+        # a hack to shut up warning
+        alias old_init initialize
+        remove_method :old_init
+      }
+      begin
+	require 'rbtree'
+
+	module_eval %{
+	  def initialize(*args, &block)
+	    @hash = RBTree.new
+	    super
+	  end
+	  
+	  def add(o)
+	    o.respond_to?(:<=>) or raise ArgumentError, "value must respond to <=>"
+	    super
+	  end
+	  alias << add
+	}
+      rescue LoadError
+	module_eval %{
+	  def initialize(*args, &block)
+	    @keys = nil
+	    super
+	  end
+
+	  def clear
+	    @keys = nil
+	    super
+	  end
+
+	  def replace(enum)
+	    @keys = nil
+	    super
+	  end
+
+	  def add(o)
+	    o.respond_to?(:<=>) or raise ArgumentError, "value must respond to <=>"
+	    @keys = nil
+	    super
+	  end
+	  alias << add
+
+	  def delete(o)
+	    @keys = nil
+	    @hash.delete(o)
+	    self
+	  end
+
+	  def delete_if
+            block_given? or return enum_for(__method__)
+	    n = @hash.size
+	    super
+	    @keys = nil if @hash.size != n
+	    self
+	  end
+
+	  def keep_if
+	    block_given? or return enum_for(__method__)
+	    n = @hash.size
+	    super
+	    @keys = nil if @hash.size != n
+	    self
+	  end
+
+	  def merge(enum)
+	    @keys = nil
+	    super
+	  end
+
+	  def each
+	    block_given? or return enum_for(__method__)
+	    to_a.each { |o| yield(o) }
+	    self
+	  end
+
+	  def to_a
+	    (@keys = @hash.keys).sort! unless @keys
+	    @keys
+	  end
+	}
+      end
 
-  def to_a
-    unless @keys
-      keys = @hash.keys
-      keys.sort!
-      @keys = keys
+      @@setup = true
     end
-    @keys
   end
 
+  def initialize(*args, &block)	# :nodoc:
+    SortedSet.setup
+    initialize(*args, &block)
+  end
 end
 
 module Enumerable
@@ -515,97 +628,97 @@ end
 # == RestricedSet class
 # RestricedSet implements a set with restrictions defined by a given
 # block.
-# 
+#
 # === Super class
 #     Set
-# 
+#
 # === Class Methods
 # --- RestricedSet::new(enum = nil) { |o| ... }
 # --- RestricedSet::new(enum = nil) { |rset, o| ... }
 #     Creates a new restricted set containing the elements of the given
 #     enumerable object.  Restrictions are defined by the given block.
-# 
+#
 #     If the block's arity is 2, it is called with the RestrictedSet
 #     itself and an object to see if the object is allowed to be put in
 #     the set.
-# 
+#
 #     Otherwise, the block is called with an object to see if the object
 #     is allowed to be put in the set.
-# 
+#
 # === Instance Methods
 # --- restriction_proc
 #     Returns the restriction procedure of the set.
-# 
+#
 # =end
-# 
+#
 # class RestricedSet < Set
 #   def initialize(*args, &block)
 #     @proc = block or raise ArgumentError, "missing a block"
-# 
+#
 #     if @proc.arity == 2
 #       instance_eval %{
-#         def add(o)
-#           @hash[o] = true if @proc.call(self, o)
-#           self
-#         end
-#         alias << add
-# 
-#         def add?(o)
-#           if include?(o) || !@proc.call(self, o)
-#             nil
-#           else
-#             @hash[o] = true
-#             self
-#           end
-#         end
-# 
-#         def replace(enum)
-#           enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
-#           clear
-#           enum.each { |o| add(o) }
-# 
-#           self
-#         end
-# 
-#         def merge(enum)
-#           enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
-#           enum.each { |o| add(o) }
-# 
-#           self
-#         end
+# 	def add(o)
+# 	  @hash[o] = true if @proc.call(self, o)
+# 	  self
+# 	end
+# 	alias << add
+#
+# 	def add?(o)
+# 	  if include?(o) || !@proc.call(self, o)
+# 	    nil
+# 	  else
+# 	    @hash[o] = true
+# 	    self
+# 	  end
+# 	end
+#
+# 	def replace(enum)
+# 	  enum.respond_to?(:each) or raise ArgumentError, "value must be enumerable"
+# 	  clear
+# 	  enum.each_entry { |o| add(o) }
+#
+# 	  self
+# 	end
+#
+# 	def merge(enum)
+# 	  enum.respond_to?(:each) or raise ArgumentError, "value must be enumerable"
+# 	  enum.each_entry { |o| add(o) }
+#
+# 	  self
+# 	end
 #       }
 #     else
 #       instance_eval %{
-#         def add(o)
+# 	def add(o)
 #         if @proc.call(o)
-#             @hash[o] = true 
-#         end
-#           self
-#         end
-#         alias << add
-# 
-#         def add?(o)
-#           if include?(o) || !@proc.call(o)
-#             nil
-#           else
-#             @hash[o] = true
-#             self
-#           end
+# 	    @hash[o] = true
 #         end
+# 	  self
+# 	end
+# 	alias << add
+#
+# 	def add?(o)
+# 	  if include?(o) || !@proc.call(o)
+# 	    nil
+# 	  else
+# 	    @hash[o] = true
+# 	    self
+# 	  end
+# 	end
 #       }
 #     end
-# 
+#
 #     super(*args)
 #   end
-# 
+#
 #   def restriction_proc
 #     @proc
 #   end
 # end
 
-# if $0 == __FILE__
-  # eval DATA.read, nil, $0, __LINE__+4
-# end
+if $0 == __FILE__
+  eval DATA.read, nil, $0, __LINE__+4
+end
 
 __END__
 
@@ -635,7 +748,6 @@ class TC_Set < Test::Unit::TestCase
       Set.new([])
       Set.new([1,2])
       Set.new('a'..'c')
-      Set.new('XYZ')
     }
     assert_raises(ArgumentError) {
       Set.new(false)
@@ -723,12 +835,12 @@ class TC_Set < Test::Unit::TestCase
     set1 = Set[
       1,
       Set[
-        5,
-        Set[7,
-          Set[0]
-        ],
-        Set[6,2],
-        1
+	5,
+	Set[7,
+	  Set[0]
+	],
+	Set[6,2],
+	1
       ],
       3,
       Set[3,4]
@@ -904,14 +1016,14 @@ class TC_Set < Test::Unit::TestCase
     assert_same(set, ret)
 
     e = set.each
-    assert_instance_of(Enumerable::Enumerator, e)
+    assert_instance_of(Enumerator, e)
 
     assert_nothing_raised {
       set.each { |o|
-        raise "unexpected element: #{o}" unless ary.delete(o)
+	ary.delete(o) or raise "unexpected element: #{o}"
       }
 
-      raise "forgotten elements: #{ary.join(', ')}" unless ary.empty?
+      ary.empty? or raise "forgotten elements: #{ary.join(', ')}"
     }
   end
 
@@ -973,11 +1085,11 @@ class TC_Set < Test::Unit::TestCase
     ret = set.collect! { |i|
       case i
       when Numeric
-        i * 2
+	i * 2
       when String
-        i.upcase
+	i.upcase
       else
-        nil
+	nil
       end
     }
 
@@ -1102,15 +1214,15 @@ class TC_Set < Test::Unit::TestCase
     assert_equal(set, ret.flatten)
     ret.each { |s|
       if s.include?(0)
-        assert_equal(Set[0,1], s)
+	assert_equal(Set[0,1], s)
       elsif s.include?(3)
-        assert_equal(Set[3,4,5], s)
+	assert_equal(Set[3,4,5], s)
       elsif s.include?(7)
-        assert_equal(Set[7], s)
+	assert_equal(Set[7], s)
       elsif s.include?(9)
-        assert_equal(Set[9,10,11], s)
+	assert_equal(Set[9,10,11], s)
       else
-        raise "unexpected group: #{s.inspect}"
+	raise "unexpected group: #{s.inspect}"
       end
     }
   end
@@ -1204,33 +1316,33 @@ end
 # class TC_RestricedSet < Test::Unit::TestCase
 #   def test_s_new
 #     assert_raises(ArgumentError) { RestricedSet.new }
-# 
+#
 #     s = RestricedSet.new([-1,2,3]) { |o| o > 0 }
 #     assert_equal([2,3], s.sort)
 #   end
-# 
+#
 #   def test_restriction_proc
 #     s = RestricedSet.new([-1,2,3]) { |o| o > 0 }
-# 
+#
 #     f = s.restriction_proc
 #     assert_instance_of(Proc, f)
 #     assert(f[1])
 #     assert(!f[0])
 #   end
-# 
+#
 #   def test_replace
 #     s = RestricedSet.new(-3..3) { |o| o > 0 }
 #     assert_equal([1,2,3], s.sort)
-# 
+#
 #     s.replace([-2,0,3,4,5])
 #     assert_equal([3,4,5], s.sort)
 #   end
-# 
+#
 #   def test_merge
 #     s = RestricedSet.new { |o| o > 0 }
 #     s.merge(-5..5)
 #     assert_equal([1,2,3,4,5], s.sort)
-# 
+#
 #     s.merge([10,-10,-8,8])
 #     assert_equal([1,2,3,4,5,8,10], s.sort)
 #   end

data/lib/rubysl/set/version.rb

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

data/rubysl-set.gemspec

@@ -19,5 +19,4 @@ Gem::Specification.new do |spec|
   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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubysl-set
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Brian Shirai
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-16 00:00:00.000000000 Z
+date: 2013-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,20 +52,6 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.5'
-- !ruby/object:Gem::Dependency
-  name: rubysl-prettyprint
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.0'
 description: Ruby standard library set.
 email:
 - brixen@gmail.com
@@ -205,7 +191,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.7
 signing_key: 
 specification_version: 4
 summary: Ruby standard library set.