matchete 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a3717143d8e222ee9da803cd7647f328c36f56a7
-  data.tar.gz: bf3af40853ad0382c1776698fb8997da63a7254b
+  metadata.gz: d82680012c34cb8d63c1e461711b34727036a455
+  data.tar.gz: a23af03a534d39a1295855a959eb362ceebbda82
 SHA512:
-  metadata.gz: 4684675527ccb701546d644fb324d189befd55d0f4dfcb77fa09e58dab98b67c40ccd629494e3cdc495b54a3c188d1acd67a38fb2b02ea19443ecca87596e8f8
-  data.tar.gz: 30b6af0a2dbf30a61cf307cdad0d9e691aa9039b34aa4c6569c90a8876bc937a5975d93d4261286dbbfe4243510f4e1d11883eddec29bf62ea93649e7b3dd583
+  metadata.gz: 29d6a30c0274d6fbe59c79dcbbc1c78c5359f76bddc2791c8afeb8980e3219bcc44e6eebe837997e4644497fd9f50dc89f7503130c3488a33757a787f2e9d4bf
+  data.tar.gz: 9fae0969b2f2aa630d3608d38db7c91fca1a56f32ca423a0aacfbb11952bf1db45bf025a510faf96694a702e280007cf59468719bbc8138be15f7fa64385b076

data/README.md

@@ -1 +1,103 @@
-#Matchete
+Matchete
+=========
+
+Matchete provides a DSL for method overloading based on pattern matching for Ruby.
+
+It's just a quick hack inspired by weissbier and the use-return-values-of-method-definitions DSL technique used in [harmonic](https://github.com/s2gatev/harmonic)
+
+Install
+-----
+`gem install matchete`
+
+Usage
+-----
+
+```ruby
+require 'matchete'
+
+class FactorialStrikesAgain
+  include Matchete
+
+  on 1,
+  def factorial(value)
+    1
+  end
+
+  on -> x { x > 1 },
+  def factorial(value)
+    value * factorial(value - 1)
+  end
+end
+
+FactorialStrikesAgain.new.factorial(4) #24
+FactorialStrikesAgain.new.factorial(-2) #Matchete::NotResolvedError No matching factorial method for args [-2]
+```
+
+```ruby
+require 'matchete'
+
+class Converter
+  include Matchete
+
+  on Integer,
+  def convert(value)
+    [:integer, value]
+  end
+  
+  on Hash,
+  def convert(values)
+    [:dict, values.map { |k, v| [convert(k), convert(v)] }]
+  end
+  
+  on /reserved_/,
+  def convert(value)
+    [:reserved_symbol, value]
+  end
+  
+  on String,
+  def convert(value)
+    [:string, value]
+  end
+  
+  on ['deleted', [Integer, Any]],
+  def convert(value)
+    ['deleted', value[1]]
+  end
+  
+  on :not_implemented?,
+  def convert(value)
+    [:fail, value]
+  end
+  
+  on free: Integer, method:
+  def convert(free:)
+    [:rofl, free]
+  end
+
+  default def convert(value)
+    [:z, value]
+  end
+  
+  def not_implemented?(value)
+    value.is_a? Symbol
+  end
+end
+
+converter = Converter.new
+p converter.convert(2) #[:integer, 2]
+p converter.convert({2 => 4}) #[:dict, [[[:integer, 2], [:integer, 4]]]
+p converter.convert('reserved_l') #[;reserved_symbol, 'l']
+p converter.convert('zaza') #[:string, 'zaza']
+p converter.convert(['deleted', [2, Array]]) #['deleted', [2, Array]]
+p converter.convert(:f) #[:fail, :f]
+p converter.convert(free: 2) #[:rofl, 2]
+p converter.convert(2.2) #[:z, 2.2]
+```
+
+Todo
+-----
+
+Copyright
+-----
+
+Copyright (c) 2014 Alexander Ivanov. See LICENSE for further details.

data/lib/matchete.rb

@@ -1,31 +1,38 @@
 require 'set'
+require_relative 'matchete/exceptions'
 
 module Matchete
-  class NotResolvedError < StandardError
-  end
-
   def self.included(klass)
     klass.extend ClassMethods
-    klass.instance_variable_set "@functions", {}
-    klass.instance_variable_set "@default_functions", {}
+    klass.instance_variable_set "@methods", {}
+    klass.instance_variable_set "@default_methods", {}
   end
 
   Any = -> (x) { true }
   None = -> (x) { false }
 
   module ClassMethods
-    def on(*guards, function)
-      @functions[function] ||= []
-      @functions[function] << [guards, instance_method(function)]
-      convert_to_matcher function
+    def on(*args, **kwargs)
+      if kwargs.count.zero?
+        *guard_args, method_name = args
+        guard_kwargs = {}
+      else
+        method_name = kwargs[:method]
+        kwargs.delete :method
+        guard_args = args
+        guard_kwargs = kwargs
+      end
+      @methods[method_name] ||= []
+      @methods[method_name] << [guard_args, guard_kwargs, instance_method(method_name)]
+      convert_to_matcher method_name
     end
 
     def default(method_name)
-      @default_functions[method_name] = instance_method(method_name)
+      @default_methods[method_name] = instance_method(method_name)
       convert_to_matcher method_name
     end
 
-    def duck(*method_names)
+    def supporting(*method_names)
       -> object do
         method_names.all? do |method_name|
           object.respond_to? method_name
@@ -33,51 +40,72 @@ module Matchete
       end
     end
 
-    def convert_to_matcher(function)
-      define_method(function) do |*args|
-        guards = self.class.instance_variable_get('@functions')[function].find do |guards, _|
-          self.class.match_guards guards, args
-        end
-        
-        handler = if guards.nil?
-          default_method = self.class.instance_variable_get('@default_functions')[function]
-          if default_method
-            default_method
-          else
-            raise NotResolvedError.new("not resolved #{function} with #{args}")
-          end
-        else
-          guards[1]
-        end
-
-        handler.bind(self).call *args
+    def convert_to_matcher(method_name)
+      define_method(method_name) do |*args, **kwargs|
+        call_overloaded(method_name, args: args, kwargs: kwargs)
       end
     end
-
-    def match_guards(guards, args)
-      guards.zip(args).all? do |guard, arg|
-        match_guard guard, arg
+  end
+  
+  def call_overloaded(method_name, args: [], kwargs: {})
+    handler = find_handler(method_name, args, kwargs)
+    if handler.parameters.any? do |type, _|
+        [:key, :keyrest, :keyreq].include? type
       end
+      handler.bind(self).call *args, **kwargs
+    else
+      handler.bind(self).call *args
+    end
+    #insane workaround, because if you have
+    #def z(f);end
+    #and you call it like that
+    #a(2, **{e: 4})
+    #it raises wrong number of arguments (2 for 1)
+    #clean later
+  end
+
+  def find_handler(method_name, args, kwargs)
+    guards = self.class.instance_variable_get('@methods')[method_name].find do |guard_args, guard_kwargs, _|
+      match_guards guard_args, guard_kwargs, args, kwargs
     end
 
-    def match_guard(guard, arg)
-      case guard
-        when Module
-          arg.is_a? guard
-        when Symbol
-          send guard, arg
-        when Proc
-          guard.call arg
-        when String
-          guard == arg
-        when Regexp
-          arg.is_a? String and guard.match arg
-        when Array
-          arg.is_a?(Array) and
-          guard.zip(arg).all? { |child_guard, child| match_guard child_guard, child }
-        else
-          guard == arg
+    if guards.nil?
+      default_method = self.class.instance_variable_get('@default_methods')[method_name]
+      if default_method
+        default_method
+      else
+        raise NotResolvedError.new("No matching #{method_name} method for args #{args}")
       end
+    else
+      guards[2]
+    end
+  end
+
+  def match_guards(guard_args, guard_kwargs, args, kwargs)
+    return false if guard_args.count != args.count || guard_kwargs.count != kwargs.count
+    guard_args.zip(args).all? do |guard, arg|
+      match_guard guard, arg
+    end and
+    guard_kwargs.all? do |label, guard|
+      match_guard guard, kwargs[label]
+    end
+  end
+
+  def match_guard(guard, arg)
+    case guard
+      when Module
+        arg.is_a? guard
+      when Symbol
+        send guard, arg
+      when Proc
+        guard.call arg
+      when Regexp
+        arg.is_a? String and guard.match arg
+      when Array
+        arg.is_a?(Array) and
+        guard.zip(arg).all? { |child_guard, child| match_guard child_guard, child }
+      else
+        guard == arg
     end
   end
 end

data/lib/matchete/exceptions.rb

@@ -0,0 +1,7 @@
+module Matchete
+  class NotResolvedError < StandardError
+  end
+end
+
+
+  

data/matchete.gemspec

@@ -3,7 +3,7 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = 'matchete'
-  s.version     = '0.0.1'
+  s.version     = '0.0.2'
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Alexander Ivanov"]
   s.email       = ["alehander42@gmail.com"]

data/spec/matchete_spec.rb

@@ -69,4 +69,177 @@ describe Matchete do
     a.play([2, 2.2]).should eq [:integer, :float]
     a.play([[2], Matchete]).should eq :s
   end
-end
+
+  it 'can use a pattern based on exact values' do
+    class A
+      include Matchete
+
+      on 2, Integer,
+      def play(value, obj)
+        2
+      end
+
+      on 4, Integer,
+      def play(value, obj)
+        4
+      end
+    end
+
+    a = A.new
+    a.play(2, 4).should eq 2
+    a.play(4, 4).should eq 4
+    -> { a.play(8, 2) }.should raise_error(Matchete::NotResolvedError)
+  end
+
+  it 'can use a pattern based on regexes' do
+    class A
+      include Matchete
+
+      on /z/,
+      def play(value)
+        'z'
+      end
+
+      on /y/,
+      def play(value)
+        'y'
+      end
+    end
+
+    a = A.new
+    a.play('zewr').should eq 'z'
+    a.play('yy').should eq 'y'
+  end
+
+  it 'can use a default method when everything else fails' do
+    class A
+      include Matchete
+
+      on Integer,
+      def play(value)
+        :integer
+      end
+    end
+
+    -> { A.new.play(2.2) }.should raise_error(Matchete::NotResolvedError)
+    
+    class A
+      default def play(value)
+        :else
+      end
+    end
+
+    A.new.play(2.2).should eq :else    
+  end
+
+  it 'can use a pattern based on existing predicate methods given as symbols' do
+    class A
+      include Matchete
+
+      on :even?,
+      def play(value)
+        value
+      end
+      
+      def even?(value)
+        value.remainder(2).zero? #so gay and gay
+      end
+    end
+
+    A.new.play(2).should eq 2
+    -> { A.new.play(5) }.should raise_error(Matchete::NotResolvedError)
+  end
+
+  it 'can use a pattern based on a lambda predicate' do
+    class A
+      include Matchete
+
+      on -> x { x % 2 == 0 },
+      def play(value)
+        value
+      end
+    end
+
+    A.new.play(2).should eq 2
+    -> { A.new.play(7) }.should raise_error(Matchete::NotResolvedError)
+  end
+
+  it 'can use a pattern based on responding to methods' do
+    class A
+      include Matchete
+
+      on supporting(:map),
+      def play(value)
+        value
+      end
+    end
+
+    A.new.play([]).should eq []
+    -> { A.new.play(4) }.should raise_error(Matchete::NotResolvedError)
+  end
+
+  it 'can match on different keyword arguments' do
+    class A
+      include Matchete
+
+      on e: Integer, f: String, method:
+      def play(e:, f:)
+        :y
+      end
+    end
+
+    A.new.play(e: 0, f: "y").should eq :y
+    -> { A.new.play(e: "f", f: Class)}.should raise_error(Matchete::NotResolvedError)
+  end
+
+  it 'can match on multiple different kinds of patterns' do
+    class A
+      include Matchete
+    end
+
+    A.new.match_guards([Integer, Float], {}, [8, 8.8], {}).should be_true
+  end
+
+  describe '#match_guard' do
+    before :all do
+      class A
+        include Matchete
+
+        def even?(value)
+          value.remainder(2).zero?
+        end
+      end
+      @a = A.new
+    end
+
+    it 'matches modules and classes' do
+      @a.match_guard(Integer, 2).should be_true
+      @a.match_guard(Class, 4).should be_false
+    end
+
+    it 'matches methods given as symbols' do
+      @a.match_guard(:even?, 2).should be_true
+      -> { @a.match_guard(:odd?, 4) }.should raise_error
+    end
+
+    it 'matches predicates given as lambdas' do
+      @a.match_guard(-> x { x == {} }, {}).should be_true
+    end
+
+    it 'matches on regex' do
+      @a.match_guard(/a/, 'aw').should be_true
+      @a.match_guard(/z/, 'lol').should be_false
+    end
+
+    it 'matches on nested arrays' do
+      @a.match_guard([Integer, [:even?]], [2, [4]]).should be_true
+      @a.match_guard([Float, [:even?]], [2.2, [7]]).should be_false      
+    end
+
+    it 'matches on exact values' do
+      @a.match_guard(2, 2).should be_true
+      @a.match_guard('d', 'f').should be_false
+    end
+  end
+end
+  

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: matchete
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Alexander Ivanov
@@ -36,6 +36,7 @@ files:
 - README.md
 - Rakefile
 - lib/matchete.rb
+- lib/matchete/exceptions.rb
 - matchete.gemspec
 - spec/matchete_spec.rb
 - spec/spec_helper.rb