pattern_matching 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b06b9cf226bb98d933ddf95eb0b75788ae350bd2
+  data.tar.gz: 2f60e9f04cf9ffe1162c6f0689a8a510ef74d93c
+SHA512:
+  metadata.gz: ce9d684d17669385f62e003c7a2961490d353bc42b069699ec2bdc9f7f865ef893f54c78cd4ac3cf48bff115976a5fb983c7679c89f9a47da8b77c3d44613e30
+  data.tar.gz: 76c6f315f0d7c474f8762739d6b6778d105f1492e84e3c1b0d5007b31f38f591e46a1632f961a882d1c29e135869e91dd20cc209f89c1eb80ed75256df91abf9

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,33 @@
+PATH
+  remote: .
+  specs:
+    pattern_matching (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ansi (1.5.0)
+    builder (3.2.2)
+    minitest (5.9.1)
+    minitest-reporters (1.1.11)
+      ansi
+      builder
+      minitest (>= 5.0)
+      ruby-progressbar
+    rake (10.5.0)
+    ruby-progressbar (1.8.1)
+    turn-again-reporter (1.1.0)
+      minitest-reporters (~> 1.0, >= 1.0.8)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.7)
+  minitest-reporters (~> 1.1)
+  pattern_matching!
+  rake (~> 10.0)
+  turn-again-reporter (~> 1.1, >= 1.1.0)
+
+BUNDLED WITH
+   1.13.5

data/LICENSE.md

@@ -0,0 +1,27 @@
+Copyright (c) 2016, Paul Kwiatkowski
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of adalog nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs        << "test"
+  t.test_files  = Dir[File.join(File.dirname(__FILE__), 'test/**/*test.rb')]
+end

data/lib/pattern_matching.rb

@@ -0,0 +1,181 @@
+# Allows for crude pattern-matching like behavior. Very crude.
+# Currently just a Symbol as a status tag paired with a value.
+# Provides capitalized methods (bad form, perhaps?) to make
+# them stand out: `#Pattern`, `#Result` and `#Match`.
+#
+# Example usage:
+#
+# def some_computation
+#   Result(:ok, "awesome sauce")
+# end
+#
+# case (result = some_computation)
+# when Match(:ok)
+#   puts "Things went okay: #{result.value}"
+# when Match(:error)
+#   puts "Something went wrong: #{result.value}"
+# end
+#
+# # => "Things went okay: awesome sauce"
+#
+# Originally named `Result` but that would have a conflicting meaning
+# with the typical use of the Result Monad in most languages/environments.
+# So while this is not true pattern matching, it might one day grow into
+# something of the sort, and so the name fits... in a limited way.
+module PatternMatching
+
+  ##
+  # Configure behavior based on existing configuration.
+  # This is a lot of noodley-looking nested conditional logic but that's
+  # kind of the point with lots of boolean-based configuration of behavior!
+  def self.included(base)
+    if PatternMatching.config.use_binding_helper
+      base.const_set(PatternMatching.config.binding_helper, PatternMatching::BindingsSet.new)
+      if PatternMatching.config.default_binding_helper?
+        base.send(:include, PatternMatching::MethodsWithBindingHelper)
+      else
+        base.send(:include, PatternMatching.methods_with_custom_binding_helper)
+      end
+    else
+      base.send(:include, PatternMatching::Methods)
+    end
+
+    if PatternMatching.config.use_proc_helpers
+      if PatternMatching.config.default_proc_helpers?
+        base.send(:include, PatternMatching::ProcHelpers)
+      else
+        base.send(:include, PatternMatching.custom_proc_helpers)
+      end
+    end
+  end
+
+  ##
+  # Available configuration options are:
+  #
+  # - use_proc_helpers: controls whether or not helpers for sending
+  #   messages and calling a method in the local context are included
+  #   with this module.
+  #
+  # - use_binding_helper: controls whether or not bindings are enabled (and thus)
+  #   whether or not helpers are included.
+  #
+  # - send_helper: the method name used as the proc helper for
+  #   "sending a message" to the object when matching.
+  #
+  # - call_helper: the method name used as the proc helper for "calling a
+  #   method in the current context" with the object as an argument when matching.
+  #
+  # - binding_helper: the method name used as the binding set for each match.
+  def self.configure(&block)
+    block.call(config)
+
+    unless config.default_proc_helpers?
+      build_custom_proc_helpers(config.send_helper, config.call_helper)
+    end
+
+    if config.use_binding_helper && !config.default_binding_helper?
+      build_custom_binding_helper(config.binding_helper)
+      puts "Using a custom binding helper are we?"
+    end
+  end
+
+  ##
+  # Simple class-instance variable to hold configuration
+  def self.config
+    @config ||= ::PatternMatching::Configuration.default
+  end
+
+  ##
+  # For of use in testing, because of how Ruby loading works when testing
+  # behavior that is thread-global (?) for the instance of this module.
+  def self.default_configuration!
+    @config = ::PatternMatching::Configuration.default
+  end
+
+  ##
+  # Will only be set with a proper module if a call to ::configure results in
+  # there being proc helpers with non-default names. Is not intelligently
+  # assigned, nor should it be used, when called in any manner before a call
+  # to ::configure that specifies an alternative value to config.call_helper
+  # and config.binding_helper.
+  def self.custom_proc_helpers
+    @custom_proc_helpers
+  end
+
+  ##
+  # Will only be set with a proper module if a call to ::configure results in
+  # a binding helper set to a name which is not the default. Is not intelligently
+  # assigned, nor should it be used, when called in any manner before a call
+  # to ::configure that specifies an alternative value to config.binding_helper
+  def self.methods_with_custom_binding_helper
+    @methods_with_custom_binding_helper
+  end
+
+  ##
+  # Implementations internal to the blocks of the define_method calls
+  # should remain identical to the implementations in the PatternMatching::ProcHelpers
+  # module, with the only change being that the produced module has different names for
+  # the methods behind the call and send helpers.
+  def self.build_custom_proc_helpers(send_helper, call_helper)
+    proc_helpers = ->() {
+      define_method(send_helper) do |symbol|
+        symbol.to_proc
+      end
+
+      define_method(call_helper) do |symbol|
+        Proc.new { |obj| self.send(symbol, obj) }
+      end
+    }
+
+    @custom_proc_helpers = Module.new
+    @custom_proc_helpers.class_exec(&proc_helpers)
+  end
+
+  ##
+  # The implementation of the METHODS heredoc should remain identical to the contents of
+  # the Match and Pattern methods of PatternMatching::MethodsWithBindingHelper except that
+  # here we are interpolating on our
+  def self.build_custom_binding_helper(binding_helper)
+    methods_with_binding = ->() {
+      eval(
+<<-METHODS
+def Match(*pattern)
+  result = ::PatternMatching::CaseEqualityReversal.new(*pattern)
+  (self.class)::#{binding_helper}._clear_bindings!(caller_locations(1,1)[0].label) unless result
+  result
+end
+
+def Pattern(*pattern)
+  (self.class)::#{binding_helper}._clear_bindings!(caller_locations(1,1)[0].label)
+  ::PatternMatching::PatternMatch.new(*pattern)
+end
+METHODS
+      )
+    }
+    @methods_with_custom_binding_helper = Module.new
+    @methods_with_custom_binding_helper.class_exec(&methods_with_binding)
+  end
+
+  ##
+  # Additional singleton constants and wildcards
+  Undefined = Object.new
+  Any       = Object.new
+  Head      = Object.new
+  Tail      = Object.new
+  def Undefined.inspect ; "<Undefined>" ; end
+  def Undefined.to_s    ; "<Undefined>" ; end
+  def Any.inspect       ; "<Any>"       ; end
+  def Any.to_s          ; "<Any>"       ; end
+  def Head.inspect      ; "<Head>"      ; end
+  def Head.to_s         ; "<Head>"      ; end
+  def Tail.inspect      ; "<Tail>"      ; end
+  def Tail.to_s         ; "<Tail>"      ; end
+
+end
+
+
+##
+# Include the rest of this library.
+Dir[File.join(File.dirname(__FILE__), "pattern_matching", "*.rb")].each do |rb_file|
+  require rb_file
+end

data/lib/pattern_matching/bindings.rb

@@ -0,0 +1,59 @@
+module PatternMatching
+  ##
+  # Taken nearly verbatim from the idea presented by Avdi Grimm in an episode of
+  # the fantastic Ruby Tapas series, including the use of the >> (right-shift) operator
+  # as a "guard" operator, as visually stands out compared to other define-able
+  # binary operators but it lacks idiomatic re-use the way that << (left-shift) does.
+  # It also feels a little bit like the \\ guards used in Elixir, which I would have
+  # used, if I could find a way to have Ruby treat either \\ or // as a binary operator.
+  class Bindings < BasicObject
+
+    def initialize
+      @bindings = ::Hash.new do |hash, key|
+        ::PatternMatching::Bindings::BoundValue.new(hash, key)
+      end
+    end
+
+    ##
+    # Hello darkness, my old friend.
+    def method_missing(msg, *)
+      @bindings[msg]
+    end
+
+
+    ##
+    # The interesting work of Bindings happens in this class.
+    #
+    # Allows setting up guards via the >> oprator.
+    #
+    # If guards pass, or no guards have been added to a BoundValue,
+    # then comparing via == or === with that BoundValue will always
+    # return true, and will save the compared-to value in the hash,
+    # presumably provided by an instance of the Bindings class.
+    class BoundValue
+      def initialize(bindings, name)
+        @bindings = bindings
+        @name     = name
+        @guards   = []
+      end
+
+      def ==(other)
+        return false unless @guards.all? { |g| g === other }
+        @bindings[@name] = other
+        true
+      end
+
+      def ===(other)
+        return false unless @guards.all? { |g| g === other }
+        @bindings[@name] = other
+        true
+      end
+
+      def >>(guard)
+        @guards << guard
+        self
+      end
+    end
+
+  end
+end

data/lib/pattern_matching/bindings_set.rb

@@ -0,0 +1,84 @@
+module PatternMatching
+  class BindingsSet
+
+    ##
+    # For reasons I have yet to determine, implementing BindingsSet as a subclass
+    # of BasicObject has caused stack overflow issues. So the current workaround
+    # is to just remove everything we possibly can from this class at load time
+    # via the very hamfisted Module#undef_method.
+    REMOVABLE_OBJECT_METHODS = [
+      :nil?,
+      :===,
+      :=~,
+      :!~,
+      :eql?,
+      :hash,
+      :<=>,
+      :class,
+      :singleton_class,
+      :clone,
+      :dup,
+      :taint,
+      :tainted?,
+      :untaint,
+      :untrust,
+      :untrusted?,
+      :trust,
+      :freeze,
+      :frozen?,
+      :to_s,
+      :inspect,
+      :methods,
+      :singleton_methods,
+      :protected_methods,
+      :private_methods,
+      :public_methods,
+      :instance_variables,
+      :instance_variable_get,
+      :instance_variable_set,
+      :instance_variable_defined?,
+      :remove_instance_variable,
+      :instance_of?,
+      :kind_of?,
+      :is_a?,
+      :tap,
+      :send,
+      :public_send,
+      :respond_to?,
+      :extend,
+      :display,
+      :method,
+      :public_method,
+      :singleton_method,
+      :define_singleton_method,
+      :to_enum,
+      :enum_for,
+    ]
+
+    REMOVABLE_OBJECT_METHODS.each do |msg|
+      undef_method(msg)
+    end
+
+
+    def initialize
+      @bindings = {}
+    end
+
+    ###
+    # Based on the caller's method name (obviously not an universally-optimal choice),
+    # cache a Bindings object and forward all messages there.
+    def method_missing(msg, *)
+      caller_label = caller_locations(1,1)[0].label
+      @bindings[caller_label] ||= PatternMatching::Bindings.new
+      @bindings[caller_label].send(msg)
+    end
+
+    ##
+    # Used internally as a hacky hook into auto-bindings with the B constant,
+    # when enabled. See documentation for automatic bindings.
+    def _clear_bindings!(caller_label)
+      @bindings.delete(caller_label)
+    end
+
+  end
+end

data/lib/pattern_matching/case_equality_reversal.rb

@@ -0,0 +1,15 @@
+module PatternMatching
+  ##
+  # Used by #Match to invert the call to `===` by `when` clauses
+  class CaseEqualityReversal < BasicObject
+
+    def initialize(*pattern)
+      @pattern = pattern
+    end
+
+    def ===(other)
+      other.===(*@pattern)
+    end
+
+  end
+end

data/lib/pattern_matching/configuration.rb

@@ -0,0 +1,50 @@
+module PatternMatching
+  ##
+  # Available configuration options are:
+  #
+  # - use_proc_helpers: controls whether or not helpers for sending
+  #   messages and calling a method in the local context are included
+  #   with this module.
+  #
+  # - use_binding_helper: controls whether or not bindings are enabled (and thus)
+  #   whether or not helpers are included.
+  #
+  # - send_helper: the method name used as the proc helper for
+  #   "sending a message" to the object when matching.
+  #
+  # - call_helper: the method name used as the proc helper for "calling a
+  #   method in the current context" with the object as an argument when matching.
+  #
+  # - binding_helper: the method name used as the binding set for each match.
+  class Configuration
+
+    def self.default
+      new(true, true, :S, :C, :B)
+    end
+
+    attr_accessor :use_proc_helpers,
+                  :use_binding_helper,
+                  :send_helper,
+                  :call_helper,
+                  :binding_helper
+
+    def initialize(use_proc_helpers, use_binding_helper, send_helper, call_helper, binding_helper)
+      @use_proc_helpers   = use_proc_helpers
+      @use_binding_helper = use_binding_helper
+      @send_helper        = send_helper
+      @call_helper        = call_helper
+      @binding_helper     = binding_helper
+    end
+
+
+    def default_proc_helpers?
+      :S == send_helper && :C == call_helper
+    end
+
+
+    def default_binding_helper?
+      :B == binding_helper
+    end
+
+  end
+end

data/lib/pattern_matching/methods.rb

@@ -0,0 +1,17 @@
+module PatternMatching
+  module Methods
+
+    ##
+    # Wraps a matchable 'pattern' in an object that inverts `===` (case-equality method).
+    def Match(*pattern)
+      ::PatternMatching::CaseEqualityReversal.new(*pattern)
+    end
+
+    ##
+    # Wraps an argument list as a pattern for use in a call to #Match
+    def Pattern(*pattern)
+      ::PatternMatching::PatternMatch.new(*pattern)
+    end
+
+  end
+end

data/lib/pattern_matching/methods_with_binding_helper.rb

@@ -0,0 +1,21 @@
+module PatternMatching
+  module MethodsWithBindingHelper
+
+    ##
+    # Wraps a matchable 'pattern' in an object that inverts `===` (case-equality method).
+    def Match(*pattern)
+      result = ::PatternMatching::CaseEqualityReversal.new(*pattern)
+      (self.class)::B._clear_bindings!(caller_locations(1,1)[0].label) unless result
+      result
+    end
+
+    ##
+    # Wraps an argument list as a pattern for use in a call to #Match
+    def Pattern(*pattern)
+      (self.class)::B._clear_bindings!(caller_locations(1,1)[0].label)
+      ::PatternMatching::PatternMatch.new(*pattern)
+    end
+
+  end
+end
+

data/lib/pattern_matching/pattern_match.rb

@@ -0,0 +1,55 @@
+module PatternMatching
+  ##
+  # Encapsulates pattern matching behaviors such as deep-matching of collection
+  # types as well as wildcard values such as `Any`.
+  class PatternMatch
+
+    attr_reader   :pattern
+    alias_method  :value, :pattern
+
+    def initialize(*pattern)
+      @pattern = pattern
+    end
+
+    ##
+    # As both self.pattern and other are slurped, they are guaranteed to begin as
+    # Arrays (i.e. they are enumerable). Thus all matches begin by checking a match
+    # as if the values are enumerable.
+    def ===(*other)
+      match_enumerable(pattern, other)
+    end
+
+
+  private ######################################################################
+
+    ##
+    # Enumerable arguments with different lengths are not equal, at least as long as
+    # wildcards such as Head and Tail remain un-implemented. This is used as a
+    # fast-reject clause. Otherwise, iteration is used to decide
+    #
+    # TODO: There might be a better way of determining which objects are legitimately
+    #       useful as matachable collections than simply descending from Enumerable or
+    #       responding to #length, #zip and #reduce, as is implicit here.
+    def match_enumerable(from_self, from_other)
+      return false if from_self.length < from_other.length
+      combined = from_self.zip(from_other)
+      combined.reduce(true) do |acc, (self_item, other_item)|
+        acc && match_item(self_item, other_item)
+      end
+    end
+
+    ##
+    # Handles matching for non-collection values, including the logic behind
+    # the wildcard Any. In the case of a collection, defers instead to #match_enumerable.
+    def match_item(from_self, from_other)
+      if Any == from_other
+        true
+      elsif Enumerable === from_other && Enumerable === from_self
+        match_enumerable(from_self, from_other)
+      else
+        from_other === from_self
+      end
+    end
+
+  end
+end

data/lib/pattern_matching/proc_helpers.rb

@@ -0,0 +1,19 @@
+module PatternMatching
+  module ProcHelpers
+
+    ##
+    # S for 'send', as in "send message to object".
+    # Allows for prettier Proc pattern-matches than simply :sym.to_proc everywhere
+    def S(symbol)
+      symbol.to_proc
+    end
+
+    ##
+    # C for 'call', as in "call method in current context".
+    # Allows for prettier Method pattern-matches than method(:sym)
+    def C(symbol)
+      Proc.new { |obj| self.send(symbol, obj) }
+    end
+
+  end
+end

data/lib/pattern_matching/version.rb

@@ -0,0 +1,3 @@
+module PatternMatching
+  VERSION = '0.1.0'
+end

data/test/configuration_tests/no_proc_helpers_test.rb

@@ -0,0 +1,21 @@
+require 'test_helper'
+
+PatternMatching.configure do |config|
+  config.use_proc_helpers = false
+end
+
+module ConfigurationTests
+  class NoProcHelpers < Minitest::Test
+    include PatternMatching
+
+    test "send helper is not defined" do
+      refute_respond_to(self, :S)
+    end
+
+    test "call helper is not defined" do
+      refute_respond_to(self, :C)
+    end
+
+  end
+end
+

data/test/configuration_tests/renamed_proc_helpers_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+PatternMatching.configure do |config|
+  config.use_proc_helpers = true
+  config.send_helper      = :foo
+  config.call_helper      = :bar
+end
+
+module ConfigurationTests
+  class RenamedProcHelpers < Minitest::Test
+    include PatternMatching
+
+    test "send helper is defined as foo" do
+      assert_respond_to(self, :foo)
+    end
+
+    test "call helper is defined as bar" do
+      assert_respond_to(self, :bar)
+    end
+
+
+    test "can use S as a shortcut for symbol-to-proc" do
+      result = Pattern(42, "", 555)
+      assert_match(result,  foo(:even?),  foo(:empty?), foo(:odd?))
+      refute_match(result,  foo(:odd?),   foo(:empty?), foo(:odd?))
+    end
+
+
+    def contains_e?(str)
+      str.kind_of?(String) && str.count('e') > 0
+    end
+
+
+    def forty_two?(val)
+      42 == val
+    end
+
+
+    def triple_five?(val)
+      555 == val
+    end
+
+
+    test "can use C as a shortcut for methods in current context" do
+      result = Pattern(42, "streetlight", 555)
+      assert_match(result,  bar(:forty_two?),  bar(:contains_e?), bar(:triple_five?))
+      refute_match(result,  bar(:forty_two?),  bar(:forty_two?),  bar(:triple_five?))
+    end
+
+  end
+end
+

data/test/proc_helper_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+PatternMatching.default_configuration!
+
+class ProcHelperTest < Minitest::Test
+  include PatternMatching
+
+
+  test "can use S as a shortcut for symbol-to-proc" do
+    result = Pattern(42, "", 555)
+
+    assert_match(result,  S(:even?),  S(:empty?), S(:odd?))
+
+    refute_match(result,  S(:odd?),   S(:empty?), S(:odd?))
+    refute_match(result,  S(:even?),  S(:empty?), S(:even?))
+    refute_match(result,  S(:even?),  S(:nil?),   S(:odd?))
+  end
+
+
+  def contains_e?(str)
+    str.kind_of?(String) && str.count('e') > 0
+  end
+
+
+  def forty_two?(val)
+    42 == val
+  end
+
+
+  def triple_five?(val)
+    555 == val
+  end
+
+
+  test "can use C as a shortcut for methods in current context" do
+    result = Pattern(42, "streetlight", 555)
+
+    assert_match(result,  C(:forty_two?),  C(:contains_e?), C(:triple_five?))
+
+    refute_match(result,  C(:forty_two?),  C(:forty_two?),  C(:triple_five?))
+    refute_match(result,  C(:forty_two?),  C(:contains_e?), C(:contains_e?))
+    refute_match(result,  C(:forty_two?),  C(:contains_e?), C(:forty_two?))
+  end
+
+
+end
+

data/test/simple_matching_test.rb

@@ -0,0 +1,134 @@
+require 'test_helper'
+
+class SimpleMatchingTest < Minitest::Test
+  include PatternMatching
+
+
+  test "matches status and exact value" do
+    result = Pattern(     :ok, [1, 2, 3])
+    assert_match(result,  :ok, [1, 2, 3])
+    refute_match(result,  :ok, [1, 2])
+    refute_match(result,  :ok, [3, 2, 1])
+    refute_match(result,  :ok, [])
+  end
+
+
+  test "matches status without value" do
+    result = Pattern(     :ok)
+    assert_match(result,  :ok)
+    assert_match(result,  Any)
+    refute_match(result,  :ok, [1, 2, 3])
+    refute_match(result,  :ok, Any)
+    refute_match(result,  Any, Any)
+  end
+
+
+  test "matches class hierarchy" do
+    result = Pattern(     :ok, [1, 2, 3])
+    assert_match(result,  :ok, Array)
+    assert_match(result,  Symbol, [1, 2, 3])
+    refute_match(result,  :ok, [Array])
+    refute_match(result,  :ok, [Fixnum])
+    refute_match(result,  :ok, String)
+    refute_match(result,  :ok, Fixnum)
+    refute_match(result,  Symbol, [])
+  end
+
+
+  test "matches range inclusion" do
+    result = Pattern(     5)
+    assert_match(result,  (1..10))
+    refute_match(result,  (1...5))
+  end
+
+
+  test "matches by calling procs or lambdas" do
+    result = Pattern(     5)
+
+    assert_match(result,  ->(val)   { true })
+    assert_match(result,  Proc.new  { true })
+    assert_match(result,  :odd?.to_proc)
+
+    refute_match(result,  Proc.new  { false })
+    refute_match(result,  :even?.to_proc)
+  end
+
+
+  test "matches arrays recursively" do
+    result = Pattern(     :ok, [1, 2, 3])
+
+    assert_match(result,  :ok, [1, Any, 3])
+    assert_match(result,  :ok, [Any, Any, Any])
+    refute_match(result,  :ok, [1, Any])
+
+    assert_match(result,  :ok, [1, :even?.to_proc, 3])
+    refute_match(result,  :ok, [1, :odd?.to_proc, 3])
+
+    assert_match(result,  Symbol, [1, Numeric, 3])
+    refute_match(result,  Symbol, [1, Float, 3])
+
+    assert_match(result,  Symbol, [1, (0..10), 3])
+    refute_match(result,  Symbol, [1, (5..10), 3])
+  end
+
+
+  test "matches hash strucutre" do
+    result = Pattern(     :ok, { a: 1, b: 2, c: 3 })
+    assert_match(result,  :ok, { a: 1, b: 2, c: 3 })
+    assert_match(result,  :ok, { a: Any, b: Any, c: Any })
+    assert_match(result,  :ok, { a: Any, b: Any, c: Any })
+    refute_match(result,  :ok, {})
+    refute_match(result,  :ok, { d: Any})
+    refute_match(result,  :ok, { a: 1,    b: 2,   c: 3,   d: 4 })
+    refute_match(result,  :ok, { a: 1,    b: 2,   c: 3,   d: Any })
+    refute_match(result,  :ok, { a: Any,  b: Any, c: Any, d: Any })
+    refute_match(result,  :ok, { a: 1 })
+    refute_match(result,  :ok, { a: '1',  b: '2', c: '3' })
+    refute_match(result,  :ok, { a: Any,  b: '2', c: Any })
+  end
+
+
+  test "matches Any deeply nested arrays" do
+    deeply_nested = [
+      1,
+      "foo",
+      2,
+      [ "bar",
+        [3, 4, :five],
+        "baz"
+      ],
+    ]
+    result = Pattern(deeply_nested)
+
+    assert_match(result, [
+      1,
+      "foo",
+      2,
+      [ "bar",
+        [Numeric, 4, :five],
+        "baz"
+      ],
+    ])
+
+    refute_match(result, [
+      1,
+      "foo",
+      2,
+      [ "bar",
+        [3, 4, 5],
+        "baz"
+      ],
+    ])
+
+    assert_match(result, [
+      Any,
+      Any,
+      Any,
+      [ Any,
+        [Any, Any, Any],
+        Any
+      ],
+    ])
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,57 @@
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'minitest/reporters'
+require 'minitest/reporters/turn_again_reporter'
+Minitest::Reporters.use!(Minitest::Reporters::TurnAgainReporter.new)
+
+# Require ourselves.
+require 'pattern_matching'
+
+##
+# Blatantly stolen from ActiveSupport::Testing::Declarative
+# Allows for test files such as
+#   test "verify something" do
+#     ...
+#   end
+# which become methods named test_verify_something, leaving a visual difference
+# between tests themselves and any helper methods declared in the usual
+# manner of `def some_helper_method`.
+module DeclarativeTests
+  def test(name, &block)
+    test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
+    defined = instance_method(test_name) rescue false
+    raise "#{test_name} is already defined in #{self}" if defined
+    if block_given?
+      define_method(test_name, &block)
+    else
+      define_method(test_name) do
+        flunk "No implementation provided for #{name}"
+      end
+    end
+  end
+end
+
+
+class Minitest::Test
+  extend DeclarativeTests
+
+  def assert_match(result, *pattern)
+    case result
+    when Match(*pattern)
+      assert(true)
+    else
+      assert(false, "Result of #{result.pattern}' should match pattern '#{pattern.join(', ')}'")
+    end
+  end
+
+
+  def refute_match(result, *pattern)
+    case result
+    when Match(*pattern)
+      assert(false, "Result of '#{result.pattern}' should not match pattern '#{pattern.join(', ')}'")
+    else
+      assert(true)
+    end
+  end
+
+end

data/test/wildcard_test.rb

@@ -0,0 +1,79 @@
+require 'test_helper'
+
+PatternMatching.default_configuration!
+
+class WildcardTest < Minitest::Test
+  include PatternMatching
+
+
+  test "matches with Any as items or enumerables" do
+    result = Pattern(     :ok, [1, 2, 3])
+    assert_match(result,  :ok, Any)
+    assert_match(result,  Any, [1, 2, 3])
+    assert_match(result,  Any, Any)
+    refute_match(result,  Any, Any, Any)
+  end
+
+
+  test "matches Any internal to arrays" do
+    result = Pattern(     [1, 2, 3])
+    assert_match(result,  [1, Any, 3])
+    assert_match(result,  [Any, Any, Any])
+    refute_match(result,  [1, Any])
+  end
+
+
+  test "matches Any internal to hashes" do
+    result = Pattern(     { a: 1, b: 2, c: 3 })
+
+    assert_match(result,  Any)
+    assert_match(result,  { a: 1, b: 2, Any => Any })
+    assert_match(result,  { a: 1, b: 2, Any => 3 })
+    assert_match(result,  { a: Any, b: Any, c: Any })
+    assert_match(result,  { a: Any, b: Any, c: Any })
+
+    refute_match(result,  {})
+    refute_match(result,  { d: Any})
+    refute_match(result,  { a: 1,     b: 2,   Any => 4 })
+    refute_match(result,  { a: 1,     b: 2,   c: 3,   d: Any })
+    refute_match(result,  { a: Any,   b: Any, c: Any, d: Any })
+    refute_match(result,  { a: 1 })
+    refute_match(result,  { a: '1',   b: '2', c: '3' })
+    refute_match(result,  { a: Any,   b: '2', c: Any })
+  end
+
+
+  test "matches Any in deeply nested arrays" do
+    deeply_nested = [
+      1,
+      "foo",
+      2,
+      [ "bar",
+        [3, 4, :five],
+        "baz"
+      ],
+    ]
+    result = Pattern(deeply_nested)
+
+    assert_match(result, [
+      1,
+      "foo",
+      2,
+      [ "bar",
+        [Numeric, Any, :five],
+        "baz"
+      ],
+    ])
+
+    assert_match(result, [
+      Any,
+      Any,
+      Any,
+      [ Any,
+        [Any, Any, Any],
+        Any
+      ],
+    ])
+  end
+
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: pattern_matching
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Paul Kwiatkowski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: turn-again-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+description: Allows for pattern matching behavior, ala many functional languages,
+  using Ruby's case statements. Additionally, values can be bound at match time. Provides
+  a few helper modules to make this even more terse and feel more flexible.
+email:
+- paul@groupraise.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE.md
+- Rakefile
+- lib/pattern_matching.rb
+- lib/pattern_matching/bindings.rb
+- lib/pattern_matching/bindings_set.rb
+- lib/pattern_matching/case_equality_reversal.rb
+- lib/pattern_matching/configuration.rb
+- lib/pattern_matching/methods.rb
+- lib/pattern_matching/methods_with_binding_helper.rb
+- lib/pattern_matching/pattern_match.rb
+- lib/pattern_matching/proc_helpers.rb
+- lib/pattern_matching/version.rb
+- test/configuration_test.rb
+- test/configuration_tests/no_proc_helpers_test.rb
+- test/configuration_tests/renamed_proc_helpers_test.rb
+- test/proc_helper_test.rb
+- test/simple_matching_test.rb
+- test/test_helper.rb
+- test/wildcard_test.rb
+homepage: https://github.com/swifthand/pattern_matching
+licenses:
+- Revised BSD, see LICENSE.md
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.4.8
+signing_key: 
+specification_version: 4
+summary: Allows for pattern matching behavior with value bindings and wildcards.
+test_files:
+- test/configuration_test.rb
+- test/configuration_tests/no_proc_helpers_test.rb
+- test/configuration_tests/renamed_proc_helpers_test.rb
+- test/proc_helper_test.rb
+- test/simple_matching_test.rb
+- test/test_helper.rb
+- test/wildcard_test.rb