active-fedora 8.7.0 → 9.0.0.beta1

data/lib/active_fedora/associations/contains_association.rb

@@ -0,0 +1,50 @@
+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)
+      end
+
+      def target_uri
+        "#{owner.uri}/#{reflection.name}"
+      end
+
+      private
+
+      def raise_on_type_mismatch(record)
+        return if record.is_a? LoadableFromJson::SolrBackedMetadataFile
+        super
+      end
+
+      def replace(record)
+        if record
+          raise_on_type_mismatch(record)
+          @updated = true
+        end
+
+        self.target = record
+      end
+
+      def new_record(method, attributes)
+        record = super
+        configure_datastream(record)
+        record
+      end
+
+      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)
+        end
+        if record.new_record? && reflection.options[:autocreate]
+          record.datastream_will_change!
+        end
+      end
+    end
+  end
+end

data/lib/active_fedora/associations/has_and_belongs_to_many_association.rb

@@ -15,36 +15,51 @@ module ActiveFedora
           end
         end
 
-        ### TODO save relationship
-        @owner.add_relationship(@reflection.options[:property], record)
+        owner[reflection.foreign_key] ||= []
+        owner[reflection.foreign_key] += [record.id]
 
         if @owner.new_record? and @reflection.options[:inverse_of]
           ActiveFedora::Base.logger.warn("has_and_belongs_to_many #{@reflection.inspect} is cowardly refusing to insert the inverse relationship into #{record}, because #{@owner} is not persisted yet.") if ActiveFedora::Base.logger
         elsif @reflection.options[:inverse_of]
-          record.add_relationship(@reflection.options[:inverse_of], @owner)
+          inverse = @reflection.inverse_of
+          record[inverse.foreign_key] ||= []
+          record[inverse.foreign_key] += [owner.id]
           record.save
         end
 
         return true
       end
 
+      def concat_records(*records)
+        result = true
 
-      def find_target
-          page_size = @reflection.options[:solr_page_size]
-          page_size ||= 200
-          pids = @owner.ids_for_outbound(@reflection.options[:property])
-          return [] if pids.empty?
-          solr_result = []
-          0.step(pids.size,page_size) do |startIdx|
-            query = ActiveFedora::SolrService.construct_query_for_pids(pids.slice(startIdx,page_size))
-            solr_result += ActiveFedora::SolrService.query(query, rows: page_size)
+        records.flatten.each do |record|
+          raise_on_type_mismatch(record)
+          add_to_target(record) do |r|
+            result &&= insert_record(record)
           end
-          return ActiveFedora::SolrService.reify_solr_results(solr_result)
+        end
+
+        result && records
       end
 
-      # In a HABTM, just look in the rels-ext, no need to run a count query from solr.
+
+      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::SolrService.construct_query_for_ids(ids.slice(startIdx,page_size))
+          solr_result += ActiveFedora::SolrService.query(query, rows: page_size)
+        end
+        return ActiveFedora::SolrService.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.ids_for_outbound(@reflection.options[:property]).size
+        owner[reflection.foreign_key].size
       end
 
       def first
@@ -59,19 +74,24 @@ module ActiveFedora
 
         def delete_records(records, method)
           records.each do |r|
-            @owner.remove_relationship(@reflection.options[:property], r)
-            
+            owner[reflection.foreign_key] -= [r.id]
+
             if (@reflection.options[:inverse_of])
-              r.remove_relationship(@reflection.options[:inverse_of], @owner)
-              # It looks like inverse_of points at a predicate, not at a relationship name,
-              # which is what we should have done. Now we need a way to look up the
-              # reflection by predicate
-              name = r.class.reflection_name_for_predicate(@reflection.options[:inverse_of])
-              r.association(name).reset
+              inverse = @reflection.inverse_of
+              r[inverse.foreign_key] -= [owner.id]
+              r.association(inverse.name).reset
               r.save
             end
           end
-          @owner.save! unless @owner.new_record?
+          unless @owner.new_record? || @owner.destroyed?
+            @owner.save!
+          end
+        end
+
+      private
+
+        def stale_state
+          owner[reflection.foreign_key]
         end
 
     end

data/lib/active_fedora/associations/has_many_association.rb

@@ -14,7 +14,7 @@ module ActiveFedora
       # 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 loaded? 
+        count = if loaded?
           @target.size
         else
           @reflection.klass.count(:conditions => @counter_query)
@@ -28,18 +28,52 @@ module ActiveFedora
         return count
       end
 
-      def insert_record(record, force = false, validate = true)
-        set_belongs_to_association_for(record)
-        record.save
+      def set_owner_attributes(record)
+        if klass == ActiveFedora::Base
+          inverse = find_polymorphic_inverse(record)
+          if inverse.belongs_to?
+            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
+      end
+
+      def insert_record(record, validate = true, raise = false)
+        set_owner_attributes(record)
+        set_inverse_instance(record)
+
+        if raise
+          record.save!(validate: validate)
+        else
+          record.save(validate: validate)
+        end
       end
 
       protected
 
+        def find_polymorphic_inverse(record)
+          record.reflections.values.find{ |r| !r.has_many? && r.options[:property] == reflection.options[:property]}
+        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
             # Find all the records that point to this and nullify them
             # keys  = records.map { |r| r[reflection.association_primary_key] }
@@ -50,22 +84,22 @@ module ActiveFedora
               #update_counter(-scope.delete_all)
             else
 
-                
               if reflection.inverse_of # Can't get an inverse when class_name: 'ActiveFedora::Base' is supplied
-                inverse = reflection.inverse_of.name
+                inverse = reflection.inverse_of
                 records.each do |record|
                   if record.persisted?
-                    assoc = record.association(inverse)
-                    if assoc.reflection.collection?
+                    if inverse.collection?
                       # Remove from a has_and_belongs_to_many
-                      record.association(inverse).delete(@owner)
+                      record.association(inverse.name).delete(@owner)
+                    elsif inverse.klass == ActiveFedora::Base
+                      record[inverse.foreign_key] = nil
                     else
                       # Remove from a belongs_to
-                      record.association(inverse).id_writer(nil)
+                      record[reflection.foreign_key] = nil
                     end
                     # Check to see if the object still exists (may be already deleted).
                     # In Rails, they do this with an update_all to avoid callbacks and validations, we may need the same.
-                    record.save! if record.class.exists?(record.pid)
+                    record.save! if record.class.exists?(record.id)
                   end
                 end
               end
@@ -74,8 +108,6 @@ module ActiveFedora
             end
           end
         end
-
-        
     end
   end
 end

data/lib/active_fedora/associations/rdf.rb

@@ -0,0 +1,86 @@
+module ActiveFedora
+  module Associations
+    class RDF < SingularAssociation #:nodoc:
+
+      def replace(values)
+        raise "can't modify frozen #{owner.class}" if owner.frozen?
+        destroy
+        values.each do |value|
+          uri = ActiveFedora::Base.id_to_uri(value)
+          owner.resource.insert [owner.rdf_subject, reflection.predicate, ::RDF::URI.new(uri)]
+        end
+        owner.send(:attribute_will_change!, reflection.name)
+      end
+
+      def reader
+        filtered_results.map { |val| ActiveFedora::Base.uri_to_id(val) }
+      end
+
+      def destroy
+        filtered_results.each do |candidate|
+          owner.resource.delete([owner.rdf_subject, reflection.predicate, candidate])
+        end
+      end
+
+      private
+
+      # @return [Array<RDF::URI>] the rdf results filtered to objects that match the specified class_name consraint
+      def filtered_results
+        if filtering_required?
+          filter_by_class(rdf_uris)
+        else
+          rdf_uris
+        end
+      end
+
+      # TODO Detect when this is the only relationship for this predicate, then skip the filtering.
+      def filtering_required?
+        reflection.klass != ActiveFedora::Base
+      end
+
+      # @return [Array<RDF::URI>]
+      def rdf_uris
+        rdf_query.map(&:object)
+      end
+
+      # @return [Array<RDF::Statement>]
+      def rdf_query
+        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?
+        ids = candidate_uris.map {|uri| ActiveFedora::Base.uri_to_id(uri) }
+        results = ActiveFedora::SolrService.query(ActiveFedora::SolrService.construct_query_for_ids(ids), rows: 10000)
+
+        docs = results.select do |result|
+          ActiveFedora::SolrService.classes_from_solr_document(result).any? { |klass|
+            class_ancestors(klass).include? reflection.klass
+          }
+        end
+
+        docs.map {|doc| ::RDF::URI.new(ActiveFedora::Base.id_to_uri(doc['id']))}
+      end
+
+      ##
+      # Returns a list of all the ancestor classes up to ActiveFedora::Base including the class itself
+      # @param [Class] klass
+      # @return [Array<Class>]
+      # @example
+      #   class Car < ActiveFedora::Base; end
+      #   class SuperCar < Car; end
+      #   class_ancestors(SuperCar)
+      #   # => [SuperCar, Car, ActiveFedora::Base]
+      def class_ancestors(klass)
+        klass.ancestors.select {|k| k.instance_of?(Class) } - [Object, BasicObject]
+      end
+
+
+
+    end
+  end
+end
+

data/lib/active_fedora/associations/singular_association.rb

@@ -5,6 +5,7 @@ module ActiveFedora
       # Implements the reader method, e.g. foo.bar for Foo.has_one :bar
       def reader(force_reload = false)
         if force_reload
+          raise NotImplementedError, "Need to define the uncached method" #TODO
           klass.uncached { reload }
         elsif !loaded? || stale_target?
           reload
@@ -17,7 +18,6 @@ module ActiveFedora
         replace(record)
       end
 
-
       def create(attributes = {})
         new_record(:create, attributes)
       end
@@ -33,7 +33,9 @@ module ActiveFedora
       private
 
         def find_target
-          scoped.first.tap { |record| set_inverse_instance(record) }
+          # TODO this forces a solr query, but I think it's likely we can just lookup from Fedora.
+          rec = scope.take
+          rec.tap { |record| set_inverse_instance(record) }
         end
 
         # Implemented by subclasses
@@ -45,12 +47,6 @@ module ActiveFedora
           replace(record)
         end
 
-        def check_record(record)
-          record = record.target if Association === record
-          raise_on_type_mismatch(record) if record
-          record
-        end
-
         def new_record(method, attributes)
           attributes = {} #scoped.scope_for_create.merge(attributes || {})
           record = @reflection.send("#{method}_association", attributes)

data/lib/active_fedora/associations/singular_rdf.rb

@@ -0,0 +1,15 @@
+module ActiveFedora
+  module Associations
+    class SingularRDF < RDF #:nodoc:
+
+      def replace(value)
+        super(Array(value))
+      end
+
+      def reader
+        super.first
+      end
+
+    end
+  end
+end

data/lib/active_fedora/attached_files.rb

@@ -0,0 +1,195 @@
+require 'deprecation'
+
+module ActiveFedora
+  module AttachedFiles
+    extend ActiveSupport::Concern
+    extend Deprecation
+    self.deprecation_horizon = "active-fedora 10.0"
+
+    def ds_specs
+      self.class.child_resource_reflections
+    end
+    deprecation_deprecate :ds_specs
+
+    def serialize_attached_files
+      attached_files.each_value {|file| file.serialize! }
+    end
+
+    #
+    # Attached file management
+    #
+
+    # Returns all known attached files for the object.  If the object has been
+    # saved to fedora, the persisted files will be included.
+    # Attached files that have been modified in memory are given preference over
+    # the copy in Fedora.
+    def attached_files
+      @attached_files ||= FilesHash.new(self)
+    end
+
+    def datastreams
+      attached_files
+    end
+    deprecation_deprecate :datastreams
+
+    def clear_attached_files
+      @attached_files = nil
+    end
+
+    def clear_datastreams
+      clear_attached_files
+    end
+    deprecation_deprecate :clear_datastreams
+
+    def datastream_assertions
+      resource.query(subject: resource, predicate: Ldp.contains).objects.map(&:to_s)
+    end
+
+    def load_attached_files
+      datastream_assertions.each do |ds_uri|
+        dsid = ds_uri.to_s.sub(uri + '/', '')
+        next if association(dsid.to_sym)
+        create_singleton_association(dsid)
+      end
+    end
+
+    # Adds datastream to the object.
+    # @return [String] dsid of the added datastream
+    def attach_file(file, file_path, opts={})
+      create_singleton_association(file_path)
+      attached_files[file_path] = file
+      file_path
+    end
+
+    def add_datastream(datastream, opts={})
+      attach_file(datastream, opts)
+    end
+    deprecation_deprecate :add_datastream
+
+    # @return [Array] all attached files that return true for `metadata?` and are not Rels-ext
+    def metadata_streams
+      attached_files.select { |k, ds| ds.metadata? }.values
+    end
+
+    #
+    # File Management
+    #
+
+    # Attach the given file to object
+    #
+    # @param [File] file the file to add
+    # @param [Hash] opts options: :dsid, :prefix, :mime_type
+    # @option opts [String] :dsid The datastream id
+    # @option opts [String] :prefix The datastream prefix (for auto-generated dsid)
+    # @option opts [String] :mime_type The Mime-Type of the file
+    # @option opts [String] :original_name The original name of the file (used for Content-Disposition)
+    def add_file_datastream(file, opts={})
+      find_or_create_child_resource(opts).tap do |node|
+        node.content = file
+        node.mime_type = if opts[:mimeType]
+          Deprecation.warn AttachedFiles, "The :mimeType option to add_file_datastream is deprecated and will be removed in active-fedora 10.0. Use :mime_type instead", caller
+          opts[:mimeType]
+        else
+          opts[:mime_type]
+        end
+        node.original_name = opts[:original_name]
+      end
+    end
+
+    def undeclared_files
+      @undeclared_files ||= []
+    end
+
+
+    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_cache[file_path.to_sym] = association
+
+        self.singleton_class.send :define_method, accessor_name(file_path) do
+           @association_cache[file_path.to_sym].reader
+        end
+        association
+      end
+
+      def find_or_create_child_resource(opts)
+        association = association(opts[:dsid].to_sym) if opts[:dsid]
+        association ||= begin
+          file_path = FilePathBuilder.build(self, opts[:dsid], opts[:prefix])
+          create_singleton_association(file_path)
+        end
+        association.reader
+      end
+
+      ## Given a file_path return a standard name
+      def accessor_name(file_path)
+        file_path.gsub('-', '_')
+      end
+
+
+    module ClassMethods
+      extend Deprecation
+      self.deprecation_horizon = 'active-fedora version 10.0'
+
+      def ds_specs
+        child_resource_reflections
+      end
+      deprecation_deprecate :ds_specs
+
+      # This method is used to specify the details of a datastream.
+      # You can pass the name as the first argument and a hash of options as the second argument
+      # or you can pass the :name as a value in the args hash. Either way, name is required.
+      # Note that this method doesn't actually execute the block, but stores it, to be executed
+      # by any the implementation of the datastream(specified as :type)
+      #
+      # @param [Hash] args
+      # @option args [Class] :type The class that will represent this datastream, should extend ``ActiveFedora::File''
+      # @option args [String] :name the handle to refer to this datastream as
+      # @option args [String] :url
+      # @option args [Boolean] :autocreate Always create this datastream on new objects
+      # @yield block executed by some kinds of datastreams
+      def has_metadata(*args, &block)
+        if args.first.is_a? String
+          name = args.first
+          args = args[1] || {}
+          args[:name] = name
+        else
+          args = args.first || {}
+        end
+        name = args.delete(:name)
+        raise ArgumentError, "You must provide a :type property for the datastream '#{name}'" unless args[:type]
+        args[:class_name] = args.delete(:type).to_s
+        contains(name, args, &block)
+      end
+      deprecation_deprecate :has_metadata
+
+
+      # @overload has_file_datastream(name, args)
+      #   Declares a file datastream exists for objects of this type
+      #   @param [String] name
+      #   @param [Hash] args
+      #     @option args :type (ActiveFedora::File) The class the datastream should have
+      #     @option args [Boolean] :autocreate Always create this datastream on new objects
+      # @overload has_file_datastream(args)
+      #   Declares a file datastream exists for objects of this type
+      #   @param [Hash] args
+      #     @option args :name ("content") The dsid of the datastream
+      #     @option args :type (ActiveFedora::File) The class the datastream should have
+      #     @option args [Boolean] :autocreate Always create this datastream on new objects
+      def has_file_datastream(*args)
+        if args.first.is_a? String
+          name = args.first
+          args = args[1] || {}
+          args[:name] = name
+        else
+          args = args.first || {}
+        end
+        name = args.delete(:name)
+        args[:class_name] = args.delete(:type).to_s
+        contains(name, args)
+      end
+      deprecation_deprecate :has_file_datastream
+    end
+  end
+end