patm 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e616e4136344078fc78da517f68682dd2ace261
-  data.tar.gz: 759ff1f8066ad8b0f9ea3e1cd28573458b62fc5d
+  metadata.gz: d2a4036ae8e3a9b302bd189406ebb284f3efcc54
+  data.tar.gz: 10b6f6831b67755280f6e6ba5faf145a3ddf8910
 SHA512:
-  metadata.gz: 3471bde54cc18238144344e507e66a40cf116bfea3aebb3c4b6c85c18e27edb7931f0db1474f684a5dc6c1044a9a9e89c4a46f8b222e9056ed562d877658abfd
-  data.tar.gz: cb68d3f85838c99f3f39089f78f53e64f5ec8f21734c111563c18e773a17ad29388e563952185aa636b2d0fbef838ed4a4491ec42fae7c3491c2392a6fa6aa24
+  metadata.gz: 50f3198622f079bc716eb064a4e8cfbdad3f63bfd6f7c9f76c750fefd35e86301513c79542b777c5c4d7594165632acdcbb00e213661a544cc8e61fbf439ef72
+  data.tar.gz: 093665d2fcb727165d6fda3cd9c214805be766f70b15cf565ec7670aa585a21c280514687298dd2aa64558248633fbee7f815f836a9e6207c00ced7ece6e2b7e

data/README.md

@@ -102,21 +102,36 @@ end
 
 ## Patterns
 
-### `1`, `:x`, String, ...
+### Value
 
-Normal pattern matches if `pattern === value` is true.
+Value patterns such as `1, :x, String, ...` matches if `pattern === target_value` is true.
 
 ### Array
 
+`[1, 2, _any]` matches `[1, 2, 3]`, `[1, 2, :x]`, etc.
+
 `[1, 2, _xs]` matches `[1, 2]`, `[1, 2, 3]`, `[1, 2, 3, 4]`, etc.
+
 `[1, _xs, 2]` matches `[1, 2]`, `[1, 10, 2]`, etc.
 
 Note: More than one `_xs` in same array is invalid.
 
+### Hash
+
+`{a: 1}` matches `{a: 1}`, `{a: 1, b: 2}`, etc.
+
+`{a: 1, Patm.exact => true}` matches only `{a: 1}`.
+
+`{a: 1, b: Patm.opt(2)}` matches `{a: 1}`, `{a: 1, b: 2}`.
+
 ### Capture
 
 `_1`, `_2`, etc matches any value, and capture the value as correspond match group.
 
+`Pattern#[capture_name]` also used for capture.`Patm._any[:foo]` capture any value as `foo`.
+
+Captured values are accessible through `Match#_1, _2, ...` and `Match#[capture_name]`
+
 ### Compose
 
 `_1&[_any, _any]` matches any two element array, and capture the array as _1.
@@ -125,6 +140,13 @@ Note: More than one `_xs` in same array is invalid.
 
 ## Changes
 
+### 2.0.0(Unreleased)
+
+- Named capture
+- Patm::GROUPS is obsolete. Use `pattern[number_or_name]` or `Patm._1, _2, ...` instead.
+- More optimize for compiled pattern.
+- Hash patterns
+
 ### 1.0.0
 
 - DSL

data/lib/patm.rb

@@ -5,7 +5,7 @@ module Patm
       case plain
       when Pattern
         plain
-      when Array
+      when ::Array
         array = plain.map{|a| build_from(a)}
         rest_index = array.index(&:rest?)
         if rest_index
@@ -16,13 +16,47 @@ module Patm
         else
           Arr.new(array)
         end
+      when ::Hash
+        Hash.new(
+          plain.each_with_object({}) do|(k, v), h|
+            h[k] = build_from(v) if k != Patm.exact
+          end,
+          plain[Patm.exact]
+        )
       else
         Obj.new(plain)
       end
     end
 
+    module Util
+      def self.compile_value(value, free_index)
+        if value.is_a?(Numeric) || value.is_a?(String) || value.is_a?(Symbol)
+          [
+            value.inspect,
+            [],
+            free_index,
+          ]
+        else
+          [
+            "_ctx[#{free_index}]",
+            [value],
+            free_index + 1,
+          ]
+        end
+      end
+    end
+
+    # Use in Hash pattern.
+    def opt
+      Opt.new(self)
+    end
+
     def execute(match, obj); true; end
 
+    def opt?
+      false
+    end
+
     def rest?
       false
     end
@@ -31,14 +65,18 @@ module Patm
       And.new([self, rhs])
     end
 
+    def [](name)
+      self & Named.new(name)
+    end
+
     def compile
       src, context, _ = self.compile_internal(0)
 
-      Compiled.new(self.inspect, src, context)
+      Compiled.new(self.inspect, src || "true", context)
     end
 
-    # free_index:Numeric -> [src, context, free_index]
-    # variables: _ctx, _match, _obj
+    # free_index:Numeric -> target_name:String -> [src:String|nil, context:Array, free_index:Numeric]
+    # variables: _ctx, _match, (target_name)
     def compile_internal(free_index, target_name = "_obj")
       [
         "_ctx[#{free_index}].execute(_match, #{target_name})",
@@ -69,6 +107,82 @@ module Patm
       def inspect; "<compiled>#{@desc}"; end
     end
 
+    class Hash < self
+      def initialize(hash, exact)
+        @pat = hash
+        @exact = exact
+        @non_opt_count = @pat.values.count{|v| !v.opt? }
+      end
+      def execute(match, obj)
+        return false unless obj.is_a?(::Hash)
+        obj.size >= @non_opt_count &&
+          (!@exact || obj.keys.all?{|k| @pat.has_key?(k) }) &&
+          @pat.all? {|k, pat|
+            if obj.has_key?(k)
+              pat.execute(match, obj[k])
+            else
+              pat.opt?
+            end
+          }
+      end
+      def inspect; @pat.inspect; end
+      def compile_internal(free_index, target_name = "_obj")
+        i = free_index
+        ctxs = []
+        src = []
+
+        ctxs << [@pat]
+        i += 1
+
+        pat = "_ctx[#{free_index}]"
+        src << "#{target_name}.is_a?(::Hash)"
+        src << "#{target_name}.size >= #{@non_opt_count}"
+        if @exact
+          src << "#{target_name}.keys.all?{|k| #{pat}.has_key?(k) }"
+        end
+        tname = "#{target_name}_elm"
+        @pat.each do|k, v|
+          key_src, c, i = Util.compile_value(k, i)
+          ctxs << c
+          s, c, i = v.compile_internal(i, tname)
+          body =
+            if s
+              "(#{tname} = #{target_name}[#{key_src}]; #{s})"
+            else
+              "true"
+            end
+          src <<
+            if v.opt?
+              "(!#{target_name}.has_key?(#{key_src}) || #{body})"
+            else
+              "(#{target_name}.has_key?(#{key_src}) && #{body})"
+            end
+          ctxs << c
+        end
+        [
+          src.join(" &&\n"),
+          ctxs.flatten(1),
+          i,
+        ]
+      end
+    end
+
+    class Opt < self
+      def initialize(pat)
+        @pat = pat
+      end
+      def opt?
+        true
+      end
+      def execute(match, obj)
+        @pat.execute(match, obj)
+      end
+      def inspect; "?#{@pat.inspect}"; end
+      def compile_internal(free_index, target_name = "_obj")
+        @pat.compile_internal(free_index, target_name)
+      end
+    end
+
     class Arr < self
       def initialize(head, rest = nil, tail = [])
         @head = head
@@ -114,26 +228,28 @@ module Patm
         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})"
+          srcs << "(#{elm_target_name} = #{target_name}[#{hi}]; #{s})" if 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
+        unless @tail.empty?
+          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})" if s
+            ctxs << c
+          end
         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})"
+          srcs << "(#{tname} = #{target_name}[#{@head.size}..-(#{@tail.size+1})];#{s})" if s
           ctxs << c
         end
 
         [
-          srcs.map{|s| "(#{s})"}.join(" &&\n"),
+          srcs.compact.map{|s| "(#{s})"}.join(" &&\n"),
           ctxs.flatten(1),
           i
         ]
@@ -150,7 +266,7 @@ module Patm
       def inspect; "..."; end
       def compile_internal(free_index, target_name = "_obj")
         [
-          "true",
+          nil,
           [],
           free_index
         ]
@@ -171,10 +287,11 @@ module Patm
       end
 
       def compile_internal(free_index, target_name = "_obj")
+        val_src, c, i = Util.compile_value(@obj, free_index)
         [
-          "_ctx[#{free_index}] === #{target_name}",
-          [@obj],
-          free_index + 1,
+          "#{val_src} === #{target_name}",
+          c,
+          i
         ]
       end
     end
@@ -184,26 +301,28 @@ module Patm
       def inspect; 'ANY'; end
       def compile_internal(free_index, target_name = "_obj")
         [
-          "true",
+          nil,
           [],
           free_index
         ]
       end
     end
 
-    class Group < self
-      def initialize(index)
-        @index = index
+    class Named < self
+      def initialize(name)
+        raise ::ArgumentError unless name.is_a?(Symbol) || name.is_a?(Numeric)
+        @name = name
       end
-      attr_reader :index
-      def execute(mmatch, obj)
-        mmatch[@index] = obj
+      attr_reader :name
+      alias index name # compatibility
+      def execute(match, obj)
+        match[@name] = obj
         true
       end
-      def inspect; "GROUP(#{@index})"; end
+      def inspect; "NAMED(#{@name})"; end
       def compile_internal(free_index, target_name = "_obj")
         [
-          "_match[#{@index}] = #{target_name}; true",
+          "_match[#{@name.inspect}] = #{target_name}; true",
           [],
           free_index
         ]
@@ -226,11 +345,17 @@ module Patm
         end
 
         [
-          srcs.map{|s| "(#{s})" }.join(" #{@op_str}\n"),
+          srcs.compact.map{|s| "(#{s})" }.join(" #{@op_str}\n"),
           ctxs.flatten(1),
           i
         ]
       end
+      def rest?
+        @pats.any?(&:rest?)
+      end
+      def opt?
+        @pats.any?(&:opt?)
+      end
     end
 
     class Or < LogicalOp
@@ -242,9 +367,6 @@ module Patm
           pat.execute(mmatch, obj)
         end
       end
-      def rest?
-        @pats.any?(&:rest?)
-      end
       def inspect
         "OR(#{@pats.map(&:inspect).join(',')})"
       end
@@ -259,17 +381,12 @@ module Patm
           pat.execute(mmatch, obj)
         end
       end
-      def rest?
-        @pats.any?(&:rest?)
-      end
       def inspect
         "AND(#{@pats.map(&:inspect).join(',')})"
       end
     end
   end
 
-  GROUP = 100.times.map{|i| Pattern::Group.new(i) }
-
   def self.or(*pats)
     Pattern::Or.new(pats.map{|p| Pattern.build_from(p) })
   end
@@ -282,10 +399,28 @@ module Patm
     @xs = Pattern::ArrRest.new
   end
 
+  # Use in hash value.
+  # Mark this pattern is optional.
+  def self.opt(pat = _any)
+    Pattern::Opt.new(Pattern.build_from(pat))
+  end
+
+  EXACT = Object.new
+  def EXACT.inspect
+    "EXACT"
+  end
+  # Use in Hash key.
+  # Specify exact match or not.
+  def self.exact
+    EXACT
+  end
+
+  PREDEF_GROUP_SIZE = 100
+
   class <<self
-    GROUP.each do|g|
-      define_method "_#{g.index}" do
-        g
+    PREDEF_GROUP_SIZE.times do|i|
+      define_method "_#{i}" do
+        Pattern::Named.new(i)
       end
     end
   end
@@ -349,9 +484,9 @@ module Patm
       @group[i] = val
     end
 
-    Patm::GROUP.each do|g|
-      define_method "_#{g.index}" do
-        self[g.index]
+    PREDEF_GROUP_SIZE.times.each do|i|
+      define_method "_#{i}" do
+        self[i]
       end
     end
   end
@@ -367,9 +502,9 @@ module Patm
     end
 
     def [](i); @match[i]; end
-    Patm::GROUP.each do|g|
-      define_method "_#{g.index}" do
-        @match[g.index]
+    PREDEF_GROUP_SIZE.times do|i|
+      define_method "_#{i}" do
+        @match[i]
       end
     end
   end

data/patm.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.name        = 'patm'
-  s.version     = '1.0.0'
+  s.version     = '2.0.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

@@ -24,14 +24,20 @@ module PatmHelper
 
     def and_capture(g1, g2 = nil, g3 = nil, g4 = nil)
       these_matches(
-        self, _capture(self, g1, g2, g3, g4)
+        self, _capture(self, {1 => g1, 2 => g2, 3 => g3, 4 => g4})
+      )
+    end
+
+    def and_named_capture(capture)
+      these_matches(
+        self, _capture(self, capture)
       )
     end
   end
 
-  matcher :_capture do|m, g1, g2, g3, g4|
+  matcher :_capture do|m, capture|
     match do|_|
-      [m.match[1], m.match[2], m.match[3], m.match[4]] == [g1, g2, g3, g4]
+      [m.match[1], m.match[2], m.match[3], m.match[4]] == capture.values_at(1,2,3,4)
     end
   end
 
@@ -206,9 +212,9 @@ describe Patm::Pattern do
     it { should match_to([0, 1, 2, 3]).and_capture([2, 3]) }
   end
 
-  pattern [0, 1, Patm._xs, 2] do
-    it { should match_to([0,1,2]) }
-    it { should match_to([0,1,10,20,30,2]) }
+  pattern [0, 1, Patm._xs[1], 2] do
+    it { should match_to([0,1,2]).and_capture([]) }
+    it { should match_to([0,1,10,20,30,2]).and_capture([10,20,30]) }
     it { should_not match_to([0,1]) }
   end
 
@@ -217,6 +223,45 @@ describe Patm::Pattern do
     it { should_not match_to [0, [1, 3]] }
   end
 
+  pattern Patm._any[:x] do
+    it { should match_to("aaa").and_named_capture(:x => "aaa") }
+  end
+
+  pattern(a: Patm._any[1]) do
+    it { should_not match_to {} }
+    it { should match_to(a: 1).and_capture(1) }
+    it { should match_to(a: 1, b: 2).and_capture(1) }
+  end
+
+  pattern(a: Patm._any, Patm.exact => false) do
+    it { should_not match_to(b: 1) }
+    it { should     match_to(a: 1) }
+    it { should     match_to(a: 1, b: 2) }
+  end
+
+  pattern(a: Patm._any, Patm.exact => true) do
+    it { should_not match_to(b: 1) }
+    it { should     match_to(a: 1) }
+    it { should_not match_to(a: 1, b: 2) }
+  end
+
+  pattern(a: Patm._any[1].opt) do
+    it { should match_to({}).and_capture(nil) }
+    it { should match_to({a: 1}).and_capture(1) }
+  end
+
+  pattern(a: Patm._any[1], b: Patm._any[2].opt) do
+    it { should_not match_to({}) }
+    it { should     match_to({a: 1}).and_capture(1, nil) }
+    it { should     match_to({a: 1, b: 2}).and_capture(1, 2) }
+  end
+
+  pattern({a: 1} => {b: 2}) do
+    it { should_not match_to({a: 1} => {b: 0}) }
+    it { should_not match_to({a: 0} => {b: 2}) }
+    it { should     match_to({a: 1} => {b: 2}) }
+  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) }
@@ -225,5 +270,9 @@ describe Patm::Pattern do
       it { should match_to [1] }
       it { should match_to [2] }
     end
+    pattern [Patm._1, 2, [Patm._any, 3], Patm._xs[1], 4] do
+      it { should match_to([1, 2, [10, 3], 4]).and_capture([]) }
+      it { should match_to([1, 2, [10, 3], 20, 4]).and_capture([20]) }
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: patm
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - todesking
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-26 00:00:00.000000000 Z
+date: 2014-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -72,7 +72,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: PATtern Matching library