ripple 0.7.0 → 0.7.1

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

@@ -14,28 +14,26 @@
 require 'ripple'
 
 module Ripple
-  module Document
-    module Associations
-      module Instantiators
-        
-        def build(attrs={})
-          instantiate_target(:new, attrs)
-        end
+  module Associations
+    class OneEmbeddedProxy < Proxy
+      include One
+      include Embedded
 
-        def create(attrs={})
-          instantiate_target(:create, attrs)
-        end
+      def replace(doc)
+        @_doc = doc.respond_to?(:attributes_for_persistence) ? doc.attributes_for_persistence : doc
+        assign_references(doc)
+        reset
+        @_doc
+      end
 
-        def create!(attrs={})
-          instantiate_target(:create!, attrs)
+      protected
+      def find_target
+        return nil unless @_doc
+        klass.instantiate(@_doc).tap do |doc|
+          assign_references(doc)
         end
-        
-        protected
-          def instantiate_target
-            raise NotImplementedError
-          end
-        
       end
+
     end
   end
-end
+end

data/lib/ripple/associations/proxy.rb

@@ -0,0 +1,123 @@
+# 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
+    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(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
+
+      protected
+      def method_missing(method, *args, &block)
+        if load_target
+          if block_given?
+            target.send(method, *args)  { |*block_args| block.call(*block_args) }
+          else
+            target.send(method, *args)
+          end
+        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,116 @@
+# 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
+  # Makes ActiveRecord-like attribute accessors based on your
+  # {Document}'s properties.
+  module AttributeMethods
+    extend ActiveSupport::Concern
+    extend ActiveSupport::Autoload
+    include ActiveModel::AttributeMethods
+
+    autoload :Read
+    autoload :Write
+    autoload :Query
+    autoload :Dirty
+
+    included do
+      include Read
+      include Write
+      include Query
+      include Dirty
+    end
+
+    module ClassMethods
+      # @private
+      def property(key, type, options={})
+        undefine_attribute_methods
+        super
+      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
+    end
+
+    module InstanceMethods
+      attr_accessor :key
+
+      # 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
+        self.class.properties.values.inject({}) do |hash, prop|
+          hash[prop.key] = attribute(prop.key)
+          hash
+        end.with_indifferent_access
+      end
+
+      # Mass assign the document's attributes.
+      # @param [Hash] attrs the attributes to assign
+      def 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
+
+      def key=(value)
+        @key = value.to_s
+      end
+
+      # @private
+      def initialize(attrs={})
+        super()
+        @attributes = attributes_from_property_defaults
+        self.attributes = attrs
+        yield self if block_given?
+      end
+
+      # @private
+      def method_missing(method, *args, &block)
+        self.class.define_attribute_methods
+        super
+      end
+
+      # @private
+      def respond_to?(*args)
+        self.class.define_attribute_methods
+        super
+      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 if prop.default
+          hash
+        end.with_indifferent_access
+      end
+    end
+  end
+end

data/lib/ripple/{document/attribute_methods/write.rb → attribute_methods/dirty.rb}

@@ -14,27 +14,37 @@
 require 'ripple'
 
 module Ripple
-  module Document
-    module AttributeMethods
-      module Write
-        extend ActiveSupport::Concern
+  module AttributeMethods
+    module Dirty
+      extend ActiveSupport::Concern
+      include ActiveModel::Dirty
 
-        included do
-          attribute_method_suffix "="
-        end
-        
-        def []=(attr_name, value)
-          __send__(:attribute=, attr_name, value)
+      # @private
+      def save
+        if result = super
+          changed_attributes.clear
         end
+        result
+      end
 
-        private
-        def attribute=(attr_name, value)
-          if prop = self.class.properties[attr_name]
-            value = prop.type_cast(value)
-          end
-          @attributes[attr_name] = value
+      # @private
+      def reload
+        returning super do
+          changed_attributes.clear
         end
       end
+
+      # @private
+      def initialize(attrs={})
+        super(attrs)
+        changed_attributes.clear
+      end
+
+      private
+      def attribute=(attr_name, value)
+        attribute_will_change!(attr_name)
+        super
+      end
     end
   end
 end

data/lib/ripple/attribute_methods/query.rb

@@ -0,0 +1,48 @@
+# 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 AttributeMethods
+    module Query
+      extend ActiveSupport::Concern
+
+      included do
+        attribute_method_suffix "?"
+      end
+
+      private
+      # Based on code from ActiveRecord
+      def attribute?(attr_name)
+        unless value = attribute(attr_name)
+          false
+        else
+          prop = self.class.properties[attr_name]
+          if prop.nil?
+            if Numeric === value || value !~ /[^0-9]/
+              !value.to_i.zero?
+            else
+              Boolean.ripple_cast(value) || value.present?
+            end
+          elsif prop.type <= Numeric
+            !value.zero?
+          else
+            value.present?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ripple/{document/attribute_methods → attribute_methods}/read.rb

@@ -14,26 +14,24 @@
 require 'ripple'
 
 module Ripple
-  module Document
-    module AttributeMethods
-      module Read
-        extend ActiveSupport::Concern
+  module AttributeMethods
+    module Read
+      extend ActiveSupport::Concern
 
-        included do
-          attribute_method_suffix ""
-        end
-        
-        def [](attr_name)
-          attribute(attr_name)
-        end
+      included do
+        attribute_method_suffix ""
+      end
+
+      def [](attr_name)
+        attribute(attr_name)
+      end
 
-        private
-        def attribute(attr_name)
-          if @attributes.include?(attr_name)
-            @attributes[attr_name]
-          else
-            nil
-          end
+      private
+      def attribute(attr_name)
+        if @attributes.include?(attr_name)
+          @attributes[attr_name]
+        else
+          nil
         end
       end
     end

data/lib/ripple/attribute_methods/write.rb

@@ -0,0 +1,38 @@
+# 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 AttributeMethods
+    module Write
+      extend ActiveSupport::Concern
+
+      included do
+        attribute_method_suffix "="
+      end
+
+      def []=(attr_name, value)
+        __send__(:attribute=, attr_name, value)
+      end
+
+      private
+      def attribute=(attr_name, value)
+        if prop = self.class.properties[attr_name]
+          value = prop.type_cast(value)
+        end
+        @attributes[attr_name] = value
+      end
+    end
+  end
+end