ducktape 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ae5e41fb6852b1d6c317f3cb72d2615ee2ad04a8
-  data.tar.gz: a3aa58766760da4d1f6363f7727db35cff8ad1b1
+  metadata.gz: c0f795c6666e9a4c52a4bada0c0cb9f523c6bc8b
+  data.tar.gz: 60d1edc8db2aa8c1334d6d0a1a8a4fdaabacc634
 SHA512:
-  metadata.gz: 19a4061eda2662fbab5e27529fa04b1bf4e70fdde0789bdda80d71b3a01aea7cddd84b3e98f81022dc265295c9adc5f619c05d711de6e6e420790ffb80fce637
-  data.tar.gz: e74ce291ea4b9c8758c6688ef195bc754818b306b0cedaf531fc8ad84ae9916eb7580ecb1aeb69c02d8b1dbd21cfee5fc7c27b98da7f0515eb98cae5e4fa86dc
+  metadata.gz: 6544f7a65a030f457598adacd40e2209f645d518d6905c119fafe1fe6160599bc7176c2008811e3a12d8840327622981a7e269274a794245a879844cb82aef07
+  data.tar.gz: 12b3a55f99fbeac0c386fa7ede356c5744ecf02d83bc64f0734f768e427e800f84e7cb49af02aa2f2005673314e79b592d375c4af21f02f3e0671fbfeec3cab5

data/lib/ducktape/bindable.rb

@@ -17,39 +17,52 @@ module Ducktape
     module ClassMethods
       def bindable(name, options = {})
         name = name.to_s
-        options[:access] ||= :both
-        m = BindableAttributeMetadata.new(metadata(name) || name, options)
-        bindings_metadata[name] = m
-        raise InconsistentAccessorError.new(true, name)  if options[:access] == :writeonly && options[:getter]
-        raise InconsistentAccessorError.new(false, name) if options[:access] == :readonly && options[:setter]
-
-        define_method name, options[:getter] || ->() { get_value(name) } unless options[:access] == :writeonly
-
-        unless options[:access] == :readonly
-          define_method "#{name}=", options[:setter] || ->(value) { set_value(name, value) }
-        end
+        bindings_metadata[name] = metadata = BindableAttributeMetadata.new(metadata(name) || name, options)
+        define_getter metadata
+        define_setter metadata
         nil
       end
 
-      #TODO improve metadata search
       def metadata(name)
         name = name.to_s
-        m = bindings_metadata[name]
-        return m if m
-        a = ancestors.find { |a| a != self && a.respond_to?(:metadata) }
-        return nil unless a && (m = a.metadata(name))
-        m = m.dup
-        bindings_metadata[name] = m
-      end
 
-      protected
-      def bindings_metadata
-        @bindings_metadata ||= {}
+        meta = ancestors.find do |ancestor|
+          bindings = ancestor.instance_variable_get(:@bindings_metadata)
+          meta = bindings && bindings[name]
+          break meta if meta
+        end
+
+        return unless meta
+        bindings_metadata[name] = meta
       end
+
+      private
+
+        def bindings_metadata
+          @bindings_metadata ||= {}
+        end
+
+        def define_getter(metadata)
+          if metadata.access == :writeonly
+            raise InconsistentAccessorError.new(true, @name) if metadata.getter
+            return
+          end
+
+          define_method metadata.name, metadata.getter_proc
+        end
+
+        def define_setter(metadata)
+          if metadata.access == :readonly
+            raise InconsistentAccessorError.new(false, @name) if metadata.setter
+            return
+          end
+
+          define_method "#{metadata.name}=", metadata.setter_proc
+        end
     end
 
     def self.included(base)
-      base.extend(ClassMethods)
+      base.extend ClassMethods
       return unless base.is_a?(Module)
       included = base.respond_to?(:included) && base.method(:included)
       base.define_singleton_method(:included, ->(c) do
@@ -62,6 +75,10 @@ module Ducktape
       raise 'Cannot extend, only include.'
     end
 
+    def bind(attr_name, *args)
+      send "#{attr_name}=", BindingSource.new(*args)
+    end
+
     def bindable_attr?(attr_name)
       !!metadata(attr_name)
     end
@@ -93,29 +110,27 @@ module Ducktape
       hook
     end
 
-    protected #--------------------------------------------------------------
-
-    def get_value(attr_name)
-      get_bindable_attr(attr_name).value
-    end
+    private #--------------------------------------------------------------
 
-    def metadata(name)
-      is_a?(Class) ? singleton_class.metadata(name) : self.class.metadata(name)
-    end
+      def get_value(attr_name)
+        get_bindable_attr(attr_name).value
+      end
 
-    def set_value(attr_name, value)
-      get_bindable_attr(attr_name).value = value
-    end
+      def metadata(name)
+        is_a?(Class) ? singleton_class.metadata(name) : self.class.metadata(name)
+      end
 
-    private #----------------------------------------------------------------
+      def set_value(attr_name, value, &block)
+        get_bindable_attr(attr_name).set_value(value, &block)
+      end
 
-    def bindable_attrs
-      @bindable_attrs ||= {}
-    end
+      def bindable_attrs
+        @bindable_attrs ||= {}
+      end
 
-    def get_bindable_attr(name)
-      raise AttributeNotDefinedError.new(self.class, name.to_s) unless bindable_attr?(name)
-      bindable_attrs[name.to_s] ||= BindableAttribute.new(self, name)
-    end
+      def get_bindable_attr(name)
+        raise AttributeNotDefinedError.new(self.class, name.to_s) unless bindable_attr?(name)
+        bindable_attrs[name.to_s] ||= BindableAttribute.new(self, name)
+      end
   end
 end

data/lib/ducktape/bindable_attribute.rb

@@ -13,21 +13,19 @@ module Ducktape
     attr_reader :owner,         # Bindable
                 :name,          # String
                 :value          # Object
-                #:source        # Link - link between source and target
+                #:source_link   # Link - link between source and target
 
     def initialize(owner, name)
-      @owner, @name, = owner, name.to_s
-      @source = nil
+      @owner, @name, @source_link = owner, name.to_s, nil
       reset_value
     end
 
     def binding_source
-      return unless @source
-      @source.binding_source
+      @source_link.binding_source if @source_link
     end
 
     def has_source?
-      !!@source
+      !!@source_link
     end
 
     def metadata
@@ -37,62 +35,56 @@ module Ducktape
     #After unbinding the source the value can be reset, or kept.
     #The default is to reset the target's (self) value.
     def remove_source(reset = true)
-      return unless @source
-      src, @source = @source, nil
+      return unless @source_link
+      src, @source_link = @source_link, nil
       src.unbind
       reset_value if reset
       src.binding_source
     end
 
     def reset_value
-      set_value(metadata.default)
+      set_value metadata.default
     end
 
-    def value=(value)
-      set_value(value)
-    end
-
-    def to_s
-      "#<#{self.class}:0x#{object_id.to_s(16)} @name=#{name}>"
-    end
-
-    private #----------------------------------------------------------------
-
     def set_value(value)
       if value.is_a?(BindingSource) #attach new binding source
-        remove_source(false)
-        @source = Link.new(value, self).tap { |l| l.bind }
-
-        unless @source.forward?
-          @source.update_source
-          return @value #value didn't change
-        end
-
-        value = @source.source_value
+        replace_source value
+        return @value unless @source_link.forward? #value didn't change
+        value = @source_link.source_value
       end
 
-      return @value if value.equal?(@original_value) || value == @original_value # untransformed value is the same?
-
-      original_value = value
-
-      # transform value
-      m = metadata
-      value = m.coerce(owner, value)
-      raise InvalidAttributeValueError.new(@name, value) unless m.validate(value)
+      original_value, value = value, transform_value(value)
 
       return @value if value.equal?(@value) || value == @value # transformed value is the same?
 
       #set effective value
-      old_value, @value, @original_value = @value, value, original_value
-      call_hooks(:on_changed, owner, attribute: name.dup, value: @value, old_value: old_value)
+      old_value, @original_value, @value = @value, original_value, value
+      yield @value if block_given?
+      call_hooks :on_changed, owner, attribute: name.dup, value: @value, old_value: old_value
 
-      @source.update_source if @source && @source.reverse?
+      @source_link.update_source if @source_link && @source_link.reverse?
 
       @value
     end
 
-    def convert(value)
-      value
+    def to_s
+      "#<#{self.class}:0x#{object_id.to_s(16)} @name=#{name}>"
     end
+
+    private
+
+      def replace_source(new_source)
+        remove_source false
+        @source_link = Link.new(new_source, self)
+        @source_link.bind
+        @source_link.update_source unless @source_link.forward?
+      end
+
+      def transform_value(value)
+        metadata = self.metadata
+        value = metadata.coerce(owner, value)
+        metadata.validate(value)
+        value
+      end
   end
 end

data/lib/ducktape/bindable_attribute_metadata.rb

@@ -1,6 +1,8 @@
 module Ducktape
   class BindableAttributeMetadata
 
+    @validators = [ ClassValidator, ProcValidator, RegexpValidator, RangeValidator ]
+
     VALID_OPTIONS = [:access, :coerce, :default, :getter, :setter, :validate].freeze
 
     attr_reader :name, :access, :getter, :setter
@@ -8,27 +10,21 @@ module Ducktape
     def initialize(name, options = {})
 
       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
-        @default    = options.has_key?(:default) ? options[:default] : name.instance_variable_get(:@default)
-        @validation = options.has_key?(:validate) ? options[:validate] : name.instance_variable_get(:@validation)
-        @coercion   = options.has_key?(:coerce) ? options[:coerce] : name.instance_variable_get(:@coercion)
-        @access     = options.has_key?(:access) ? options[:access] : name.access
-        @getter     = options.has_key?(:getter) ? options[:getter] : name.getter
-        @setter     = options.has_key?(:setter) ? options[:setter] : name.setter
+        each { |k| $stderr.puts "WARNING: invalid option #{k.inspect} for #{name.inspect} attribute. Will be ignored." }
+
+      if name.is_a?(BindableAttributeMetadata)
+        @name   = name.name
+        options = name.send(:as_options).merge!(options)
       else
-        @name       = name
-        @default    = options[:default]
-        @validation = options[:validate]
-        @coercion   = options[:coerce]
-        @access     = options[:access]
-        @getter     = options[:getter]
-        @setter     = options[:setter]
+        @name = name
       end
 
-      @validation = [*@validation] unless @validation.nil?
+      @default    = options[:default]
+      @validation = validation(*options[:validate])
+      @coercion   = options[:coerce] || ->(_owner, value) { value }
+      @access     = options[:access] || :both
+      @getter     = options[:getter]
+      @setter     = options[:setter]
     end
 
     def default=(value)
@@ -39,20 +35,28 @@ module Ducktape
       @default.respond_to?(:call) ? @default.call : @default
     end
 
-    def validation(*options, &block)
-      options << block
-      @validation = options
+    def getter_proc
+      self.class.getter_proc(@getter, @name)
     end
 
-    def validate(value)
-      return true unless @validation
-      @validation.each do |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
+    def setter_proc
+      self.class.setter_proc(@setter, @name)
+    end
+
+    def validation(*validators, &block)
+      validators << block if block
+      class_validators = Set.new(self.class.instance_variable_get(:@validators))
+      @validation = validators.map do |validator|
+        class_validators.include?(validator.class) ? validator : self.class.create_validator(validator)
       end
-      false
+    end
+
+    def valid?(value)
+      @validation.empty? || @validation.any? { |validator| validator.validate(value) }
+    end
+
+    def validate(value)
+      raise InvalidAttributeValueError.new(@name, value) unless valid?(value)
     end
 
     def coercion(&block)
@@ -60,7 +64,47 @@ module Ducktape
     end
 
     def coerce(owner, value)
-      @coercion ? @coercion.call(owner, value) : value
+      @coercion ? @coercion.(owner, value) : value
     end
+
+    def self.register_validator(validator_class)
+      @validators << validator_class
+    end
+
+    private
+
+      def as_options
+        {
+          default:  @default,
+          validate: @validation,
+          coerce:   @coercion,
+          access:   @access,
+          getter:   @getter,
+          setter:   @setter
+        }
+      end
+
+      def self.create_validator(validator)
+        validator_class = @validators.find { |validator_class| validator_class.matches?(validator) } || EqualityValidator
+        validator_class.new(validator)
+      end
+
+      def self.getter_proc(getter, name)
+        case getter
+          when Proc           then getter
+          when Symbol, String then ->() { send(getter) }
+          when nil            then ->() { get_value(name) }
+          else raise ArgumentError, 'requires a Proc, a Symbol or nil'
+        end
+      end
+
+      def self.setter_proc(setter, name)
+        case setter
+          when Proc           then setter
+          when Symbol, String then ->(value) { send(setter, value) }
+          when nil            then ->(value) { set_value(name, value) }
+          else raise ArgumentError, 'requires a Proc, a Symbol or nil'
+        end
+      end
   end
-end
+end

data/lib/ducktape/expression/identifier_exp.rb

@@ -1,8 +1,7 @@
 module Ducktape
   module Expression
     class IdentifierExp
-      include LiteralExp
-      include Ref #WeakReference
+      include Ref, LiteralExp
 
       def bind(src, type, qual = nil, _ = src)
         unbind
@@ -83,7 +82,7 @@ module Ducktape
       def property_set(src, value)
         case
           when src.is_a?(Bindable) && src.bindable_attr?(literal)
-            src.send(:get_bindable_attr, literal).value = value
+            src.send(:get_bindable_attr, literal).set_value value
           when src.respond_to?("#{literal}=")
             src.public_send("#{literal}=", value)
           when src.respond_to?(literal) && [-2, -1, 1].include?(src.public_method(literal).arity)

data/lib/ducktape/expression/indexer_exp.rb

@@ -1,8 +1,7 @@
 module Ducktape
   module Expression
     class IndexerExp # left[right+]
-      include BinaryOpExp
-      include Ref
+      include Ref, BinaryOpExp
 
       alias_method :params, :right
 

data/lib/{ext → ducktape/ext}/def_hookable.rb

@@ -4,11 +4,9 @@ module Ducktape
 
   def self.def_hookable(klass, *args)
     return if args.length == 0
+    names_hash = args.extract_options!
 
-    names_hash = args.pop if args.last.is_a?(Hash)
-    names_hash ||= {}
-
-    #Reversed merge because names_hash has priority.
+    # reversed merge because names_hash has priority
     @hookable_types[klass] = Hash[args.flatten.map { |v| [v, v] }].merge!(names_hash)
 
     nil
@@ -16,9 +14,10 @@ module Ducktape
 
   def self.hookable(obj)
     return obj if obj.is_a?(Hookable)
-    m = obj.class.ancestors.each { |c| v = @hookable_types[c]; break v if v }
+    m = obj.class.ancestors.find { |c| @hookable_types.has_key?(c) }
     return obj unless m
-    (class << obj; include Hookable; self end).make_hooks(m)
+    obj.singleton_class.send :include, Hookable
+    obj.singleton_class.make_hooks(@hookable_types[m])
     obj
   end
 

data/lib/ducktape/hookable.rb

@@ -1,114 +1,198 @@
 module Ducktape
   module Hookable
+    def self.included(base)
+      if base.is_a?(Class)
+        base.include InstanceMethods
+        base.extend  ClassMethods
+        base.def_hook(:on_changed) unless base.method_defined?(:on_changed)
+        return
+      end
+
+      # Module
+
+      # just create a proxy for #included
+      include_method = if base.respond_to?(:included)
+        base_included_method = base.method(:included)
+        ->(c) do
+          base_included_method.(c)
+          c.send :include, ::Ducktape::Hookable
+        end
+      else
+        ->(c) { c.send :include, ::Ducktape::Hookable }
+      end
+
+      base.define_singleton_method(:included, include_method)
+    end
+
+    def self.extended(_)
+      raise 'Cannot extend, only include.'
+    end
 
     module ClassMethods
-      def def_hook(*events)
-        events.each { |e| define_method e, ->(method_name = nil, &block) { add_hook(e, method_name, &block) } }
+
+      # Creates a wrapper method for #add_hook that doesn't require the event to be passed.
+      # For example, calling:
+      #
+      #    def_hook :on_init
+      #
+      # will create a +on_init+ method, that can be used as:
+      #
+      #    on_init { |*_| puts 'I initialized' }
+      #
+      # It's the same as calling:
+      #
+      #    add_hook(:on_init) { |*_| puts 'I initialized' }
+      #
+      def def_hook(event)
+        define_method event, ->(method_name = nil, &block) do
+          add_hook event, method_name, &block
+        end
+      end
+
+      # Calls +def_hook+ for each event passed.
+      def def_hooks(*events)
+        events.each { |event| def_hook(event) }
+      end
+
+      # Overrides (decorates) existing methods to make then hookable.
+      def make_hooks(*args)
+        make :hook, *args
+      end
+
+      # Overrides (decorates) existing methods to make then handleable.
+      # This is similar to hookable, but stops calling the hooks
+      # when a hook returns +false+ or +nil+.
+      def make_handlers(*args)
+        make :handler, *args
       end
 
-      %w'hook handler'.each do |type|
-        define_method "make_#{type}s" do |*args|
+      private
+
+        def make(type, *args)
           return if args.length == 0
 
-          names_hash = (args.last.is_a?(Hash) && args.pop) || {}
+          build_hook_names(args).each do |method_name, event|
+            hook_name = "on_#{event}"
+            def_hook(hook_name) unless method_defined?(hook_name)
+            original_method = public_instance_method(method_name)
+            decorate_method type, original_method, hook_name
+          end
+        end
 
-          #Reversed merge because names_hash has priority.
-          names_hash = Hash[args.flatten.map { |v| [v, v] }].merge!(names_hash)
+        def build_hook_names(args)
+          hook_names = args.extract_options!
 
-          names_hash.each do |name, aka|
-            aka = "on_#{aka}"
-            def_hook(aka) unless method_defined?(aka)
+          #Reversed merge because hook_names has priority.
+          Hash[args.flatten.map { |v| [v, v] }].merge!(hook_names)
+        end
 
-            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,         name, OpenStruct.new(args: a, result: r)) || type != 'handler'
-                send(  cm, :on_changed, name, OpenStruct.new(args: a, result: r))
-              end
-              r
+        def decorate_method(type, original_method, hook_name)
+          define_method(original_method.name) do |*args, &block|
+            bound_method = original_method.bind(self)
+            result = bound_method.(*args, &block)
+            params = OpenStruct.new(args: args, result: result)
+            call_name = "call_#{ type }s"
+            result = send(call_name, hook_name, original_method.name, params)
+            unless result && type == :handler
+              # invoke if previous call is false or nil
+              send call_name, :on_changed, original_method.name, params
             end
+            result
           end
         end
-      end
     end
 
-    def self.included(base)
-      base.extend(ClassMethods)
-      base.def_hook :on_changed unless base.method_defined?(:on_changed)
-      return unless base.is_a?(Module)
-      included = base.respond_to?(:included) && base.method(:included)
-      base.define_singleton_method(:included, ->(c) do
-        included.(c) if included
-        c.extend(ClassMethods)
-      end)
-    end
+    module InstanceMethods
 
-    def self.extended(_)
-      raise 'Cannot extend, only include.'
-    end
+      # Registers a block, a named method, or any object that responds to +call+
+      # to be triggered when the +event+ occurs.
+      def add_hook(event, hook = nil, &block)
+        hook = block if block #block has precedence
+        raise ArgumentError, 'no hook was passed' unless hook
+        hook = hook.to_s unless hook.respond_to?(:call)
+        hooks[event.to_s].unshift(hook)
+        hook
+      end
 
-    def add_hook(event, hook = nil, &block)
-      hook = block if block #block has precedence
-      raise ArgumentError, 'no hook was passed' unless hook
-      hook = hook.to_s unless hook.respond_to?(:call)
-      self.hooks[event.to_s].unshift(hook)
-      hook
-    end
+      # Removes the specified hook. Returns +nil+ if the hook wasn't found.
+      def remove_hook(event, hook)
+        return unless hooks.has_key?(event.to_s)
+        hook = hook.to_s unless hook.respond_to?(:call)
+        hooks[event.to_s].delete(hook)
+      end
 
-    def remove_hook(event, hook)
-      hook = hook.to_s unless hook.respond_to?(:call)
-      self.hooks[event.to_s].delete(hook)
-    end
+      # Removes all hooks from the specified +event+.
+      # If an +event+ wasn't passed, removes all hooks from all events.
+      def clear_hooks(event = nil)
+        if event
+          hooks.delete(event.to_s) if hooks.has_key?(event.to_s)
+          return
+        end
 
-    def clear_hooks(event = nil)
-      if event
-        self.hooks.delete(event.to_s)
-      else
-        self.hooks.clear.dup
+        hooks.clear
+        nil
       end
-    end
-
-    protected #--------------------------------------------------------------
 
-    def hooks
-      @hooks ||= Hash.new { |h,k| h[k.to_s] = [] }
-    end
+      private #--------------------------------------------------------------
 
-    # `#call_handlers` is similar to `#call_hooks`,
-    # but stops calling other hooks when a hook returns a value other than nil or false.
-    # If caller is a Hash, then use: call_*s(event, hash, {})
-    %w'hook handler'.each do |name|
-      define_method("call_#{name}s", ->(event, *args) do
-        raise ArgumentError, "wrong number of arguments (#{args.length} for 3)" if args.length > 2
-        caller, parms = case
-          when args.length == 0 then [self, {}]                                    # call_*s(event, caller = self, parms = {})
-          when args.length == 2 then args                                          # call_*s(event, caller, parms)
-          when [Hash, OpenStruct].any? { |c| c === args[0] } then [self, args[0]]  # call_*s(event, caller = self, parms)
-          else [args[0], {}]                                                       # call_*s(event, caller, parms = {})
+        def hooks
+          @hooks ||= Hash.new { |h, k| h[k.to_s] = [] }
         end
 
-        return unless hooks.has_key?(event.to_s)
+        def extract_parameters(args)
+          raise ArgumentError, "wrong number of arguments (#{args.length} for 0..2)" if args.length > 2
+
+          case
+            when args.length == 0                               # call_*s(event, caller = self, parms = {})
+              [self, {}]
+            when args.length == 2                               # call_*s(event, caller, parms)
+              args
+            when [Hash, OpenStruct].include?(args[0].class)     # call_*s(event, caller = self, parms)
+              [self, args[0]]
+            else
+              [args[0], {}]                                     # call_*s(event, caller, parms = {})
+          end
+        end
 
-        handled, parms2 = nil, nil
-        hooks[event.to_s].each do |hook|
-          hook = case hook
+        def build_hook(hook)
+          case hook
             when Proc, Method then hook
             when Symbol, String then caller.method(hook)
             else hook.method(:call)
           end
-          handled = if hook.arity == 1
-                      parms2 ||= OpenStruct.new(
-                        (parms.is_a?(OpenStruct) ? parms.to_h : parms).merge(event: event, caller: caller))
-                      hook.(parms2)
-                    else
-                      hook.(event, caller, parms)
-                    end
-          break if name.index('handler') && handled
         end
-        name.index('handler') && handled
-      end)
+
+        def call_hook(hook, event, caller, parms, parms2)
+          return hook.(), parms2 if hook.arity == 0
+          return hook.(event, caller, parms) if hook.arity > 1
+
+          parms = parms.to_h if parms.is_a?(OpenStruct)
+          parms2 ||= OpenStruct.new(parms.merge(event: event, caller: caller))
+          [ hook.(parms2), parms2 ]
+        end
+
+        def call_hooks(event, *args)
+          invoke :hook, event, *args
+        end
+
+        # `#call_handlers` is similar to `#call_hooks`,
+        # but stops calling other hooks when a hook returns a value other than +nil+ or +false+.
+        # If caller is a Hash, then use: call_*s(event, hash, {})
+        def call_handlers(event, *args)
+          invoke :handler, event, *args
+        end
+
+        def invoke(type, event, *args)
+          caller, parms = extract_parameters(args)
+          return unless hooks.has_key?(event.to_s)
+          handled, parms2 = nil, nil
+          hooks[event.to_s].each do |hook|
+            hook = build_hook(hook)
+            handled, parms2 = call_hook(hook, event, caller, parms, parms2)
+            break if type == :handler && handled
+          end
+          type == :handler && handled
+        end
     end
   end
 end

data/lib/ducktape/link.rb

@@ -4,20 +4,6 @@ module Ducktape
 
     class ModeError < StandardError; end
 
-    class << self
-      def cleanup(*method_names)
-        method_names.each do |method_name|
-          m = instance_method(method_name)
-          define_method(method_name, ->(*args, &block) do
-            return m.bind(self).(*args, &block) unless broken?
-            unbind if @expression
-            @target.object.remove_source if @target && @target.object
-            @source, @target, @expression = nil
-          end)
-        end
-      end
-    end
-
     attr_accessor :source,     # WeakRef of Object
                   :expression, # Expression (e.g.: 'a::X.b[c,d]')
                   :target,     # WeakRef of BindingAttribute
@@ -50,52 +36,58 @@ module Ducktape
     end
 
     def bind
-      @expression.bind(@source.object, :value)
+      with_cleanup { @expression.bind(@source.object, :value) }
       nil
     end
 
     def unbind
-      @expression.unbind
+      with_cleanup { @expression.unbind }
       nil
     end
 
     def update_source
       assert_mode :set, :source, :reverse
-      @expression.value = target_value
+      with_cleanup { @expression.value = target_value }
     end
 
     def update_target
       assert_mode :set, :target, :forward
-      @target.object.value = source_value
+      with_cleanup { @target.object.set_value source_value }
     end
 
     def source_value
       assert_mode :get, :source, :forward
-      @converter.convert(@expression.value)
+      with_cleanup { @converter.convert(@expression.value) }
     end
 
     def target_value
       assert_mode :get, :target, :reverse
-      @converter.revert(@target.object.value)
+      with_cleanup { @converter.revert(@target.object.value) }
     end
 
-    cleanup :bind, :unbind, :update_source, :update_target, :source_value, :target_value
-
     private
-    def assert_mode(accessor, type, mode)
-      raise ModeError, "cannot #{accessor} #{type} value on a non #{mode} link" unless public_send("#{mode}?")
-    end
 
-    def path_changed
-      bind
-      forward? ? update_target : update_source
-      nil
-    end
+      def assert_mode(accessor, type, mode)
+        raise ModeError, "cannot #{accessor} #{type} value on a non #{mode} link" unless public_send("#{mode}?")
+      end
 
-    def value_changed
-      return unless forward?
-      update_target
-      nil
-    end
+      def path_changed
+        bind
+        forward? ? update_target : update_source
+        nil
+      end
+
+      def value_changed
+        return unless forward?
+        update_target
+        nil
+      end
+
+      def with_cleanup
+        return yield unless broken?
+        unbind if @expression
+        @target.object.remove_source if @target && @target.object
+        @source, @target, @expression = nil
+      end
   end
 end

data/lib/ducktape/validators/class_validator.rb

@@ -0,0 +1,15 @@
+module Ducktape
+  class ClassValidator
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def validate(obj)
+      obj.is_a?(@klass)
+    end
+
+    def self.matches?(obj)
+      obj.is_a?(Module)
+    end
+  end
+end

data/lib/ducktape/validators/equality_validator.rb

@@ -0,0 +1,15 @@
+module Ducktape
+  class EqualityValidator
+    def initialize(obj)
+      @obj = obj
+    end
+
+    def validate(obj)
+      obj == @obj
+    end
+
+    def self.matches?(_)
+      true
+    end
+  end
+end

data/lib/ducktape/validators/proc_validator.rb

@@ -0,0 +1,15 @@
+module Ducktape
+  class ProcValidator
+    def initialize(proc)
+      @proc = proc
+    end
+
+    def validate(obj)
+      @proc.(obj)
+    end
+
+    def self.matches?(obj)
+      obj.respond_to?(:call)
+    end
+  end
+end

data/lib/ducktape/validators/range_validator.rb

@@ -0,0 +1,15 @@
+module Ducktape
+  class RangeValidator
+    def initialize(range)
+      @range = range
+    end
+
+    def validate(obj)
+      @range.include?(obj)
+    end
+
+    def self.matches?(obj)
+      obj.is_a?(Range)
+    end
+  end
+end

data/lib/ducktape/validators/regexp_validator.rb

@@ -0,0 +1,15 @@
+module Ducktape
+  class RegexpValidator
+    def initialize(regexp)
+      @regexp = regexp
+    end
+
+    def validate(obj)
+      obj =~ @regexp
+    end
+
+    def self.matches?(obj)
+      obj.is_a?(Regexp)
+    end
+  end
+end

data/lib/ducktape/version.rb

@@ -1,7 +1,7 @@
-# Although against rubygems recommendation, 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.
+# Although against sematinc versioning recommendation, 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.
 
 module Ducktape
-  VERSION = '0.4.0'.freeze
+  VERSION = '0.5.0'.freeze
 end

data/lib/ducktape.rb

@@ -1,6 +1,7 @@
 %w'
   set
   facets/ostruct
+  facets/array/extract_options
   ref
   whittle
 '.each { |f| require f }
@@ -18,9 +19,13 @@
   converter
   link
   binding_source
+  validators/class_validator
+  validators/proc_validator
+  validators/regexp_validator
+  validators/range_validator
+  validators/equality_validator
   bindable_attribute_metadata
   bindable_attribute
   bindable
-'.each { |f| require "ducktape/#{f}" }
-
-%w'def_hookable'.each { |f| require "ext/#{f}" }
+  ext/def_hookable
+'.each { |f| require_relative "ducktape/#{f}" }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ducktape
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - SilverPhoenix99
@@ -9,64 +9,64 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-09 00:00:00.000000000 Z
+date: 2015-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: facets
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.9'
+        version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.9'
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: whittle
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.0'
 - !ruby/object:Gem::Dependency
   name: ref
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
 description: Truly outrageous bindable attributes
 email:
 - silver.phoenix99@gmail.com
@@ -75,6 +75,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- README.md
+- lib/ducktape.rb
 - lib/ducktape/bindable.rb
 - lib/ducktape/bindable_attribute.rb
 - lib/ducktape/bindable_attribute_metadata.rb
@@ -88,14 +90,17 @@ files:
 - lib/ducktape/expression/property_exp.rb
 - lib/ducktape/expression/qualified_exp.rb
 - lib/ducktape/ext/array.rb
+- lib/ducktape/ext/def_hookable.rb
 - lib/ducktape/ext/hash.rb
 - lib/ducktape/ext/string.rb
 - lib/ducktape/hookable.rb
 - lib/ducktape/link.rb
+- lib/ducktape/validators/class_validator.rb
+- lib/ducktape/validators/equality_validator.rb
+- lib/ducktape/validators/proc_validator.rb
+- lib/ducktape/validators/range_validator.rb
+- lib/ducktape/validators/regexp_validator.rb
 - lib/ducktape/version.rb
-- lib/ducktape.rb
-- lib/ext/def_hookable.rb
-- README.md
 homepage: https://github.com/SilverPhoenix99/ducktape
 licenses:
 - MIT
@@ -105,12 +110,10 @@ post_install_message: |
     Thank you for choosing Ducktape.
 
     ==========================================================================
-    0.4.0 Changes:
-      - This version is compatible with version 0.3.x.
-      - Added path expression to binding sources.
-
-    If you like what you see, support us on Pledgie:
-      http://www.pledgie.com/campaigns/18955
+    0.5.0 Changes:
+      - Added Bindable::bind method to wrap BindingSource construction.
+      - Added support for Range validation in bindable attributes.
+      - Internal refactorings.
 
     If you find any bugs, please report them on
       https://github.com/SilverPhoenix99/ducktape/issues
@@ -121,17 +124,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Truly outrageous bindable attributes