RubyRanges 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rvmrc

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in RubyRanges.gemspec
+gemspec

data/README.textile

@@ -0,0 +1,98 @@
+h1. RubyRanges
+
+RubyRanges is my attempt to move names of Rails gems back to sane naming
+conventions.  Just because you can name a gem something fun, doesn't mean I can
+find it. I could have named it LoneRanges, HomeOnTheRanges, or RangingOut, but I
+didn't.  I named it what it is: RubyRanges.
+
+:)
+
+h2. For the serious documentation:
+
+The real reason I created the ranges is to be able to treat ranges similar to
+arrays instead of using "to_a" -- which causes inefficiencies.  I think of
+adding Ranges as a consolidating overlay.  I think of subtracting arrays as
+a shark bite -- whatever that means to you.
+
+h3. Quick Examples
+
+Below are some examples of work, take a look at the tests for more:
+
+h4. Ultimately, I wanted to do something like this:
+
+<pre>
+  (4..88) - (33..45) + (115..122) + (85..110) => [4..33, 45..110, 115..122]
+</pre>
+
+h4. But wait, it works with dates too:
+
+<pre>
+  (Time.now..Time.now + 180) + (Time.now + 360..Time.now + 400) - (Time.now + 380..Time.now + 395) =>
+    [Sat Aug 07 00:45:09 -0500 2010..Sat Aug 07 00:48:09 -0500 2010, Sat Aug 07 00:51:09 -0500 2010..Sat Aug 07 00:51:49 -0500 2010]
+</pre>
+
+h4. And it works with letters: (which I really don't have a usage for)
+
+<pre>
+  ("A".."FB") + ("P".."DE") - ("BC".."MA") => "A".."BC"
+</pre>
+
+(Psst. . . it works with anything Ruby creates a range with)
+
+h3. Long Examples
+
+h4. Addition
+
+<pre>
+  (1..9) + (4..7)  => (1..9)
+  (4..7) + (1..9)  => (1..9)
+  (1..9) + (5..12) => (1..12)
+  (1..9) + (-5..5) => (-5..9)
+</pre>
+
+h4. Addition with non-continuous ranges
+
+<pre>
+  (1..4) + (8..9)  => RubyRanges::Array.new(1..4, 8..9)
+</pre>
+
+h4. Subtraction
+
+<pre>
+  (1..9) - (5..7)  => RubyRanges::Ranges.new(1..5, 7..9)
+
+  (1..9) - (6..12)  => 1..6
+  (1..9) - (-1..4)  => 4..9
+  (1..9) - (-1..10) => nil
+
+  (1..9) - (11..12) => 1..9
+</pre>
+
+h4. Now for RubyRanges::Array
+
+I created the RubyRanges::Array to give some special actions to +, -, and flatten_ranges
+for sets of Ranges.  Below are some usage examples.
+
+<pre>
+  RubyRanges::Array.new((1..4), (18..20)) + RubyRanges::Array.new((12..15), (6..9)) =>
+    RubyRanges::Array.new((1..4), (6..9), (12..15), (18..20))
+
+  RubyRanges::Array.new((1..10), (15..25)) + RubyRanges::Array.new((8..23), (25..28)) => 1..28
+
+  RubyRanges::Array.new(10..15, 20..25) + RubyRanges::Array.new(5..13, 18..22) =>
+    RubyRanges::Array.new(5..15, 18..25)
+
+  RubyRanges::Array.new(10..15, 20..25) + RubyRanges::Array.new(13..18, 23..28) =>
+    RubyRanges::Array.new(10..18, 20..28)
+  end
+
+  RubyRanges::Array.new(10..15, 20..25) + (28..30) =>
+    RubyRanges::Array.new(10..15, 20..25, 28..30)
+
+  RubyRanges::Array.new(10..15, 20..25) + (13..22) => 10..25
+
+  RubyRanges::Array.new(10..15, 20..25) + (18..22) => RubyRanges::Array.new(10..15, 18..25)
+</pre>
+
+Have fun, please donate if you fix / change.  Licenses are for the lawyers, if you're
+a lawyer, this is GPLv3.  If you're a coder, this is code.

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/RubyRanges.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ruby_ranges/version"
+
+Gem::Specification.new do |s|
+  s.name        = "RubyRanges"
+  s.version     = RubyRanges::VERSION
+  s.authors     = ["Chris Winslett"]
+  s.email       = ["christopherwinslett@gmail.com"]
+  s.homepage    = "https://github.com/Winslett/RubyRanges"
+  s.summary     = %q{Allows array type actions on ranges and arrays of ranges}
+  s.description = %q{See https://github.com/Winslett/RubyRanges}
+
+  s.rubyforge_project = "RubyRanges"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/ruby_ranges/array.rb

@@ -0,0 +1,81 @@
+class Array
+  alias :old_plus :+
+end
+
+module RubyRanges
+  class Array < Array
+
+    alias :old_plus :+
+
+    #
+    # Takes the same arguments as Array.new:
+    # 
+    #   RubyRanges::Array.new(35..38, 55..72)
+    #   RubyRanges::Array.new(Time.now..3.minutes.from_now, Time.now..3.minutes.ago)
+    #
+    # If you have a question whether it works. . . try it.  It might.
+    #
+    def initialize(*args)
+      args.each { |arg| self << arg }
+    end
+
+    #
+    # Takes either a Range or Array of Ranges
+    #
+    #   RubyRanges::Array.new(1..4, 8..11) + RubyRanges::Array.new(3..6, 7..9) =>
+    #     RubyRanges::Array.new(1..6, 7..9)
+    #
+    #   RubyRanges::Array.new(1..4, 8..11) + (3..9) => 1..9
+    #
+    # This method will "flatten" any RubyRanges::Array which compasses the smallest to the largest.  It
+    # will also compress an ranges which overlap.
+    #
+    def +(object)
+      raise "Expecting RubyRanges::Array or Range, but was #{object.class} : #{object.inspect}" unless object.is_a?(Range) || object.is_a?(Array)
+      array_of_ranges = Array.new((object.is_a?(Range) ? (self.old_plus([object])) : super(object)))
+      array_of_ranges.flatten_ranges
+    end
+
+    #
+    # Similar to +, takes either Range or Array of Ranges.
+    #
+    # This method splits apart ranges with an all encompassed subtrahend
+    #
+    def -(object)
+      raise "Expecting RubyRanges::Array or Range, but was #{object.class} : #{object.inspect}" unless object.is_a?(Range) || object.is_a?(Array)
+      if object.is_a?(Range)
+        array_of_ranges = inject([]) do |new, range|
+          new.old_plus([range - object])
+        end
+      else
+        other = self
+        object.each do |other_range|
+          other = Array.new(other - other_range).flatten
+        end
+        other
+      end
+    end
+
+    #
+    # Flattens a RubyRanges::Array with overlapping Ranges.
+    #
+    def flatten_ranges
+      new = []
+      
+      flatten.sort_by(&:begin).each do |range|
+        if new.last.nil?
+          new << range
+        else
+          last = new.pop + range
+
+          new = last.is_a?(Array) ?
+            new.old_plus(last) : (new << last)
+        end
+      end
+
+      array = Array.new(new).flatten
+      array.length == 1 ? array[0] : array
+    end
+
+  end
+end

data/lib/ruby_ranges/inclusive.rb

@@ -0,0 +1,9 @@
+module RubyRanges
+  
+  class WhollyIncluded; def self.to_value; true; end; end
+  class InverseWhollyIncluded; def self.to_value; nil; end; end
+  class UpwardIncluded;  def self.to_value; 1; end; end
+  class DownwardIncluded; def self.to_value; -1; end; end
+  class MutuallyExcluded; def self.to_value; false; end; end
+  
+end

data/lib/ruby_ranges/range.rb

@@ -0,0 +1,64 @@
+module RubyRanges
+  module Range
+
+    def self.included(base)
+      base.send(:define_method, :include?) do |object|
+        object.is_a?(Range) ? include_range?(object) : super(object)
+      end
+    end
+    
+    def +(range)
+      add_range(range)
+    end
+
+    def -(range)
+      subtract_range(range)
+    end
+
+    def include_range?(range)
+      case
+      when self.include?(range.begin) && self.include?(range.end) # wholly inclusive
+        RubyRanges::WhollyIncluded
+      when range.include?(self.begin) && range.include?(self.end) # inverse wholly inclusive
+        RubyRanges::InverseWhollyIncluded
+      when self.include?(range.begin) && self.end < range.end # upload inclusive
+        RubyRanges::UpwardIncluded
+      when self.include?(range.end) && self.begin > range.begin # downward inclusive
+        RubyRanges::DownwardIncluded
+      else # exclusive range
+        RubyRanges::MutuallyExcluded
+      end
+    end
+
+    private
+    def add_range(range)
+      case self.include?(range).to_value
+      when RubyRanges::WhollyIncluded.to_value # self swallows smaller range
+        self
+      when RubyRanges::InverseWhollyIncluded.to_value # self swallowed by larger range
+        range
+      when RubyRanges::UpwardIncluded.to_value # add upward inclusive range
+        self.begin..range.end
+      when RubyRanges::DownwardIncluded.to_value # add downward inclusive range
+        range.begin..self.end
+      else # mutually exclusive
+        Array.new(self, range)
+      end
+    end
+
+    def subtract_range(range)
+      case self.include?(range).to_value
+      when NilClass # self removed by larger range
+        nil
+      when TrueClass # self split by wholly inclusive range
+        Array.new(self.begin..range.begin, range.end..self.end)
+      when 1 # self shortened by upload inclusive range
+        self.begin..range.begin
+      when -1 # self shortened by downward inclusive range
+        range.end..self.end
+      else # mutually exclusive
+        self
+      end
+    end
+  end
+end

data/lib/ruby_ranges/version.rb

@@ -0,0 +1,3 @@
+module RubyRanges
+  VERSION = "0.0.1"
+end

data/lib/ruby_ranges.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/ruby_ranges/version.rb'
+require File.dirname(__FILE__) + '/ruby_ranges/inclusive.rb'
+require File.dirname(__FILE__) + '/ruby_ranges/range.rb'
+require File.dirname(__FILE__) + '/ruby_ranges/array.rb'
+
+class Range
+  include RubyRanges::Range
+end

data/test/ruby_ranges_array_test.rb

@@ -0,0 +1,86 @@
+require File.dirname(__FILE__) + '/../lib/ruby_ranges'
+require 'test/unit'
+
+class RubyRanges::ArrayTest < Test::Unit::TestCase
+
+  def test_adding_mutually_exclusive_ruby_ranges_arrays
+    output = RubyRanges::Array.new((1..4), (18..20)) + RubyRanges::Array.new((12..15), (6..9))
+    assert_equal RubyRanges::Array.new((1..4), (6..9), (12..15), (18..20)), output
+  end
+
+  def test_adding_spanning_ruby_ranges_arrays
+    output = RubyRanges::Array.new((1..10), (15..25)) + RubyRanges::Array.new((8..23), (25..28))
+    assert_equal 1..28, output
+  end
+
+  def test_adding_downward_inclusive_ruby_ranges_arrays
+    output = RubyRanges::Array.new(10..15, 20..25) + RubyRanges::Array.new(5..13, 18..22)
+    assert_equal RubyRanges::Array.new(5..15, 18..25), output
+  end
+
+  def test_adding_upward_inclusive_exclusive_ruby_ranges_arrays
+    output = RubyRanges::Array.new(10..15, 20..25) + RubyRanges::Array.new(13..18, 23..28)
+    assert_equal RubyRanges::Array.new(10..18, 20..28), output
+  end
+
+  def test_adding_mutually_exclusive_range_to_ruby_ranges_arrays
+    output = RubyRanges::Array.new(10..15, 20..25) + (28..30)
+    assert_equal RubyRanges::Array.new(10..15, 20..25, 28..30), output
+  end
+
+  def test_adding_spanning_range_to_ruby_ranges_arrays
+    output = RubyRanges::Array.new(10..15, 20..25) + (13..22)
+    assert_equal 10..25, output
+  end
+
+  def test_adding_downward_inclusive_range_to_ruby_ranges_arrays
+    output = RubyRanges::Array.new(10..15, 20..25) + (18..22)
+    assert_equal RubyRanges::Array.new(10..15, 18..25), output
+  end
+
+  def test_adding_upward_inclusive_range_to_ruby_ranges_arrays
+    output = RubyRanges::Array.new(10..15, 20..25) + (13..18)
+    assert_equal RubyRanges::Array.new(10..18, 20..25), output
+  end
+
+  def test_subtracting_mutually_exclusive_ruby_ranges_array
+    output = RubyRanges::Array.new(10..15, 20..25) - RubyRanges::Array.new(17..19, 27..30)
+    assert_equal RubyRanges::Array.new(10..15, 20..25), output
+  end
+
+  def test_subtracting_spanning_array_of_ranges
+    output = RubyRanges::Array.new(10..15, 20..25) - RubyRanges::Array.new(13..22, 24..30)
+    assert_equal RubyRanges::Array.new(10..13, 22..24), output
+  end
+
+  def test_subtracting_downward_inclusive_array_of_ranges
+    output = RubyRanges::Array.new(10..15, 20..25) - RubyRanges::Array.new(8..12, 18..22)
+    assert_equal RubyRanges::Array.new(12..15, 22..25), output
+  end
+
+  def test_subtracting_upward_inclusive_array_of_ranges
+    output = RubyRanges::Array.new(10..15, 20..25) - RubyRanges::Array.new(13..18, 24..30)
+    assert_equal RubyRanges::Array.new(10..13, 20..24), output
+  end
+
+  def test_subtracting_mutually_inclusive_range_from_array_of_ranges
+    output = RubyRanges::Array.new(10..15, 20..25) - (17..19)
+    assert_equal RubyRanges::Array.new(10..15, 20..25), output
+  end
+
+  def test_subtracting_spanning_range_from_array_of_ranges
+    output = RubyRanges::Array.new(10..15, 20..25) - (13..22)
+    assert_equal RubyRanges::Array.new(10..13, 22..25), output
+  end
+
+  def test_subtracting_downward_inclusive_range_from_array_of_ranges
+    output = RubyRanges::Array.new(10..15, 20..25) - (18..22)
+    assert_equal RubyRanges::Array.new(10..15, 22..25), output
+  end
+
+  def test_subtracting_upward_inclusive_range_from_array_of_ranges
+    output = RubyRanges::Array.new(10..15, 20..25) - (13..18)
+    assert_equal RubyRanges::Array.new(10..13, 20..25), output
+  end
+  
+end

data/test/ruby_ranges_test.rb

@@ -0,0 +1,99 @@
+require File.dirname(__FILE__) + '/../lib/ruby_ranges'
+require 'test/unit'
+
+class RubyRanges::RangeTest < Test::Unit::TestCase
+
+  include RubyRanges
+
+  def test_include_partial_downward_range
+    assert_equal -1, (1..9).include?(-1..3).to_value
+    assert_equal RubyRanges::DownwardIncluded, (1..9).include?(-1..3)
+  end
+
+  def test_include_partial_upward_range
+    assert_equal 1, (1..9).include?(7..11).to_value
+    assert_equal RubyRanges::UpwardIncluded, (1..9).include?(7..11)
+  end
+
+  def test_include_wholly_inclusive_range
+    assert_equal true, (1..9).include?(4..7).to_value
+    assert_equal RubyRanges::WhollyIncluded, (1..9).include?(4..7)
+  end
+
+  def test_include_inverse_wholly_inclusive_range
+    assert_equal nil, (4..7).include?(1..9).to_value
+    assert_equal RubyRanges::InverseWhollyIncluded, (4..7).include?(1..9)
+  end
+
+  def test_include_exclusive_range
+    assert_equal false, (1..9).include?(10..12).to_value
+  end
+
+  def test_adding_smaller_range
+    output = (1..9) + (4..7)
+    assert_equal (1..9), output
+  end
+
+  def test_adding_larger_range
+    output = (4..7) + (1..9)
+    assert_equal (1..9), output
+  end
+
+  def test_adding_an_upward_inclusive_range
+    assert_equal (1..12), (1..9) + (5..12)
+  end
+
+  def test_adding_a_downward_inclusive_range
+    assert_equal (-5..9), (1..9) + (-5..5)
+  end
+
+  def test_adding_exclusive_ranges
+    output = (1..4) + (8..9)
+    assert_equal RubyRanges::Array.new((1..4), (8..9)), output
+  end
+
+  def test_adding_ruby_ranges_array
+    pending
+  end
+
+  def test_subtracting_wholly_included_range
+    output = (1..9) - (5..7)
+    assert_equal RubyRanges::Array.new(1..5, 7..9), output
+  end
+
+  def test_subtracting_upward_inclusive_range
+    output = (1..9) - (6..12)
+    assert_equal 1..6, output
+  end
+
+  def test_subtracting_downward_inclusive_range
+    output = (1..9) - (-1..4)
+    assert_equal 4..9, output
+  end
+
+  def test_subtracting_surrounding_range
+    assert_equal nil, (1..9) - (-1..10)
+  end
+
+  def test_subtracting_exclusive_range
+    output = (1..9) - (11..12)
+    assert_equal 1..9, output
+  end
+
+  def test_subtracting_wholly_inclusive_ruby_ranges_array
+    pending
+  end
+
+  def test_subtracting_mutually_exclusive_ruby_ranges_array
+    pending
+  end
+
+  def test_subtracting_downward_exclusive_ruby_ranges_array
+    pending
+  end
+
+  def test_subtracting_upward_exclusive_ruby_ranges_array
+    pending
+  end
+  
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: RubyRanges
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Chris Winslett
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-25 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: See https://github.com/Winslett/RubyRanges
+email: 
+- christopherwinslett@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.textile
+- Rakefile
+- RubyRanges.gemspec
+- lib/ruby_ranges.rb
+- lib/ruby_ranges/array.rb
+- lib/ruby_ranges/inclusive.rb
+- lib/ruby_ranges/range.rb
+- lib/ruby_ranges/version.rb
+- test/ruby_ranges_array_test.rb
+- test/ruby_ranges_test.rb
+has_rdoc: true
+homepage: https://github.com/Winslett/RubyRanges
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: RubyRanges
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: Allows array type actions on ranges and arrays of ranges
+test_files: 
+- test/ruby_ranges_array_test.rb
+- test/ruby_ranges_test.rb