patm 2.0.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 64949366066d3d6c55747fc4de1163fc77624491
-  data.tar.gz: 84b8d7f389aa5be66d911c42cb8c9d25041657b8
+  metadata.gz: 7dfd622177fbff6949aeba6e0ea9a37c503ca13e
+  data.tar.gz: 49e7f41b2e40d4fa9724eb607340b6196a41ef0c
 SHA512:
-  metadata.gz: 9f4e569ff98ea968a05c736076b01eb8e8d33a2f10a40879e4ec02a5db58c16389dee0c694ca4d2c1dc979de4a46ace0f72d9eba82c9e044012ba12655da5360
-  data.tar.gz: 098c8031f081a57b2958cde2f9643e7a053d1c9c4871ed449690895e95594a91e0a48a0ff8338c5cb967e63315d80a40cc231ceb4b8c662a1bcd6ec9efc0dfb1
+  metadata.gz: 7a0dd73809aadf15e43dab4c93cd857f38bf3bdb0666525f4791f117e415d0123df8dd90d0f66880362669efbaad2bfd3c0ecf82a17c2929c620711e6b773655
+  data.tar.gz: 379c2300a12acd9662f5abffa284dc6ffc1854f027d5ca9a8e92e5bafb9a497581054a39998334c965bb21cd4e872035ff7e88471ee00983e4468f47421cc87b

data/.gitignore

@@ -1,2 +1,4 @@
 Gemfile.lock
 *.gem
+coverage
+coverage.vim

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 2.1.2
+  - 2.0.0
+  - 1.9.3
+  - 1.9.2
+script: rspec

data/README.md

@@ -1,32 +1,15 @@
 # PATM: PATtern Matcher for Ruby
 
-## Usage
-
-```ruby
-require 'patm'
-```
+[![Build Status](https://travis-ci.org/todesking/patm.svg?branch=master)](https://travis-ci.org/todesking/patm)
 
-```ruby
-# With case(simple but slow)
-def match(obj)
-  p = Patm
-  _xs = Patm._xs
-  case obj
-  when m = Patm.match([:x, p._1, p._2])
-    [m._2, m._1]
-  when m = Patm.match([1, _xs&p._1])
-    m._1
-  end
-end
+PATM is extremely faster pattern match library.
 
-match([1, 2, 3])
-# => [2, 3]
+Features: Match value/classes, Capture, Array/Hash decomposition.
 
-match([:x, :y, :z])
-# => [:z, :y]
+## Usage
 
-match([])
-# => nil
+```ruby
+require 'patm'
 ```
 
 ```ruby
@@ -46,6 +29,9 @@ class A
       _self.match1(m._1)
     end
     # ...
+    r.else do
+      nil
+    end
   end
 end
 
@@ -53,6 +39,29 @@ A.new.match1([:x, 1, 2])
 # => [1, 2]
 ```
 
+```ruby
+# With case(simple but slow)
+def match(obj)
+  p = Patm
+  _xs = Patm._xs
+  case obj
+  when m = Patm.match([:x, p._1, p._2])
+    [m._2, m._1]
+  when m = Patm.match([1, _xs&p._1])
+    m._1
+  end
+end
+
+match([1, 2, 3])
+# => [2, 3]
+
+match([:x, :y, :z])
+# => [:z, :y]
+
+match([])
+# => nil
+```
+
 ```ruby
 # With pre-built Rule
 rule = Patm::Rule.new do|r|
@@ -76,29 +85,31 @@ rule.apply([])
 # => nil
 ```
 
+## DSL
+
 ```ruby
-# With cached rules
-class A
-  def initialize
-    @rules = Patm::RuleCache.new
+class PatternMatcher
+  extend Patm::DSL
+
+  define_matcher(:match) do|r| # r is instance of Patm::Rule
+    # r.on( PATTERN ) {|match, _self|
+    #   First argument is instance of Patm::Match. Use it to access captured value.
+    #   ex. m._1, m._2, ..., m[capture_name]
+    #
+    #   Second argument is instance of the class. Use it to access other methods.
+    #   ex. _self.other_method
+    # }
+    #
+    # r.else {|value, _self|
+    #   First argument is the value. Second is instance of the class.
+    # }
   end
+end
 
-  def match1(obj)
-    @rules.match(:match1, obj) do|r|
-      p = Patm
-      r.on [:x, p._1, p._2] do|m|
-        [m._1, m._2]
-      end
-    end
-  end
+matcher = PatternMatcher.new
 
-  def match2(obj)
-    @rules.match(:match2, obj) do|r|
-      # ...
-    end
-  end
-end
- ```
+matcher.match(1)
+```
 
 ## Patterns
 
@@ -138,8 +149,52 @@ Captured values are accessible through `Match#_1, _2, ...` and `Match#[capture_n
 `Patm.or(1, 2)` matches 1 or 2.
 
 
+## Performance
+
+see [benchmark code](./benchmark/comparison.rb) for details
+
+Machine: MacBook Air(Late 2010) C2D 1.8GHz, OS X 10.9.2
+
+```
+RUBY_VERSION: 2.1.2 p95
+
+Benchmark: Empty(x10000)
+                    user     system      total        real
+manual          0.010000   0.000000   0.010000 (  0.012252)
+patm            0.060000   0.000000   0.060000 (  0.057050)
+pattern_match   1.710000   0.010000   1.720000 (  1.765749)
+
+Benchmark: SimpleConst(x10000)
+                    user     system      total        real
+manual          0.020000   0.000000   0.020000 (  0.018274)
+patm            0.060000   0.000000   0.060000 (  0.075068)
+patm_case       0.160000   0.000000   0.160000 (  0.161002)
+pattern_match   1.960000   0.020000   1.980000 (  2.007936)
+
+Benchmark: ArrayDecomposition(x10000)
+                    user     system      total        real
+manual          0.050000   0.000000   0.050000 (  0.047948)
+patm            0.250000   0.000000   0.250000 (  0.254039)
+patm_case       1.710000   0.000000   1.710000 (  1.765656)
+pattern_match  12.890000   0.060000  12.950000 ( 13.343334)
+
+Benchmark: VarArray(x10000)
+                    user     system      total        real
+manual          0.050000   0.000000   0.050000 (  0.052425)
+patm            0.210000   0.000000   0.210000 (  0.223190)
+patm_case       1.440000   0.000000   1.440000 (  1.587535)
+pattern_match  10.050000   0.070000  10.120000 ( 10.898683)
+```
+
+
 ## Changes
 
+### 3.0.0
+
+- If given value can't match any pattern and no `else`, `Patm::NoMatchError` raised(Instead of return nil).
+- RuleCache is now obsoleted. Use DSL.
+- More optimized compiler
+
 ### 2.0.1
 
 - Bugfix: About pattern `Patm._1 & Array`.

data/benchmark/benchmark.rb

@@ -53,8 +53,8 @@ end
   end
 end
 
-@rule = P::Rule.new(false, &@ruledef)
-@compiled_rule = P::Rule.new(true, &@ruledef)
+@rule = P::Rule.new(&@ruledef)
+@compiled_rule = P::Rule.new(&@ruledef).compile
 
 def match_with_rule(obj)
   @rule.apply(obj)

data/benchmark/comparison.rb

@@ -0,0 +1,209 @@
+require 'benchmark'
+
+def benchmark(klass, n)
+  puts "Benchmark: #{klass}(x#{n})"
+
+  target_methods = klass.instance_methods - Object.instance_methods - [:test_values]
+  validate(klass, target_methods)
+
+  Benchmark.bm('pattern-match'.size) do|b|
+    obj = klass.new
+    test_values = obj.test_values
+    target_methods.each do|method_name|
+      b.report(method_name) do
+        m = obj.method(method_name)
+        n.times { test_values.each {|val| m.call(val) } }
+      end
+    end
+  end
+  puts
+end
+
+def validate(klass, target_methods)
+  obj = klass.new
+  obj.test_values.each do|val|
+    results = target_methods.map {|name| [name, obj.public_send(name, val)] }
+    unless results.each_cons(2).all?{|(_, a), (_, b)| a == b }
+      raise "ERROR: Result not match. val=#{val.inspect}, #{results.map{|n,r| "#{n}=#{r.inspect}"}.join(', ')}"
+    end
+  end
+end
+
+load File.join(File.dirname(__FILE__), '../lib/patm.rb')
+require 'pattern-match'
+
+class Empty
+  extend Patm::DSL
+
+  def manual(obj)
+    nil
+  end
+
+  define_matcher :patm do|r|
+    r.else { nil }
+  end
+
+  def pattern_match(obj)
+    match(obj) do
+      with(_) { nil }
+    end
+  end
+
+  def test_values
+    [1, 2, 3]
+  end
+end
+
+class SimpleConst
+  extend Patm::DSL
+
+  def manual(obj)
+    if obj == 1
+      100
+    elsif obj == 2
+      200
+    else
+      300
+    end
+  end
+
+  define_matcher :patm do|r|
+    r.on(1) { 100 }
+    r.on(2) { 200 }
+    r.else { 300 }
+  end
+
+  def patm_case(obj)
+    case obj
+    when m = Patm.match(1)
+        100
+    when m = Patm.match(2)
+        200
+    else
+      300
+    end
+  end
+
+  def pattern_match(obj)
+    match(obj) do
+      with(1) { 100 }
+      with(2) { 200 }
+      with(_) { 300 }
+    end
+  end
+
+  def test_values
+    [1, 2, 3]
+  end
+end
+
+class ArrayDecomposition
+  extend Patm::DSL
+
+  def manual(obj)
+    return 100 unless obj
+    return nil unless obj.is_a?(Array)
+    return nil if obj.size != 3
+    return nil unless obj[0] == 1
+
+    if  obj[2] == 2
+      obj[1]
+    else
+      [obj[1], obj[2]]
+    end
+  end
+
+  define_matcher :patm do|r|
+    _1, _2 = Patm._1, Patm._2
+    r.on([1, _1, 2]) {|m| m._1 }
+    r.on([1, _1, _2]) {|m| [m._1, m._2] }
+    r.on(nil) { 100 }
+    r.else { nil }
+  end
+
+  def patm_case(obj)
+    _1, _2 = Patm._1, Patm._2
+    case obj
+    when m = Patm.match([1, _1, 2])
+      m._1
+    when m = Patm.match([1, _1, _2])
+      [m._1, m._2]
+    when m = Patm.match(nil)
+      100
+    else
+      nil
+    end
+  end
+
+  def pattern_match(obj)
+    match(obj) do
+      with(_[1, _1, 2]) { _1 }
+      with(_[1, _1, _2]) { [_1, _2] }
+      with(nil) { 100 }
+      with(_) { nil }
+    end
+  end
+
+  def test_values
+    [
+      [],
+      [1, 9, 2],
+      [1, 9, 3],
+      [1, 9, 1],
+      [1],
+      "foo",
+      nil
+    ]
+  end
+end
+
+class VarArray
+  extend Patm::DSL
+
+  def manual(obj)
+    return nil unless obj.is_a?(Array) && obj.size >= 2 && obj[0] == 1 && obj[1] == 2
+    return obj[2..-1]
+  end
+
+  define_matcher :patm do|r|
+    r.on([1, 2, Patm._xs[1]]) {|m| m[1] }
+    r.else { nil }
+  end
+
+  def patm_case(obj)
+    case obj
+    when m = Patm.match([1, 2, Patm._xs[1]])
+      m._1
+    else
+      nil
+    end
+  end
+
+  def pattern_match(obj)
+    match(obj) do
+      with(_[1, 2, *_1]) { _1 }
+      with(_) { nil }
+    end
+  end
+
+  def test_values
+    [
+      nil,
+      100,
+      [],
+      [1, 2],
+      [1, 2, 3],
+      [1, 2, 3, 4],
+      [1, 10, 100],
+    ]
+  end
+end
+
+
+puts "RUBY_VERSION: #{RUBY_VERSION} p#{RUBY_PATCHLEVEL}"
+puts
+
+benchmark Empty, 10000
+benchmark SimpleConst, 10000
+benchmark ArrayDecomposition, 10000
+benchmark VarArray, 10000

data/lib/patm.rb

@@ -1,4 +1,11 @@
 module Patm
+  class NoMatchError < StandardError
+    def initialize(value)
+      super("Pattern not match: value=#{value.inspect}")
+      @value = value
+    end
+    attr_reader :value
+  end
   class Pattern
 
     def self.build_from(plain)
@@ -30,7 +37,7 @@ module Patm
 
     module Util
       def self.compile_value(value, free_index)
-        if value.is_a?(Numeric) || value.is_a?(String) || value.is_a?(Symbol)
+        if value.nil? || value.is_a?(Numeric) || value.is_a?(String) || value.is_a?(Symbol)
           [
             value.inspect,
             [],
@@ -90,6 +97,7 @@ module Patm
         @desc = desc
         @context = context
         singleton_class = class <<self; self; end
+        @src_body = src
         @src = <<-RUBY
         def execute(_match, _obj)
           _ctx = @context
@@ -99,10 +107,11 @@ module Patm
         singleton_class.class_eval(@src)
       end
 
+      attr_reader :src_body
       attr_reader :src
 
       def compile_internal(free_index, target_name = "_obj")
-        raise "Already compiled"
+        raise "already compiled"
       end
       def inspect; "<compiled>#{@desc}"; end
     end
@@ -227,16 +236,22 @@ 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})" if s
-          ctxs << c
+          if h.is_a?(Obj)
+            s, c, i = h.compile_internal(i, "#{target_name}[#{hi}]")
+            srcs << "#{s}" if s
+            ctxs << c
+          else
+            s, c, i = h.compile_internal(i, elm_target_name)
+            srcs << "#{elm_target_name} = #{target_name}[#{hi}]; #{s}" if s
+            ctxs << c
+          end
         end
 
         unless @tail.empty?
-          srcs << "(#{target_name}_t = #{target_name}[(-#{@tail.size})..-1]; true)"
+          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
+            srcs << "#{elm_target_name} = #{target_name}_t[#{ti}]; #{s}" if s
             ctxs << c
           end
         end
@@ -244,7 +259,7 @@ module Patm
         if @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
+          srcs << "#{tname} = #{target_name}[#{@head.size}..-(#{@tail.size+1})];#{s}" if s
           ctxs << c
         end
 
@@ -434,20 +449,15 @@ module Patm
   end
 
   class Rule
-    def initialize(compile = true, &block)
-      @compile = compile
-      # { Pattern => Proc }
+    def initialize(&block)
+      # [[Pattern, Proc]...]
       @rules = []
-      @else = ->(obj){nil}
+      @else = nil
       block[self]
     end
 
     def on(pat, &block)
-      if @compile
-        @rules << [Pattern.build_from(pat).compile, block]
-      else
-        @rules << [Pattern.build_from(pat), block]
-      end
+      @rules << [Pattern.build_from(pat), block]
     end
 
     def else(&block)
@@ -461,36 +471,82 @@ module Patm
           return block.call(match, _self)
         end
       end
-      @else[obj, _self]
+      @else ? @else[obj, _self] : (raise NoMatchError.new(obj))
+    end
+
+    def inspect
+      "Rule{#{@rules.map(&:first).map(&:inspect).join(', ')}#{@else ? ', _' : ''}}"
     end
-  end
 
-  class RuleCache
-    def initialize(compile = true)
-      @compile = compile
-      @rules = {}
+    def compile_call(block, *args)
+      "call(#{args[0...block.arity].join(', ')})"
+    end
+
+    def compile
+      i = 0
+      ctxs = []
+      srcs = []
+      @rules.each do|pat, block|
+        s, c, i = pat.compile_internal(i, '_obj')
+        ctxs << c
+        ctxs << [block]
+        srcs << "if (#{s || 'true'})\n_ctx[#{i}].#{compile_call(block, "::Patm::Match.new(_match)"," _self")}"
+        i += 1
+      end
+      src = srcs.join("\nels")
+      if @else
+        src << "\nelse\n" unless srcs.empty?
+        src << "_ctx[#{i}].#{compile_call(@else, "_obj"," _self")}"
+        ctxs << [@else]
+        i += 1
+      else
+        src << "\nelse\n" unless srcs.empty?
+        src << "raise ::Patm::NoMatchError.new(_obj)"
+      end
+      src << "\nend" unless srcs.empty?
+      Compiled.new(
+        src,
+        ctxs.flatten(1)
+      )
     end
-    def match(rule_name, obj, _self = nil, &rule)
-      (@rules[rule_name] ||= ::Patm::Rule.new(@compile, &rule)).apply(obj, _self)
+
+    class Compiled
+      def initialize(src_body, context)
+        @src_body = src_body
+        @context = context
+        @src = <<-RUBY
+        def apply(_obj, _self = nil)
+          _ctx = @context
+          _match = {}
+#{@src_body}
+        end
+        RUBY
+
+        singleton_class = class <<self; self; end
+        singleton_class.class_eval(@src)
+      end
+
+      attr_reader :src_body
+      attr_reader :context
     end
   end
 
   class Match
-    def initialize
-      @group = {}
+    def initialize(data = {})
+      @data = data
     end
 
     def [](i)
-      @group[i]
+      @data[i]
     end
 
     def []=(i, val)
-      @group[i] = val
+      @data[i] = val
     end
 
     PREDEF_GROUP_SIZE.times.each do|i|
       define_method "_#{i}" do
-        self[i]
+        @data[i]
       end
     end
   end
@@ -515,11 +571,18 @@ module Patm
 
   module DSL
     def define_matcher(name, &rule)
-      @patm_rules ||= RuleCache.new
-      rules = @patm_rules
-      define_method name do|obj|
-        rules.match(name, obj, self, &rule)
-      end
+      rule = Rule.new(&rule).compile
+      ctx = rule.context
+      self.class_variable_set("@@_patm_ctx_#{name}", ctx)
+      src = <<-RUBY
+      def #{name}(_obj)
+        _self = self
+        _ctx = self.#{self.name ? 'class' : 'singleton_class'}.class_variable_get(:@@_patm_ctx_#{name})
+        _match = {}
+#{rule.src_body}
+      end
+      RUBY
+      class_eval(src)
     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     = '2.0.1'
+  s.version     = '3.0.0'
   s.summary     = 'PATtern Matching library'
   s.description = 'Pattern matching library for plain data structure'
   s.required_ruby_version = '>= 1.9.0'
@@ -16,6 +16,9 @@ Gem::Specification.new do |s|
   s.test_files    = s.files.grep(%r{^(test|spec|features)/})
   s.require_paths = ["lib"]
 
+  s.add_development_dependency('simplecov', '~> 0.7.1')
+  s.add_development_dependency('simplecov-vim')
   s.add_development_dependency('rspec', '~>2.14')
   s.add_development_dependency('pry', '~>0.9')
+  s.add_development_dependency('pattern-match', '=0.5.1') # for benchmarking
 end

data/spec/patm_spec.rb

@@ -1,43 +1,64 @@
+require 'simplecov'
+require 'simplecov-vim/formatter'
+SimpleCov.start do
+  formatter SimpleCov::Formatter::VimFormatter
+end
+
 require File.join(File.dirname(__FILE__), '..', 'lib', 'patm.rb')
 require 'pry'
 
 module PatmHelper
-  extend RSpec::Matchers::DSL
+  module Pattern
+    extend RSpec::Matchers::DSL
 
-  matcher :these_matches do|*matches|
-    match do|actual|
-      matches.all?{|m| m.matches?(actual) }
+    matcher :these_matches do|*matches|
+      match do|actual|
+        matches.all?{|m| m.matches?(actual) }
+      end
     end
-  end
 
-  matcher :match_to do|expected|
-    match do|actual|
-      exec(actual, expected)
-    end
+    matcher :match_to do|expected|
+      match do|actual|
+        exec(actual, expected)
+      end
 
-    def exec(actual, expected)
-      @match = Patm::Match.new
-      actual.execute(@match, expected)
-    end
+      def exec(actual, expected)
+        @match = Patm::Match.new
+        actual.execute(@match, expected)
+      end
+
+      def match; @match; end
 
-    def match; @match; end
+      def and_capture(g1, g2 = nil, g3 = nil, g4 = nil)
+        these_matches(
+          self, _capture(self, {1 => g1, 2 => g2, 3 => g3, 4 => g4})
+        )
+      end
 
-    def and_capture(g1, g2 = nil, g3 = nil, g4 = nil)
-      these_matches(
-        self, _capture(self, {1 => g1, 2 => g2, 3 => g3, 4 => g4})
-      )
+      def and_named_capture(capture)
+        these_matches(
+          self, _capture(self, capture)
+        )
+      end
     end
 
-    def and_named_capture(capture)
-      these_matches(
-        self, _capture(self, capture)
-      )
+    matcher :_capture do|m, capture|
+      match do|_|
+        [m.match[1], m.match[2], m.match[3], m.match[4]] == capture.values_at(1,2,3,4)
+      end
     end
   end
 
-  matcher :_capture do|m, capture|
-    match do|_|
-      [m.match[1], m.match[2], m.match[3], m.match[4]] == capture.values_at(1,2,3,4)
+  module Rule
+    extend RSpec::Matchers::DSL
+    matcher :converts do|value, result|
+      match do|rule|
+        @matched = rule.apply(value, nil)
+        @matched == result
+      end
+      failure_message_for_should do|rule|
+        "match #{value.inspect} to #{rule.inspect}: expected #{result} but #{@matched.inspect}"
+      end
     end
   end
 
@@ -57,7 +78,7 @@ describe "Usage:" do
 
   it 'with predefined Rule' do
     p = Patm
-    r = p::Rule.new(false) do|r|
+    r = p::Rule.new do|r|
       r.on [1, p._1, p._2] do|m|
         [m._1, m._2]
       end
@@ -68,43 +89,13 @@ describe "Usage:" do
 
   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
-
-    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
-
-  it 'with RuleCache(compiled)' do
-    p = Patm
-    rs = p::RuleCache.new(true)
-
-    rs.match(:pattern_1, [1, 2, 3]) do|r|
+    r = p::Rule.new 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]
+    r.compile.apply([1, 2, 3]).should == [2, 3]
   end
 
   it 'with DSL' do
@@ -139,8 +130,55 @@ describe "Usage:" do
   end
 end
 
+describe Patm::Rule do
+  include PatmHelper::Rule
+  def self.rule(name, definition, &block)
+    [[false, "#{name}"], [true, "#{name}(compiled)"]].each do|compile, name|
+      describe name do
+        subject { Patm::Rule.new(&definition).tap{|r| break r.compile if compile } }
+        self.instance_eval(&block)
+      end
+    end
+  end
+
+  rule(:rule1, ->(r){
+    r.on([1, Patm._1, Patm._2]) {|m| [m._1, m._2] }
+    r.else { [] }
+  }) do
+    it { should converts([1, 2, 3], [2, 3]) }
+    it { should converts([1], []) }
+  end
+
+  rule(:rule2, ->(r) {
+    r.on(1) { 100 }
+  }) do
+    it { should converts(1, 100) }
+    it { expect { subject.apply(nil) }.to raise_error(Patm::NoMatchError) }
+  end
+
+  context 'regression' do
+    rule(:reg1, ->(r){
+      _1, _2 = Patm._1, Patm._2
+      r.on([1, _1, 2]) {|m| m._1 }
+      r.on([1, _1, _2]) {|m| [m._1, m._2] }
+      r.on(nil) { 100 }
+      r.else { nil }
+    }) do
+      it { should converts([1, 2, 2], 2) }
+      it { should converts([1, 2, 3], [2, 3]) }
+      it { should converts(nil, 100) }
+      it { should converts([], nil) }
+    end
+
+    rule(:reg2, ->(r) { r.else { nil }}) do
+      it { should converts(1, nil) }
+      it { should converts("hoge", nil) }
+    end
+  end
+end
+
 describe Patm::Pattern do
-  include PatmHelper
+  include PatmHelper::Pattern
   def self.pattern(plain, &b)
     context "pattern '#{plain.inspect}'" do
       subject { Patm::Pattern.build_from(plain) }

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: patm
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 3.0.0
 platform: ruby
 authors:
 - todesking
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-12 00:00:00.000000000 Z
+date: 2014-05-24 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+- !ruby/object:Gem::Dependency
+  name: simplecov-vim
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +66,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: pattern-match
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.1
 description: Pattern matching library for plain data structure
 email: discommucative@gmail.com
 executables: []
@@ -45,10 +87,12 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE
 - README.md
 - benchmark/benchmark.rb
+- benchmark/comparison.rb
 - lib/patm.rb
 - patm.gemspec
 - spec/patm_spec.rb