match-maker 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.rbx
+

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in matchmaker.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Simão Mata
+
+MIT License
+
+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,157 @@
+# Matchmaker
+
+Simple pattern matching library for ruby.
+
+## Examples
+
+### Simple match by class name
+
+```ruby
+require 'matchmaker'
+
+class Dummy
+  def initialize(x, y, z)
+    @x, @y, @z = 1, 2, 3
+  end
+
+  def sum
+    @x + @y + @z
+  end
+end
+
+obj = Dummy.new(1, 2, 3)
+
+Matchmaker.match(obj) do
+  pattern Dummy do puts "Dummy class matched" end
+end
+
+# => Dummy class matched
+
+```
+
+### Matching by implemented methods and instance variables
+
+```ruby
+Matchmaker.match(obj) do
+  pattern Dummy, :w do puts "obj does not have w" end
+  pattern Dummy, :sum do puts "But it has a sum: #{sum}" end
+end
+
+# => But it has a sum: 6
+
+# You don't even need to specify a class
+Matchmaker.match(obj) do
+  pattern :w do puts "obj does not have w" end
+  pattern :sum do puts "But it has a sum" end
+end
+
+# => But it has a sum
+
+```
+
+### You can access instance variables and methods declared in the pattern
+
+```ruby
+Matchmaker.match(obj) do
+  pattern Dummy, :x, :sum do puts "x is #{x}, sum is #{sum}" end
+end
+
+# => x is 1, sum is 6
+```
+
+### You can use `__` as a 'catch all' pattern
+```ruby
+Matchmaker.match(obj) do
+  pattern Array do puts "obj is an array" end
+  __ do puts "Default matcher matched" end
+end
+
+# => Default matcher matched
+```
+
+### Match a nil value with nil
+
+```ruby
+Matchmaker.match(nil) do
+  pattern Dummy do puts "this does not match" end
+  pattern nil do puts "I AM NIL!!!" end
+end
+
+# => I AM NIL!!!
+```
+
+### Gets even more interesting when using Array matchers
+
+```ruby
+array_obj = [1, 2, 3]
+
+Matchmaker.match(array_obj) do
+  enum :x do puts "Does not match because array_objs.size > 1"  end
+  enum :x, :y, :z, :a do puts "does not match because it's too small" end
+  enum :x, :y, :z do puts "You can access x: #{x}, y: #{y} and #{z}" end
+end
+
+# => You can access x: 1, y: 2 and 3
+
+Matchmaker.match([]) do
+  enum nil do puts "[] or nil matches any empty enum" end
+end
+
+# => [] or nil matches any empty enum
+
+# You can use the `enum_cons` matcher to split the enum
+Matchmaker.match(array_obj) do
+  enum_cons :x, :xs do puts "You can access head #{x} and tail #{xs} of the enum" end
+end
+
+Matchmaker.match(array_obj) do
+  enum_cons :x, :y, :xs do puts "More than one element before tail: #{y}" end
+end
+
+Matchmaker.match([1]) do
+  enum_cons :x, :xs do puts "The tail can be empty: x: #{x}, xs: #{xs}" end
+end
+
+# => The tail can be empty: x: 1, xs: []
+```
+
+### Hashes are kind of supported ;)
+
+```ruby
+hash_obj = {a: 1, b: 2}
+
+Matchmaker.match(hash_obj) do
+    enum_cons :x, :y, :xs do puts "head: #{x}, y: #{y}, tail: #{xs}" end
+end
+
+# => head: [:a, 1], y: [:b, 2], tail: []
+
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'matchmaker'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install matchmaker
+
+## Usage
+
+See examples.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Have fun writing some code
+4. Remember to run tests `ruby matchmaker_spec.rb`
+5. Commit your changes (`git commit -am 'Add some feature'`)
+6. Push to the branch (`git push origin my-new-feature`)
+7. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/matchmaker.rb

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+require 'matchmaker/version'
+require 'matchmaker/matcher'
+
+require 'matchmaker/evaluator'
+require 'matchmaker/class_matcher'
+require 'matchmaker/default_matcher'
+require 'matchmaker/enum'
+
+module Matchmaker
+  class NoMatchError < RuntimeError; end
+
+  def self.matchers
+    {
+      :__ => DefaultMatcher,
+      :pattern => ClassMatcher,
+      :enum_cons => Enum::EnumConsMatcher,
+      :enum => Enum::EnumMatcher
+    }
+  end
+
+  def self.default_matcher(subject)
+    Matcher.new(subject, matchers)
+  end
+
+  def self.match(subject, &block)
+    default_matcher(subject).match(&block)
+  end
+
+  class << self
+    alias_method :marry, :match
+  end
+end

data/lib/matchmaker/class_matcher.rb

@@ -0,0 +1,56 @@
+module Matchmaker
+  class ClassMatcherBindings
+    attr_reader :subject, :names
+
+    def initialize(subject, names)
+      @subject, @names = subject, names
+    end
+
+    def each_name(&block)
+      @names.each(&block)
+    end
+
+    def get(name)
+      if subject.instance_variable_defined?("@#{name}")
+        subject.instance_variable_get("@#{name}")
+      elsif subject.respond_to?(name)
+        subject.send(name)
+      end
+    end
+  end
+
+  class ClassMatcher
+    def initialize(subject)
+      @subject = subject
+    end
+
+    def subject_matches?(*args)
+      if args == [nil]
+        klass = NilClass
+        vars = []
+      elsif !args.first.is_a?(Class)
+        klass = Object
+        vars = args
+      else
+        klass = args.first
+        vars = args[1, args.size]
+      end
+
+      return false unless @subject.is_a?(klass)
+
+      vars.all? do |v|
+        @subject.instance_variable_defined?("@#{v}") || @subject.respond_to?(v)
+      end
+    end
+
+    def eval(*args, block)
+      vars = args.compact
+      vars = args[1, args.size] if args.first.is_a?(Class)
+
+      bindings = ClassMatcherBindings.new(@subject, vars)
+
+      Evaluator.new.run_block(bindings, block)
+    end
+  end
+end
+

data/lib/matchmaker/default_matcher.rb

@@ -0,0 +1,17 @@
+module Matchmaker
+  class EmptyBindings
+    def each_name; end
+  end
+
+  class DefaultMatcher
+    def initialize(*args); end
+
+    def subject_matches?(*args)
+      true
+    end
+
+    def eval(*args, block)
+      Evaluator.new.run_block(EmptyBindings.new, block)
+    end
+  end
+end

data/lib/matchmaker/enum.rb

@@ -0,0 +1,2 @@
+require 'matchmaker/enum/enum_matcher'
+require 'matchmaker/enum/enum_cons'

data/lib/matchmaker/enum/enum_cons.rb

@@ -0,0 +1,54 @@
+module Matchmaker
+  module Enum
+    class EnumBindings
+      def initialize(enum, names)
+        @bindings = build_bindings(enum, names)
+      end
+
+      def build_bindings(enum, names)
+        return {} if names == [nil] || names == [[]] || names == [{}]
+        enum = enum.dup
+        res = {}
+
+        names.each_with_index do |name, i|
+          e = enum.shift
+
+          if e.nil?
+            res[name] = []
+            break
+          elsif i == names.size - 1
+            res[name] = enum.unshift(e)
+          else
+            res[name] = e
+          end
+        end
+
+        res
+      end
+
+      def each_name(&block)
+        @bindings.keys.each(&block)
+      end
+
+      def get(name)
+        @bindings[name]
+      end
+    end
+
+    class EnumConsMatcher
+      def initialize(subject)
+        @subject = subject
+      end
+
+      def subject_matches?(*args)
+        return false unless @subject.is_a?(Enumerable)
+        return true if @subject.empty? && (args == [nil] || args == [[]])
+        @subject.size >= (args.size - 1)
+      end
+
+      def eval(*args, block)
+        Evaluator.new.run_block(EnumBindings.new(@subject, args), block)
+      end
+    end
+  end
+end

data/lib/matchmaker/enum/enum_matcher.rb

@@ -0,0 +1,40 @@
+module Matchmaker
+  module Enum
+    class HashBindings
+      def initialize(enum, bindings)
+        @bindings = bindings
+      end
+
+      def each_name(&block)
+        @bindings.keys.each(&block)
+      end
+
+      def get(name)
+        @bindings[name]
+      end
+    end
+
+    class EnumMatcher
+      def initialize(subject)
+        @subject = subject
+      end
+
+      def subject_matches?(*args)
+        return false unless @subject.is_a?(Enumerable)
+        return true if @subject.empty? && (args == [nil] || args == [[]])
+        @subject.size == args.size
+      end
+
+      def eval(*args, block)
+        if args == [nil] || args == [[]]
+          hash_bindings = {}
+        else
+          hash_bindings = Hash[args.zip(@subject)]
+        end
+
+        bindings = HashBindings.new(@subject, hash_bindings)
+        Evaluator.new.run_block(bindings, block)
+      end
+    end
+  end
+end

data/lib/matchmaker/evaluator.rb

@@ -0,0 +1,13 @@
+module Matchmaker
+  class Evaluator
+    def run_block(bindings, block)
+      bindings.each_name do |name|
+        define_singleton_method(name) do
+          bindings.get(name)
+        end
+      end
+
+      instance_eval(&block)
+    end
+  end
+end

data/lib/matchmaker/matcher.rb

@@ -0,0 +1,38 @@
+module Matchmaker
+  class Matcher
+    attr_accessor :subject
+
+    def initialize(subject, matchers)
+      @subject = subject
+      @matched = false
+
+      setup_matchers(matchers)
+    end
+
+    def match(&block)
+      result = instance_eval(&block)
+      raise NoMatchError unless @matched
+      result
+    end
+
+    def call_matcher(klass, args, block)
+      return false if @matched
+      matcher = klass.new(subject)
+
+      if matcher.subject_matches?(*args)
+        @matched = true
+        matcher.eval(*args, block)
+      else
+        nil
+      end
+    end
+
+    def setup_matchers(matchers)
+      matchers.each do |sym, klass|
+        define_singleton_method(sym) do |*args, &block|
+          call_matcher(klass, args, block)
+        end
+      end
+    end
+  end
+end

data/lib/matchmaker/version.rb

@@ -0,0 +1,3 @@
+module Matchmaker
+  VERSION = "0.0.1"
+end

data/matchmaker.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'matchmaker/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "match-maker"
+  gem.version       = Matchmaker::VERSION
+  gem.authors       = ["Simão Mata"]
+  gem.email         = ["simao.m@gmail.com"]
+  gem.description   = %q{Pattern matching for ruby}
+  gem.summary       = %q{Simple pattern matching library for ruby}
+  gem.homepage      = "http://github.com/simao/matchmaker"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/spec/matchmaker_spec.rb

@@ -0,0 +1,269 @@
+require_relative 'spec_helper'
+
+module Matchmaker
+  class Dummy
+    attr_reader :x, :y, :z
+
+    def initialize(x, y, z)
+      @x, @y, @z = x, y, z
+    end
+
+    def calculation
+      x + y + z
+    end
+  end
+
+  describe ClassMatcher do
+    before do
+      @obj = Dummy.new(1, 2, 3)
+      @class_matcher = ClassMatcher.new(@obj)
+    end
+
+    describe "#subject_matches?" do
+      it "matches if classname is the same" do
+        @class_matcher.subject_matches?(Dummy).must_equal true
+      end
+
+      it "does not match if not all bindings are possible" do
+        @class_matcher.subject_matches?(Dummy, :undefined).must_equal false
+      end
+
+      it "matches nil without using explicit NilClass" do
+        @class_matcher = ClassMatcher.new(nil)
+        @class_matcher.subject_matches?(nil).must_equal true
+      end
+
+      it "does not match nil pattern if it's not a NilClass object" do
+        @class_matcher = ClassMatcher.new(@obj)
+        @class_matcher.subject_matches?(nil).must_equal false
+      end
+    end
+  end
+
+  describe Matcher do
+    describe "#match" do
+      before do
+        @matcher = Matcher.new(nil, Matchmaker.matchers)
+      end
+
+      it "only runs ONE matching block" do
+        probe = 0
+
+        @matcher.match do
+          pattern nil do probe = 1 end
+          __ do probe = 2 end
+        end
+
+        probe.must_equal 1
+      end
+
+      it "runs default block if exists" do
+        probe = 0
+
+        @matcher.match do
+          pattern Dummy do probe = 1 end
+          __ do probe = 2 end
+        end
+
+        probe.must_equal 2
+      end
+
+      it "raises exception if no pattern could be matched" do
+
+        proc {
+          @matcher.match do
+            pattern Dummy do nil end
+          end
+        }.must_raise NoMatchError
+
+      end
+
+      it "returns the value of the applied match" do
+        result = @matcher.match do
+          __ { 22 }
+        end
+
+        result.must_equal 22
+      end
+
+      describe "#pattern" do
+        before do
+          @obj = Dummy.new(1, 2, 3)
+          @matcher = Matcher.new(@obj, Matchmaker.matchers)
+        end
+
+        it "yields block when matching only class" do
+          probe = @matcher.pattern(Dummy) do probe = true end
+          probe.must_equal true
+        end
+
+        it "allows access to subject vars from block" do
+          x_value = @matcher.pattern(Dummy, :x) do x end
+
+          x_value.must_equal @obj.x
+        end
+
+        it "allows access to subject methods" do
+          v = @matcher.pattern(Dummy, :calculation) do calculation end
+          v.must_equal @obj.calculation
+        end
+
+        it "matches only methods/instance variables when not using class" do
+          v = @matcher.pattern(:x, :y) do x end
+          v.must_equal @obj.x
+        end
+      end
+    end
+
+    describe "#enum" do
+      describe "with a non empty enum" do
+        before do
+          @obj = [1, 2, 3]
+          @matcher = Matcher.new(@obj, Matchmaker.matchers)
+        end
+
+        it "matches array" do
+          v = @matcher.enum(:x, :y, :z) do [x, y, z] end
+          v.must_equal [1, 2, 3]
+        end
+
+        it "does not match if size is not the same" do
+          v = @matcher.enum(:x) do true end
+          v.must_be_nil
+        end
+
+        it "does not match if enum size is not big enough" do
+          v = @matcher.enum(:x) do true end
+          v.must_be_nil
+        end
+
+        it "does not match nil for empty subject" do
+          v = @matcher.enum(nil) do true end
+          v.must_be_nil
+        end
+      end
+
+    end
+
+    describe "with an empty enum" do
+      before do
+        @matcher = Matcher.new([], Matchmaker.matchers)
+      end
+
+      it "matches [] for empty subject" do
+        v = @matcher.enum([]) do true end
+        v.must_equal true
+      end
+
+      it "matches nil for empty subject" do
+        v = @matcher.enum(nil) do true end
+        v.must_equal true
+      end
+    end
+  end
+
+  describe "#enum_cons" do
+    describe "with arrays" do
+      before do
+        @obj = [1, 2, 3]
+        @matcher = Matcher.new(@obj, Matchmaker.matchers)
+      end
+
+      it "matches enumerable" do
+        v = @matcher.enum_cons do 1 end
+        v.must_equal 1
+      end
+
+      it "assigns head and tail" do
+        head = nil
+        tail = nil
+
+        @matcher.enum_cons(:x, :xs) do head = x; tail = xs end
+
+        head.must_equal 1
+        tail.must_equal [2, 3]
+      end
+
+      it "assigns elements first and then tail" do
+        head, head_y, tail = nil
+
+        @matcher.enum_cons(:x, :y, :xs) do head = x; head_y = y; tail = xs end
+
+        head.must_equal 1
+        head_y.must_equal 2
+        tail.must_equal [3]
+      end
+
+      it "allows to match an enum using an empty tail" do
+        head, head_y, head_z, tail = nil
+
+        @matcher.enum_cons(:x, :y, :z, :xs) do
+          head = x
+          head_y = y
+          head_z = z
+          tail = xs
+        end
+
+        head.must_equal 1
+        head_y.must_equal 2
+        head_z.must_equal 3
+        tail.must_equal []
+      end
+
+      it "does not match if not enough elements in enum" do
+        v = @matcher.enum_cons(:x, :y, :v, :z, :xs) do true end
+        v.must_be_nil
+      end
+
+    end
+
+    describe "with hashes" do
+      before do
+        @matcher = Matcher.new({:a => 1, :b => 2}, Matchmaker.matchers)
+      end
+
+      it "can match hashes" do
+        x_, y_, z_ = nil
+
+        @matcher.enum_cons(:x, :y, :z) do x_ = x; y_ = y; z_ = z end
+        x_.must_equal([:a, 1])
+        y_.must_equal([:b, 2])
+        z_.must_equal([])
+      end
+    end
+
+    describe "with empty enums" do
+      before do
+        @matcher = Matcher.new([], Matchmaker.matchers)
+      end
+
+      it "matches empty hash with matcher" do
+        @matcher = Matcher.new({}, Matchmaker.matchers)
+        v = @matcher.enum_cons({}) do true end
+        v.must_equal true
+      end
+
+      it "matches empty array with nil matcher" do
+        v = @matcher.enum_cons(nil) do true end
+        v.must_equal true
+      end
+
+      it "matches empty array with empty enum instance" do
+        v = @matcher.enum_cons([]) do true end
+        v.must_equal true
+      end
+    end
+  end
+
+  describe "#__" do
+    before do
+      @obj = Dummy.new(1, 2, 3)
+      @matcher = Matcher.new(@obj, Matchmaker.matchers)
+    end
+
+    it "always calls associated block" do
+      probe = @matcher.__ do true end
+      probe.must_equal true
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'minitest/autorun'
+
+$: << '../lib'
+
+require 'matchmaker'

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: match-maker
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Simão Mata
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-10 00:00:00.000000000 Z
+dependencies: []
+description: Pattern matching for ruby
+email:
+- simao.m@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/matchmaker.rb
+- lib/matchmaker/class_matcher.rb
+- lib/matchmaker/default_matcher.rb
+- lib/matchmaker/enum.rb
+- lib/matchmaker/enum/enum_cons.rb
+- lib/matchmaker/enum/enum_matcher.rb
+- lib/matchmaker/evaluator.rb
+- lib/matchmaker/matcher.rb
+- lib/matchmaker/version.rb
+- matchmaker.gemspec
+- spec/matchmaker_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/simao/matchmaker
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Simple pattern matching library for ruby
+test_files:
+- spec/matchmaker_spec.rb
+- spec/spec_helper.rb