pattern-match 0.5.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 71fd4640c715750480dcad518ebc8fe68d468bf7
-  data.tar.gz: 84c2f108c050569e0dd6b9eb2f3ff79900ef65a3
+  metadata.gz: ef7bf869eb224fa684f0d76e818765b7c29bac7a
+  data.tar.gz: 8f0250bc045bc40226c470eeecc0d4cb19c9948e
 SHA512:
-  metadata.gz: ba8572f327ebe6fef3109d1fe7d14ce22146a33e7c5602afc3457fa7a17110699ff1683af2d9f0cda81f98b124cc495a2a3923ef84ae5bca9df52f81ba82042f
-  data.tar.gz: af9f39647b62a984634f30afa28c5a7ad6d3d9b1fb39fdda5599aee5ffae9033de99aee5c6024178f23482800ee80478e1d4949857638ec0fb8233f21811b0b5
+  metadata.gz: da3c2aee6e261dc82bac97d578629b2d92a4449e6eb10ccd8f321fbd99330f2b505cde23df1e10080e7f9d2549ce40a9ba2c20c6e680d0fc6abe2c701cea3596
+  data.tar.gz: 5c7108710be125a049fe4fde57a1292e6e820a87cb414ef6fe7db18ad6d339da2549659381ea018b17de6469adcf51cb90240fa532c8ea92b44d027f3065f847

data/.travis.yml

@@ -1,6 +1,30 @@
 rvm:
-  - 1.9.2
   - 1.9.3
   - 2.0.0
-  - 2.1.0
+  - 2.1
+  - 2.2
   - ruby-head
+  - jruby-19mode
+env:
+  - TEST="test/test_*"
+  - TEST="test/test_standard.rb"
+  - DISABLE_REFINEMENTS=1 TEST="test/test_*"
+  - DISABLE_REFINEMENTS=1 TEST="test/test_standard.rb"
+matrix:
+  exclude:
+    - rvm: 1.9.3
+      env: TEST="test/test_*"
+    - rvm: 1.9.3
+      env: TEST="test/test_standard.rb"
+    - rvm: 2.0.0
+      env: TEST="test/test_*"
+    - rvm: 2.0.0
+      env: TEST="test/test_standard.rb"
+    - rvm: jruby-19mode
+      env: TEST="test/test_*"
+    - rvm: jruby-19mode
+      env: TEST="test/test_standard.rb"
+    - rvm: jruby-19mode
+      env: DISABLE_REFINEMENTS=1 TEST="test/test_*"
+  allow_failures:
+    - rvm: ruby-head

data/BSDL

@@ -1,4 +1,4 @@
-Copyright (C) 2012-2014 Kazuki Tsujimoto, All rights reserved.
+Copyright (C) 2012-2015 Kazuki Tsujimoto, All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions

data/COPYING

@@ -1,4 +1,4 @@
-Copyright (C) 2012-2014 Kazuki Tsujimoto, All rights reserved.
+Copyright (C) 2012-2015 Kazuki Tsujimoto, All rights reserved.
 
 You can redistribute it and/or modify it under either the terms of the
 2-clause BSDL (see the file BSDL), or the conditions below:

data/README.rdoc

@@ -19,9 +19,10 @@ or
  $ bundle install --path vendor/bundle
 
 == Basic Usage
-pattern-match library provides Kernel#match.
+pattern-match library provides <code>Object#match</code>.
 
  require 'pattern-match'
+ using PatternMatch
 
  match(object) do
    with(pattern[, guard]) do
@@ -111,7 +112,7 @@ all objects bound to variable must be equal.
 <code>And</code>, <code>Or</code>, <code>Not</code> return and/or/not pattern.
 
  match([0, [1]]) do
-   with(a & Fixnum, ! (_[2] | _[3])) { a } #=> 0
+   with(_[a & Fixnum, ! (_[2] | _[3])]) { a } #=> 0
  end
 
  match(0) do
@@ -238,6 +239,18 @@ Pattern guard can be specified as a second argument to <code>with</code>.
    end
  end
 
+ match('0') do
+   with(/\d+/.(a << :to_i)) do
+     a #=> 0
+   end
+ end
+
+ match([Set[0, 1, 2], Set[3, 4]]) do
+   with(_[Set.(a, b), Set.(c)], guard { a + b * c == 2 } ) do
+     [a, b, c] #=> [2, 0, 3]
+   end
+ end
+
 * {RubyTextProcessing}[https://code.google.com/p/tokland/wiki/RubyTextProcessing]
 * {yhara/tapl-ruby}[https://github.com/yhara/tapl-ruby]
 

data/Rakefile

@@ -6,5 +6,6 @@ require "rake/testtask"
 task :default => :test
 Rake::TestTask.new do |t|
   t.libs << "lib"
+  t.ruby_opts = ["-w"]
   t.test_files = FileList["test/test_*.rb"]
 end

data/lib/pattern-match.rb

@@ -1,7 +1,7 @@
 # pattern-match.rb
 #
-# Copyright (C) 2012-2014 Kazuki Tsujimoto, All rights reserved.
+# Copyright (C) 2012-2015 Kazuki Tsujimoto, All rights reserved.
 
 require 'pattern-match/version'
-require 'pattern-match/core'
 require 'pattern-match/deconstructor'
+require 'pattern-match/core'

data/lib/pattern-match/core.rb

@@ -1,24 +1,12 @@
-require 'pattern-match/version'
+require 'pattern-match/deconstructor'
 
 module PatternMatch
-  module Deconstructable
-    def call(*subpatterns)
-      pattern_matcher(*subpatterns)
-    end
-  end
-
-  class ::Object
-    def pattern_matcher(*subpatterns)
-      PatternObjectDeconstructor.new(self, *subpatterns)
-    end
-  end
-
   module HasOrderedSubPatterns
     private
 
     def set_subpatterns_relation
       super
-      @subpatterns.each_cons(2) do |a, b|
+      subpatterns.each_cons(2) do |a, b|
         a.next = b
         b.prev = a
       end
@@ -37,7 +25,7 @@ module PatternMatch
     end
 
     def vars
-      @subpatterns.map(&:vars).flatten
+      subpatterns.map(&:vars).flatten
     end
 
     def ancestors
@@ -69,7 +57,11 @@ module PatternMatch
     end
 
     def quantified?
-      (@next and @next.quantifier?) or (root? ? false : @parent.quantified?)
+       directly_quantified? or (root? ? false : @parent.quantified?)
+    end
+
+    def directly_quantified?
+      @next and @next.quantifier?
     end
 
     def root
@@ -81,13 +73,13 @@ module PatternMatch
     end
 
     def validate
-      @subpatterns.each(&:validate)
+      subpatterns.each(&:validate)
     end
 
     def match(vals)
-      if @next and @next.quantifier?
+      if directly_quantified?
         q = @next
-        repeating_match(vals, q.longest?) do |vs, rest|
+        repeating_match(vals, q.greedy?) do |vs, rest|
           if vs.length < q.min_k
             next false
           end
@@ -106,7 +98,7 @@ module PatternMatch
       if @next
         @next.append(pattern)
       else
-        if @subpatterns.empty?
+        if subpatterns.empty?
           if root?
             new_root = PatternAnd.new(self)
             self.parent = new_root
@@ -114,21 +106,23 @@ module PatternMatch
           pattern.parent = @parent
           @next = pattern
         else
-          @subpatterns[-1].append(pattern)
+          subpatterns[-1].append(pattern)
         end
       end
     end
 
     def inspect
-      "#<#{self.class.name}: subpatterns=#{@subpatterns.inspect}>"
+      "#<#{self.class.name}: subpatterns=#{subpatterns.inspect}>"
     end
 
     private
 
-    def repeating_match(vals, longest)
+    attr_reader :subpatterns
+
+    def repeating_match(vals, is_greedy)
       quantifier = @next
-      lp = longest_patterns(vals)
-      (longest ? lp : lp.reverse).each do |(vs, rest)|
+      candidates = generate_candidates(vals)
+      (is_greedy ? candidates : candidates.reverse).each do |(vs, rest)|
         vars.each {|i| i.set_bind_to(quantifier) }
         begin
           if yield vs, rest
@@ -141,14 +135,14 @@ module PatternMatch
       false
     end
 
-    def longest_patterns(vals)
+    def generate_candidates(vals)
       vals.length.downto(0).map do |n|
         [vals.take(n), vals.drop(n)]
       end
     end
 
     def set_subpatterns_relation
-      @subpatterns.each do |i|
+      subpatterns.each do |i|
         i.parent = self
       end
     end
@@ -157,10 +151,10 @@ module PatternMatch
   class PatternQuantifier < Pattern
     attr_reader :min_k
 
-    def initialize(min_k, longest)
+    def initialize(min_k, is_greedy)
       super()
       @min_k = min_k
-      @longest = longest
+      @is_greedy = is_greedy
     end
 
     def validate
@@ -185,12 +179,12 @@ module PatternMatch
       end
     end
 
-    def longest?
-      @longest
+    def greedy?
+      @is_greedy
     end
 
     def inspect
-      "#<#{self.class.name}: min_k=#{@min_k}, longest=#{@longest}>"
+      "#<#{self.class.name}: min_k=#{@min_k}, is_greedy=#{@is_greedy}>"
     end
   end
 
@@ -206,6 +200,8 @@ module PatternMatch
   class PatternObjectDeconstructor < PatternDeconstructor
     include HasOrderedSubPatterns
 
+    using PatternMatch if respond_to?(:using, true)
+
     def initialize(deconstructor, *subpatterns)
       super(*subpatterns)
       @deconstructor = deconstructor
@@ -214,57 +210,15 @@ module PatternMatch
     def match(vals)
       super do |val|
         deconstructed_vals = @deconstructor.deconstruct(val)
-        if @subpatterns.empty?
+        if subpatterns.empty?
           next deconstructed_vals.empty?
         end
-        @subpatterns[0].match(deconstructed_vals)
+        subpatterns[0].match(deconstructed_vals)
       end
     end
 
     def inspect
-      "#<#{self.class.name}: deconstructor=#{@deconstructor.inspect}, subpatterns=#{@subpatterns.inspect}>"
-    end
-  end
-
-  class PatternKeywordArgStyleDeconstructor < PatternDeconstructor
-    def initialize(klass, checker, getter, *keyarg_subpatterns)
-      spec = normalize_keyword_arg(keyarg_subpatterns)
-      super(*spec.values)
-      @klass = klass
-      @checker = checker
-      @getter = getter
-      @spec = spec
-    end
-
-    def match(vals)
-      super do |val|
-        next false unless val.kind_of?(@klass)
-        next false unless @spec.keys.all? {|k| val.__send__(@checker, k) }
-        @spec.all? do |k, pat|
-          pat.match([val.__send__(@getter, k)]) rescue false
-        end
-      end
-    end
-
-    def inspect
-      "#<#{self.class.name}: klass=#{@klass.inspect}, spec=#{@spec.inspect}>"
-    end
-
-    private
-
-    def normalize_keyword_arg(subpatterns)
-      syms = subpatterns.take_while {|i| i.kind_of?(Symbol) }
-      rest = subpatterns.drop(syms.length)
-      hash = case rest.length
-             when 0
-               {}
-             when 1
-               rest[0]
-             else
-               raise MalformedPatternError
-             end
-      variables = Hash[syms.map {|i| [i, PatternVariable.new(i)] }]
-      Hash[variables.merge(hash).map {|k, v| [k, v.kind_of?(Pattern) ? v : PatternValue.new(v)] }]
+      "#<#{self.class.name}: deconstructor=#{@deconstructor.inspect}, subpatterns=#{subpatterns.inspect}>"
     end
   end
 
@@ -384,8 +338,8 @@ module PatternMatch
     end
 
     def match(vals)
-      if @next and @next.quantifier?
-        repeating_match(vals, @next.longest?) do |rewind|
+      if directly_quantified?
+        repeating_match(vals, @next.greedy?) do |rewind|
           if rewind.ntimes < @next.min_k
             next false
           end
@@ -400,20 +354,20 @@ module PatternMatch
 
     def validate
       super
-      raise MalformedPatternError if @subpatterns.empty?
+      raise MalformedPatternError if subpatterns.empty?
       raise MalformedPatternError unless @parent.kind_of?(HasOrderedSubPatterns)
     end
 
     private
 
     def make_rewind(n)
-      PatternRewind.new(n, @subpatterns[0], (@next and @next.quantifier?) ? @next.next : @next)
+      PatternRewind.new(n, subpatterns[0], directly_quantified? ? @next.next : @next)
     end
 
-    def repeating_match(vals, longest)
+    def repeating_match(vals, is_greedy)
       quantifier = @next
-      lp = longest_patterns(vals)
-      (longest ? lp : lp.reverse).each do |rewind|
+      candidates = generate_candidates(vals)
+      (is_greedy ? candidates : candidates.reverse).each do |rewind|
         vars.each {|i| i.set_bind_to(quantifier) }
         begin
           with_rewind(rewind) do
@@ -428,37 +382,37 @@ module PatternMatch
       false
     end
 
-    def longest_patterns(vals)
+    def generate_candidates(vals)
       vals.length.downto(0).map do |n|
         make_rewind(n)
       end
     end
 
     def with_rewind(rewind)
-      @subpatterns[-1].next = rewind
+      subpatterns[-1].next = rewind
       yield rewind
     ensure
-      @subpatterns[-1].next = nil
+      subpatterns[-1].next = nil
     end
   end
 
   class PatternAnd < PatternElement
     def match(vals)
       super do |val|
-        @subpatterns.all? {|i| i.match([val]) }
+        subpatterns.all? {|i| i.match([val]) }
       end
     end
 
     def validate
       super
-      raise MalformedPatternError if @subpatterns.empty?
+      raise MalformedPatternError if subpatterns.empty?
     end
   end
 
   class PatternOr < PatternElement
     def match(vals)
       super do |val|
-        @subpatterns.find do |i|
+        subpatterns.find do |i|
           begin
             i.match([val])
           rescue PatternNotMatch
@@ -470,7 +424,7 @@ module PatternMatch
 
     def validate
       super
-      raise MalformedPatternError if @subpatterns.empty?
+      raise MalformedPatternError if subpatterns.empty?
       raise MalformedPatternError unless vars.empty?
     end
   end
@@ -479,7 +433,7 @@ module PatternMatch
     def match(vals)
       super do |val|
         begin
-          ! @subpatterns[0].match([val])
+          ! subpatterns[0].match([val])
         rescue PatternNotMatch
           true
         end
@@ -488,7 +442,7 @@ module PatternMatch
 
     def validate
       super
-      raise MalformedPatternError unless @subpatterns.length == 1
+      raise MalformedPatternError unless subpatterns.length == 1
       raise MalformedPatternError unless vars.empty?
     end
   end
@@ -559,7 +513,7 @@ module PatternMatch
       ::Kernel.raise ::ArgumentError, "wrong number of arguments (#{args.length} for 0)" unless args.empty?
       case name.to_s
       when /\A__(\d+)(\??)\z/
-        PatternQuantifier.new($1.to_i, ! $2.empty?)
+        PatternQuantifier.new($1.to_i, $2.empty?)
       else
         PatternVariable.new(name)
       end
@@ -570,8 +524,10 @@ module PatternMatch
       when 0
         uscore = PatternVariable.new(:_)
         class << uscore
+          using PatternMatch if respond_to?(:using, true)
+
           def [](*args)
-            Array.call(*args)
+            Array.(*args)
           end
 
           def vars
@@ -685,26 +641,27 @@ module PatternMatch
     end
     private_constant :Env
   end
-end
 
-module Kernel
-  private
+  refine Object do
 
-  def match(*vals, &block)
-    do_match = Proc.new do |val|
-      env = PatternMatch.const_get(:Env).new(self, val)
-      catch(:exit_match) do
-        env.instance_eval(&block)
-        raise PatternMatch::NoMatchingPatternError
+    private
+
+    def match(*vals, &block)
+      do_match = Proc.new do |val|
+        env = Env.new(self, val)
+        catch(:exit_match) do
+          env.instance_eval(&block)
+          raise NoMatchingPatternError
+        end
+      end
+      case vals.length
+      when 0
+        do_match
+      when 1
+        do_match.(vals[0])
+      else
+        raise ArgumentError, "wrong number of arguments (#{vals.length} for 0..1)"
       end
-    end
-    case vals.length
-    when 0
-      do_match
-    when 1
-      do_match.(vals[0])
-    else
-      raise ArgumentError, "wrong number of arguments (#{vals.length} for 0..1)"
     end
   end
 end

data/lib/pattern-match/deconstructor.rb

@@ -1,60 +1,78 @@
-require 'pattern-match/core'
+require 'pattern-match/version'
 
-class Class
-  include PatternMatch::Deconstructable
+module PatternMatch
+  refine Object do
+    private
 
-  def deconstruct(val)
-    raise NotImplementedError, "need to define `#{__method__}'"
+    def pattern_matcher(*subpatterns)
+      PatternObjectDeconstructor.new(self, *subpatterns)
+    end
   end
 
-  private
+  module Deconstructable
+    using PatternMatch if respond_to?(:using, true)
 
-  def accept_self_instance_only(val)
-    raise PatternMatch::PatternNotMatch unless val.kind_of?(self)
+    def call(*subpatterns)
+      pattern_matcher(*subpatterns)
+    end
   end
-end
 
-class << Array
-  def deconstruct(val)
-    accept_self_instance_only(val)
-    val
+  refine Class do
+    include PatternMatch::Deconstructable
+
+    def deconstruct(val)
+      raise NotImplementedError, "need to define `#{__method__}'"
+    end
+
+    private
+
+    def accept_self_instance_only(val)
+      raise PatternMatch::PatternNotMatch unless val.kind_of?(self)
+    end
   end
-end
 
-class << Struct
-  def deconstruct(val)
-    accept_self_instance_only(val)
-    val.values
+  refine Array.singleton_class do
+    def deconstruct(val)
+      accept_self_instance_only(val)
+      val
+    end
   end
-end
 
-class << Complex
-  def deconstruct(val)
-    accept_self_instance_only(val)
-    val.rect
+  refine Struct.singleton_class do
+    def deconstruct(val)
+      accept_self_instance_only(val)
+      val.values
+    end
   end
-end
 
-class << Rational
-  def deconstruct(val)
-    accept_self_instance_only(val)
-    [val.numerator, val.denominator]
+  refine Complex.singleton_class do
+    def deconstruct(val)
+      accept_self_instance_only(val)
+      val.rect
+    end
   end
-end
 
-class << MatchData
-  def deconstruct(val)
-    accept_self_instance_only(val)
-    val.captures.empty? ? [val[0]] : val.captures
+  refine Rational.singleton_class do
+    def deconstruct(val)
+      accept_self_instance_only(val)
+      [val.numerator, val.denominator]
+    end
+  end
+
+  refine MatchData.singleton_class do
+    def deconstruct(val)
+      accept_self_instance_only(val)
+      val.captures.empty? ? [val[0]] : val.captures
+    end
   end
-end
 
-class Regexp
-  include PatternMatch::Deconstructable
+  refine Regexp do
+    include PatternMatch::Deconstructable
 
-  def deconstruct(val)
-    m = Regexp.new("\\A#{source}\\z", options).match(val.to_s)
-    raise PatternMatch::PatternNotMatch unless m
-    m.captures.empty? ? [m[0]] : m.captures
+    def deconstruct(val)
+      m = Regexp.new("\\A#{source}\\z", options).match(val.to_s)
+      raise PatternMatch::PatternNotMatch unless m
+      m.captures.empty? ? [m[0]] : m.captures
+    end
   end
 end

data/lib/pattern-match/disable_refinements.rb

@@ -0,0 +1,25 @@
+class Module
+  methods = Module.instance_methods(false) + Module.private_instance_methods(false)
+  if methods.include?(:refine)
+    if methods.include?(:__refine_orig)
+      raise LoadError, "can't re-define Module#refine"
+    end
+    alias_method :__refine_orig, :refine
+    remove_method :refine
+  end
+
+  def refine(klass, &blk)
+    klass.class_eval(&blk)
+  end
+
+  begin
+    require 'pattern-match'
+  ensure
+    remove_method :refine
+
+    if Kernel.respond_to?(:__refine_orig, true)
+      alias_method :refine, :__refine_orig
+      remove_method :__refine_orig
+    end
+  end
+end

data/lib/pattern-match/experimental.rb

@@ -1,7 +1,57 @@
 require 'pattern-match/core'
+require 'continuation'
+require 'set'
+
+raise LoadError, 'Module#prepend required' unless Module.respond_to?(:prepend, true)
 
 module PatternMatch
+  class Pattern
+    module Backtrackable
+      def match(vals)
+        matched = super
+        if root? and not matched and not choice_points.empty?
+          restore_choice_point
+        end
+        matched
+      end
+
+      def choice_points
+        if root?
+          @choice_points ||= []
+        else
+          @parent.choice_points
+        end
+      end
+
+      private
+
+      def repeating_match(vals, is_greedy)
+        super do |vs, rest|
+          cont = nil
+          if callcc {|c| cont = c; yield vs, rest }
+            save_choice_point(cont)
+            true
+          else
+            false
+          end
+        end
+      end
+
+      def save_choice_point(choice_point)
+        choice_points.push(choice_point)
+      end
+
+      def restore_choice_point
+        choice_points.pop.call(false)
+      end
+    end
+
+    prepend Backtrackable
+  end
+
   module Deconstructable
+    using PatternMatch if respond_to?(:using, true)
+
     remove_method :call
     def call(*subpatterns)
       if Object == self
@@ -31,6 +81,98 @@ module PatternMatch
       end
     end
   end
+
+  class PatternKeywordArgStyleDeconstructor < PatternDeconstructor
+    def initialize(klass, checker, getter, *keyarg_subpatterns)
+      spec = normalize_keyword_arg(keyarg_subpatterns)
+      super(*spec.values)
+      @klass = klass
+      @checker = checker
+      @getter = getter
+      @spec = spec
+    end
+
+    def match(vals)
+      super do |val|
+        next false unless val.kind_of?(@klass)
+        next false unless @spec.keys.all? {|k| val.__send__(@checker, k) }
+        @spec.all? do |k, pat|
+          pat.match([val.__send__(@getter, k)]) rescue false
+        end
+      end
+    end
+
+    def inspect
+      "#<#{self.class.name}: klass=#{@klass.inspect}, spec=#{@spec.inspect}>"
+    end
+
+    private
+
+    def normalize_keyword_arg(subpatterns)
+      syms = subpatterns.take_while {|i| i.kind_of?(Symbol) }
+      rest = subpatterns.drop(syms.length)
+      hash = case rest.length
+             when 0
+               {}
+             when 1
+               rest[0]
+             else
+               raise MalformedPatternError
+             end
+      variables = Hash[syms.map {|i| [i, PatternVariable.new(i)] }]
+      Hash[variables.merge(hash).map {|k, v| [k, v.kind_of?(Pattern) ? v : PatternValue.new(v)] }]
+    end
+  end
+
+  class << Set
+    def pattern_matcher(*subpatterns)
+      PatternSetDeconstructor.new(self, *subpatterns)
+    end
+  end
+
+  class PatternSetDeconstructor < PatternDeconstructor
+    def initialize(klass, *subpatterns)
+      super(*subpatterns)
+      @klass = klass
+    end
+
+    def match(vals)
+      super do |val|
+        next false unless val.kind_of?(@klass)
+        members = val.to_a
+        next false unless subpatterns.length <= members.length
+        members.permutation(subpatterns.length).find do |perm|
+          cont = nil
+          if callcc {|c| cont = c; perm.zip(subpatterns).all? {|i, pat| pat.match([i]) } }
+            save_choice_point(cont)
+            true
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+
+  class PatternVariable
+    def <<(converter)
+      @converter = converter.respond_to?(:call) ? converter : converter.to_proc
+      self
+    end
+
+    prepend Module.new {
+      def initialize(name)
+        super
+        @converter = nil
+      end
+
+      private
+
+      def bind(val)
+        super(@converter ? @converter.call(val) : val)
+      end
+    }
+  end
 end
 
 class Hash
@@ -38,6 +180,8 @@ class Hash
 end
 
 class Object
+  using PatternMatch if respond_to?(:using, true)
+
   def assert_pattern(pattern)
     match(self) do
       Kernel.eval("with(#{pattern}) { self }", Kernel.binding)

data/lib/pattern-match/version.rb

@@ -1,3 +1,3 @@
 module PatternMatch
-  VERSION = "0.5.1"
+  VERSION = "1.0.0"
 end

data/pattern-match.gemspec

@@ -16,8 +16,10 @@ Gem::Specification.new do |s|
   s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables      = `git ls-files -- bin/*`.split("\n").map{|f| File.basename(f) }
   s.require_paths    = ['lib']
+  s.add_development_dependency 'test-unit'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'simplecov'
   s.extra_rdoc_files = ['README.rdoc']
   s.rdoc_options     = ['--main', 'README.rdoc']
+  s.licenses         = ['2-clause BSDL', "Ruby's"]
 end

data/test/helper.rb

@@ -1,3 +1,11 @@
+require 'test/unit/assertions'
+
+module Test::Unit::Assertions
+  def pass
+    assert(true)
+  end
+end
+
 begin
   if ENV['COVERAGE']
     require 'simplecov'

data/test/test_experimental.rb

@@ -1,7 +1,16 @@
 require_relative 'helper'
-require 'test/unit'
-require_relative '../lib/pattern-match'
-require_relative '../lib/pattern-match/experimental'
+require 'test-unit'
+if ENV['DISABLE_REFINEMENTS']
+  require_relative '../lib/pattern-match/disable_refinements'
+  require_relative '../lib/pattern-match'
+else
+  require_relative '../lib/pattern-match'
+  using PatternMatch
+end
+begin
+  require_relative '../lib/pattern-match/experimental'
+rescue LoadError
+end
 
 class TestExperimental < Test::Unit::TestCase
   def test_matcher_attribute_matcher
@@ -58,7 +67,7 @@ class TestExperimental < Test::Unit::TestCase
     match({a: 0, b: 1}) do
       with(Hash.(:a, :b, b: b2)) do
         assert_equal(0, a)
-        assert_raise(NameError) { b }
+        assert_raises(NameError) { b }
         assert_equal(1, b2)
       end
       with(_) { flunk }
@@ -75,18 +84,65 @@ class TestExperimental < Test::Unit::TestCase
       with(_) { flunk }
     end
 
-    assert_raise(PatternMatch::MalformedPatternError) do
+    assert_raises(PatternMatch::MalformedPatternError) do
       match(0) do
         with(Object.(a, b)) {}
       end
     end
   end
 
+  def test_matcher_class_set
+    match([Set[0, 1, 2], Set[3, 4]]) do
+      with(_[Set.(a, b), Set.(c)], guard { a + b * c == 2 } ) do
+        assert_equal(2, a)
+        assert_equal(0, b)
+        assert_equal(3, c)
+      end
+    end
+  end
+
   def test_object_assert_pattern
     assert_equal([0], [0].assert_pattern('_[Fixnum]'))
     assert_equal([0], [0].assert_pattern('_[a & Fixnum], guard { a.even? }'))
-    assert_raise(PatternMatch::NoMatchingPatternError) do
+    assert_raises(PatternMatch::NoMatchingPatternError) do
       [0, 1].assert_pattern('_[Fixnum]')
     end
   end
-end
+
+  def test_pattern_variable_converter
+    match([0, 1]) do
+      with(_[a << :to_s, b << ->(i){ i.to_s }]) do
+        assert_equal('0', a)
+        assert_equal('1', b)
+      end
+      with(_) { flunk }
+    end
+  end
+
+  def test_quantifier_with_backtracking
+    match([[0, 0], [0, 1]]) do
+      with(_[_[*a, *_], _[*a, *_]]) do
+        assert_equal([0], a)
+      end
+      with(_) { flunk }
+    end
+
+    match([[0, 1], 2]) do
+      with(_[_[*a, *b], c], guard { a.empty? }) do
+        assert_equal([], a)
+        assert_equal([0, 1], b)
+        assert_equal(2, c)
+      end
+      with(_) { flunk }
+    end
+  end
+
+  def test_sequence_with_backtracking
+    match([[0, 0, 0], [0, 1, 2]]) do
+      with(_[_[Seq(a), ___, *_], _[Seq(a), ___, *_]]) do
+        assert_equal([0], a)
+      end
+      with(_) { flunk }
+    end
+  end
+end if defined? PatternMatch::AttributeMatcher

data/test/test_standard.rb

@@ -1,6 +1,12 @@
 require_relative 'helper'
-require 'test/unit'
-require_relative '../lib/pattern-match'
+require 'test-unit'
+if ENV['DISABLE_REFINEMENTS']
+  require_relative '../lib/pattern-match/disable_refinements'
+  require_relative '../lib/pattern-match'
+else
+  require_relative '../lib/pattern-match'
+  using PatternMatch
+end
 
 class TestStandard < Test::Unit::TestCase
   def test_basic
@@ -18,10 +24,10 @@ class TestStandard < Test::Unit::TestCase
       with(_) { flunk }
     end
     assert_equal(4, ret)
-    assert_raise(NameError) { a }
-    assert_raise(NameError) { b }
+    assert_raises(NameError) { a }
+    assert_raises(NameError) { b }
 
-    assert_raise(PatternMatch::NoMatchingPatternError) do
+    assert_raises(PatternMatch::NoMatchingPatternError) do
       match(0) do
         with(1) { flunk }
         with(2) { flunk }
@@ -39,7 +45,7 @@ class TestStandard < Test::Unit::TestCase
       with(_) { flunk }
     end
 
-    assert_raise(ArgumentError) do
+    assert_raises(ArgumentError) do
       match(0) do
         p 1
       end
@@ -63,21 +69,21 @@ class TestStandard < Test::Unit::TestCase
             end
             assert_equal(1, a)
             assert_equal(2, b)
-            assert_raise(NameError) { c }
+            assert_raises(NameError) { c }
           end
         end
         assert_equal(0, a)
-        assert_raise(NameError) { b }
-        assert_raise(NameError) { c }
+        assert_raises(NameError) { b }
+        assert_raises(NameError) { c }
       end
     end
-    assert_raise(NameError) { a }
-    assert_raise(NameError) { b }
-    assert_raise(NameError) { c }
+    assert_raises(NameError) { a }
+    assert_raises(NameError) { b }
+    assert_raises(NameError) { c }
   end
 
   def test_lexical_scoping(rec_call = false, f = nil)
-    skip 'not supported'
+    omit 'not supported'
     unless rec_call
       match(0) do
         with(a) do
@@ -90,7 +96,7 @@ class TestStandard < Test::Unit::TestCase
         end
       end
     else
-      assert_raise(NameError) { a }
+      assert_raises(NameError) { a }
       assert_equal(0, f.())
       match(1) do
         with(a) do
@@ -105,7 +111,7 @@ class TestStandard < Test::Unit::TestCase
   end
 
   def test_override_singleton_method
-    skip 'Module#prepend not supported' unless Module.respond_to?(:prepend, true)
+    omit 'Module#prepend is not defined' unless Module.respond_to?(:prepend, true)
     match(0) do
       with(_test_override_singleton_method) do
         def self._test_override_singleton_method
@@ -119,12 +125,12 @@ class TestStandard < Test::Unit::TestCase
   def test_uscore
     match([0, 1, Fixnum]) do
       with(_[_, ! _(Float), _(Fixnum, :==)]) do
-        assert_raise(NameError) { _ }
+        assert_raises(NameError) { _ }
       end
       with(_) { flunk }
     end
 
-    assert_raise(PatternMatch::MalformedPatternError) do
+    assert_raises(PatternMatch::MalformedPatternError) do
       match(0) do
         with(_(0, :==, nil)) {}
       end
@@ -228,25 +234,25 @@ class TestStandard < Test::Unit::TestCase
       with(_) { flunk }
     end
 
-    assert_raise(PatternMatch::MalformedPatternError) do
+    assert_raises(PatternMatch::MalformedPatternError) do
       match(0) do
         with(___) {}
       end
     end
 
-    assert_raise(PatternMatch::MalformedPatternError) do
+    assert_raises(PatternMatch::MalformedPatternError) do
       match(0) do
         with(_[___]) {}
       end
     end
 
-    assert_raise(PatternMatch::MalformedPatternError) do
+    assert_raises(PatternMatch::MalformedPatternError) do
       match(0) do
         with(_[_[___]]) {}
       end
     end
 
-    assert_raise(PatternMatch::MalformedPatternError) do
+    assert_raises(PatternMatch::MalformedPatternError) do
       match(0) do
         with(_[a, ___, ___]) {}
       end
@@ -304,6 +310,18 @@ class TestStandard < Test::Unit::TestCase
       end
       with(_) { flunk }
     end
+
+    match([0, 1]) do
+      with(_[a, __0, *_]) do
+        assert_equal([0, 1], a)
+      end
+    end
+
+    match([0, 1]) do
+      with(_[a, __0?, *_]) do
+        assert_equal([], a)
+      end
+    end
   end
 
   def test_sequence
@@ -382,25 +400,25 @@ class TestStandard < Test::Unit::TestCase
       with(_) { flunk }
     end
 
-    assert_raise(PatternMatch::MalformedPatternError) do
+    assert_raises(PatternMatch::MalformedPatternError) do
       match(0) do
         with(Seq()) {}
       end
     end
 
-    assert_raise(PatternMatch::MalformedPatternError) do
+    assert_raises(PatternMatch::MalformedPatternError) do
       match(0) do
         with(_[Seq()]) {}
       end
     end
 
-    assert_raise(PatternMatch::MalformedPatternError) do
+    assert_raises(PatternMatch::MalformedPatternError) do
       match([0]) do
         with(_[a & Seq(0)]) {}
       end
     end
 
-    assert_raise(NotImplementedError) do
+    assert_raises(NotImplementedError) do
       match([0]) do
         with(_[Seq(a & Fixnum, ___), ___]) {}
       end
@@ -448,7 +466,7 @@ class TestStandard < Test::Unit::TestCase
       with(_) { flunk }
     end
 
-    assert_raise(PatternMatch::MalformedPatternError) do
+    assert_raises(PatternMatch::MalformedPatternError) do
       match(1) do
         with(a | b) {}
       end
@@ -459,19 +477,19 @@ class TestStandard < Test::Unit::TestCase
       with(_) { flunk }
     end
 
-    assert_raise(PatternMatch::MalformedPatternError) do
+    assert_raises(PatternMatch::MalformedPatternError) do
       match(1) do
         with(! a) {}
       end
     end
 
-    assert_raise(PatternMatch::MalformedPatternError) do
+    assert_raises(PatternMatch::MalformedPatternError) do
       match(1) do
         with(a | ___) {}
       end
     end
 
-    assert_raise(PatternMatch::MalformedPatternError) do
+    assert_raises(PatternMatch::MalformedPatternError) do
       match(1) do
         with(a & ___) {}
       end
@@ -492,25 +510,25 @@ class TestStandard < Test::Unit::TestCase
       with(_) { flunk }
     end
 
-    assert_raise(PatternMatch::MalformedPatternError) do
+    assert_raises(PatternMatch::MalformedPatternError) do
       match(1) do
         with(And()) {}
       end
     end
 
-    assert_raise(PatternMatch::MalformedPatternError) do
+    assert_raises(PatternMatch::MalformedPatternError) do
       match(1) do
         with(Or()) {}
       end
     end
 
-    assert_raise(PatternMatch::MalformedPatternError) do
+    assert_raises(PatternMatch::MalformedPatternError) do
       match(1) do
         with(Not()) {}
       end
     end
 
-    assert_raise(PatternMatch::MalformedPatternError) do
+    assert_raises(PatternMatch::MalformedPatternError) do
       match(1) do
         with(Not(0, 1)) {}
       end
@@ -522,14 +540,14 @@ class TestStandard < Test::Unit::TestCase
   end
 
   def test_match_too_many_arguments
-    assert_raise(ArgumentError) do
+    assert_raises(ArgumentError) do
       match(0, 1) do
       end
     end
   end
 
   def test_deconstructor_class
-    assert_raise(NotImplementedError) do
+    assert_raises(NotImplementedError) do
       c = Class.new
       match(0) do
         with(c.(a)) do
@@ -610,4 +628,18 @@ class TestStandard < Test::Unit::TestCase
       with(_) { flunk }
     end
   end
+
+  def test_refinements
+    if ENV['DISABLE_REFINEMENTS']
+      assert_kind_of(PatternMatch.const_get(:Pattern), eval('Class.()', TOPLEVEL_BINDING))
+      assert_equal(0, eval('match(0) { with(_) { 0 } }', TOPLEVEL_BINDING))
+    else
+      assert_raises(NoMethodError) do
+        eval('Class.()', TOPLEVEL_BINDING)
+      end
+      assert_raises(NoMethodError) do
+        eval('match(0) { with(_) { 0 } }', TOPLEVEL_BINDING)
+      end
+    end
+  end
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: pattern-match
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Kazuki Tsujimoto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-02 00:00:00.000000000 Z
+date: 2015-02-07 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  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: rake
   requirement: !ruby/object:Gem::Requirement
@@ -56,6 +70,7 @@ files:
 - lib/pattern-match.rb
 - lib/pattern-match/core.rb
 - lib/pattern-match/deconstructor.rb
+- lib/pattern-match/disable_refinements.rb
 - lib/pattern-match/experimental.rb
 - lib/pattern-match/version.rb
 - pattern-match.gemspec
@@ -63,7 +78,9 @@ files:
 - test/test_experimental.rb
 - test/test_standard.rb
 homepage: https://github.com/k-tsj/pattern-match
-licenses: []
+licenses:
+- 2-clause BSDL
+- Ruby's
 metadata: {}
 post_install_message: 
 rdoc_options:
@@ -83,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: A pattern matching library