ducktape 0.0.1

data/lib/ducktape/bindable.rb

@@ -0,0 +1,69 @@
+module Ducktape
+  module Bindable
+    module ClassMethods
+      def inherited(child)
+        super
+        child.instance_eval { @bindings_metadata = {} }
+      end
+
+      def bindable(name, options = {})
+        name = name.to_s
+        m = BindableAttributeMetadata.new(metadata(name) || name, options)
+        @bindings_metadata[name.to_s] = m
+        define_method name, ->{get_bindable_attr(name).value} if !options.has_key?(:readable) or options[:readable]
+        define_method "#{name}=", ->(value){get_bindable_attr(name).value = value} if !options.has_key?(:writable) or options[:writable]
+        nil
+      end
+
+      #TODO improve metadata search
+      def metadata(name)
+        name = name.to_s
+        m = @bindings_metadata[name]
+        return m if m
+        return nil unless superclass.respond_to?(:metadata) && (m = superclass.metadata(name))
+        m = m.dup
+        @bindings_metadata[name] = m
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.instance_eval { @bindings_metadata = {} }
+    end
+
+    def self.extended(_)
+      raise 'Cannot extend, only include.'
+    end
+
+    def unbind_source(name)
+      get_bindable_attr(name.to_s).remove_source(true)
+      nil
+    end
+
+    def clear_bindings()
+      bindable_attrs.each { |_,attr| attr.remove_source() }
+      nil
+    end
+
+    def on_changed(attr_name, &block)
+      return nil unless block
+      get_bindable_attr(attr_name.to_s).send(:on_changed, &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)
+      block
+    end
+
+    private
+    def bindable_attrs
+      @bindable_attrs ||= {}
+    end
+
+    def get_bindable_attr(name)
+      bindable_attrs[name.to_s] ||= BindableAttribute.new(self, name.to_s)
+    end
+  end
+end

data/lib/ducktape/bindable_attribute.rb

@@ -0,0 +1,116 @@
+autoload :Set, 'set'
+
+module Ducktape
+
+  class InvalidAttributeValueError < StandardError
+    def initialize(name, value)
+      super("value #{value.inspect} is invalid for attribute '#{name}'")
+    end
+  end
+
+  class BindableAttribute
+
+    include Hookable
+
+    attr_reader :owner,    # Bindable
+                :name,     # String
+                :source,   # BindingSource
+                #:targets, # { BindableAttribute => BindingSource }
+                :value     # Object
+
+    def_hook :on_changed
+
+    def initialize(owner, name)
+      @owner, @name, @targets, @source = owner, name.to_s, {}, nil
+      reset_value(false)
+    end
+
+    def metadata
+      @owner.class.metadata(@name)
+    end
+
+    def value=(value)
+      set_value(value)
+    end
+
+    def remove_source(propagate = true)
+      detach(@source, self, propagate)
+    end
+
+    def reset_value(propagate = true)
+      meta = metadata
+      value = @source ? @source.source.value : meta.default
+
+      if propagate
+        self.value = value
+      else
+        @value = value
+      end
+
+      nil
+    end
+
+    protected #--------------------------------------------------------------
+
+    def set_value(value, exclusions = Set.new)
+      return if exclusions.member? 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
+      end
+
+      #set effective value
+      if @value != value
+        m = metadata
+        value = m.coerce(owner, value)
+        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
+
+    private #----------------------------------------------------------------
+
+    def propagate_to_source
+      return false unless @source
+      BindingSource::PROPAGATE_TO_SOURCE.member? @source.mode
+    end
+
+    def targets_to_propagate
+      @targets.select { |_, b| BindingSource::PROPAGATE_TO_TARGETS.member? b.mode }
+    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 }
+    end
+
+    # source: BindableAttribute
+    def self.detach(source, target, propagate)
+      return unless target.source and target.source.source == source
+
+      source.instance_eval { @targets.delete(target) }
+      target.instance_eval { @source = nil; reset_value(propagate) }
+
+      nil
+    end
+  end
+end

data/lib/ducktape/bindable_attribute_metadata.rb

@@ -0,0 +1,53 @@
+module Ducktape
+  class BindableAttributeMetadata
+
+  		attr_reader :name
+
+  		def initialize(name, options = {})
+  			if name.is_a? BindableAttributeMetadata
+  				@name = name.name
+  				@default = options[:default] || name.instance_variable_get(:@default)
+  				@validation = options[:validate] || name.instance_variable_get(:@validation)
+  				@coercion = options[:coerce] || name.instance_variable_get(:@coercion)
+  			else
+  				@name = name
+  				@default = options[:default]
+  				@validation = options[:validate]
+  				@coercion = options[:coerce]
+  			end
+
+  			@validation = [*@validation] unless @validation.nil?
+  		end
+
+  		def default=(value)
+  			@default = value
+  		end
+
+  		def default
+  			@default.is_a?(Proc) ? @default.call : @default
+  		end
+
+  		def validation(*options, &block)
+  			options << block
+  			@validation = options
+  		end
+
+  		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
+  			end
+  			false
+  		end
+
+  		def coercion(&block)
+  			@coercion = block
+  		end
+
+  		def coerce(owner, value)
+  			@coercion ? @coercion.call(owner, value) : value
+  		end
+  	end
+end

data/lib/ducktape/binding_source.rb

@@ -0,0 +1,21 @@
+module Ducktape
+  class BindingSource
+    PROPAGATE_TO_SOURCE  = [:reverse, :both].freeze
+    PROPAGATE_TO_TARGETS = [:forward, :both].freeze
+
+    attr_reader :source # BindableAttribute
+    attr_accessor :mode # :forward, :reverse, :both
+
+    def initialize(source, source_attr, mode = :both)
+      set_source(source, source_attr)
+      @mode = mode
+    end
+
+    private
+
+    #TODO: notify source/target of change
+    def set_source(source, source_attr)
+      @source = source.send(:get_bindable_attr, source_attr)
+    end
+  end
+end

data/lib/ducktape/hookable.rb

@@ -0,0 +1,48 @@
+module Ducktape
+  module Hookable
+
+    module ClassMethods
+      def def_hook(*events)
+        events.each { |e| define_method e, ->(&block){ add_hook(e, &block) } }
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def self.extended(_)
+      raise 'Cannot extend, only include.'
+    end
+
+    def add_hook(event, &block)
+      return unless block
+      self.hooks[event.to_s].unshift block
+      nil
+    end
+
+    def remove_hook(event, block)
+      self.hooks[event.to_s].delete(block)
+    end
+
+    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 { |hook| hook.call(event, caller, *args) }
+      nil
+    end
+
+    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)
+        return handled if handled
+      end
+      nil
+    end
+  end
+end

data/lib/ducktape.rb

@@ -0,0 +1,11 @@
+module Ducktape
+  ROOT = File.expand_path('../ducktape', __FILE__)
+
+  {
+    :Bindable                  => 'bindable',
+    :BindableAttribute         => 'bindable_attribute',
+    :BindableAttributeMetadata => 'bindable_attribute_metadata',
+    :BindingSource             => 'binding_source',
+    :Hookable                  => 'hookable'
+  }.each { |k, v| autoload k, "#{ROOT}/#{v}" }
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: ducktape
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- SilverPhoenix99
+- P3t3rU5
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-28 00:00:00.000000000 Z
+dependencies: []
+description: Truly outrageous bindable attributes
+email:
+- silver.phoenix99@gmail.com
+- pedro.megastore@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ducktape.rb
+- lib/ducktape/bindable.rb
+- lib/ducktape/bindable_attribute.rb
+- lib/ducktape/bindable_attribute_metadata.rb
+- lib/ducktape/binding_source.rb
+- lib/ducktape/hookable.rb
+homepage: https://github.com/SilverPhoenix99/ducktape
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Truly outrageous bindable attributes
+test_files: []
+has_rdoc: