ocean-dynamo 0.5.0 → 0.5.1

data/lib/ocean-dynamo/active_record_stuff/collection_proxy.rb

@@ -1,11 +1,5 @@
-module OceanDynamo
-  module Associations
-    #
-    # This entire file shamelessly lifted from ActiveRecord, for compatibility
-    # reasons. OceanDynamo must implement the same query interface as ActiveRecord.
-    #
-    
-
+module OceanDynamo #:nodoc:
+  module Associations #:nodoc:
     #
     # Association proxies in OceanDynamo are middlemen between the object that
     # holds the association, known as the <tt>@owner</tt>, and the actual associated

data/lib/ocean-dynamo/active_record_stuff/has_and_belongs_to_many_association.rb

@@ -0,0 +1,57 @@
+module ActiveRecord #:nodoc:
+  # = Active Record Has And Belongs To Many Association
+  module Associations #:nodoc:
+    class HasAndBelongsToManyAssociation < CollectionAssociation #:nodoc:
+      attr_reader :join_table
+
+      def initialize(owner, reflection)
+        @join_table = Arel::Table.new(reflection.join_table)
+        super
+      end
+
+      def insert_record(record, validate = true, raise = false)
+        if record.new_record?
+          if raise
+            record.save!(:validate => validate)
+          else
+            return unless record.save(:validate => validate)
+          end
+        end
+
+        stmt = join_table.compile_insert(
+          join_table[reflection.foreign_key]             => own
+          er.id,
+          join_table[reflection.association_foreign_key] => record.id
+        )
+
+        owner.class.connection.insert stmt
+
+        record
+      end
+
+      private
+
+        def count_records
+          load_target.size
+        end
+
+        def delete_records(records, method)
+          relation  = join_table
+          condition = relation[reflection.foreign_key].eq(owner.id)
+
+          unless records == :all
+            condition = condition.and(
+              relation[reflection.association_foreign_key]
+                .in(records.map { |x| x.id }.compact)
+            )
+          end
+
+          owner.class.connection.delete(relation.where(condition).compile_delete)
+        end
+
+        def invertible_for?(record)
+          false
+        end
+    end
+  end
+end

data/lib/ocean-dynamo/active_record_stuff/has_many_association.rb

@@ -0,0 +1,132 @@
+module ActiveRecord #:nodoc:
+  # = Active Record Has Many Association
+  module Associations #:nodoc:
+    # This is the proxy that handles a has many association.
+    #
+    # If the association has a <tt>:through</tt> option further specialization
+    # is provided by its child HasManyThroughAssociation.
+    class HasManyAssociation < CollectionAssociation #:nodoc:
+
+      def handle_dependency
+        case options[:dependent]
+        when :restrict_with_exception
+          raise ActiveRecord::DeleteRestrictionError.new(reflection.name) unless empty?
+
+        when :restrict_with_error
+          unless empty?
+            record = klass.human_attribute_name(reflection.name).downcase
+            owner.errors.add(:base, :"restrict_dependent_destroy.many", record: record)
+            false
+          end
+
+        else
+          if options[:dependent] == :destroy
+            # No point in executing the counter update since we're going to destroy the parent anyway
+            load_target.each { |t| t.destroyed_by_association = reflection }
+            destroy_all
+          else
+            delete_all
+          end
+        end
+      end
+
+      def insert_record(record, validate = true, raise = false)
+        set_owner_attributes(record)
+
+        if raise
+          record.save!(:validate => validate)
+        else
+          record.save(:validate => validate)
+        end
+      end
+
+      private
+
+        # Returns the number of records in this collection.
+        #
+        # If the association has a counter cache it gets that value. Otherwise
+        # it will attempt to do a count via SQL, bounded to <tt>:limit</tt> if
+        # there's one. Some configuration options like :group make it impossible
+        # to do an SQL count, in those cases the array count will be used.
+        #
+        # That does not depend on whether the collection has already been loaded
+        # or not. The +size+ method is the one that takes the loaded flag into
+        # account and delegates to +count_records+ if needed.
+        #
+        # If the collection is empty the target is set to an empty array and
+        # the loaded flag is set to true as well.
+        def count_records
+          count = if has_cached_counter?
+            owner.send(:read_attribute, cached_counter_attribute_name)
+          else
+            scope.count
+          end
+
+          # If there's nothing in the database and @target has no new records
+          # we are certain the current target is an empty array. This is a
+          # documented side-effect of the method that may avoid an extra SELECT.
+          @target ||= [] and loaded! if count == 0
+
+          [association_scope.limit_value, count].compact.min
+        end
+
+        def has_cached_counter?(reflection = reflection)
+          owner.attribute_present?(cached_counter_attribute_name(reflection))
+        end
+
+        def cached_counter_attribute_name(reflection = reflection)
+          options[:counter_cache] || "#{reflection.name}_count"
+        end
+
+        def update_counter(difference, reflection = reflection)
+          if has_cached_counter?(reflection)
+            counter = cached_counter_attribute_name(reflection)
+            owner.class.update_counters(owner.id, counter => difference)
+            owner[counter] += difference
+            owner.changed_attributes.delete(counter) # eww
+          end
+        end
+
+        # This shit is nasty. We need to avoid the following situation:
+        #
+        #   * An associated record is deleted via record.destroy
+        #   * Hence the callbacks run, and they find a belongs_to on the record with a
+        #     :counter_cache options which points back at our owner. So they update the
+        #     counter cache.
+        #   * In which case, we must make sure to *not* update the counter cache, or else
+        #     it will be decremented twice.
+        #
+        # Hence this method.
+        def inverse_updates_counter_cache?(reflection = reflection)
+          counter_name = cached_counter_attribute_name(reflection)
+          reflection.klass.reflect_on_all_associations(:belongs_to).any? { |inverse_reflection|
+            inverse_reflection.counter_cache_column == counter_name
+          }
+        end
+
+        # Deletes the records according to the <tt>:dependent</tt> option.
+        def delete_records(records, method)
+          if method == :destroy
+            records.each { |r| r.destroy }
+            update_counter(-records.length) unless inverse_updates_counter_cache?
+          else
+            if records == :all
+              scope = self.scope
+            else
+              scope = self.scope.where(reflection.klass.primary_key => records)
+            end
+
+            if method == :delete_all
+              update_counter(-scope.delete_all)
+            else
+              update_counter(-scope.update_all(reflection.foreign_key => nil))
+            end
+          end
+        end
+
+        def foreign_key_present?
+          owner.attribute_present?(reflection.association_primary_key)
+        end
+    end
+  end
+end

data/lib/ocean-dynamo/active_record_stuff/reflection.rb

@@ -1,4 +1,4 @@
-module ActiveRecord
+module ActiveRecord #:nodoc:
   # = Active Record Reflection
   module Reflection # :nodoc:
     extend ActiveSupport::Concern
@@ -16,7 +16,7 @@ module ActiveRecord
     #
     # MacroReflection class has info for AggregateReflection and AssociationReflection
     # classes.
-    module ClassMethods
+    module ClassMethods #:nodoc:
       def create_reflection(macro, name, scope, options, active_record)
         case macro
         when :has_many, :belongs_to, :has_one, :has_and_belongs_to_many

data/lib/ocean-dynamo/active_record_stuff/relation.rb

@@ -1,6 +1,6 @@
-module ActiveRecord
+module ActiveRecord #:nodoc:
   # = Active Record Relation
-  class Relation
+  class Relation #:nodoc:
     JoinOperation = Struct.new(:relation, :join_class, :on)
 
     MULTI_VALUE_METHODS  = [:includes, :eager_load, :preload, :select, :group,

data/lib/ocean-dynamo/associations/association.rb

@@ -0,0 +1,158 @@
+module OceanDynamo
+  module Associations
+    #
+    # This is the root class of all Associations.
+    # The class structure is exactly like in ActiveRecord:
+    #
+    #   Association
+    #     CollectionAssociation
+    #       HasAndBelongsToManyAssociation
+    #       HasManyAssociation
+    #
+    # It should be noted, however, that the ActiveRecord documentation  
+    # is misleading: belongs_to and has_one no longer are implemented using
+    # proxies, even though the documentation and the source itself says it is.
+    # Furthermore, method_missing is no longer used at all, despite what the
+    # documentation and source comments say.
+    #
+    # In OceanDynamo, we have removed the unused classes and stripped away
+    # the SQL-specific features such as scopes. Neither do we implement counter
+    # caches. We have kept the same module and class structure for compatibility, 
+    # though.
+    #
+    class Association #:nodoc:
+
+      attr_reader :owner
+      attr_reader :reflection
+      attr_reader :target
+
+
+      #
+      # 
+      #
+      def initialize(owner, reflection)
+        @owner, @reflection = owner, reflection
+        reset
+      end
+
+      #
+      # Resets the \loaded flag to +false+ and sets the \target to +nil+.
+      #
+      def reset
+        @loaded = false
+        @target = nil
+        @stale_state = nil
+      end
+
+      #
+      # Has the \target been already \loaded?
+      #
+      def loaded?
+        @loaded
+      end
+
+      #
+      # Asserts the \target has been loaded setting the \loaded flag to +true+.
+      #
+      def loaded!
+        @loaded = true
+        @stale_state = stale_state
+      end
+
+      #
+      # Sets the target of this association to <tt>\target</tt>, and the \loaded flag to +true+.
+      #
+      def target=(target)
+        @target = target
+        loaded!
+      end
+
+      #
+      # The target is stale if the target no longer points to the record(s) that the
+      # relevant foreign_key(s) refers to. If stale, the association accessor method
+      # on the owner will reload the target. It's up to subclasses to implement the
+      # stale_state method if relevant.
+      #
+      # Note that if the target has not been loaded, it is not considered stale.
+      #
+      def stale_target?
+        loaded? && @stale_state != stale_state
+      end
+
+      #
+      # Loads the \target if needed and returns it.
+      #
+      # This method is abstract in the sense that it relies on +find_target+,
+      # which is expected to be provided by descendants.
+      #
+      # If the \target is already \loaded it is just returned. Thus, you can call
+      # +load_target+ unconditionally to get the \target.
+      #
+      # ActiveRecord::RecordNotFound is rescued within the method, and it is
+      # not reraised. The proxy is \reset and +nil+ is the return value.
+      #
+      def load_target
+        @target = find_target if (@stale_state && stale_target?) || find_target?
+        loaded! unless loaded?
+        target
+      rescue OceanDynamo::RecordNotFound
+        reset
+      end
+
+      #
+      # Returns the class of the target. belongs_to polymorphic used to override this 
+      # to look at the polymorphic_type field on the owner. However, belongs_to is no
+      # longer implemented in AR using an Assocation, so we keep this only for structural
+      # compatibility.
+      #
+      def klass
+        reflection.klass
+      end
+
+      #
+      # Reloads the \target and returns +self+ on success.
+      #
+      def reload
+        reset
+        load_target
+        self unless target.nil?
+      end
+
+
+      private
+
+        def find_target?
+          !loaded? && (!owner.new_record? || foreign_key_present?) && klass
+        end
+
+        #
+        # Should be true if there is a foreign key present on the owner which
+        # references the target. This is used to determine whether we can load
+        # the target if the owner is currently a new record (and therefore
+        # without a key).
+        #
+        # Currently implemented by belongs_to (vanilla and polymorphic) and
+        # has_one/has_many :through associations which go through a belongs_to
+        #
+        # This method is, nowadays, merely an archaeological artifact since
+        # +belongs_to+ no longer uses Associations, meaning this method will
+        # never be overridden.
+        #
+        def foreign_key_present?
+          false
+        end
+
+        #
+        # This should be implemented to return the values of the relevant key(s) on the owner,
+        # so that when stale_state is different from the value stored on the last find_target,
+        # the target is stale.
+        #
+        # This is only relevant to certain associations, which is why it returns nil by default.
+        #
+        def stale_state
+          nil
+        end
+
+    end
+  end
+end

data/lib/ocean-dynamo/associations/associations.rb

@@ -4,6 +4,10 @@ module OceanDynamo
     def self.included(base)
       base.extend(ClassMethods)
     end
+
+    # This class really does some of the stuff that in ActiveRecord is
+    # handled by the Reflection class. We could switch to the AR paradigm
+    # at some point.
   
 
     # ---------------------------------------------------------

data/lib/ocean-dynamo/associations/belongs_to.rb

@@ -24,7 +24,7 @@ module OceanDynamo
       #    end
       #    has_many :topics, dependent: :destroy
       #  end
-      # 
+      #  
       # class Topic < OceanDynamo::Table
       #   dynamo_schema(:uuid) do
       #     attribute :title
@@ -32,14 +32,14 @@ module OceanDynamo
       #   belongs_to :forum
       #   has_many :posts, dependent: :destroy
       # end
-      # 
+      #  
       # class Post < OceanDynamo::Table
       #   dynamo_schema(:uuid) do
       #     attribute :body
       #   end
       #   belongs_to :topic, composite_key: true
       # end
-      # 
+      #
       # The only non-standard aspect of the above is <tt>composite_key: true</tt>, 
       # which is required as the Topic class itself has a +belongs_to+ relation and 
       # thus has a composite key. This must be declared in the child class as it 
@@ -57,6 +57,8 @@ module OceanDynamo
         target_class = class_name.constantize            # Master
 
         assert_only_one_belongs_to!
+        assert_range_key_not_specified!
+        assert_hash_key_is_not_id!
 
         self.table_range_key = table_hash_key            # The RANGE KEY is variable
         self.table_hash_key = target_attr_id.to_sym      # The HASH KEY is the parent UUID
@@ -72,7 +74,6 @@ module OceanDynamo
         define_attribute_accessors(table_range_key)      # define uuid, uuid=, uuid?
 
 
-
         # Define the parent id attribute 
         attribute target_attr_id, :reference, default: nil, target_class: target_class,
                                   association: :belongs_to
@@ -101,6 +102,15 @@ module OceanDynamo
                            @#{target_attr} = nil
                            value
                          end"
+
+        # Define parent builders
+        self.class_eval "def self.build_#{target_attr}(**opts)
+                           #{target_class}.new(opts)
+                         end"
+
+        self.class_eval "def self.create_#{target_attr}(**opts)
+                           #{target_class}.create(opts)
+                         end"
       end
 
 
@@ -144,6 +154,24 @@ module OceanDynamo
         end
         false
       end
+
+
+      #
+      # Make sure the range key isn't specified.
+      #
+      def assert_range_key_not_specified!  # :nodoc:
+        raise RangeKeyMustNotBeSpecified, 
+              "Tables with belongs_to relations may not specify the range key" if table_range_key
+      end
+
+
+      #
+      # Make sure the hash key isn't called :id.
+      #
+      def assert_hash_key_is_not_id!  # :nodoc:
+        raise HashKeyMayNotBeNamedId, 
+              "Tables with belongs_to relations may not name their hash key :id" if table_hash_key.to_s == "id"
+      end
     end