pattern-matching 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dc55948d3772a5d4805826b923d12ae1f84f09cd
+  data.tar.gz: 6cf392b7bd93afe0e752c0fca586c2454ca583c1
+SHA512:
+  metadata.gz: 630fb32894b0074e0e3f273f8d83c37e845c1becc3609e532d226e2e7308389bf744296d9ea411fa8e0b2dbb3c51f21c87e22db37db46726128d4be6dbbd0a15
+  data.tar.gz: 9369b4042e2cd7760cd2ade36aa5c7e8cdc545f5071e20b67af0c0f98e6971ba17c193899ff6fdd8f6efd1608093e3b4530d129f3f8e16419a66af051224c254

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) Jerry D'Antonio -- released under the MIT license.
+
+http://www.opensource.org/licenses/mit-license.php  
+
+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,181 @@
+# PatternMatching [![Build Status](https://secure.travis-ci.org/jdantonio/pattern_matching.png)](http://travis-ci.org/jdantonio/pattern_matching?branch=master) [![Dependency Status](https://gemnasium.com/jdantonio/pattern_matching.png)](https://gemnasium.com/jdantonio/pattern_matching)
+
+A gem for adding Erlang-style pattern matching to Ruby classes.
+
+*NOTE: This is a work in progress. Expect changes.*
+
+## Introduction
+
+[Ruby](http://www.ruby-lang.org/en/) is my favorite programming by far. As much as I love Ruby I've always been a little disappointed that Ruby doesn't support function overloading. Function overloading tends to reduce branching and keep functions signatures simpler. No sweat, I learned to do without. Then I started programming in [Erlang](http://www.erlang.org/)…
+
+I've really started to enjoy working in Erlang. Erlang is good at all the things Ruby is bad at and vice versa. Together, Ruby and Erlang make me happy. My favotite Erlang feature is, without question, [pattern matching](http://learnyousomeerlang.com/syntax-in-functions#pattern-matching). Pattern matching is like function overloading cranked to 11. So one day I was musing on Twitter and one of my friends responded with "Build it!" So I did. And here it is.
+
+### Goals
+
+* Stay true to the spirit of Erlang pattern matching, if not the semantics
+* Keep the semantics as idiomatic Ruby as possible
+* Support features that make sense in Ruby
+* Exclude features that only make sense in Erlang
+* Avoid using #method_missing
+
+### Features
+
+* Basic pattern matching for instance methods.
+* Parameter count matching
+* Mathing against primitive values
+* Matching by class/datatype
+* Matching against specific key/vaue pairs in hashes
+* Matching against the presence of keys within hashes
+* Reasonable error messages when no match is found
+* Dispatching to superclass methods when no match is found
+* Recursive calls to other pattern matches
+* Recursive calls to superclass methods
+
+### To-do
+
+* Variable-length argument lists
+* Matching against array elements
+* Guard clauses
+* Support class methods
+* Support module instance methods
+* Support module methods
+
+## Install
+
+    gem install pattern-matching
+
+or add the following line to Gemfile:
+
+    gem 'pattern-matching
+
+and run `bundle install` from your shell.
+
+## Supported Ruby versions
+
+MRI 1.9.x and above. Anything else and your mileage may vary.
+
+## Examples
+
+For more examples see the integration tests in *spec/integration_spec.rb*.
+
+### Simple Functions
+
+This example is based on [Syntax in defnctions: Pattern Matching](http://learnyousomeerlang.com/syntax-in-defnctions) in [Learn You Some Erlang for Great Good!](http://learnyousomeerlang.com/).
+
+Erlang:
+
+    greet(male, Name) ->
+      io:format("Hello, Mr. ~s!", [Name]);
+    greet(female, Name) ->
+      io:format("Hello, Mrs. ~s!", [Name]);
+    greet(_, Name) ->
+      io:format("Hello, ~s!", [Name]).
+
+Ruby:
+
+    require 'pattern_matching'
+
+    class Foo
+      include PatternMatching
+  
+      defn(:greet, _) do |name|
+        "Hello, #{name}!"
+      end
+  
+      defn(:greet, :male, _) { |name|
+        "Hello, Mr. #{name}!"
+      }
+      defn(:greet, :female, _) { |name|
+        "Hello, Ms. #{name}!"
+      }
+      defn(:greet, _, _) { |_, name|
+        "Hello, #{name}!"
+      }
+    end
+
+### Simple Functions with Overloading
+
+This example is based on [Syntax in defnctions: Pattern Matching](http://learnyousomeerlang.com/syntax-in-defnctions) in [Learn You Some Erlang for Great Good!](http://learnyousomeerlang.com/).
+
+Erlang:
+
+    greet(Name) ->
+      io:format("Hello, ~s!", [Name]).
+
+    greet(male, Name) ->
+      io:format("Hello, Mr. ~s!", [Name]);
+    greet(female, Name) ->
+      io:format("Hello, Mrs. ~s!", [Name]);
+    greet(_, Name) ->
+      io:format("Hello, ~s!", [Name]).
+
+Ruby:
+
+    require 'pattern_matching'
+
+    class Foo
+      include PatternMatching
+  
+      defn(:greet, _) do |name|
+        "Hello, #{name}!"
+      end
+  
+      defn(:greet, :male, _) { |name|
+        "Hello, Mr. #{name}!"
+      }
+      defn(:greet, :female, _) { |name|
+        "Hello, Ms. #{name}!"
+      }
+      defn(:greet, nil, _) { |name|
+        "Goodbye, #{name}!"
+      }
+      defn(:greet, _, _) { |_, name|
+        "Hello, #{name}!"
+      }
+    end
+
+### Matching by Class/Datatype
+
+Ruby:
+
+    require 'pattern_matching'
+
+    class Foo
+      include PatternMatching
+  
+      defn(:concat, Integer, Integer) { |first, second|
+        first + second
+      }
+      defn(:concat, Integer, String) { |first, second|
+        "#{first} #{second}"
+      }
+      defn(:concat, String, String) { |first, second|
+        first + second
+      }
+      defn(:concat, Integer, _) { |first, second|
+        first + second.to_i
+      }
+    end
+
+### Matching a Hash Parameter
+
+Ruby:
+
+    require 'pattern_matching'
+
+    class Foo
+      include PatternMatching
+
+      defn(:hashable, {foo: :bar}) { |opts|
+        # matches any hash with key :foo and value :bar
+        :foo_bar
+      }
+      defn(:hashable, {foo: _}) { |opts|
+        # matches any hash with :key foo regardless of value
+        :foo_unbound
+      }
+      defn(:hashable, {}) { |opts|
+        # matches any hash
+        :unbound_unbound
+      }
+    end

data/lib/pattern_matching.rb

@@ -0,0 +1,90 @@
+module PatternMatching
+
+  VERSION = '0.0.1'
+
+  UNBOUND = Unbound = Class.new
+
+  def self.included(base)
+
+    base.instance_variable_set(:@__function_pattern_matches__, Hash.new)
+
+    def __match_pattern__(args, pattern) # :nodoc:
+      return unless args.length == pattern.length
+      pattern.each_with_index do |p, i|
+        arg = args[i]
+        next if p.is_a?(Class) && arg.is_a?(p)
+        if p.is_a?(Hash) && arg.is_a?(Hash)
+          next if p.empty?
+          p.each do |key, value|
+            return false unless arg.has_key?(key)
+            next if value == UNBOUND
+            return false unless arg[key] == value
+          end
+          next
+        end
+        return false unless p == UNBOUND || p == arg
+      end
+      return true
+    end
+
+    def __pattern_match__(func, *args, &block) # :nodoc:
+      clazz = self.class
+
+      matchers = clazz.instance_variable_get(:@__function_pattern_matches__)
+      matchers = matchers[func]
+
+      # scan through all patterns for this function
+      match = nil
+      matchers.each do |matcher|
+        if __match_pattern__(args.first, matcher.first)
+          match = matcher
+          break(matcher)
+        end
+      end
+
+      # if a match is found call the block
+      if match.nil?
+        [:nomatch, nil]
+      else
+        argv = []
+        match.first.each_with_index do |p, i|
+          argv << args.first[i] if p == UNBOUND || p.is_a?(Class) || p.is_a?(Hash)
+        end
+        return [:ok, self.instance_exec(*argv, &match.last)]
+      end
+    end
+
+    class << base
+
+      def _() # :nodoc:
+        return UNBOUND
+      end
+
+      def __add_pattern_for__(func, *args, &block) # :nodoc:
+        block = Proc.new{} unless block_given?
+        matchers = self.instance_variable_get(:@__function_pattern_matches__)
+        matchers[func] = [] unless matchers.has_key?(func)
+        matchers[func] << [args, block]
+      end
+
+      def defn(func, *args, &block)
+
+        block = Proc.new{} unless block_given?
+        __add_pattern_for__(func, *args, &block)
+
+        unless self.instance_methods(false).include?(func)
+          self.send(:define_method, func) do |*args, &block|
+            result, value = __pattern_match__(func, args, block)
+            return value if result == :ok
+            begin
+              super(*args, &block)
+            rescue NoMethodError
+              raise NoMethodError.new("no method `#{func}` matching #{args} found for class #{self.class}")
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe 'integration' do
+
+  class Bar
+
+    def greet
+      return 'Hello, World!'
+    end
+  end
+
+  class Foo < Bar
+    include PatternMatching
+
+    attr_accessor :name
+
+    def initialize(name = 'baz')
+      @name = name
+    end
+
+    defn(:greet, _) do |name|
+      "Hello, #{name}!"
+    end
+
+    defn(:greet, :male, _) { |name|
+      "Hello, Mr. #{name}!"
+    }
+    defn(:greet, :female, _) { |name|
+      "Hello, Ms. #{name}!"
+    }
+    defn(:greet, nil, _) { |name|
+      "Goodbye, #{name}!"
+    }
+    defn(:greet, _, _) { |_, name|
+      "Hello, #{name}!"
+    }
+
+    defn(:hashable, _, {foo: :bar}, _) { |_, opts, _|
+      :foo_bar
+    }
+    defn(:hashable, _, {foo: _}, _) { |_, opts, _|
+      :foo_unbound
+    }
+    defn(:hashable, _, {}, _) { |_, opts, _|
+      :unbound_unbound
+    }
+
+    defn(:recurse) {
+      'w00t!'
+    }
+    defn(:recurse, :match) {
+      recurse()
+    }
+    defn(:recurse, :super) {
+      greet()
+    }
+    defn(:recurse, :instance) {
+      @name
+    }
+    defn(:recurse, _) { |arg|
+      arg
+    }
+
+    defn(:concat, Integer, Integer) { |first, second|
+      first + second
+    }
+    defn(:concat, Integer, String) { |first, second|
+      "#{first} #{second}"
+    }
+    defn(:concat, String, String) { |first, second|
+      first + second
+    }
+    defn(:concat, Integer, _) { |first, second|
+      first + second.to_i
+    }
+  end
+
+  let(:name) { 'Pattern Matcher' }
+  subject { Foo.new(name) }
+
+  specify { subject.greet.should eq 'Hello, World!' }
+
+  specify { subject.greet('Jerry').should eq 'Hello, Jerry!' }
+
+  specify { subject.greet(:male, 'Jerry').should eq 'Hello, Mr. Jerry!' }
+  specify { subject.greet(:female, 'Jeri').should eq 'Hello, Ms. Jeri!' }
+  specify { subject.greet(:unknown, 'Jerry').should eq 'Hello, Jerry!' }
+  specify { subject.greet(nil, 'Jerry').should eq 'Goodbye, Jerry!' }
+
+  specify { subject.hashable(:male, {foo: :bar}, :female).should eq :foo_bar }
+  specify { subject.hashable(:male, {foo: :baz}, :female).should eq :foo_unbound }
+  specify { subject.hashable(:male, {foo: :bar, bar: :baz}, :female).should eq :foo_bar }
+  specify { subject.hashable(:male, {bar: :baz}, :female).should eq :unbound_unbound }
+
+  specify { subject.recurse.should eq 'w00t!' }
+  specify { subject.recurse(:match).should eq 'w00t!' }
+  specify { subject.recurse(:super).should eq 'Hello, World!' }
+  specify { subject.recurse(:instance).should eq name }
+  specify { subject.recurse(:foo).should eq :foo }
+
+  specify { subject.concat(1, 1).should eq 2 }
+  specify { subject.concat(1, 'shoe').should eq '1 shoe' }
+  specify { subject.concat('shoe', 'fly').should eq 'shoefly' }
+  specify { subject.concat(1, 2.9).should eq 3 }
+
+end

data/spec/pattern_matching_spec.rb

@@ -0,0 +1,324 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe PatternMatching do
+
+  def new_clazz(&block)
+    clazz = Class.new
+    clazz.send(:include, PatternMatching)
+    clazz.instance_eval(&block) if block_given?
+    return clazz
+  end
+
+  subject { new_clazz }
+
+  context '#defn declaration' do
+
+    it 'can be used within a class declaration' do
+      lambda {
+        class Clazz
+          include PatternMatching
+          defn :foo
+        end
+      }.should_not raise_error
+    end
+
+    it 'can be used on a class object' do
+      lambda {
+        clazz = Class.new
+        clazz.send(:include, PatternMatching)
+        clazz.defn(:foo)
+      }.should_not raise_error
+    end
+  end
+
+  context 'parameter count' do
+
+    it 'does not match a call with not enough arguments' do
+
+      subject.defn(:foo, true) { 'expected' }
+
+      lambda {
+        subject.new.foo()
+      }.should raise_error(NoMethodError)
+    end
+
+    it 'does not match a call with too many arguments' do
+
+      subject.defn(:foo, true) { 'expected' }
+
+      lambda {
+        subject.new.foo(true, false)
+      }.should raise_error(NoMethodError)
+    end
+
+  end
+
+  context 'recursion' do
+
+    it 'defers unmatched calls to the superclass' do
+
+      class UnmatchedCallTesterSuperclass
+        def foo(bar)
+          return bar
+        end
+      end
+
+      class UnmatchedCallTesterSubclass  < UnmatchedCallTesterSuperclass
+        include PatternMatching
+        defn(:foo) { 'baz' }
+      end
+
+      subject = UnmatchedCallTesterSubclass.new
+      subject.foo(:bar).should eq :bar
+    end
+
+    it 'can call another match from within a match' do
+
+      subject.defn(:foo, :bar) { |arg| foo(:baz) }
+      subject.defn(:foo, :baz) { |arg| 'expected' }
+
+      subject.new.foo(:bar).should eq 'expected'
+    end
+
+    it 'can call a superclass method from within a match' do
+
+      class RecursiveCallTesterSuperclass
+        def foo(bar)
+          return bar
+        end
+      end
+
+      class RecursiveCallTesterSubclass  < RecursiveCallTesterSuperclass
+        include PatternMatching
+        defn(:foo, :bar) { foo(:baz) }
+      end
+
+      subject = RecursiveCallTesterSubclass.new
+      subject.foo(:bar).should eq :baz
+    end
+  end
+
+  context 'datatypes' do
+
+    it 'matches an argument of the class given in the match parameter' do
+
+      subject.defn(:foo, Integer) { 'expected' }
+      subject.new.foo(100).should eq 'expected'
+
+      lambda {
+        subject.new.foo('hello')
+      }.should raise_error(NoMethodError)
+    end
+
+    it 'passes the matched argument to the block' do
+
+      subject.defn(:foo, Integer) { |arg| arg }
+      subject.new.foo(100).should eq 100
+    end
+  end
+
+  context 'function with no parameters' do
+
+    it 'accepts no parameters' do
+
+      subject.defn(:foo)
+      obj = subject.new
+
+      lambda {
+        obj.foo
+      }.should_not raise_error(NoMethodError)
+    end
+
+    it 'does not accept any parameters' do
+
+      subject.defn(:foo)
+      obj = subject.new
+
+      lambda {
+        obj.foo(1)
+      }.should raise_error(NoMethodError)
+    end
+
+    it 'returns the correct value' do
+      subject.defn(:foo){ true }
+      subject.new.foo.should be_true
+    end
+  end
+
+  context 'function with one parameter' do
+
+    it 'matches a nil parameter' do
+
+      subject.defn(:foo, nil) { 'expected' }
+      subject.new.foo(nil).should eq 'expected'
+
+      lambda {
+        subject.new.foo('no match should be found')
+      }.should raise_error(NoMethodError)
+    end
+
+    it 'matches a boolean parameter' do
+
+      subject.defn(:foo, true) { 'expected' }
+      subject.defn(:foo, false) { 'false case' }
+
+      subject.new.foo(true).should eq 'expected'
+      subject.new.foo(false).should eq 'false case'
+
+      lambda {
+        subject.new.foo('no match should be found')
+      }.should raise_error(NoMethodError)
+    end
+
+    it 'matches a symbol parameter' do
+
+      subject.defn(:foo, :bar) { 'expected' }
+      subject.new.foo(:bar).should eq 'expected'
+
+      lambda {
+        subject.new.foo(:baz)
+      }.should raise_error(NoMethodError)
+    end
+
+    it 'matches a number parameter' do
+
+      subject.defn(:foo, 10) { 'expected' }
+      subject.new.foo(10).should eq 'expected'
+
+      lambda {
+        subject.new.foo(11.0)
+      }.should raise_error(NoMethodError)
+    end
+
+    it 'matches a string parameter' do
+
+      subject.defn(:foo, 'bar') { 'expected' }
+      subject.new.foo('bar').should eq 'expected'
+
+      lambda {
+        subject.new.foo('baz')
+      }.should raise_error(NoMethodError)
+    end
+
+    it 'matches an array parameter' do
+
+      subject.defn(:foo, [1, 2, 3]) { 'expected' }
+      subject.new.foo([1, 2, 3]).should eq 'expected'
+
+      lambda {
+        subject.new.foo([3, 4, 5])
+      }.should raise_error(NoMethodError)
+    end
+
+    it 'matches a hash parameter' do
+
+      subject.defn(:foo, bar: 1, baz: 2) { 'expected' }
+      subject.new.foo(bar: 1, baz: 2).should eq 'expected'
+
+      lambda {
+        subject.new.foo(foo: 0, bar: 1)
+      }.should raise_error(NoMethodError)
+    end
+
+    it 'matches an object parameter' do
+
+      subject.defn(:foo, OpenStruct.new(foo: :bar)) { 'expected' }
+      subject.new.foo(OpenStruct.new(foo: :bar)).should eq 'expected'
+
+      lambda {
+        subject.new.foo(OpenStruct.new(bar: :baz))
+      }.should raise_error(NoMethodError)
+    end
+
+    it 'matches an unbound parameter' do
+
+      subject.defn(:foo, PatternMatching::UNBOUND) {|arg| arg }
+      subject.new.foo(:foo).should eq :foo
+    end
+  end
+
+  context 'function with two parameters' do
+
+    it 'matches two bound arguments' do
+
+      subject.defn(:foo, :male, :female){ 'expected' }
+      subject.new.foo(:male, :female).should eq 'expected'
+
+      lambda {
+        subject.new.foo(1, 2)
+      }.should raise_error(NoMethodError)
+    end
+
+    it 'matches two unbound arguments' do
+
+      subject.defn(:foo, PatternMatching::UNBOUND, PatternMatching::UNBOUND) do |first, second|
+        [first, second]
+      end
+      subject.new.foo(:male, :female).should eq [:male, :female]
+    end
+
+    it 'matches when the first argument is bound and the second is not' do
+
+      subject.defn(:foo, :male, PatternMatching::UNBOUND) do |second|
+        second
+      end
+      subject.new.foo(:male, :female).should eq :female
+    end
+
+    it 'matches when the second argument is bound and the first is not' do
+
+      subject.defn(:foo, PatternMatching::UNBOUND, :female) do |first|
+        first
+      end
+      subject.new.foo(:male, :female).should eq :male
+    end
+  end
+
+  context 'functions with hash arguments' do
+
+    it 'matches when all hash keys and values match' do
+
+      subject.defn(:foo, {bar: :baz}) { true }
+      subject.new.foo(bar: :baz).should be_true
+
+      lambda {
+        subject.new.foo({one: :two})
+      }.should raise_error(NoMethodError)
+    end
+
+    it 'matches when the pattern uses an empty hash' do
+
+      subject.defn(:foo, {}) { true }
+      subject.new.foo(bar: :baz).should be_true
+    end
+
+    it 'matches when every pattern key/value are in the argument' do
+
+      subject.defn(:foo, {bar: :baz}) { true }
+      subject.new.foo(foo: :bar, bar: :baz).should be_true
+    end
+
+    it 'matches when all keys with unbound values in the pattern have an argument' do
+
+      subject.defn(:foo, {bar: PatternMatching::UNBOUND}) { true }
+      subject.new.foo(bar: :baz).should be_true
+    end
+
+    it 'passes the matched hash to the block' do
+
+      subject.defn(:foo, {bar: PatternMatching::UNBOUND}) { |args| args }
+      subject.new.foo(bar: :baz).should == {bar: :baz}
+    end
+
+    it 'does not match a non-hash argument' do
+
+      subject.defn(:foo, {}) { true }
+
+      lambda {
+        subject.new.foo(:bar)
+      }.should raise_error(NoMethodError)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'pattern_matching'
+
+# import all the support files
+Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each { |f| require File.expand_path(f) }
+
+RSpec.configure do |config|
+
+  config.before(:suite) do
+  end
+
+  config.before(:each) do
+  end
+
+  config.after(:each) do
+  end
+
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: pattern-matching
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jerry D'Antonio
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: |2
+      A gem for adding Erlang-style pattern matching to Ruby classes.
+email: jerry.dantonio@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE
+files:
+- README.md
+- LICENSE
+- lib/pattern_matching.rb
+- spec/integration_spec.rb
+- spec/pattern_matching_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/jdantonio/pattern_matching/
+licenses:
+- MIT
+metadata: {}
+post_install_message: Happy matching!
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Erlang-style pattern matching to Ruby classes.
+test_files:
+- spec/integration_spec.rb
+- spec/pattern_matching_spec.rb
+- spec/spec_helper.rb
+has_rdoc: