matchete 0.0.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d82680012c34cb8d63c1e461711b34727036a455
-  data.tar.gz: a23af03a534d39a1295855a959eb362ceebbda82
+  metadata.gz: c15b81dead014a1340a37b9172d0ae776022403e
+  data.tar.gz: 41f24df6592f9844db61c761244adc461a7f188d
 SHA512:
-  metadata.gz: 29d6a30c0274d6fbe59c79dcbbc1c78c5359f76bddc2791c8afeb8980e3219bcc44e6eebe837997e4644497fd9f50dc89f7503130c3488a33757a787f2e9d4bf
-  data.tar.gz: 9fae0969b2f2aa630d3608d38db7c91fca1a56f32ca423a0aacfbb11952bf1db45bf025a510faf96694a702e280007cf59468719bbc8138be15f7fa64385b076
+  metadata.gz: 374025ed07b2683c768cb4129e72ec3b0d6293282ea6356122f630271bf6d53ff198175344d98e27d8673e11e280ba3443f644d6f71b68e607e82188358b65e8
+  data.tar.gz: ef2763cf51026c47d1e9fd04b8087ee0ea2183c8647c68414159af74b79e6bf771d216373130249bcc0a9a37bca162968733400316b8d647aedba0cc39618b18

data/README.md

@@ -5,10 +5,26 @@ Matchete provides a DSL for method overloading based on pattern matching for Rub
 
 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)
 
+**It supports only ruby 2.1+**
+
+Features
+--------
+
+* `on [:value, Integer]` matches an arg with the same internal structure
+* `on '#method_name'` matches args responding to `method_name`
+* `on AClass` matches instances of `AClass`
+* `on a: 2, method:...` matches keyword args
+* `on :test?` matches with user-defined predicate methods
+* `on either('#count', Array)` matches if any of the tests returns true for an arg
+* `on full_match('#count', '#combine')` matches if all of the tests return true for an arg
+
+
+
 Install
 -----
 `gem install matchete`
 
+
 Usage
 -----
 
@@ -34,70 +50,99 @@ FactorialStrikesAgain.new.factorial(-2) #Matchete::NotResolvedError No matching
 ```
 
 ```ruby
-require 'matchete'
-
 class Converter
   include Matchete
 
+  on '#special_convert',
+  def convert(value)
+    value.special_convert
+  end
+
   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?,
+
+  on :starts_with_cat?,
   def convert(value)
     [:fail, value]
   end
-  
+
   on free: Integer, method:
   def convert(free:)
     [:rofl, free]
   end
 
+  on either('#count', Array),
+  def convert(value)
+    value.count
+  end
+
+  on full_match('#count', '#lala'),
+  def convert(value)
+    value.count + value.lala
+  end
+
   default def convert(value)
     [:z, value]
   end
-  
-  def not_implemented?(value)
-    value.is_a? Symbol
+
+  def starts_with_cat?(value)
+    value.to_s.start_with?('cat')
+  end
+end
+
+class Z
+  def special_convert
+    [:special_convert, nil]
   end
 end
 
 converter = Converter.new
+p Converter.instance_methods
 p converter.convert(2) #[:integer, 2]
+p converter.convert(Z.new) #[:special_convert, nil]
+p converter.convert([4, 4]) # 2
 p converter.convert({2 => 4}) #[:dict, [[[:integer, 2], [:integer, 4]]]
-p converter.convert('reserved_l') #[;reserved_symbol, 'l']
+p converter.convert('reserved_l') #[:reserved_symbol, 'reserved_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(:cat_hehe) #[:fail, :cat_hehe]
 p converter.convert(free: 2) #[:rofl, 2]
 p converter.convert(2.2) #[:z, 2.2]
+
 ```
+cbb
+-----
+![](https://global3.memecdn.com/kawaii-danny-trejo_o_2031011.jpg)
 
 Todo
 -----
+* Clean up the specs, right now they're a mess.
+* Fix all kinds of edge cases
+
 
 Copyright
 -----
 
-Copyright (c) 2014 Alexander Ivanov. See LICENSE for further details.
+Copyright (c) 2015 Alexander Ivanov. See LICENSE for further details.

data/lib/matchete.rb

@@ -32,6 +32,14 @@ module Matchete
       convert_to_matcher method_name
     end
 
+    def either(*guards)
+      -> arg { guards.any? { |g| match_guard(g, arg) } }
+    end
+
+    def full_match(*guards)
+      -> arg { guards.all? { |g| match_guard(g, arg) } }
+    end
+
     def supporting(*method_names)
       -> object do
         method_names.all? do |method_name|
@@ -46,22 +54,22 @@ module Matchete
       end
     end
   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
+
+    if kwargs.empty?
       handler.bind(self).call *args
+    else
+      handler.bind(self).call *args, **kwargs
     end
     #insane workaround, because if you have
     #def z(f);end
     #and you call it like that
-    #a(2, **{e: 4})
+    #empty = {}
+    #z(2, **empty)
     #it raises wrong number of arguments (2 for 1)
-    #clean later
+    #clean up later
   end
 
   def find_handler(method_name, args, kwargs)
@@ -77,12 +85,13 @@ module Matchete
         raise NotResolvedError.new("No matching #{method_name} method for args #{args}")
       end
     else
-      guards[2]
+      guards.last
     end
   end
 
   def match_guards(guard_args, guard_kwargs, args, kwargs)
-    return false if guard_args.count != args.count || guard_kwargs.count != kwargs.count
+    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
@@ -92,20 +101,25 @@ module Matchete
   end
 
   def match_guard(guard, arg)
+    p
     case guard
       when Module
         arg.is_a? guard
       when Symbol
         send guard, arg
       when Proc
-        guard.call arg
+        instance_exec arg, &guard
       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 guard.is_a?(String) && guard[0] == '#'
+          arg.respond_to? guard[1..-1]
+        else
+          guard == arg
+        end
     end
   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.2'
+  s.version     = '0.2.0'
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Alexander Ivanov"]
   s.email       = ["alehander42@gmail.com"]
@@ -12,10 +12,10 @@ Gem::Specification.new do |s|
   s.description = %q{A DSL for method overloading for Ruby based on pattern matching}
 
   s.add_development_dependency 'rspec', '~> 0'
-  
+
   s.license       = 'MIT'
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
-end
+end

data/spec/matchete_spec.rb

@@ -20,8 +20,8 @@ describe Matchete do
     end
 
     a = A.new
-    a.play(2).should eq :integer
-    a.play(2.2, 4).should eq :float
+    expect(a.play(2)).to eq :integer
+    expect(a.play(2.2, 4)).to eq :float
   end
 
   it 'can use a pattern based on classes and modules' do
@@ -45,9 +45,9 @@ describe Matchete do
     end
 
     a = A.new
-    a.play(2).should eq :integer
-    a.play(2.2).should eq :float
-    a.play([2]).should eq :enumerable
+    expect(a.play(2)).to eq :integer
+    expect(a.play(2.2)).to eq :float
+    expect(a.play([2])).to eq :enumerable
   end
 
   it 'can use a pattern based on nested arrays with classes/modules' do
@@ -66,8 +66,8 @@ describe Matchete do
     end
 
     a = A.new
-    a.play([2, 2.2]).should eq [:integer, :float]
-    a.play([[2], Matchete]).should eq :s
+    expect(a.play([2, 2.2])).to eq [:integer, :float]
+    expect(a.play([[2], Matchete])).to eq :s
   end
 
   it 'can use a pattern based on exact values' do
@@ -86,9 +86,9 @@ describe Matchete do
     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)
+    expect(a.play(2, 4)).to eq 2
+    expect(a.play(4, 4)).to eq 4
+    expect { a.play(8, 2) }.to raise_error(Matchete::NotResolvedError)
   end
 
   it 'can use a pattern based on regexes' do
@@ -107,8 +107,8 @@ describe Matchete do
     end
 
     a = A.new
-    a.play('zewr').should eq 'z'
-    a.play('yy').should eq 'y'
+    expect(a.play('zewr')).to eq 'z'
+    expect(a.play('yy')).to eq 'y'
   end
 
   it 'can use a default method when everything else fails' do
@@ -121,15 +121,15 @@ describe Matchete do
       end
     end
 
-    -> { A.new.play(2.2) }.should raise_error(Matchete::NotResolvedError)
-    
+    expect { A.new.play(2.2) }.to raise_error(Matchete::NotResolvedError)
+
     class A
       default def play(value)
         :else
       end
     end
 
-    A.new.play(2.2).should eq :else    
+    expect(A.new.play(2.2)).to eq :else
   end
 
   it 'can use a pattern based on existing predicate methods given as symbols' do
@@ -140,14 +140,14 @@ describe Matchete do
       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)
+    expect(A.new.play(2)).to eq 2
+    expect { A.new.play(5) }.to raise_error(Matchete::NotResolvedError)
   end
 
   it 'can use a pattern based on a lambda predicate' do
@@ -160,8 +160,8 @@ describe Matchete do
       end
     end
 
-    A.new.play(2).should eq 2
-    -> { A.new.play(7) }.should raise_error(Matchete::NotResolvedError)
+    expect(A.new.play(2)).to eq 2
+    expect { A.new.play(7) }.to raise_error(Matchete::NotResolvedError)
   end
 
   it 'can use a pattern based on responding to methods' do
@@ -174,8 +174,8 @@ describe Matchete do
       end
     end
 
-    A.new.play([]).should eq []
-    -> { A.new.play(4) }.should raise_error(Matchete::NotResolvedError)
+    expect(A.new.play([])).to eq []
+    expect { A.new.play(4) }.to raise_error(Matchete::NotResolvedError)
   end
 
   it 'can match on different keyword arguments' do
@@ -188,8 +188,8 @@ describe Matchete do
       end
     end
 
-    A.new.play(e: 0, f: "y").should eq :y
-    -> { A.new.play(e: "f", f: Class)}.should raise_error(Matchete::NotResolvedError)
+    expect(A.new.play(e: 0, f: "y")).to eq :y
+    expect { A.new.play(e: "f", f: Class)}.to raise_error(Matchete::NotResolvedError)
   end
 
   it 'can match on multiple different kinds of patterns' do
@@ -197,7 +197,7 @@ describe Matchete do
       include Matchete
     end
 
-    A.new.match_guards([Integer, Float], {}, [8, 8.8], {}).should be_true
+    expect(A.new.match_guards([Integer, Float], {}, [8, 8.8], {})).to be_truthy
   end
 
   describe '#match_guard' do
@@ -213,33 +213,33 @@ describe Matchete do
     end
 
     it 'matches modules and classes' do
-      @a.match_guard(Integer, 2).should be_true
-      @a.match_guard(Class, 4).should be_false
+      expect(@a.match_guard(Integer, 2)).to be_truthy
+      expect(@a.match_guard(Class, 4)).to be_falsey
     end
 
     it 'matches methods given as symbols' do
-      @a.match_guard(:even?, 2).should be_true
-      -> { @a.match_guard(:odd?, 4) }.should raise_error
+      expect(@a.match_guard(:even?, 2)).to be_truthy
+      expect { @a.match_guard(:odd?, 4) }.to raise_error
     end
 
     it 'matches predicates given as lambdas' do
-      @a.match_guard(-> x { x == {} }, {}).should be_true
+      expect(@a.match_guard(-> x { x == {} }, {})).to be_truthy
     end
 
     it 'matches on regex' do
-      @a.match_guard(/a/, 'aw').should be_true
-      @a.match_guard(/z/, 'lol').should be_false
+      expect(@a.match_guard(/a/, 'aw')).to be_truthy
+      expect(@a.match_guard(/z/, 'lol')).to be_falsey
     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      
+      expect(@a.match_guard([Integer, [:even?]], [2, [4]])).to be_truthy
+      expect(@a.match_guard([Float, [:even?]], [2.2, [7]])).to be_falsey
     end
 
     it 'matches on exact values' do
-      @a.match_guard(2, 2).should be_true
-      @a.match_guard('d', 'f').should be_false
+      expect(@a.match_guard(2, 2)).to be_truthy
+      expect(@a.match_guard('d', 'f')).to be_falsey
     end
   end
 end
-  
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: matchete
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Alexander Ivanov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-20 00:00:00.000000000 Z
+date: 2015-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -60,8 +60,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Method overloading for Ruby based on pattern matching
-test_files: []
+test_files:
+- spec/matchete_spec.rb
+- spec/spec_helper.rb