pattern-match 0.1.1 → 0.1.2

data/BSDL

@@ -1,4 +1,4 @@
-Copyright (C) 2012 Kazuki Tsujimoto, All rights reserved.
+Copyright (C) 2012-2013 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 Kazuki Tsujimoto, All rights reserved.
+Copyright (C) 2012-2013 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

@@ -49,18 +49,6 @@ or
    }
  end
 
- # With Refinements
- def balance(left, key, right)
-   match([left, key, right]) {
-     with(_[R[a, x, b], y, R[c, z, d]]) { R[B[a, x, b], y, B[c, z, d]] }
-     with(_[R[R[a, x, b], y, c], z, d]) { R[B[a, x, b], y, B[c, z, d]] }
-     with(_[R[a, x, R[b, y, c]], z, d]) { R[B[a, x, b], y, B[c, z, d]] }
-     with(_[a, x, R[b, y, R[c, z, d]]]) { R[B[a, x, b], y, B[c, z, d]] }
-     with(_[a, x, R[R[b, y, c], z, d]]) { R[B[a, x, b], y, B[c, z, d]] }
-     with(_) { B[left, key, right] }
-   }
- end
-
  ## (D)
  class EMail
    def self.deconstruct(value)
@@ -74,13 +62,6 @@ or
    }
  }
 
- # With Refinements
- match(['foo-bar@example.com', 'baz-bar@example.com']) {
-   with(_[mail & EMail[name & /(\w+)-(\w+)/[firstname, 'bar'], domain], ___]) {
-     p [firstname, name, domain, mail] # => [["foo", "baz"], ["foo-bar", "baz-bar"], ["example.com", "example.com"], ["foo-bar@example.com", "baz-bar@example.com"]]
-   }
- }
-
  ## (E)
  match(10) {
    with(Object.(:to_i => a, :foobar => b)) { :not_match }
@@ -89,14 +70,6 @@ or
    }
  }
 
- # With Refinements
- match(10) {
-   with(:to_i[a] & :foobar[b]) { :not_match }
-   with(:to_i[a] & :to_s.(16)[b])) {
-     p [a, b] #=> [10, "a"]
-   }
- }
-
 You can see another example in test/test_pattern-match.rb.
 
 == Development

data/lib/pattern-match.rb

@@ -1,26 +1,10 @@
 # pattern-match.rb
 #
-# Copyright (C) 2012 Kazuki Tsujimoto, All rights reserved.
+# Copyright (C) 2012-2013 Kazuki Tsujimoto, All rights reserved.
 
 require 'pattern-match/version'
 
 module PatternMatch
-  if Module.private_method_defined? :refine
-    SUPPORT_REFINEMENTS = true
-  else
-    SUPPORT_REFINEMENTS = false
-    Module.module_eval do
-      private
-
-      def refine(klass, &block)
-        klass.class_eval(&block)
-      end
-
-      def using(klass)
-      end
-    end
-  end
-
   module Deconstructable
     def call(*subpatterns)
       if Object == self
@@ -33,117 +17,15 @@ module PatternMatch
         PatternDeconstructor.new(self, *subpatterns)
       end
     end
-
-    if SUPPORT_REFINEMENTS
-      alias [] call
-    end
-  end
-
-  module NameSpace
-    refine Class do
-      include Deconstructable
-
-      def deconstruct(val)
-        raise NotImplementedError, "need to define `#{__method__}'"
-      end
-
-      private
-
-      def accept_self_instance_only(val)
-        raise PatternNotMatch unless val.kind_of?(self)
-      end
-    end
-
-    refine Array.singleton_class do
-      def deconstruct(val)
-        accept_self_instance_only(val)
-        val
-      end
-    end
-
-    refine Struct.singleton_class do
-      def deconstruct(val)
-        accept_self_instance_only(val)
-        val.values
-      end
-    end
-
-    refine Complex.singleton_class do
-      def deconstruct(val)
-        accept_self_instance_only(val)
-        val.rect
-      end
-    end
-
-    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
-
-    if SUPPORT_REFINEMENTS
-      def Struct.method_added(name)
-        if name == members[0]
-          this = self
-          PatternMatch::NameSpace.module_eval do
-            refine this.singleton_class do
-              include Deconstructable
-            end
-          end
-        end
-      end
-
-      refine Proc do
-        include Deconstructable
-
-        def deconstruct(val)
-          [self === val]
-        end
-      end
-
-      refine Symbol do
-        include Deconstructable
-
-        def deconstruct(val)
-          [self.to_proc === val]
-        end
-      end
-    end
-
-    refine Symbol do
-      def call(*args)
-        Proc.new {|obj| obj.__send__(self, *args) }
-      end
-    end
-
-    refine Regexp do
-      include Deconstructable
-
-      def deconstruct(val)
-        m = Regexp.new("\\A#{source}\\z", options).match(val.to_s)
-        raise PatternNotMatch unless m
-        m.captures.empty? ? [m[0]] : m.captures
-      end
-    end
   end
 
   class Pattern
     attr_accessor :parent, :next, :prev
-    attr_writer :pattern_match_env
 
     def initialize(*subpatterns)
       @parent = nil
       @next = nil
       @prev = nil
-      @pattern_match_env = nil
       @subpatterns = subpatterns.map {|i| i.kind_of?(Pattern) ? i : PatternValue.new(i) }
       set_subpatterns_relation
     end
@@ -189,10 +71,6 @@ module PatternMatch
       @subpatterns.each(&:validate)
     end
 
-    def pattern_match_env
-      @pattern_match_env || @parent.pattern_match_env
-    end
-
     private
 
     def set_subpatterns_relation
@@ -243,19 +121,19 @@ module PatternMatch
   end
 
   class PatternDeconstructor < Pattern
-    def initialize(extractor, *subpatterns)
+    def initialize(deconstructor, *subpatterns)
       super(*subpatterns)
-      @extractor = extractor
+      @deconstructor = deconstructor
     end
 
     def match(val)
-      extracted_vals = pattern_match_env.call_refined_method(@extractor, :deconstruct, val)
-      k = extracted_vals.length - (@subpatterns.length - 2)
+      deconstructed_vals = @deconstructor.deconstruct(val)
+      k = deconstructed_vals.length - (@subpatterns.length - 2)
       quantifier = @subpatterns.find {|i| i.kind_of?(PatternQuantifier) }
       if quantifier
         return false unless quantifier.min_k <= k
       else
-        return false unless @subpatterns.length == extracted_vals.length
+        return false unless @subpatterns.length == deconstructed_vals.length
       end
       @subpatterns.flat_map do |pat|
         case
@@ -267,7 +145,7 @@ module PatternMatch
         else
           [pat]
         end
-      end.zip(extracted_vals).all? do |pat, v|
+      end.zip(deconstructed_vals).all? do |pat, v|
         pat.match(v)
       end
     end
@@ -399,7 +277,6 @@ module PatternMatch
     def with(pat_or_val, guard_proc = nil, &block)
       pat = pat_or_val.kind_of?(Pattern) ? pat_or_val : PatternValue.new(pat_or_val)
       pat.validate
-      pat.pattern_match_env = self
       if pat.match(@val) and (guard_proc ? with_tmpbinding(@ctx, pat.binding, &guard_proc) : true)
         ret = with_tmpbinding(@ctx, pat.binding, &block)
         ::Kernel.throw(:exit_match, ret)
@@ -428,10 +305,9 @@ module PatternMatch
       case vals.length
       when 0
         uscore = PatternVariable.new(:_)
-        uscore.pattern_match_env = self
         class << uscore
           def [](*args)
-            pattern_match_env.call_refined_method(::Array, :call, *args)
+            Array.call(*args)
           end
 
           def match(val)
@@ -509,7 +385,7 @@ module PatternMatch
     constants.each do |c|
       klass = const_get(c)
       next unless klass.kind_of?(Class)
-      if klass.ancestors.find {|i| i == Pattern }
+      if klass <= Pattern
         private_constant c
       end
     end
@@ -523,13 +399,6 @@ module Kernel
   def match(*vals, &block)
     do_match = Proc.new do |val|
       env = PatternMatch.const_get(:Env).new(self, val)
-      class << env
-        using ::PatternMatch::NameSpace
-
-        def call_refined_method(obj, name, *args)
-          obj.__send__(name, *args)
-        end
-      end
       catch(:exit_match) do
         env.instance_eval(&block)
         raise ::PatternMatch::NoMatchingPatternError
@@ -545,3 +414,68 @@ module Kernel
     end
   end
 end
+
+class Class
+  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
+
+class << Array
+  def deconstruct(val)
+    accept_self_instance_only(val)
+    val
+  end
+end
+
+class << Struct
+  def deconstruct(val)
+    accept_self_instance_only(val)
+    val.values
+  end
+end
+
+class << Complex
+  def deconstruct(val)
+    accept_self_instance_only(val)
+    val.rect
+  end
+end
+
+class << Rational
+  def deconstruct(val)
+    accept_self_instance_only(val)
+    [val.numerator, val.denominator]
+  end
+end
+
+class << MatchData
+  def deconstruct(val)
+    accept_self_instance_only(val)
+    val.captures.empty? ? [val[0]] : val.captures
+  end
+end
+
+class Regexp
+  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
+  end
+end
+
+class Symbol
+  def call(*args)
+    Proc.new {|obj| obj.__send__(self, *args) }
+  end
+end

data/lib/pattern-match/version.rb

@@ -1,3 +1,3 @@
 module PatternMatch
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/test/test_pattern-match.rb

@@ -312,7 +312,7 @@ class TestPatternMatch < Test::Unit::TestCase
     assert_equal(1, 2.times.find(&match { with(1) { true }; with(_) { false } }))
   end
 
-  def test_extractor_class
+  def test_deconstructor_class
     assert_raise(NotImplementedError) {
       c = Class.new
       match(0) {
@@ -322,7 +322,7 @@ class TestPatternMatch < Test::Unit::TestCase
     }
   end
 
-  def test_extractor_class_struct
+  def test_deconstructor_class_struct
     s = Struct.new(:a, :b, :c)
     match(s[0, 1, 2]) {
       with(s.(a, b, c)) {
@@ -334,20 +334,7 @@ class TestPatternMatch < Test::Unit::TestCase
     }
   end
 
-  def test_extractor_struct_with_refinements
-    skip 'refinements not supported' unless PatternMatch::SUPPORT_REFINEMENTS
-    s = Struct.new(:a, :b, :c)
-    match(s[0, 1, 2]) {
-      with(s[a, b, c]) {
-        assert_equal(0, a)
-        assert_equal(1, b)
-        assert_equal(2, c)
-      }
-      with(_) { flunk }
-    }
-  end
-
-  def test_extractor_class_complex
+  def test_deconstructor_class_complex
     match(Complex(0, 1)) {
       with(Complex.(a, b)) {
         assert_equal(0, a)
@@ -357,7 +344,7 @@ class TestPatternMatch < Test::Unit::TestCase
     }
   end
 
-  def test_extractor_class_rational
+  def test_deconstructor_class_rational
     match(Rational(0, 1)) {
       with(Rational.(a, b)) {
         assert_equal(0, a)
@@ -367,7 +354,7 @@ class TestPatternMatch < Test::Unit::TestCase
     }
   end
 
-  def test_extractor_class_matchdata
+  def test_deconstructor_class_matchdata
     m = /.../.match('abc')
     match(m) {
       with(MatchData.(a)) {
@@ -387,7 +374,7 @@ class TestPatternMatch < Test::Unit::TestCase
     }
   end
 
-  def test_extractor_obj_regexp
+  def test_deconstructor_obj_regexp
     match('abc') {
       with(/./.(a)) { flunk }
       with(a & /.../.(b)) {
@@ -408,48 +395,6 @@ class TestPatternMatch < Test::Unit::TestCase
     }
   end
 
-  def test_extractor_obj_regexp_with_refinements
-    skip 'refinements not supported' unless PatternMatch::SUPPORT_REFINEMENTS
-    match('abc') {
-      with(/./[a]) { flunk }
-      with(a & /.../[b]) {
-        assert_equal('abc', a)
-        assert_equal('abc', b)
-      }
-      with(_) { flunk }
-    }
-
-    match('abc') {
-      with(a & /(.)(.)(.)/[b, c ,d]) {
-        assert_equal('abc', a)
-        assert_equal('a', b)
-        assert_equal('b', c)
-        assert_equal('c', d)
-      }
-      with(_) { flunk }
-    }
-  end
-
-  def test_extractor_obj_proc_with_refinements
-    skip 'refinements not supported' unless PatternMatch::SUPPORT_REFINEMENTS
-    match(0) {
-      with((Proc.new {|i| i + 1 })[a]) {
-        assert_equal(1, a)
-      }
-      with(_) { flunk }
-    }
-  end
-
-  def test_extractor_obj_symbol_with_refinements
-    skip 'refinements not supported' unless PatternMatch::SUPPORT_REFINEMENTS
-    match(0) {
-      with(:to_s[a]) {
-        assert_equal('0', a)
-      }
-      with(_) { flunk }
-    }
-  end
-
   def test_object
     match(10) {
       with(Object.(:to_i => a, :to_s.(16) => b, :no_method => c)) { flunk }
@@ -484,19 +429,4 @@ class TestPatternMatch < Test::Unit::TestCase
       with(_) { flunk }
     }
   end
-
-  def test_refine_after_requiring_library
-    c = Class.new
-    ::PatternMatch::NameSpace.module_eval {
-      refine c.singleton_class do
-        def deconstruct(*)
-          [:c]
-        end
-      end
-    }
-    match(:c) {
-      with(c.(a)) { assert_equal(:c, a) }
-      with(_) { flunk }
-    }
-  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pattern-match
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-11 00:00:00.000000000 Z
+date: 2013-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &8646440 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,12 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *8646440
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A pattern matching library.
 email:
 - kazuki@callcc.net
@@ -57,7 +62,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1580258758057961953
+      hash: -3372255759969491054
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -66,10 +71,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1580258758057961953
+      hash: -3372255759969491054
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: A pattern matching library