ducktape 0.3.3 → 0.4.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NTdhMjYxMTNjNWZmOTYwOWEwZjI0ZGU2OTQxOTYyYTgxYTUzOTQwNw==
-  data.tar.gz: !binary |-
-    ZTViZThkYWZiNGRiNjI3NGRmZTg1NTUzMzc3ZjIwMGEwNzVjYjc5MA==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    MWIxOWMxOWVkNWZlMWFlNzA4OWUzMDU5MDljNzBhNWI4ZDBlZTJkZWUyN2Ji
-    M2Y5NmJiN2UxZmZjMmIxNWM0ZmI0OTM2MWQyZTE4MDg5ODdlZTQxYTU3N2Ez
-    YmVkM2EzMjU4MDViMmY0M2RhNDgxYTgyNmM4ZDg1MDU0NmVlZWM=
-  data.tar.gz: !binary |-
-    YTk1NTYxN2NjNDgwMmI2NTJkMmU4MGQyNTYzZjFlNDU1NzdkOGQ5MDJlNjc3
-    ZDQwM2M2MDUzOTkyN2QyNmU0YTk4ZjhjOTJkNDhiZGZmOThkOWIyYjU3ZmYz
-    MzhjOWM5NDhhODdkZWIwZjBlNTI3N2NmOTFlNzAzNDgzYTY1MmU=
+SHA1:
+  metadata.gz: ae5e41fb6852b1d6c317f3cb72d2615ee2ad04a8
+  data.tar.gz: a3aa58766760da4d1f6363f7727db35cff8ad1b1
+SHA512:
+  metadata.gz: 19a4061eda2662fbab5e27529fa04b1bf4e70fdde0789bdda80d71b3a01aea7cddd84b3e98f81022dc265295c9adc5f619c05d711de6e6e420790ffb80fce637
+  data.tar.gz: e74ce291ea4b9c8758c6688ef195bc754818b306b0cedaf531fc8ad84ae9916eb7580ecb1aeb69c02d8b1dbd21cfee5fc7c27b98da7f0515eb98cae5e4fa86dc

data/lib/ducktape/bindable.rb

@@ -62,26 +62,35 @@ module Ducktape
       raise 'Cannot extend, only include.'
     end
 
-    def unbind_source(attr_name)
-      get_bindable_attr(attr_name).remove_source
-      nil
+    def bindable_attr?(attr_name)
+      !!metadata(attr_name)
     end
 
-    def clear_bindings()
-      bindable_attrs.each { |_, attr| attr.remove_source }
+    def binding_source(attr_name)
+      return unless bindable_attr?(attr_name)
+      get_bindable_attr(attr_name).binding_source
+    end
+
+    def clear_bindings(reset = true)
+      bindable_attrs.each { |_, attr| attr.remove_source(reset) }
       nil
     end
 
     def on_changed(attr_name, hook = nil, &block)
       return nil unless block || hook
       get_bindable_attr(attr_name).on_changed(hook, &block)
-      block
+      hook || block
+    end
+
+    def unbind_source(attr_name)
+      get_bindable_attr(attr_name).remove_source
+      nil
     end
 
-    def unhook_on_changed(attr_name, block)
-      return nil unless block
-      get_bindable_attr(attr_name).remove_hook(:on_changed, block)
-      block
+    def unhook_on_changed(attr_name, hook)
+      return nil unless hook
+      get_bindable_attr(attr_name).remove_hook(:on_changed, hook)
+      hook
     end
 
     protected #--------------------------------------------------------------
@@ -90,6 +99,10 @@ module Ducktape
       get_bindable_attr(attr_name).value
     end
 
+    def metadata(name)
+      is_a?(Class) ? singleton_class.metadata(name) : self.class.metadata(name)
+    end
+
     def set_value(attr_name, value)
       get_bindable_attr(attr_name).value = value
     end
@@ -101,7 +114,7 @@ module Ducktape
     end
 
     def get_bindable_attr(name)
-      raise AttributeNotDefinedError.new(self.class, name.to_s) unless self.class.metadata(name)
+      raise AttributeNotDefinedError.new(self.class, name.to_s) unless bindable_attr?(name)
       bindable_attrs[name.to_s] ||= BindableAttribute.new(self, name)
     end
   end

data/lib/ducktape/bindable_attribute.rb

@@ -1,5 +1,3 @@
-autoload :Set, 'set'
-
 module Ducktape
 
   class InvalidAttributeValueError < StandardError
@@ -12,115 +10,89 @@ module Ducktape
 
     include Hookable
 
-    attr_reader :owner    # Bindable
-    attr_reader :name     # String
-    attr_reader :source   # BindingSource
-    attr_reader :value    # Object
-
-    #attr_reader :targets # Hash{ BindableAttribute => BindingSource }
-
-    #def_hook :on_changed
+    attr_reader :owner,         # Bindable
+                :name,          # String
+                :value          # Object
+                #:source        # Link - link between source and target
 
     def initialize(owner, name)
-      @owner, @name, @source, @targets = owner, name.to_s, nil, {}
+      @owner, @name, = owner, name.to_s
+      @source = nil
       reset_value
     end
 
-    def metadata
-      @owner.class.metadata(@name)
+    def binding_source
+      return unless @source
+      @source.binding_source
     end
 
     def has_source?
-      !@source.nil?
+      !!@source
     end
 
-    def value=(value)
-      set_value(value)
+    def metadata
+      @owner.send(:metadata, @name)
     end
 
-    #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
+    #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
+      src.unbind
+      reset_value if reset
+      src.binding_source
     end
 
     def reset_value
       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 #----------------------------------------------------------------
 
-    attr_reader :targets
+    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 }
 
-    def set_value(value, exclusions = Set.new)
-      return if exclusions.include? self
-      exclusions << self
+        unless @source.forward?
+          @source.update_source
+          return @value #value didn't change
+        end
 
-      if value.is_a? BindingSource
-        attach_source(value) #attach new binding source
-        exclusions << @source.source #update value
-        value = @source.source.value #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
+      return @value if value.equal?(@original_value) || value == @original_value # untransformed value is the same?
 
-        old_value.remove_hook(:on_changed, method(:hookable_value_changed)) if old_value.is_a?(Hookable)
-        @value.on_changed(method(:hookable_value_changed)) if @value.is_a?(Hookable)
+      original_value = value
 
-        call_hooks(:on_changed, owner, attribute: name.dup, value: @value, old_value: old_value)
-      end
+      # transform value
+      m = metadata
+      value = m.coerce(owner, value)
+      raise InvalidAttributeValueError.new(@name, value) unless m.validate(value)
 
-      propagate_value(exclusions)
-      @value
-    end
+      return @value if value.equal?(@value) || value == @value # transformed value is the same?
 
-    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 attach_source(source)
-      detach_source
-      @source = source
-      source.source.send(:targets)[self] = source
-      nil
-    end
+      #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)
 
-    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.update_source if @source && @source.reverse?
 
-    def propagate_value(exclusions)
-      targets_to_propagate.each { |target| target.send(:set_value, value, exclusions) }
-      nil
+      @value
     end
 
-    def hookable_value_changed(*_)
-      call_hooks('on_changed', owner, attribute: name, value: @value)
-      nil
+    def convert(value)
+      value
     end
   end
 end

data/lib/ducktape/bindable_attribute_metadata.rb

@@ -36,7 +36,7 @@ module Ducktape
     end
 
     def default
-      @default.respond_to?('call') ? @default.call : @default
+      @default.respond_to?(:call) ? @default.call : @default
     end
 
     def validation(*options, &block)
@@ -47,9 +47,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.respond_to?('call') && 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/binding_source.rb

@@ -1,21 +1,34 @@
 module Ducktape
   class BindingSource
-    PROPAGATE_TO_SOURCE  = [:reverse, :both].freeze
-    PROPAGATE_TO_TARGETS = [:forward, :both].freeze
+    PROPAGATE_TO_TARGET = [:forward, :both].freeze
+    PROPAGATE_TO_SOURCE = [:reverse, :both].freeze
 
-    attr_reader :source # BindableAttribute
-    attr_accessor :mode # :forward, :reverse, :both
+    attr_reader :source,   # Bindable | Object
+                :path,     # String | Symbol
+                :mode,     # :forward, :reverse, :both
+                :converter # Converter
 
-    def initialize(source, source_attr, mode = :both)
-      set_source(source, source_attr)
-      @mode = mode
+    def initialize(source, path, mode = :both, converter = Converter)
+      @source, @path, @mode = source, path, mode
+      @converter = make_converter(converter)
     end
 
-    private
+    def forward?
+      PROPAGATE_TO_TARGET.include?(@mode)
+    end
 
-    #TODO: notify source/target of change
-    def set_source(source, source_attr)
-      @source = source.send(:get_bindable_attr, source_attr)
+    def reverse?
+      PROPAGATE_TO_SOURCE.include?(@mode)
+    end
+
+    private
+    def make_converter(c)
+      case c
+        when nil then Converter
+        when Class then (c.respond_to?(:convert) && c.respond_to?(:revert)) ? c : c.new
+        when Proc, Method, Array then Converter.new(*c)
+        else c
+      end
     end
   end
 end

data/lib/ducktape/converter.rb

@@ -0,0 +1,23 @@
+module Ducktape
+  class Converter
+    def initialize(convert = ->(v){v}, revert = nil)
+      @cnv, @rev = convert, revert || convert
+    end
+
+    def convert(value)
+      @cnv.(value)
+    end
+
+    def revert(value)
+      @rev.(value)
+    end
+
+    def self.convert(value)
+      value
+    end
+
+    def self.revert(value)
+      value
+    end
+  end
+end

data/lib/ducktape/expression/binary_op_exp.rb

@@ -0,0 +1,44 @@
+module Ducktape
+  module Expression
+    module BinaryOpExp
+      attr_reader :left, :right
+      attr_reader :owner
+
+      def initialize(left, right)
+        @left, @right = left, right
+      end
+
+      def owner=(o)
+        @owner, left.owner, right.owner = [o]*3
+      end
+
+      def bind(src, type, qual = nil, root = src)
+        unbind
+        lsrc = left.bind(src, :path, qual, root)
+        right.bind(lsrc, type, self.class, root)
+      end
+
+      def unbind
+        left.unbind
+        right.unbind
+        nil
+      end
+
+      def rightmost
+        @right.rightmost
+      end
+
+      def unparse
+        "#{left.unparse}#{self.class.instance_variable_get(:@op)}#{right.unparse}"
+      end
+
+      def value
+        right.value
+      end
+
+      def value=(v)
+        right.value = v
+      end
+    end
+  end
+end

data/lib/ducktape/expression/binding_parser.rb

@@ -0,0 +1,50 @@
+module Ducktape
+  module Expression
+    class UnboundError < StandardError; end
+
+    class BindingParser < Whittle::Parser
+      %w':: . , [ ]'.each { |op| rule(op) }
+
+      rule(number: /[0-9]+/).as { |v| IntegerExp.new(Integer(v)) }
+      rule(id:     /[a-zA-Z_]\w*/).as { |v| IdentifierExp.new(v) }
+      rule(symbol: /:[a-zA-Z_]\w*/).as { |v| SymbolExp.new(v[1,v.length].to_sym) }
+
+      rule(:qual) do |r|
+        r[:indexer, '::', :expr].as { |l, _, r| QualifiedExp.new(l, r) }
+        r[:id,      '::', :expr].as { |l, _, r| QualifiedExp.new(l, r) }
+      end
+
+      rule(:property) do |r|
+        r[:indexer, '.', :expr].as { |l, _, r| PropertyExp.new(l, r) }
+        r[:id,      '.', :expr].as { |l, _, r| PropertyExp.new(l, r) }
+      end
+
+      rule(:params) do |r|
+        r[:params, ',', :expr].as   { |params, _, v| params << v }
+        r[:params, ',', :symbol].as { |params, _, v| params << v }
+        r[:params, ',', :number].as { |params, _, v| params << v }
+        r[:expr].as                 { |v| [v] }
+        r[:symbol].as               { |v| [v] }
+        r[:number].as               { |v| [v] }
+      end
+
+      rule(:indexer) do |r|
+        r[:indexer, '[', :params, ']'].as { |l, _, r, _| IndexerExp.new(l, r) }
+        r[:id,      '[', :params, ']'].as { |l, _, r, _| IndexerExp.new(l, r) }
+      end
+
+      rule(:expr) do |r|
+        r[:qual]
+        r[:property]
+        r[:indexer]
+        r[:id]
+      end
+
+      start :expr
+
+      def self.parse(input, options = {})
+        new.parse(input.to_s, options)
+      end
+    end
+  end
+end

data/lib/ducktape/expression/identifier_exp.rb

@@ -0,0 +1,96 @@
+module Ducktape
+  module Expression
+    class IdentifierExp
+      include LiteralExp
+      include Ref #WeakReference
+
+      def bind(src, type, qual = nil, _ = src)
+        unbind
+        @source, @type, @qual = WeakReference.new(src), type, qual
+
+        case
+          when src.is_a?(Bindable) && src.bindable_attr?(literal) then src.on_changed(literal, self)
+          when src.is_a?(Hookable) then src.on_changed(self)
+        end
+
+        value
+      end
+
+      def unbind
+        return unless @source
+        src = @source.object
+        return @source, @type, @qual = nil unless src
+
+        case
+          when src.is_a?(Bindable) && src.bindable_attr?(literal) then src.unhook_on_changed(literal, self)
+          when src.is_a?(Hookable) then src.remove_hook(:on_changed, self)
+        end
+
+        @source, @type, @qual = nil
+      end
+
+      def call(parms)
+        return unless parms[:attribute].to_s == literal.to_s
+        owner.send("#{@type}_changed")
+        nil
+      end
+
+      def rightmost
+        self
+      end
+
+      def unparse
+        literal
+      end
+
+      def value
+        src = source
+        case @qual
+          when QualifiedExp then src.const_get(literal)
+          when PropertyExp  then src.public_send(literal)
+          else is_constant?(src) ? src.const_get(literal) : src.public_send(literal)
+        end
+      end
+
+      def value=(value)
+        src = source
+        return unless @type == :value
+
+        case @qual
+          when QualifiedExp then src.const_set(literal, value)
+          when PropertyExp then property_set(src, value)
+          else is_constant?(src) ? src.const_set(literal, value) : property_set(src, value)
+        end
+
+        nil
+      end
+
+      protected
+      def source
+        raise UnboundError unless @source
+        src = @source.object
+        raise UnboundError unless src
+        src
+      end
+
+      private
+      def is_constant?(src)
+        literal =~ /^[A-Z]/ && # starts with capital?
+        src.respond_to?(:const_defined?) && # source can check for constants (Class, Module)?
+        src.const_defined?(literal) # check to see if constant exists
+      end
+
+      def property_set(src, value)
+        case
+          when src.is_a?(Bindable) && src.bindable_attr?(literal)
+            src.send(:get_bindable_attr, literal).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)
+            src.public_send(literal, value)
+          else nil # nothing to do
+        end
+      end
+    end
+  end
+end

data/lib/ducktape/expression/indexer_exp.rb

@@ -0,0 +1,74 @@
+module Ducktape
+  module Expression
+    class IndexerExp # left[right+]
+      include BinaryOpExp
+      include Ref
+
+      alias_method :params, :right
+
+      def bind(src, type, qual = nil, root = src)
+        unbind
+        src = left.bind(src, :path, qual, root)
+        @source = WeakReference.new(src)
+        @type = type
+        params.each { |param| param.bind(root, :path) }
+
+        src.on_store(self) if src.is_a?(Hookable) && src.respond_to?(:on_store) #convention hook for []=
+
+        value
+      end
+
+      def unbind
+        params.each { |param| param.unbind }
+
+        return unless @source
+        src = @source.object
+        return @source, @type, @qual = nil unless src
+
+        src = source
+        src.remove_hook(:on_store, self) if src.is_a?(Hookable) && src.respond_to?(:on_store)
+        nil
+      end
+
+      def call(parms)
+        parms = parms.args.dup
+        parms.pop
+        return unless parms == params_values
+        owner.send("#{@type}_changed")
+      end
+
+      def owner=(o)
+        @owner, left.owner = o, o
+        params.each { |param| param.owner = o }
+      end
+
+      def rightmost
+        self
+      end
+
+      def unparse
+        "#{left.unparse}[#{params.map(&:unparse).join(',')}]"
+      end
+
+      def value
+        source[*params_values]
+      end
+
+      def value=(v)
+        source[*params_values] = v
+      end
+
+      protected
+      def source
+        raise UnboundError unless @source
+        src = @source.object
+        raise UnboundError unless src
+        src
+      end
+
+      def params_values
+        params.map { |param| param.value }
+      end
+    end
+  end
+end

data/lib/ducktape/expression/literal_exp.rb

@@ -0,0 +1,34 @@
+module Ducktape
+  module Expression
+    module LiteralExp
+      attr_reader :literal
+      attr_accessor :owner
+
+      def initialize(literal)
+        @literal = literal
+        @literal.freeze
+      end
+
+      def bind(_, _) end
+      def unbind; end
+
+      def rightmost
+        nil
+      end
+
+      def unparse
+        literal.inspect
+      end
+
+      alias_method :value, :literal
+    end
+
+    class IntegerExp
+      include LiteralExp
+    end
+
+    class SymbolExp
+      include LiteralExp
+    end
+  end
+end

data/lib/ducktape/expression/property_exp.rb

@@ -0,0 +1,8 @@
+module Ducktape
+  module Expression
+    class PropertyExp #a.b
+      include BinaryOpExp
+      @op = '.'
+    end
+  end
+end

data/lib/ducktape/expression/qualified_exp.rb

@@ -0,0 +1,8 @@
+module Ducktape
+  module Expression
+    class QualifiedExp #A::B
+      include BinaryOpExp
+      @op = '::'
+    end
+  end
+end

data/lib/ducktape/link.rb

@@ -0,0 +1,101 @@
+module Ducktape
+  class Link
+    include Ref #WeakReference
+
+    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
+                  :converter,  # Method
+                  :mode        # :forward, :reverse, :both
+
+    attr_reader :binding_source
+
+    def initialize(binding_source, target)
+      @binding_source = binding_source
+      @source         = WeakReference.new(binding_source.source)
+      @expression     = Expression::BindingParser.parse(binding_source.path)
+      @target         = WeakReference.new(target)
+      @converter      = binding_source.converter
+      @mode           = binding_source.mode
+
+      @expression.owner = self
+    end
+    
+    def broken?
+      !(@source && @target && @source.object && @target.object)
+    end
+
+    def forward?
+      BindingSource::PROPAGATE_TO_TARGET.include?(@mode)
+    end
+
+    def reverse?
+      BindingSource::PROPAGATE_TO_SOURCE.include?(@mode)
+    end
+
+    def bind
+      @expression.bind(@source.object, :value)
+      nil
+    end
+
+    def unbind
+      @expression.unbind
+      nil
+    end
+
+    def update_source
+      assert_mode :set, :source, :reverse
+      @expression.value = target_value
+    end
+
+    def update_target
+      assert_mode :set, :target, :forward
+      @target.object.value = source_value
+    end
+
+    def source_value
+      assert_mode :get, :source, :forward
+      @converter.convert(@expression.value)
+    end
+
+    def target_value
+      assert_mode :get, :target, :reverse
+      @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 value_changed
+      return unless forward?
+      update_target
+      nil
+    end
+  end
+end

data/lib/ducktape/version.rb

@@ -3,5 +3,5 @@
 # represented by a major version number increase.
 
 module Ducktape
-  VERSION = '0.3.3'.freeze
+  VERSION = '0.4.0'.freeze
 end

data/lib/ducktape.rb

@@ -1,11 +1,22 @@
 %w'
   set
   facets/ostruct
+  ref
+  whittle
 '.each { |f| require f }
 
 %w'
   version
   hookable
+  expression/literal_exp
+  expression/binary_op_exp
+  expression/identifier_exp
+  expression/indexer_exp
+  expression/property_exp
+  expression/qualified_exp
+  expression/binding_parser
+  converter
+  link
   binding_source
   bindable_attribute_metadata
   bindable_attribute

data/lib/ext/def_hookable.rb

@@ -15,20 +15,10 @@ module Ducktape
   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
-
+    return obj if obj.is_a?(Hookable)
+    m = obj.class.ancestors.each { |c| v = @hookable_types[c]; break v if v }
+    return obj unless m
+    (class << obj; include Hookable; self end).make_hooks(m)
     obj
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ducktape
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.0
 platform: ruby
 authors:
 - SilverPhoenix99
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-08 00:00:00.000000000 Z
+date: 2013-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: facets
@@ -25,6 +25,48 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '2.9'
+- !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'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Truly outrageous bindable attributes
 email:
 - silver.phoenix99@gmail.com
@@ -37,29 +79,54 @@ files:
 - lib/ducktape/bindable_attribute.rb
 - lib/ducktape/bindable_attribute_metadata.rb
 - lib/ducktape/binding_source.rb
+- lib/ducktape/converter.rb
+- lib/ducktape/expression/binary_op_exp.rb
+- lib/ducktape/expression/binding_parser.rb
+- lib/ducktape/expression/identifier_exp.rb
+- lib/ducktape/expression/indexer_exp.rb
+- lib/ducktape/expression/literal_exp.rb
+- lib/ducktape/expression/property_exp.rb
+- lib/ducktape/expression/qualified_exp.rb
 - lib/ducktape/ext/array.rb
 - lib/ducktape/ext/hash.rb
 - lib/ducktape/ext/string.rb
 - lib/ducktape/hookable.rb
+- lib/ducktape/link.rb
 - lib/ducktape/version.rb
 - lib/ducktape.rb
 - lib/ext/def_hookable.rb
 - README.md
 homepage: https://github.com/SilverPhoenix99/ducktape
-licenses: []
+licenses:
+- MIT
 metadata: {}
-post_install_message: 
+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
+
+    If you find any bugs, please report them on
+      https://github.com/SilverPhoenix99/ducktape/issues
+
+  +----------------------------------------------------------------------------+
 rdoc_options: []
 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: []
@@ -69,4 +136,3 @@ signing_key:
 specification_version: 4
 summary: Truly outrageous bindable attributes
 test_files: []
-has_rdoc: