ducktape 0.2.0 → 0.2.1

data/README.md

@@ -188,7 +188,7 @@ class X
   bindable :name, validate: [String, Symbol]
 
   def initialize(name)
-	self.name = name
+    self.name = name
   end
 end
 ```
@@ -202,11 +202,35 @@ class X
   bindable :name, validate: ->(value){ !value.nil? }
 
   def initialize(name)
-	self.name = name
+    self.name = name
   end
 end
 ```
 
+Additionally, it has built-in support for regular expressions:
+
+```ruby
+class X
+  include Ducktape::Bindable
+
+  bindable :name, validate: /ruby/
+
+  def initialize(name)
+    self.name = name
+  end
+end
+
+#passes
+X.new('rubygems')
+
+#fails
+begin
+  X.new('diamonds')
+rescue => e
+  puts e.message
+end
+```
+
 Validation also works with any kind of objects. For example, to make an enumerable:
 
 ```ruby
@@ -266,12 +290,12 @@ class X
   bindable :points, validate: Integer
 
   def initialize(name, age, points)
-	self.name = name
-	self.age = age
-	self.points = points
+    self.name = name
+    self.age = age
+    self.points = points
 
-	# You can hook for any method available
-	%w'name age points'.each { |k, v| on_changed k, &method(:attribute_changed) }
+    # You can hook for any method available
+    %w'name age points'.each { |k, v| on_changed k, &method(:attribute_changed) }
   end
 end
 
@@ -315,16 +339,18 @@ class X
   def_hook :on_loaded #define one or more hooks
 
   def load
-	call_hooks(:on_loaded)
+    # do other stuff here
+
+    call_hooks(:on_loaded)
   end
 end
 
 x = X.new
 
-x.on_loaded &method(:called_load)
+x.on_loaded method(:called_load)
 
 #if we didn't create a hook with def_hook we could still use:
-#x.add_hook :on_loaded, &method(:called_load)
+#x.add_hook :on_loaded, method(:called_load)
 
 x.load
 ```
@@ -334,9 +360,62 @@ The output should be something like:
 => "X<14e35b4> called \"on_loaded\""
 ```
 
+### Named hooks
+
+It is possible to define a hook by providing a method name. This makes it possible to separate logic from definition.
+Note that the method must exist for the instance that calls the hooks (through `call_hooks` or `call_handlers`).
+
+```ruby
+#class logic file
+
+class Y
+  def called_load(event, owner)
+    puts "loaded #{self}" #self == owner
+  end
+
+  def load
+    #do some stuff here
+
+    call_hooks(:on_loaded)
+  end
+end
+```
+
+```ruby
+#instance definition file
+
+x = Y.tap do |y|
+  y.on_loaded :called_load
+end
+
+x.load
+```
+
+The output should be something like:
+```ruby
+=> "loaded Y<3539af>"
+```
+
+This also allows to dynamically bind the hook by overriding the method.
+
+```ruby
+#taking the same instance from before
+
+x.define_singleton_method(:called_load) { puts "singleton #{self} has loaded" }
+```
+
+The output should now be:
+```ruby
+=> "singleton Y<3539af> has loaded"
+```
+
 ### Removing hooks
 
-To remove all hooks from an object call the `#clear_hooks` method. To select a single hook, pass the name of the hook as a parameter. The next section has an example of this.
+To remove all hooks from an object call the `#clear_hooks` method. To remove all hooks from a single event, pass the name of the event as a parameter. The next section has an example of this.
+
+To remove a single hook from an event, call the `#remove_hook` with the name of the event, and the hook name or hook proc corresponding with how the hook was added.
+
+### Handlers
 
 ### Hookable arrays and hashes
 
@@ -396,6 +475,6 @@ The output will only be for the `on_changed` hook, which wasn't removed:
 
 Future work
 ===========
-* Pass a hook by method name. This will provide a more dynamic binding if the method is overriden.
 * Multi-sourced BA's.
-* More complex binding source paths instead of just the member name (e.g.: ruby like 'a.b.c' or xml like 'a/b/c').
+* More complex binding source paths instead of just the member name (e.g.: ruby like 'a.b.c' or xml like 'a/b/c').
+* Add built-in support for hookable arrays and hashes in bindable attributes.

data/lib/ducktape/bindable.rb

@@ -51,9 +51,9 @@ module Ducktape
       nil
     end
 
-    def on_changed(attr_name, &block)
-      return nil unless block
-      get_bindable_attr(attr_name.to_s).on_changed(&block)
+    def on_changed(attr_name, hook = nil, &block)
+      return nil unless block || hook
+      get_bindable_attr(attr_name.to_s).on_changed(hook, &block)
       block
     end
 

data/lib/ducktape/bindable_attribute.rb

@@ -4,7 +4,7 @@ module Ducktape
 
   class InvalidAttributeValueError < StandardError
     def initialize(name, value)
-      super("value #{value.inspect} is invalid for attribute '#{name}'")
+      super("value #{value.inspect} is invalid for attribute #{name.to_s.inspect}")
     end
   end
 

data/lib/ducktape/bindable_attribute_metadata.rb

@@ -7,7 +7,8 @@ module Ducktape
 
     def initialize(name, options = {})
 
-      options.each_key { |k| puts "WARNING: invalid option #{k.inspect} for #{name.inspect} attribute. Will be ignored." unless VALID_OPTIONS.member?(k) }
+      options.keys.reject { |k| VALID_OPTIONS.member?(k) }.
+        each { |k| puts "WARNING: invalid option #{k.inspect} for #{name.inspect} attribute. Will be ignored." }
 
       if name.is_a? BindableAttributeMetadata
         @name = name.name
@@ -39,10 +40,11 @@ module Ducktape
 
     def validate(value)
       return true unless @validation
-      @validation.each do |validation|
-        return true if (validation.is_a?(Class) and value.is_a?(validation)) or
-                 (validation.is_a?(Proc) and validation.call(value)) or
-                value == validation
+      @validation.each do |v|
+        return true if ( v.is_a?(Class)  && value.is_a?(v) ) ||
+                       ( v.is_a?(Proc)   && v.(value)      ) ||
+                       ( v.is_a?(Regexp) && value =~ v     ) ||
+                         value == v
       end
       false
     end

data/lib/ducktape/hookable.rb

@@ -3,7 +3,7 @@ module Ducktape
 
     module ClassMethods
       def def_hook(*events)
-        events.each { |e| define_method e, ->(&block){ add_hook(e, &block) } }
+        events.each { |e| define_method e, ->(method_name = nil, &block){ add_hook(e, method_name, &block) } }
       end
     end
 
@@ -15,23 +15,25 @@ module Ducktape
       raise 'Cannot extend, only include.'
     end
 
-    def add_hook(event, &block)
-      return unless block
-      self.hooks[event.to_s].unshift block
-      nil
+    def add_hook(event, hook = nil, &block)
+      hook = block if block #block has precedence
+      return unless hook
+      hook = hook.to_s unless hook.is_a?(Proc)
+      self.hooks[event.to_s].unshift(hook)
+      hook
     end
 
-    def remove_hook(event, block)
-      self.hooks[event.to_s].delete(block)
+    def remove_hook(event, hook)
+      hook = hook.to_s unless hook.is_a?(Proc)
+      self.hooks[event.to_s].delete(hook)
     end
 
     def clear_hooks(event = nil)
       if event
         self.hooks.delete(event.to_s)
       else
-        self.hooks.clear
+        self.hooks.clear.dup
       end
-      nil
     end
 
     protected
@@ -41,14 +43,19 @@ module Ducktape
 
     def call_hooks(event, caller, *args)
       return unless self.hooks.has_key? event.to_s
-      self.hooks[event.to_s].each { |hook| hook.call(event, caller, *args) }
+      self.hooks[event.to_s].each do |hook|
+        hook = caller.method(hook) unless hook.is_a?(Proc)
+        hook.(event, caller, *args)
+      end
       nil
     end
 
+    # Similar to `call_hooks`, but stops calling other hooks when a hook returns a value other than nil or false.
     def call_handlers(event, caller, *args)
       return unless self.hooks.has_key? event.to_s
       self.hooks[event.to_s].each do |hook|
-        handled = hook.call(event, caller, *args)
+        hook = caller.method(hook) unless hook.is_a?(Proc)
+        handled = hook.(event, caller, *args)
         return handled if handled
       end
       nil

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Ducktape
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ducktape
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
   prerelease: 
 platform: ruby
 authors: