active-fedora 6.8.0 → 7.0.0.pre1

data/lib/active_fedora/associations/builder/collection_association.rb

@@ -0,0 +1,56 @@
+module ActiveFedora::Associations::Builder
+  class CollectionAssociation < Association #:nodoc:
+    CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
+
+    self.valid_options += [ 
+      :before_add, :after_add, :before_remove, :after_remove
+    ]
+
+
+    def self.build(model, name, options)
+      new(model, name, options).build
+    end
+
+    def initialize(model, name, options)
+      super(model, name, options)
+    end
+
+    def build
+      reflection = super
+      CALLBACKS.each { |callback_name| define_callback(callback_name) }
+      reflection
+    end
+
+    def writable?
+      true
+    end
+
+    private
+
+      def define_callback(callback_name)
+        full_callback_name = "#{callback_name}_for_#{name}"
+
+        # TODO : why do i need method_defined? I think its because of the inheritance chain
+        model.class_attribute full_callback_name.to_sym unless model.method_defined?(full_callback_name)
+        model.send("#{full_callback_name}=", Array(options[callback_name.to_sym]))
+      end
+
+      def define_readers
+        super
+
+        name = self.name
+        mixin.redefine_method("#{name.to_s.singularize}_ids") do
+          association(name).ids_reader
+        end
+      end
+
+      def define_writers
+        super
+
+        name = self.name
+        mixin.redefine_method("#{name.to_s.singularize}_ids=") do |ids|
+          association(name).ids_writer(ids)
+        end
+      end
+  end
+end

data/lib/active_fedora/associations/builder/has_and_belongs_to_many.rb

@@ -0,0 +1,30 @@
+module ActiveFedora::Associations::Builder
+  class HasAndBelongsToMany < CollectionAssociation #:nodoc:
+    self.macro = :has_and_belongs_to_many
+
+    self.valid_options += [:inverse_of]
+
+    def build
+      reflection = super
+      redefine_destroy
+      reflection
+    end
+
+    private
+
+      def redefine_destroy
+        # Don't use a before_destroy callback since users' before_destroy
+        # callbacks will be executed after the association is wiped out.
+        name = self.name
+        model.send(:include, Module.new {
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def destroy          # def destroy
+              super              #   super
+              #{name}.clear      #   posts.clear
+            end                  # end
+          RUBY
+        })
+      end
+
+  end
+end

data/lib/active_fedora/associations/builder/has_many.rb

@@ -0,0 +1,63 @@
+module ActiveFedora::Associations::Builder
+  class HasMany < CollectionAssociation #:nodoc:
+    self.macro = :has_many
+
+    self.valid_options += [:dependent, :inverse_of]
+
+    def build
+      reflection = super
+      configure_dependency
+      reflection
+    end
+
+    private
+
+      def configure_dependency
+        if options[:dependent]
+          unless [:destroy, :delete_all, :nullify, :restrict].include?(options[:dependent])
+            raise ArgumentError, "The :dependent option expects either :destroy, :delete_all, " \
+                                 ":nullify or :restrict (#{options[:dependent].inspect})"
+          end
+
+          send("define_#{options[:dependent]}_dependency_method")
+          model.before_destroy dependency_method_name
+        end
+      end
+
+      def define_destroy_dependency_method
+        name = self.name
+        model.send(:define_method, dependency_method_name) do
+          send(name).each do |o|
+            # No point in executing the counter update since we're going to destroy the parent anyway
+            counter_method = ('belongs_to_counter_cache_before_destroy_for_' + self.class.name.downcase).to_sym
+            if o.respond_to?(counter_method)
+              class << o
+                self
+              end.send(:define_method, counter_method, Proc.new {})
+            end
+          end
+
+          send(name).delete_all
+        end
+      end
+
+      def define_delete_all_dependency_method
+        name = self.name
+        model.send(:define_method, dependency_method_name) do
+          send(name).delete_all
+        end
+      end
+      alias :define_nullify_dependency_method :define_delete_all_dependency_method
+
+      def define_restrict_dependency_method
+        name = self.name
+        model.send(:define_method, dependency_method_name) do
+          raise ActiveRecord::DeleteRestrictionError.new(name) unless send(name).empty?
+        end
+      end
+
+      def dependency_method_name
+        "has_many_dependent_for_#{name}"
+      end
+  end
+end

data/lib/active_fedora/associations/builder/singular_association.rb

@@ -0,0 +1,32 @@
+module ActiveFedora::Associations::Builder
+  class SingularAssociation < Association #:nodoc:
+    self.valid_options += [:dependent, :counter_cache, :inverse_of]
+
+    def constructable?
+      true
+    end
+
+    def define_accessors
+      super
+      define_constructors if constructable?
+    end
+
+    private
+
+      def define_constructors
+        name = self.name
+
+        mixin.redefine_method("build_#{name}") do |*params|
+          association(name).build(*params)
+        end
+
+        mixin.redefine_method("create_#{name}") do |*params|
+          association(name).create(*params)
+        end
+
+        mixin.redefine_method("create_#{name}!") do |*params|
+          association(name).create!(*params)
+        end
+      end
+  end
+end

data/lib/active_fedora/associations/{association_collection.rb → collection_association.rb}

@@ -1,9 +1,74 @@
 module ActiveFedora
   module Associations
-    class AssociationCollection < AssociationProxy #:nodoc:
+    class CollectionAssociation < Association #:nodoc:
+      attr_reader :proxy
+
       def initialize(owner, reflection)
         super
+
         construct_query
+        @proxy = CollectionProxy.new(self)
+      end
+
+
+      # Implements the reader method, e.g. foo.items for Foo.has_many :items
+      # @param opts [Boolean, Hash] if true, force a reload
+      # @option opts [Symbol] :response_format can be ':solr' to return a solr result.
+      def reader(opts = false)
+        if opts.kind_of?(Hash)
+          if opts.delete(:response_format) == :solr
+            return load_from_solr(opts) 
+          end
+          raise ArgumentError, "Hash parameter must include :response_format=>:solr (#{opts.inspect})"
+        else
+          force_reload = opts
+        end
+        reload if force_reload || stale_target?
+        proxy
+      end
+
+      # Implements the writer method, e.g. foo.items= for Foo.has_many :items
+      def writer(records)
+        replace(records)
+      end
+
+      # Implements the ids reader method, e.g. foo.item_ids for Foo.has_many :items
+      def ids_reader
+        if loaded?
+          load_target.map do |record|
+            record.pid
+          end
+        else
+          load_from_solr.map do |solr_record|
+            solr_record['id']
+          end
+        end
+      end
+
+      # Implements the ids writer method, e.g. foo.item_ids= for Foo.has_many :items
+      def ids_writer(ids)
+        ids = Array(ids).reject { |id| id.blank? }
+        replace(klass.find(ids))#.index_by { |r| r.id }.values_at(*ids))
+        #TODO, like this when find() can return multiple records
+        #send("#{reflection.name}=", reflection.klass.find(ids))
+        #send("#{reflection.name}=", ids.collect { |id| reflection.klass.find(id)})
+      end
+
+      def reset
+        reset_target!
+        @loaded = false
+      end
+
+      def find(*args)
+        scope.find(*args)
+      end
+
+      def first(*args)
+        first_or_last(:first, *args)
+      end
+
+      def last(*args)
+        first_or_last(:last, *args)
       end
 
       # Returns the size of the collection 
@@ -38,21 +103,22 @@ module ActiveFedora
         concat(other_array.select { |v| !current.include?(v) })
       end
       
-
-      def to_ary
-        load_target
-        if @target.is_a?(Array)
-          @target.to_ary
+      def include?(record)
+        if record.is_a?(reflection.klass)
+          if record.new_record?
+            target.include?(record)
+          else
+            loaded? ? target.include?(record) : scope.exists?(record)
+          end
         else
-          Array.wrap(@target)
+          false
         end
       end
-      alias_method :to_a, :to_ary
 
-      def reset
-        reset_target!
-        @loaded = false
+      def to_ary
+        load_target.dup
       end
+      alias_method :to_a, :to_ary
 
       def build(attributes = {}, &block)
         if attributes.is_a?(Array)
@@ -60,6 +126,7 @@ module ActiveFedora
         else
           build_record(attributes) do |record|
             block.call(record) if block_given?
+            add_to_target(record)
             set_belongs_to_association_for(record)
           end
         end
@@ -71,7 +138,7 @@ module ActiveFedora
         result = true
         load_target unless loaded?
 
-        flatten_deeper(records).each do |record|
+        records.flatten.each do |record|
           raise_on_type_mismatch(record)
           add_record_to_target_with_callbacks(record) do |r|
             result &&= insert_record(record)
@@ -84,6 +151,26 @@ module ActiveFedora
       alias_method :push, :<<
       alias_method :concat, :<<
 
+      # Remove all records from this association
+      #
+      # See delete for more info.
+      def delete_all
+        delete(load_target).tap do
+          reset
+          loaded!
+        end
+      end
+
+      # Remove all records from this association
+      #
+      # See delete for more info.
+      def destroy_all
+        destroy(load_target).tap do
+          reset
+          loaded!
+        end
+      end
+
       # Removes +records+ from this association calling +before_remove+ and
       # +after_remove+ callbacks.
       #
@@ -92,10 +179,17 @@ module ActiveFedora
       # are actually removed from the database, that depends precisely on
       # +delete_records+. They are in any case removed from the collection.
       def delete(*records)
-        remove_records(records) do |_records, old_records|
-          delete_records(old_records) if old_records.any?
-          _records.each { |record| @target.delete(record) }
-        end
+        delete_or_destroy(records, options[:dependent])
+      end
+
+      # Destroy +records+ and remove them from this association calling
+      # +before_remove+ and +after_remove+ callbacks.
+      #
+      # Note that this method will _always_ remove records from the database
+      # ignoring the +:dependent+ option.
+      def destroy(*records)
+        records = find(records) if records.any? { |record| record.kind_of?(Fixnum) || record.kind_of?(String) }
+        delete_or_destroy(records, :destroy)
       end
 
       def create(attrs = {})
@@ -115,58 +209,67 @@ module ActiveFedora
           record.save!
         end
       end
-      
 
+      # Count all records using solr. Construct options and pass them with
+      # scope to the target class's +count+.
+      def count(options = {})
+        @reflection.klass.count(:conditions => @counter_query)
+      end
+      
       def load_target
-        if !@owner.new_record?
+        if find_target?
+          targets = []
+
           begin
-            if !loaded?
-              if @target.is_a?(Array) && @target.any?
-                @target = find_target.map do |f|
-                  i = @target.index(f)
-                  if i
-                    @target.delete_at(i).tap do |t|
-                      keys = ["id"] + t.changes.keys + (f.attribute_names - t.attribute_names)
-                      t.attributes = f.attributes.except(*keys)
-                    end
-                  else
-                    f
-                  end
-                end + @target
-              else
-                @target = find_target
-              end
-            end
+            targets = find_target
           rescue ObjectNotFoundError => e
             ActiveFedora::Base.logger.error "Solr and Fedora may be out of sync:\n" + e.message
             reset
           end
+
+          @target = merge_target_lists(targets, @target)
         end
 
-        loaded if target
+        loaded!
         target
       end
 
       def find_target
-        return [] if @finder_query.empty?
-        solr_result = SolrService.query(@finder_query, :rows=>1000)
-
-        # Set the default classname to base inheritance on.
-        opts = {}
-        opts[:class] = @reflection.class_name.constantize.to_class_uri unless @reflection.class_name.nil?
+        # TODO: don't reify, just store the solr results and lazily reify.
+        # For now, we set a hard limit of 1000 results.
+        return ActiveFedora::SolrService.reify_solr_results(load_from_solr(rows: 1000))
+      end
 
-#TODO, don't reify, just store the solr results and lazily reify.
-        return ActiveFedora::SolrService.reify_solr_results(solr_result)
+      def merge_target_lists(loaded, existing)
+        return loaded if existing.empty?
+        return existing if loaded.empty?
+
+        loaded.map do |f|
+          i = existing.index(f)
+          if i
+            existing.delete_at(i).tap do |t|
+              keys = ["id"] + t.changes.keys + (f.attribute_names - t.attribute_names)
+              # FIXME: this call to attributes causes many NoMethodErrors
+              attributes = f.attributes
+              (attributes.keys - keys).each do |k|
+                t.send("#{k}=", attributes[k])
+              end
+            end
+          else
+            f
+          end
+        end + existing
       end
 
-      def load_from_solr
+      # @param opts [Hash] Options that will be passed through to ActiveFedora::SolrService.query.
+      def load_from_solr(opts = Hash.new)
         return [] if @finder_query.empty?
-        SolrService.query(@finder_query, :rows=>1000)
+        solr_opts = {rows: opts.delete(:rows) || count}
+        SolrService.query(@finder_query, solr_opts.merge(opts))
       end
 
-
       def add_record_to_target_with_callbacks(record)
-      #  callback(:before_add, record)
+        callback(:before_add, record)
         yield(record) if block_given?
         @target ||= [] unless loaded?
         if index = @target.index(record)
@@ -174,11 +277,38 @@ module ActiveFedora
         else
            @target << record
         end
-      #  callback(:after_add, record)
+        callback(:after_add, record)
       #  set_inverse_instance(record, @owner)
         record
       end
 
+      def add_to_target(record)
+      #  transaction do
+          callback(:before_add, record)
+          yield(record) if block_given?
+
+          if @reflection.options[:uniq] && index = @target.index(record)
+            @target[index] = record
+          else
+            @target << record
+          end
+
+          callback(:after_add, record)
+          set_inverse_instance(record)
+       # end
+
+        record
+      end
+
+      def scope(opts = {})
+        scope = super()
+        scope.none! if opts.fetch(:nullify, true) && null_scope?
+        scope
+      end
+
+      def null_scope?
+        owner.new_record? && !foreign_key_present?
+      end
       protected
         def reset_target!
           @target = Array.new
@@ -194,6 +324,14 @@ module ActiveFedora
 
       private 
 
+        # Assigns the ID of the owner to the corresponding foreign key in +record+.
+        # If the association is polymorphic the type of the owner is also set.
+        def set_belongs_to_association_for(record)
+          unless @owner.new_record?
+            record.add_relationship(find_predicate, @owner)
+          end
+        end
+
         def find_predicate
           if @reflection.options[:property]
             @reflection.options[:property]
@@ -243,13 +381,16 @@ module ActiveFedora
           end
         end
 
-        def remove_records(*records)
-          records = flatten_deeper(records)
+        def delete_or_destroy(records, method)
+          records = records.flatten
           records.each { |record| raise_on_type_mismatch(record) }
+          existing_records = records.reject { |r| r.new_record? }
 
           records.each { |record| callback(:before_remove, record) }
-          old_records = records.reject { |r| r.new_record? }
-          yield(records, old_records)
+
+          delete_records(existing_records, method) if existing_records.any?
+          records.each { |record| target.delete(record) }
+
           records.each { |record| callback(:after_remove, record) }
         end
 
@@ -276,6 +417,15 @@ module ActiveFedora
             raise ActiveFedora::RecordNotSaved, "You cannot call create unless the parent is saved"
           end
         end
+
+        # Fetches the first/last using solr if possible, otherwise from the target array.
+        def first_or_last(type, *args)
+          args.shift if args.first.is_a?(Hash) && args.first.empty?
+
+          #collection = fetch_first_or_last_using_find?(args) ? scoped : load_target
+          collection = load_target
+          collection.send(type, *args)
+        end
       
     end
   end