patm 3.0.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7dfd622177fbff6949aeba6e0ea9a37c503ca13e
-  data.tar.gz: 49e7f41b2e40d4fa9724eb607340b6196a41ef0c
+  metadata.gz: fce015f4cd31a8ee0eb2227373c6e809302411ed
+  data.tar.gz: 7000cb5f66f204896bf207e8fee63a9f07387e60
 SHA512:
-  metadata.gz: 7a0dd73809aadf15e43dab4c93cd857f38bf3bdb0666525f4791f117e415d0123df8dd90d0f66880362669efbaad2bfd3c0ecf82a17c2929c620711e6b773655
-  data.tar.gz: 379c2300a12acd9662f5abffa284dc6ffc1854f027d5ca9a8e92e5bafb9a497581054a39998334c965bb21cd4e872035ff7e88471ee00983e4468f47421cc87b
+  metadata.gz: 778234a77d4bf3e4cbc1f3132e29f55ac1dad6f4fb5738f0d7da1145f3f8b4a1bcf9d3e36d7b9271dfd74cf047ed0880178ba6022f64479a91b4d338b8e7c589
+  data.tar.gz: cba96914ce05332a949d851a48fbfd3d3a840812b4fb402c9b6b6ec55b274bad532bdeea239c77bc9afb9f7a5adf8bd5e073188cb902222e8dbd322bc3bd505a

data/README.md

@@ -1,6 +1,7 @@
 # PATM: PATtern Matcher for Ruby
 
 [![Build Status](https://travis-ci.org/todesking/patm.svg?branch=master)](https://travis-ci.org/todesking/patm)
+[![Code Climate](https://codeclimate.com/github/todesking/patm.png)](https://codeclimate.com/github/todesking/patm)
 
 PATM is extremely faster pattern match library.
 
@@ -117,6 +118,20 @@ matcher.match(1)
 
 Value patterns such as `1, :x, String, ...` matches if `pattern === target_value` is true.
 
+### Struct
+
+```ruby
+A = Struct.new(:x, :y)
+
+# ...
+define_matcher :match_struct do|r|
+  # use Patm[struct_class].( ... ) for match struct
+  # argument is a Hash(member_name => pattern) or patterns that correspond struct members.
+  r.on Patm[A].(x: 1, y: Patm._1) {|m| m._1 }
+  r.on Patm[A].(2, Patm._1) {|m| m._1 }
+end
+```
+
 ### Array
 
 `[1, 2, _any]` matches `[1, 2, 3]`, `[1, 2, :x]`, etc.
@@ -189,6 +204,10 @@ pattern_match  10.050000   0.070000  10.120000 ( 10.898683)
 
 ## Changes
 
+### 3.1.0
+
+- Struct matcher
+
 ### 3.0.0
 
 - If given value can't match any pattern and no `else`, `Patm::NoMatchError` raised(Instead of return nil).

data/lib/patm.rb

@@ -13,28 +13,36 @@ module Patm
       when Pattern
         plain
       when ::Array
-        array = plain.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
+        build_from_array(plain)
       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]
-        )
+        build_from_hash(plain)
       else
         Obj.new(plain)
       end
     end
 
+    def self.build_from_array(plain)
+      array = plain.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 self.build_from_hash(plain)
+      self::Hash.new(
+        plain.each_with_object({}) do|(k, v), h|
+          h[k] = build_from(v) if k != Patm.exact
+        end,
+        plain[Patm.exact]
+      )
+    end
+
     module Util
       def self.compile_value(value, free_index)
         if value.nil? || value.is_a?(Numeric) || value.is_a?(String) || value.is_a?(Symbol)
@@ -200,16 +208,24 @@ module Patm
       end
 
       def execute(mmatch, obj)
-        size_min = @head.size + @tail.size
         return false unless obj.is_a?(Array)
-        return false unless @rest ? (obj.size >= size_min) :  (obj.size == size_min)
-        @head.zip(obj[0..(@head.size - 1)]).all? {|pat, o|
+
+        size_min = @head.size + @tail.size
+        if @rest
+          return false if obj.size < size_min
+        else
+          return false if obj.size != size_min
+        end
+
+        return false unless @head.zip(obj[0..(@head.size - 1)]).all? {|pat, o|
           pat.execute(mmatch, o)
-        } &&
-        @tail.zip(obj[(-@tail.size)..-1]).all? {|pat, o|
+        }
+
+        return false unless @tail.zip(obj[(-@tail.size)..-1]).all? {|pat, o|
           pat.execute(mmatch, o)
-        } &&
-        (!@rest || @rest.execute(mmatch, obj[@head.size..-(@tail.size+1)]))
+        }
+
+        !@rest || @rest.execute(mmatch, obj[@head.size..-(@tail.size+1)])
       end
 
       def inspect
@@ -227,48 +243,59 @@ module Patm
 
         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}"
+        i = compile_size_check(target_name, srcs, ctxs, i)
+
+        i = compile_part(target_name, @head, srcs, ctxs, i)
+
+        unless @tail.empty?
+          srcs << "#{target_name}_t = #{target_name}[(-#{@tail.size})..-1]; true"
+          i = compile_part("#{target_name}_t", @tail, srcs, ctxs, i)
         end
 
-        elm_target_name = "#{target_name}_elm"
-        @head.each_with_index do|h, hi|
-          if h.is_a?(Obj)
-            s, c, i = h.compile_internal(i, "#{target_name}[#{hi}]")
-            srcs << "#{s}" if s
-            ctxs << c
+        i = compile_rest(target_name, srcs, ctxs, i)
+
+        [
+          srcs.compact.map{|s| "(#{s})"}.join(" &&\n"),
+          ctxs.flatten(1),
+          i
+        ]
+      end
+
+      private
+        def compile_size_check(target_name, srcs, ctxs, i)
+          size_min = @head.size + @tail.size
+          if @rest
+            srcs << "#{target_name}.size >= #{size_min}"
           else
-            s, c, i = h.compile_internal(i, elm_target_name)
-            srcs << "#{elm_target_name} = #{target_name}[#{hi}]; #{s}" if s
-            ctxs << c
+            srcs << "#{target_name}.size == #{size_min}"
           end
+          i
         end
 
-        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
+        def compile_part(target_name, part, srcs, ctxs, i)
+          part.each_with_index do|h, hi|
+            if h.is_a?(Obj)
+              s, c, i = h.compile_internal(i, "#{target_name}[#{hi}]")
+              srcs << "#{s}" if s
+              ctxs << c
+            else
+              elm_target_name = "#{target_name}_elm"
+              s, c, i = h.compile_internal(i, elm_target_name)
+              srcs << "#{elm_target_name} = #{target_name}[#{hi}]; #{s}" if s
+              ctxs << c
+            end
           end
+          i
         end
 
-        if @rest
+        def compile_rest(target_name, srcs, ctxs, i)
+          return i unless @rest
           tname = "#{target_name}_r"
           s, c, i = @rest.compile_internal(i, tname)
           srcs << "#{tname} = #{target_name}[#{@head.size}..-(#{@tail.size+1})];#{s}" if s
           ctxs << c
-        end
-
-        [
-          srcs.compact.map{|s| "(#{s})"}.join(" &&\n"),
-          ctxs.flatten(1),
           i
-        ]
-      end
+        end
     end
 
     class ArrRest < self
@@ -323,6 +350,70 @@ module Patm
       end
     end
 
+    class Struct < self
+      def initialize(klass, pat)
+        @klass, @pat = klass, pat
+      end
+
+      def inspect
+        "STRUCT(#{@klass.name || "<unnamed>"}, #{@pat.inspect})"
+      end
+
+      def execute(match, obj)
+        obj.is_a?(@klass) && @pat.all?{|k, v| v.execute(match, obj[k]) }
+      end
+
+      def compile_internal(free_index, target_name = "_obj")
+        srcs = []
+        ctxs = []
+        i = free_index
+
+        if @klass.name
+          srcs << "#{target_name}.is_a?(::#{@klass.name})"
+        else
+          srcs << "#{target_name}.is_a?(_ctx[#{i}])"
+          ctxs << [@klass]
+          i += 1
+        end
+
+        @pat.each do|(member, v)|
+          s, c, i = v.compile_internal(i, "#{target_name}_elm")
+          srcs << "#{target_name}_elm = #{target_name}.#{member}; #{s}" if s
+          ctxs << c
+        end
+
+        [
+          srcs.map{|s| "(#{s})"}.join(" &&\n"),
+          ctxs.flatten(1),
+          i
+        ]
+      end
+
+      class Builder
+        def initialize(klass)
+          raise ArgumentError, "#{klass} is not Struct" unless klass.ancestors.include?(::Struct)
+          @klass = klass
+        end
+
+        # member_1_pat -> member_2_pat -> ... -> Pattern
+        # {member:Symbol => pattern} -> Pattern
+        def call(*args)
+          if args.size == 1 && args.first.is_a?(::Hash)
+            hash = args.first
+            hash.keys.each do|k|
+              raise ArgumentError, "#{k.inspect} is not member of #{@klass}" unless @klass.members.include?(k)
+            end
+            Struct.new(@klass, hash.each_with_object({}){|(k, plain), h|
+              h[k] = Pattern.build_from(plain)
+            })
+          else
+            raise ArgumentError, "Member size not match: expected #{@klass.members.size} but #{args.size}" unless args.size == @klass.members.size
+            Struct.new(@klass, ::Hash[*@klass.members.zip(args.map{|a| Pattern.build_from(a) }).flatten(1)])
+          end
+        end
+      end
+    end
+
     class Named < self
       def initialize(name)
         raise ::ArgumentError unless name.is_a?(Symbol) || name.is_a?(Numeric)
@@ -345,7 +436,8 @@ module Patm
     end
 
     class LogicalOp < self
-      def initialize(pats, op_str)
+      def initialize(name, pats, op_str)
+        @name = name
         @pats = pats
         @op_str = op_str
       end
@@ -375,34 +467,31 @@ module Patm
       def opt?
         @pats.any?(&:opt?)
       end
+      def inspect
+        "#{@name}(#{@pats.map(&:inspect).join(',')})"
+      end
     end
 
     class Or < LogicalOp
       def initialize(pats)
-        super(pats, '||')
+        super('OR', pats, '||')
       end
       def execute(mmatch, obj)
         @pats.any? do|pat|
           pat.execute(mmatch, obj)
         end
       end
-      def inspect
-        "OR(#{@pats.map(&:inspect).join(',')})"
-      end
     end
 
     class And < LogicalOp
       def initialize(pats)
-        super(pats, '&&')
+        super('AND', pats, '&&')
       end
       def execute(mmatch, obj)
         @pats.all? do|pat|
           pat.execute(mmatch, obj)
         end
       end
-      def inspect
-        "AND(#{@pats.map(&:inspect).join(',')})"
-      end
     end
   end
 
@@ -434,6 +523,10 @@ module Patm
     EXACT
   end
 
+  def self.[](struct_klass)
+    Pattern::Struct::Builder.new(struct_klass)
+  end
+
   PREDEF_GROUP_SIZE = 100
 
   class <<self

data/patm.gemspec

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

@@ -2,6 +2,7 @@ require 'simplecov'
 require 'simplecov-vim/formatter'
 SimpleCov.start do
   formatter SimpleCov::Formatter::VimFormatter
+  formatter SimpleCov::Formatter::HTMLFormatter
 end
 
 require File.join(File.dirname(__FILE__), '..', 'lib', 'patm.rb')
@@ -300,6 +301,26 @@ describe Patm::Pattern do
     it { should     match_to({a: 1} => {b: 2}) }
   end
 
+  Struct1 = Struct.new(:a, :b)
+
+  pattern(Patm[Struct1].(1, Patm._1)) do
+    it { should_not match_to(nil) }
+    it { should_not match_to(Struct1.new(2, 2)) }
+    it { should     match_to(Struct1.new(1, 2)).and_capture(2) }
+  end
+
+  pattern(Patm[Struct1].(a: 1, b: Patm._1)) do
+    it { should_not match_to(nil) }
+    it { should_not match_to(Struct1.new(2, 2)) }
+    it { should     match_to(Struct1.new(1, 2)).and_capture(2) }
+  end
+
+  unnamed_struct = Struct.new(:x, :y)
+  pattern(Patm[unnamed_struct].(x: 1, y: Patm._1)) do
+    it { should_not match_to(nil) }
+    it { should match_to(unnamed_struct.new(1, 2)).and_capture(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) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: patm
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.1.0
 platform: ruby
 authors:
 - todesking
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-24 00:00:00.000000000 Z
+date: 2014-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: simplecov