hyrax 3.0.0.pre.rc2 → 3.0.0.pre.rc3

data/lib/wings/services/custom_queries/find_collections_by_type.rb

@@ -20,7 +20,7 @@ module Wings
       #
       # @return [Enumerable<PcdmCollection>]
       def find_collections_by_type(global_id:)
-        ::Collection.where(collection_type_gid_ssim: global_id.to_s).map(&:valkyrie_resource)
+        ::Collection.where(Hyrax.config.collection_type_index_field.to_sym => global_id.to_s).map(&:valkyrie_resource)
       end
     end
   end

data/lib/wings/services/custom_queries/find_file_metadata.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
-# Custom query override specific to Wings for finding Hydra::PCDM::File and converting to Hyrax::FileMetadata.
-# @example
-#   Hyrax.custom_queries.find_file_metadata_by(id: valkyrie_id, use_valkyrie: true)
-#   Hyrax.custom_queries.find_file_metadata_by_alternate_identifier(alternate_identifier: id, use_valkyrie: true)
-require 'wings/services/file_converter_service'
 module Wings
   module CustomQueries
+    # Custom query override specific to Wings for finding Hydra::PCDM::File and converting to Hyrax::FileMetadata.
+    #
+    # @example
+    #   Hyrax.custom_queries.find_file_metadata_by(id: valkyrie_id, use_valkyrie: true)
+    #   Hyrax.custom_queries.find_file_metadata_by_alternate_identifier(alternate_identifier: id, use_valkyrie: true)
     class FindFileMetadata
       def self.queries
         [:find_file_metadata_by,
@@ -21,69 +21,96 @@ module Wings
       attr_reader :query_service
       delegate :resource_factory, to: :query_service
 
-      # WARNING: In general, prefer find_by_alternate_identifier over this
-      # method.
+      ##
+      # Find a Hyrax::FileMetadata using a Valkyrie ID,
       #
-      # Hyrax uses a shortened noid in place of an id, and this is what is
-      # stored in ActiveFedora, which is still the storage backend for Hyrax.
+      # @param id [Valkyrie::ID, String]
+      # @param use_valkyrie [boolean] defaults to true; optionally return
+      #   ActiveFedora::File objects if false
       #
-      # If you do not heed this warning, then switch to Valyrie's Postgres
-      # MetadataAdapter, but continue passing noids to find_by, you will
-      # start getting ObjectNotFoundErrors instead of the objects you wanted
+      # @return [Hyrax::FileMetadata, Hydra::PCDM::File] - when use_valkyrie is
+      #   true, returns FileMetadata resource; otherwise, returns ActiveFedora PCDM::File
       #
-      # Find a file metadata using a Valkyrie ID, and map it to a Hyrax::FileMetadata or Hydra::PCDM::File, if use_valkyrie is true or false, respectively.
-      # @param id [Valkyrie::ID, String]
-      # @param use_valkyrie [boolean] defaults to true; optionally return ActiveFedora::File objects if false
-      # @return [Hyrax::FileMetadata, Hydra::PCDM::File] - when use_valkyrie is true, returns FileMetadata resource; otherwise, returns ActiveFedora PCDM::File
       # @raise [Hyrax::ObjectNotFoundError]
       def find_file_metadata_by(id:, use_valkyrie: true)
         find_file_metadata_by_alternate_identifier(alternate_identifier: id, use_valkyrie: use_valkyrie)
       end
 
-      # Find a file metadata using an alternate ID, and map it to a Hyrax::FileMetadata or Hydra::PCDM::File, if use_valkyrie is true or false, respectively.
+      # Find a Hyrax::FileMetadata using an alternate ID, and map it to a
+      #
+      #
       # @param alternate_identifier [Valkyrie::ID, String]
-      # @param use_valkyrie [boolean] defaults to true; optionally return ActiveFedora::File objects if false
-      # @return [Hyrax::FileMetadata, Hydra::PCDM::File] - when use_valkyrie is true, returns FileMetadata resource; otherwise, returns ActiveFedora PCDM::File
+      # @param use_valkyrie [boolean] defaults to true; optionally return
+      #   ActiveFedora::File objects if false
+      #
+      # @return [Hyrax::FileMetadata, Hydra::PCDM::File] - when use_valkyrie is
+      #   true, returns FileMetadata resource; otherwise, returns ActiveFedora PCDM::File
+      #
       # @raise [Hyrax::ObjectNotFoundError]
       def find_file_metadata_by_alternate_identifier(alternate_identifier:, use_valkyrie: true)
-        alternate_identifier = ::Valkyrie::ID.new(alternate_identifier.to_s) if alternate_identifier.is_a?(String)
-        raise Hyrax::ObjectNotFoundError unless Hydra::PCDM::File.exists?(alternate_identifier.to_s)
+        alternate_identifier = ::Valkyrie::ID.new(alternate_identifier)
         object = Hydra::PCDM::File.find(alternate_identifier.to_s)
-        return object if use_valkyrie == false
-        Wings::FileConverterService.af_file_to_resource(af_file: object)
+        raise Hyrax::ObjectNotFoundError if object.new_record?
+
+        if use_valkyrie == false
+          warn_about_deprecation
+          return object
+        end
+
+        object.valkyrie_resource
       end
 
-      # Find an array of file metadata using Valkyrie IDs, and map them to Hyrax::FileMetadata maintaining order based on given ids
+      # Find an array of file metadata using Valkyrie IDs, and map them to
+      # Hyrax::FileMetadata maintaining order based on given ids.
+      #
+      # @note Ignores non-existent ids and ids for non-file metadata resources.
+      #
       # @param ids [Array<Valkyrie::ID, String>]
-      # @param use_valkyrie [boolean] defaults to true; optionally return ActiveFedora::File objects if false
-      # @return [Array<Hyrax::FileMetadata, Hydra::PCDM::File>] or empty array if there are no ids or none of the ids map to Hyrax::FileMetadata
-      # NOTE: Ignores non-existent ids and ids for non-file metadata resources.
+      # @param use_valkyrie [boolean] defaults to true; optionally return
+      #   ActiveFedora::File objects if false
+      #
+      # @return [Array<Hyrax::FileMetadata, Hydra::PCDM::File>] or empty array
+      #   if there are no ids or none of the ids map to Hyrax::FileMetadata
       def find_many_file_metadata_by_ids(ids:, use_valkyrie: true)
-        results = []
-        ids.each do |alt_id|
+        ids.each_with_object([]) do |alt_id, results|
           begin
-            # For Wings, the id and alt_id are the same, so just use alt id querying.
-            file_metadata = query_service.custom_queries.find_file_metadata_by_alternate_identifier(alternate_identifier: alt_id, use_valkyrie: use_valkyrie)
-            results << file_metadata
+            results << find_file_metadata_by_alternate_identifier(alternate_identifier: alt_id, use_valkyrie: use_valkyrie)
           rescue Hyrax::ObjectNotFoundError
             next
           end
         end
-        results
       end
 
       ##
-      # Find file metadata for files within a resource that have the requested use.
+      # Find file metadata for files within a resource that have the requested
+      # use.
+      #
       # @param use [RDF::URI] uri for the desired use Type
-      # @param use_valkyrie [boolean] defaults to true; optionally return ActiveFedora::File objects if false
-      # @return [Array<Hyrax::FileMetadata, Hydra::PCDM::File>] or empty array if there are no files with the requested use
+      # @param use_valkyrie [boolean] defaults to true; optionally return
+      #   ActiveFedora::File objects if false
+      #
+      # @return [Array<Hyrax::FileMetadata, Hydra::PCDM::File>] or empty array
+      #   if there are no files with the requested use
+      #
       # @example
       #   Hyrax.query_service.find_file_metadata_by_use(use: ::RDF::URI("http://pcdm.org/ExtractedText"))
+      #
       def find_many_file_metadata_by_use(resource:, use:, use_valkyrie: true)
         pcdm_files = find_many_file_metadata_by_ids(ids: resource.file_ids, use_valkyrie: false)
         pcdm_files.select! { |pcdm_file| pcdm_file.metadata_node.type.include?(use) }
-        return pcdm_files if use_valkyrie == false
-        pcdm_files.collect { |pcdm_file| Wings::FileConverterService.af_file_to_resource(af_file: pcdm_file) }
+
+        if use_valkyrie == false
+          warn_about_deprecation
+          return pcdm_files
+        end
+
+        pcdm_files.map(&:valkyrie_resource)
+      end
+
+      private
+
+      def warn_about_deprecation
+        Deprecation.warn("use_valkyrie: is deprecated for valkyrie/wings queries")
       end
     end
   end

data/lib/wings/services/file_converter_service.rb

@@ -1,67 +1,18 @@
 # frozen_string_literal: true
 # Conversion service for going between files on a valkyrie resource and files on an active fedora object
 module Wings
+  # @deprecated use generic Wings converters instead.
+  # @see ModelTransformer, ActiveFedoraConverter
   class FileConverterService
     class << self
       def af_file_to_resource(af_file:)
-        return if af_file&.id.blank?
-        attrs = base_af_file_attributes(af_file: af_file)
-        attrs = metadata_node_to_attributes(metadata_node: af_file.metadata_node,
-                                            attributes: attrs)
-        Hyrax::FileMetadata.new(attrs)
+        Deprecation.warn("Use ModelTransformer.for(af_file) instead.")
+        ModelTransformer.for(af_file)
       end
 
       def resource_to_af_file(metadata_resource:)
-        return if metadata_resource&.alternate_ids.blank?
-        af_file = Hydra::PCDM::File.new(id: metadata_resource.alternate_ids.first.to_s)
-        af_file.content = content(metadata_resource)
-        af_file.original_name = metadata_resource.original_filename.first
-        af_file.mime_type = metadata_resource.mime_type.first
-        valkyrie_attributes_to_af_file(attributes: metadata_resource.attributes,
-                                       af_file: af_file)
-        af_file
-      end
-
-      private
-
-      # extracts attributes that come from the af_file
-      def base_af_file_attributes(af_file:)
-        id = ::Valkyrie::ID.new(af_file.id)
-        { id: id,
-          alternate_ids: [id],
-          file_identifiers: [id],
-          created_at: af_file.create_date,
-          updated_at: af_file.modified_date,
-          content: af_file.content,
-          size: af_file.size,
-          original_filename: [af_file.original_name],
-          mime_type: [af_file.mime_type],
-          type: af_file.metadata_node.type.to_a }
-      end
-
-      # extracts attributes that come from the metadata_node
-      def metadata_node_to_attributes(metadata_node:, attributes:)
-        af_attrs = metadata_node.attributes.dup
-        af_attrs.delete('id')
-        af_attrs.each { |k, v| attributes[k.to_sym] = Array(v) unless attributes.key?(k.to_sym) }
-        attributes
-      end
-
-      def valkyrie_attributes_to_af_file(attributes:, af_file:)
-        attributes.each do |k, v|
-          next if [:id, :content, :type].include? k
-          mname = (k.to_s + '=').to_sym
-          if af_file.respond_to? mname
-            af_file.send(mname, v)
-          elsif af_file.metadata_node.respond_to? mname
-            af_file.metadata_node.send(mname, v)
-          end
-        end
-      end
-
-      def content(metadata_resource)
-        return nil if metadata_resource.content.blank?
-        metadata_resource.content.first
+        Deprecation.warn("Use ActiveFedoraConverter.convert(resource:) instead.")
+        ActiveFedoraConverter.convert(resource: metadata_resource)
       end
     end
   end

data/lib/wings/services/file_metadata_builder.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
-# TODO: The file_metadata resource and the file_metadata_builder should be in Hyrax as they will be needed for non-wings valkyrie implementations too.
 
 module Wings
   # Stores a file and an associated Hyrax::FileMetadata
+  #
+  # @deprecated use `Hyrax.storage_adapter` instead
   class FileMetadataBuilder
     include Hyrax::Noid
 
     attr_reader :storage_adapter, :persister
     def initialize(storage_adapter:, persister:)
+      Deprecation.warn('This class is deprecated; use Wings::Valkyrie::Storage instead.')
       @storage_adapter = storage_adapter
       @persister = persister
     end
@@ -16,18 +18,20 @@ module Wings
     # @param file_metadata [Hyrax::FileMetadata] the metadata to represent the file
     # @param file_set [Valkyrie::Resouce, Hydra::Works::FileSet] the associated FileSet # TODO: WINGS - Remove Hydra::Works::FileSet as a potential type when valkyrization is complete.
     # @return [Hyrax::FileMetadata] the persisted metadata file_metadata that represents the file
+    #
+    # @deprecated use `Hyrax.storage_adapter` instead
     def create(io_wrapper:, file_metadata:, file_set:)
+      Deprecation.warn('Use storage_adapter.upload, Fedora creates a `FileMetadata` (describedBy) implictly. ' \
+                       'Query it with Hyrax.custom_queries.find_file_metadata_by(id: stored_file.id).')
       io_wrapper = build_file(io_wrapper, file_metadata.type)
-      file_set.save unless file_set.persisted?
-      file_metadata.id = ::Valkyrie::ID.new(assign_id)
-      file_metadata.file_set_id = file_set.id
       stored_file = storage_adapter.upload(file: io_wrapper,
                                            original_filename: io_wrapper.original_filename,
                                            content_type: io_wrapper.content_type,
-                                           resource: file_metadata,
-                                           resource_uri_transformer: Hyrax.config.resource_id_to_uri_transformer)
-      file_metadata.file_identifiers = [stored_file.id]
-      attach_file_metadata(file_metadata: file_metadata, file_set: file_set)
+                                           resource: file_set,
+                                           use: Array(file_metadata.type).first,
+                                           id_hint: assign_id)
+
+      Hyrax.custom_queries.find_file_metadata_by(id: stored_file.id)
     end
 
     # @param file_metadata [Hyrax::FileMetadata] the metadata to represent the file

data/lib/wings/setup.rb

@@ -1,11 +1,65 @@
 # frozen_string_literal: true
 
 ActiveFedora::Base.include Wings::Valkyrizable
+ActiveFedora::File.include Wings::Valkyrizable
+
+module ActiveTriples
+  class NodeConfig
+    ##
+    # all ActiveTriples nodes are multiple
+    #
+    # this is a commonly used method on ActiveFedora's node configurations
+    # adding the method here gives us a more consistent interface from
+    # `ActiveFedora::Base.properties`.
+    def multiple?
+      true
+    end
+  end
+end
 
 module ActiveFedora
   def self.model_mapper
     ActiveFedora::DefaultModelMapper.new(classifier_class: Wings::ActiveFedoraClassifier)
   end
+
+  class Base
+    def self.supports_property?(property)
+      property == :permissions ||
+        property.to_s.end_with?('_attributes') ||
+        properties.key?(property.to_s) ||
+        reflections.key?(property.to_sym)
+    end
+  end
+
+  class File
+    alias eql? ==
+
+    def self.supports_property?(property)
+      properties.key?(property.to_s)
+    end
+
+    def self.properties
+      metadata.properties
+    end
+  end
+
+  module Associations
+    class ContainerProxy
+      delegate :build_or_set, to: :@association
+    end
+
+    class ContainsAssociation
+      def build_or_set(attributes, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| build_or_set(attr, &block) }
+        else
+          add_to_target(reflection.build_association(attributes)) do |record|
+            yield(record) if block_given?
+          end
+        end
+      end
+    end
+  end
 end
 
 Valkyrie::MetadataAdapter.register(
@@ -13,16 +67,8 @@ Valkyrie::MetadataAdapter.register(
 )
 Valkyrie.config.metadata_adapter = :wings_adapter
 
-if ENV['RAILS_ENV'] == 'test'
-  Valkyrie::MetadataAdapter.register(
-    Valkyrie::Persistence::Memory::MetadataAdapter.new, :test_adapter
-  )
-end
-
 Valkyrie::StorageAdapter.register(
-  Wings::Storage::ActiveFedora
-    .new(connection: Ldp::Client.new(ActiveFedora.fedora.host), base_path: ActiveFedora.fedora.base_path),
-  :active_fedora
+  Wings::Valkyrie::Storage.new, :active_fedora
 )
 Valkyrie.config.storage_adapter = :active_fedora
 
@@ -47,3 +93,4 @@ Wings::ModelRegistry.register(Hyrax::PcdmCollection,    ::Collection)
 Wings::ModelRegistry.register(Hyrax::FileSet,           FileSet)
 Wings::ModelRegistry.register(Hyrax::Embargo,           Hydra::AccessControls::Embargo)
 Wings::ModelRegistry.register(Hyrax::Lease,             Hydra::AccessControls::Lease)
+Wings::ModelRegistry.register(Hyrax::FileMetadata,      Hydra::PCDM::File)

data/lib/wings/transformer_value_mapper.rb

@@ -72,6 +72,7 @@ module Wings
     ##
     # @return [Enumerable<Object>]
     def result
+      return calling_mapper.for(value.first).result if value.length < 2
       value.map { |v| calling_mapper.for(v).result }
     end
   end

data/lib/wings/valkyrie/metadata_adapter.rb

@@ -7,7 +7,7 @@ module Wings
         @persister ||= Wings::Valkyrie::Persister.new(adapter: self)
       end
 
-      # @return [Class] {Valkyrie::Persistence::Postgres::QueryService}
+      # @return [Class] +Valkyrie::Persistence::Postgres::QueryService+
       def query_service
         @query_service ||= Wings::Valkyrie::QueryService.new(adapter: self)
       end
@@ -20,7 +20,7 @@ module Wings
         end
       end
 
-      # @return [Class] {Valkyrie::Persistence::Postgres::ResourceFactory}
+      # @return [Class] +Valkyrie::Persistence::Postgres::ResourceFactory+
       def resource_factory
         @resource_factory ||= Wings::Valkyrie::ResourceFactory.new(adapter: self)
       end

data/lib/wings/valkyrie/persister.rb

@@ -1,6 +1,12 @@
 # frozen_string_literal: true
 module Wings
   module Valkyrie
+    ##
+    # A valkyrie persister that aims for data consistency/backwards compatibility with ActiveFedora.
+    #
+    # The guiding principle of design for this persister is that resources persisted with it should
+    # be directly readable by `Hydra::Works`-style ActiveFedora models. It aims to be as complete as
+    # possible as a Valkyrie Persister, given that limitation.
     class Persister
       attr_reader :adapter
       extend Forwardable
@@ -16,28 +22,21 @@ module Wings
       # @param [Valkyrie::Resource] resource
       # @return [Valkyrie::Resource] the persisted/updated resource
       def save(resource:)
-        return save_file(file_metadata: resource) if resource.is_a? Hyrax::FileMetadata
         af_object = resource_factory.from_resource(resource: resource)
 
         check_lock_tokens(af_object: af_object, resource: resource)
 
-        af_object.save!
+        # the #save! api differs between ActiveFedora::Base and ActiveFedora::File objects,
+        # if we get a falsey response, we expect we have a File that has failed to save due
+        # to empty content
+        af_object.save! ||
+          raise(FailedSaveError.new("#{af_object.class}#save! returned non-true. It might be missing required content.", obj: af_object))
+
         resource_factory.to_resource(object: af_object)
-      rescue ActiveFedora::RecordInvalid => err
+      rescue ActiveFedora::RecordInvalid, RuntimeError => err
         raise FailedSaveError.new(err.message, obj: af_object)
       end
 
-      def save_file(file_metadata:)
-        # This is a no-op when the file is being created or updated through the FileActor.
-        # There may be other scenarios where something needs to happen here.
-        file_metadata
-
-        # TODO: potentially need to...
-        #   find existing af File
-        #   convert file_metadata resource into af File metadata
-        #   save af File
-      end
-
       # Persists a resource using ActiveFedora
       # @param [Valkyrie::Resource] resource
       # @return [Valkyrie::Resource] the persisted/updated resource

data/lib/wings/valkyrie/storage.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Wings
+  module Valkyrie
+    ##
+    # This is a Wings storage adapter designed for compatibility with
+    # Hydra::Pcdm/Hydra::Works.
+    #
+    # Where the built-in `Valkyrie::Storage::Fedora` adapter uploads files
+    # without LDP containment relationships (via HTTP PUT), this adapter
+    # supports adding files to a `/files` container when a `FileSet` is
+    # passed as the `resource:` argument.
+    #
+    # If a non `#file_set?` resource is passed, the logic is very similar to the
+    # built-in storage adapter.
+    #
+    # For use with Hyrax, this adapter defaults to Fedora 4.
+    class Storage < ::Valkyrie::Storage::Fedora
+      DEFAULT_CTYPE = 'application/octet-stream'
+      LINK_HEADER = "<http://www.w3.org/ns/ldp#NonRDFSource>; rel=\"type\""
+      FILES_PATH = 'files'
+
+      attr_reader :sha1
+
+      def initialize(connection: Ldp::Client.new(ActiveFedora.fedora.host), base_path: ActiveFedora.fedora.base_path, fedora_version: 4)
+        @sha1 = fedora_version == 5 ? "sha" : "sha1"
+        super
+      end
+
+      def upload(file:, original_filename:, resource:, content_type: DEFAULT_CTYPE, # rubocop:disable Metrics/ParameterLists
+                 resource_uri_transformer: default_resource_uri_transformer, use: Hydra::PCDM::Vocab::PCDMTerms.File,
+                 id_hint: 'original', **extra_arguments)
+        id = if resource.try(:file_set?)
+               upload_with_works(resource: resource, file: file, use: use)
+             else
+               put_file(file: file,
+                        original_filename: original_filename,
+                        resource: resource,
+                        content_type: content_type,
+                        resource_uri_transformer: resource_uri_transformer,
+                        id_hint: id_hint, **extra_arguments)
+             end
+
+        find_by(id: ::Valkyrie::ID.new(id.to_s.sub(/^.+\/\//, PROTOCOL)))
+      end
+
+      private
+
+      def digest_for(file)
+        "#{sha1}=#{Digest::SHA1.file(file)}"
+      end
+
+      def default_resource_uri_transformer
+        lambda do |resource, hint|
+          id = [CGI.escape(resource.id), FILES_PATH, hint].join('/')
+          RDF::URI.new(Hyrax.config.translate_id_to_uri.call(id))
+        end
+      end
+
+      ##
+      # Create a file with HTTP put; no containers here.
+      # @return [String] the identifier of the created file
+      def put_file(file:, original_filename:, resource:, content_type:, # rubocop:disable Metrics/ParameterLists
+                   resource_uri_transformer:, id_hint:, **_extra_arguments)
+        identifier = resource_uri_transformer.call(resource, id_hint)
+
+        connection.http.put do |request|
+          request.url identifier
+          request.headers['Content-Type'] = content_type
+          request.headers['Content-Length'] = (file.try(:size) || file.try(:length)).to_s
+          request.headers['Content-Disposition'] = "attachment; filename=\"#{original_filename}\""
+          request.headers['digest'] = digest_for(file)
+          request.headers['link'] = LINK_HEADER
+          request.body = Faraday::UploadIO.new(file, content_type, original_filename)
+        end
+
+        identifier
+      end
+
+      def upload_with_works(resource:, file:, use:)
+        file_set = FileSet.find(resource.id.to_s)
+
+        Hydra::Works::AddFileToFileSet.call(file_set, file, use)
+
+        created_file = file_set.filter_files_by_type(use).first
+        raise(StorageError, "Couldn't find a file we tried to create on #{file_set}") unless created_file
+
+        Hyrax.config.translate_id_to_uri.call(created_file.id)
+      end
+    end
+  end
+
+  class StorageError < RuntimeError; end
+end