range_operators 0.0.1 → 0.1.1

data/Manifest

@@ -1,7 +1,9 @@
 LICENSE
-Manifest
 README.rdoc
 Rakefile
 lib/range_operators.rb
-lib/rangify.rb
+lib/range_operators/array_operator_definitions.rb
+lib/range_operators/range_operator_definitions.rb
+spec/array_operator_definitions_spec.rb
 spec/range_operators_spec.rb
+Manifest

data/README.rdoc

@@ -1,17 +1,18 @@
 = RangeOperators
 
-This gem will mixin range operations (addition and subtraction) into Ruby's Range class.
+This gem will mixin range operations into Ruby's Range and Array classes.
 
-It requires that the second operand have a '- (integer)' method defined (ie. Fixnum, Bignum, and Date).
-(This allows the determination of a previous/predecessor value of an object.)
+	Range Methods::	Addition and subtraction
+	
+	Array Methods:: Combining elements into ranges, determining intersection of elements,
+									and determining missing elements
 
 It assumes inclusive ranges (ie. 1..4) and range.first <= range.last.
-
-Values returned from the operations are in an array.
+Also, the objects making up the ranges must have #succ and #<=> methods.
 
 = Usage
 
-The methods added are Range#- (alias Range#minus) and Range#+ (alias Range#plus).
+The methods added are Range#- (alias Range#minus), Range#+ (alias Range#plus), Array#rangify, Array#intersection, and Array#missing.
 
 
 Examples:
@@ -22,6 +23,29 @@ irb > (1..10) - (4..6)  => [1..3, 7..10]
 
 irb > (1..10).minus(9..12)  => [1..8]
 
+Note:  #- requires that the second operand have a #- (integer) method defined (ie. Fixnum, Bignum, and Date).
+(This allows the determination of a previous/predecessor value of an object.)
+----
+
 irb > (1..10) + (9..12)  => [1..12]
 
 irb > (1..10).plus(15..20)  => [1..10, 15..20]
+----
+
+irb > [1,2,3,6,7,8].rangify  => [1..3, 6..8]
+
+irb > [10..15, 16..20, 21, 22].rangify  => [10..22]
+----
+
+irb > [1, 2].intersection  => nil
+
+irb > [1..10, 1].intersection  => 1
+
+irb > [5..10, 1..10, 4..8 ].intersection  => 5..8
+
+Note:  #intersection will determine the values in common to all of the elements.
+----
+
+irb > [100, 9..11, 14, 1..5, 16, 10..12, 17..17].missing  => [6..8, 13, 15, 18..99]
+
+Note:  Like #-, #missing requires that the second operand have a #- (integer) method. 

data/Rakefile

@@ -2,8 +2,8 @@ require 'rubygems'
 require 'rake'
 require 'echoe'
 
-Echoe.new('range_operators', '0.0.1') do |p|
-  p.description    = "A gem that adds addition and subtraction to Ruby's Range class."
+Echoe.new('range_operators', '0.1.1') do |p|
+  p.description    = "A gem that adds range methods to Ruby's Range and Array classes. (Range#+, Range#-, Array#rangify, Array#intersection, Array#missing)"
   p.url            = "http://github.com/monocle/range_operators"
   p.author         = "monocle"
   p.email          = "frappez_2000@yahoo.com"

data/lib/range_operators.rb

@@ -1,47 +1,2 @@
-#Will add range operations ('+' and '-') to Ruby's Range class.
-#Requires that the second operand have a '- (integer)' method defined (ie. Fixnum, Bignum, and Date).
-#Assumes inclusive ranges (ie. 1..4) and range.first <= range.last.
-#Values returned from the operations are in an array.
-module RangeOperators
-	require 'rangify'
-	
-	def +(value)
-		[self, value].rangify
-	end
-
-	alias plus +
-	
-	def -(value)
-		if value.class == self.first.class
-			self.minus_obj(value)
-		else
-			[self.minus_obj(value.first)[0], self.minus_obj(value.last)[1]].compact
-		end
-	end
-	
-	alias minus -
-	
-	protected
-	
-	def minus_obj(value)
-		first = case value <=> self.first.succ
-			when -1 then nil
-			when 0 then self.first
-			else
-				value < self.last.succ ? self.first..(value - 1) : self
-		end
-
-		second = case self.last <=> value.succ
-			when -1 then nil
-			when 0 then self.last
-			else
-				value.succ > self.first ? value.succ..self.last : self
-		end
-
-		[first, second]
-	end
-end
-
-class Range
-	include RangeOperators
-end
+require 'range_operators/array_operator_definitions'
+require 'range_operators/range_operator_definitions'

data/lib/range_operators/array_operator_definitions.rb

@@ -0,0 +1,92 @@
+module RangeOperators
+#= Rangify
+#
+#This module will add the rangify method to Ruby's Array class.
+#The rangify method will produce appropriate ranges from the objects in the array.
+#
+#= Usage
+#
+#Examples:
+#
+#[1,2,3,6,7,8].rangify = [1..3, 6..8]
+#
+#[10..15, 16..20, 21, 22].rangify = [10..22]
+#
+#
+#Assumes inclusive ranges (ie. 1..4) and range.first <= range.last.
+#
+#Works with integers, dates and strings.  However, all the objects in the array must be of the same class.
+	module ArrayOperatorDefinitions
+		def rangify
+			array = self.sort_elements
+			array.inject([]) do |collection, value|
+				unless collection.empty?
+					last = collection.last
+					last_value = comparison_value(last, :last)
+					current_value = comparison_value(value, :first)
+					if (last_value.succ <=> current_value) == -1
+						collection << value
+					else
+						first = comparison_value(last, :first)
+						second = [comparison_value(last, :last), comparison_value(value, :last)].max
+						collection[-1] = [first..second]
+						collection.flatten!
+					end
+				else
+					collection << value
+				end
+			end
+		end
+		
+		# Returns the values in common for an array set (nil, singe value/object, or range).
+		def intersection
+			array = self.sort_elements
+			array.inject() do |common, element|
+				value_first = comparison_value(common, :last)
+				value_element = comparison_value(element, :first)
+				case value_first <=> value_element
+				when -1 then return nil
+				when 0 then value_first
+				else
+					if element.class == Range 
+						value_element..([value_first, comparison_value(element, :last)].min)
+					else
+						value_element
+					end
+				end
+			end
+		end
+		
+		#Returns the missing elements in an array set
+		def missing
+			missing, array = [], self.rangify
+			i, length = 0, array.size - 1
+
+			while i < length 
+				current = comparison_value(array[i], :last)
+				nextt = comparison_value(array[i+1], :first)
+				missing << (current.succ.succ == nextt ? current.succ : (current.succ)..(nextt - 1))
+				i += 1
+			end
+			missing
+		end
+
+	  protected
+		
+		def sort_elements
+			self.uniq.sort_by { |element| comparison_value(element, :first) }
+		end
+
+		private
+		
+		# For a Range, will return value.first or value.last. A non-Range will return itself.  
+		def comparison_value(value, position)
+			return value if value.class != Range
+			position == :first ? value.first : value.last
+		end
+	end
+end
+
+class Array
+  include RangeOperators::ArrayOperatorDefinitions
+end

data/lib/range_operators/range_operator_definitions.rb

@@ -0,0 +1,48 @@
+module RangeOperators
+#Will add range operations ('+' and '-') to Ruby's Range class.
+#Requires that the second operand have a '- (integer)' method defined (ie. Fixnum, Bignum, and Date).
+#Assumes inclusive ranges (ie. 1..4) and range.first <= range.last.
+#Values returned from the operations are in an array.
+	module RangeOperatorDefinitions
+	
+		def +(value)
+			[self, value].rangify
+		end
+
+		alias plus +
+		
+		def -(value)
+			if value.class == self.first.class
+				self.minus_obj(value)
+			else
+				[self.minus_obj(value.first)[0], self.minus_obj(value.last)[1]].compact
+			end
+		end
+		
+		alias minus -
+		
+		protected
+		
+		def minus_obj(value)
+			first = case value <=> self.first.succ
+			when -1 then nil
+			when 0 then self.first
+			else
+				value < self.last.succ ? self.first..(value - 1) : self
+			end
+
+			second = case self.last <=> value.succ
+			when -1 then nil
+			when 0 then self.last
+			else
+				value.succ > self.first ? value.succ..self.last : self
+			end
+
+			[first, second]
+		end
+	end
+end
+
+class Range
+	include RangeOperators::RangeOperatorDefinitions
+end

data/range_operators.gemspec

@@ -2,23 +2,23 @@
 
 Gem::Specification.new do |s|
   s.name = %q{range_operators}
-  s.version = "0.0.1"
+  s.version = "0.1.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["monocle"]
   s.cert_chain = ["/ruby/keys/range_operators/gem-public_cert.pem"]
-  s.date = %q{2010-07-03}
-  s.description = %q{A gem that adds addition and subtraction to Ruby's Range class.}
+  s.date = %q{2010-07-04}
+  s.description = %q{A gem that adds range methods to Ruby's Range and Array classes. (Range#+, Range#-, Array#rangify, Array#intersection, Array#missing)}
   s.email = %q{frappez_2000@yahoo.com}
-  s.extra_rdoc_files = ["LICENSE", "README.rdoc", "lib/range_operators.rb", "lib/rangify.rb"]
-  s.files = ["LICENSE", "Manifest", "README.rdoc", "Rakefile", "lib/range_operators.rb", "lib/rangify.rb", "spec/range_operators_spec.rb", "range_operators.gemspec"]
+  s.extra_rdoc_files = ["LICENSE", "README.rdoc", "lib/range_operators.rb", "lib/range_operators/array_operator_definitions.rb", "lib/range_operators/range_operator_definitions.rb"]
+  s.files = ["LICENSE", "README.rdoc", "Rakefile", "lib/range_operators.rb", "lib/range_operators/array_operator_definitions.rb", "lib/range_operators/range_operator_definitions.rb", "spec/array_operator_definitions_spec.rb", "spec/range_operators_spec.rb", "Manifest", "range_operators.gemspec"]
   s.homepage = %q{http://github.com/monocle/range_operators}
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Range_operators", "--main", "README.rdoc"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{range_operators}
   s.rubygems_version = %q{1.3.6}
   s.signing_key = %q{/ruby/keys/range_operators/gem-private_key.pem}
-  s.summary = %q{A gem that adds addition and subtraction to Ruby's Range class.}
+  s.summary = %q{A gem that adds range methods to Ruby's Range and Array classes. (Range#+, Range#-, Array#rangify, Array#intersection, Array#missing)}
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION

data/spec/array_operator_definitions_spec.rb

@@ -0,0 +1,63 @@
+require 'lib/range_operators'
+
+describe Array do
+	describe '#missing' do
+		it { [1,3..3].missing.should == [2] }
+		it { [1..5,10..12].missing.should == [6..9] }
+		it { [100, 9..11, 14, 1..5, 16, 10..12, 17..17].missing.should == [6..8, 13, 15, 18..99] }
+	end
+
+	describe '#intersection' do
+		it { [1, 2].intersection.should == nil }
+		it { [1..10, 11..20].intersection.should == nil }
+		it { [1..10, 5..15, 11..20].intersection.should == nil }
+		it { [8..8, 1..10, 10 ].intersection.should == nil }
+		it { [10, 1..10].intersection.should == 10 }
+		it { [1..10, 1].intersection.should == 1 }
+		it { [1, 1].intersection.should == 1 }
+		it { [1..10, 5, 5..8, 5..10 ].intersection.should == 5 }
+		it { [1..10, 5..8, 5..10 ].intersection.should == (5..8) }
+		it { [5..10, 1..10, 4..8 ].intersection.should == (5..8) }
+		it { [5..10, 1..10, 4..20, 8].intersection.should == 8 }
+
+	end
+	
+	describe '#rangify' do
+
+		it 'An array of consecutive integers should return an array made up of a single range.' do
+			[1,2,3,4,5].rangify.should == [1..5]
+		end
+		
+		it 'An array of non-consecutive integers should return the original array.' do
+			[1,3,5,7].rangify.should == [1,3,5,7]
+		end
+
+		describe 'An array of consecutive and non-consecutive integers' do
+			before :each do
+				@result = [1..3, 6..8, 10, 15] 
+			end
+
+			it 'should return the correct ranges.' do
+				[1,2,3,6,7,8,10,15].rangify.should == @result
+			end
+		
+			it 'Array element order should not affect the result.' do
+				[8, 1, 15, 2, 6, 3, 7, 10].rangify.should == @result
+			end
+			
+			it 'Duplicate elements should not affect the result.' do
+				[8, 1, 15, 2, 6, 3, 7, 10, 8, 15, 2, 3, 1, 2].rangify.should == @result
+			end
+		end
+			
+		it 'An array of ranges should return the correct ranges.' do
+			arr = [40..45, 1..3, 4..10, 20..30, 24..28, 42..50, 1..6, 1..3, 1..1]
+			arr.rangify.should == [1..10, 20..30, 40..50]
+		end
+		
+		it 'An array of ranges and integers should return the correct ranges.' do
+			arr = [99, 100, 1..3, 101, 4..5, 103, 10..19, 99, 20..20, 31, 32..33, 98, 97]
+			arr.rangify.should == [1..5, 10..20, 31..33, 97..101, 103]
+		end	
+	end
+end

data/spec/range_operators_spec.rb

@@ -1,180 +1,103 @@
 require 'lib/range_operators'
 
-describe RangeOperators do
+describe Range do
 	describe '#+' do
 		describe 'when given a range of integers' do
-			before :each do
-				@range = 1..10
-			end
-			
-			it '1..10 + 11  = [1..11]' do
-				(@range + 11).should == [1..11]
-			end
 			
-			it '1..10 + 12 = [1..10, 12]' do
-				(@range + 12).should == [1..10, 12]
-			end
-
-			it '1..10 + 10..12 = [1..12]' do
-				(@range + (10..12)).should == [1..12]
-			end
-
-			it '1..10 + 11..12 = [1..12]' do
-				(@range + (11..12)).should == [1..12]
-			end
-
-			it '1..10 + 9..12 = [1..12]' do
-				(@range + (9..12)).should == [1..12]
-			end
-
-			it '1..10 + 1..12 = [1..12]' do
-				(@range + (1..12)).should == [1..12]
-			end
+			it { lambda{ (1..10) + 'a' }.should raise_error }
 
-			it '1..10 + 12..20 = [1..10, 12..20]' do
-				(@range + (12..20)).should == [1..10, 12..20]
-			end
+			it { ((1..10) + (11..11)).should == [1..11] }
+			
+			it { ((1..10) + 12).should == [1..10, 12] }
 
-			it '1..10 + 0 = [0..10]' do
-				(@range + 0).should == [0..10]
-			end
+			it { ((1..10) + (10..12)).should == [1..12] }
 
-			it '1..10 + -1 = [-1, 1..10]' do
-				(@range + -1).should == [-1, 1..10]
-			end			
+			it { ((1..10) + (11..12)).should == [1..12] }
 
-			it '1..10 + (-10..-1) = [-10..-1, 1..10]' do
-				(@range + (-10..-1)).should == [-10..-1, 1..10]
-			end		
+			it { ((1..10) + (9..12)).should == [1..12] }
 
-			it '1..10 + (-10..0) = [-10..10]' do
-				(@range + (-10..0)).should == [-10..10]
-			end		
+			it { ((1..10) + (1..12)).should == [1..12] }
+			
+			it { ((1..10) + (12..20)).should == [1..10, 12..20] }
 
-			it '1..10 + (-10..1) = [-10..10]' do
-				(@range + (-10..1)).should == [-10..10]
-			end		
+			it { ((1..10) + 0).should == [0..10] }
 
-			it '1..10 + (-10..2) = [-10..10]' do
-				(@range + (-10..2)).should == [-10..10]
-			end		
+			it { ((1..10) + -1).should == [-1, 1..10] }
+			
+			it { ((1..10) + (-10..-1)).should == [-10..-1, 1..10] }
 
-			it '1..10 + (-10..20) = [-10..20]' do
-				(@range + (-10..20)).should == [-10..20]
-			end		
+			it { ((1..10) + (-10..0)).should == [-10..10] }
+			
+			it { ((1..10) + (-10..1)).should == [-10..10] }
+			
+			it { ((1..10) + (-10..2)).should == [-10..10] }
+			
+			it { ((1..10) + (-10..20)).should == [-10..20]}
 		end
 	end
 
 	describe '#-' do
 		describe 'when given a range of integers' do
-			before :each do
-				@range = 1..10 
-			end
-			
-			it 'should raise error if subtracting a non-integer' do
-				lambda{@range - 'a'}.should raise_error
-			end
-			
-			describe 'and subtracting an integer' do
-				it '(1..10) - 5 = [1..4, 6..10]' do
-					(@range - 5).should == [1..4, 6..10]
-				end
-
-				it '(1..10) - 2 = [1, 3..10]' do
-					(@range - 2).should == [1, 3..10]
-				end
-
-				it '(1..10)- 9 = [1..8, 10]' do
-					(@range - 9).should == [1..8, 10]
-				end
-
-				it '(1..10) - 10 = [1..9, nil]' do
-					(@range - 10).should == [1..9, nil]
-				end
-
-				it '(1..10) - 1 = [nil, 2..10]' do
-					(@range - 1).should == [nil, 2..10]
-				end
 
-				it '(1..10) - 11 = [1..10, nil]' do
-					(@range - 11).should == [1..10, nil]
-				end
-
-				it '(1..10) - 12 = [1..10, nil]' do
-					(@range - 12).should == [1..10, nil]
-				end
-
-				it '(1..10) - 0 = [nil, 1..10]' do
-					(@range - 0).should == [nil, 1..10]
-				end
+			it { lambda{ (1..10) - 'a' }.should raise_error }
+						
+			describe 'and subtracting an integer' do
 
-				it '(1..10) - -1 = [nil, 1..10]' do
-					(@range - -1).should == [nil, 1..10]
-				end
+				it { ((1..10) - (5..5)).should == [1..4, 6..10] }
+				
+				it { ((1..10) - 2).should == [1, 3..10] }
+				
+				it { ((1..10) - 9).should == [1..8, 10] }
+					
+				it { ((1..10) - 10).should == [1..9, nil] }
+					
+				it { ((1..10) - 1).should == [nil, 2..10] }
+					
+				it { ((1..10) - 11).should == [1..10, nil] }
+					
+				it { ((1..10) - 12).should == [1..10, nil] }
+					
+				it { ((1..10) - 0).should == [nil, 1..10] }
+					
+				it { ((1..10) - -1).should == [nil, 1..10] }
 			end
 		
 			describe 'and subtracting another range' do
 
-				it '1..10 - 4..6 = [1..3, 7..10]' do
-					(@range - (4..6)).should == [1..3, 7..10]
-				end
-
-				it '1..10 - 2..6 = [1, 7..10]' do
-					(@range - (2..6)).should == [1, 7..10]
-				end
-
-				it '1..10 - 4..9 = [1..3, 10]' do
-					(@range - (4..9)).should == [1..3, 10]
-				end
-
-				it '1..10 - 2..9 = [1, 10]' do
-					(@range - (2..9)).should == [1, 10]
-				end
-
-				it '1..10 - 2..11 = [1]' do
-					(@range - (2..11)).should == [1]
-				end
-
-				it '1..10 - 0..9 = [10]' do
-					(@range - (0..9)).should == [10]
-				end
-				
-				it '1..10 - 4..10 = [1..3]' do
-					(@range - (4..10)).should == [1..3]
-				end
-
-				it '1..10 - 4..12 = [1..3]' do
-					(@range - (4..12)).should == [1..3]
-				end
-
-				it '1..10 - 1..6 = [7..10]' do
-					(@range - (1..6)).should == [7..10]
-				end
-
-				it '1..10 - (-2..6) = [7..10]' do
-					(@range - (-2..6)).should == [7..10]
-				end
-
-				it '1..10 - 11..20 = [1..10]' do
-					(@range - (11..20)).should == [1..10]
-				end
-
-				it '1..10 - (-10..0) = [1..10]' do
-					(@range - (-10..0)).should == [1..10]
-				end
-
-				it '1..10 - (-10..20) = []' do
-					(@range - (-10..20)).should == []
-				end
+				it { ((1..10) - (4..6)).should == [1..3, 7..10] }
+					
+				it { ((1..10) - (2..6)).should == [1, 7..10] }
+					
+				it { ((1..10) - (4..9)).should == [1..3, 10] }
+					
+				it { ((1..10) - (2..9)).should == [1, 10] }
+					
+				it { ((1..10) - (2..11)).should == [1] }
+					
+				it { ((1..10) - (0..9)).should == [10] }
+									
+				it { ((1..10) - (4..10)).should == [1..3] }
+					
+				it { ((1..10) - (4..12)).should == [1..3] }
+					
+				it { ((1..10) - (1..6)).should == [7..10] }
+					
+				it { ((1..10) - (-2..6)).should == [7..10] }
+					
+				it { ((1..10) - (11..20)).should == [1..10] }
+					
+				it { ((1..10) - (-10..0)).should == [1..10] }
+					
+				it { ((1..10) - (-10..20)).should == [] }
 			end
 		end
 	end
 	
 	it '#minus is an alias of #-' do
-		RangeOperators.instance_method(:minus).should == RangeOperators.instance_method(:-)
+		Range.instance_method(:minus).should == Range.instance_method(:-)
 	end
 
 	it '#plus is an alias of #+' do
-		RangeOperators.instance_method(:plus).should == RangeOperators.instance_method(:+)
+		Range.instance_method(:plus).should == Range.instance_method(:+)
 	end
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 0
   - 1
-  version: 0.0.1
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - monocle
@@ -35,11 +35,11 @@ cert_chain:
   lTblHT4UBS6VZYs6PY8=
   -----END CERTIFICATE-----
 
-date: 2010-07-03 00:00:00 -07:00
+date: 2010-07-04 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
-description: A gem that adds addition and subtraction to Ruby's Range class.
+description: A gem that adds range methods to Ruby's Range and Array classes. (Range#+, Range#-, Array#rangify, Array#intersection, Array#missing)
 email: frappez_2000@yahoo.com
 executables: []
 
@@ -49,15 +49,18 @@ extra_rdoc_files:
 - LICENSE
 - README.rdoc
 - lib/range_operators.rb
-- lib/rangify.rb
+- lib/range_operators/array_operator_definitions.rb
+- lib/range_operators/range_operator_definitions.rb
 files: 
 - LICENSE
-- Manifest
 - README.rdoc
 - Rakefile
 - lib/range_operators.rb
-- lib/rangify.rb
+- lib/range_operators/array_operator_definitions.rb
+- lib/range_operators/range_operator_definitions.rb
+- spec/array_operator_definitions_spec.rb
 - spec/range_operators_spec.rb
+- Manifest
 - range_operators.gemspec
 has_rdoc: true
 homepage: http://github.com/monocle/range_operators
@@ -94,6 +97,6 @@ rubyforge_project: range_operators
 rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: A gem that adds addition and subtraction to Ruby's Range class.
+summary: A gem that adds range methods to Ruby's Range and Array classes. (Range#+, Range#-, Array#rangify, Array#intersection, Array#missing)
 test_files: []
 

data/lib/rangify.rb

@@ -1,52 +0,0 @@
-#= Rangify
-#
-#This gem will add the rangify method to Ruby's Array class.
-#The rangify method will produce appropriate ranges from the objects in the array.
-#
-#= Usage
-#
-#Examples:
-#
-#[1,2,3,6,7,8].rangify = [1..3, 6..8]
-#
-#[10..15, 16..20, 21, 22].rangify = [10..22]
-#
-#
-#Assumes inclusive ranges (ie. 1..4) and range.first <= range.last.
-#
-#Works with integers, dates and strings.  However, all the objects in the array must be of the same class.
-
-module Rangify
-	def rangify
-    array = self.uniq.sort_by { |element| comparison_value(element, :first) }
-    array.inject([]) do |collection, value|
-      unless collection.empty?
-        last = collection.last
-        last_value = comparison_value(last, :last)
-        current_value = comparison_value(value, :first)
-        if (last_value.succ <=> current_value) == -1
-          collection << value
-        else
-          first = [comparison_value(last, :first), comparison_value(value, :first)].min
-          second = [comparison_value(last, :last), comparison_value(value, :last)].max
-          collection[-1] = [first..second]
-          collection.flatten!
-        end
-      else
-        collection << value
-      end
-    end
-  end
-
-  private
-
-  # For a Range, will return value.first or value.last. A non-Range will return itself.  
-  def comparison_value(value, position)
-    return value if value.class != Range
-    position == :first ? value.first : value.last
-  end
-end
-
-class Array
-  include Rangify
-end