patm 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1adf094454c70d6f4147b4c44e134a0204274e6c
+  data.tar.gz: 93e09c5195a23d9dfd2ac2e317841c4a6cb80afc
+SHA512:
+  metadata.gz: 80ada62d20ae8926cf97f27c120e70896e3f0d916e38058221afa60967b5a6701cb2ca8d1dd35c8807d104f616bddc62bd032f64e27857d67c2821e5a7aae2a9
+  data.tar.gz: 824f33ef73d6561932e620ca7e657c74ad2767301b32ede0c47677fc4a50010277a603e419b17967273d86320288e9a08788c47595ed3179f332c6d9cddeb09c

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 todesking
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,85 @@
+# PATM: PATtern Matcher for Ruby
+
+## Usage
+
+```ruby
+require 'patm'
+```
+
+```ruby
+# With case(simple but slow)
+def match(obj)
+  p = Patm
+  _xs = Patm::ARRAY_REST
+  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|
+  p = Patm
+  _xs = Patm::ARRAY_REST
+  r.on [:x, p._1, p._2] do|m|
+    [m._2, m._1]
+  end
+  r.on [1, _xs&p._1] do|m|
+    m._1
+  end
+end
+
+rule.apply([1,2,3])
+# => [2, 3]
+
+rule.apply([:x, :y, :z])
+# => [:z, :y]
+
+rule.apply([])
+# => nil
+```
+
+```ruby
+# With cached rules
+class A
+  def initialize
+    @rules = Patm::RuleCache.new
+  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
+
+  def match2(obj)
+    @rules.match(:match2, obj) do|r|
+      # ...
+    end
+  end
+end
+ ```
+
+
+## Changes
+
+### 0.0.1
+
+- Initial release
+

data/lib/patm.rb

@@ -0,0 +1,229 @@
+module Patm
+  class Pattern
+    def execute(match, obj); true; end
+
+    def rest?
+      false
+    end
+
+    def self.build_from(plain)
+      case plain
+      when Pattern
+        plain
+      when Array
+        if plain.last.is_a?(Pattern) && plain.last.rest?
+          Arr.new(plain[0..-2].map{|p| build_from(p) }, plain.last)
+        else
+          Arr.new(plain.map{|p| build_from(p) })
+        end
+      else
+        Obj.new(plain)
+      end
+    end
+
+    def &(rhs)
+      And.new([self, rhs])
+    end
+
+    class Arr < self
+      def initialize(head, rest = nil, tail = [])
+        @head = head
+        @rest = rest
+        @tail = tail
+      end
+
+      def execute(mmatch, obj)
+        size_min = @head.size + @tail.size
+        return false unless obj.is_a?(Array)
+        return false unless @rest ? (obj.size >= size_min) :  (obj.size == size_min)
+        @head.zip(obj[0..(@head.size - 1)]).all? {|pat, o|
+          pat.execute(mmatch, o)
+        } &&
+        @tail.zip(obj[(-@tail.size)..-1]).all? {|pat, o|
+          pat.execute(mmatch, o)
+        } &&
+        (!@rest || @rest.execute(mmatch, obj[@head.size..-(@tail.size+1)]))
+      end
+
+      def inspect; (@head + [@rest] + @tail).inspect; end
+    end
+
+    class ArrRest < self
+      def execute(mmatch, obj)
+        true
+      end
+      def rest?
+        true
+      end
+      def inspect; "..."; end
+    end
+
+    class Obj < self
+      def initialize(obj)
+        @obj = obj
+      end
+
+      def execute(mmatch, obj)
+        @obj === obj
+      end
+
+      def inspect
+        "OBJ(#{@obj.inspect})"
+      end
+    end
+
+    class Any < self
+      def execute(match, obj); true; end
+      def inspect; 'ANY'; end
+    end
+
+    class Group < self
+      def initialize(index)
+        @index = index
+      end
+      attr_reader :index
+      def execute(mmatch, obj)
+        mmatch[@index] = obj
+        true
+      end
+      def inspect; "GROUP(#{@index})"; end
+    end
+
+    class Or < self
+      def initialize(pats)
+        @pats = pats
+      end
+      def execute(mmatch, obj)
+        @pats.any? do|pat|
+          pat.execute(mmatch, obj)
+        end
+      end
+      def rest?
+        @pats.any?(&rest?)
+      end
+      def inspect
+        "OR(#{@pats.map(&:inspect).join(',')})"
+      end
+    end
+
+    class And <self
+      def initialize(pats)
+        @pats = pats
+      end
+      def execute(mmatch, obj)
+        @pats.all? do|pat|
+          pat.execute(mmatch, obj)
+        end
+      end
+      def rest?
+        @pats.any?(&:rest?)
+      end
+      def inspect
+        "AND(#{@pats.map(&:inspect).join(',')})"
+      end
+    end
+  end
+
+  ANY = Pattern::Any.new
+  GROUP = 100.times.map{|i| Pattern::Group.new(i) }
+  ARRAY_REST = Pattern::ArrRest.new
+
+  class Rule
+    def initialize(&block)
+      # { Pattern => Proc }
+      @rules = []
+      block[self]
+    end
+
+    def on(pat, &block)
+      @rules << [Pattern.build_from(pat), block]
+    end
+
+    def else(&block)
+      @rules << [ANY, lambda {|m,o| block[o] }]
+    end
+
+    def apply(obj)
+      match = Match.new
+      @rules.each do|(pat, block)|
+        if pat.execute(match, obj)
+          return block.call(match, obj)
+        end
+      end
+      nil
+    end
+  end
+
+  class RuleCache
+    def initialize
+      @rules = {}
+    end
+    def match(rule_name, obj, &rule)
+      (@rules[rule_name] ||= ::Patm::Rule.new(&rule)).apply(obj)
+    end
+  end
+
+  class Match
+    def initialize
+      @group = {}
+    end
+
+    def [](i)
+      @group[i]
+    end
+
+    def []=(i, val)
+      @group[i] = val
+    end
+
+    Patm::GROUP.each do|g|
+      define_method "_#{g.index}" do
+        self[g.index]
+      end
+    end
+  end
+
+  class CaseBinder
+    def initialize(pat)
+      @pat = pat
+      @match = Match.new
+    end
+
+    def ===(obj)
+      @pat.execute(@match, obj)
+    end
+
+    def [](i); @match[i]; end
+    Patm::GROUP.each do|g|
+      define_method "_#{g.index}" do
+        @match[g.index]
+      end
+    end
+  end
+
+  def self.match(plain_pat)
+    CaseBinder.new Pattern.build_from(plain_pat)
+  end
+
+  def self.match_array(head, rest_spat = nil, tail = [])
+    Match.new(
+      Pattern::Arr.new(
+        head.map{|e| Pattern.build_from(e)},
+        rest_spat,
+        tail.map{|e| Pattern.build_from(e)}
+      )
+    )
+  end
+
+  def self.or(*pats)
+    Pattern::Or.new(pats.map{|p| Pattern.build_from(p) })
+  end
+
+  class <<self
+    GROUP.each do|g|
+      define_method "_#{g.index}" do
+        g
+      end
+    end
+  end
+end

data/patm.gemspec

@@ -0,0 +1,21 @@
+Gem::Specification.new do |s|
+  s.platform    = Gem::Platform::RUBY
+  s.name        = 'patm'
+  s.version     = '0.0.1'
+  s.summary     = 'PATtern Matching library'
+  s.description = 'Pattern matching library for plain data structure'
+  s.required_ruby_version = '>= 1.9.0'
+  s.license     = 'MIT'
+
+  s.author            = 'todesking'
+  s.email             = 'discommucative@gmail.com'
+  s.homepage          = 'https://github.com/todesking/patm'
+
+  s.files         = `git ls-files`.split($\)
+  s.executables   = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency('rspec', '~>2.14')
+  s.add_development_dependency('pry', '~>0.9')
+end

data/spec/patm_spec.rb

@@ -0,0 +1,143 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'patm.rb')
+require 'pry'
+
+module PatmHelper
+  extend RSpec::Matchers::DSL
+
+  matcher :these_matches do|*matches|
+    match do|actual|
+      matches.all?{|m| m.matches?(actual) }
+    end
+  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 match; @match; end
+
+    def and_capture(g1, g2 = nil, g3 = nil)
+      these_matches(
+        self, _capture(self, g1, g2, g3)
+      )
+    end
+  end
+
+  matcher :_capture do|m, g1, g2, g3|
+    match do|_|
+      [m.match[1], m.match[2], m.match[3]] == [g1, g2, g3]
+    end
+  end
+
+end
+
+describe "Usage:" do
+  it 'with case expression' do
+    p = Patm
+    case [1, 2, 3]
+    when m = p.match([1, p._1, p._2])
+      [m._1, m._2]
+    else
+      []
+    end
+      .should == [2, 3]
+  end
+
+  it 'with predefined Rule' do
+    p = Patm
+    r = p::Rule.new 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
+end
+
+describe Patm::Pattern do
+  include PatmHelper
+  def self.pattern(plain, &b)
+    context "pattern '#{plain.inspect}'" do
+      subject { Patm::Pattern.build_from(plain) }
+      instance_eval(&b)
+    end
+  end
+
+  pattern 1 do
+    it { should match_to(1) }
+    it { should_not match_to(2) }
+  end
+
+  pattern [] do
+    it { should match_to [] }
+    it { should_not match_to {} }
+    it { should_not match_to [1] }
+  end
+
+  pattern [1,2] do
+    it { should match_to [1,2] }
+    it { should_not match_to [1] }
+    it { should_not match_to [1, -1] }
+    it { should_not match_to [1,2,3] }
+  end
+
+  pattern Patm::ANY do
+    it { should match_to 1 }
+    it { should match_to ["foo", "bar"] }
+  end
+
+  pattern [1, Patm::ANY, 3] do
+    it { should match_to [1, 2, 3] }
+    it { should match_to [1, 0, 3] }
+    it { should_not match_to [1, 0, 4] }
+  end
+
+  pattern Patm.or(1, 2) do
+    it { should match_to 1 }
+    it { should match_to 2 }
+    it { should_not match_to 3 }
+  end
+
+  pattern Patm._1 do
+    it { should match_to(1).and_capture(1) }
+    it { should match_to('x').and_capture('x') }
+  end
+
+  pattern [0, Patm._1, Patm._2] do
+    it { should match_to([0, 1, 2]).and_capture(1, 2) }
+    it { should_not match_to(['x', 1, 2]).and_capture(1, 2) }
+  end
+
+  pattern [0, 1, Patm::ARRAY_REST] do
+    it { should_not match_to([0]) }
+    it { should match_to([0, 1]) }
+    it { should match_to([0, 1, 2, 3]) }
+  end
+
+  pattern [0, 1, Patm::ARRAY_REST & Patm._1] do
+    it { should match_to([0, 1]).and_capture([]) }
+    it { should match_to([0, 1, 2, 3]).and_capture([2, 3]) }
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: patm
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- todesking
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: Pattern matching library for plain data structure
+email: discommucative@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- lib/patm.rb
+- patm.gemspec
+- spec/patm_spec.rb
+homepage: https://github.com/todesking/patm
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: PATtern Matching library
+test_files:
+- spec/patm_spec.rb