defmatch 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 31f145fc6e1eb79e17023f0857c7aa0743d21635
-  data.tar.gz: ee52c39e0f841cc70ef1724453b524084463b88a
+  metadata.gz: 4d48a7b93d105306536da143e7762fe0184b5dbd
+  data.tar.gz: 982228cc5e465124ea6f6a6745ee729789c214ff
 SHA512:
-  metadata.gz: 28cb8b2f285d1befe9ec3e5fea7be53e5c55244499f497a976463ce2662fd79dc42eb610e7e95026ed3af2318428d4cbd282af4736817053c37f3a74f39ad2ee
-  data.tar.gz: f33a33c7ac4dd4bbe779d3c056bf0e2c39ebc7f2925f978cefa39b2a259be92e092427ea8c0c09d658398055968cf128ffa334fae16d77390fd318107bd4d142
+  metadata.gz: d2e95091e117a324eee5d93437d5a4a7697779c46168da203a70b4a9f5c9cce9a4f61abc3785735d339998dbd0889eb2e631e6d665b82dcf7f813e28ac4d2a21
+  data.tar.gz: 33f29be2d23840e56ba94f1eb14c693ec277c08a228195621af71ce68e7bb7f7ee4ee2d94d34191ec0ee16e675280cb43b8641cbeb653b884fc2f6425afb445c

data/README.md

@@ -61,6 +61,8 @@ class TestMe
   defmatch(:magic,Fixnum,Fixnum) {|a,b| "Found two numbers #{a}:#{b}" }
   # Run this function when there is a single argument that is equal to "banana" (not a great example as this could be done with a literal)
   defmatch(:magic,lambda {|arg| arg == "banana" }) {|arg| "I matched using a procedure that made sure \"banana\" == #{arg}" }
+  # Run this function with no arguments
+  defmatch(:magic) { "nifty" }
 end
 
 #Now you have an instance method called magic that dispatches what runs based on the patterns you defined and their associated block
@@ -70,6 +72,8 @@ x.magic([1,2,3]) # -> Matches the second
 x.magic(:literally) # -> You get the idea
 x.magic(2,3)
 x.magic("banana")
+x.magic()
+x.magic("I","never","defined","this","to","match") # -> ArgumentError: No function clause matching arguments
 ```
 
 This can come in very handy, but remember that the order in which you define things matters. Lets say I define my magic function like this:
@@ -83,7 +87,26 @@ This can come in very handy, but remember that the order in which you define thi
 
 Even if I run ```x.magic(1)``` I will get ```2``` as the result. The second defmatch will never be matched because there is a more general match case above it. Order matters. Define your most specific matches first.
 
+If you want to create class methods (yes there are no true class methods in ruby, but it's a convient definition) you can use the ```defclassmatch``` method. It works just like ```defmatch``` but makes a class method instead.
+
+## A note about inheritance
+If you've defined a class you intend to inherit from and it uses Defmatch then be warned. Presently Defmatch defines an ```inherited``` method for your class when you extend it. So if you
+use this method yourself then you'll be overwriting Defmatch's and you'll get odd errors when trying to use the defmatch/defclassmatch defined methods in your subclass. The work around for this is to reference the Defmatch version of the inherited function in your own inherited function.
+
+```ruby
+class MySuperClass
+
+  def self.inherited(subklass)
+    Defmatch.inherited(self,subklass)
+  end
+
+end
+```
+
+It's not a great solution, but it will work until I come up with a better one.
+
 ## Roadmap
 
 * Add parameter deconstruction
+* Cleaner way to handle inheritance
 * Add it to the Kernel so it's available without having to include things. This will require ruby 2.0 and I'm not prepared to kill backwards compatability yet.

data/lib/defmatch/version.rb

@@ -1,3 +1,3 @@
 module Defmatch
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/defmatch.rb

@@ -26,6 +26,19 @@ module Defmatch
     end
   end
 
+  def self.dispatch_clone(dispatch)
+    dispatch.keys.inject({}) {|nd,key| nd[key] = dispatch[key].clone; nd } if dispatch
+  end
+
+  def self.inherited(klass,subklass)
+    subklass.instance_variable_set(:@defmatch_dispatch_info,Defmatch.dispatch_clone(klass.instance_variable_get(:@defmatch_dispatch_info)))
+    subklass.instance_variable_set(:@defclassmatch_dispatch_info,Defmatch.dispatch_clone(klass.instance_variable_get(:@defclassmatch_dispatch_info)))
+  end
+
+  def inherited(subklass)
+    Defmatch.inherited(self,subklass)
+  end
+
   def defmatch(method,*args,&block)
     @defmatch_dispatch_info ||= {} # setup the methods in an instance variable
     @defmatch_dispatch_info[method] ||= [] # setup the ordered array for the method the first time

data/spec/defmatch_spec.rb

@@ -18,6 +18,38 @@ describe Defmatch do
     defclassmatch(:cscope) { self }
   end
 
+  class ATester < Tester
+    defmatch(:times,:not_in_super) { "not in super" }
+  end
+
+  class InheritedTesterBroken
+    extend(Defmatch)
+
+    defmatch(:times,Fixnum) {|num| num * 2 }
+
+    def inherited(subclass)
+      :do_nothing
+    end
+
+  end
+
+  class InheritedTesterWorkaround
+    extend(Defmatch)
+
+    defclassmatch(:times,Fixnum) {|num| num * 2 }
+
+    def inherited(subclass)
+      Defmatch.inherited(self,subclass)
+    end
+
+  end
+
+  class InheritedTesterBrokenA < InheritedTesterBroken
+  end
+
+  class InheritedTesterWorkaroundA < InheritedTesterWorkaround
+  end
+
   it 'should create methods' do
     expect(Tester).to respond_to(:defmatch)
     expect(Tester).to respond_to(:defclassmatch)
@@ -39,6 +71,20 @@ describe Defmatch do
     expect(Tester.cscope).to equal(Tester)
   end
 
+  it 'should allow for inheritance' do
+    expect(ATester.cscope).to equal(ATester)
+    x = Tester.new
+    y = ATester.new
+    expect(y.scope).to equal(y)
+    expect(y.times(:not_in_super)).to eq("not in super")
+    expect { x.times(:not_in_super) }.to raise_error(ArgumentError)
+  end
+
+  it 'should allow for inherited workaround' do
+    expect(InheritedTesterWorkaroundA.times(2)).to eq(4)
+    expect { InheritedTesterBrokenA.times(2) }.to raise_error(NoMethodError)
+  end
+
   instance = Tester.new
 
   describe instance do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: defmatch
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Max Warnock
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-08-15 00:00:00.000000000 Z
+date: 2014-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler