patm 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1adf094454c70d6f4147b4c44e134a0204274e6c
-  data.tar.gz: 93e09c5195a23d9dfd2ac2e317841c4a6cb80afc
+  metadata.gz: a6f5f8bcb3f5f3031bac6f117418b1d3bc917e8a
+  data.tar.gz: 56f203d9076b6905894ffb752954c7caa41fcca6
 SHA512:
-  metadata.gz: 80ada62d20ae8926cf97f27c120e70896e3f0d916e38058221afa60967b5a6701cb2ca8d1dd35c8807d104f616bddc62bd032f64e27857d67c2821e5a7aae2a9
-  data.tar.gz: 824f33ef73d6561932e620ca7e657c74ad2767301b32ede0c47677fc4a50010277a603e419b17967273d86320288e9a08788c47595ed3179f332c6d9cddeb09c
+  metadata.gz: 7f01fa35d647fea7658029071682a77dea11e7da92968087c383028f13476ba7a7745a7f04093457c1a45beb92bc1328fab4c9feb464f55550ef3df08b38bb40
+  data.tar.gz: 9ac471509e902916d52693fc7fe0bac69fb84106b8a539bcbd1f6a6657c34150e6214e73d0555b28c32ac6038bbdfaa7f40073160327ac024a9be16c2d7d1bdd

data/.gitignore

@@ -1 +1,2 @@
 Gemfile.lock
+*.gem

data/README.md

@@ -79,6 +79,11 @@ end
 
 ## Changes
 
+### 0.1.0
+
+- Faster matching with pattern compilation
+- Fix StackOverflow bug for `[Patm.or()]`
+
 ### 0.0.1
 
 - Initial release

data/benchmark/benchmark.rb

@@ -0,0 +1,99 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'patm.rb')
+require 'benchmark'
+
+P = Patm
+
+def match_with_case(obj)
+  _1 = P._1
+  _2 = P._2
+  _3 = P._3
+  _4 = P._4
+  _xs = P::ARRAY_REST
+
+  case obj
+  when m = P.match([:assign, [:var_field, [:@ident, _1, [_2, _3]]], _4])
+    :as
+  when m = P.match([:massign, _1, _2])
+    :mas
+  when m = P.match([:var_ref, [:@ident, _1, [_2, _3]]])
+    :vr
+  when m = P.match([:params, _1, _2, _3, _xs])
+    :par
+  when m = P.match(P.or(nil, true, false, Numeric, String, Symbol, []))
+    :ignore
+  else
+    :else
+  end
+end
+
+@ruledef = lambda do|r|
+  _1 = P._1
+  _2 = P._2
+  _3 = P._3
+  _4 = P._4
+  _xs = P::ARRAY_REST
+
+  r.on [:assign, [:var_field, [:@ident, _1, [_2, _3]]], _4] do|m|
+    :as
+  end
+  r.on [:massign, _1, _2] do|m|
+    :mas
+  end
+  r.on [:var_ref, [:@ident, _1, [_2, _3]]] do|m|
+    :vr
+  end
+  r.on [:params, _1, _2, _3, _xs] do|m|
+    :par
+  end
+  r.on P.or(nil, true, false, Numeric, String, Symbol, []) do|m|
+    :ignore
+  end
+  r.else do|obj|
+    :else
+  end
+end
+
+@rule = P::Rule.new(&@ruledef)
+@compiled_rule = P::Rule.new(true, &@ruledef)
+
+def match_with_rule(obj)
+  @rule.apply(obj)
+end
+
+def match_with_compiled_rule(obj)
+  @compiled_rule.apply(obj)
+end
+
+
+VALUES = [
+  [ [:assign, [:var_field, [:@ident, 10, [20, 30]]], false], :as ],
+  [ [:massign, 1, 2], :mas],
+  [ [:var_ref, [:@ident, "x", [1, 2]]], :vr ],
+  [ [:params, 10, 20, 30, 40, 50, 60, 70, 80], :par ],
+  [ nil, :ignore ],
+  [ 100, :ignore ],
+  [ [1,2,3], :else],
+]
+
+
+def bm(&b)
+  10000.times do
+    VALUES.each do|obj, expected|
+      actual = b.call obj
+      raise "e:#{expected.inspect} a:#{actual.inspect}" unless actual == expected
+    end
+  end
+end
+
+Benchmark.bm(15) do|b|
+  b.report("case-when") { bm {|obj| match_with_case(obj) } }
+  b.report("rule") { bm {|obj| match_with_rule(obj) } }
+  b.report("compiled-rule") { bm {|obj| match_with_compiled_rule(obj) } }
+end
+
+
+# [:assign, [:var_field, [:@ident, _1, [_2, _3]]], _4] do|m|
+# [:massign, _1, _2] do|m|
+# [:var_ref, [:@ident, _1, [_2, _3]]] do|m|
+# [:params, _1, _2, _3, _xs] do|m|
+# p.or(nil, true, false, Numeric, String, Symbol, []) do|m|

data/lib/patm.rb

@@ -11,20 +11,67 @@ module Patm
       when Pattern
         plain
       when Array
-        if plain.last.is_a?(Pattern) && plain.last.rest?
-          Arr.new(plain[0..-2].map{|p| build_from(p) }, plain.last)
-        else
-          Arr.new(plain.map{|p| build_from(p) })
-        end
+        build_from_array(plain)
       else
         Obj.new(plain)
       end
     end
 
+    def self.build_from_array(array)
+      array = array.map{|a| build_from(a)}
+      rest_index = array.index(&:rest?)
+      if rest_index
+        head = array[0...rest_index]
+        rest = array[rest_index]
+        tail = array[(rest_index+1)..-1]
+        Arr.new(head, rest, tail)
+      else
+        Arr.new(array)
+      end
+    end
+
     def &(rhs)
       And.new([self, rhs])
     end
 
+    def compile
+      src, context, _ = self.compile_internal(0)
+
+      Compiled.new(self.inspect, src, context)
+    end
+
+    # free_index:Numeric -> [src, context, free_index]
+    # variables: _ctx, _match, _obj
+    def compile_internal(free_index, target_name = "_obj")
+      [
+        "_ctx[#{free_index}].execute(_match, #{target_name})",
+        [self],
+        free_index + 1
+      ]
+    end
+
+    class Compiled < self
+      def initialize(desc, src, context)
+        @desc = desc
+        @context = context
+        singleton_class = class <<self; self; end
+        @src = <<-RUBY
+        def execute(_match, _obj)
+          _ctx = @context
+#{src}
+        end
+        RUBY
+        singleton_class.class_eval(@src)
+      end
+
+      attr_reader :src
+
+      def compile_internal(free_index, target_name = "_obj")
+        raise "Already compiled"
+      end
+      def inspect; "<compiled>#{@desc}"; end
+    end
+
     class Arr < self
       def initialize(head, rest = nil, tail = [])
         @head = head
@@ -45,7 +92,55 @@ module Patm
         (!@rest || @rest.execute(mmatch, obj[@head.size..-(@tail.size+1)]))
       end
 
-      def inspect; (@head + [@rest] + @tail).inspect; end
+      def inspect
+        if @rest
+          (@head + [@rest] + @tail).inspect
+        else
+          (@head + @tail).inspect
+        end
+      end
+
+      def compile_internal(free_index, target_name = "_obj")
+        i = free_index
+        srcs = []
+        ctxs = []
+
+        srcs << "#{target_name}.is_a?(::Array)"
+
+        size_min = @head.size + @tail.size
+        if @rest
+          srcs << "#{target_name}.size >= #{size_min}"
+        else
+          srcs << "#{target_name}.size == #{size_min}"
+        end
+
+        elm_target_name = "#{target_name}_elm"
+        @head.each_with_index do|h, hi|
+          s, c, i = h.compile_internal(i, elm_target_name)
+          srcs << "(#{elm_target_name} = #{target_name}[#{hi}]; #{s})"
+          ctxs << c
+        end
+
+        srcs << "(#{target_name}_t = #{target_name}[(-#{@tail.size})..-1]; true)"
+        @tail.each_with_index do|t, ti|
+          s, c, i = t.compile_internal(i, elm_target_name)
+          srcs << "(#{elm_target_name} = #{target_name}_t[#{ti}]; #{s})"
+          ctxs << c
+        end
+
+        if @rest
+          tname = "#{target_name}_r"
+          s, c, i = @rest.compile_internal(i, tname)
+          srcs << "(#{tname} = #{target_name}[#{@head.size}..-(#{@tail.size+1})];#{s})"
+          ctxs << c
+        end
+
+        [
+          srcs.map{|s| "(#{s})"}.join(" &&\n"),
+          ctxs.flatten(1),
+          i
+        ]
+      end
     end
 
     class ArrRest < self
@@ -56,6 +151,13 @@ module Patm
         true
       end
       def inspect; "..."; end
+      def compile_internal(free_index, target_name = "_obj")
+        [
+          "true",
+          [],
+          free_index
+        ]
+      end
     end
 
     class Obj < self
@@ -70,11 +172,26 @@ module Patm
       def inspect
         "OBJ(#{@obj.inspect})"
       end
+
+      def compile_internal(free_index, target_name = "_obj")
+        [
+          "_ctx[#{free_index}] === #{target_name}",
+          [@obj],
+          free_index + 1,
+        ]
+      end
     end
 
     class Any < self
       def execute(match, obj); true; end
       def inspect; 'ANY'; end
+      def compile_internal(free_index, target_name = "_obj")
+        [
+          "true",
+          [],
+          free_index
+        ]
+      end
     end
 
     class Group < self
@@ -87,11 +204,41 @@ module Patm
         true
       end
       def inspect; "GROUP(#{@index})"; end
+      def compile_internal(free_index, target_name = "_obj")
+        [
+          "_match[#{@index}] = #{target_name}; true",
+          [],
+          free_index
+        ]
+      end
     end
 
-    class Or < self
-      def initialize(pats)
+    class LogicalOp < self
+      def initialize(pats, op_str)
         @pats = pats
+        @op_str = op_str
+      end
+      def compile_internal(free_index, target_name = "_obj")
+        srcs = []
+        i = free_index
+        ctxs = []
+        @pats.each do|pat|
+          s, c, i = pat.compile_internal(i, target_name)
+          srcs << s
+          ctxs << c
+        end
+
+        [
+          srcs.map{|s| "(#{s})" }.join(" #{@op_str}\n"),
+          ctxs.flatten(1),
+          i
+        ]
+      end
+    end
+
+    class Or < LogicalOp
+      def initialize(pats)
+        super(pats, '||')
       end
       def execute(mmatch, obj)
         @pats.any? do|pat|
@@ -99,16 +246,16 @@ module Patm
         end
       end
       def rest?
-        @pats.any?(&rest?)
+        @pats.any?(&:rest?)
       end
       def inspect
         "OR(#{@pats.map(&:inspect).join(',')})"
       end
     end
 
-    class And <self
+    class And < LogicalOp
       def initialize(pats)
-        @pats = pats
+        super(pats, '&&')
       end
       def execute(mmatch, obj)
         @pats.all? do|pat|
@@ -129,18 +276,27 @@ module Patm
   ARRAY_REST = Pattern::ArrRest.new
 
   class Rule
-    def initialize(&block)
+    def initialize(compile = false, &block)
+      @compile = compile
       # { Pattern => Proc }
       @rules = []
       block[self]
     end
 
     def on(pat, &block)
-      @rules << [Pattern.build_from(pat), block]
+      if @compile
+        @rules << [Pattern.build_from(pat).compile, block]
+      else
+        @rules << [Pattern.build_from(pat), block]
+      end
     end
 
     def else(&block)
-      @rules << [ANY, lambda {|m,o| block[o] }]
+      if @compile
+        @rules << [ANY.compile, lambda {|m,o| block[o] }]
+      else
+        @rules << [ANY, lambda {|m,o| block[o] }]
+      end
     end
 
     def apply(obj)
@@ -155,11 +311,12 @@ module Patm
   end
 
   class RuleCache
-    def initialize
+    def initialize(compile = false)
+      @compile = compile
       @rules = {}
     end
     def match(rule_name, obj, &rule)
-      (@rules[rule_name] ||= ::Patm::Rule.new(&rule)).apply(obj)
+      (@rules[rule_name] ||= ::Patm::Rule.new(@compile, &rule)).apply(obj)
     end
   end
 
@@ -206,6 +363,7 @@ module Patm
   end
 
   def self.match_array(head, rest_spat = nil, tail = [])
+    # TODO: deprecated
     Match.new(
       Pattern::Arr.new(
         head.map{|e| Pattern.build_from(e)},

data/patm.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.name        = 'patm'
-  s.version     = '0.0.1'
+  s.version     = '0.1.0'
   s.summary     = 'PATtern Matching library'
   s.description = 'Pattern matching library for plain data structure'
   s.required_ruby_version = '>= 1.9.0'

data/spec/patm_spec.rb

@@ -22,16 +22,16 @@ module PatmHelper
 
     def match; @match; end
 
-    def and_capture(g1, g2 = nil, g3 = nil)
+    def and_capture(g1, g2 = nil, g3 = nil, g4 = nil)
       these_matches(
-        self, _capture(self, g1, g2, g3)
+        self, _capture(self, g1, g2, g3, g4)
       )
     end
   end
 
-  matcher :_capture do|m, g1, g2, g3|
+  matcher :_capture do|m, g1, g2, g3, g4|
     match do|_|
-      [m.match[1], m.match[2], m.match[3]] == [g1, g2, g3]
+      [m.match[1], m.match[2], m.match[3], m.match[4]] == [g1, g2, g3, g4]
     end
   end
 
@@ -60,6 +60,17 @@ describe "Usage:" do
     r.apply([1, 2, 3]).should == [2, 3]
   end
 
+  it 'with predefined Rule(compiled)' do
+    p = Patm
+    r = p::Rule.new(true) do|r|
+      r.on [1, p._1, p._2] do|m|
+        [m._1, m._2]
+      end
+      r.else {|obj| [] }
+    end
+    r.apply([1, 2, 3]).should == [2, 3]
+  end
+
   it 'with RuleCache' do
     p = Patm
     rs = p::RuleCache.new
@@ -74,6 +85,21 @@ describe "Usage:" do
 
     rs.match(:pattern_1, [1, 3, 5]) {|r| fail "should not reach here" }.should == [3, 5]
   end
+
+  it 'with RuleCache(compiled)' do
+    p = Patm
+    rs = p::RuleCache.new(true)
+
+    rs.match(:pattern_1, [1, 2, 3]) do|r|
+      r.on [1, p._1, p._2] do|m|
+        [m._1, m._2]
+      end
+      r.else {|obj| [] }
+    end
+      .should == [2, 3]
+
+    rs.match(:pattern_1, [1, 3, 5]) {|r| fail "should not reach here" }.should == [3, 5]
+  end
 end
 
 describe Patm::Pattern do
@@ -83,6 +109,10 @@ describe Patm::Pattern do
       subject { Patm::Pattern.build_from(plain) }
       instance_eval(&b)
     end
+    context "pattern '#{plain.inspect}'(Compiled)" do
+      subject { Patm::Pattern.build_from(plain).compile }
+      instance_eval(&b)
+    end
   end
 
   pattern 1 do
@@ -125,6 +155,10 @@ describe Patm::Pattern do
     it { should match_to('x').and_capture('x') }
   end
 
+  pattern Patm._1 & Patm._2 do
+    it { should match_to(1).and_capture(1, 1) }
+  end
+
   pattern [0, Patm._1, Patm._2] do
     it { should match_to([0, 1, 2]).and_capture(1, 2) }
     it { should_not match_to(['x', 1, 2]).and_capture(1, 2) }
@@ -140,4 +174,25 @@ describe Patm::Pattern do
     it { should match_to([0, 1]).and_capture([]) }
     it { should match_to([0, 1, 2, 3]).and_capture([2, 3]) }
   end
+
+  pattern [0, 1, Patm::ARRAY_REST, 2] do
+    it { should match_to([0,1,2]) }
+    it { should match_to([0,1,10,20,30,2]) }
+    it { should_not match_to([0,1]) }
+  end
+
+  pattern [0, [1, 2]] do
+    it { should match_to [0, [1, 2]] }
+    it { should_not match_to [0, [1, 3]] }
+  end
+
+  context 'regression' do
+    pattern [:assign, [:var_field, [:@ident, Patm._1, [Patm._2, Patm._3]]], Patm._4] do
+      it { should match_to([:assign, [:var_field, [:@ident, 10, [20, 30]]], false]).and_capture(10, 20, 30, false) }
+    end
+    pattern [Patm.or(1, 2)] do
+      it { should match_to [1] }
+      it { should match_to [2] }
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: patm
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - todesking
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-24 00:00:00.000000000 Z
+date: 2014-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -48,6 +48,7 @@ files:
 - Gemfile
 - LICENSE
 - README.md
+- benchmark/benchmark.rb
 - lib/patm.rb
 - patm.gemspec
 - spec/patm_spec.rb
@@ -71,7 +72,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: PATtern Matching library