ripple 0.7.0 → 0.7.1

data/lib/ripple.rb

@@ -23,9 +23,25 @@ module Ripple
   extend ActiveSupport::Autoload
   include ActiveSupport::Configurable
 
+  # Primary models
   autoload :EmbeddedDocument
   autoload :Document
+
+  # Model mixins and support classes
+  autoload :Association, "ripple/associations"
+  autoload :Associations
+  autoload :AttributeMethods
+  autoload :Callbacks
+  autoload :Conversion
+  autoload :Properties
+  autoload :Property, "ripple/properties"
+  autoload :Timestamps
+  autoload :Validations
+
+  # Exceptions
   autoload :PropertyTypeMismatch
+
+  # Utilities
   autoload :Translation
 
   DEFAULT_CONFIG = {}
@@ -46,7 +62,7 @@ module Ripple
       self.client = nil
       super
     end
-    
+
     def load_config(config_file)
       self.config = YAML.load_file(File.expand_path config_file).with_indifferent_access[:ripple]
     end

data/lib/ripple/associations.rb

@@ -0,0 +1,157 @@
+# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+require 'ripple'
+
+module Ripple
+  module Associations
+    extend ActiveSupport::Concern
+    extend ActiveSupport::Autoload
+
+    autoload :Proxy
+    autoload :One
+    autoload :Many
+    autoload :Embedded
+    autoload :Instantiators
+    autoload :OneEmbeddedProxy
+    autoload :ManyEmbeddedProxy
+
+    module ClassMethods
+      # @private
+      def inherited(subclass)
+        super
+        subclass.associations.merge!(associations)
+      end
+
+      # Associations defined on the document
+      def associations
+        @associations ||= {}.with_indifferent_access
+      end
+
+      # Associations of embedded documents
+      def embedded_associations
+        associations.values.select(&:embeddable?)
+      end
+
+      # Creates a singular association
+      def one(name, options={})
+        create_association(:one, name, options)
+      end
+
+      # Creates a plural association
+      def many(name, options={})
+        create_association(:many, name, options)
+      end
+
+      private
+      def create_association(type, name, options={})
+        association = associations[name] = Association.new(type, name, options)
+
+        define_method(name) do
+          get_proxy(association)
+        end
+
+        define_method("#{name}=") do |value|
+          get_proxy(association).replace(value)
+          value
+        end
+
+        if association.one?
+          define_method("#{name}?") do
+            get_proxy(association).present?
+          end
+        end
+      end
+    end
+
+    module InstanceMethods
+      # @private
+      def get_proxy(association)
+        unless proxy = instance_variable_get(association.ivar)
+          proxy = association.proxy_class.new(self, association)
+          instance_variable_set(association.ivar, proxy)
+        end
+        proxy
+      end
+
+      # Adds embedded documents to the attributes
+      # @private
+      def attributes_for_persistence
+        self.class.embedded_associations.inject(super) do |attrs, association|
+          if documents = instance_variable_get(association.ivar)
+            attrs[association.name] = documents.is_a?(Array) ? documents.map(&:attributes_for_persistence) : documents.attributes_for_persistence
+          end
+          attrs
+        end
+      end
+    end
+  end
+
+  class Association
+    attr_reader :type, :name, :options
+
+    # association options :using, :class_name, :class, :extend,
+    # options that may be added :validate
+
+    def initialize(type, name, options={})
+      @type, @name, @options = type, name, options.to_options
+    end
+
+    def class_name
+      @class_name ||= case
+                      when @options[:class_name]
+                        @options[:class_name]
+                      when @options[:class]
+                        @options[:class].to_s
+                      when many?
+                        @name.to_s.classify
+                      else
+                        @name.to_s.camelize
+                      end
+    end
+
+    def klass
+      @klass ||= options[:class] || class_name.constantize
+    end
+
+    def many?
+      @type == :many
+    end
+
+    def one?
+      @type == :one
+    end
+
+    def embeddable?
+      klass.embeddable?
+    end
+
+    def polymorphic?
+      false
+    end
+
+    def ivar
+      "@_#{name}"
+    end
+
+    def proxy_class
+      @proxy_class ||= proxy_class_name.constantize
+    end
+
+    def proxy_class_name
+      @using   ||= options[:using] || (embeddable? ? :embedded : :link)
+      klass_name = (many? ? 'Many' : 'One') + @using.to_s.camelize + ('Polymorphic' if polymorphic?).to_s + 'Proxy'
+      "Ripple::Associations::#{klass_name}"
+    end
+  end
+end

data/lib/ripple/associations/embedded.rb

@@ -0,0 +1,42 @@
+# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+require 'ripple'
+
+module Ripple
+  module Associations
+    module Embedded
+
+      def initialize(*args)
+        super
+        owner.class.validates reflection.name, :associated => true
+      end
+
+      protected
+
+      def assign_references(docs)
+        Array(docs).each do |doc|
+          next unless doc.respond_to?(:_parent_document=)
+          doc._parent_document = owner
+        end
+      end
+
+      def instantiate_target(*args)
+        doc = super
+        assign_references(doc)
+        doc
+      end
+
+    end
+  end
+end

data/lib/ripple/associations/instantiators.rb

@@ -0,0 +1,39 @@
+# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+require 'ripple'
+
+module Ripple
+  module Associations
+    module Instantiators
+
+      def build(attrs={})
+        instantiate_target(:new, attrs)
+      end
+
+      def create(attrs={})
+        instantiate_target(:create, attrs)
+      end
+
+      def create!(attrs={})
+        instantiate_target(:create!, attrs)
+      end
+
+      protected
+      def instantiate_target
+        raise NotImplementedError
+      end
+
+    end
+  end
+end

data/lib/ripple/{document/associations → associations}/linked.rb

@@ -14,19 +14,17 @@
 require 'ripple'
 
 module Ripple
-  module Document
-    module Associations
-      module Linked
+  module Associations
+    module Linked
 
-        def create(attrs={})
-          instantiate_target(:create, attrs)
-        end
+      def create(attrs={})
+        instantiate_target(:create, attrs)
+      end
 
-        def create!(attrs={})
-          instantiate_target(:create!, attrs)
-        end
-        
+      def create!(attrs={})
+        instantiate_target(:create!, attrs)
       end
+
     end
   end
-end
+end

data/lib/ripple/{document/associations/one_embedded_proxy.rb → associations/many.rb}

@@ -14,28 +14,37 @@
 require 'ripple'
 
 module Ripple
-  module Document
-    module Associations
-      class OneEmbeddedProxy < Proxy
-        include One
-        include Embedded
-        
-        def replace(doc)
-          @_doc = doc.respond_to?(:attributes_for_persistence) ? doc.attributes_for_persistence : doc
-          assign_references(doc)
-          reset
-          @_doc
-        end
-        
+  module Associations
+    module Many
+      include Instantiators
+
+      def to_ary
+        load_target
+        Array === target ? target.to_ary : Array(target)
+      end
+
+      def count
+        load_target
+        target.size
+      end
+
+      def reset
+        super
+        @target = []
+      end
+
+      def <<
+          raise NotImplementedError
+      end
+      alias_method :push, :<<
+        alias_method :concat, :<<
+
         protected
-          def find_target
-            return nil unless @_doc
-            klass.instantiate(@_doc).tap do |doc|
-              assign_references(doc)
-            end
-          end
-        
+      def instantiate_target(instantiator, attrs={})
+        doc = klass.send(instantiator, attrs)
+        self << doc
+        doc
       end
     end
   end
-end
+end

data/lib/ripple/{document/associations/embedded.rb → associations/many_embedded_proxy.rb}

@@ -14,31 +14,34 @@
 require 'ripple'
 
 module Ripple
-  module Document
-    module Associations
-      module Embedded
-        
-        def initialize(*args)
-          super
-          owner.class.validates reflection.name, :associated => true
-        end
-        
-        protected
-          
-          def assign_references(docs)
-            Array(docs).each do |doc|
-              next unless doc.respond_to?(:_parent_document=)
-              doc._parent_document = owner
-            end
-          end
-          
-          def instantiate_target(*args)
-            doc = super
+  module Associations
+    class ManyEmbeddedProxy < Proxy
+      include Many
+      include Embedded
+
+      def <<(docs)
+        load_target
+        assign_references(docs)
+        @target += Array(docs)
+        self
+      end
+
+      def replace(docs)
+        @_docs = docs.map { |doc| attrs = doc.respond_to?(:attributes_for_persistence) ? doc.attributes_for_persistence : doc }
+        assign_references(docs)
+        reset
+        @_docs
+      end
+
+      protected
+      def find_target
+        (@_docs || []).map do |attrs|
+          klass.instantiate(attrs).tap do |doc|
             assign_references(doc)
-            doc
           end
-        
+        end
       end
+
     end
   end
-end
+end

data/lib/ripple/{embedded_document/conversion.rb → associations/one.rb}

@@ -14,20 +14,15 @@
 require 'ripple'
 
 module Ripple
-  module EmbeddedDocument
-    module Conversion
-      extend ActiveSupport::Concern
+  module Associations
+    module One
+      include Instantiators
 
-      module InstanceMethods
-        include ActiveModel::Conversion
-        
-        def to_key
-          new? ? nil : [key]
-        end
-
-        def to_param
-          key
-        end
+      protected
+      def instantiate_target(instantiator, attrs={})
+        @target = klass.send(instantiator, attrs)
+        loaded
+        @target
       end
     end
   end