rubo_claus 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e4ddf83f73f07a31517416ef5bea818d7d574561
-  data.tar.gz: 9940e9766b9af282e20d30f3d5f98102b2501a48
+  metadata.gz: bec5af93a59d08f56169f041625c4e7c67fbdd4e
+  data.tar.gz: c185d7213d32531ff43d5bd2f9ff9c7c0c1a6c74
 SHA512:
-  metadata.gz: c7f8f1c381054d7de8a4bc3dcd212daba86dd996e658315f20bd599ff741df5aad5530fead18846f58b40fda772bd82e6f2971206512ec22173ac789623d972a
-  data.tar.gz: 84bc8b619df55125bca97b0843d2e0bdb54ffe9dad803cce6c01fce7df958012047d5db61d58f4951c1437fe84c864940085304f35530a74973b689a8260bbb2
+  metadata.gz: 6b7d5d705d13430d5e29056c964b6c0b9fdb2c33e69a89fe2a8cbd0491ef0bb748811c03b35b8102587aa8242fdc04e635aeb1daa3885238f1455a6698f85a48
+  data.tar.gz: b3729d8789de8c9ad048f60786a7d56c3874d9085ce6e37a10ea35427d4fb9622800b52d7f4ad5189a0ef60770dffb5a3b5022c1ec7c0db3b181a74d7657bcdc

data/.gitignore

@@ -0,0 +1,4 @@
+.ruby-version
+*.gem
+
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,6 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+  - 2.2.5
+  - 2.1.10

data/Gemfile

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

data/README.md

@@ -1,11 +1,154 @@
 # RuboClaus
 
-## Ruby method pattern matching ala Erlang/Elixir
+RuboClaus is an open source project that gives the Ruby developer a DSL to implement functions with multiple clauses and varying numbers of arguments on a pattern matching paradigm, inspired by functional programming in Elixir and Erlang.
 
-__NOTE__
+#### Note
 
-This is purely a thought experiment at this point.  Don't freak out,
-no one even said this was a good idea or will be usable yet.  This is
-purely exploratory at this point.
+_RuboClaus is still in very early stage of development and thought process.  We are still treating this as a proof-of-concept and are still exploring the topic.  As such, we don't suggest you use this in any kind of production environment, without first looking at the library code and feeling comfortable with how it works.  And, if you would like to continue this thought experiment and provide feedback/suggestions/changes, we would love to hear it._
 
-_You have been warned_
+### Rationale
+
+The beauty of multiple function clauses with pattern matching is fewer conditionals and fewer lines of unnecessary defensive logic. Focus on the happy path. Control types as they come in, and handle for edge cases with catch all clauses. It does not work great for simple methods, like this:
+
+Ruby:
+
+```ruby
+def add(first, second)
+  return "Please use numbers" unless [first, second].all? { |obj| obj.is_a? Fixnum }
+  first + second
+end
+```
+
+Ruby With RuboClaus:
+
+```ruby
+define_function :add do
+  clauses(
+    clause([Fixnum, Fixnum], proc { |first, second| first + second }),
+    catch_all(proc { "Please use numbers" }
+  )
+end
+```
+
+It is cumbersome for problems like `add`--in which case we don't recommend using it. But as soon as we add complexity that depends on parameter arity or type, we can see how RuboClaus makes our code more extendible and maintainable. For example:
+
+Ruby:
+
+```ruby
+def handle_response(status, has_body, is_chunked)
+  if status == 200 && has_body && is_chunked
+    # ...
+  else
+    if status == 200 && has_body && !is_chunked
+      # ...
+    else
+      if status == 200 && !has_body
+        # ...
+      else
+        # ...
+      end
+    end
+  end
+end
+```
+
+Ruby with RuboClaus:
+
+```ruby
+define_function :handle_response do
+  clauses(
+    clause([200, true, true], proc { |status, has_body, is_chunked| ... }),
+    clause([200, true, false], proc { |status, has_body, is_chunked| ... }),
+    clause([200, false], proc { |status, has_body| ... }),
+    catch_all(proc { return_error })
+  )
+end
+```
+[Credit](https://www.reddit.com/r/elixir/comments/34jyto/what_are_the_benefits_of_pattern_matching_as/cqve33n)
+
+To learn more about this style of programming read about [function overloading](https://en.wikipedia.org/wiki/Function_overloading) and [pattern matching](https://en.wikipedia.org/wiki/Pattern_matching).
+
+## Usage
+
+Below are the public API methods and their associated arguments.
+
+* `define_function`
+	* Symbol - name of the method to define
+	* Block - a single block with a `clauses` method call
+* `clauses`
+	* N number of `clause` method calls and/or a single `catch_all` method call
+* `clause` | `p_clause`
+	* Array - list of arguments to pattern match against
+      * Keywords:
+        * `:any` - among your arguments, `:any` represents that any data type will be accepted in its position.
+        * `:tail` - given an array argument with defined "head" elements and `:tail` as the last element (such as `[String, String, :tail]`), this will destructure the head elements and make the tail an array of the non-head elements.
+	* Proc - method body to execute when this method is matched and executed
+    * Note on `p_clause` - only visible to other clauses in the function, and will return `NoPatternMatchError` if invoked with matching parameters external to the function. Ideally used when calling the function recursively with different arity than the public api to the method.
+* `catch_all`
+	* Proc - method body that will be executed if the arguments do not match any of the `clause` patterns defined
+
+### Clause pattern arguments
+
+The first argument to the `clause` method is an array of pattern match options.  This array can vary in length, and values depending on your pattern match case.
+
+You can match against specific values:
+
+```ruby
+clause(["foo"], proc {...})
+clause([42], proc {...})
+clause(["Hello", :darth_vader], proc {...})
+```
+
+You can match against specifc argument types:
+
+```ruby
+clause([String], proc {...})
+clause([Fixnum], proc {...})
+clause([String, Symbol], proc {...})
+```
+
+You can match against specific values and types:
+
+```ruby
+clause(["Hello", String], proc {...})
+clause([42, Fixnum], proc {...})
+clause([String, :darth_vader], proc {...})
+```
+
+You also can match against any value or type if you don't have a specific requirement for an argument by using the `:any` symbol.
+
+```ruby
+clause(["Hello", :any], proc {...})
+clause([:any], proc {...})
+clause([42, :any], proc {...})
+```
+
+You also can destructure an array with `:tail`.
+
+```ruby
+clause(["Hello", [Fixnum, :tail]], proc { |string, number, tail_array| ...  })
+clause([Hash, [Fixnum, Fixnum :tail]], proc { |hash, number1, number2,  tail_array| ... })
+```
+
+
+
+### Examples
+
+Please see the [examples directory](https://github.com/mojotech/rubo_claus/tree/master/examples) for various example use cases.  Most examples include direct comparisons of the Ruby code to a similar implementation in Elixir.
+
+## Development
+
+Don't introduce unneeded external dependencies.
+
+Nothing else special to note for development.  Just add tests associated to any code changes and make sure they pass.
+
+## TODO
+
+- [ ] Rename public API methods? `define_function` is awkward since Ruby uses the term `method` instead of `function`
+- [ ] Add Benchmarks to see performance implications
+- [ ] Support private clauses to enforce a single entry point to a defined function
+
+---
+
+[![Build Status](https://travis-ci.org/mojotech/rubo_claus.svg?branch=master)](https://travis-ci.org/mojotech/rubo_claus)
+[![contributions welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat)](https://github.com/dwyl/esta/issues)

data/examples/cookie_hash.rb

@@ -0,0 +1,32 @@
+# From https://github.com/jnunemaker/httparty/blob/master/lib/httparty/cookie_hash.rb
+
+class HTTParty::CookieHash < Hash #:nodoc:
+  include RuboClaus
+  
+  CLIENT_COOKIES = %w(path expires domain path secure httponly)
+
+  define_function :add_cookies do
+    clauses(
+      clause([String], proc { |s| ... }),
+      clause([Hash], proc { |h| merge!(h) }),
+      catch_all(proc { raise "add_cookies only takes a Hash or a String" })
+    )
+  end
+  
+  ##  Ruby originally implemented in jnunemaker/httparty
+  #
+  #  def add_cookies(value)
+  #    case value
+  #    when Hash
+  #      merge!(value)
+  #    when String
+  #      ...
+  #    else
+  #      raise "add_cookies only takes a Hash or a String"
+  #    end
+  #  end
+
+  def to_cookie_string
+    reject { |k, v| CLIENT_COOKIES.include?(k.to_s.downcase) }.collect { |k, v| "#{k}=#{v}" }.join("; ")
+  end
+end

data/examples/dna.rb

@@ -0,0 +1,43 @@
+require 'rubo_claus'
+
+class DNA
+  include RuboClaus
+
+  def to_rna(dna='')
+    dna.split(//).map { |char| transform(char) }.join('')
+  end
+
+  define_function :transform do
+    clauses(
+      clause(['G'], proc { 'C' }),
+      clause(['C'], proc { 'G' }),
+      clause(['T'], proc { 'A' }),
+      clause(['A'], proc { 'U' })
+    )
+  end
+end
+
+###
+### ELIXIR VERSION
+###
+#
+# defmodule DNA do
+#   @doc """
+#   Transcribes a character list representing DNA nucleotides to RNA
+#
+#   ## Examples
+#
+#   iex> DNA.to_rna('ACTG')
+#   'UGAC'
+#   """
+#   @spec to_rna([char]) :: [char]
+#   def to_rna(dna) do
+#     Enum.map dna, &transform/1
+#   end
+#
+#   @spec transform(char) :: char
+#   defp transform(?G), do: ?C
+#   defp transform(?C), do: ?G
+#   defp transform(?T), do: ?A
+#   defp transform(?A), do: ?U
+# end

data/examples/list_operations.rb

@@ -0,0 +1,33 @@
+require 'rubo_claus'
+
+class ListOps
+  include RuboClaus
+
+  define_function :count do
+    clauses(
+      clause([Array], proc { |array| count(array, 0) }),
+      clause([[], Fixnum], proc { |_array, sum| sum }),
+      clause([[:any, :tail], Fixnum], proc { |_head, tail, sum| count(tail, sum + 1) })
+    )
+  end
+
+  # The Ruby way to implement count recursively
+  def plain_ruby_count(array, sum=0)
+    return sum if array == []
+    a, *b = array
+    plain_ruby_count(b, sum + 1)
+  end
+end
+
+###
+### ELIXIR VERSION
+###
+# defmodule ListOps do
+#   @moduledoc """
+#   Implements some common list operations by hand
+#   """
+#   @spec count(list) :: non_neg_integer
+#   def count(l), do: l |> count(0)
+#   def count([], sum), do: sum
+#   def count([_|t], sum), do: count(t, sum + 1)
+# end

data/examples/run_length_encoder.rb

@@ -0,0 +1,70 @@
+require 'rubo_claus'
+
+class RunLengthEncoder
+  include RuboClaus
+
+  def encode(str)
+    encoder str.split(//), ''
+  end
+
+  define_function :encoder do
+    clauses(
+      clause([[], String], proc { |_arr, encoded| encoded }),
+      clause([Array, String], proc do |arr, encoded|
+        encoder(arr, encoded, 1)
+      end),
+      clause([Array, String, Fixnum], proc do |arr, encoded, count|
+        h, *t = arr
+        if h == t[0]
+          encoder(t, encoded, count + 1)
+        else
+          encoder(t, encoded + "#{count}#{h}")
+        end
+      end)
+    )
+  end
+end
+
+###
+### ELIXIR VERSION
+###
+#
+# defmodule RunLengthEncoder do
+#   @doc """
+#   Generates a string where consecutive elements are represented as a data value and count.
+#   "HORSE" => "1H1O1R1S1E"
+#   For this example, assume all input are strings, that are all uppercase letters.
+#   It should also be able to reconstruct the data into its original form.
+#   "1H1O1R1S1E" => "HORSE"
+#   """
+#   @spec encode(String.t) :: String.t
+#   def encode(string) do
+#     encoder String.codepoints(string), ""
+#   end
+#
+#   @spec encoder([String.t], String.t) :: String.t
+#   defp encoder([], encoded), do: encoded
+#   defp encoder([h | t], encoded), do: encoder([h | t], encoded, 1)
+#
+#   @spec encoder([String.t], String.t, integer()) :: String.t
+#   defp encoder([h | t], encoded, count) do
+#     cond do
+#       Enum.at(t, 0) == h -> encoder(t, encoded, count + 1)
+#       true -> encoder(t, encoded <> "#{count}#{h}")
+#     end
+#   end
+#
+#   @spec decode(String.t) :: String.t
+#   def decode(string) do
+#     Regex.scan(~r/\\d+[A-Z]/, string) |> List.flatten |> decoder
+#   end
+#
+#   @spec decoder([String.t]) :: String.t
+#   defp decoder(chars) do
+#     Enum.reduce chars, "", &(&2 <> format_string(String.split_at(&1, -1)))
+#   end
+#
+#   @spec format_string(String.t) :: String.t
+#   defp format_string({1, str}), do: str
+#   defp format_string({cnt, str}), do: String.duplicate(str, String.to_integer(cnt))
+# end

data/lib/match.rb

@@ -1,29 +1,30 @@
 module Match
-  def deep_match?(lhs, rhs)
+  def match?(lhs, rhs)
+    return true if lhs.is_a?(RuboClaus::CatchAll)
+    return false if lhs.args.length != rhs.length
+    any_match?(lhs.args, rhs)
+  end
+
+  private def deep_match?(lhs, rhs)
     return match_array(lhs, rhs) if [lhs, rhs].all? { |side| side.is_a? Array }
     return match_hash(lhs, rhs) if [lhs, rhs].all? { |side| side.is_a? Hash }
     false
   end
 
-  def single_match?(lhs, rhs)
+  private def single_match?(lhs, rhs)
     return true if lhs == :any
     return true if lhs == rhs
     return true if lhs == rhs.class
     false
   end
 
-  def match?(lhs, rhs)
-    return true if lhs.is_a?(RuboClaus::CatchAll)
-    return false if lhs.args.length != rhs.length
-    any_match?(lhs.args, rhs)
-  end
-
-  def any_match?(lhs, rhs)
+  private def any_match?(lhs, rhs)
     return true if single_match?(lhs, rhs)
     deep_match?(lhs, rhs)
   end
 
   private def match_array(lhs, rhs)
+    return head_tail_destructuring_match(lhs, rhs) if lhs.include?(:tail)
     return false if lhs.length != rhs.length
     lhs.zip(rhs) { |array| return false unless any_match?(*array) } || true
   end
@@ -46,4 +47,8 @@ module Match
   private def values_match?(lhs, rhs)
     any_match?(lhs.values, rhs.values)
   end
+
+  private def head_tail_destructuring_match(lhs, rhs)
+    any_match?(lhs[0..-2], rhs[0..(lhs[0..-2].size - 1)])
+  end
 end

data/lib/rubo_claus.rb

@@ -3,6 +3,7 @@ require 'match'
 module RuboClaus
   include Match
   Clause = Struct.new(:args, :function)
+  PrivateClause = Struct.new(:args, :function)
   CatchAll = Struct.new(:proc)
 
   class NoPatternMatchError < NoMethodError; end
@@ -10,13 +11,23 @@ module RuboClaus
   module ClassMethods
     def define_function(symbol, &block)
       @function_name = symbol
+      @from_proc = false
       block.call
     end
 
     def clauses(*klauses)
       define_method(@function_name) do |*runtime_args|
-        matching_function = find_matching_function(klauses, runtime_args)
-        matching_function ? matching_function.call(*runtime_args) : raise(NoPatternMatchError)
+        case matching_clause = find_matching_clause(klauses, runtime_args)
+        when Clause
+          execute(head_tail_handle(matching_clause.args, runtime_args), matching_clause.function)
+        when PrivateClause
+          raise NoPatternMatchError, "no pattern defined for: #{runtime_args}" unless @from_proc
+          execute(head_tail_handle(matching_clause.args, runtime_args), matching_clause.function)
+        when CatchAll
+          execute(runtime_args, matching_clause.proc)
+        else
+          raise NoPatternMatchError, "no pattern defined for: #{runtime_args}"
+        end
       end
     end
 
@@ -24,15 +35,36 @@ module RuboClaus
       Clause.new(args, function)
     end
 
+    def p_clause(args, function)
+      PrivateClause.new(args, function)
+    end
+
     def catch_all(_proc)
       CatchAll.new(_proc)
     end
   end
 
-  private def find_matching_function(klauses, runtime_args)
+  private def execute(args, proc)
+    @from_proc = true
+    method = instance_exec *args, &proc
+    @from_proc = false
+    method
+  end
+
+  private def find_matching_clause(klauses, runtime_args)
     clause = klauses.find { |pattern| match?(pattern, runtime_args) }
-    return clause.function if clause.is_a?(Clause)
-    return clause.proc if clause.is_a?(CatchAll)
+    return clause if [Clause, PrivateClause, CatchAll].include?(clause.class)
+  end
+
+  private def head_tail_handle(lhs, rhs)
+    lhs.each_with_index.flat_map do |arg, index|
+      if arg.is_a?(Array) && arg.include?(:tail)
+        number_of_heads = lhs[index][0..-2].size
+        rhs[index][0..(number_of_heads - 1)] + [rhs[index][number_of_heads..-1]]
+      else
+        [rhs[index]]
+      end
+    end
   end
 
   def self.included(klass)

data/lib/rubo_claus/version.rb

@@ -1,3 +1,3 @@
 module RuboClaus
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/rubo_claus.gemspec

@@ -3,17 +3,20 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'rubo_claus/version'
 
 Gem::Specification.new do |s|
-  s.name 					= 'rubo_claus'
-  s.version 			= RuboClaus::VERSION
-  s.date 					= '2016-08-09'
-  s.summary 			= 'Ruby Method Pattern Matcher'
-  s.description 	= 'Define ruby methods with pattern matching much like Erlang/Elixir'
-  s.authors 			= ['Omid Bachari', 'Craig P Jolicoeur']
-  s.email 				= ['omid@mojotech.com', 'craig@mojotech.com']
-  s.files 				= `git ls-files`.split($/)
+  s.name          = 'rubo_claus'
+  s.version       = RuboClaus::VERSION
+  s.date          = '2016-08-09'
+  s.summary       = 'Ruby Method Pattern Matcher'
+  s.description   = 'Define ruby methods with pattern matching much like Erlang/Elixir'
+  s.authors       = ['Omid Bachari', 'Craig P Jolicoeur']
+  s.email         = ['omid@mojotech.com', 'craig@mojotech.com']
+  s.files         = `git ls-files`.split($/)
   s.test_files    = s.files.grep(%r{^(test|spec|features)/})
   s.require_paths = ["lib"]
-  s.license 			= 'MIT'
+  s.license       = 'MIT'
+  s.homepage      = 'http://mojotech.github.io/rubo_claus/'
 
   s.add_development_dependency 'rake', '~> 0'
+  s.add_development_dependency 'minitest', '>= 5.9'
+  s.required_ruby_version = '>= 2.1'
 end

data/test/test_match.rb

@@ -0,0 +1,69 @@
+require 'minitest/autorun'
+require 'match'
+
+class MyClassTest < Minitest::Test
+  include Match
+  Clause = Struct.new(:args, :function)
+
+  def test_types
+    lhs = Clause.new([String, Fixnum, Array, Symbol, Float, Hash, Proc], '')
+    rhs = ["", 1, [], :hi, 1.1, {}, proc {}]
+    assert match?(lhs, rhs)
+  end
+
+  def test_any_matching
+    lhs = Clause.new([:any, 1, :any], '')
+    rhs = ["dog", 1, 1.22]
+
+    assert match?(lhs, rhs)
+  end
+
+  def test_literal_matching
+    lhs = Clause.new([1, 2, 3], '')
+    rhs = [1, 2, 3]
+    rhs_fail = [2, 2, 4]
+
+    assert match?(lhs, rhs)
+    assert !match?(lhs, rhs_fail)
+  end
+
+  # array
+  def test_array_matching
+    lhs = Clause.new([1, [:any, Hash, 2], 3], '')
+    rhs = [1, ["Dog", {people: ['Tom', 'Mary']}, 2], 3]
+
+    assert match?(lhs, rhs)
+  end
+
+  def test_array_matching_2
+    lhs = Clause.new([1, [[:any, [1]], Hash, 2], 3], '')
+    rhs = [1, [[2, [1]], {people: ['Tom', 'Mary']}, 2], 3]
+    rhs_fail = [1, [[2, [77]], {people: ['Tom', 'Mary']}, 2], 3]
+
+    assert match?(lhs, rhs)
+    assert !match?(lhs, rhs_fail)
+  end
+
+  def test_hash_matching
+    lhs = Clause.new([{name: :any, friends: Array, home_phone: String}], '')
+    rhs = [{name: "Jose", friends: ['Tim', 'Mary'], home_phone: '234-234-2343'}]
+    rhs_fail = [{username: "Jose", friends: ['Tim', 'Mary'], home_phone: '234-234-2343'}]
+
+    assert match?(lhs, rhs)
+    assert !match?(lhs, rhs_fail)
+  end
+
+  def test_hash_destructuring
+    lhs = Clause.new([{name: :any, friends: Array, home_phone: String}], '')
+    rhs = [{name: "Jose", friends: ['Tim', 'Mary'], home_phone: '234-234-2343', fax_number: '11-1111-111'}]
+
+    assert match?(lhs, rhs)
+  end
+
+  def test_compound_data_matching
+    lhs = Clause.new([{name: :any, friends: Array, home_phone: String, homes: [:any, Array, {address: [String, "111 Gomer Pile"]}]}], '')
+    rhs = [{name: "Jose", friends: ['Tim', 'Mary'], home_phone: '234-234-2343', homes: ["Big one", [1, 2 ,3], {address: ["Home", "111 Gomer Pile"]}], fax_number: '11-1111-111'}]
+
+    assert match?(lhs, rhs)
+  end
+end

data/test/test_rubo_claus.rb

@@ -11,51 +11,39 @@ end
 class MyClass
   include RuboClaus
 
-  define_function :add_one do
+  define_function :return_thing do
     clauses(
-      clause([0], proc { |n| "Dont add one to zero please!" }),
-      clause([NilClass], proc { |n| 42 }),
-      clause([:any], proc { |n| n + 1 }),
-      catch_all(proc { raise NoMethodError, "no clause defined} "})
+      clause([Array], proc { |n| n.inspect }),
+      clause([:any], proc { |n| n })
     )
   end
 
-  define_function :greeting do
+  define_function :return_two_things do
     clauses(
-      clause([String], proc { |str| "Hello, #{str}!" }),
-      clause([String, String], proc { |greet, str| "#{greet}, #{str}!"})
+      clause([:any, :any], proc { |n, n1| [n, n1] }),
+      clause([:any], proc { "Please use two things, not one." })
     )
   end
 
-  define_function :any_test do
+  define_function :welcome_persons_named_tim do
     clauses(
-      clause([1, :any, 3], proc { |n1, any, n3| "#{n1} ANY 2" }),
-      clause([:any, 2, 3], proc { |any, n2, n3| "ANY 2 3" }),
-      clause([:any, 2, :any], proc { |ne1, n2, ne2| "ANY 2 ANY" })
+      clause(["Tim"], proc { "Please welcome Tim."}),
+      catch_all(proc { "You are not Tim." })
     )
   end
 
-  define_function :print_string_in_array do
+  define_function :fib do
     clauses(
-      clause([1, [:any, [String]], Fixnum], proc { |n, n1, n2| "#{n1[1][0]}" })
+      clause([0], proc { 0 }),
+      clause([1], proc { 1 }),
+      clause([Fixnum], proc { |num| fib(num-1) + fib(num-2) })
     )
   end
 
-  define_function :integer_in_nested_array do
+  define_function :get_head_and_tail_shallow do
     clauses(
-      clause([Fixnum, 2, [[[[[Fixnum]]]]]], proc { |n, n1, n2| n2[0][0][0][0][0] })
-    )
-  end
-
-  define_function :hash_keys do
-    clauses(
-      clause([Hash], proc { |hash| hash.keys })
-    )
-  end
-
-  define_function :friend_hash do
-    clauses(
-      clause([{friend: String, foe: :any}], proc { |n| "I know #{n[:friend]}" })
+      clause([[String, :any, :tail], :any], proc { |n, n1, n2_tail, n3| {first: n, second: n1, third: n2_tail, fourth: n3} }),
+      clause([[:any, :tail], :any], proc { |n, n1_tail, n2| {first: n, second: n1_tail, third: n2} })
     )
   end
 
@@ -65,12 +53,6 @@ class MyClass
     )
   end
 
-  define_function :get_people do
-    clauses(
-      clause([:any, [1, 2, String, String], {people: String}], proc { |n, n1, n2| n2[:people] })
-    )
-  end
-
   define_function :night_emergency_phone do
     param_shape = {username: String, friends: Array, phone: {fax: :any, mobile: String, emergency: {day: String, night: String}}}
 
@@ -80,97 +62,70 @@ class MyClass
              end)
     )
   end
-end
-
-class MyClassTest < Minitest::Test
-  def test_simple_clauses
-    k = MyClass.new
-    assert_equal "Dont add one to zero please!", k.add_one(0)
-    assert_equal 3, k.add_one(2)
-    assert_equal 42, k.add_one(nil)
-    assert_raises NoMethodError do
-      k.add_one(1,2,3, [:b])
-    end
-  end
 
-  def test_variadic_arity
-    k = MyClass.new
-    assert_equal "Hello, Newman!", k.greeting("Newman")
-    assert_equal "Bye Bye, Dolly!", k.greeting("Bye Bye", "Dolly")
+  define_function :count do
+    clauses(
+      clause([Array], proc { |array| count(array, 0) }),
+      clause([[], Fixnum], proc { |_array, sum| sum }),
+      clause([[:any, :tail], Fixnum], proc { |_head, tail, sum| count(tail, sum + 1) })
+    )
   end
 
-  def test_mixed_location_any_terms
-    k = MyClass.new
-    assert_equal "1 ANY 2", k.any_test(1,999,3)
-    assert_equal "ANY 2 3", k.any_test(999,2,3)
-    assert_equal "ANY 2 ANY", k.any_test(999,2,987)
+  define_function :count_with_private do
+    clauses(
+      clause([Array], proc { |array| count_with_private(array, 0) }),
+      p_clause([[], Fixnum], proc { |_array, sum| sum }),
+      p_clause([[:any, :tail], Fixnum], proc { |_head, tail, sum| count_with_private(tail, sum + 1) })
+    )
   end
+end
 
-  def test_no_catch_all_clause_defined
+class MyClassTest < Minitest::Test
+  def test_define_function
     k = MyClass.new
 
-    assert_raises RuboClaus::NoPatternMatchError do
-      k.greeting(1,2,3,)
-    end
-
-    assert_raises RuboClaus::NoPatternMatchError do
-      k.greeting(["Goat"])
-    end
+    assert_equal '[1]', k.return_thing([1])
+    assert_equal 1, k.return_thing(1)
   end
 
-  def test_nested_array_with_shape
+  def test_using_clauses_and_variadic_arity
     k = MyClass.new
 
-    assert_equal "Inner string", k.print_string_in_array(1, [1, ["Inner string"]], 3)
+    assert_equal [1, 2], k.return_two_things(1, 2)
+    assert_equal "Please use two things, not one.", k.return_two_things(1)
 
     assert_raises RuboClaus::NoPatternMatchError do
-      k.print_string_in_array(3, [1, "Inner string"], 3)
-    end
-
-    assert_raises RuboClaus::NoPatternMatchError do
-      k.print_string_in_array(3, [1, "Inner string"], "S")
-    end
-
-    assert_raises RuboClaus::NoPatternMatchError do
-      k.print_string_in_array(3, [1, []], "S")
-    end
-
-    assert_raises RuboClaus::NoPatternMatchError do
-      k.print_string_in_array(3, [[]], "S")
+      k.return_two_things(1, 2, 3)
     end
   end
 
-  def test_nested_array
+  def test_using_catchall
     k = MyClass.new
 
-    assert_equal 3, k.integer_in_nested_array(1, 2, [[[[[3]]]]])
-
-    assert_raises RuboClaus::NoPatternMatchError do
-      k.integer_in_nested_array(1, 2, [[[[["Dog"]]]]])
-    end
+    assert_equal "Please welcome Tim.", k.welcome_persons_named_tim("Tim")
+    assert_equal "You are not Tim.", k.welcome_persons_named_tim("Don")
   end
 
-  def test_hash
+  def test_using_recursion
     k = MyClass.new
 
-    assert_equal [:dog], k.hash_keys({dog: :bone})
-
-    assert_raises RuboClaus::NoPatternMatchError do
-      k.hash_keys([{}])
-    end
-  end
+    assert_equal 0, k.fib(0)
+    assert_equal 1, k.fib(1)
+    assert_equal 1, k.fib(2)
+    assert_equal 2, k.fib(3)
+    assert_equal 3, k.fib(4)
 
-  def test_hash_with_keys
-    k = MyClass.new
+    assert_equal 3, k.count([1, 2, 3])
+    assert_equal 1, k.count([1])
 
-    assert_equal "I know John", k.friend_hash({friend: "John", foe: 3})
+    assert_equal 3, k.count_with_private([1, 2, 3])
 
     assert_raises RuboClaus::NoPatternMatchError do
-      k.friend_hash({})
+      k.count_with_private([1, 2, 3], 3)
     end
   end
 
-  def test_hash_with_keys_destructured
+  def test_shallow_hash_destructuring
     k = MyClass.new
 
     assert_equal "I know everything about John", k.friend_hash_des({friend: "John", foe: 3})
@@ -180,20 +135,19 @@ class MyClassTest < Minitest::Test
     end
   end
 
-  def test_compound_hash_array
+  def test_shallow_head_tail_destructuring
     k = MyClass.new
+    output = {first: 1, second: [2, 3, 4], third: 5}
+    second_output = {first: "1", second: 2, third: [3, 4], fourth: 5}
 
-    assert_equal "John", k.get_people("Douglas", [1, 2, "Anything", "Another any string"], {people: "John"})
-
-    assert_raises RuboClaus::NoPatternMatchError do
-      k.get_people("Douglas", [], {people: "John"})
-    end
+    assert_equal output, k.get_head_and_tail_shallow([1, 2, 3, 4], 5)
+    assert_equal second_output, k.get_head_and_tail_shallow(["1", 2, 3, 4], 5)
   end
 
-  def test_three_dimensional_compound_data_structure
+  def test_compound_data_destructuring
     k = MyClass.new
 
-    param = {username: "Sally Moe", friends: [], phone: {fax: "NA", mobile: "123-345-1232", emergency: {day: "123-123-1234", night: "999-999-9999"}}}
+    param = {username: "Sally Moe", friends: [], phone: {fax: "NA", mobile: "123-345-1232", emergency: {day: "123-123-1234", night: "999-999-9999", weekend: '123-123-1233'}}}
     assert_equal "999-999-9999", k.night_emergency_phone(param)
 
     assert_raises RuboClaus::NoPatternMatchError do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubo_claus
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Omid Bachari
@@ -25,6 +25,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.9'
 description: Define ruby methods with pattern matching much like Erlang/Elixir
 email:
 - omid@mojotech.com
@@ -33,15 +47,23 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".ruby-version"
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
 - README.md
 - Rakefile
+- examples/.keep
+- examples/cookie_hash.rb
+- examples/dna.rb
+- examples/list_operations.rb
+- examples/run_length_encoder.rb
 - lib/match.rb
 - lib/rubo_claus.rb
 - lib/rubo_claus/version.rb
 - rubo_claus.gemspec
+- test/test_match.rb
 - test/test_rubo_claus.rb
-homepage: 
+homepage: http://mojotech.github.io/rubo_claus/
 licenses:
 - MIT
 metadata: {}
@@ -53,7 +75,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -66,4 +88,5 @@ signing_key:
 specification_version: 4
 summary: Ruby Method Pattern Matcher
 test_files:
+- test/test_match.rb
 - test/test_rubo_claus.rb

data/.ruby-version

@@ -1 +0,0 @@
-2.3.1