hyrax 2.8.0 → 3.0.0.pre.rc2

data/lib/wings/hydra/pcdm/models/concerns/collection_valkyrie_behavior.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require 'wings/hydra/pcdm/models/concerns/pcdm_valkyrie_behavior'
+
+module Wings
+  module Pcdm
+    module CollectionValkyrieBehavior
+      extend ActiveSupport::Concern
+
+      included do
+        include Wings::Pcdm::PcdmValkyrieBehavior
+      end
+
+      ##
+      # @return [Boolean] whether this instance is a PCDM Object.
+      def pcdm_object?
+        false
+      end
+
+      ##
+      # @return [Boolean] whether this instance is a PCDM Collection.
+      def pcdm_collection?
+        true
+      end
+
+      # TODO: Add translated methods
+    end
+  end
+end

data/lib/wings/hydra/pcdm/models/concerns/object_valkyrie_behavior.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require 'wings/active_fedora_converter'
+
+module Wings
+  module Pcdm
+    module ObjectValkyrieBehavior
+      extend ActiveSupport::Concern
+
+      included do
+        include Wings::Pcdm::PcdmValkyrieBehavior
+      end
+
+      ##
+      # @return [Boolean] whether this instance is a PCDM Object.
+      def pcdm_object?
+        true
+      end
+
+      ##
+      # @return [Boolean] whether this instance is a PCDM Collection.
+      def pcdm_collection?
+        false
+      end
+
+      # TODO: Add translated methods
+    end
+  end
+end

data/lib/wings/hydra/pcdm/models/concerns/pcdm_valkyrie_behavior.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+require 'wings/active_fedora_converter'
+
+module Wings
+  module Pcdm
+    module PcdmValkyrieBehavior
+      extend ActiveSupport::Concern
+
+      included do
+        attribute :member_of_collection_ids, ::Valkyrie::Types::Set.of(::Valkyrie::Types::ID)
+        attribute :member_ids, ::Valkyrie::Types::Array.of(::Valkyrie::Types::ID).meta(ordered: true)
+        # TODO: get/set via members and ordered_members
+        #   * get objs - For both, this is the same as #objects. Because the Array in Valkyrie is ordered, everything will be ordered
+        #   * get ids - always returns valkyrie ids -- can't define a method for member_ids(valkyrie: false) which would return af ids
+        #   * set - In AF, members and ordered_members are enumerable and can be set using operators << and +=.
+        #           Since member_ids is all that keeps these in wings, how can we do that here?
+      end
+
+      # TODO: Methods requiring further investigation...
+      #   #type_validator class method
+      #   #ancestor?
+
+      # TODO: Should these method NOT USED BY HYRAX be converted...
+      #   #related_object_ids
+      #   #related_objects
+
+      ##
+      # @return [Enumerable<ActiveFedora::Base> | Enumerable<Valkyrie::Resource>] an enumerable over the parent collections
+      def parent_collections(valkyrie: false)
+        af_collections = parent_collection_ids.map { |id| ActiveFedora::Base.find(id) }
+        return af_collections unless valkyrie
+        af_collections.map(&:valkyrie_resource)
+      end
+      alias member_of_collections parent_collections
+
+      ##
+      # @return [Enumerable<String> | Enumerable<Valkyrie::ID] the parent collection ids
+      def parent_collection_ids(valkyrie: false)
+        return member_of_collection_ids if valkyrie
+        member_of_collection_ids.map(&:id)
+      end
+      # alias member_of_collection_ids child_object_ids # TODO: Cannot alias in this way because member_of_collection_ids method is already defined thru the attribute definition.
+
+      ##
+      # @return [Enumerable<ActiveFedora::Base> | Enumerable<Valkyrie::Resource>] an enumerable over the child collections
+      # @todo There is no guarantee to collection ordering until Hyrax is fully valkyrie-native, see issue 3784
+      def child_collections(valkyrie: false)
+        resources = Hyrax.custom_queries.find_child_collections(resource: self)
+        return resources if valkyrie
+        resources.map { |r| Wings::ActiveFedoraConverter.new(resource: r).convert }
+      end
+      alias collections child_collections
+      alias member_collections child_collections
+      alias ordered_collections child_collections
+
+      ##
+      # @return [Enumerable<String> | Enumerable<Valkyrie::ID] the child collection ids
+      # @todo There is no guarantee to collection ordering until Hyrax is fully valkyrie-native, see issue 3784
+      def child_collection_ids(valkyrie: false)
+        child_collections(valkyrie: valkyrie).map(&:id)
+      end
+      alias collection_ids child_collection_ids
+      alias member_collection_ids child_collection_ids
+      alias ordered_collection_ids child_collection_ids
+
+      ##
+      # Gives the subset of #members that are PCDM objects
+      # @return [Enumerable<ActiveFedora::Base> | Enumerable<Valkyrie::Resource>] an enumerable over the members
+      #   that are PCDM objects
+      # @note A collection could be added to members, but for Hyrax collections are stored using member_of_collection_ids.
+      #       As long as this rule holds, then members and ordered_members are equivalent to objects/child_objects.
+      # @todo Do we want to support members separate from child_objects (see NOTE)
+      def child_objects(valkyrie: false)
+        af_objects = Wings::ActiveFedoraConverter.new(resource: self).convert.objects
+        return af_objects unless valkyrie
+        af_objects.map(&:valkyrie_resource)
+      end
+      alias objects child_objects
+      alias ordered_objects child_objects
+      alias members child_objects
+      alias ordered_members child_objects
+      alias member_works child_objects
+
+      ##
+      # Gives a subset of #member_ids, where all elements are PCDM objects.
+      # @return [Enumerable<String> | Enumerable<Valkyrie::ID] the object ids
+      # @note A collection could be added to member_ids, but for Hyrax collections are stored using member_of_collection_ids.
+      #       As long as this rule holds, then member_ids and ordered_member_ids are equivalent to object_ids/child_object_ids.
+      # @todo Do we want to support member_ids separate from child_objects (see NOTE)
+      def child_object_ids(valkyrie: false)
+        child_objects(valkyrie: valkyrie).map(&:id)
+      end
+      alias object_ids child_object_ids
+      alias ordered_object_ids child_object_ids
+      # alias member_ids child_object_ids # TODO: Cannot alias in this way because member_ids method is already defined thru the attribute definition.
+      alias ordered_members_ids child_object_ids
+      alias member_work_ids child_object_ids
+
+      ##
+      # @return [Enumerable<ActiveFedora::Base> | Enumerable<Valkyrie::Resource>] the collections the
+      #    collection or object is a member of.
+      # @note For Hyrax, member_of_collection_ids is used to hold the parent collections.
+      #       members is used to hold the child works and child filesets.  This method looks
+      #       in solr for the members relationship and infers a member_of relationship through
+      #       a solr query by looking for all parents that have self's id in their members list.
+      def member_of(valkyrie: false)
+        af_id = valkyrie ? id : id.id
+        return [] if af_id.nil?
+        af_parents = Wings::ActiveFedoraConverter.new(resource: self).convert.member_of
+        return af_parents unless valkyrie
+        af_parents.map(&:valkyrie_resource)
+      end
+      alias parent_objects member_of
+
+      # @return [Enumerable<ActiveFedora::Base> | Enumerable<Valkyrie::Resource>] the collections the
+      #   object is a member of.
+      # @todo This is using the member_of method which uses the members relationship.  That should
+      #       never return any collections since they are stored using the member_of_collection
+      #       relationship.  But this method is called in characterize_job.rb and collection_indexer.rb.
+      #       It could be that these are no-ops because nothing is ever returned, but more exploration
+      #       is needed to determine this.
+      def in_collections(valkyrie: false)
+        member_of(valkyrie: valkyrie).select(&:pcdm_collection?).to_a
+      end
+
+      # @return [Enumerable<String> | Enumerable<Valkyrie::ID] ids for collections the object is a member of
+      # @todo This is using the member_of method which uses the members relationship.  That should
+      #       never return any collections since they are stored using the member_of_collection
+      #       relationship.  But this method is called in base_actor.rb #destroy.
+      #       It could be that these are no-ops because nothing is ever returned, but more exploration
+      #       is needed to determine this.
+      def in_collection_ids(valkyrie: false)
+        in_collections(valkyrie: valkyrie).map(&:id)
+      end
+
+      ##
+      # @return [Boolean] whether this instance is an audio.
+      def audio?
+        af_object = Wings::ActiveFedoraConverter.new(resource: self).convert
+        af_object.audio?
+      end
+
+      # TODO: This can be removed when we upgrade to ActiveFedora 12.0
+      # @return [String] the etag from the response headers
+      #
+      # @raise [RuntimeError] when the resource is new and has no etag
+      # @raise [Ldp::Gone]    when the resource is deleted
+      def etag
+        raise "Unable to produce an etag for a unsaved object" unless persisted?
+        af_object = Wings::ActiveFedoraConverter.new(resource: self).convert
+        af_object.ldp_source.head.etag
+      end
+
+      # @param valkyrie [Boolean] Should the returned ids be for Valkyrie or AF objects?
+      # @return [Enumerable<Hydra::Works::Work>] The works this work is contained in
+      # @note This method avoids using the Hydra::Works version of parent_works because of Issue #361
+      def parent_works(valkyrie: false)
+        af_child = Wings::ActiveFedoraConverter.new(resource: self).convert
+        af_parents = af_child.member_of_works
+        return af_parents unless valkyrie
+        af_parents.map(&:valkyrie_resource)
+      end
+
+      # @param valkyrie [Boolean] Should the returned ids be for Valkyrie or AF objects?
+      # @return [Enumerable<String> | Enumerable<Valkyrie::ID>] The ids of the works this work is contained in
+      def parent_work_ids(valkyrie: false)
+        parent_works(valkyrie: valkyrie).map(&:id)
+      end
+    end
+  end
+end

data/lib/wings/hydra/works/models/concerns/collection_valkyrie_behavior.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+require 'wings/hydra/pcdm/models/concerns/collection_valkyrie_behavior'
+
+module Wings
+  module Works
+    module CollectionValkyrieBehavior
+      extend ActiveSupport::Concern
+
+      included do
+        include Wings::Pcdm::CollectionValkyrieBehavior
+      end
+
+      # @return [Boolean] whether this instance is a Hydra::Works Collection.
+      def collection?
+        true
+      end
+
+      # @return [Boolean] whether this instance is a Hydra::Works Generic Work.
+      def work?
+        false
+      end
+
+      # @return [Boolean] whether this instance is a Hydra::Works::FileSet.
+      def file_set?
+        false
+      end
+
+      # TODO: Add translated methods
+    end
+  end
+end

data/lib/wings/hydra/works/models/concerns/file_set_valkyrie_behavior.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+require 'wings/hydra/pcdm/models/concerns/object_valkyrie_behavior'
+
+module Wings
+  module Works
+    module FileSetValkyrieBehavior
+      extend ActiveSupport::Concern
+
+      included do
+        include Wings::Pcdm::ObjectValkyrieBehavior
+      end
+
+      # @return [Boolean] whether this instance is a Hydra::Works Collection.
+      def collection?
+        false
+      end
+
+      # @return [Boolean] whether this instance is a Hydra::Works Generic Work.
+      def work?
+        false
+      end
+
+      # @return [Boolean] whether this instance is a Hydra::Works::FileSet.
+      def file_set?
+        true
+      end
+
+      # TODO: Add translated methods
+    end
+  end
+end

data/lib/wings/hydra/works/models/concerns/work_valkyrie_behavior.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require 'wings/hydra/pcdm/models/concerns/object_valkyrie_behavior'
+
+module Wings
+  module Works
+    module WorkValkyrieBehavior
+      extend ActiveSupport::Concern
+
+      included do
+        include Wings::Pcdm::ObjectValkyrieBehavior
+      end
+
+      # @return [Boolean] whether this instance is a Hydra::Works Collection.
+      def collection?
+        false
+      end
+
+      # @return [Boolean] whether this instance is a Hydra::Works Generic Work.
+      def work?
+        true
+      end
+
+      # @return [Boolean] whether this instance is a Hydra::Works::FileSet.
+      def file_set?
+        false
+      end
+
+      # @param valkyrie [Boolean] Should the returned resources be Valkyrie or AF objects?
+      # @return [Enumerable<Hydra::Works::Work>] The works this work contains
+      def child_works(valkyrie: false)
+        child_objects(valkyrie: valkyrie).select(&:work?)
+      end
+      alias works child_works
+      alias member_works child_works
+
+      # @param valkyrie [Boolean] Should the returned ids be for Valkyrie or AF objects?
+      # @return [Enumerable<String> | Enumerable<Valkerie::ID] The ids of the works this work contains
+      def child_work_ids(valkyrie: false)
+        child_works(valkyrie: valkyrie).map(&:id)
+      end
+      alias work_ids child_work_ids
+
+      # @param valkyrie [Boolean] Should the returned resources be Valkyrie or AF objects?
+      # @return [Enumerable<Hydra::Works::FileSet>] The file sets this work contains
+      def child_file_sets(valkyrie: false)
+        child_objects(valkyrie: valkyrie).select(&:file_set?)
+      end
+      alias file_sets child_file_sets
+
+      # @param valkyrie [Boolean] Should the returned ids be for Valkyrie or AF objects?
+      # @return [Enumerable<String> | Enumerable<Valkerie::ID] The ids of the file sets this work contains
+      def child_file_set_ids(valkyrie: false)
+        child_file_sets(valkyrie: valkyrie).map(&:id)
+      end
+      alias file_set_ids child_file_set_ids
+
+      # TODO: Add translated methods
+    end
+  end
+end

data/lib/wings/hydra/works/services/add_file_to_file_set.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+# TODO: This should live in Hyrax::AddFileMetadataToFileSet service and should work for all valkyrie adapters.
+module Wings::Works
+  class AddFileToFileSet
+    class << self
+      # Adds a file to the file_set
+      # @param file_set [Valkyrie::Resource] adding file to this file set
+      # @param [IO,File,Rack::Multipart::UploadedFile, #read] file the object that will be the contents.
+      #   If file responds to :mime_type, :content_type, :original_name, or :original_filename, those will be called to provide metadata.
+      # @param [RDF::URI or String] type URI for the RDF.type that identifies the file's role within the file_set
+      # @param [Boolean] update_existing whether to update an existing file if there is one. When set to true, performs a create_or_update.
+      #   When set to false, always creates a new file within file_set.files.
+      # @param [Boolean] versioning whether to create new version entries (only applicable if +type+ corresponds to a versionable file)
+      def call(file_set:, file:, type:, update_existing: true, versioning: true)
+        raise ArgumentError, 'supplied object must be an instance of Valkyrie::Resource' unless file_set.is_a?(Valkyrie::Resource) && file_set.file_set?
+        raise ArgumentError, 'supplied file must respond to read' unless file.respond_to? :read
+
+        af_type = normalize_type(type)
+        raise ArgumentError, "supplied type (#{type}) is not supported" if af_type.blank?
+
+        af_file_set = Wings::ActiveFedoraConverter.new(resource: file_set).convert
+        result = Hydra::Works::AddFileToFileSet.call(af_file_set, file, af_type, update_existing: update_existing, versioning: versioning)
+
+        # TODO: model_transformer/file_converter_service should create FileMetadata and set ids and attributes
+        result ? af_file_set.valkyrie_resource : false
+      end
+
+      private
+
+      def normalize_type(original_type)
+        type = original_type.is_a?(Array) && !original_type.size.zero? ? original_type.first : original_type
+        association_type(type) || type_to_rdf_uri(type)
+      end
+
+      def association_type(type)
+        return type if [:original_file, :extracted_text, :thumbnail].include? type
+        type_to_association_type type
+      end
+
+      def type_to_association_type(type)
+        case type
+        when Hyrax::FileMetadata::Use::ORIGINAL_FILE
+          :original_file
+        when Hyrax::FileMetadata::Use::EXTRACTED_TEXT
+          :extracted_text
+        when Hyrax::FileMetadata::Use::THUMBNAIL
+          :thumbnail
+        end
+      end
+
+      def type_to_rdf_uri(type)
+        return type if type.is_a? RDF::URI
+        return RDF::URI.new(type) if type.is_a? String
+      end
+    end
+  end
+end

data/lib/wings/model_registry.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Wings
+  ##
+  # This registry provides an off-ramp for legacy ActiveFedora models.
+  #
+  # New valkyrie models can be defined manually and registered as an analogue
+  # of an existing `ActiveFedora::Base` implementer. This allows Wings to cast
+  # the new model to the legacy model when saving, ensuring backwards compatible
+  # data on save.
+  #
+  # Several models from Hyrax components have default mappings provided by Wings.
+  #
+  # @example
+  #   Wings::ModelRegistry.register(NewValkyrieModel, OldActiveFedoraModel)
+  #
+  #   Wings::ModelRegistry.lookup(NewValkyrieModel) # => OldActiveFedoraModel
+  #   Wings::ModelRegistry.reverse_lookup(OldActiveFedoraModel) # => NewValkyrieModel
+  #
+  class ModelRegistry
+    include Singleton
+
+    def self.register(*args)
+      instance.register(*args)
+    end
+
+    def self.lookup(*args)
+      instance.lookup(*args)
+    end
+
+    def self.reverse_lookup(*args)
+      instance.reverse_lookup(*args)
+    end
+
+    def initialize
+      @map = {}
+    end
+
+    def register(valkyrie, active_fedora)
+      @map[valkyrie] = active_fedora
+    end
+
+    def lookup(valkyrie)
+      valkyrie = valkyrie._canonical_valkyrie_model if
+        valkyrie.respond_to?(:_canonical_valkyrie_model)
+
+      @map.fetch(valkyrie) { ActiveFedoraConverter::DefaultWork(valkyrie) }
+    end
+
+    def reverse_lookup(active_fedora)
+      @map.rassoc(active_fedora)&.first
+    end
+  end
+end