match_map 1.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/CHANGES

@@ -0,0 +1,4 @@
+1.1.0 Add a different optimize method and benchmarking code; now 1.9 only
+1.0.0 Improve documentation and bump version to 1.0.0
+0.5.0 Change underlying structures so return order is guaranteed; lost optimize in the process
+0.0.0 First github release

data/Gemfile

@@ -0,0 +1,16 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+
+
+group :development do
+  gem "minitest", ">= 0"
+  gem "yard", "~> 0.6.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+  gem 'turn', '>=0.9.3'
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Bill Dueber
+
+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,195 @@
+# MatchMap -- a multimap where key matching is based on regular expressions
+
+`match_map` defines an object with a hash-like interface that allows Regexp patterns as keys and/or multiple simultaneous lookuup arguments. Calling `mm[arg]` checks _arg_ against every key, aggregating their associated values into an array.
+
+```ruby
+require 'match_map'
+
+mm = MatchMap.new
+mm['a'] = 'a_string'
+mm[/a/] = 'apat'
+mm[/b/] = ['bpat1', 'bpat2']
+mm[/.+b$/] = 'bpat3'
+
+mm['a'] #=> ['a_string', 'apat'] # order is the same as the key order
+mm['aa']  #=> ['apat']
+mm['b']   #=> ['bpat1', 'bpat2']
+mm['cob']  #=> ['bpat1', 'bpat2', 'bpat3'] # flattened one level!!!
+mm['cab']  #=> ['apat', 'bpat1', 'bpat2', 'bpat3']
+mm['c']    #=> nil # no match
+
+
+# Change the default miss value to ease some processing forms
+mm.default = []
+mm['neverGonnaMatch'].each do { #never get here}
+
+# You can also query on multiple values at once by passing an array
+mm[['a', 'aa', 'b']] #=> ['a_string', 'apat', 'bpat1', 'bpat2']
+
+# Or use a Proc as the value; it gets the match variable as its argument
+
+mm = MatchMap.new
+mm[/a(b+)/] = Proc.new {|m| [m[1].size]}
+mm['abbbb'] #=> [4]
+
+
+# You can set #echo to return the argument :always or only :onmiss
+mm = MatchMap.new
+mm[/ab/] = "AB"
+
+# first, without echo
+mm['miss'] = nil
+mm['cab']  = ['AB']
+
+#...then with echo = :always
+mm.echo = :always
+mm['miss'] = ['miss']
+mm['cab']  = ['cab', 'AB']
+
+#...and again with echo = :onmiss
+mm.echo = :onmiss
+mm['miss'] #=> ['miss'] # because nothing else matched
+mm['cab']  #=> ['AB']   # because a match was found
+
+# Need to ditch a key?
+if mm.has_key? /ab/ 
+  mm.delete /ab/
+end
+
+```
+
+A MatchMap is a hash-like with the following properties:
+
+* keys can be anything that responds to '==' (e.g., strings) or regular expressions
+* keys cannot be repeated (mirroring how a hash works, but see below about multiple values)
+* arguments are compared to non-pattern keys based on ==
+* arguments are compared to pattern keys based on pattern match against arg.to_s_
+* values can be scalars, arrays (treated as multiple return values), or Proc objects
+* a scalar argument to #[] is left alone for comparison to non-patterns (so a string or integer can be exactly matched), but converted to a string for comparison to patterns. (see "How are arguments compared to keys?", below)
+* an array argument to #[] is treated as if you want all values for all matches for all array members
+* the return value from #[] goes through #uniq and #compact (no repeated values, no nil values), which may or may not mess with what you expect the output order to be.
+
+The idea is that you can set up a bunch of (possibly overlapping) patterns, each of which is associated with one or more values, and easily get back all the values for those patterns that match the argument. `match_map` was originally designed for transforming values for full-text indexing, but has other uses as well. 
+
+
+## What is this good for?
+
+A match_map can be useful for (among other things) values that map onto a hierarchy.
+
+Here's part of a map for library call numbers:
+
+```ruby
+mm = MatchMap.new
+mm[/^H/] = 'Social Science'
+mm[/^HA/] = 'Statistics'
+mm['HA37 .P27 P16'] #=> ['Social Science', 'Statistics']
+```
+
+Or use it as a clean way to extract semi-regular information from free-text strings
+
+```ruby
+state = MatchMap.new
+state[/\bMN\b/i] = 'Minnesota'
+state[/\bMI\b/i] = 'Michigan'
+state['St. Paul, MN 55117'] #=> ['Minnesota']
+state['2274 Delaware Drive, Ann Arbor, MI, 48103'] #=> ['Michigan']
+```
+
+
+## How are arguments compared to keys?
+
+There are three basic rules:
+
+1. If the argument is an array, each element is handled separately
+2. If the argument (`a`) is being matched against a pattern key (`pk`), check if `pk.match(a.to_s)`
+3. If the argument (`a`) is being matched against a key that is not a pattern (`npk`), check if `a == npk`
+
+Here's a quick example to show how it works
+
+```ruby
+  mm = MatchMap.new
+  mm[1] = 'fixnum'
+  mm['1'] = 'string'
+  mm[/1/] = 'pattern'
+  mm[1] #=> ['fixnum', 'pattern']
+  mm['1'] #=> ['string', 'pattern']
+```
+
+
+## Using Proc objects as values
+
+You can also use a Proc object as a value. It must:
+
+* take a single argument; the match variable
+* return a (possibly empty) _array of values_
+
+This can be abused, of course, but can be useful. Here's a simple example that reverses the order of a comma-delimited duple. 
+
+```ruby
+mm = MatchMap.new
+mm[/^(.+),\s*(.+)$/] = Proc.new {|m| "#{m[2]} #{m[1]}"}
+mm['Dueber, Bill'] #=> ["Bill Dueber"]
+```    
+## Using echo to always/sometimes get back the argument
+
+There are two common requirements when doing this sort of translation for indexing:
+
+* The raw argument should always appear in the output
+* The raw argument should appear in the output only if there are no other matches. 
+
+```ruby
+mm = MatchMap.new
+mm[/ab/] = "AB"
+
+# first, without echo
+mm['miss'] = []
+mm['cab']  = ['AB']
+
+#...then with echo = :always
+mm.echo = :always
+mm['miss'] = ['miss']
+mm['cab']  = ['cab', 'AB']
+
+#...and again with echo = :onmiss
+mm.echo = :onmiss
+mm['miss'] #=> ['miss'] # because nothing else matched
+mm['cab']  #=> ['AB']   # because a match was found
+```
+
+Note that the `default` value will never be added to the output if `echo` is set.
+
+## Optimizing
+
+You can call `mm.optimize!` to attempt to optimize a MatchMap where none of the keys are regular expressions
+and none of the values are Proc objects for a significant speed increase (run `rake bench` for an idea
+of how much faster). This allows you to take advantage of all the differences between MatchMap and a regular
+hash (pass multiple arguments, flatten return values, echoing, etc.) while remaining an O(1) operation (instead
+of a O(n) for the standard, try-to-match-each-key-in-turn algorithm). 
+
+Note that a call to `#optimize!` actually picks the best algorithm for that particular map, so if you have a simple map,
+call `#optmize!`, and add a regular-expression key, another call to `#optmize!` is required to start using the 
+regular algorithm again. 
+
+Obviously, only call `#optimize!` when you're sure you won't be modifying the map anymore. 
+
+## Gotchas
+
+* Like a hash, repeated assignment to the same key results in a replacement. So `mm[/a/] = 'a'; mm[/a/] = 'A'` will give `mm['a'] #=> ['A']`
+* Return values are flattened one level. So, a => 1 and b => [2,3], the something that matches both will return [1,2,3]. If you really want to return an array, you need to do something like `m['a'] = [[1,2]]`
+  
+
+## Contributing to MatchMap
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2011 Bill Dueber. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.required_ruby_version = '>= 1.9.0' # due to use of define_singleton_method in optimize
+  gem.name = "match_map"
+  gem.homepage = "http://github.com/billdueber/match_map"
+  gem.license = "MIT"
+  gem.summary = "A multimap that allows keys to match regex patterns"
+  gem.description = %Q{MatchMap is a map representing key=>value pairs but where 
+    (a) a query argument can match more than one key, and (b) the argument is compraed to the key
+    such that you can use regex patterns as keys}
+  gem.email = "bill@dueber.com"
+  gem.authors = ["Bill Dueber"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+desc "Run a quick benchmark"
+task :bench do
+  $: << 'lib'
+  load 'bench/bench.rb'
+end
+
+task :default => :test
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+1.1.0

data/bench/bench.rb

@@ -0,0 +1,62 @@
+require 'benchmark'
+require 'match_map'
+
+h5 = {
+  'a' => 'A',
+  'b' => 'B',
+  'c' => 'C',
+  'd' => 'D',
+  'e' => 'E',
+  # /a/ => 'AAA'
+}
+
+@mm = MatchMap.new
+h5.each_pair {|k,v| @mm[k] = v}
+
+@mm2 = MatchMap.new()
+(1..20).each do |i|
+  @mm2[i] = i*2
+end
+# @mm2[/a/] = 'AAA'
+
+iters = 100_000
+puts "Testing #{iters} accesses"
+
+method = (defined? JRUBY_VERSION) ? :bmbm : :bm
+Benchmark.send(method) do |x|
+
+  x.report('hash            ') do
+    1..iters.times do
+      y = h5['a']
+    end
+  end
+
+  x.report('straight 5 keys ') do
+    1..iters.times do
+      y = @mm['a']
+    end
+  end
+  
+  x.report('optimized 5 keys') do
+    @mm.optimize!
+    1..iters.times do
+      y = @mm['a']
+    end
+  end
+
+  x.report('straight 20 keys') do
+    1..iters.times do
+      y = @mm2['a']
+    end
+  end
+  
+  
+  x.report('optimized 20 keys') do
+    @mm2.optimize!
+     1..iters.times do
+       y = @mm2['a']
+     end
+   end
+
+
+end

data/lib/match_map.rb

@@ -0,0 +1,102 @@
+# A hash-like object that tries to match an argument against
+# *all* keys (using == for non-Regexp keys and pattern matching
+# for Regexp keys)
+
+class MatchMap
+
+  # 
+  attr_accessor :default
+  attr_reader   :echo
+
+
+  def echo= arg
+    raise RuntimeError.new, "echo value must be :onmiss or :always" unless [:onmiss, :always].include? arg
+    @echo = arg
+  end
+
+  def []= key, val
+    @map[key] = val
+    @keys.push key unless @keys.include? key
+    set_attrs key, val
+  end
+  
+  def set_attrs key, val
+    @attrs[key] = {:regexkey => (key.is_a? Regexp), :procval => (val.is_a? Proc)}
+  end
+
+  def [] arg
+    rv = []
+    rv.push *arg if @echo == :always
+    if arg.is_a? Array
+      arg.map {|s| inner = self.inner_get(s); rv.push *inner}
+    else
+      inner = self.inner_get arg
+      rv.push *inner
+    end
+    rv.uniq!
+    rv.compact!
+    if rv.size == 0
+      if @echo == :onmiss
+        return [*arg]
+      else
+        return @default
+      end
+    end
+    return rv
+  end
+
+  def optimized_inner_get arg
+    return [@map[arg]]
+  end
+
+  def normal_inner_get arg
+    rv = []
+    @keys.each do |k|
+      if k.is_a? Regexp
+        m = k.match arg.to_s
+      else
+        m = (k == arg) ? arg : false
+      end
+      if m
+        v = @map[k]
+        if v.is_a? Proc
+          processed = v.call(m)
+          rv.push *processed if processed
+        else
+          rv.push *v
+        end
+      end
+    end
+    return rv
+  end
+
+  def has_key? key
+    @map.has_key? key
+  end
+
+  def delete key
+    @map.delete(key)
+    @keys.delete(key)
+  end
+
+  def initialize hash = {}
+    @default = nil # default miss value is nil
+    @echo = echo
+    @keys = hash.keys
+    @map = hash
+    @attrs = {}
+    @map.each_pair {|k, v| set_attrs k, v}
+    define_singleton_method :inner_get, method(:normal_inner_get)
+  end
+
+  def optimize!
+    @map.each_pair do |k,v|
+      if k.is_a? Regexp or v.is_a? Proc
+        define_singleton_method :inner_get, method(:normal_inner_get)
+        return
+      end
+    end
+    define_singleton_method :inner_get, method(:optimized_inner_get)
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'minitest/spec'
+require 'minitest/benchmark'
+begin; require 'turn'; rescue LoadError; end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'match_map'
+
+class MiniTest::Unit::TestCase
+end
+
+MiniTest::Unit.autorun

data/test/test_match_map.rb

@@ -0,0 +1,213 @@
+require 'helper'
+
+describe MatchMap do
+
+  before do
+    @h = MatchMap.new
+  end
+   
+  describe "when empty" do
+        
+    it "should return nil (default)" do
+      @h['a'].must_equal nil
+    end
+    
+    it 'should allow set of default' do
+      @h.default = 'def'
+      @h['a'].must_equal 'def'
+    end
+    
+  end
+  
+  describe "when a single string key" do
+    it 'should set correctly' do
+      @h['a'] = 3
+      @h['a'].must_equal [3]
+    end
+        
+    it 'should still return default' do
+      @h['a'] = 3
+      @h['c'].must_equal @h.default
+    end
+    
+    it 'should reset a value' do
+      @h['a'] = 3
+      @h['a'] = 4
+      @h['a'].must_equal [4]
+    end
+    
+    it 'should allow array values' do
+      @h['a'] = [1,2]
+      @h['a'].must_equal [1,2]
+    end
+    
+  end
+
+
+  describe "has/delete key" do
+    it "detects key" do
+      @h['a'] = 'a'
+      @h['b'] = 'b'
+      @h.has_key?('a').must_equal true
+      @h.has_key?('c').must_equal false
+      @h.delete('a')
+      @h.has_key?('a').must_equal false
+      @h['a'].must_equal @h.default
+    end
+  end
+  
+  describe "works with pattern keys" do
+    
+    it 'works with an always-match pattern' do
+      @h[/.?/] = 100
+      @h['a']  = 1
+      @h[10].must_equal [100]
+      @h['a'].must_equal [100, 1]
+    end
+    
+    
+    it "uses a single pattern" do
+      @h[/.+a/] = 1
+      @h['b'].must_equal @h.default
+      @h['a'].must_equal @h.default
+      @h['aa'].must_equal [1]
+      @h['era'].must_equal [1]
+    end
+    
+    it "works with disjoint patterns" do
+      @h[/.+a/] = 1
+      @h[/b/] = 2
+      @h['aa'].must_equal [1]
+      @h['ab'].must_equal [2]
+      @h['cab'].must_equal [1,2]
+    end
+  end
+  
+  describe "works with non-pattern keys" do
+        
+    it "is fine with strings" do
+      @h['a'] = 1
+      @h[/a/] = 2
+      @h['a'].must_equal [1,2]
+      @h['aa'].must_equal [2]
+    end
+    
+    it 'is fine with fixnums' do
+      @h[1] = 1
+      @h[2] = 2
+      @h[12] = 3
+      @h[1].must_equal [1]
+      @h[2].must_equal [2]
+      @h[12].must_equal [3] 
+    end
+  end
+
+  describe "works with a Proc" do
+    it 'does an echo proc' do
+      @h[/ab+/] = Proc.new {|m| m[0]}
+      @h['ab'].must_equal ['ab']
+    end
+    
+    it 'deals with match data' do
+      @h[/a(b+)/] = Proc.new {|m| [m[0], m[1].size.to_s]}
+      @h[/abb/].must_equal ['abb', '2']
+    end
+    
+    it "works with a more complex proc" do
+      mm = MatchMap.new
+      mm[/^(.+),\s*(.+)$/] = Proc.new {|m| "#{m[2]} #{m[1]}"}
+      mm['Dueber, Bill'].must_equal ["Bill Dueber"]
+    end
+    
+    it "calls the Proc for string argument, even though that kind of an abuse" do
+      mm = MatchMap.new
+      mm['a'] = Proc.new {|m| [m[0] + 'bbb']}
+      mm['a'].must_equal ['abbb']
+    end
+  end
+  
+  describe "works with echo" do
+    before do
+      @j  = MatchMap.new
+    end
+    
+    it "echos when empty" do
+      @j['miss'].must_equal @h.default # no echoing
+      
+      @j.echo = :always
+      @j['miss'].must_equal ['miss']
+      
+      @j.echo = :onmiss
+      @j['miss'].must_equal ['miss']
+    end
+    
+    it "echos when not empty" do
+      @j[/a/] = 'hello'
+      
+      @j['miss'].must_equal @j.default
+      
+      @j.echo = :always
+      @j['miss'].must_equal ['miss']
+      @j['ab'].must_equal ['ab', 'hello'].sort
+      
+      @j.echo = :onmiss
+      @j['miss'].must_equal ['miss']
+      @j['ab'].must_equal ['hello']
+      
+    end
+    
+    it "works with a Proc and echo" do
+      mm = MatchMap.new
+      mm[/^(.+),\s*(.+)$/] = Proc.new {|m| "#{m[2]} #{m[1]}"}
+      mm.echo = :always
+      mm['Dueber, Bill'].must_equal ['Dueber, Bill', "Bill Dueber"]
+    end
+    
+  end
+  
+  describe 'Multiple key arguments' do
+    before do
+      @h = MatchMap.new
+      @h['a'] = 1
+      @h['b'] = 2
+      @h[/c/] = 3
+    end
+    
+    it 'works with simple array arg' do
+      @h[['a', 'b']].must_equal [1,2]
+    end
+    
+    it "works with echo" do
+      @h.echo = :always
+      @h[['a', 'ac']].must_equal ['a', 'ac', 1, 3]
+    end
+    
+    it 'misses hard' do
+      @h[[1,2,3]].must_equal nil
+    end
+    
+  end
+      
+  describe 'Flattens correctly' do
+    before do
+      @h = MatchMap.new
+      @h[/c/] = 1
+      @h[/cc/] = [2, 3]
+      @h[/ccc/] = [[4,5, 6]]
+      @h[/cccc/] = [7, 8, [9, 10]]
+    end
+    
+    it 'flattens one level' do
+      @h['cc'].must_equal [1,2,3]
+    end
+    
+    it "doesn't over-flatten" do 
+      @h['ccc'].must_equal [1, 2, 3, [4,5,6]]
+    end
+    
+    it 'allows mixed depth' do
+      @h['cccc'].must_equal [1, 2, 3, [4, 5, 6], 7, 8, [9, 10]]
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: match_map
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Bill Dueber
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &70104080307140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70104080307140
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &70104080321880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *70104080321880
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70104080321120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *70104080321120
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &70104080320260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *70104080320260
+- !ruby/object:Gem::Dependency
+  name: turn
+  requirement: &70104080319220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+  type: :development
+  prerelease: false
+  version_requirements: *70104080319220
+description: ! "MatchMap is a map representing key=>value pairs but where \n    (a)
+  a query argument can match more than one key, and (b) the argument is compraed to
+  the key\n    such that you can use regex patterns as keys"
+email: bill@dueber.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .document
+- CHANGES
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- bench/bench.rb
+- lib/match_map.rb
+- test/helper.rb
+- test/test_match_map.rb
+homepage: http://github.com/billdueber/match_map
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: A multimap that allows keys to match regex patterns
+test_files: []