rubo_claus 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e4ddf83f73f07a31517416ef5bea818d7d574561
+  data.tar.gz: 9940e9766b9af282e20d30f3d5f98102b2501a48
+SHA512:
+  metadata.gz: c7f8f1c381054d7de8a4bc3dcd212daba86dd996e658315f20bd599ff741df5aad5530fead18846f58b40fda772bd82e6f2971206512ec22173ac789623d972a
+  data.tar.gz: 84bc8b619df55125bca97b0843d2e0bdb54ffe9dad803cce6c01fce7df958012047d5db61d58f4951c1437fe84c864940085304f35530a74973b689a8260bbb2

data/.ruby-version

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

data/README.md

@@ -0,0 +1,11 @@
+# RuboClaus
+
+## Ruby method pattern matching ala Erlang/Elixir
+
+__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.
+
+_You have been warned_

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/lib/match.rb

@@ -0,0 +1,49 @@
+module Match
+  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)
+    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)
+    return true if single_match?(lhs, rhs)
+    deep_match?(lhs, rhs)
+  end
+
+  private def match_array(lhs, rhs)
+    return false if lhs.length != rhs.length
+    lhs.zip(rhs) { |array| return false unless any_match?(*array) } || true
+  end
+
+  private def match_hash(lhs, rhs)
+    lhs, rhs = handle_destructuring(lhs, rhs) if lhs.keys.length < rhs.keys.length
+    return false unless keys_match?(lhs, rhs)
+    return false unless values_match?(lhs, rhs)
+    true
+  end
+
+  private def handle_destructuring(lhs, rhs)
+    [lhs, rhs.select {|k, v| lhs.keys.include? k }]
+  end
+
+  private def keys_match?(lhs, rhs)
+    lhs.keys.sort == rhs.keys.sort
+  end
+
+  private def values_match?(lhs, rhs)
+    any_match?(lhs.values, rhs.values)
+  end
+end

data/lib/rubo_claus/version.rb

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

data/lib/rubo_claus.rb

@@ -0,0 +1,41 @@
+require 'match'
+
+module RuboClaus
+  include Match
+  Clause = Struct.new(:args, :function)
+  CatchAll = Struct.new(:proc)
+
+  class NoPatternMatchError < NoMethodError; end
+
+  module ClassMethods
+    def define_function(symbol, &block)
+      @function_name = symbol
+      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)
+      end
+    end
+
+    def clause(args, function)
+      Clause.new(args, function)
+    end
+
+    def catch_all(_proc)
+      CatchAll.new(_proc)
+    end
+  end
+
+  private def find_matching_function(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)
+  end
+
+  def self.included(klass)
+    klass.extend ClassMethods
+  end
+end

data/rubo_claus.gemspec

@@ -0,0 +1,19 @@
+lib = File.expand_path('../lib', __FILE__)
+$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.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+  s.license 			= 'MIT'
+
+  s.add_development_dependency 'rake', '~> 0'
+end

data/test/test_rubo_claus.rb

@@ -0,0 +1,204 @@
+require 'minitest/autorun'
+require 'rubo_claus'
+require 'rubo_claus/version'
+
+class RuboClausTest < Minitest::Test
+  def test_has_version_number
+    refute_nil RuboClaus::VERSION
+  end
+end
+
+class MyClass
+  include RuboClaus
+
+  define_function :add_one 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} "})
+    )
+  end
+
+  define_function :greeting do
+    clauses(
+      clause([String], proc { |str| "Hello, #{str}!" }),
+      clause([String, String], proc { |greet, str| "#{greet}, #{str}!"})
+    )
+  end
+
+  define_function :any_test 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" })
+    )
+  end
+
+  define_function :print_string_in_array do
+    clauses(
+      clause([1, [:any, [String]], Fixnum], proc { |n, n1, n2| "#{n1[1][0]}" })
+    )
+  end
+
+  define_function :integer_in_nested_array 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]}" })
+    )
+  end
+
+  define_function :friend_hash_des do
+    clauses(
+      clause([{friend: String}], proc { |n| "I know everything about #{n[:friend]}" })
+    )
+  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}}}
+
+    clauses(
+      clause([param_shape], proc do |data|
+               data[:phone][:emergency][:night]
+             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")
+  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)
+  end
+
+  def test_no_catch_all_clause_defined
+    k = MyClass.new
+
+    assert_raises RuboClaus::NoPatternMatchError do
+      k.greeting(1,2,3,)
+    end
+
+    assert_raises RuboClaus::NoPatternMatchError do
+      k.greeting(["Goat"])
+    end
+  end
+
+  def test_nested_array_with_shape
+    k = MyClass.new
+
+    assert_equal "Inner string", k.print_string_in_array(1, [1, ["Inner string"]], 3)
+
+    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")
+    end
+  end
+
+  def test_nested_array
+    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
+  end
+
+  def test_hash
+    k = MyClass.new
+
+    assert_equal [:dog], k.hash_keys({dog: :bone})
+
+    assert_raises RuboClaus::NoPatternMatchError do
+      k.hash_keys([{}])
+    end
+  end
+
+  def test_hash_with_keys
+    k = MyClass.new
+
+    assert_equal "I know John", k.friend_hash({friend: "John", foe: 3})
+
+    assert_raises RuboClaus::NoPatternMatchError do
+      k.friend_hash({})
+    end
+  end
+
+  def test_hash_with_keys_destructured
+    k = MyClass.new
+
+    assert_equal "I know everything about John", k.friend_hash_des({friend: "John", foe: 3})
+
+    assert_raises RuboClaus::NoPatternMatchError do
+      k.friend_hash_des({})
+    end
+  end
+
+  def test_compound_hash_array
+    k = MyClass.new
+
+    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
+  end
+
+  def test_three_dimensional_compound_data_structure
+    k = MyClass.new
+
+    param = {username: "Sally Moe", friends: [], phone: {fax: "NA", mobile: "123-345-1232", emergency: {day: "123-123-1234", night: "999-999-9999"}}}
+    assert_equal "999-999-9999", k.night_emergency_phone(param)
+
+    assert_raises RuboClaus::NoPatternMatchError do
+      param = {username: "Sally Moe", friends: "", phone: {fax: "NA", mobile: "123-345-1232", emergency: [{day: "123-123-1234", night: "999-999-9999"}]}}
+      k.night_emergency_phone(param)
+    end
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: rubo_claus
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Omid Bachari
+- Craig P Jolicoeur
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: Define ruby methods with pattern matching much like Erlang/Elixir
+email:
+- omid@mojotech.com
+- craig@mojotech.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".ruby-version"
+- README.md
+- Rakefile
+- lib/match.rb
+- lib/rubo_claus.rb
+- lib/rubo_claus/version.rb
+- rubo_claus.gemspec
+- test/test_rubo_claus.rb
+homepage: 
+licenses:
+- MIT
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Ruby Method Pattern Matcher
+test_files:
+- test/test_rubo_claus.rb