patrun 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 26be7b15694fcdb3af30b2cf505e1f5446e75094
+  data.tar.gz: 8d6c257f618b6c0acdbfa7ff47a2cb02c0225014
+SHA512:
+  metadata.gz: e08f11b282afa711d2b25cff516780804d1647cb0b51960edcca2768ddefc289647f401b36839f17e9b0c4ad9c5e116219beb2eaacf3c8627e1bae572fa2b2e4
+  data.tar.gz: f4903d54e56315f32e43964d746d07a1b5c7ce45f2954286f1f285128268369dfeb0770ec22530a6256c35d8531551a1b09406a345ff257e3c6b7d5f3589dd2b

data/lib/patrun.rb

@@ -0,0 +1,406 @@
+class Patrun
+  def initialize(custom = nil)
+    @top = {}
+    @custom = custom
+  end
+
+
+  def add(pat, data)
+
+    customizer = nil
+    if @custom
+      customizer = @custom.call(self, pat, data)
+    end
+
+    pat = pat.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+    keys = pat.keys.sort()
+
+    keymap = @top
+    valmap = nil
+
+    i = 0
+    while i < keys.length
+      key = keys[i]
+      val = pat[keys[i]]
+
+      if nil == val
+        next
+      end
+
+      valmap = keymap[:v]
+      if valmap && key == keymap[:k]
+        keymap = valmap[val] || (valmap[val] = {})
+
+      elsif !keymap[:k]
+        keymap[:k] = key
+
+        keymap[:v] = {}
+
+        keymap = keymap[:v][val] = {}
+
+      else
+        if key < keymap[:k]
+          curv = keymap[:v]
+          curs   = keymap[:s]
+          keymap[:v] = {}
+          keymap[:s] = {:k => keymap[:k], :v => curv, :s => curs}
+
+          keymap[:k] = key
+          keymap = keymap[:v][val] = {}
+        else
+          valmap = keymap[:v]
+          keymap = keymap[:s] || (keymap[:s] = {})
+          i-= 1
+        end
+      end
+      i += 1
+    end
+
+    if data != nil && keymap
+      keymap[:d] = data
+      if customizer
+        keymap[:f] = isFunction(customizer) ? customizer : (customizer.class == Hash ? customizer[:find] :  false)
+        if (customizer.class == Hash)
+          keymap[:r] = isFunction(customizer[:remove]) ? customizer[:remove] : nil
+        end
+      end
+    end
+
+    self
+  end
+
+
+
+  def findexact(pat)
+    find(pat, true)
+  end
+
+  def find(pat, exact = false)
+
+    pat = pat.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+    if nil == pat
+      return nil
+    end
+
+    keymap    = @top
+    data      = @top[:d] || nil
+    finalfind = @top[:f]
+    key       = nil
+    stars     = []
+    foundkeys = {}
+    patlen    = pat.keys.length
+
+
+    loop do
+      key = keymap[:k]
+
+      if keymap[:v]
+        nextkeymap = keymap[:v][pat[key]]
+        if nextkeymap
+          foundkeys[key] = true
+
+          if keymap[:s]
+            stars.push(keymap[:s])
+          end
+
+          data      = nil == nextkeymap[:d] ? nil : nextkeymap[:d]
+          finalfind = nextkeymap[:f]
+          keymap    = nextkeymap
+
+        else
+          keymap = keymap[:s]
+        end
+
+      else
+        keymap = nil
+      end
+
+      if nil == keymap && nil == data && 0 < stars.length
+        keymap = stars.pop()
+      end
+
+      break if !keymap
+    end
+
+    # special case for default with no properties
+    if nil == data && 0 == patlen && nil != top[:d]
+      data      = top[:d]
+      finalfind = top[:f]
+    end
+
+    if exact && foundkeys.keys.length != patlen
+      data = nil
+    end
+
+    if finalfind
+      data = finalfind.call(self, pat, data)
+    end
+
+    data
+  end
+
+  def remove(pat)
+    keymap = @top
+    data = nil
+    key = nil
+    path = []
+
+    loop do
+      key = keymap[:k]
+
+      if keymap[:v]
+        nextkeymap = keymap[:v][pat[key]]
+        if nextkeymap
+          path.push({:km => keymap,:v => pat[key]})
+          data   = nextkeymap[:d]
+          keymap = nextkeymap
+
+        else
+          keymap = keymap[:s]
+        end
+
+      else
+        keymap = nil
+      end
+
+      break if !keymap
+    end
+
+    if nil != data
+      part = path[path.length-1]
+      if part && part[:km] && part[:km][:v]
+        point = part[:km][:v][part[:v]]
+        if !point[:r] || point[:r].call(self, pat, point[:d])
+          point.delete(:d)
+        end
+      end
+    end
+  end
+
+
+
+
+  # values can be verbatim, glob, or array of globs
+  def list(pat = nil, exact = false)
+
+    acc = []
+
+    if @top[:d]
+
+      acc.push({:match => {},
+                :data => @top[:d],
+                :find => top[:f]
+      })
+    end
+
+    if pat != nil
+      pat = pat.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+    end
+    descend(pat, exact, @top, {}, merge({}, pat), acc)
+
+
+    acc
+  end
+
+
+  def toString(dstr = nil, tree = false)
+    defaultFormat = Proc.new { | d |
+      isFunction(d) ? "<#{d}>" : "<#{d}>"
+    }
+
+    tree = isBoolean(dstr) ? dstr : tree
+    tree = nil == tree ? false : tree
+
+    dstr = isFunction(dstr) ? dstr : defaultFormat
+
+    str = []
+    o = []
+
+    walk(@top,o,0,[], str, dstr)
+
+    return tree ? o.join('') : str.join("\n")
+  end
+
+
+  def inspect
+    this.toString()
+  end
+
+
+  def toJSON(indent)
+
+    @top.to_json()
+
+  end
+
+  private
+
+
+
+  def indent(o,d)
+    for i in 0..d
+      o.push(' ')
+    end
+  end
+
+
+  def descend(pat, exact, keymap, match, missing, acc)
+
+    if keymap[:v]
+      key = keymap[:k]
+      patVal = pat ? (nil == pat[key] ? ( exact ? nil : '*' ) : pat[key]) : '*'
+
+      itermatch   = merge({}, match)
+      itermissing = merge({}, missing)
+      nextkeymap = nil
+
+
+      for val in keymap[:v].keys
+
+        if gexval(patVal, val)
+
+          valitermatch = deepCopy(itermatch)
+          valitermatch[key] = val
+
+          valitermissing = merge({}, itermissing)
+          valitermissing.delete(key)
+
+          nextkeymap = keymap[:v][val]
+
+          if 0 == valitermissing.keys.length &&
+            nextkeymap &&
+            nextkeymap[:d]
+
+            acc.push({
+              :match => valitermatch,
+              :data => nextkeymap[:d],
+              :find => nextkeymap[:f]
+            })
+          end
+
+          if nextkeymap && nextkeymap[:v]
+
+            descend(pat, exact,
+              nextkeymap,
+              merge({}, valitermatch),
+              merge({}, valitermissing),
+              acc)
+          end
+        end
+      end
+
+      nextkeymap = keymap[:s]
+      if nextkeymap
+        descend(pat, exact,
+          nextkeymap,
+          merge({}, itermatch),
+          merge({}, itermissing),
+          acc)
+      end
+    end
+  end
+
+  def walk(n,o,counter,vs,str, dstr)
+
+    if nil != n[:d]
+      indent(o,counter)
+      o.push(dstr.call(n[:d]))
+
+      str.push("#{vs.join(', ')} -> #{dstr.call(n[:d])}")
+    end
+
+    if n[:k]
+      o.push("\n")
+      indent(o,counter)
+      o.push("#{n[:k]}:")
+    end
+
+    if n[:v]
+      counter =+ 1
+      for p in n[:v].keys
+        o.push("\n")
+        indent(o,counter)
+        o.push("#{p} ->")
+
+        vsc = deepCopy(vs)
+        vsc.push("#{n[:k]}=#{p}")
+
+        walk(n[:v][p],o,counter + 1,vsc,str,dstr)
+      end
+
+      if n[:s]
+        o.push("\n")
+        indent(o,counter)
+        o.push('* ->')
+
+        vsc = deepCopy(vs)
+        walk(n[:s],o,counter + 1,vsc,str,dstr)
+      end
+    end
+  end
+
+
+  def isBoolean(obj)
+
+    if obj != nil && obj.class == TrueClass || obj.class == FalseClass
+
+      true
+    else
+      false
+    end
+  end
+
+  def deepCopy(o)
+    Marshal.load(Marshal.dump(o))
+  end
+
+  def isFunction(param)
+    if param != nil && param.class == Proc
+      true
+    else
+      false
+    end
+  end
+
+  def merge(source, destination)
+    if destination != nil
+      source.merge(destination)
+    else
+      source
+    end
+  end
+
+  def gexval(pattern, value)
+
+
+    pattern = escregexp(pattern)
+
+    # use [\s\S] instead of . to match newlines
+    pattern = pattern.gsub(/\\\*/,'[\\s\\S]*')
+    pattern = pattern.gsub(/\\\?/,'[\\s\\S]')
+
+    # escapes ** and *?
+    pattern = pattern.gsub(/\[\\s\\S\]\*\[\\s\\S\]\*/,'\\\*')
+    pattern = pattern.gsub(/\[\\s\\S\]\*\[\\s\\S\]/,'\\\?')
+
+    pattern = "^#{pattern}$"
+
+    if value.to_s.match(pattern) != nil
+      true
+    else
+      false
+    end
+
+  end
+
+  def escregexp(restr)
+    if restr
+      restr.to_s.gsub(/[-\[\]{}()*+?.,\\^$|#\s]/) { "\\#{$&}" }
+    else
+      ""
+    end
+  end
+
+end

metadata

@@ -0,0 +1,44 @@
+--- !ruby/object:Gem::Specification
+name: patrun
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Colm Harte
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-17 00:00:00.000000000 Z
+dependencies: []
+description: A fast pattern matcher on Ruby object properties.
+email: colm.harte@nearform.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/patrun.rb
+homepage: http://rubygems.org/gems/patrun
+licenses:
+- MIT
+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.14
+signing_key: 
+specification_version: 4
+summary: Fast pattern matcher
+test_files: []