range_hash 2.0.0

data/.gitignore

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

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

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

data/README.md

@@ -0,0 +1,62 @@
+
+range_hash
+========================
+
+##Problem
+
+  Given a list of ranges, how do you effectively find if an element exist in any of them?
+
+##Solution
+
+    [sudo] gem install range_hash
+
+##Example
+
+### Simple
+
+    require 'range_hash'
+    ranges = RangeHash.new
+    ranges[1..3] = 'a'
+    ranges[10..15] = 'b'
+    ranges[27...30] = 'c'
+    ranges[7..10] = 'd'
+
+    ranges[2] #=> 'a'
+    ranges[15] #=> 'b'
+    ranges[100] #=> nil
+
+### Callbacks
+    require 'range_hash'
+    ranges = RangeHash.new
+    ranges.add_callback(1..13) do |elem|
+      puts "#{elem} is between 1 and 3"
+    end
+    ranges.add_callback(10..15) do |elem|
+      puts "#{elem} is between 10 and 15!"
+    end
+    ranges.add_callback(27...30) do |elem|
+      puts "#{elem} is between 27 and 29!"
+    end
+    ranges.add_callback(7..10) do |elem|
+      puts "#{elem} is between 7 and 10!"
+    end
+    ranges.add_callback(:default) do |elem|
+      puts "Couldn't find a range for #{elem}"
+    end
+
+    ranges.call(2) #=> 2 is between 1 and 3!
+    ranges.call(15) #=> 15 is between 10 and 15!
+    ranges.call(100) #=> Couldn't find a range of 100
+
+
+
+##Wait ... why?
+
+  Because O(log n) is better than O(N). RangeHash keeps an internal sorted array that uses a binary search to find your range. This allows you to achieve (log n) search. Another option would be to store a dense hash that stores all possible elements within the ranges, however this isn't efficient in terms of memory usage. This is great happy medium.
+
+  On-top of that, RangeHash provides some awesome functionality such as callbacks.
+
+
+##Notes
+
+  Currently does not support ranges that overlap one another.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+include Rake::DSL
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+task :test => :spec
+

data/lib/range_hash/version.rb

@@ -0,0 +1,3 @@
+class RangeHash
+  VERSION = "2.0.0"
+end

data/lib/range_hash.rb

@@ -0,0 +1,101 @@
+require "rangehash/version"
+require 'forwardable'
+
+class Range
+  def real_end
+    exclude_end? ? self.end - 1 : self.end
+  end
+end
+
+class RangeHashElement
+  extend Forwardable
+
+  attr_reader :range
+  attr_accessor :value, :callback
+
+  def_delegators :@range, :begin
+  def_delegator :@range, :real_end, :end
+  def initialize(opts={})
+    @range, @value, @callback = opts[:range], opts[:value], opts[:callback]
+  end
+end
+
+class RangeHash
+  def initialize
+    @arr = []
+    @default_callback = nil
+  end
+
+  def [](key)
+    result = search(key)
+  end
+
+  def call(key)
+    index = search(key, true)
+    if index < 0
+      @default_callback.call(key) if @default_callback.respond_to?(:call)
+    else
+      callback = @arr[index].callback
+      callback.call(key) if callback.respond_to?(:call)
+    end
+    nil
+  end
+
+  def []=(range,value)
+    raise ArgumentError.new("Key should be a range") unless Range === range
+    edit_or_create(range, :range => range, :value => value)
+    value
+  end
+
+  def add_callback(range, &callback)
+    raise ArgumentError.new("Need to pass a callback in the form of a block") unless block_given?
+    unless Range === range || range == :default
+      raise ArgumentError.new("Argument needs to be a range or :default")
+    end
+    if range == :default
+      @default_callback = callback
+    else
+      edit_or_create(range, :range => range, :callback => callback)
+    end
+    nil
+  end
+
+  def to_s
+    "#RangeHash<@ranges=[#{@arr.map(&:range).join(",")}]>"
+  end
+
+  private
+
+  def edit_or_create(range, element_opts={})
+    index = search(range.real_end, true)
+    if index < 0
+      elem = RangeHashElement.new(element_opts)
+      index = -(index + 1)
+      @arr.insert(index, elem)
+    else
+      element_opts.delete(:range)
+      edit_attr, attr_value = element_opts.to_a.first
+      @arr[index].instance_variable_set(:"@#{edit_attr}", attr_value)
+    end
+  end
+
+  def search(key, ret_index=false)
+    low, high = 0, @arr.size - 1
+    mid = 0
+
+    while low <= high
+      mid = (low + high)/ 2
+      if key <= @arr[mid].end && key >= @arr[mid].begin
+        val = ret_index ? mid : @arr[mid].value
+        return val
+      elsif key < @arr[mid].end
+        high = mid - 1
+      else
+        low = mid + 1
+      end
+    end
+
+    return -low - 1 if ret_index
+  end
+end
+

data/range_hash.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "range_hash/version"
+
+Gem::Specification.new do |s|
+  s.name        = "range_hash"
+  s.version     = RangeHash::VERSION
+  s.authors     = ["Mike Lewis"]
+  s.email       = ["ft.mikelewis@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{An efficient hash that allows ranges to be keys and searched given an element within those ranges.}
+  s.description = %q{An efficient hash that allows ranges to be keys and searched given an element within those ranges.}
+
+  s.rubyforge_project = "range_hash"
+
+  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"]
+
+  # specify any dependencies here; for example:
+   s.add_development_dependency "rspec"
+   s.add_development_dependency "rake"
+  # s.add_runtime_dependency "rest-client"
+end

data/spec/rangehash_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe RangeHash do
+  before do
+    @rh = RangeHash.new
+  end
+  [:[], :[]=].each do |meth|
+    it "should respond to #{meth}" do
+      @rh.should respond_to(meth)
+    end
+  end
+
+  context "integeration" do
+    before  do
+      c = (13..16)
+      d = (20...25)
+      a = (1..10)
+      b = (10...13)
+
+      @rh[c] = 'c'
+      @rh[d] = 'd'
+      @rh[a] = 'a'
+      @rh[b] = 'b'
+    end
+    it "should insert to keep the internal array" do
+      internal_array = @rh.instance_eval { @arr }
+      internal_array.map(&:value).should == ['a', 'b', 'c', 'd']
+    end
+
+    it "[] should return the associated value for that range" do
+      @rh[21].should == 'd'
+    end
+
+    it "[] should return nil for a value that is not in a range" do
+      @rh[25].should == nil
+    end
+
+    it "should beable to replace an element" do
+      @rh[(13..16)] = 'new'
+
+      @rh[14].should == 'new'
+    end
+
+    it "should accept callbacks and return nil" do
+      result = nil
+      n = @rh.add_callback(100..105) do |elem|
+        result = elem
+      end
+
+      @rh.call(103)
+
+      result.should == 103
+      n.should be_nil
+    end
+
+    it "should accept a default callback" do
+      result = nil
+      @rh.add_callback(:default) do |elem|
+        result = elem
+      end
+      @rh.call(2000)
+      result.should == 2000
+    end
+
+    it "should return nil and not blow up when accessing a callback that does not exist" do
+      lambda { @rh.call(3) }.should_not raise_error
+      @rh.call(3).should be_nil
+    end
+
+    it "should raise an ArgumentError if no block is passed into add_callback" do
+      lambda { @rh.add_callback((1..3)) }.should raise_error(ArgumentError)
+    end
+
+    it "should raise an ArgumentError if a non range or not default is passed into a callback" do
+      lambda { @rh.add_callback(3) }.should raise_error(ArgumentError)
+    end
+
+    it "should raise an ArgumentError if key is not range" do
+      lambda { @rh["yo"] = 5}.should raise_error(ArgumentError)
+    end
+
+  end
+
+end
+
+describe RangeHashElement do
+  it "should handle inclusive ranges for end" do
+    e = RangeHashElement.new(:range => (1..10), :value => 'a')
+    e.end.should == 10
+  end
+
+  it "should handle begin for ranges" do
+    e = RangeHashElement.new(:range => (1..10), :value => 'a')
+    e.begin.should == 1
+  end
+
+  it "should handle exclusive ranges end" do
+    e = RangeHashElement.new(:range => (1...10), :value => 'a')
+    e.end.should == 9
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'range_hash'
+

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: range_hash
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Mike Lewis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2151811980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2151811980
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2151810580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2151810580
+description: An efficient hash that allows ranges to be keys and searched given an
+  element within those ranges.
+email:
+- ft.mikelewis@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- README.md
+- Rakefile
+- lib/range_hash.rb
+- lib/range_hash/version.rb
+- range_hash.gemspec
+- spec/rangehash_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+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: range_hash
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: An efficient hash that allows ranges to be keys and searched given an element
+  within those ranges.
+test_files:
+- spec/rangehash_spec.rb
+- spec/spec_helper.rb