range_set 0.0.1

data/.gitignore

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

data/.rvmrc

@@ -0,0 +1,2 @@
+rvm use ruby-1.8.7@range_set
+#rvm use ruby-1.9.2@range_set

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,14 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'bundler' do
+  watch('Gemfile')
+  watch(/^.+\.gemspec/)
+end
+
+guard 'rspec', :cli => '-c --format documentation -r ./spec/spec_helper.rb --debug',
+               :version => 2 do
+  watch(%r{^spec/.+_spec\.rb})
+  watch(%r{^lib/(.+)\.rb})        { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')    { "spec" }
+end

data/Rakefile

@@ -0,0 +1,24 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = [
+    '-c',
+    '--format documentation',
+    '-r ./spec/spec_helper.rb'
+  ]
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+desc "open coverage report"
+task :coverage do
+  system 'rake spec'
+  system 'open coverage/index.html'
+end
+
+desc "Open development console"
+task :console do
+  puts "Loading development console..."
+  system "irb -I #{File.join('.', 'lib')} -r #{File.join('.', 'lib', 'range_set')}"
+end

data/lib/range_set/version.rb

@@ -0,0 +1,3 @@
+class RangeSet
+  VERSION = "0.0.1"
+end

data/lib/range_set.rb

@@ -0,0 +1,173 @@
+class RangeSet
+  attr_accessor :ranges
+
+  def initialize(*ranges)
+    @ranges = []
+    ranges.each do |r|
+      union_with_range!(r)
+    end
+    self
+  end
+  
+  def intersect!(r)
+    if r.is_a?(Range)
+      intersect_with_range!(r)
+    elsif r.is_a?(RangeSet)
+      @ranges = r.ranges.inject(RangeSet.new) do |accum, range|
+        accum + (self & range)
+      end.ranges
+    end
+    self
+  end
+  
+  def intersect(r)
+    self.clone.intersect!(r)
+  end
+  
+  def subtract!(r)
+    if r.is_a?(Range)
+      subtract_range!(r)
+    elsif r.is_a?(RangeSet)
+      r.each {|r| subtract_range!(r)}
+    end
+    self
+  end
+  
+  def subtract(r)
+    self.clone.subtract!(r)
+  end
+  
+  def union!(r)
+    if r.is_a?(Range)
+      union_with_range!(r)
+    elsif r.is_a?(RangeSet)
+      r.each {|r| union_with_range!(r)}
+    end
+    self
+  end
+  
+  def union(r)
+    self.clone.union!(r)
+  end
+  
+  def each
+    @ranges.each {|r| yield r}
+  end
+  
+  #returns an array of RangeSets
+  def split_at(*boundaries)
+    result = []
+    rs = RangeSet.new
+    ranges = @ranges.clone
+    boundaries.compact.sort.uniq.each do |boundary|
+      
+      while (range = ranges.shift)
+        if range.end <= boundary
+          rs += range
+        elsif range.begin >= boundary
+          ranges.unshift(range)
+          break
+        else
+          rs += (range.begin .. boundary)
+          ranges.unshift(boundary .. range.end)
+          break
+        end
+      end
+      
+      unless rs.empty?
+        result << rs
+        rs = RangeSet.new
+      end
+    end
+    result << RangeSet.new(*ranges) unless ranges.empty?
+    result
+  end
+  
+  # TODO : need to be more explicit and careful about
+  # whether or not a range's end is inclusive. For now,
+  # we just assume that it's NOT inclusive.
+  def include?(v)
+    if v.is_a?(Range)
+      each do |range|
+        return true if range.begin <= v.begin && v.begin <= v.end && v.end <= range.end
+      end
+    elsif v.is_a?(RangeSet)
+      v.ranges.each do |range|
+        return false unless self.include?(range)
+      end
+      return true
+    else
+      each do |range|
+        return true if range.begin <= v && v < range.end
+      end
+    end
+    false
+  end
+  
+  def empty?
+    @ranges.empty?
+  end
+  
+  alias :- :subtract
+  alias :| :union
+  alias :+ :union
+  alias :& :intersect
+  
+  private
+  
+  def subtract_range!(r)
+    return if r.begin == r.end
+    r = (r.end .. r.begin) unless r.begin < r.end
+    result = []
+    each do |range|
+      if range.end < r.begin
+        result << range
+      elsif range.begin > r.end
+        result << range
+      else
+        result << (range.begin .. r.begin) if range.begin < r.begin
+        result << (r.end .. range.end) if range.end > r.end
+      end
+    end
+    @ranges = result
+  end
+  
+  def intersect_with_range!(r)
+    if r.begin == r.end
+      @ranges = []
+      return
+    elsif r.begin > r.end
+      r = (r.end .. r.begin)
+    end
+    result = []
+    each do |range|
+      r2 = ([range.begin, r.begin].max .. [range.end, r.end].min)
+      if (r2.begin < r2.end)
+        result << r2
+      end
+    end
+    @ranges = result    
+  end
+  
+  def union_with_range!(r)
+    return if r.begin == r.end
+    joined = (r.begin < r.end) ? r : (r.end .. r.begin)
+    still_need_joined = true
+    result = []
+    each do |range|
+      if range.end < joined.begin
+        result << range
+      elsif range.end == joined.begin
+        joined = (range.begin .. joined.end)
+      elsif range.begin > joined.end
+        result << joined if still_need_joined
+        still_need_joined = false
+        result << range
+      else
+        joined = ([range.begin,joined.begin].min .. [range.end,joined.end].max)
+      end
+    end
+    result << joined if still_need_joined
+    @ranges = result
+  end
+end

data/range_set.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "range_set/version"
+
+Gem::Specification.new do |s|
+  s.name        = "range_set"
+  s.version     = RangeSet::VERSION
+  s.authors     = ["Chris Johnson"]
+  s.email       = ["chris@kindkid.com"]
+  s.homepage    = "https://github.com/kindkid/range_set"
+  s.summary     = "Set implementation based on ranges"
+  s.description = s.summary
+
+  s.rubyforge_project = "range_set"
+
+  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"]
+  s.add_development_dependency "rspec", "~> 2.6"
+  s.add_development_dependency "simplecov", "~> 0.4"
+  s.add_development_dependency("rb-fsevent", "~> 0.4") if RUBY_PLATFORM =~ /darwin/i
+  s.add_development_dependency "guard", "~> 0.5"
+  s.add_development_dependency "guard-bundler", "~> 0.1"
+  s.add_development_dependency "guard-rspec", "~> 0.4"
+end

data/spec/lib/range_set_spec.rb

@@ -0,0 +1,197 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe RangeSet do
+  before(:each) do
+    @rs = RangeSet.new(0..10)
+  end
+
+  it "can be initialized with a range" do
+    @rs.ranges.should == [(0..10)]
+  end
+
+  it "can be initialized with a backwards range" do
+    @rs = RangeSet.new(10..0)
+    @rs.ranges.should == [(0..10)]
+  end
+  
+  it "can be initialized with multiple ranges" do
+    @rs = RangeSet.new(1..2, 99..100)
+    @rs.ranges.should == [(1..2),(99..100)]
+  end
+
+  describe ".union" do
+    it "handles a contiguous range" do
+      @rs += 10..20
+      @rs.ranges.should == [(0..20)]
+    end
+
+    it "handles an overlapping range" do
+      @rs += 5..15
+      @rs.ranges.should == [(0..15)]
+    end
+
+    it "handles a non-contiguous range in back" do
+      @rs += 20..30
+      @rs.ranges.should == [(0..10), (20..30)]
+    end
+
+    it "handles a non-contiguous range in front" do
+      @rs += -10..-5
+      @rs.ranges.should == [(-10..-5), (0..10)]
+    end
+
+    it "handles this funky case" do
+      @rs = RangeSet.new(7..8, 9..10)
+      @rs += 5..6
+      @rs.ranges.should == [(5..6), (7..8), (9..10)]
+    end
+
+    it "merges internal ranges as needed" do
+      @rs = RangeSet.new(0..10, 20..30)
+      @rs += 10..20
+      @rs.ranges.should == [(0..30)]
+    end
+
+    it "handles reversed ranges" do
+      @rs += 20..10
+      @rs.ranges.should == [(0..20)]
+    end
+
+    it "handles a RangeSet" do
+      @rs += RangeSet.new(5..15, 25..30)
+      @rs.ranges.should == [(0..15), (25..30)]
+    end
+  end
+
+  describe ".subtract" do
+    it "can shorten a range" do
+      @rs -= 0..5
+      @rs.ranges.should == [(5..10)]
+    end
+
+    it "can remove a range and shorten others at the same time" do
+      @rs = RangeSet.new(0..10, 20..30, 40..50)
+      @rs -= 5..45
+      @rs.ranges.should == [(0..5),(45..50)]
+    end
+
+    it "handles a contained range" do
+      @rs -= 3..8
+      @rs.ranges.should == [(0..3),(8..10)]
+    end
+
+    it "handles a containing range" do
+      @rs -= -1..10
+      @rs.ranges.should == []
+    end
+
+    it "handles an empty range" do
+      @rs -= 5..5
+      @rs.ranges.should == [(0..10)]
+    end
+
+    it "handles a missing range" do
+      @rs = RangeSet.new(0..10, 20..30)
+      @rs -= 12..18
+      @rs.ranges.should == [(0..10),(20..30)]
+    end
+
+    it "handles a border-case missing range" do
+      @rs = RangeSet.new(0..10, 20..30)
+      @rs -= 10..20
+      @rs.ranges.should == [(0..10),(20..30)]
+    end
+
+    it "handles a RangeSet" do
+      @rs = RangeSet.new(0..10, 20..30)
+      @rs -= RangeSet.new(0..5, 8..21)
+      @rs.ranges.should == [(5..8), (21..30)]
+    end
+  end
+
+  describe ".intersect" do
+    it "handles overlapping ranges" do
+      @rs &= 5..15
+      @rs.ranges.should == [(5..10)]
+    end
+
+    it "handles multiple overlaps" do
+      @rs = RangeSet.new(0..10, 20..30, 40..50)
+      @rs &= 5..45
+      @rs.ranges.should == [(5..10), (20..30), (40..45)]
+    end
+
+    it "handles contained ranges" do
+      @rs &= 3..8
+      @rs.ranges.should == [(3..8)]
+    end
+
+    it "handles containing ranges" do
+      @rs &= -1..11
+      @rs.ranges.should == [(0..10)]
+    end
+
+    it "handles empty ranges" do
+      @rs &= 20..20
+      @rs.ranges.should == []
+    end
+
+    it "handles reversed ranges" do
+      @rs &= 15..5
+      @rs.ranges.should == [(5..10)]
+    end
+
+    it "handles a RangeSet" do
+      @rs = RangeSet.new(0..10, 20..30, 40..50)
+      @rs &= RangeSet.new(5..25, 35..55)
+      @rs.ranges.should == [(5..10), (20..25), (40..50)]
+    end
+  end
+
+  describe ".empty?" do
+    it "returns true for an empty range" do
+      RangeSet.new(1..1).empty?.should be_true
+    end
+
+    it "returns false for a non-empty range" do
+      RangeSet.new(1..2).empty?.should_not be_true
+    end
+
+    it "returns false for multiple ranges" do
+      RangeSet.new(-2..-1, 1..2).empty?.should_not be_true
+    end
+  end
+
+  describe ".include?" do
+    it "handles ranges" do
+      rs = RangeSet.new(1..3,4..6,7..9)
+      rs.include?(1..3).should == true
+      rs.include?(1..2).should == true
+      rs.include?(2..2).should == true
+      rs.include?(3..4).should == false
+      rs.include?(1..4).should == false
+      rs.include?(10..11).should == false
+    end
+
+    it "handles RangeSets" do
+      rs = RangeSet.new(1..3,4..6,7..9)
+      rs.include?(RangeSet.new(1..3)).should == true
+      rs.include?(rs).should == true
+      rs.include?(RangeSet.new(1..1)).should == true
+      rs.include?(RangeSet.new(1..3,4..6)).should == true
+      rs.include?(RangeSet.new(1..3,4..6,10..12)).should == false
+      rs.include?(RangeSet.new(1..2,5..6)).should == true
+    end
+
+    it "handles scalars" do
+      rs = RangeSet.new(1..3,4..6,7..9)
+      rs.include?(0).should be_false
+      rs.include?(1).should be_true
+      rs.include?(2).should be_true
+      rs.include?(3).should be_false
+      rs.include?(4).should be_true
+      rs.include?(9).should be_false
+      rs.include?(10).should be_false
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'rubygems'
+require 'bundler'
+
+Bundler.require(:default, :test, :development)

metadata

@@ -0,0 +1,167 @@
+--- !ruby/object:Gem::Specification 
+name: range_set
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Chris Johnson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-02 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 6
+        version: "2.6"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: simplecov
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        - 4
+        version: "0.4"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rb-fsevent
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        - 4
+        version: "0.4"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: guard
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 0
+        - 5
+        version: "0.5"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: guard-bundler
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 0
+        - 1
+        version: "0.1"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: guard-rspec
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        - 4
+        version: "0.4"
+  type: :development
+  version_requirements: *id006
+description: Set implementation based on ranges
+email: 
+- chris@kindkid.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- Guardfile
+- Rakefile
+- lib/range_set.rb
+- lib/range_set/version.rb
+- range_set.gemspec
+- spec/lib/range_set_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/kindkid/range_set
+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: range_set
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Set implementation based on ranges
+test_files: 
+- spec/lib/range_set_spec.rb
+- spec/spec_helper.rb