hashrules 1.1.4

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MDJhZmM2MWMyMTkzNjc3NjkwNjYzZmRlMjkwMjllNjFkZmJlNmRlYw==
+  data.tar.gz: !binary |-
+    YjZiYTk1NDBkY2I1MzgzNmY4YmI5NGRhYTkyMDkwOGU4MTY0ODY5ZQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YTgyMzk0NzQ3MDdiOWNiM2JlMjM3ZmM4ZTIwYTc3YWI2NDliNWEzNzE2OGRh
+    MWIwNGM3ZGI0MWU5YzhhYmFiMDBkN2ZkYzE1ZDUxYzE4ODVjOGVmMzg1Zjdk
+    ZTQ5MDdhNTc1MWE3YzNiMDBhZjA0MWM1ZjRjMjdmYmFmM2YwNDg=
+  data.tar.gz: !binary |-
+    MzRiMGI0N2NmYTk5NDhkZWM5MDQxNDM3ODU4ZDM2Y2Q5YWQ5YmJiM2E2M2Vl
+    ZmQxMDQyYzZmZjk3ZDU3OTk3Yjc3Mzg5ZmMxZTVhOThkN2VhZWI4OWNhMTQz
+    M2U3NjNiNjRjMzgzMmEzZDNjZjYyMmZhMjM0NWM0N2Y3N2U2NWM=

data/CHANGELOG.mdown

@@ -0,0 +1,52 @@
+
+# ChangeLog
+
+## 1.1.4
+
+* Bumped version due to need to republish to RubyGems (last version did not include all files)
+
+## 1.1.3
+
+* Improved cache hits
+
+## 1.1.2
+
+* Sort results that can explain more matches above those with less, even if the others covers more characters
+
+## 1.1.1
+
+* Percent coverage should include spaces between matches, otherwise a fully covered string would never reach 100%
+
+## 1.1.0
+
+* Added result caching
+
+## 1.0.3
+
+* Bugfix: Some cases would sort a low-level submatch over a higher one. Now matchlevel is set accordingly and sorted with if coverage are equal
+
+## 1.0.2
+
+* Bugfix: Coverage was not set for parent matchers in the case of a successful submatch. This meant that sometimes a first-level match would be ranked lower (treated as a submatch) when another submatch was found.
+
+## 1.0.1
+
+* Bugfix: When using smart search / submatching - don't count whitespace as coverage. This caused /germany/ in first level to gain less priority than /( |^)germany( |$)/ in USA (second level).
+* Bugfix: Fix a certain case where a Limit set to 1 would gain -1 (unlimited) interpretation
+
+## 1.0.0
+
+This is a major version which breaks backwards compatibility.
+
+* Changed API: HashRules#process now takes a single string and returns a new hash
+* Added submatch feature to find results (deeply) nested even if a top level couldn't match.
+* HashRules no longer cleans string before process (such as removing - and /), this is now the responsibility of the application.
+
+## 0.2.3
+
+* Fix issue with using both and strings (it would only accept no-class and regex before)
+
+## 0.2
+
+* Add matcher keywords both() for applying AND operator and no() for negating an expression
+* Change name to sc-hashrules

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gem 'turn'
+gem 'shoulda'
+gem 'mocha'
+gem 'htmlentities'
+gem 'rake'
+gem 'awesome_print'

data/Gemfile.lock

@@ -0,0 +1,37 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (3.2.9)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    ansi (1.4.3)
+    awesome_print (1.0.1)
+    bourne (1.1.2)
+      mocha (= 0.10.5)
+    htmlentities (4.3.1)
+    i18n (0.6.1)
+    metaclass (0.0.1)
+    mocha (0.10.5)
+      metaclass (~> 0.0.1)
+    multi_json (1.5.0)
+    rake (10.0.3)
+    shoulda (3.3.2)
+      shoulda-context (~> 1.0.1)
+      shoulda-matchers (~> 1.4.1)
+    shoulda-context (1.0.1)
+    shoulda-matchers (1.4.2)
+      activesupport (>= 3.0.0)
+      bourne (~> 1.1.2)
+    turn (0.9.6)
+      ansi
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  awesome_print
+  htmlentities
+  mocha
+  rake
+  shoulda
+  turn

data/LICENSE.txt

@@ -0,0 +1,4 @@
+HashRules by Mikael Wikman is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
+
+For more information, please visit:
+http://creativecommons.org/licenses/by-sa/3.0/

data/README.mdown

@@ -0,0 +1,143 @@
+
+# HashRules
+
+A simple, yet powerful, gem for building constructions for identifying contents in a string in a structured, hierarchical, manner.
+
+## Example
+
+Suppose you're building a system for identifying countries, regions and cities within a string. An exerpt might look like this:
+
+```ruby
+match 'united states', w(/u ?s ?a/) do
+  set country: 'United States'
+
+  match /( |^)cali/, 'ca' do
+    set state: 'California'
+    set region: 'West Coast'
+
+    match 'long beach', 'longbeach' do
+      set city: 'Long Beach'
+    end
+
+    match 'fontana' do
+      set city: 'Fontana'
+    end
+  end
+end
+```
+
+This simple DSL translates to a series of OR and AND statements. For example, if we were to write the exact same logic but in plain if/then/else and regexes; the path for matching all the way to 'Long Beach' would be:
+
+```ruby
+text = "Long Beach, California, United States"
+text.gsub!(',','')
+result = {}
+
+if (text =~ /( |^)united states( |$)/ || text =~ /( |^)u ?s ?a( |$)/)
+  result['country'] = 'United States'
+
+  if (text =~ /( |^)cali/ || text =~ /( |^)ca( |$)/)
+    result['state'] = 'California'
+    result['region'] = 'West Coast'
+
+    if (text =~ /( |^)long beach( |$)/ || text =~ /( |^)longbeach( |$)/)
+      result['city'] = 'Long Beach'
+    elsif text =~ /( |^)fontana( |$)/
+      result['city'] = 'Fontana'
+    end
+  end
+end
+```
+
+## Available matchers
+<table>
+  <tr>
+    <th>Notation</th><th>Equivalence</th><th>Use case</th>
+  </tr>
+  <tr>
+    <td>
+      w(regex)
+    </td>
+    <td>
+      /( |^)#{regex}( |$)/
+    </td>
+    <td>
+      Create regex matching only whole words 
+    </td>
+  </tr>
+
+  <tr>
+    <td>
+      'regex'
+    </td>
+    <td>
+      /( |^)#{Regexp.escape(regex)}( |$)/
+    </td>
+    <td>
+      String matching whole words. 'key' would match "I have a key" but not "monkey"
+    </td>
+  </tr>
+
+  <tr>
+    <td>
+      no(matcher)
+    </td>
+    <td>
+      !(matcher.success?)
+    </td>
+    <td>
+      Inverted string or regex matcher 
+    </td>
+  </tr>
+
+  <tr>
+    <td>
+      both(A,B)
+    </td>
+    <td>
+      A.success? && B.success?            
+    </td>
+    <td>
+      Logical AND of given matchers, which may be nested 
+    </td>
+  </tr>
+</table>
+
+## Installation
+
+`gem install hashrules`
+
+## Usage
+
+```
+require 'hash_rules'
+
+rules = HashRules.new(args)
+
+# args:
+#  * folder: path to the folder containing one or more rule files (all will be read)
+
+process_args={}
+results = rules.process('Alabama, Canada', process_args)
+
+results.each do |result|
+  p result
+end
+```
+
+Each result contains the following keys:
+
+* data: This is the resulting data accumulated from the rules `set` statements
+* coverage: An array of index pairs showing what part of the string was matched.
+* match_id: Indicates the deepest matching rule id
+* matchlevel: Indicates how deeply nested the first match was. If `max_submatch_level` is zero, this will always be 1.
+* percent_coverage: A number 0 to 100 indicating how many percent of the string was matched
+
+Process_args may be any of the following:
+
+* max_submatch_level: Allow search to start from a nested matcher. If this value is 1, this means HashRules may skip at the very most one level. Recommended to be used with limit: -1
+* limit: Stop search when this number of matches have been found. Good for performance, but not recommended if `max_submatch_level` is more than zero because results won't guarantee best match.
+
+## License
+
+<a rel="license" href="http://creativecommons.org/licenses/by-sa/3.0/deed.en_US"><img alt="Creative Commons License" style="border-width:0" src="http://i.creativecommons.org/l/by-sa/3.0/80x15.png" /></a><br /><span xmlns:dct="http://purl.org/dc/terms/" property="dct:title">HashRules</span> by <span xmlns:cc="http://creativecommons.org/ns#" property="cc:attributionName">Mikael Wikman</span> is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-sa/3.0/deed.en_US">Creative Commons Attribution-ShareAlike 3.0 Unported License</a>.

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/app.gemspec

@@ -0,0 +1,16 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |gem|
+  gem.authors       = ['Mikael Wikman']
+  gem.email         = ['mikael@swedcontent.com']
+  gem.description   = %q{Rule-based hash manipulator using custom DSL}
+  gem.summary       = %q{ }
+  gem.homepage      = "https://github.com/mikaelwikman/hashrules"
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|features)/})
+  gem.name          = "hashrules"
+  gem.require_paths = ["lib"]
+  gem.version       = '1.1.4'
+end

data/lib/hash_matcher.rb

@@ -0,0 +1,167 @@
+class HashMatcher
+  attr_reader :rules, :sets
+
+  def initialize
+    @rules = []
+    @sets = {}
+    @context = self
+  end
+
+  def include_folder folder
+    Dir["#{folder}/*.rb"].each do |file|
+      @current_folder = folder
+      contents = File.read(file)
+      eval(contents, binding)
+    end
+  end
+
+  def include_subfolder folder
+    include_folder "#{@current_folder}/#{folder}"
+  end
+
+  def to_s i=0
+    result = ""
+    sets.each do |k,v|
+      result << "#{" "*i}#{k} = #{v}\n"
+    end
+    rules.each do |regexes, matcher|
+      result << "\n#{" "*i}If match #{regexes.to_s}\n"
+      result << matcher.to_s(i+1)
+      result << "#{" "*i}End\n"
+    end
+    result
+  end
+
+  def analyze string, opts={}, level=1
+    matches = []
+    opts[:limit] ||= 1
+    skip_levels = opts[:skip_levels] || 0
+
+    rules.each do |regexes, matcher|
+      offsets = []
+      if regexes.find{|r| offsets=test(string,r)} || skip_levels > 0 
+        opts[:skip_levels] = skip_levels-1
+        sub_matches = matcher.analyze(string, opts, level+1)
+        
+        sub_matches.map do |m| 
+          m['data'] = sets.merge(m['data'])
+          if offsets
+            m['matchlevel'] = level
+            offsets.each do |offset|
+              start, stop  = offset
+
+              stop -= 1
+
+              start += 1 if string[start] == ' '
+              stop -= 1 if string[stop] == ' '
+
+              m['coverage'] << [start,stop]
+            end
+          end
+        end
+
+        matches += sub_matches
+
+        if skip_levels <= 0
+          opts[:limit] -= 1
+        end
+
+        if (opts[:limit]) == 0
+          break
+        end
+      end
+    end
+    if matches.empty? && skip_levels < 0
+      matches << { 'data' => sets.dup, 'coverage' => [], match_id: self.object_id}
+    end
+
+    matches
+  end
+
+  private
+
+  def test string, matcher
+    if matcher.is_a?(NoClass)
+      m = test(string,matcher.regex)
+      [[-1,-1]] if !m
+    elsif matcher.is_a?(AndClass)
+      r = matcher.regexes.map{|r| a=test(string,r); a[0] if a}
+      if r.all?{|r| r}
+        r.find_all{|r| r[0] != -1}
+      end
+    else
+      m = matcher.match(string)
+      [m.offset(0)] if m
+    end
+  end
+
+  def set sub_hash
+    @context.sets.merge! stringified sub_hash
+  end
+
+  def match *args, &block
+    regexes = args.map{|r| to_regex(r)}
+    matcher = HashMatcher.new
+    old_context = @context
+    old_folder = @current_folder
+    @context.rules << [regexes, matcher]
+    @context = matcher
+    block.call
+    @context = old_context
+    @current_folder = old_folder
+  end
+
+  def w(regex) # make it match whole words
+    /(^| )#{regex.source}($| )/
+  end
+
+  def no(regex)
+    NoClass.new(to_regex(regex))
+  end
+
+  def both(*regexes)
+    AndClass.new(to_regex(regexes))
+  end
+
+  def to_regex(matcher)
+    if matcher.kind_of?(String)
+      /(^| )#{Regexp.escape(matcher)}($| )/
+    elsif matcher.kind_of?(Array) 
+      matcher.map{|r| to_regex(r)}
+    else
+      matcher
+    end
+  end
+
+  def stringified hash
+    hash.keys.each do |key|
+      val = hash.delete(key)
+      hash[key.to_s] = val
+    end
+    hash
+  end
+
+  class NoClass
+    attr_reader :regex
+
+    def initialize regex
+      @regex = regex
+    end
+
+    def to_s
+      "!(#{@regex})"
+    end
+  end
+
+  class AndClass
+    attr_reader :regexes
+
+    def initialize regexes
+      @regexes = regexes
+    end
+
+    def to_s
+      @regexes.map{|r| r.inspect}.join(' AND ')
+    end
+  end
+end

data/lib/hash_rules.rb

@@ -0,0 +1,124 @@
+require 'hash_matcher'
+require 'json'
+
+class HashRules
+
+  def initialize args
+    @folder = args[:folder] || raise("No folder specified!")
+
+    @hashmatcher = HashMatcher.new
+    @hashmatcher.include_folder(@folder)
+    @cache = {}
+  end
+
+  def process string, opts={}
+    string = clean_string(string)
+
+    if cached=@cache[string]
+      return Marshal.load(cached)
+    end
+
+    result = Processor.new(string, @hashmatcher, opts).do
+
+    @cache[string] = Marshal.dump(result)
+    result
+  end
+
+  def clean_string string
+    string.gsub /\s+/, ' '
+  end
+
+  def to_s
+    "== HASHRULES ==" << @hashmatcher.to_s
+  end
+
+  class Processor
+    def initialize string, hashmatcher, opts
+      @string = string.dup
+      @hashmatcher = hashmatcher
+      @max_submatch_level = opts[:max_submatch_level] || 0
+      @limit = opts[:limit] || 1
+      @memory = []
+    end
+
+    def do
+      each_submatch_level do |submatch_level|
+        add_to_list(new_results = analyze(submatch_level))
+        break if reached_limit?
+      end
+
+      sort_by_coverage
+
+      list
+    end
+
+    private
+
+    def analyze submatch_level
+      limit = @limit <= 0 ? -1 : (results_count() - @limit).abs
+      opts = {
+        skip_levels: submatch_level,
+        limit: limit
+      }
+
+      matches = @hashmatcher.analyze(@string, opts)
+      matches = matches.delete_if{|m| m['data'].empty?}
+
+      matches.each do |m|
+        coverage = Array.new(@string.length, false)
+        m['coverage'].each do |start, stop|
+          (start..stop).each do |i|
+            coverage[i] = true
+          end
+        end
+        (1..(coverage.count-2)).each do |i|
+          if coverage[i-1] && coverage[i+1]
+            coverage[i] = true
+          end
+        end
+
+        m['percent_coverage'] = coverage.find_all{|c| c}.count * 100 / @string.length
+      end
+       
+      matches
+    end
+
+    def each_submatch_level &block
+      (0..@max_submatch_level).each &block
+    end
+
+    def reached_limit?
+      @limit > 0 && @memory.count >= @limit
+    end
+
+    def results_count
+      @memory.count
+    end
+
+    def add_to_list results
+      @memory += results
+#      results.each do |result|
+#        @memory << result unless @memory.any?{|m| m[:match_id] == result[:match_id]}
+#      end
+    end
+
+    def sort_by_coverage
+      @memory.sort! do |a,b| 
+        result = b['coverage'].count <=> a['coverage'].count
+        if result == 0
+          result = b['percent_coverage'] <=> a['percent_coverage']
+
+          if result == 0
+            result = a['matchlevel'] <=> b['matchlevel']
+          end
+        end
+        result
+      end
+    end
+
+    def list
+      @memory
+    end
+    
+  end
+end

data/test/examples/canada/oregon.rb

@@ -0,0 +1,3 @@
+match 'oregon' do
+  set region: 'Oregon'
+end

data/test/examples/cyrillic.rb

@@ -0,0 +1,4 @@
+
+match /ми 8т/ do
+  set manufacturer: 'Ми-8Т'
+end

data/test/examples/match_two.rb

@@ -0,0 +1,8 @@
+
+match "match" do
+  set match: 'first'
+end
+
+match "match" do
+  set match: 'second'
+end

data/test/examples/piper.rb

@@ -0,0 +1,14 @@
+
+match both(/per/, no(/piper/)) do
+  set manufacturer: 'Per'
+end
+
+match both('string', /regex/) do
+  set manufacturer: 'success'
+end
+
+match /piper/ do
+  set manufacturer: 'Piper'
+
+  include_subfolder 'piper'
+end

data/test/examples/piper/pa28.rb

@@ -0,0 +1,19 @@
+
+match w(/pa ?28/) do # => /( |^)pa ?28( |$)/
+  set family: 'PA-28 Cherokee'
+  set engine_count: 1
+  set category: 'piston'
+
+  match 'pa28 181', 'pa 28 181' do
+    set model: 'PA-28-181'
+    set horsepower: 180
+
+    match /archer ii/, /archer 2/, /ii/ do
+      set model: 'PA-28-181 Archer II'
+    end
+
+    match /archer iii/, /archer 3/, /iii/ do
+      set model: 'PA-28-181 Archer III'
+    end
+  end
+end

data/test/examples/united states/ohio.rb

@@ -0,0 +1,4 @@
+match 'ohio' do
+  set region: 'Ohio'
+  include_subfolder('ohio')
+end

data/test/examples/united states/ohio/oregon.rb

@@ -0,0 +1,7 @@
+match 'oregon', 'or' do
+  set city: 'Oregon'
+
+  match 'pearson' do
+    set place: 'pearson park'
+  end
+end

data/test/examples/world.rb

@@ -0,0 +1,10 @@
+
+match 'canada' do
+  set country: 'Canada'
+  include_subfolder('canada')
+end
+
+match w(/u ?s ?a?/), 'united states' do
+  set country: 'United States'
+  include_subfolder('united states')
+end

data/test/hash_rules_test.rb

@@ -0,0 +1,178 @@
+# encoding: utf-8
+
+require 'test_helper'
+require 'hash_rules'
+
+class HashRulesTest < TestCase
+  context 'hashrules, normal operation' do
+
+    setup do
+      @it = HashRules.new(folder: 'test/examples')
+    end
+
+    should 'return empty array when no match' do
+      assert_equal [], @it.process('curry')
+    end
+
+    should 'identify manufacturer' do
+      data = @it.process("1986 piper tjobahobo").first['data']
+      assert_equal 'Piper', data['manufacturer']
+    end
+
+    should 'identify perfect match' do
+      data = @it.process("piper pa28 181 ii").first['data']
+      assert_equal 'PA-28-181 Archer II', data['model']
+    end
+
+    should 'identify model' do
+      data = @it.process("2001 piper pa28 181 ii").first['data']
+      assert_equal 'PA-28-181 Archer II', data['model']
+    end
+
+    should 'allow numbers or letter next to match' do
+      data = @it.process("apiperloon").first['data']
+      assert_equal "Piper", data['manufacturer']
+    end
+
+    should 'match on string' do
+      data = @it.process("piper pa 28 181").first['data']
+      assert_equal "PA-28-181", data['model']
+    end
+
+    should 'discard double whitespace' do
+      data = @it.process("piper \t\r \npa 28\n 181").first['data']
+      assert_equal "PA-28-181", data['model']
+    end
+
+    should 'use "word" to make regexes match whole words' do
+      data = @it.process("piper apa-280").first['data']
+      assert_equal nil, data['family']
+    end
+
+    should 'present us with matched slices and percentage covered' do
+      data = @it.process("i'd like a piper in the pa28 family")
+      first = data.first
+
+      assert_equal 'Piper', first['data']['manufacturer']
+      assert_equal [[24, 27], [11, 15]], first['coverage']
+      assert_equal 25, first['percent_coverage']
+    end
+
+    should 'include spaces between matches in percentage' do
+      data = @it.process("oregon canada")
+      first = data.first
+
+      assert_equal 100, first['percent_coverage']
+    end
+
+    context 'both and no' do
+      should 'make operation trees' do
+        result = @it.process('person')
+        assert_equal 'Per', result.first['data']['manufacturer']
+      end
+
+      should 'use both with strings and regexes' do
+        data = @it.process('string rregexx').first['data']
+        assert_equal 'success', data['manufacturer']
+      end
+    end
+
+
+    should 'not allow numbers or letter next to STRING match' do
+      data = @it.process("piper apa-28 18100").first['data']
+      assert_equal nil, data['model']
+    end
+
+    should 'not allow several matches in the same context' do
+      # note: the rules are written in regex /ii/ which means it will also match /iii/
+      data = @it.process('piper pa28 181 archer iii', limit: 1).first['data']
+      assert_equal 'PA-28-181 Archer II', data['model']
+    end
+
+    context "case insensitive" do
+      should 'match cyrillic letters' do
+        data = @it.process("ми 8т").first['data']
+        assert_equal "Ми-8Т", data['manufacturer']
+      end
+    end
+  end
+
+  context 'multimatch' do
+
+    setup do
+      @it = HashRules.new(folder: 'test/examples')
+    end
+
+    should 'match several if indicated' do
+      r = @it.process('this should return two match', limit: -1)
+      assert_equal 2, r.count
+      first, second = r
+
+      assert_equal 'first', first['data']['match']
+      assert_equal 'second', second['data']['match']
+    end
+  end
+
+  context 'hashrules, submatch' do
+
+    setup do
+      @it = HashRules.new(folder: 'test/examples')
+    end
+
+    should 'match with adequate information, just as without submatch' do
+      r = @it.process('oregon ohio united states').first['data']
+      assert_equal 'United States', r['country']
+      assert_equal 'Ohio', r['region']
+      assert_equal 'Oregon', r['city']
+
+      r = @it.process('canada oregon').first['data']
+      assert_equal 'Canada', r['country']
+      assert_equal 'Oregon', r['region']
+      assert_equal nil, r['city']
+    end
+
+    should 'prefer to match on 2:nd level over 3:rd level' do
+      r = @it.process('oregon', max_submatch_level: 1, limit: 1).first['data']
+
+      # united states have a city called 'oregon', but which is on 3rd level,
+      # Oregon in canada is a state, and on the 2nd level
+      assert_equal 'Canada', r['country']
+    end
+
+    should 'prefer several multimatch over a single match and many characters' do
+
+      # there is no such place as 'or us' in canada, however there is or in united states
+      r = @it.process('canada or us', max_submatch_level: 6, limit: -1)
+
+      assert_equal 3, r.count
+      assert_equal 'United States', r[0]['data']['country']
+    end
+
+    should 'strive for 100% matach if possible' do
+      r = @it.process('oregon ohio', max_submatch_level: 5, limit: -1)
+
+      assert_equal 3, r.count
+
+      # Without intelligence, Oregon (canada) would be chosen because it's a state on the 2nd level, and Oregon in US is a city on 3rd level. However, we reason that if a 3rd level match can explain more about a string then it is reasonably more likely to be accurate.
+      
+      assert_equal 'Ohio', r[0]['data']['region']
+    end
+
+    should 'backtrack coverage when found submatch' do
+      r = @it.process('pearson ohio', max_submatch_level: 6, limit: -1)
+
+      assert_equal [[0,6],[8,11]], r[0]['coverage']
+    end
+
+    should 'include matchlevel' do
+      r = @it.process('pearson ohio', max_submatch_level: 6, limit: -1)
+      assert_equal 2, r[0]['matchlevel']
+
+      r = @it.process('oregon', max_submatch_level: 6, limit: -1)
+      assert_equal 'Canada', r[0]['data']['country']
+      assert_equal 2, r[0]['matchlevel']
+      assert_equal 'United States', r[1]['data']['country']
+      assert_equal 3, r[1]['matchlevel']
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+require 'bundler/setup'
+require 'test/unit'
+require 'turn/autorun'
+require 'shoulda'
+require 'mocha'
+
+#Turn.config.format = :dot
+
+$LOAD_PATH << 'lib'
+
+class TestCase < Test::Unit::TestCase
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: hashrules
+version: !ruby/object:Gem::Version
+  version: 1.1.4
+platform: ruby
+authors:
+- Mikael Wikman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-04 00:00:00.000000000 Z
+dependencies: []
+description: Rule-based hash manipulator using custom DSL
+email:
+- mikael@swedcontent.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.mdown
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.mdown
+- Rakefile
+- app.gemspec
+- lib/hash_matcher.rb
+- lib/hash_rules.rb
+- test/examples/canada/oregon.rb
+- test/examples/cyrillic.rb
+- test/examples/match_two.rb
+- test/examples/piper.rb
+- test/examples/piper/pa28.rb
+- test/examples/united states/ohio.rb
+- test/examples/united states/ohio/oregon.rb
+- test/examples/world.rb
+- test/hash_rules_test.rb
+- test/test_helper.rb
+homepage: https://github.com/mikaelwikman/hashrules
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: ''
+test_files:
+- test/examples/canada/oregon.rb
+- test/examples/cyrillic.rb
+- test/examples/match_two.rb
+- test/examples/piper.rb
+- test/examples/piper/pa28.rb
+- test/examples/united states/ohio.rb
+- test/examples/united states/ohio/oregon.rb
+- test/examples/world.rb
+- test/hash_rules_test.rb
+- test/test_helper.rb