ducktape 0.2.1 → 0.3.0

data/README.md

@@ -1,7 +1,6 @@
-Ducktape
-========
+# ducktape
 
-A [truly outrageous](http://youtu.be/dSPb56-_I98) gem for bindable attributes.
+A [truly outrageous](http://youtu.be/dSPb56-_I98) gem for bindable attributes and event notification.
 
 To install:
 
@@ -9,472 +8,6 @@ To install:
 gem install ducktape
 ```
 
-Bindable attributes
--------------------
+Additional documentation can be found in the [Wiki](https://github.com/SilverPhoenix99/ducktape/wiki).
 
-Bindable attributes (BA) work just like normal attributes. To assign a BA to a class you just need to declare it like an attr_accessor:
-
-```ruby
-require 'ducktape'
-
-class X
-  include Ducktape::Bindable
-
-  bindable :name
-
-  def initialize(name)
-    self.name = name
-  end
-end
-```
-
-### Binding
-
-BA's, like the name hints, can be bound to other BA's:
-
-```ruby
-class X
-  include Ducktape::Bindable
-
-  bindable :name
-end
-
-class Y
-  include Ducktape::Bindable
-
-  bindable :other_name
-end
-
-x = X.new
-
-y = Y.new
-y.other_name = Ducktape::BindingSource.new(x, :name)
-
-x.name = 'Richard'
-
-puts y.other_name
-```
-
-Output:
-```ruby
-=> "Richard"
-```
-
-There are three types of direction for `BindingSource`:
-* `:both` - (default) Changes apply in both directions.
-* `:forward` - Changes only apply from the binding source BA to the destination BA.
-* `:reverse` - Changes only apply from the destination BA to the binding source BA.
-
-Here's an example of `:reverse` binding (very similar to the previous):
-
-```ruby
-class X
-  include Ducktape::Bindable
-
-  bindable :name
-end
-
-class Y
-  include Ducktape::Bindable
-
-  bindable :other_name
-end
-
-x = X.new
-
-y = Y.new
-y.other_name = Ducktape::BindingSource.new(x, :name, :reverse)
-
-y.other_name = 'Mary'
-
-puts x.name
-puts y.other_name
-```
-
-Output:
-```ruby
-=> "Mary"
-=> "Mary"
-```
-
-But if you then do:
-
-```ruby
-x.name = 'John'
-
-puts x.name
-puts y.other_name
-```
-
-the output will be:
-```ruby
-=> "John"
-=> "Mary"
-```
-
-### Removing bindings
-
-To remove a previously defined binding call the `#unbind_source(attr_name)` method. To remove all bindings for a given object, call the `#clear_bindings` method.
-
-### Read only / Write only
-
-BA's can be read-only and write-only. Read-only BA's are useful for reverse only bindings or when the object itself changes the value through the protected method `#set_value`. On the other hand, write-only BA's are best used as sources, though the owner object can call the `#get_value` to get the value of the BA.
-
-To define a BA as read-only or write-only, use the `:access` modifier.
-
-Here's an example of read-only and write-only BA's:
-
-```ruby
-class X
-  include Ducktape::Bindable
-
-  bindable :name, access: :readonly
-
-  #no need for this now
-  #
-  #def initialize(name = 'John')
-  #  self.name = name
-  #end
-end
-
-class Y
-  include Ducktape::Bindable
-
-  bindable :other_name, access: :writeonly
-end
-
-x = X.new
-y = Y.new
-
-y.other_name = Ducktape::BindingSource.new(x, :name, :reverse)
-y.other_name = 'Alex'
-
-puts x.name
-```
-
-Output:
-```ruby
-=> "Alex"
-```
-
-### Default values
-
-You can set default values for your BA:
-
-```ruby
-class X
-  include Ducktape::Bindable
-
-  bindable :name, default: 'John'
-
-  #we don't need to do this now:
-  #
-  #def initialize(name = 'John')
-  #  self.name = name
-  #end
-end
-```
-
-### Validation
-
-You can do validation on a BA.
-
-Following the last example we could validate `:name` as a String or a Symbol:
-
-```ruby
-class X
-  include Ducktape::Bindable
-
-  bindable :name, validate: [String, Symbol]
-
-  def initialize(name)
-    self.name = name
-  end
-end
-```
-
-Validation works with procs as well. In this case, a proc must have a single parameter which is the new value.
-
-```ruby
-class X
-  include Ducktape::Bindable
-
-  bindable :name, validate: ->(value){ !value.nil? }
-
-  def initialize(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
-class X
-  include Ducktape::Bindable
-
-  # place attribute will only accept assignment to these three symbols:
-  bindable :place, default: :first, validate: [:first, :middle, :last]
-end
-```
-
-In short, you can have a single object or a proc, or an array of objects/procs to validate. If any of them returns "true" (i.e., not `nil` and not `false`), then the new value is accepted. Otherwise it will throw an `InvalidAttributeValueError`.
-
-### Coercion
-
-While validation can help knowing when things aren't what we expect, sometimes what we really want is to force a value to remain in a domain. This is where coercion comes in.
-
-For example, we would like for a float value to remain between 0 and 1, inclusively. If the value goes out of scope, then we want to clamp it to remain between 0 and 1. Additionally, we want other numerical types to be valid, and converted to floats.
-
-```ruby
-class X
-  include Ducktape::Bindable
-
-  bindable :my_float,
-    validate: Numeric,
-    default: 0.0,
-    coerce: ->(owner, value) { value = value.to_f; value < 0.0 ? 0.0 : (value > 1.0 ? 1.0 : value) }
-end
-
-x = X.new
-x.my_float = 2.0
-
-puts x.my_float
-```
-
-The output would be:
-```ruby
-=> 1.0
-```
-
-Note that if validation is defined, then it will only happen after coercion is applied.
-
-### Hookable change notifications
-
-You can watch for changes in a BA by using the public instance method `#on_changed(attr_name, &block)`. Here's an example:
-
-```ruby
-def attribute_changed(event, owner, attr_name, new_value, old_value)
-  puts "#{owner.class}<#{owner.object_id.to_s(16)}> called the event #{event.inspect} and changed the attribute #{attr_name.inspect} from #{old_value.inspect} to #{new_value.inspect}"
-end
-
-class X
-  include Ducktape::Bindable
-
-  bindable :name, validate: [String, Symbol]
-  bindable :age, validate: Integer
-  bindable :points, validate: Integer
-
-  def initialize(name, age, 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) }
-  end
-end
-
-# oops, a misspelling...
-x = X.new('Richad', 23, 150)
-
-# It's also useful to see changes outside of the class:
-x.on_changed 'name', &->(_, _, _, _, new_value) { puts "Hello #{new_value}!" }
-
-x.name = 'Richard'
-```
-
-After calling `#name=`, the output should be something like:
-
-```ruby
-=> "Hello Richard!"
-=> "X<14e35b4> called the event \"on_changed\" and changed the attribute \"name\" from \"Richad\" to \"Richard\""
-```
-
-The `on_changed` hook has the following arguments:
-* the name of the event (in this case, `'on_changed'`)
-* the caller/owner of the BA (the instance that sent the message),
-* the name of the BA (`name`, `age`, `points`, etc...),
-* the new value,
-* the old value
-
-Hooks
------
-
-Has you might have seen, Ducktape comes with hooks, which is what powers the `on_changed` for bindable attributes.
-You can easily define a hook by using `def_hook`:
-
-```ruby
-def called_load(event, owner)
-  puts "#{owner.class}<#{owner.object_id.to_s(16)}> called #{event.inspect}"
-end
-
-class X
-  include Ducktape::Hookable
-
-  def_hook :on_loaded #define one or more hooks
-
-  def load
-    # do other stuff here
-
-    call_hooks(:on_loaded)
-  end
-end
-
-x = X.new
-
-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.load
-```
-
-The output should be something like:
-```ruby
-=> "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 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
-
-A `Ducktape::HookableArray` is a wrapper for arrays that allows you to add hooks to modifiers of the array. The same concept applies to `Ducktape::HookableHash` in relation to hashes.
-To add a hook to a specific modifier you just have to pass a block to a method that has the same name as the modifier, prefixed with `on_`.
-
-There are three exceptions to the naming convention:
-* `HookableArray#<<`: pass the hook through the `on_append` method.
-* `HookableArray#[]=`: pass the hook through the `on_store` method.
-* `HookableHash#[]=`: pass the hook through the `on_store` method.
-
-The parameters for all the hooks are very similar to the ones used for bindables:
-* the name of the event (for example, `'on_store'`)
-* the instance of `HookableArray` or `HookableHash` that triggered the hook
-* an array of the arguments that were passed to the method that triggered the hook (for example, the index and value of the `[]=` method)
-* and the result of the call to the method
-
-Additionally, there is a generic `on_changed` hook, that is called for every modifier. In this case, the parametes are:
-* the name of the event (for example, `'on_store'`)
-* the instance of `HookableArray` or `HookableHash` that triggered the hook
-* the name of the method (`"[]="`, `"<<"`, "sort!", etc...) that triggered the hook
-* an array of the arguments that were passed to the method that triggered the hook (for example, the index and value of the `[]=` method)
-* and the result of the call to the method
-
-Here is an example that shows how to use the hooks on a `HookableArray`:
-
-```ruby
-a = Ducktape::HookableArray[1, :x] #same as new()
-a.on_append do |event, owner, args, result|
-  puts "#{event.inspect}, #{owner.class}<#{owner.object_id.to_s(16)}>, #{args.inspect}, #{result.inspect}"
-end
-
-a.on_changed do |event, owner, name, args, result|
-  puts "#{event.inspect}, #{owner.class}<#{owner.object_id.to_s(16)}>, #{name.inspect}, #{args.inspect}, #{result.inspect}"
-end
-
-a << 'hi'
-```
-
-The output would be something like:
-```ruby
-=> "\"on_append\", Ducktape::HookableArray<37347c>, [\"hi\"], [1, :x, \"hi\"]"
-=> "\"on_changed\", Ducktape::HookableArray<37347c>, \"<<\", [\"hi\"], [1, :x, \"hi\"]"
-```
-
-If you then do:
-```ruby
-a.clear_hooks('on_append')
-
-a << 'bye'
-```
-
-The output will only be for the `on_changed` hook, which wasn't removed:
-```ruby
-=> "\"on_changed\", Ducktape::HookableArray<37347c>, \"<<\", [\"bye\"], [1, :x, \"hi\", \"bye\"]"
-```
-
-Future work
-===========
-* 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').
-* Add built-in support for hookable arrays and hashes in bindable attributes.
+<font color=red>**WARNING**: Version 0.3.0 is incompatible with version 0.2.1 and below.</font>

data/lib/ducktape/bindable.rb

@@ -41,38 +41,40 @@ module Ducktape
       raise 'Cannot extend, only include.'
     end
 
-    def unbind_source(name)
-      get_bindable_attr(name.to_s).remove_source(true)
+    def unbind_source(attr_name)
+      get_bindable_attr(attr_name).remove_source
       nil
     end
 
     def clear_bindings()
-      bindable_attrs.each { |_,attr| attr.remove_source() }
+      bindable_attrs.each { |_,attr| attr.remove_source }
       nil
     end
 
     def on_changed(attr_name, hook = nil, &block)
       return nil unless block || hook
-      get_bindable_attr(attr_name.to_s).on_changed(hook, &block)
+      get_bindable_attr(attr_name).on_changed(hook, &block)
       block
     end
 
     def unhook_on_changed(attr_name, block)
       return nil unless block
-      get_bindable_attr(attr_name.to_s).send(:remove_hook, :on_changed, block)
+      get_bindable_attr(attr_name).remove_hook(:on_changed, block)
       block
     end
 
-    protected
+    protected #--------------------------------------------------------------
+
     def get_value(attr_name)
-      get_bindable_attr(attr_name.to_s).value
+      get_bindable_attr(attr_name).value
     end
 
     def set_value(attr_name, value)
-      get_bindable_attr(attr_name.to_s).value = value
+      get_bindable_attr(attr_name).value = value
     end
 
-    private
+    private #----------------------------------------------------------------
+
     def bindable_attrs
       @bindable_attrs ||= {}
     end

data/lib/ducktape/bindable_attribute.rb

@@ -12,58 +12,63 @@ module Ducktape
 
     include Hookable
 
-    attr_reader :owner,    # Bindable
-                :name,     # String
-                :source,   # BindingSource
-                #:targets, # { BindableAttribute => BindingSource }
-                :value     # Object
+    attr_reader :owner    # Bindable
+    attr_reader :name     # String
+    attr_reader :source   # BindingSource
+    attr_reader :value    # Object
 
-    def_hook :on_changed
+    #attr_reader :targets # Hash{ BindableAttribute => BindingSource }
+
+    #def_hook :on_changed
 
     def initialize(owner, name)
-      @owner, @name, @targets, @source = owner, name.to_s, {}, nil
-      reset_value(false)
+      @owner, @name, @source, @targets = owner, name.to_s, nil, {}
+      reset_value
     end
 
     def metadata
       @owner.class.metadata(@name)
     end
 
+    def has_source?
+      !@source.nil?
+    end
+
     def value=(value)
       set_value(value)
     end
 
-    def remove_source(propagate = true)
-      detach(@source, self, propagate)
+    #If values are equal, it means that both attributes share the same value,
+    #if they are different, the values are independent.
+    #As such, self's value is reset if mode is both, or if mode is forward and values are equal;
+    #the source's value is reset of mode is reverse and values are equal.
+    def remove_source
+      return unless has_source?
+      bs, v = detach_source
+      reset_value if bs.mode == :both || (bs.mode == :forward && v == @value)
+      bs
     end
 
-    def reset_value(propagate = true)
-      meta = metadata
-      value = @source ? @source.source.value : meta.default
-
-      if propagate
-        self.value = value
-      else
-        @value = value
-      end
+    def reset_value
+      set_value(metadata.default)
+    end
 
-      nil
+    def to_s
+      "#<#{self.class}:0x#{object_id.to_s(16)} @name=#{name}>"
     end
 
-    protected #--------------------------------------------------------------
+    private #----------------------------------------------------------------
+
+    attr_reader :targets
 
     def set_value(value, exclusions = Set.new)
-      return if exclusions.member? self
+      return if exclusions.include? self
       exclusions << self
 
       if value.is_a? BindingSource
-        BindableAttribute.attach(value, self, false)
-
-        #update value
-        exclusions << @source.source
-
-        #new value is the new source value
-        value = @source.source.value
+        attach_source(value) #attach new binding source
+        exclusions << @source.source #update value
+        value = @source.source.value #new value is the new source value
       end
 
       #set effective value
@@ -73,43 +78,48 @@ module Ducktape
         raise InvalidAttributeValueError.new(@name, value) unless m.validate(value)
         old_value = @value
         @value = value
-        call_hooks('on_changed', owner, name, @value, old_value)
-      end
 
-      #propagate value
-      @source.source.set_value(value, exclusions) if propagate_to_source
-      targets_to_propagate.each { |target, _| target.set_value(value, exclusions) }
-    end
+        old_value.remove_hook('on_changed', method('hookable_value_changed')) if old_value.respond_to?('on_changed')
+        @value.on_changed(method('hookable_value_changed')) if @value.respond_to?('on_changed')
 
-    private #----------------------------------------------------------------
+        call_hooks('on_changed', owner, attribute: name.dup, value: @value, old_value: old_value)
+      end
 
-    def propagate_to_source
-      return false unless @source
-      BindingSource::PROPAGATE_TO_SOURCE.member? @source.mode
+      propagate_value(exclusions)
+      @value
     end
 
-    def targets_to_propagate
-      @targets.select { |_, b| BindingSource::PROPAGATE_TO_TARGETS.member? b.mode }
+    def detach_source
+      return unless @source
+      bs = @source
+      v = bs.source.value
+      @source = nil
+      bs.source.send(:targets).delete(self)
+      bs.source.reset_value if bs.mode == :reverse && v == @value
+      [bs, v]
     end
 
     # source: BindingSource
-    def self.attach(source, target, propagate)
-      target.instance_eval do
-        detach(@source.source, self, false) if @source
-        @source = source
-        reset_value(propagate)
-      end
-
-      source.source.instance_eval { @targets[target] = source }
+    def attach_source(source)
+      detach_source
+      @source = source
+      source.source.send(:targets)[self] = source
+      nil
     end
 
-    # source: BindableAttribute
-    def self.detach(source, target, propagate)
-      return unless target.source and target.source.source == source
+    def targets_to_propagate
+      targets = []
+      targets << @source.source if @source && BindingSource::PROPAGATE_TO_SOURCE.member?(@source.mode)
+      targets.concat(@targets.values.select { |b| BindingSource::PROPAGATE_TO_TARGETS.member?(b.mode) })
+    end
 
-      source.instance_eval { @targets.delete(target) }
-      target.instance_eval { @source = nil; reset_value(propagate) }
+    def propagate_value(exclusions)
+      targets_to_propagate.each { |target| target.send(:set_value, value, exclusions) }
+      nil
+    end
 
+    def hookable_value_changed(*_)
+      call_hooks('on_changed', owner, attribute: name, value: @value)
       nil
     end
   end

data/lib/ducktape/bindable_attribute_metadata.rb

@@ -30,7 +30,7 @@ module Ducktape
     end
 
     def default
-      @default.is_a?(Proc) ? @default.call : @default
+      @default.respond_to?('call') ? @default.call : @default
     end
 
     def validation(*options, &block)
@@ -41,9 +41,9 @@ module Ducktape
     def validate(value)
       return true unless @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     ) ||
+        return true if ( v.is_a?(Class)        && value.is_a?(v) ) ||
+                       ( v.respond_to?('call') && v.(value)      ) ||
+                       ( v.is_a?(Regexp)       && value =~ v     ) ||
                          value == v
       end
       false

data/lib/ducktape/ext/array.rb

@@ -0,0 +1,32 @@
+class Array
+  include Ducktape::Hookable
+
+  make_hooks %w'clear
+    compact!
+    concat
+    delete
+    delete_at
+    delete_if
+    fill
+    flatten!
+    insert
+    keep_if
+    map!
+    pop
+    push
+    reject!
+    replace
+    reverse!
+    rotate!
+    select!
+    shift
+    shuffle!
+    slice!
+    sort!
+    sort_by!
+    uniq!
+    unshift',
+    '<<'       => 'append',
+    '[]='      => 'store',
+    'collect!' => 'map!'
+end

data/lib/ducktape/ext/hash.rb

@@ -0,0 +1,19 @@
+class Hash
+  include Ducktape::Hookable
+
+  make_hooks %w'clear
+    default=
+    default_proc=
+    delete
+    delete_if
+    keep_if
+    merge!
+    rehash
+    reject!
+    replace
+    select!
+    shift
+    store',
+    '[]='    => 'store',
+    'update' => 'merge!'
+end

data/lib/ducktape/ext/string.rb

@@ -0,0 +1,33 @@
+class String
+  include Ducktape::Hookable
+
+  make_hooks %w'concat
+    capitalize!
+    chomp!
+    chop!
+    clear
+    delete!
+    downcase!
+    encode!
+    force_encoding
+    gsub!
+    insert
+    lstrip!
+    next!
+    prepend
+    replace
+    reverse!
+    rstrip!
+    setbyte
+    slice!
+    squeeze!
+    strip!
+    sub!
+    swapcase!
+    tr!
+    tr_s!
+    upcase!',
+    '<<'    => 'concat',
+    '[]='   => 'store',
+    'succ!' => 'next!'
+end

data/lib/ducktape/hookable.rb

@@ -5,10 +5,41 @@ module Ducktape
       def def_hook(*events)
         events.each { |e| define_method e, ->(method_name = nil, &block){ add_hook(e, method_name, &block) } }
       end
+
+      %w'hook handler'.each do |type|
+        define_method "make_#{type}s" do |*args|
+          return if args.length == 0
+
+          #def_hook 'on_changed' unless method_defined?('on_changed')
+
+          names_hash = args.pop if args.last.is_a?(Hash)
+          names_hash ||= {}
+
+          #Reversed merge because names_hash has priority.
+          names_hash = Hash[args.flatten.map { |v| [v, v] }].merge!(names_hash)
+
+          names_hash.each do |name, aka|
+            aka = "on_#{aka}"
+            def_hook(aka) unless method_defined?(aka)
+
+            um = public_instance_method(name)
+            cm = "call_#{type}s"
+            define_method(name) do |*a, &block|
+              bm = um.bind(self)
+              r = bm.(*a, &block)
+              if !send(cm,          aka, self, event: name, args: a, result: r) || type != 'handler'
+                send(  cm, 'on_changed', self, event: name, args: a, result: r)
+              end
+              r
+            end
+          end
+        end
+      end
     end
 
     def self.included(base)
       base.extend(ClassMethods)
+      base.def_hook :on_changed unless base.method_defined? :on_changed
     end
 
     def self.extended(_)
@@ -18,13 +49,13 @@ module Ducktape
     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)
+      hook = hook.to_s unless hook.respond_to?('call')
       self.hooks[event.to_s].unshift(hook)
       hook
     end
 
     def remove_hook(event, hook)
-      hook = hook.to_s unless hook.is_a?(Proc)
+      hook = hook.to_s unless hook.respond_to?('call')
       self.hooks[event.to_s].delete(hook)
     end
 
@@ -36,29 +67,23 @@ module Ducktape
       end
     end
 
-    protected
+    protected #--------------------------------------------------------------
+
     def hooks
       @hooks ||= Hash.new { |h,k| h[k.to_s] = [] }
     end
 
-    def call_hooks(event, caller, *args)
-      return unless self.hooks.has_key? event.to_s
-      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|
-        hook = caller.method(hook) unless hook.is_a?(Proc)
-        handled = hook.(event, caller, *args)
-        return handled if handled
-      end
-      nil
+    # `#call_handlers` is similar to `#call_hooks`,
+    # but stops calling other hooks when a hook returns a value other than nil or false.
+    %w'hook handler'.each do |type|
+      define_method("call_#{type}s", ->(event, caller = self, parms = {}) do
+        return unless self.hooks.has_key? event.to_s
+        self.hooks[event.to_s].each do |hook|
+          hook = caller.method(hook) unless hook.respond_to?('call')
+          handled = hook.(event, caller, parms)
+          break handled if type == 'handler' && handled
+        end
+      end)
     end
   end
 end

data/lib/ducktape.rb

@@ -3,16 +3,12 @@ require 'version'
 module Ducktape
   camelize = ->(f){ f.gsub(/(^|_)([^_]+)/) { |_| $2.capitalize } }
 
-  Dir["#{File.expand_path('../ducktape', __FILE__)}/*.rb"].
-    map  { |f| File.basename(f, File.extname(f)) }.
-    each { |f| autoload camelize.(f), "ducktape/#{f}" }
+  %w'ducktape'.each do |dir|
+    Dir["#{File.expand_path("../#{dir}", __FILE__)}/*.rb"].
+      map  { |f| File.basename(f, File.extname(f)) }.
+      each { |f| autoload camelize.(f), "#{dir}/#{f}" }
+  end
+
+  %w'def_hookable'.each { |f| require "ext/#{f}" }
 
-  #%w'bindable
-  #   bindable_attribute
-  #   bindable_attribute_metadata
-  #   binding_source
-  #   hookable
-  #   hookable_array
-  #   hookable_collection
-  #   hookable_hash'.each { |f| autoload camelize.(f), "ducktape/#{f}" }
 end

data/lib/ext/def_hookable.rb

@@ -0,0 +1,113 @@
+module Ducktape
+
+  @hookable_types = {}
+
+  def self.def_hookable(klass, *args)
+    return if args.length == 0
+
+    names_hash = args.pop if args.last.is_a?(Hash)
+    names_hash ||= {}
+
+    #Reversed merge because names_hash has priority.
+    @hookable_types[klass] = Hash[args.flatten.map { |v| [v, v] }].merge!(names_hash)
+
+    nil
+  end
+
+  def self.hookable(obj)
+    unless obj.is_a? Hookable
+      m = obj.class.ancestors.each do |c|
+        v = @hookable_types[c]
+        break v if v
+      end
+
+      if m
+        (class << obj
+          include Hookable
+          self
+        end).make_hooks(m)
+      end
+    end
+
+    obj
+  end
+
+  def_hookable Array,
+    %w'clear
+    compact!
+    concat
+    delete
+    delete_at
+    delete_if
+    fill
+    flatten!
+    insert
+    keep_if
+    map!
+    pop
+    push
+    reject!
+    replace
+    reverse!
+    rotate!
+    select!
+    shift
+    shuffle!
+    slice!
+    sort!
+    sort_by!
+    uniq!
+    unshift',
+    '<<'       => 'append',
+    '[]='      => 'store',
+    'collect!' => 'map!'
+
+  def_hookable Hash,
+    %w'clear
+    default=
+    default_proc=
+    delete
+    delete_if
+    keep_if
+    merge!
+    rehash
+    reject!
+    replace
+    select!
+    shift
+    store',
+    '[]='    => 'store',
+    'update' => 'merge!'
+
+  def_hookable String,
+    %w'concat
+    capitalize!
+    chomp!
+    chop!
+    clear
+    delete!
+    downcase!
+    encode!
+    force_encoding
+    gsub!
+    insert
+    lstrip!
+    next!
+    prepend
+    replace
+    reverse!
+    rstrip!
+    setbyte
+    slice!
+    squeeze!
+    strip!
+    sub!
+    swapcase!
+    tr!
+    tr_s!
+    upcase!',
+    '<<'    => 'concat',
+    '[]='   => 'store',
+    'succ!' => 'next!'
+
+end

data/lib/version.rb

@@ -1,3 +1,7 @@
 module Ducktape
-  VERSION = '0.2.1'
+  # Although against rubygems recomendation, while version is < 1.0.0, an increase in the minor version number
+  # may represent an incompatible implementation with the previous minor version, which should have been
+  # represented by a major version number increase.
+
+  VERSION = '0.3.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ducktape
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-20 00:00:00.000000000 Z
+date: 2012-06-03 00:00:00.000000000 Z
 dependencies: []
 description: Truly outrageous bindable attributes
 email:
@@ -24,11 +24,12 @@ files:
 - lib/ducktape/bindable_attribute.rb
 - lib/ducktape/bindable_attribute_metadata.rb
 - lib/ducktape/binding_source.rb
+- lib/ducktape/ext/array.rb
+- lib/ducktape/ext/hash.rb
+- lib/ducktape/ext/string.rb
 - lib/ducktape/hookable.rb
-- lib/ducktape/hookable_array.rb
-- lib/ducktape/hookable_collection.rb
-- lib/ducktape/hookable_hash.rb
 - lib/ducktape.rb
+- lib/ext/def_hookable.rb
 - lib/version.rb
 - README.md
 homepage: https://github.com/SilverPhoenix99/ducktape

data/lib/ducktape/hookable_array.rb

@@ -1,69 +0,0 @@
-module Ducktape
-  class HookableArray
-    include HookableCollection
-
-    def self.[](*args)
-      new([*args])
-    end
-
-    def self.try_convert(obj)
-      return obj if obj.is_a? self
-      obj = Array.try_convert(obj)
-      obj ? new(obj) : nil
-    end
-
-    # Careful when duping arrays. Duping is shallow.
-    def initialize(*args, &block)
-      @content = if args.length == 1
-        arg = args[0]
-        case
-          when arg.is_a?(Array) then arg.dup
-          when arg.is_a?(HookableArray) then arg.instance_variable_get('@content').dup
-          when arg.is_a?(Enumerable) || arg.respond_to?(:to_a) then arg.to_a
-        end
-      end || Array.new(*args, &block)
-    end
-
-    def to_a() self end
-    def to_ary() self end
-
-    def ==(other)
-      other = Array.try_convert(other)
-      return false unless other || other.count != self.count
-      enum = other.each
-      each { |v1| return false unless v1 == enum.next }
-      true
-    end
-
-    compile_hooks(
-      %w'clear
-      collect!
-      compact!
-      concat
-      delete
-      delete_at
-      delete_if
-      fill
-      flatten!
-      insert
-      keep_if
-      map!
-      pop
-      push
-      reject!
-      replace
-      reverse!
-      rotate!
-      select!
-      shift
-      shuffle!
-      slice!
-      sort!
-      sort_by!
-      uniq!
-      unshift',
-      '<<'  => 'append',
-      '[]=' => 'store'
-    )
-  end
-end

data/lib/ducktape/hookable_collection.rb

@@ -1,58 +0,0 @@
-module Ducktape
-  module HookableCollection
-    extend Hookable::ClassMethods
-
-    module ClassMethods
-      def compile_hooks(names_ary, names_hash = {})
-        #Reversed merge because names_hash has priority.
-        names_hash = Hash[names_ary.map { |v| [v, v] }].merge!(names_hash)
-
-        names_hash.each do |name, aka|
-          aka = "on_#{aka}"
-          def_hook(aka) unless method_defined?(aka)
-          defined_hooks[name.to_s] = aka
-        end
-
-        nil
-      end
-
-      def defined_hooks
-        @defined_hooks ||= {}
-      end
-    end
-
-    def self.included(base)
-      base.send(:include, Hookable)
-      base.extend(ClassMethods)
-    end
-
-    def self.extended(_)
-      raise 'Cannot extend, only include.'
-    end
-
-    def_hook 'on_changed'
-
-    def content() @content.dup end
-    def to_s() "#{self.class}#{@content.to_s}" end
-    def inspect() "#{self.class}#{@content.inspect}" end
-    def hash() @content.hash end
-    def dup() self.class.new(@content) end
-
-    def eq?(other)
-      equal?(other) || self == other
-    end
-
-    def method_missing(name, *args, &block)
-      result = @content.public_send(name, *args, &block)
-      result = self if result.equal?(@content)
-
-      aka = self.class.defined_hooks[name.to_s]
-      if aka
-        call_hooks(aka, self, args, result)
-        call_hooks('on_changed', self, name, args, result)
-      end
-
-      result
-    end
-  end
-end

data/lib/ducktape/hookable_hash.rb

@@ -1,55 +0,0 @@
-module Ducktape
-  class HookableHash
-    include HookableCollection
-
-    def self.[](*args)
-      new(Hash[*args])
-    end
-
-    def self.try_convert(obj)
-      return obj if obj.is_a? self
-      obj = Hash.try_convert(obj)
-      obj ? new(obj) : nil
-    end
-
-    # Careful with duping hashes. Duping is shallow.
-    def initialize(*args, &block)
-      @content = if args.length == 1
-        arg = args[0]
-        case
-          when arg.is_a?(Hash) then arg.dup
-          when arg.is_a?(HookableHash) then arg.instance_variable_get('@hash').dup
-          when arg.respond_to?(:to_hash) then arg.to_hash
-        end
-      end || Hash.new(*args, &block)
-    end
-
-    def to_hash() self end
-
-    def ==(other)
-      other = Hash.try_convert(other)
-      return false unless other || other.count != self.count
-      enum = other.each
-      each { |v1| return false unless v1 == enum.next }
-      true
-    end
-
-    compile_hooks(
-      %w'clear
-      default=
-      default_proc=
-      delete
-      delete_if
-      keep_if
-      merge!
-      rehash
-      reject!
-      replace
-      select!
-      shift
-      store
-      update',
-      '[]=' => 'store'
-    )
-  end
-end