pattern-match 0.5.0 → 0.5.1

data/lib/pattern-match/deconstructor.rb

@@ -0,0 +1,60 @@
+require 'pattern-match/core'
+
+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

data/lib/pattern-match/experimental.rb

@@ -0,0 +1,46 @@
+require 'pattern-match/core'
+
+module PatternMatch
+  module Deconstructable
+    remove_method :call
+    def call(*subpatterns)
+      if Object == self
+        PatternKeywordArgStyleDeconstructor.new(Object, :respond_to?, :__send__, *subpatterns)
+      else
+        pattern_matcher(*subpatterns)
+      end
+    end
+  end
+
+  module AttributeMatcher
+    def self.included(klass)
+      class << klass
+        def pattern_matcher(*subpatterns)
+          PatternKeywordArgStyleDeconstructor.new(self, :respond_to?, :__send__, *subpatterns)
+        end
+      end
+    end
+  end
+
+  module KeyMatcher
+    def self.included(klass)
+      class << klass
+        def pattern_matcher(*subpatterns)
+          PatternKeywordArgStyleDeconstructor.new(self, :has_key?, :[], *subpatterns)
+        end
+      end
+    end
+  end
+end
+
+class Hash
+  include PatternMatch::KeyMatcher
+end
+
+class Object
+  def assert_pattern(pattern)
+    match(self) do
+      Kernel.eval("with(#{pattern}) { self }", Kernel.binding)
+    end
+  end
+end

data/lib/pattern-match/version.rb

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

data/pattern-match.gemspec

@@ -17,6 +17,7 @@ Gem::Specification.new do |s|
   s.executables      = `git ls-files -- bin/*`.split("\n").map{|f| File.basename(f) }
   s.require_paths    = ['lib']
   s.add_development_dependency 'rake'
+  s.add_development_dependency 'simplecov'
   s.extra_rdoc_files = ['README.rdoc']
   s.rdoc_options     = ['--main', 'README.rdoc']
 end

data/test/helper.rb

@@ -0,0 +1,9 @@
+begin
+  if ENV['COVERAGE']
+    require 'simplecov'
+    SimpleCov.start do
+      add_filter '/test/'
+    end
+  end
+rescue LoadError
+end

data/test/test_experimental.rb

@@ -0,0 +1,92 @@
+require_relative 'helper'
+require 'test/unit'
+require_relative '../lib/pattern-match'
+require_relative '../lib/pattern-match/experimental'
+
+class TestExperimental < Test::Unit::TestCase
+  def test_matcher_attribute_matcher
+    person_class = Struct.new(:name, :age) do
+      include PatternMatch::AttributeMatcher
+    end
+
+    company_class = Struct.new(:name) do
+      include PatternMatch::AttributeMatcher
+    end
+
+    match([person_class.new("Mary", 50), company_class.new("C")]) do
+      with(_[company_class.(:name => "Mary"), company_class.(:name => "C")]) { flunk }
+      with(_[person_class.(:age, :name => person_name), company_class.(:name => company_name)]) do
+        assert_equal("Mary", person_name)
+        assert_equal(50, age)
+        assert_equal("C", company_name)
+      end
+      with(_) { flunk }
+    end
+  end
+
+  def test_matcher_class_hash
+    match({a: 0, b: 1}) do
+      with(Hash.(a: a, b: b, c: c)) { flunk }
+      with(Hash.(a: a, b: b)) do
+        assert_equal(0, a)
+        assert_equal(1, b)
+      end
+      with(_) { flunk }
+    end
+
+    match({a: 0, b: 1}) do
+      with(Hash.(a: a)) do
+        assert_equal(0, a)
+      end
+      with(_) { flunk }
+    end
+
+    match({a: 0}) do
+      with(Hash.(a: 0)) { pass }
+      with(_) { flunk }
+    end
+
+    match({a: 0, b: 1}) do
+      with(Hash.(:a, :b, :c)) { flunk }
+      with(Hash.(:a, :b)) do
+        assert_equal(0, a)
+        assert_equal(1, b)
+      end
+      with(_) { flunk }
+    end
+
+    match({a: 0, b: 1}) do
+      with(Hash.(:a, :b, b: b2)) do
+        assert_equal(0, a)
+        assert_raise(NameError) { b }
+        assert_equal(1, b2)
+      end
+      with(_) { flunk }
+    end
+  end
+
+  def test_matcher_class_object
+    match(0) do
+      with(Object.(:to_s, :to_i => i & 1)) { flunk }
+      with(Object.(:to_s, :to_i => i & 0)) do
+        assert_equal('0', to_s)
+        assert_equal(0, i)
+      end
+      with(_) { flunk }
+    end
+
+    assert_raise(PatternMatch::MalformedPatternError) do
+      match(0) do
+        with(Object.(a, b)) {}
+      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
+      [0, 1].assert_pattern('_[Fixnum]')
+    end
+  end
+end

data/test/{test_pattern-match.rb → test_standard.rb}

@@ -1,11 +1,13 @@
+require_relative 'helper'
 require 'test/unit'
 require_relative '../lib/pattern-match'
 
-class TestPatternMatch < Test::Unit::TestCase
+class TestStandard < Test::Unit::TestCase
   def test_basic
     this = self
     ret = match([0, 1, 2, 3]) do
       with(nil) { flunk }
+      with(_[]) { flunk }
       with(_[a, 0, 0, b]) { flunk }
       with(_[a, Fixnum , 2, b]) do
         assert_equal(this, self)
@@ -31,6 +33,17 @@ class TestPatternMatch < Test::Unit::TestCase
       with(i, guard { i.even? }) { pass }
       with(_) { flunk }
     end
+
+    match([]) do
+      with(_[]) { pass }
+      with(_) { flunk }
+    end
+
+    assert_raise(ArgumentError) do
+      match(0) do
+        p 1
+      end
+    end
   end
 
   def test_variable_shadowing
@@ -92,7 +105,7 @@ class TestPatternMatch < Test::Unit::TestCase
   end
 
   def test_override_singleton_method
-    skip 'Module#prepend not supported' unless Module.private_method_defined?(:prepend)
+    skip 'Module#prepend not supported' unless Module.respond_to?(:prepend, true)
     match(0) do
       with(_test_override_singleton_method) do
         def self._test_override_singleton_method
@@ -110,6 +123,12 @@ class TestPatternMatch < Test::Unit::TestCase
       end
       with(_) { flunk }
     end
+
+    assert_raise(PatternMatch::MalformedPatternError) do
+      match(0) do
+        with(_(0, :==, nil)) {}
+      end
+    end
   end
 
   def test_splat
@@ -498,10 +517,17 @@ class TestPatternMatch < Test::Unit::TestCase
     end
   end
 
-  def test_match_without_argument
+  def test_match_without_arguments
     assert_equal(1, 2.times.find(&match { with(1) { true }; with(_) { false } }))
   end
 
+  def test_match_too_many_arguments
+    assert_raise(ArgumentError) do
+      match(0, 1) do
+      end
+    end
+  end
+
   def test_deconstructor_class
     assert_raise(NotImplementedError) do
       c = Class.new
@@ -524,26 +550,6 @@ class TestPatternMatch < Test::Unit::TestCase
     end
   end
 
-  def test_deconstructor_class_attributes_with_hash
-    person_class = Struct.new(:name, :age) do
-      include PatternMatch::AttributeMatcher
-    end
-
-    company_class = Struct.new(:name) do
-      include PatternMatch::AttributeMatcher
-    end
-
-    match([person_class.new("Mary", 50), company_class.new("C")]) do
-      with(_[company_class.(:name => "Mary"), company_class.(:name => "C")]) { flunk }
-      with(_[person_class.(:age, :name => person_name), company_class.(:name => company_name)]) do
-        assert_equal("Mary", person_name)
-        assert_equal(50, age)
-        assert_equal("C", company_name)
-      end
-      with(_) { flunk }
-    end
-  end
-
   def test_deconstructor_class_complex
     match(Complex(0, 1)) do
       with(Complex.(a, b)) do
@@ -604,62 +610,4 @@ class TestPatternMatch < Test::Unit::TestCase
       with(_) { flunk }
     end
   end
-
-  def test_deconstructor_class_hash
-    match({a: 0, b: 1}) do
-      with(Hash.(a: a, b: b, c: c)) { flunk }
-      with(Hash.(a: a, b: b)) do
-        assert_equal(0, a)
-        assert_equal(1, b)
-      end
-      with(_) { flunk }
-    end
-
-    match({a: 0, b: 1}) do
-      with(Hash.(a: a)) do
-        assert_equal(0, a)
-      end
-      with(_) { flunk }
-    end
-
-    match({a: 0}) do
-      with(Hash.(a: 0)) { pass }
-      with(_) { flunk }
-    end
-
-    match({a: 0, b: 1}) do
-      with(Hash.(:a, :b, :c)) { flunk }
-      with(Hash.(:a, :b)) do
-        assert_equal(0, a)
-        assert_equal(1, b)
-      end
-      with(_) { flunk }
-    end
-
-    match({a: 0, b: 1}) do
-      with(Hash.(:a, :b, b: b2)) do
-        assert_equal(0, a)
-        assert_raise(NameError) { b }
-        assert_equal(1, b2)
-      end
-      with(_) { flunk }
-    end
-  end
-
-  def test_object
-    match(0) do
-      with(Object.(:to_s, :to_i => i & 1)) { flunk }
-      with(Object.(:to_s, :to_i => i & 0)) do
-        assert_equal('0', to_s)
-        assert_equal(0, i)
-      end
-      with(_) { flunk }
-    end
-
-    assert_raise(PatternMatch::MalformedPatternError) do
-      match(0) do
-        with(Object.(a, b)) {}
-      end
-    end
-  end
 end

metadata

@@ -1,27 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: pattern-match
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Kazuki Tsujimoto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-23 00:00:00.000000000 Z
+date: 2014-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   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: simplecov
+  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'
 description: A pattern matching library.
@@ -32,39 +46,44 @@ extensions: []
 extra_rdoc_files:
 - README.rdoc
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - BSDL
 - COPYING
 - Gemfile
 - README.rdoc
 - Rakefile
 - lib/pattern-match.rb
+- lib/pattern-match/core.rb
+- lib/pattern-match/deconstructor.rb
+- lib/pattern-match/experimental.rb
 - lib/pattern-match/version.rb
 - pattern-match.gemspec
-- test/test_pattern-match.rb
+- test/helper.rb
+- test/test_experimental.rb
+- test/test_standard.rb
 homepage: https://github.com/k-tsj/pattern-match
 licenses: []
 metadata: {}
 post_install_message: 
 rdoc_options:
-- --main
+- "--main"
 - README.rdoc
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: A pattern matching library