rangeset 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Darrick Wiebe
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,16 @@
+RangeSet
+========
+
+Do simple set operations on Ruby Ranges and RangeSets
+
+RangeSet objects act like Ranges except that they may have any number of
+gaps.
+
+Limitations
+-----------
+
+This library is tested against integer ranges for my use case, but any
+Comparable type should work, possible with a little bit of effort.
+
+I have not implemented more of the Range interface in RangeSet than I
+needed. If you need additional functionality, pull requests are welcome.

data/Rakefile

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

data/lib/rangeset/range.rb

@@ -0,0 +1,86 @@
+
+# left         [1..10,            20..30,            40..50]
+# right        [                       25..45,                49..55]
+#
+# left         ..........---------..........---------..........
+# right        ------------------------....................---......
+# in left only ..........         .....                    ...
+# in both                              .....         ......
+# in right only                             .........          .....
+#              [[1..10, 20..24, 46..50],
+#               [25..30, 40..45],
+#               [31..39, 51..55]]
+
+class Range
+  class << self
+    # [only in left, in both, only in right]
+    def diff(left, right)
+      if left.is_a? RangeSet or right.is_a? RangeSet
+        return RangeSet.diff left, right
+      end
+      a = left.first - right.first
+      if left.first == right.first
+        if left.last == right.last
+          # 1..3, 1..3 -> [nil, 1..3, nil]
+          [nil, left, nil]
+        elsif left.last > right.last
+          # 1..4, 1..2 -> [3..4, 1..2, nil]
+          [right.last.next..left.last, right, nil]
+        else
+          # 1..2, 1..4 -> [nil, 1..2, 3..4]
+          [nil, left, left.last.next..right.last]
+        end
+      elsif left.first < right.first
+        if left.last == right.last
+          # 1..4, 3..4 -> [1..2, 3..4, nil]
+          [left.first..(right.first - 1), right.first..right.last, nil]
+        elsif left.last > right.last
+          # 1..6, 3..4 -> [[1..2, 5..6], 3..4, nil]
+          [RangeSet.new(left.first..(right.first - 1), (right.last.next..left.last)), right, nil]
+        elsif left.last < right.last
+          if left.last < right.first
+            # 1..3, 5..6 -> [1..3, nil, 5..6]
+            [left, nil, right]
+          elsif left.last >= right.first
+            # 1..4, 3..6 -> [1..2, 3..4, 5..6]
+            [left.first..(right.first - 1), right.first..left.last, left.last.next..right.last]
+          end
+        end
+      else
+        diff(right, left).reverse
+      end
+    end
+  end
+
+  def diff(other)
+    Range.diff self, other
+  end
+
+  def difference(other)
+    diff(other)[0]
+  end
+
+  def intersection(other)
+    diff(other)[1]
+  end
+
+  def union(other)
+    RangeSet.build [self, other]
+  end
+
+  def ranges
+    [self]
+  end
+
+  unless instance_methods.include? :equal_without_rangeset
+    alias :equal_without_rangeset :==
+  end
+
+  def ==(other)
+    if other.is_a? RangeSet
+      other == self
+    else
+      equal_without_rangeset other
+    end
+  end
+end

data/lib/rangeset/version.rb

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

data/lib/rangeset.rb

@@ -0,0 +1,179 @@
+p version: require("rangeset/version")
+p range: require("rangeset/range")
+
+class RangeSet
+  class << self
+    def build(ranges)
+      if ranges
+        if ranges.is_a? Array
+          ranges = ranges.compact
+          if ranges.length == 1 and ranges.first.is_a? Range
+            ranges.first
+          elsif ranges.count == 0
+            nil
+          else
+            RangeSet.new *ranges
+          end
+        elsif ranges.is_a? Range or ranges.is_a? RangeSet
+          ranges
+        elsif ranges.is_a? Fixnum
+          ranges..ranges
+        end
+      end
+    end
+
+    def union(left, right)
+      if left.is_a? Array
+        raise 'wtf'
+      end
+      if not left
+        right
+      elsif not right
+        left
+      elsif left.is_a? Range and right.is_a? Range
+        left.union right
+      else
+        RangeSet.new right, left
+      end
+    end
+
+    def intersection(left, right)
+      if not left or not right
+        nil
+      elsif left.is_a? Range and right.is_a? Range
+        left.intersection right
+      else
+        left.ranges.reduce(nil) do |result, left|
+          intersections = right.ranges.map do |right|
+            left.intersection right
+          end
+          union(result, RangeSet.build(intersections))
+        end
+      end
+    end
+
+    def difference(left, right)
+      if not right
+        left
+      elsif left
+        left.ranges.reduce(nil) do |result, l|
+          in_left = right.ranges.map do |r|
+            l.difference(r)
+          end
+          in_left = in_left.reduce { |int, il|
+            intersection int, il
+          }
+          union result, in_left
+        end
+      end
+    end
+
+    def diff(left, right, intersect_only = false)
+      return [left, nil, nil] unless right
+      return [nil, nil, right] unless left
+      int = intersection(left, right)
+      in_left = left.difference int
+      in_right = right.difference int
+      [in_left, int, in_right]
+    end
+  end
+
+  include Enumerable
+
+  attr_reader :ranges
+
+  def initialize(*ranges)
+    if ranges.length > 1
+      @ranges = combine ranges
+    else
+      if ranges.first.is_a? RangeSet
+        @ranges = ranges.first.ranges
+      else
+        @ranges = ranges
+      end
+    end
+  end
+
+  def combine(ranges)
+    ranges = ranges.compact.flat_map do |r|
+      if r.is_a? RangeSet
+        r.ranges
+      elsif r.is_a? Range
+        [r]
+      elsif r.is_a? Fixnum
+        [r..r]
+      else
+        []
+      end
+    end
+    ranges = ranges.compact.sort_by(&:first)
+    result = [ranges.first]
+    ranges[1..-1].each do |r|
+      l = result.last
+      if l.last >= r.first
+        if l.last >= r.last
+          next
+        else
+          result.pop
+          r = l.first..r.last
+        end
+      elsif l.last + 1 == r.first
+        result.pop
+        r = l.first..r.last
+      end
+      result.push r
+    end
+    result
+  end
+
+  def gaps
+    RangeSet.build ranges.each_cons(2).map { |a, b| (a.last + 1)..(b.first - 1) }
+  end
+
+  def each(&block)
+    if block
+      ranges.each do |range|
+        range.each &block
+      end
+    else
+      to_enum :each
+    end
+  end
+
+  def first
+    ranges.first.first
+  end
+
+  def last
+    ranges.last.last
+  end
+
+  def include?(n)
+    ranges.any? { |r| r.include? n }
+  end
+
+  def diff(other)
+    RangeSet.diff self, other
+  end
+
+  def union(other)
+    RangeSet.union self, other
+  end
+
+  def intersection(other)
+    RangeSet.intersection self, other
+  end
+
+  def difference(other)
+    RangeSet.difference self, other
+  end
+
+  def ==(other)
+    !!(
+      if other.is_a? RangeSet
+        ranges == other.ranges
+      elsif other.is_a? Range and ranges.count == 1
+        ranges == [other]
+      end)
+  end
+end

data/rangeset.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rangeset/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "rangeset"
+  gem.version       = RangeSet::VERSION
+  gem.authors       = ["Darrick Wiebe"]
+  gem.email         = ["dw@xnlogic.com"]
+  gem.description   = %q{Set operations on ranges and range sets}
+  gem.summary       = %q{Set operations on ranges and range sets}
+  gem.homepage      = ""
+
+  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.require_paths = ["lib"]
+end

data/spec/rangeset/range_set_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe RangeSet do
+  subject { RangeSet.new 10..20, 30..40 }
+
+  it 'should equal itself' do
+    (subject == subject).should be_true
+  end
+
+  it 'should equal same' do
+    (subject == RangeSet.new(10..20, 30..40)).should be_true
+  end
+
+  it 'should not equal different' do
+    (subject == RangeSet.new(10..21, 30..40)).should be_false
+  end
+
+  it 'should equal equivalent range' do
+    (RangeSet.new(10..20) == (10..20)).should be_true
+  end
+
+  context 'same' do
+    let(:other) { RangeSet.new 10..20, 30..40 }
+    it "should be all same" do
+      subject.diff(other).should == [nil, subject, nil]
+      subject.diff(other).should == [nil, other, nil]
+    end
+  end
+
+  context 'subset' do
+    let(:other) { RangeSet.new 30..40 }
+    it do
+      subject.diff(other).should == [10..20, 30..40, nil]
+    end
+  end
+
+  context 'no overlap' do
+    let(:other) { RangeSet.new 130..140 }
+    it do
+      subject.diff(other).should == [subject, nil, 130..140]
+    end
+  end
+
+  context 'partial overlap' do
+    let(:other) { RangeSet.new 35..140 }
+    it do
+      subject.diff(other).should == [RangeSet.new(10..20, 30..34), 35..40, 41..140]
+    end
+  end
+
+  context 'engulfs' do
+    let(:other) { RangeSet.new 11..19 }
+    it do
+      subject.diff(other).should == [RangeSet.new(10..10, 20..20, 30..40), other, nil]
+    end
+  end
+
+  context 'engulfs2' do
+    let(:other) { RangeSet.new 11..19, 35..36 }
+    it do
+      subject.diff(other).should == [RangeSet.new(10..10, 20..20, 30..34, 37..40), other, nil]
+    end
+  end
+
+  context 'engulfed by' do
+    let(:other) { RangeSet.new 1..50 }
+    it do
+      subject.diff(other).should == [nil, subject, RangeSet.new(1..9, 21..29, 41..50)]
+    end
+  end
+end
+

data/spec/rangeset/range_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Range do
+  subject { 10..20 }
+
+  it 'should equal itself' do
+    (subject == subject).should be_true
+  end
+
+  it 'should equal same' do
+    (subject == (10..20)).should be_true
+  end
+
+  it 'should not equal different' do
+    (subject == (10..21)).should be_false
+  end
+
+  it 'should equal equivalent RangeSet' do
+    ((10..20) == RangeSet.new(10..20)).should be_true
+  end
+
+  describe '#diff' do
+    subject { 30..40 }
+
+    context 'partial overlap' do
+      let(:other) { 35..140 }
+      it do
+        subject.diff(other).should == [30..34, 35..40, 41..140]
+      end
+    end
+
+    context 'with a RangeSet' do
+      let(:other) { RangeSet.new(1..10, 30..35) }
+      it do
+        subject.diff(other).should == [36..40, 30..35, 1..10]
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  require 'lib/rangeset'
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: rangeset
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: 0.1.0
+platform: ruby
+authors:
+- Darrick Wiebe
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-02-19 00:00:00.000000000 Z
+dependencies: []
+description: Set operations on ranges and range sets
+email:
+- dw@xnlogic.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rangeset.rb
+- lib/rangeset/range.rb
+- lib/rangeset/version.rb
+- rangeset.gemspec
+- spec/rangeset/range_set_spec.rb
+- spec/rangeset/range_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+  none: false
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.24
+signing_key:
+specification_version: 3
+summary: Set operations on ranges and range sets
+test_files:
+- spec/rangeset/range_set_spec.rb
+- spec/rangeset/range_spec.rb
+- spec/spec_helper.rb
+has_rdoc: