pattern-match 0.0.2 → 0.1.0

data/README.rdoc

@@ -63,7 +63,7 @@ or
 
  ## (D)
  class EMail
-   def self.extract(value)
+   def self.deconstruct(value)
      value.to_s.split(/@/).tap {|parts| raise PatternNotMatch unless parts.length == 2 }
    end
  end

data/lib/pattern-match/version.rb

@@ -1,3 +1,3 @@
 module PatternMatch
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/lib/pattern-match.rb

@@ -9,7 +9,7 @@ module PatternMatch
     SUPPORT_REFINEMENTS = true
   else
     SUPPORT_REFINEMENTS = false
-    Module.module_eval {
+    Module.module_eval do
       private
 
       def refine(klass, &block)
@@ -18,10 +18,10 @@ module PatternMatch
 
       def using(klass)
       end
-    }
+    end
   end
 
-  module Extractable
+  module Deconstructable
     def call(*subpatterns)
       if Object == self
         raise MalformedPatternError unless subpatterns.length == 1
@@ -38,7 +38,11 @@ module PatternMatch
 
   module NameSpace
     refine Class do
-      include Extractable
+      include Deconstructable
+
+      def deconstruct(val)
+        raise NotImplementedError, "need to define `#{__method__}'"
+      end
 
       private
 
@@ -48,35 +52,35 @@ module PatternMatch
     end
 
     refine Array.singleton_class do
-      def extract(val)
+      def deconstruct(val)
         accept_self_instance_only(val)
         val
       end
     end
 
     refine Struct.singleton_class do
-      def extract(val)
+      def deconstruct(val)
         accept_self_instance_only(val)
         val.values
       end
     end
 
     refine Complex.singleton_class do
-      def extract(val)
+      def deconstruct(val)
         accept_self_instance_only(val)
         val.rect
       end
     end
 
     refine Rational.singleton_class do
-      def extract(val)
+      def deconstruct(val)
         accept_self_instance_only(val)
         [val.numerator, val.denominator]
       end
     end
 
     refine MatchData.singleton_class do
-      def extract(val)
+      def deconstruct(val)
         accept_self_instance_only(val)
         val.captures.empty? ? [val[0]] : val.captures
       end
@@ -86,26 +90,26 @@ module PatternMatch
       def Struct.method_added(name)
         if name == members[0]
           this = self
-          PatternMatch::NameSpace.module_eval {
+          PatternMatch::NameSpace.module_eval do
             refine this.singleton_class do
-              include Extractable
+              include Deconstructable
             end
-          }
+          end
         end
       end
 
       refine Proc do
-        include Extractable
+        include Deconstructable
 
-        def extract(val)
+        def deconstruct(val)
           [self === val]
         end
       end
 
       refine Symbol do
-        include Extractable
+        include Deconstructable
 
-        def extract(val)
+        def deconstruct(val)
           [self.to_proc === val]
         end
       end
@@ -113,14 +117,14 @@ module PatternMatch
 
     refine Symbol do
       def call(*args)
-        Proc.new {|obj| obj.send(self, *args) }
+        Proc.new {|obj| obj.__send__(self, *args) }
       end
     end
 
     refine Regexp do
-      include Extractable
+      include Deconstructable
 
-      def extract(val)
+      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
@@ -142,7 +146,7 @@ module PatternMatch
     end
 
     def vars
-      @subpatterns.map(&:vars).inject([], :concat)
+      @subpatterns.map(&:vars).flatten
     end
 
     def binding
@@ -230,7 +234,7 @@ module PatternMatch
     end
 
     def match(val)
-      extracted_vals = pattern_match_env.call_refined_method(@extractor, :extract, val)
+      extracted_vals = pattern_match_env.call_refined_method(@extractor, :deconstruct, val)
       k = extracted_vals.length - (@subpatterns.length - 2)
       quantifier = @subpatterns.find {|i| i.is_a?(PatternQuantifier) }
       if quantifier
@@ -329,7 +333,7 @@ module PatternMatch
     end
 
     def match(val)
-      @val.send(@compare_by, val)
+      @val.__send__(@compare_by, val)
     end
   end
 
@@ -357,10 +361,6 @@ module PatternMatch
   end
 
   class PatternNot < Pattern
-    def initialize(subpattern)
-      super
-    end
-
     def match(val)
       ! @subpatterns[0].match(val)
     rescue PatternNotMatch
@@ -446,13 +446,19 @@ module PatternMatch
       tmpbinding_module(obj).instance_eval do
         begin
           binding.each do |name, val|
-            define_method(name) { val }
-            private name
+            stack = @stacks[name]
+            if stack.empty?
+              define_method(name) { stack[-1] }
+              private name
+            end
+            stack.push(val)
           end
           obj.instance_eval(&block)
         ensure
           binding.each do |name, _|
-            remove_method(name) if private_method_defined? name
+            if @stacks[name].tap(&:pop).empty?
+              remove_method(name)
+            end
           end
         end
       end
@@ -465,6 +471,9 @@ module PatternMatch
       m = obj.singleton_class.ancestors.find {|i| i.is_a? TmpBindingModule }
       unless m
         m = TmpBindingModule.new
+        m.instance_eval do
+          @stacks = ::Hash.new {|h, k| h[k] = [] }
+        end
         obj.extend(m)
       end
       m
@@ -486,7 +495,7 @@ module Kernel
         using ::PatternMatch::NameSpace
 
         def call_refined_method(obj, name, *args)
-          obj.send(name, *args)
+          obj.__send__(name, *args)
         end
       end
       env.instance_eval(&block)

data/test/test_pattern-match.rb

@@ -38,17 +38,61 @@ class TestPatternMatch < Test::Unit::TestCase
   end
 
   def test_variable_shadowing
-    skip 'not implemented yet'
     match(0) {
       with(a) {
-        match(1) {
-          with(a) {
+        assert_equal(0, a)
+        match([1, 2]) {
+          with(_[a, b]) {
+            assert_equal(1, a)
+            assert_equal(2, b)
+            match([3, 4, 5]) {
+              with(_[a, b, c]) {
+                assert_equal(3, a)
+                assert_equal(4, b)
+                assert_equal(5, c)
+              }
+            }
             assert_equal(1, a)
+            assert_equal(2, b)
+            assert_raise(NameError) { c }
           }
         }
         assert_equal(0, a)
+        assert_raise(NameError) { b }
+        assert_raise(NameError) { c }
       }
     }
+    assert_raise(NameError) { a }
+    assert_raise(NameError) { b }
+    assert_raise(NameError) { c }
+  end
+
+  def test_lexical_scoping(rec_call = false, f = nil)
+    skip 'not supported'
+    unless rec_call
+      match(0) {
+        with(a) {
+          assert_equal(0, a)
+          test_lexical_scoping(true, ->{ a }) {|g|
+            assert_equal(0, a)
+            assert_equal(1, g.())
+          }
+          assert_equal(0, a)
+        }
+      }
+    else
+      assert_raise(NameError) { a }
+      assert_equal(0, f.())
+      match(1) {
+        with(a) {
+          assert_equal(1, a)
+          assert_equal(0, f.())
+          yield ->{ a }
+          assert_equal(1, a)
+          assert_equal(0, f.())
+        }
+      }
+    end
   end
 
   def test_uscore
@@ -254,6 +298,16 @@ class TestPatternMatch < Test::Unit::TestCase
     assert_equal(1, 2.times.find(&match { with(1) { true } }))
   end
 
+  def test_extractor_class
+    assert_raise(NotImplementedError) {
+      c = Class.new
+      match(0) {
+        with(c.(a)) {
+        }
+      }
+    }
+  end
+
   def test_extractor_class_struct
     s = Struct.new(:a, :b, :c)
     match(s[0, 1, 2]) {
@@ -403,7 +457,7 @@ class TestPatternMatch < Test::Unit::TestCase
     c = Class.new
     ::PatternMatch::NameSpace.module_eval {
       refine c.singleton_class do
-        def extract(*)
+        def deconstruct(*)
           [:c]
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pattern-match
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-04 00:00:00.000000000 Z
+date: 2012-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &6408560 !ruby/object:Gem::Requirement
+  requirement: &8625920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *6408560
+  version_requirements: *8625920
 description: A pattern matching library.
 email:
 - kazuki@callcc.net
@@ -57,7 +57,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2122497246809249036
+      hash: -900071050850383955
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -66,7 +66,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2122497246809249036
+      hash: -900071050850383955
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.11