wyngle-ripple 0.1.0

data/lib/ripple/associations/one.rb

@@ -0,0 +1,20 @@
+require 'ripple/associations/instantiators'
+
+module Ripple
+  module Associations
+    module One
+      include Instantiators
+
+      def to_a
+        [self]
+      end
+
+      protected
+      def instantiate_target(instantiator, attrs={})
+        @target = klass.send(instantiator, attrs)
+        loaded
+        @target
+      end
+    end
+  end
+end

data/lib/ripple/associations/one_embedded_proxy.rb

@@ -0,0 +1,35 @@
+require 'ripple/associations/proxy'
+require 'ripple/associations/one'
+require 'ripple/associations/embedded'
+
+module Ripple
+  module Associations
+    class OneEmbeddedProxy < Proxy
+      include One
+      include Embedded
+
+      def replace(doc)
+        @reflection.verify_type!(doc, @owner)
+        @_doc = doc.respond_to?(:attributes_for_persistence) ? doc.attributes_for_persistence : doc
+        assign_references(doc)
+
+        if doc.is_a?(@reflection.klass)
+          loaded
+          @target = doc
+        else
+          reset
+        end
+
+        @_doc
+      end
+
+      protected
+      def find_target
+        return nil unless @_doc
+        klass.instantiate(@_doc).tap do |doc|
+          assign_references(doc)
+        end
+      end
+    end
+  end
+end

data/lib/ripple/associations/one_key_proxy.rb

@@ -0,0 +1,58 @@
+require 'ripple/associations/proxy'
+require 'ripple/associations/one'
+
+module Ripple
+  module Associations
+    class OneKeyProxy < Proxy
+      include One
+
+      def replace(doc)
+        @reflection.verify_type!(doc, owner)
+
+        reset_previous_target_key_delegate
+        assign_new_target_key_delegate(doc)
+
+        loaded
+        @target = doc
+      end
+
+      def find_target
+        klass.find(owner.key)
+      end
+
+      protected
+      def instantiate_target(instantiator, attrs={})
+        @target = super
+        @target.key = owner.key
+        @target
+      end
+
+      private
+      def reset_previous_target_key_delegate
+        @target.key_delegate = @target if @target
+      end
+
+      def assign_new_target_key_delegate(doc)
+        doc.class.send(:include, Ripple::Associations::KeyDelegator) unless doc.class.include?(Ripple::Associations::KeyDelegator)
+        owner.key_delegate = doc.key_delegate = owner
+      end
+
+    end
+
+    module KeyDelegator
+      attr_accessor :key_delegate
+
+      def key_delegate
+        @key_delegate || self
+      end
+
+      def key
+        self === key_delegate ? super : key_delegate.key
+      end
+
+      def key=(value)
+        self === key_delegate ? super(value) : key_delegate.key = value
+      end
+    end
+  end
+end

data/lib/ripple/associations/one_linked_proxy.rb

@@ -0,0 +1,26 @@
+require 'ripple/associations/proxy'
+require 'ripple/associations/one'
+require 'ripple/associations/linked'
+
+module Ripple
+  module Associations
+    class OneLinkedProxy < Proxy
+      include One
+      include Linked
+
+      def key
+        keys.first
+      end
+
+      protected
+      def find_target
+        return nil if links.blank?
+
+        robjs = robjects
+        return nil if robjs.blank?
+
+        klass.send(:instantiate, robjs.first)
+      end
+    end
+  end
+end

data/lib/ripple/associations/one_stored_key_proxy.rb

@@ -0,0 +1,43 @@
+require 'ripple/associations/proxy'
+require 'ripple/associations/one'
+
+module Ripple
+  module Associations
+    class OneStoredKeyProxy < Proxy
+      include One
+
+      def replace(value)
+        @reflection.verify_type!(value, owner)
+
+        if value
+          assign_key(value.key)
+        else
+          assign_key(nil)
+        end
+
+        @target = value
+        loaded
+      end
+
+      protected
+
+      def key
+        @owner.send(key_name)
+      end
+
+      def assign_key(value)
+        @owner.send("#{key_name}=", value)
+      end
+
+      def key_name
+        "#{@reflection.name}_key"
+      end
+
+      def find_target
+        return nil if key.blank?
+
+        klass.find(key)
+      end
+    end
+  end
+end

data/lib/ripple/associations/proxy.rb

@@ -0,0 +1,118 @@
+require 'ripple/associations'
+
+module Ripple
+  module Associations
+    class Proxy
+      alias :proxy_respond_to? :respond_to?
+      alias :proxy_extend :extend
+
+      instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/ }
+
+      attr_reader :owner, :reflection, :target
+
+      alias :proxy_owner :owner
+      alias :proxy_target :target
+      alias :proxy_reflection :reflection
+
+      delegate :klass, :to => :proxy_reflection
+      delegate :options, :to => :proxy_reflection
+      delegate :collection, :to => :klass
+
+      def initialize(owner, reflection)
+        @owner, @reflection = owner, reflection
+        Array.wrap(reflection.options[:extend]).each { |ext| proxy_extend(ext) }
+        reset
+      end
+
+      def inspect
+        load_target
+        target.inspect
+      end
+
+      def loaded?
+        @loaded
+      end
+
+      def loaded
+        @loaded = true
+      end
+
+      def nil?
+        load_target
+        target.nil?
+      end
+
+      def blank?
+        load_target
+        target.blank?
+      end
+
+      def present?
+        load_target
+        target.present?
+      end
+
+      def reload
+        reset
+        load_target
+        self unless target.nil?
+      end
+
+      def replace(v)
+        raise NotImplementedError
+      end
+
+      def reset
+        @loaded = false
+        @target = nil
+      end
+
+      def respond_to?(*args)
+        proxy_respond_to?(*args) || (load_target && target.respond_to?(*args))
+      end
+
+      def send(method, *args, &block)
+        if proxy_respond_to?(method)
+          super
+        else
+          load_target
+          target.send(method, *args, &block)
+        end
+      end
+
+      def ===(other)
+        load_target
+        other === target
+      end
+
+      def loaded_documents
+        loaded? ? Array.wrap(target) : []
+      end
+
+      def has_changed_documents?
+        loaded_documents.any? { |doc| doc.changed? }
+      end
+
+      protected
+      def method_missing(method, *args, &block)
+        load_target
+
+        if block_given?
+          target.send(method, *args)  { |*block_args| block.call(*block_args) }
+        else
+          target.send(method, *args)
+        end
+      end
+
+      def load_target
+        @target = find_target unless loaded?
+        loaded
+        @target
+      end
+
+      def find_target
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/ripple/attribute_methods.rb

@@ -0,0 +1,132 @@
+require 'ripple/translation'
+require 'active_support/concern'
+require 'active_model/attribute_methods'
+require 'active_model/mass_assignment_security'
+require 'ripple/attribute_methods/read'
+require 'ripple/attribute_methods/write'
+require 'ripple/attribute_methods/query'
+require 'ripple/attribute_methods/dirty'
+
+module Ripple
+  # Makes ActiveRecord-like attribute accessors based on your
+  # {Document}'s properties.
+  module AttributeMethods
+    include Translation
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeMethods
+
+    included do
+      include Read
+      include Write
+      include Query
+      include Dirty
+      include ActiveModel::MassAssignmentSecurity
+
+      attr_protected :key
+    end
+
+    module ClassMethods
+      # @private
+      def property(key, type, options={})
+        super.tap do
+          undefine_attribute_methods
+          define_attribute_methods
+        end
+      end
+
+      # Generates all the attribute-related methods for properties defined
+      # on the document, including accessors, mutators and query methods.
+      def define_attribute_methods
+        super(properties.keys)
+      end
+
+      protected
+
+      def instance_method_already_implemented?(method_name)
+        method_defined?(method_name)
+      end
+    end
+
+    # A copy of the values of all attributes in the Document. The result
+    # is not memoized, so use sparingly.  This does not include associated objects,
+    # nor embedded documents.
+    # @return [Hash] all document attributes, by key
+    def attributes
+      raw_attributes.reject { |k, v| !respond_to?(k) }
+    end
+
+    def raw_attributes
+      self.class.properties.values.inject(@attributes.with_indifferent_access) do |hash, prop|
+        hash[prop.key] = attribute(prop.key)
+        hash
+      end
+    end
+
+    # Mass assign the document's attributes.
+    # @param [Hash] attrs the attributes to assign
+    # @param [Hash] options assignment options
+    def assign_attributes(attrs, options={})
+      raise ArgumentError, t('attribute_hash') unless(Hash === attrs)
+
+      unless options[:without_protection]
+        if method(:sanitize_for_mass_assignment).arity == 1 # ActiveModel 3.0
+          if options[:as]
+            raise ArgumentError, t('mass_assignment_roles_unsupported')
+          end
+          attrs = sanitize_for_mass_assignment(attrs)
+        else
+          mass_assignment_role = (options[:as] || :default)
+          attrs = sanitize_for_mass_assignment(attrs, mass_assignment_role)
+        end
+      end
+
+      attrs.each do |k,v|
+        if respond_to?("#{k}=")
+          __send__("#{k}=",v)
+        else
+          raise ArgumentError, t('undefined_property', :prop => k, :class => self.class.name)
+        end
+      end
+    end
+
+    # Mass assign the document's attributes.
+    # @param [Hash] attrs the attributes to assign
+    def attributes=(attrs)
+      assign_attributes(attrs)
+    end
+
+    # @private
+    def raw_attributes=(attrs)
+      raise ArgumentError, t('attribute_hash') unless Hash === attrs
+      attrs.each do |k,v|
+        next if k.to_sym == :key
+        if respond_to?("#{k}=")
+          __send__("#{k}=",v)
+        else
+          __send__(:attribute=,k,v)
+        end
+      end
+    end
+
+    # @private
+    def initialize(attrs={}, options={})
+      super()
+      @attributes = attributes_from_property_defaults
+      assign_attributes(attrs, options)
+      yield self if block_given?
+    end
+
+    protected
+    # @private
+    def attribute_method?(attr_name)
+      self.class.properties.include?(attr_name)
+    end
+
+    def attributes_from_property_defaults
+      self.class.properties.values.inject({}) do |hash, prop|
+        hash[prop.key] = prop.default unless prop.default.nil?
+        hash
+      end.with_indifferent_access
+    end
+  end
+end

data/lib/ripple/attribute_methods/dirty.rb

@@ -0,0 +1,59 @@
+require 'active_support/concern'
+require 'active_model/dirty'
+
+module Ripple
+  module AttributeMethods
+    module Dirty
+      extend ActiveSupport::Concern
+      include ActiveModel::Dirty
+
+      module ClassMethods
+        # @private
+        def instantiate(robject)
+          super(robject).tap do |o|
+            o.changed_attributes.clear
+          end
+        end
+      end
+
+      # @private
+      def really_save(*args)
+        if result = super
+          @previously_changed = changes
+          changed_attributes.clear
+        end
+        result
+      end
+
+      # @private
+      def reload
+        super.tap do
+          changed_attributes.clear
+        end
+      end
+
+      # @private
+      def initialize(*args)
+        super
+        changed_attributes.clear
+      end
+
+      # Determines if the document has any chnages.
+      # @return [Boolean] true if this document, or any of its embedded
+      # documents at any level, have changed.
+      def changed?
+        super || self.class.embedded_associations.any? do |association|
+          send(association.name).has_changed_documents?
+        end
+      end
+
+      private
+      def attribute=(attr_name, value)
+        if self.class.properties.include?(attr_name.to_sym) && @attributes[attr_name] != value
+          attribute_will_change!(attr_name)
+        end
+        super
+      end
+    end
+  end
+end