composite_range 0.1

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 @@
+--colour

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in composite_range.gemspec
+gemspec
+
+group :test do
+  gem 'rspec'
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Alex Svirin
+
+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,53 @@
+Overview
+========
+
+composite_range is a simple class if you need to deal with more than one range at once.
+
+Installation
+============
+
+Add this line to your application's Gemfile:
+
+    gem 'composite_range'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install composite_range
+
+Usage
+=====
+
+You can simply create a composite range by passing all ranges that you plan to deal with:
+
+    range = CompositeRange.new([1..10, 12..45, 37..98])
+
+If you have some ranges to exclude from the main one:
+
+    range = CompositeRange.new(1..20, exclude: [3..5, 9..14])
+
+After creating of instance, you can do the range operations: include?, cover?, begin, end, first, last.
+
+Adding ranges dynamically:
+
+    range << (2..12)
+
+or
+
+    range[] = (2..12)
+
+Getting range by index:
+
+    range[index]
+
+Contributing
+============
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/composite_range.gemspec

@@ -0,0 +1,15 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Hck"]
+  gem.homepage      = "http://github.com/hck/composite_range"
+  gem.description   = %q{CompositeRange class allows you to work with few ranges in one container}
+  gem.summary       = %q{Simple composite ranges}
+
+  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.name          = "composite_range"
+  gem.require_paths = ["lib"]
+  gem.version       = '0.1'
+end

data/lib/composite_range.rb

@@ -0,0 +1,94 @@
+class CompositeRange
+  include Enumerable
+
+  attr_accessor :ranges
+
+  def initialize(args = [], options={})
+    unless options[:exclude]
+      @ranges = args.is_a?(Array) ? args : [args]
+      return
+    end
+
+    options[:exclude] = [options[:exclude]] unless options[:exclude].is_a? Array
+
+    @ranges = options[:exclude].inject([args]) do |res, r|
+      res.map do |range|
+        if range.include?(r.begin) and range.include?(r.end)
+          val = []
+          val << (range.begin..r.begin) if range.begin != r.begin
+          val << (r.end..range.end) if range.end != r.end
+          val
+        elsif range.include?(r.begin)
+          (range.begin..r.begin) if range.begin != r.begin
+        elsif range.include?(r.end)
+          (r.end..range.end) if range.end != r.end
+        else
+          range
+        end
+      end.flatten.compact
+    end
+  end
+
+  def ==(obj)
+    obj.respond_to?(:ranges) ? self.ranges == obj.ranges : self.ranges == obj
+  end
+
+  def eql?(obj)
+    obj.is_a?(self.class) and self == obj
+  end
+
+  def [](key)
+    @ranges[key]
+  end
+
+  def []=(val)
+    if val.is_a?(::Range) or val.is_a?(self.class)
+      @ranges << val
+    else
+      raise 'Only arguments with class Range or CompositeRange allowed'
+    end
+  end
+
+  def <<(val)
+    if val.is_a?(::Range) or val.is_a?(self.class)
+      @ranges.push(val)
+    else
+      raise 'Only arguments with class Range or CompositeRange allowed'
+    end
+  end
+
+  def each(&block)
+    @ranges.each(&block)
+  end
+
+  def cover?(val)
+    select_ranges{|r| r.cover?(val)}.size > 0
+  end
+
+  def include?(val)
+    select_ranges{|r| r.include?(val)}.size > 0
+  end
+  alias :member? :include?
+  alias :=== :include?
+
+  def begin
+    ranges.min_by{|r| r.send(__method__)}.send(__method__)
+  end
+
+  def end
+    ranges.max_by{|r| r.send(__method__)}.send(__method__)
+  end
+
+  def first(n=1)
+    n == 1 ? ranges.first : ranges.first(n)
+  end
+
+  def last(n=1)
+    n == 1 ? ranges.last : ranges.last(n)
+  end
+
+  private
+  def select_ranges(&block)
+    @ranges.select(&block)
+  end
+end

data/spec/composite_range_spec.rb

@@ -0,0 +1,210 @@
+require 'spec_helper'
+
+describe CompositeRange do
+  it 'creates new object and fills ranges if passed' do
+    subject.class.new.ranges.should eq([])
+    subject.class.new((1..5)).ranges.should eq([(1..5)])
+  end
+
+  it 'creates new object and splits passed range to smaller ones by ranges, passed in :exclude option' do
+    subject.class.new(1..20, exclude: 3..5).ranges.should eq([1..3, 5..20])
+    subject.class.new(1..20, exclude: 3..20).ranges.should eq([1..3])
+    subject.class.new(1..20, exclude: [3..5, 12..13, 16..19]).ranges.should eq([1..3, 5..12, 13..16, 19..20])
+    subject.class.new(1..20, exclude: [3..5, 12..13, 16..20]).ranges.should eq([1..3, 5..12, 13..16])
+  end
+
+  describe '#[]' do
+    before(:each) do
+      @range = subject.class.new [(1..10), (13..21)]
+    end
+
+    it 'gets element by index' do
+      @range[0].should eq(1..10)
+      @range[1].should eq(13..21)
+    end
+
+    it 'gets nil if index not exists' do
+      @range[2].should be_nil
+    end
+
+    it 'raises exception if not integer index provided' do
+      ->{@range['key']}.should raise_error
+    end
+  end
+
+  describe '#[]=' do
+    before(:each) do
+      @range = subject.class.new
+    end
+
+    it 'assigns element is it is CompositeRange or Range object' do
+      @range[] = (1..10)
+      @range[] = subject.class.new
+
+      @range[0].should eq(1..10)
+      @range[1].should eq(subject.class.new)
+    end
+
+    it 'raises error if element is not Range or CompositeRange' do
+      ->{@range[] = 1}.should raise_error
+    end
+  end
+
+  describe '#<<' do
+    before(:each) do
+      @range = subject.class.new
+    end
+
+    it 'pushes element to composite range if it is CompositeRange or Range object' do
+      @range << (1..10)
+      @range << subject.class.new
+      @range[0].should eq(1..10)
+      @range[1].should eq(subject.class.new)
+    end
+
+    it 'raises error if element is not Range or CompositeRange' do
+      ->{@range << 1}.should raise_error
+    end
+  end
+
+  describe '#each' do
+    before(:each) do
+      @range = subject.class.new([1..5, 8..10, 23..45])
+      res = []
+      @range.each{|r| res << r.begin + 5}
+      res.should == [6, 13, 28]
+    end
+
+    it 'yields block for each element in @ranges' do
+
+    end
+  end
+
+  describe '#cover?' do
+    before(:each) do
+      @range = subject.class.new([1..10, 12..45, -18..-3])
+    end
+
+    it 'returns true if one of @ranges covers passed object' do
+      @range.cover?(10).should be_true
+      @range.cover?(12).should be_true
+      @range.cover?(15).should be_true
+      @range.cover?(-17).should be_true
+    end
+
+    it 'returns false if passed object is not covered in any of @ranges' do
+      @range.cover?(0).should be_false
+      @range.cover?(11).should be_false
+      @range.cover?(46).should be_false
+      @range.cover?(-2).should be_false
+    end
+  end
+
+  describe '#include?' do
+    before(:each) do
+      @range = subject.class.new([1..10, 12..45, -18..-3])
+    end
+
+    it 'returns true if one of @ranges includes passed object' do
+      @range.include?(10).should be_true
+      @range.include?(12).should be_true
+      @range.include?(15).should be_true
+      @range.include?(-17).should be_true
+    end
+
+    it 'returns false if passed object is not included in any of @ranges' do
+      @range.include?(0).should be_false
+      @range.include?(11).should be_false
+      @range.include?(46).should be_false
+      @range.include?(-2).should be_false
+    end
+  end
+
+  describe '#begin' do
+    before(:each) do
+      @range = subject.class.new
+    end
+
+    it 'returns min object from all ranges start points' do
+      @range << (1..10)
+      @range << (3..12)
+      @range << (21..85)
+      @range.begin.should eq(1)
+    end
+  end
+
+  describe '#end' do
+    before(:each) do
+      @range = subject.class.new
+    end
+
+    it 'returns min object from all ranges end points' do
+      @range << (1..10)
+      @range << (3..12)
+      @range << (21..85)
+      @range.end.should eq(85)
+    end
+  end
+
+  describe '#first' do
+    before(:each) do
+      @range = subject.class.new
+      @range << (1..10)
+      @range << (3..12)
+      @range << (21..85)
+    end
+
+    it 'returns first element if n is not specified' do
+      @range.first.should eq(1..10)
+    end
+
+    it 'returns first n element if n is specified' do
+      @range.first(2).should eq([1..10, 3..12])
+    end
+  end
+
+  describe '#last' do
+    before(:each) do
+      @range = subject.class.new
+      @range << (1..10)
+      @range << (3..12)
+      @range << (21..85)
+    end
+
+    it 'returns last element if n is not specified' do
+      @range.last.should eq(21..85)
+    end
+
+    it 'returns last n element if n is specified' do
+      @range.last(2).should eq([3..12, 21..85])
+    end
+  end
+
+  describe '#==' do
+    it 'composite ranges are == if @ranges are empty' do
+      @range1 = subject.class.new
+      @range2 = subject.class.new
+      @range1.should == @range2
+    end
+
+    it 'composite ranges are == if @ranges are equal' do
+      @range1 = subject.class.new([1..5, 7..10])
+      @range2 = subject.class.new([1..5, 7..10])
+      @range1.should == @range2
+    end
+  end
+
+  describe '#eql?' do
+    it 'composite ranges are eql? if @ranges are equal' do
+      @range1 = subject.class.new([1..5, 7..10])
+      @range2 = subject.class.new([1..5, 7..10])
+      @range1.should == @range2
+    end
+
+    it 'ranges are not eql? if they are not of the same class' do
+      @range1 = subject.class.new(1..5)
+      @range2 = (1..5)
+      @range1.should_not == @range2
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require 'rspec'
+require 'composite_range'

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: composite_range
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Hck
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-28 00:00:00.000000000 Z
+dependencies: []
+description: CompositeRange class allows you to work with few ranges in one container
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- composite_range.gemspec
+- lib/composite_range.rb
+- spec/composite_range_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/hck/composite_range
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Simple composite ranges
+test_files:
+- spec/composite_range_spec.rb
+- spec/spec_helper.rb