active-fedora 9.1.2 → 9.2.0.rc1

data/lib/active_fedora/associations/directly_contains_one_association.rb

@@ -0,0 +1,113 @@
+module ActiveFedora
+  module Associations
+    # Filters a DirectContainer relationship, returning the first item that matches the given :type
+    class DirectlyContainsOneAssociation < SingularAssociation #:nodoc:
+
+      # Finds objects contained by the container predicate (either the configured has_member_relation or ldp:contains)
+      # TODO: Refactor this to use solr (for efficiency) instead of parsing the RDF graph.  Requires indexing ActiveFedora::File objects into solr, including their RDF.type and, if possible, the id of their container
+      def find_target
+        # filtered_objects = container_association_proxy.to_a.select { |o| o.metadata_node.type.include?(options[:type]) }
+        query_node = if container_predicate = options[:has_member_relation]
+                       owner
+                     else
+                       container_predicate = ::RDF::Vocab::LDP.contains
+                       container_association.container  # Use the :through association's container
+                     end
+
+        contained_uris = query_node.resource.query(predicate: container_predicate).map { |r| r.object.to_s }
+        contained_uris.each do |object_uri|
+          contained_object = klass.find(klass.uri_to_id(object_uri))
+          return contained_object if get_type_from_record(contained_object).include?(options[:type])
+        end
+        return nil # if nothing was found & returned while iterating on contained_uris, return nil
+      end
+
+      # Adds record to the DirectContainer identified by the container_association
+      # Relies on container_association.initialize_attributes to appropriately set things like record.uri
+      def add_to_container(record)
+        container_association.add_to_target(record)  # adds record to corresponding Container
+        # TODO is send necessary?
+        container_association.send(:initialize_attributes, record) # Uses the :through association initialize the record with things like the correct URI for a direclty contained object
+      end
+
+      # Replaces association +target+ with +record+
+      # Ensures that this association's +type+ is set on the record and adds the record to the association's DirectContainer
+      def replace(record, *)
+        if record
+          raise_on_type_mismatch(record)
+          remove_existing_target
+          add_type_to_record(record, options[:type])
+          add_to_container(record)
+        else
+          remove_existing_target
+        end
+
+        self.target = record
+      end
+
+      def updated?
+        @updated
+      end
+
+      private
+
+      def remove_existing_target
+        @target ||= find_target
+        if @target
+          container_association_proxy.delete @target
+          @updated = true
+        end
+      end
+
+      # Overrides initialize_attributes to ensure that record is initialized with attributes from the corresponding container
+      def initialize_attributes(record)
+        super
+        container_association.initialize_attributes(record)
+      end
+
+      # Returns the Reflection corresponding to the direct container association that's being filtered
+      def container_reflection
+        @container_reflection ||= @owner.class.reflect_on_association(@reflection.options[:through])
+      end
+
+      # Returns the DirectContainerAssociation corresponding to the direct container that's being filtered
+      def container_association
+        container_association_proxy.proxy_association
+      end
+
+      # Returns the ContainerAssociationProxy corresponding to the direct container that's being filtered
+      def container_association_proxy
+        @owner.send(@reflection.options[:through])
+      end
+
+      # Adds type_uri to the RDF.type assertions on record
+      def add_type_to_record(record, type_uri)
+        metadata_node = metadata_node_for_record(record)
+        types = metadata_node.type
+        unless types.include?(type_uri)
+          types << type_uri
+          metadata_node.set_value(:type, types)
+        end
+        return record
+      end
+
+      # Returns the RDF.type assertions for the record
+      def get_type_from_record(record)
+        metadata_node_for_record(record).type
+      end
+
+      # Returns the RDF node that contains metadata like RDF.type assertions for the record
+      # Sometimes this is the record, other times it's record.metadata_node
+      def metadata_node_for_record(record)
+        if record.respond_to?(:type) && record.respond_to?(:set_value)
+          return record
+        elsif record.respond_to?(:metadata_node)
+          return record.metadata_node
+        else
+          raise ArgumentError, "record must either have a metadata node or must respond to .type"
+        end
+      end
+
+    end
+  end
+end

data/lib/active_fedora/associations/has_and_belongs_to_many_association.rb

@@ -46,20 +46,6 @@ module ActiveFedora
         result && records
       end
 
-
-      def find_target
-        page_size = @reflection.options[:solr_page_size]
-        page_size ||= 200
-        ids = owner[reflection.foreign_key]
-        return [] if ids.blank?
-        solr_result = []
-        0.step(ids.size,page_size) do |startIdx|
-          query = ActiveFedora::SolrQueryBuilder.construct_query_for_ids(ids.slice(startIdx,page_size))
-          solr_result += ActiveFedora::SolrService.query(query, rows: page_size)
-        end
-        return ActiveFedora::QueryResultBuilder.reify_solr_results(solr_result)
-      end
-
       # In a HABTM, just look in the RDF, no need to run a count query from solr.
       def count(options = {})
         owner[reflection.foreign_key].size
@@ -96,6 +82,12 @@ module ActiveFedora
           owner[reflection.foreign_key]
         end
 
+        def find_target
+          ids = owner[reflection.foreign_key]
+          return [] if ids.blank?
+          ActiveFedora::Base.find(ids)
+        end
+
     end
   end
 end

data/lib/active_fedora/associations/has_many_association.rb

@@ -35,19 +35,16 @@ module ActiveFedora
             record[inverse.foreign_key] = owner.id
           else # HABTM
             record[inverse.foreign_key] ||= []
-            #TODO use primary_key instead of `owner.id`
             record[inverse.foreign_key] += [owner.id]
           end
         elsif owner.persisted?
           inverse = reflection.inverse_of
           if inverse && inverse.collection?
             record[inverse.foreign_key] ||= []
-            #TODO use primary_key instead of `owner.id`
             record[inverse.foreign_key] += [owner.id]
           elsif inverse && inverse.klass == ActiveFedora::Base
             record[inverse.foreign_key] = owner.id
           else
-            #TODO use primary_key instead of `owner.id`
             record[reflection.foreign_key] = owner.id
           end
         end

data/lib/active_fedora/associations/id_composite.rb

@@ -0,0 +1,30 @@
+module ActiveFedora::Associations
+  ##
+  # A composite object for an array of IDs. This abstracts away the fact that an
+  # ID might be either a relative ID or a URI to a resource.
+  class IDComposite
+    attr_reader :ids, :id_translator
+    include Enumerable
+    def initialize(ids, id_translator)
+      @ids = ids
+      @id_translator = id_translator
+    end
+
+    # @return [Array<relative_id>]
+    def each
+      ids.each do |id|
+        yield convert(id)
+      end
+    end
+
+    private
+
+    def convert(id)
+      if id.start_with?("http")
+        id_translator.call(id)
+      else
+        id
+      end
+    end
+  end
+end

data/lib/active_fedora/associations/indirectly_contains_association.rb

@@ -0,0 +1,90 @@
+module ActiveFedora
+  module Associations
+    class IndirectlyContainsAssociation < ContainsAssociation #:nodoc:
+
+      # TODO we may want to split this into two subclasses, one for has_member_relation
+      # and the other for is_member_of_relation
+
+      def insert_record(record, force = true, validate = true)
+        container.save!
+        if force
+          record.save!
+        else
+          return false unless record.save(validate: validate)
+        end
+
+        save_through_record(record)
+
+        return true
+      end
+
+      def find_target
+        if container_predicate = options[:has_member_relation]
+          uris = owner.resource.query(predicate: container_predicate).map { |r| r.object.to_s }
+          uris.map { |object_uri| klass.find(klass.uri_to_id(object_uri)) }
+        else # is_member_of_relation
+          # TODO this is a lot of reads. Avoid this path
+          container_predicate = ::RDF::Vocab::LDP.contains
+          proxy_uris = container.resource.query(predicate: container_predicate).map { |r| r.object.to_s }
+          proxy_uris.map { |uri| proxy_class.find(proxy_class.uri_to_id(uri))[options[:foreign_key]] }
+        end
+
+
+      end
+
+      def container
+        @container ||= begin
+          IndirectContainer.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])
+            container.inserted_content_relation = Array(options[:inserted_content_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)
+          container.reload # Reload container to get updated LDP.contains
+          records.each do |record|
+            delete_record(record)
+          end
+        end
+
+        def delete_record(record)
+          record_proxy_finder.find(record).delete
+        end
+
+        def record_proxy_finder
+          ContainedFinder.new(container: container, repository: composite_proxy_repository)
+        end
+
+        def composite_proxy_repository
+          RecordComposite::Repository.new(base_repository: proxy_class)
+        end
+
+        def save_through_record(record)
+          build_proxy_node({}) do |node|
+            node[options[:foreign_key]] = record
+            node.save
+          end
+        end
+
+        def build_proxy_node(attributes, &block)
+          proxy_class.new({ id: container.mint_id }.merge(attributes), &block)
+        end
+
+        def proxy_class
+          @proxy_class ||= options[:through].constantize
+        end
+    end
+  end
+end

data/lib/active_fedora/associations/rdf.rb

@@ -33,9 +33,15 @@ module ActiveFedora
         end
       end
 
-      # TODO Detect when this is the only relationship for this predicate, then skip the filtering.
       def filtering_required?
-        reflection.klass != ActiveFedora::Base
+        return false if reflection.klass == ActiveFedora::Base
+        reflections_with_same_predicate.count > 1
+      end
+
+      # Count the number of reflections that have the same predicate as the reflection
+      # for this association.
+      def reflections_with_same_predicate
+        owner.class.outgoing_reflections.select { |k, v| v.options[:predicate] == reflection.predicate }
       end
 
       # @return [Array<RDF::URI>]
@@ -48,8 +54,6 @@ module ActiveFedora
         owner.resource.query(subject: owner.rdf_subject, predicate: reflection.predicate).enum_statement
       end
 
-
-      # TODO this is a huge waste of time that can be completely avoided if the attributes aren't sharing predicates.
       # @return [Array<RDF::URI>]
       def filter_by_class(candidate_uris)
         return [] if candidate_uris.empty?

data/lib/active_fedora/associations/record_composite.rb

@@ -0,0 +1,39 @@
+module ActiveFedora::Associations
+  ##
+  # A Composite for records - currently only supports delete interface.
+  # The goal is to push commands down to the containing records.
+  class RecordComposite
+    attr_reader :records
+    include Enumerable
+    def initialize(records:)
+      @records = records
+    end
+
+    def each
+      records.each do |record|
+        yield record
+      end
+    end
+
+    def delete
+      self.each(&:delete)
+    end
+    ##
+    # A Repository which returns a composite from #find instead of a single
+    # record. Delegates find to a base repository.
+    class Repository
+      attr_reader :base_repository
+      delegate :translate_uri_to_id, to: :base_repository
+      def initialize(base_repository:)
+        @base_repository = base_repository
+      end
+
+      def find(ids)
+        records = ids.map do |id|
+          base_repository.find(id)
+        end
+        RecordComposite.new(records: records)
+      end
+    end
+  end
+end

data/lib/active_fedora/attached_files.rb

@@ -124,7 +124,7 @@ module ActiveFedora
     private
       def create_singleton_association(file_path)
         self.undeclared_files << file_path.to_sym
-        association = Associations::ContainsAssociation.new(self, Reflection::AssociationReflection.new(:contains, file_path, {class_name: 'ActiveFedora::File'}, self.class))
+        association = Associations::BasicContainsAssociation.new(self, Reflection::AssociationReflection.new(:contains, file_path, {class_name: 'ActiveFedora::File'}, self.class))
         @association_cache[file_path.to_sym] = association
 
         self.singleton_class.send :define_method, accessor_name(file_path) do

data/lib/active_fedora/attributes.rb

@@ -177,7 +177,7 @@ module ActiveFedora
         elsif properties.key?(:delegate_to)
           define_delegated_accessor([name], properties.delete(:delegate_to), properties.reverse_merge(multiple: true), &block)
         else
-          raise "You must provide `:datastream' or `:predicate' options to property"
+          raise "You must provide `:delegate_to' or `:predicate' options to property"
         end
       end
 
@@ -186,7 +186,7 @@ module ActiveFedora
       def define_active_triple_accessor(name, properties, &block)
         warn_duplicate_predicates name, properties
         properties = { multiple: true }.merge(properties)
-        find_or_create_defined_attribute(name, nil, properties)
+        find_or_create_defined_attribute(name, ActiveTripleAttribute, properties)
         raise ArgumentError, "#{name} is a keyword and not an acceptable property name." if protected_property_name? name
         reflection = ActiveFedora::Attributes::PropertyBuilder.build(self, name, properties, &block)
         ActiveTriples::Reflection.add_reflection self, name, reflection
@@ -197,6 +197,10 @@ module ActiveFedora
       def define_delegated_accessor(fields, delegate_target, options, &block)
         define_attribute_methods fields
         fields.each do |f|
+          klass = datastream_class_for_name(delegate_target)
+          attribute_properties = options.merge(delegate_target: delegate_target, klass: klass)
+          find_or_create_defined_attribute f, attribute_class(klass), attribute_properties
+
           create_attribute_reader(f, delegate_target, options)
           create_attribute_setter(f, delegate_target, options)
           add_attribute_indexing_config(f, &block) if block_given?
@@ -204,8 +208,7 @@ module ActiveFedora
       end
 
       def add_attribute_indexing_config(name, &block)
-        # TODO the hash can be initalized to return on of these
-        index_config[name] ||= ActiveFedora::Indexing::Map::IndexObject.new &block
+        index_config[name] ||= ActiveFedora::Indexing::Map::IndexObject.new(name, &block)
       end
 
       def warn_duplicate_predicates new_name, new_properties
@@ -215,31 +218,46 @@ module ActiveFedora
         end
       end
 
-      def find_or_create_defined_attribute(field, dsid, args)
-        delegated_attributes[field] ||= DelegatedAttribute.new(field, dsid, datastream_class_for_name(dsid), args)
+      # @param [Symbol] field the field to find or create
+      # @param [Class] klass the class to use to delegate the attribute (e.g. 
+      #                ActiveTripleAttribute, OmAttribute, or RdfDatastreamAttribute)
+      # @param [Hash] args 
+      # @option args [String] :delegate_target the path to the delegate
+      # @option args [Class] :klass the class to create
+      # @option args [true,false] :multiple (false) true for multi-value fields
+      # @option args [Array<Symbol>] :at path to a deep node 
+      # @return [DelegatedAttribute] the found or created attribute
+      def find_or_create_defined_attribute(field, klass, args)
+        delegated_attributes[field] ||= klass.new(field, args)
       end
 
       # @param [String] dsid the datastream id
       # @return [Class] the class of the datastream
       def datastream_class_for_name(dsid)
-        reflection = reflect_on_association(dsid)
+        reflection = reflect_on_association(dsid.to_sym)
         reflection ? reflection.klass : ActiveFedora::File
       end
 
       def create_attribute_reader(field, dsid, args)
-        find_or_create_defined_attribute(field, dsid, args)
-
         define_method field do |*opts|
           array_reader(field, *opts)
         end
       end
 
       def create_attribute_setter(field, dsid, args)
-        find_or_create_defined_attribute(field, dsid, args)
         define_method "#{field}=".to_sym do |v|
           self[field]=v
         end
       end
+
+      def attribute_class(klass)
+        if klass < ActiveFedora::RDFDatastream
+          RdfDatastreamAttribute 
+        else
+          OmAttribute
+        end
+      end
+
     end
   end
 end