ducktape 0.1.0 → 0.2.0

data/README.md

@@ -338,29 +338,30 @@ The output should be something like:
 
 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.
 
-### Hookable arrays
+### Hookable arrays and hashes
 
-A Ducktape::HookableArray is a wrapper for arrays that allows you to add hooks to modifiers of the array.
+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 two exceptions to the naming convention:
-* `HookableArray#[]=`: pass the hook through the `on_assign` method.
+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 these hooks are very similar to the ones used for bindables:
-* the name of the event (for example, `'on_assign'`)
-* the instance of `HookableArray` that triggered the hook
+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_assign'`)
-* the instance of `HookableArray` that triggered the hook
+* 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:
+Here is an example that shows how to use the hooks on a `HookableArray`:
 
 ```ruby
 a = Ducktape::HookableArray[1, :x] #same as new()
@@ -388,13 +389,13 @@ a.clear_hooks('on_append')
 a << 'bye'
 ```
 
-The output will only be for the `on_changed` hook, that wasn't removed:
+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
 ===========
-* Hashes passed to BA's should check for element changes (hashes with hooks).
+* 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').

data/lib/ducktape/hookable_array.rb

@@ -1,54 +1,69 @@
 module Ducktape
   class HookableArray
-    include Hookable
+    include HookableCollection
 
     def self.[](*args)
-      new(args)
+      new([*args])
     end
 
     def self.try_convert(obj)
       return obj if obj.is_a? self
       obj = Array.try_convert(obj)
-      return nil if obj.nil?
-      new(obj)
+      obj ? new(obj) : nil
     end
 
+    # Careful when duping arrays. Duping is shallow.
     def initialize(*args, &block)
-      @array = if args.length == 1 && (args[0].is_a?(Array) || args[0].is_a?(HookableArray))
-        args[0]
-      else
-        Array.new(*args, &block)
-      end
+      @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 method_missing(name, *args, &block)
-      @array.public_send(name, *args, &block)
-    end
-
-    def to_s() @array.to_s end
-    def inspect() @array.inspect end
+    def to_a() self end
     def to_ary() self end
 
-    def_hook 'on_changed'
-
-    compile_hook = ->(name, aka = nil) do
-      aka ||= name
-      aka = "on_#{aka}"
-
-      def_hook(aka) unless method_defined?(aka)
-
-      define_method(name) do |*args, &block|
-        result = @array.public_send(__method__, *args, &block)
-        call_hooks(aka, self, args, result)
-        call_hooks('on_changed', self, name, args, result)
-        result
-      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
 
-    %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'.each { |m| compile_hook.(m) }
-
-    { '[]=' => 'assign', '<<' => 'append' }.each { |k, v| compile_hook.(k, v) }
+    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

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,55 @@
+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

data/lib/ducktape.rb

@@ -1,12 +1,18 @@
-require 'ducktape/version'
+require 'version'
 
 module Ducktape
-  {
-    :Bindable                  => 'bindable',
-    :BindableAttribute         => 'bindable_attribute',
-    :BindableAttributeMetadata => 'bindable_attribute_metadata',
-    :BindingSource             => 'binding_source',
-    :Hookable                  => 'hookable',
-    :HookableArray             => 'hookable_array'
-  }.each { |k, v| autoload k, "ducktape/#{v}" }
+  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'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/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ducktape
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-01 00:00:00.000000000 Z
+date: 2012-05-20 00:00:00.000000000 Z
 dependencies: []
 description: Truly outrageous bindable attributes
 email:
@@ -26,8 +26,10 @@ files:
 - lib/ducktape/binding_source.rb
 - lib/ducktape/hookable.rb
 - lib/ducktape/hookable_array.rb
-- lib/ducktape/version.rb
+- lib/ducktape/hookable_collection.rb
+- lib/ducktape/hookable_hash.rb
 - lib/ducktape.rb
+- lib/version.rb
 - README.md
 homepage: https://github.com/SilverPhoenix99/ducktape
 licenses: []

data/lib/ducktape/version.rb

@@ -1,3 +0,0 @@
-module Ducktape
-  VERSION = '0.1.0'
-end