better_ranges 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c468002e6d99d8b363b9d9d8633e06b38ff87b3a
+  data.tar.gz: e3f6c169d6cc951555576ec423f068a2d2dc3fab
+SHA512:
+  metadata.gz: bcf7070b2a67d0aafc67552b9f794a15ffc853aee82905d1406cf8bdfeb1655f857cbe992b1f31143fab4ad04b13699f3e7dc9cfa52240362f6a68cafcc95307
+  data.tar.gz: 2a248c8da4946747fcbb047006f921736862177e4603992d42a4fd13b3ee9c85096f920e3643457a1ce048d9d503deae26000e586a5a16e50c51afe3ba249d22

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+*.so
+.bundle
+.config
+.yardoc
+.ruby-version
+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 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - ruby-head
+  - jruby-18mode
+  - jruby-19mode
+  - jruby-head

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 TODO: Write your name
+
+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,35 @@
+# BetterRanges
+
+Adds support for basic set operations to the ruby Range class through the addition of a new SparseRange class.
+A SparseRange supports all the same methods as a Range plus a few more, most importantly minus (-), intersect (&), and union (|).
+
+The purpose of this library is efficiency and convenience. The usual way to achieve these functions is by either first converting the ranges to arrays, which can be slow, or by manually comparing their bounds, which is tedious, especially for more than 2 ranges.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'better_ranges'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install better_ranges
+
+## Usage
+
+Just `require 'better_ranges'` and you're good to go.
+
+## Examples
+
+```
+(1..20) - (8..12) - 5 => SparseRange(1...5, 6..7, 13..20)
+
+(1..20) & (15..25)    => SparseRange(15..20)
+
+(1..10) | (5..15)     => SparseRange(1..15)
+
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/better_ranges.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'better_ranges/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'better_ranges'
+  spec.version       = BetterRanges::VERSION
+  spec.authors       = ['Michael Ziminsky']
+  spec.email         = ['mgziminsky@gmail.com']
+  spec.summary       = 'Add support for set operations to the ruby Range class'
+  spec.homepage      = 'https://github.com/mgziminsky/better_ranges'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 1.8.6'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+end

data/lib/better_ranges.rb

@@ -0,0 +1,2 @@
+require 'better_ranges/version'
+require 'better_ranges/range_operators'

data/lib/better_ranges/range_operators.rb

@@ -0,0 +1,23 @@
+require 'better_ranges/sparse_range'
+
+module BetterRanges
+  module RangeOperators
+    def |(x)
+      SparseRange.new(self, *x)
+    end
+
+    def -(x)
+      SparseRange.new(self) - x
+    end
+
+    def &(x)
+      SparseRange.new(self) & x
+    end
+
+    alias :+ :|
+  end
+end
+
+class Range
+  include BetterRanges::RangeOperators
+end

data/lib/better_ranges/sparse_range.rb

@@ -0,0 +1,240 @@
+module BetterRanges
+  class SparseRange
+    include Enumerable
+
+    def initialize(*data)
+      @ranges = [*data].map! do |x|
+        if (x.is_a?(Enumerable))
+          if (x.none?)
+            return nil
+          elsif (x.is_a?(SparseRange))
+            return x.ranges.clone
+          end
+        end
+        x
+      end
+      optimize
+    end
+
+    def each(&block)
+      Enumerator.new do |yielder|
+        @ranges.each do |r|
+          yield_each(r){ |x| yielder.yield x}
+        end
+      end.each(&block)
+    end
+
+    def step(num = 1, &block)
+      i = 0
+      Enumerator.new do |yielder|
+        @ranges.each do |r|
+          yield_each(r) do |x|
+            yielder.yield x if ((i % num) == 0)
+            i += 1
+          end
+        end
+      end.each(&block)
+    end
+
+    def last
+      read_val(@ranges.last).last
+    end
+
+    def |(x)
+      SparseRange.new(@ranges, *x)
+    end
+
+    def -(x)
+      diff = SparseRange.new
+      diff_data = diff.ranges
+
+      i = 0
+      next_val = lambda do
+        throw :done unless i < @ranges.length
+        v = read_val(@ranges[i])
+        i += 1
+        v
+      end
+
+      catch(:done) do
+        other = (x.is_a?(SparseRange) ? x : SparseRange.new(x)).ranges
+
+        start, finish = next_val.call
+        other.each do |r|
+          other_start, other_finish = read_val(r)
+
+          while (finish < other_start)
+            diff_data << write_val(start, finish)
+            start, finish = next_val.call
+          end
+          next if other_finish < start
+
+          diff_data << (start.succ == other_start ? start : (start...other_start)) if start < other_start
+
+          start = other_finish.succ
+          start, finish = next_val.call if start > finish
+        end
+        diff_data << write_val(start, finish)
+        loop { diff_data << write_val(*next_val.call) }
+      end
+
+      diff
+    end
+
+    def &(x)
+      intersect = SparseRange.new
+      intersect_data = intersect.ranges
+
+      i = 0
+      next_val = lambda do
+        throw :done unless i < @ranges.length
+        v = read_val(@ranges[i])
+        i += 1
+        v
+      end
+
+      catch(:done) do
+        other = (x.is_a?(SparseRange) ? x : SparseRange.new(x)).ranges
+
+        start, finish = next_val.call
+        other.each do |r|
+          other_start, other_finish = read_val(r)
+          start, finish = next_val.call while (finish < other_start)
+
+          until other_finish < start
+            first = [start, other_start].max
+            last = [finish, other_finish].min
+
+            intersect_data << write_val(first, last)
+
+            start = last.succ
+            if start < other_finish
+              other_start = start
+              start, finish = next_val.call
+            end
+          end
+        end
+      end
+
+      intersect
+    end
+
+    def <<(x)
+      @ranges << [*(x.is_a?(SparseRange) ? x.ranges : x)]
+      optimize
+
+      self
+    end
+
+    def inspect
+      @ranges.inspect
+    end
+
+    def include?(x)
+      @ranges.any? do |r|
+        r.is_a?(Range) ? r.include?(x) : x == r
+      end
+    end
+
+    def empty?
+      @ranges.empty?
+    end
+
+    def size
+      @ranges.inject(0){|c, x| c + (x.is_a?(Range) ? x.count : 1)}
+    end
+
+    def ==(x)
+      other = (x.is_a?(SparseRange) ? x : SparseRange.new(x)).ranges
+      i = 0
+      (@ranges.length == other.length) && @ranges.all? do |e|
+        o = other[i]
+        i += 1
+        (e == o) || (read_val(e) == read_val(o))
+      end
+    end
+
+    # TODO: Calculate hash without creating the temp array
+    def hash
+      @ranges.map(&method(:read_val)).hash
+    end
+
+    alias :+ :|
+    alias :union :|
+
+    alias :minus :-
+    alias :intersect :&
+
+    alias :add :<<
+
+    alias :cover? :include?
+    alias :=== :include?
+
+    alias :eql? :==
+
+    protected
+    attr_reader :ranges
+
+    def yield_each(e)
+      if (e.is_a?(Range))
+        e.each{|x| yield x}
+      else
+        yield e
+      end
+    end
+
+    private
+
+    def read_val(x)
+      x.is_a?(Range) ? [x.first, (x.exclude_end? ? x.max : x.last)] : [x, x]
+    end
+
+    def write_val(start, finish)
+      (start != finish ? (start..finish) : finish)
+    end
+
+    def optimize
+      @ranges.flatten!
+      @ranges.compact!
+      @ranges.sort!{|a,b| (a <=> b) || (read_val(a) <=> read_val(b))}
+
+      fixed = []
+      start, finish = read_val(@ranges.first)
+
+      for i in (1...@ranges.length)
+        first, last = read_val(@ranges[i])
+
+        if (finish.succ >= first)
+          finish = last if last > finish
+        else
+          fixed << write_val(start, finish)
+          start, finish = first, last
+        end
+      end
+      fixed << write_val(start, finish) if finish
+
+      @ranges = fixed
+    end
+  end
+end
+
+class Range
+  include Comparable
+
+  def <=>(other)
+    comp = nil
+    if (other.is_a?(Range) || other.is_a?(BetterRanges::SparseRange))
+      comp = (first <=> other.first)
+      comp = (last <=> other.last) if comp == 0
+      if comp == 0
+        comp = -1 if exclude_end? && !other.exclude_end?
+        comp = 1 if !exclude_end? && other.exclude_end?
+      end
+    else
+      comp = (first <=> other)
+      comp = (last <=> other) if comp == 0
+      comp = -1 if comp == 0 && exclude_end?
+    end
+    comp
+  end
+end

data/lib/better_ranges/version.rb

@@ -0,0 +1,3 @@
+module BetterRanges
+  VERSION = "1.0.0"
+end

data/spec/better_ranges_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe BetterRanges do
+  it 'should have a version number' do
+    BetterRanges::VERSION.should_not be_nil
+  end
+end

data/spec/sparse_range_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+include BetterRanges
+
+describe BetterRanges::SparseRange do
+  context 'subtraction(#-)' do
+    it 'should work' do
+      a = SparseRange.new(-20..-10, 1..25, 50..75, 100..200, 300..400, 500..600, 700..800, 900)
+      b = SparseRange.new(-5..-1, 5..15, 40..80, 90..125, 150..225, 250..350, 550..650, 750, 850..950, 1000)
+
+      (a - a).should be_empty
+      (a - b).should eq [-20..-10, 1...5, 16..25, 126...150, 351..400, 500...550, 700...750, 751..800]
+    end
+  end
+
+  context 'intersection(#&)' do
+    a = SparseRange.new(1..10, 20..30, 40..50, 60..80)
+    b = SparseRange.new(10..20, 30..40, 65..75)
+
+    it 'should work' do
+      (a & a).should eq a
+      (a & b).should eq [10, 20, 30, 40, 65..75]
+    end
+
+    it 'should be commutative' do
+      (a & b).should eq(b & a)
+    end
+  end
+
+  context 'union(#|)' do
+    a = SparseRange.new(1..10, 20..30, 40..50, 60..80)
+    b = SparseRange.new(10..20, 30..40, 65..75)
+
+    it 'should work' do
+      (a | b).should eq [1..50, 60..80]
+    end
+
+    it 'should be commutative' do
+      (a | b).should eq(b | a)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'better_ranges'

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: better_ranges
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Michael Ziminsky
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- mgziminsky@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- better_ranges.gemspec
+- lib/better_ranges.rb
+- lib/better_ranges/range_operators.rb
+- lib/better_ranges/sparse_range.rb
+- lib/better_ranges/version.rb
+- spec/better_ranges_spec.rb
+- spec/sparse_range_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/mgziminsky/better_ranges
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.8.6
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Add support for set operations to the ruby Range class
+test_files:
+- spec/better_ranges_spec.rb
+- spec/sparse_range_spec.rb
+- spec/spec_helper.rb