active-fedora 9.1.2 → 9.2.0.rc1

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

@@ -1,11 +1,13 @@
 module ActiveFedora::Associations::Builder
   class HasAndBelongsToMany < CollectionAssociation #:nodoc:
+    extend Deprecation
     self.macro = :has_and_belongs_to_many
 
     self.valid_options += [:inverse_of, :solr_page_size]
 
     def validate_options
       super
+      Deprecation.warn HasAndBelongsToMany, ":solr_page_size doesn't do anything anymore and will be removed in ActiveFedora 10" if options.key?(:solr_page_size)
       if !options[:predicate]
         raise "You must specify a predicate for #{name}"
       elsif !options[:predicate].kind_of?(RDF::URI)
@@ -13,28 +15,5 @@ module ActiveFedora::Associations::Builder
       end
     end
 
-    def build
-      reflection = super
-      define_destroy_hook
-      reflection
-    end
-
-    private
-
-      def define_destroy_hook
-        # Don't use a before_destroy callback since users' before_destroy
-        # callbacks will be executed after the association is wiped out.
-        # TODO Update to destroy_associations
-        name = self.name
-        model.send(:include, Module.new {
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def destroy          # def destroy
-              #{name}.clear      #   posts.clear
-              super              #   super
-            end                  # end
-          RUBY
-        })
-      end
-
   end
 end

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

@@ -0,0 +1,26 @@
+module ActiveFedora::Associations::Builder
+  class IndirectlyContains < CollectionAssociation #:nodoc:
+    self.macro = :indirectly_contains
+    self.valid_options += [:has_member_relation, :is_member_of_relation, :inserted_content_relation, :foreign_key, :through]
+    self.valid_options -= [:predicate]
+
+    def build
+      reflection = super
+      configure_dependency
+      reflection
+    end
+
+    def validate_options
+      super
+      if !options[:has_member_relation] && !options[:is_member_of_relation]
+        raise ArgumentError, "You must specify a predicate for #{name}"
+      elsif !options[:has_member_relation].kind_of?(RDF::URI) && !options[:is_member_of_relation].kind_of?(RDF::URI)
+        raise ArgumentError, "Predicate must be a kind of RDF::URI"
+      end
+
+      raise ArgumentError, "Missing :through option" if !options[:through]
+      raise ArgumentError, "Missing :foreign_key option" if !options[:foreign_key]
+    end
+  end
+end
+

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

@@ -9,6 +9,16 @@ module ActiveFedora::Associations::Builder
       @name = :"#{name.to_s.singularize}_ids"
     end
 
+    def build
+      super.tap do |reflection|
+        model.index_config[name] = build_index_config(reflection)
+      end
+    end
+
+    def build_index_config(reflection)
+      ActiveFedora::Indexing::Map::IndexObject.new(reflection.predicate_for_solr) { |index| index.as :symbol }
+    end
+
   end
 end
 

data/lib/active_fedora/associations/collection_association.rb

@@ -47,8 +47,8 @@ module ActiveFedora
       end
 
       def reset
-        reset_target!
-        @loaded = false
+        super
+        @target = []
       end
 
       def find(*args)
@@ -239,51 +239,13 @@ module ActiveFedora
 
       def load_target
         if find_target?
-          targets = []
-
-          begin
-            targets = find_target
-          rescue ObjectNotFoundError, Ldp::Gone => e
-            ActiveFedora::Base.logger.error "Solr and Fedora may be out of sync:\n" + e.message if ActiveFedora::Base.logger
-            reset
-          end
-
-          @target = merge_target_lists(targets, @target)
+          @target = merge_target_lists(find_target, @target)
         end
 
         loaded!
         target
       end
 
-      def find_target
-        # TODO: don't reify, just store the solr results and lazily reify.
-        # For now, we set a hard limit of 1000 results.
-        records = ActiveFedora::QueryResultBuilder.reify_solr_results(load_from_solr(rows: 1000))
-        records.each { |record| set_inverse_instance(record) }
-        records
-      end
-
-      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
-
       # @param opts [Hash] Options that will be passed through to ActiveFedora::SolrService.query.
       def load_from_solr(opts = Hash.new)
         finder_query = construct_query
@@ -293,6 +255,7 @@ module ActiveFedora
         SolrService.query(finder_query, { rows: rows }.merge(opts))
       end
 
+
       def add_to_target(record, skip_callbacks = false)
       #  transaction do
           callback(:before_add, record) unless skip_callbacks
@@ -320,14 +283,11 @@ module ActiveFedora
       def null_scope?
         owner.new_record? && !foreign_key_present?
       end
+
       protected
-        def reset_target!
-          @target = Array.new
-        end
 
         def construct_query
           @solr_query ||= begin
-            #TODO use primary_key instead of id
             clauses = { find_reflection => @owner.id }
             clauses[:has_model] = @reflection.class_name.constantize.to_class_uri if @reflection.class_name && @reflection.class_name != 'ActiveFedora::Base'
             ActiveFedora::SolrQueryBuilder.construct_query_for_rel(clauses)
@@ -337,6 +297,39 @@ module ActiveFedora
 
       private
 
+        def find_target
+          # TODO: don't reify, just store the solr results and lazily reify.
+          # For now, we set a hard limit of 1000 results.
+          records = ActiveFedora::QueryResultBuilder.reify_solr_results(load_from_solr(rows: 1000))
+          records.each { |record| set_inverse_instance(record) }
+          records
+        rescue ObjectNotFoundError, Ldp::Gone => e
+          ActiveFedora::Base.logger.error "Solr and Fedora may be out of sync:\n" + e.message if ActiveFedora::Base.logger
+          reset
+          []
+        end
+
+        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 find_reflection
           return reflection if @reflection.options[:predicate]
           if @reflection.class_name && @reflection.class_name != 'ActiveFedora::Base' && @reflection.macro != :has_and_belongs_to_many
@@ -366,8 +359,12 @@ module ActiveFedora
           existing_records = records.select { |r| r.persisted? }
 
           records.each { |record| callback(:before_remove, record) }
+
+          # Delete the record from Fedora.
           delete_records(existing_records, method) if existing_records.any?
+
           records.each do |record|
+            # Remove the record from the array/collection.
             target.delete(record)
           end
 

data/lib/active_fedora/associations/collection_proxy.rb

@@ -842,6 +842,12 @@ module ActiveFedora
         @association
       end
 
+      # @return [Relation] object for the records in this association
+      def scope
+        @association.scope
+      end
+      alias spawn scope
+
       def to_ary
         load_target.dup
       end

data/lib/active_fedora/associations/contained_finder.rb

@@ -0,0 +1,41 @@
+module ActiveFedora::Associations
+  ## 
+  # Finds the objects which associate with a given record and are contained
+  # within the given container. Uses #repository to find the objects.
+  class ContainedFinder
+    attr_reader :container, :repository
+    delegate :contained_ids, to: :container
+    # @param [#contained_ids] container a container that records are stored
+    #   under.
+    # @param [#translate_uri_to_id, #find] repository a repository to build
+    #   objects from.
+    def initialize(container:, repository:)
+      @container = container
+      @repository = repository
+    end
+
+    # @param [ActiveFedora::Base] record a record which you want to find the
+    #   reference node for.
+    # @return [Array<ActiveFedora::Base>] This returns whatever type
+    #   repository.find returns.
+    def find(record)
+      record.reload
+      repository.find(matching_ids(record))
+    end
+
+    private
+
+    def matching_ids(record)
+      IDComposite.new(proxy_ids(record) & contained_ids, repository.translate_uri_to_id)
+    end
+
+    def proxy_ids(record)
+      relation_subjects(record)
+    end
+
+    def relation_subjects(record)
+      record.resource.query(object: record.rdf_subject).subjects.to_a
+    end
+  end
+
+end

data/lib/active_fedora/associations/container_proxy.rb

@@ -0,0 +1,9 @@
+module ActiveFedora
+  module Associations
+    class ContainerProxy < CollectionProxy
+      def initialize(association)
+        @association = association
+      end
+    end
+  end
+end

data/lib/active_fedora/associations/contains_association.rb

@@ -1,52 +1,34 @@
+# This is the parent class of DirectlyContainsAssociation and IndirectlyContainsAssociation
 module ActiveFedora
   module Associations
-    class ContainsAssociation < SingularAssociation #:nodoc:
-      # Implements the reader method, e.g. foo.bar for Foo.has_one :bar
-      def reader(force_reload = false)
-        super || build
-      end
-
-      def find_target
-        reflection.build_association(target_uri).tap do |record|
-          configure_datastream(record) if reflection.options[:block]
-        end 
-      end
-
-      def target_uri
-        "#{owner.uri}/#{reflection.name}"
-      end
-
-      private
+    class ContainsAssociation < CollectionAssociation #:nodoc:
 
-      def raise_on_type_mismatch(record)
-        return if record.is_a? LoadableFromJson::SolrBackedMetadataFile
-        super
+      def reader
+        @records ||= ContainerProxy.new(self)
       end
 
-      def replace(record)
-        if record
-          raise_on_type_mismatch(record)
-          @updated = true
+      def include?(other)
+        if loaded?
+          target.include?(other)
+        elsif container_predicate = options[:has_member_relation]
+          owner.resource.query(predicate: container_predicate, object: ::RDF::URI(other.uri)).present?
+        else #is_member_of_relation
+          # This will force a load, so it's slowest and the least preferable option
+          target.include?(other)
         end
-
-        self.target = record
       end
 
-      def new_record(method, attributes)
-        record = super
-        configure_datastream(record)
-        record
-      end
+      protected
 
-      def configure_datastream(record)
-        # If you called has_metadata with a block, pass the block into the File class
-        if reflection.options[:block].class == Proc
-          reflection.options[:block].call(record)
+        def count_records
+          load_target.size
         end
-        if record.new_record? && reflection.options[:autocreate]
-          record.datastream_will_change!
+
+        def uri
+          raise "Can't get uri. Owner isn't saved" if @owner.new_record?
+          "#{@owner.uri}/#{@reflection.name}"
         end
-      end
     end
   end
 end
+

data/lib/active_fedora/associations/delete_proxy.rb

@@ -0,0 +1,28 @@
+module ActiveFedora::Associations
+  class DeleteProxy
+    def self.call(proxy_ids:, proxy_class:)
+      new(proxy_ids: proxy_ids, proxy_class: proxy_class).run
+    end
+    attr_reader :proxy_ids, :proxy_class
+
+    def initialize(proxy_ids:, proxy_class:)
+      @proxy_ids = proxy_ids
+      @proxy_class = proxy_class
+    end
+
+    def run
+      proxies.each(&:delete)
+    end
+
+    private
+
+    def proxies
+      @proxies ||= proxy_ids.map{ |uri| uri_to_proxy(uri) }
+    end
+
+    def uri_to_proxy(uri)
+      proxy_class.find(proxy_class.uri_to_id(uri))
+    end
+
+  end
+end

data/lib/active_fedora/associations/directly_contains_association.rb

@@ -0,0 +1,56 @@
+module ActiveFedora
+  module Associations
+    class DirectlyContainsAssociation < ContainsAssociation #:nodoc:
+
+      def insert_record(record, force = true, validate = true)
+        container.save!
+        if force
+          record.save!
+        else
+          record.save(validate: validate)
+        end
+      end
+
+      def find_target
+        query_node = if container_predicate = options[:has_member_relation]
+           owner
+        else
+          container_predicate = ::RDF::Vocab::LDP.contains
+          container
+        end
+
+        uris = query_node.resource.query(predicate: container_predicate).map { |r| r.object.to_s }
+
+        uris.map { |object_uri| klass.find(klass.uri_to_id(object_uri)) }
+      end
+
+      def container
+        @container ||= begin
+          DirectContainer.find_or_initialize(ActiveFedora::Base.uri_to_id(uri)).tap do |container|
+            container.parent = @owner
+            container.has_member_relation = Array(options[:has_member_relation])
+            container.is_member_of_relation = Array(options[:is_member_of_relation])
+          end
+        end
+      end
+
+      protected
+
+        def initialize_attributes(record) #:nodoc:
+          record.uri = ActiveFedora::Base.id_to_uri(container.mint_id)
+          set_inverse_instance(record)
+        end
+
+      private
+
+        def delete_records(records, method)
+          if method == :destroy
+            records.each { |r| r.destroy }
+          else
+            records.each { |r| r.delete }
+          end
+        end
+
+    end
+  end
+end