hyrax 3.0.0 → 3.2.0

data/lib/hyrax/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Hyrax
-  VERSION = '3.0.0'
+  VERSION = '3.2.0'
 end

data/lib/hyrax.rb

@@ -25,6 +25,13 @@ require 'valkyrie/indexing_adapter'
 require 'valkyrie/indexing/solr/indexing_adapter'
 require 'valkyrie/indexing/null_indexing_adapter'
 
+##
+# Hyrax is a Ruby on Rails Engine built by the Samvera community. The engine
+# provides a foundation for creating many different digital repository
+# applications.
+#
+# @see https://samvera.org Samvera Community
+# @see https://guides.rubyonrails.org/engines.html Rails Guides: Getting Started with Engines
 module Hyrax
   extend ActiveSupport::Autoload
 
@@ -46,6 +53,8 @@ module Hyrax
   def self.GlobalID(input) # rubocop:disable Naming/MethodName
     case input
     when Valkyrie::Resource
+      return input.to_global_id if input.respond_to?(:to_global_id)
+
       ValkyrieGlobalIdProxy.new(resource: input).to_global_id
     else
       input.to_global_id if input.respond_to?(:to_global_id)

data/lib/tasks/collection_type_global_id.rake

@@ -2,7 +2,7 @@
 namespace :hyrax do
   namespace :collections do
     desc 'Update CollectionType global id references for Hyrax 3.0.0'
-    task :update_collection_type_global_ids do
+    task update_collection_type_global_ids: :environment do
       puts 'Updating collection -> collection type GlobalId references.'
 
       count = 0

data/lib/tasks/default_admin_set.rake

@@ -3,24 +3,25 @@ namespace :hyrax do
   namespace :default_admin_set do
     desc "Create the Default Admin Set"
     task create: :environment do
-      id = AdminSet.find_or_create_default_admin_set_id
-      # I have found that when I come back to a development
-      # environment, that I may have an AdminSet in Fedora, but it is
-      # not indexed in Solr.  This remediates that situation by
-      # ensuring we have an indexed AdminSet
-      AdminSet.find(id).update_index
-      if Hyrax::PermissionTemplate.find_by(source_id: id)
+      id = Hyrax::AdminSetCreateService.find_or_create_default_admin_set.id
+      if Hyrax::PermissionTemplate.find_by(source_id: id.to_s)
         puts "Successfully created default admin set"
       else
         warn "ERROR: Default admin set exists but it does not have an " \
           "associated permission template.\n\nThis may happen if you cleared your " \
-          "database but you did not clear out Fedora and Solr.\n\n" \
+          "database but you did not clear out metadata datasource (e.g. Fedora, Postgres) " \
+          "and Solr.\n\n" \
           "You could manually create the permission template in the rails console" \
           " (non-destructive):\n\n" \
-          "    Hyrax::PermissionTemplate.create!(source_id: AdminSet::DEFAULT_ID)\n\n" \
-          "OR you could start fresh by clearing Fedora and Solr (destructive):\n\n" \
+          "    Hyrax::PermissionTemplate.create!(source_id: Hyrax::AdminSetCreateService::DEFAULT_ID)\n\n" \
+          "OR you could start fresh by clearing the metadata datasource and Solr (destructive):\n\n" \
+          "  For ActiveFedora or Wings Valkryie adapter (default), use...\n" \
           "    require 'active_fedora/cleaner'\n" \
-          "    ActiveFedora::Cleaner.clean!\n\n"
+          "    ActiveFedora::Cleaner.clean!\n\n" \
+          "  For Valkyrie, use...\n" \
+          "    conn = Hyrax.index_adapter.connection\n" \
+          "    conn.delete_by_query('*:*', params: { 'softCommit' => true })\n" \
+          "    Hyrax.persister.wipe!\n"
       end
     end
   end

data/lib/tasks/regenerate_derivatives.rake

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+namespace :hyrax do
+  namespace :file_sets do
+    desc 'Regenerate derivatives for all FileSets in the repository'
+    task regenerate_derivatives: :environment do
+      FileSet.all.each do |fs|
+        fs.files.each { |fi| CreateDerivativesJob.perform_later(fs, fi) }
+      end
+    end
+  end
+end

data/lib/wings/active_fedora_converter/default_work.rb

@@ -100,6 +100,9 @@ module Wings
       include Hydra::AccessControls::Embargoable
       property :nested_resource, predicate: ::RDF::URI("http://example.com/nested_resource"), class_name: "Wings::ActiveFedoraConverter::NestedResource"
 
+      validates :lease_expiration_date, 'hydra/future_date': true, on: :create
+      validates :embargo_release_date, 'hydra/future_date': true, on: :create
+
       class_attribute :valkyrie_class
       self.valkyrie_class = Hyrax::Resource
 
@@ -121,6 +124,18 @@ module Wings
         alias to_s inspect
       end
 
+      ##
+      # Override aggressive Hydra::AccessControls validation
+      def enforce_future_date_for_embargo?
+        false
+      end
+
+      ##
+      # Override aggressive Hydra::AccessControls validation
+      def enforce_future_date_for_lease?
+        false
+      end
+
       def indexing_service
         Hyrax::ValkyrieIndexer.for(resource: valkyrie_resource)
       end

data/lib/wings/converter_value_mapper.rb

@@ -73,7 +73,7 @@ module Wings
     end
 
     def result
-      collections = value.last.map { |id| ActiveFedora::Base.find(id.id) }
+      collections = value.last.map { |id| ActiveFedora::Base.find(id.to_s) }
       [:member_of_collections, collections]
     end
   end
@@ -86,7 +86,7 @@ module Wings
     end
 
     def result
-      members = value.last.map { |id| ActiveFedora::Base.find(id.id) }
+      members = value.last.map { |id| ActiveFedora::Base.find(id.to_s) }
       [:members, members]
     end
   end

data/lib/wings/model_transformer.rb

@@ -110,7 +110,7 @@ module Wings
     private
 
     def mint_id
-      id = pcdm_object.assign_id
+      id = pcdm_object.try(:assign_id)
 
       pcdm_object.id = id if id.present?
     end
@@ -121,6 +121,7 @@ module Wings
 
       append_embargo(result)
       append_lease(result)
+      append_permissions(result)
 
       result
     end
@@ -168,5 +169,20 @@ module Wings
 
       attrs[:lease] = Hyrax::Lease.new(**lease_attrs)
     end
+
+    def append_permissions(attrs)
+      return unless pcdm_object.try(:permissions)
+      attrs[:permissions] = pcdm_object.permissions.map do |permission|
+        agent = permission.type == 'group' ? "group/#{permission.agent_name}" : permission.agent_name
+
+        Hyrax::Permission.new(id: permission.id,
+                              mode: permission.access.to_sym,
+                              agent: agent,
+                              access_to: ::Valkyrie::ID.new(permission.access_to_id),
+                              new_record: permission.new_record?)
+      end
+
+      attrs[:access_to] = attrs[:permissions].find { |p| p.access_to&.id&.present? }&.access_to
+    end
   end
 end

data/lib/wings/orm_converter.rb

@@ -40,6 +40,12 @@ module Wings
             _canonical_valkyrie_model&.name
           end
 
+          ##
+          # @return [String]
+          def to_s
+            internal_resource
+          end
+
           ##
           # @api private
           def _canonical_valkyrie_model
@@ -47,8 +53,18 @@ module Wings
           end
         end
 
-        def self.to_s
-          internal_resource
+        ##
+        # @return [URI::GID]
+        def to_global_id
+          URI::GID.build([GlobalID.app, internal_resource, id, {}])
+        end
+
+        ##
+        # @return [ActiveModel::Base]
+        def to_model
+          model_class = internal_resource.safe_constantize || self
+
+          Hyrax::ActiveFedoraDummyModel.new(model_class, id)
         end
 
         klass.properties.each_key do |property_name|

data/lib/wings/setup.rb

@@ -2,6 +2,7 @@
 
 ActiveFedora::Base.include Wings::Valkyrizable
 ActiveFedora::File.include Wings::Valkyrizable
+Hydra::AccessControl.include Wings::Valkyrizable
 
 module ActiveTriples
   class NodeConfig
@@ -76,6 +77,7 @@ Valkyrie.config.storage_adapter = :active_fedora
 #       A refactor is needed to add the default implementations to hyrax.rb and only handle the wings specific overrides here.
 custom_queries = [Hyrax::CustomQueries::Navigators::CollectionMembers,
                   Hyrax::CustomQueries::Navigators::ChildCollectionsNavigator,
+                  Hyrax::CustomQueries::Navigators::ParentCollectionsNavigator,
                   Hyrax::CustomQueries::Navigators::ChildFilesetsNavigator,
                   Hyrax::CustomQueries::Navigators::ChildWorksNavigator,
                   Hyrax::CustomQueries::Navigators::FindFiles,

data/lib/wings/valkyrie/persister.rb

@@ -41,9 +41,10 @@ module Wings
       # @param [Valkyrie::Resource] resource
       # @return [Valkyrie::Resource] the persisted/updated resource
       def save_all(resources:)
-        resources.map do |resource|
-          save(resource: resource)
-        end
+        resources.map { |resource| save(resource: resource) }
+      rescue ::Valkyrie::Persistence::StaleObjectError => _err
+        raise(::Valkyrie::Persistence::StaleObjectError,
+              "One or more resources have been updated by another process.")
       end
 
       # Deletes a resource persisted using ActiveFedora
@@ -51,7 +52,7 @@ module Wings
       # @return [Valkyrie::Resource] the deleted resource
       def delete(resource:)
         af_object = ActiveFedora::Base.new
-        af_object.id = resource.alternate_ids.first.to_s
+        af_object.id = resource.id
         af_object.delete
         resource
       end
@@ -84,7 +85,8 @@ module Wings
           etag_lock_token_valid?(af_object: af_object, resource: resource) &&
           last_modified_lock_token_valid?(af_object: af_object, resource: resource)
 
-        raise(::Valkyrie::Persistence::StaleObjectError, resource.id.to_s)
+        raise(::Valkyrie::Persistence::StaleObjectError,
+              "The object #{resource.id} has been updated by another process.")
       end
 
       ##

data/lib/wings/valkyrie/query_service.rb

@@ -2,16 +2,32 @@
 
 module Wings
   module Valkyrie
+    ##
+    # @note does not support duplicates!
     class QueryService
       attr_reader :adapter
       extend Forwardable
       def_delegator :adapter, :resource_factory
 
-      # @param adapter [Wings::Valkyrie::MetadataAdapter] The adapter which holds the resource_factory for this query_service.
+      ##
+      # @param adapter [Wings::Valkyrie::MetadataAdapter] The adapter which
+      #   holds the resource_factory for this query_service.
       def initialize(adapter:)
         @adapter = adapter
       end
 
+      ##
+      # @param :model [Class]
+      #
+      # @return [Integer]
+      def count_all_of_model(model:)
+        ActiveFedora::Base
+          .where(has_model_ssim: [model_class_for(model).to_rdf_representation,
+                                  model.new.internal_resource.to_s])
+          .count
+      end
+
+      ##
       # WARNING: In general, prefer find_by_alternate_identifier over this
       # method.
       #
@@ -23,14 +39,17 @@ module Wings
       # start getting ObjectNotFoundErrors instead of the objects you wanted
       #
       # Find a record using a Valkyrie ID, and map it to a Valkyrie Resource
+      #
       # @param [Valkyrie::ID, String] id
       # @return [Valkyrie::Resource]
-      # @raise [Hyrax::ObjectNotFoundError]
+      # @raise [Valkyrie::Persistence::ObjectNotFoundError]
       def find_by(id:)
         find_by_alternate_identifier(alternate_identifier: id)
       end
 
+      ##
       # Find all work/collection records, and map to Valkyrie Resources
+      #
       # @return [Array<Valkyrie::Resource>]
       def find_all
         ::ActiveFedora::Base.all.map do |obj|
@@ -38,7 +57,10 @@ module Wings
         end
       end
 
-      # Find all work/collection records of a given model, and map to Valkyrie Resources
+      ##
+      # Find all work/collection records of a given model, and map to Valkyrie
+      # Resources
+      #
       # @param model [Class]
       # @return [Array<Valkyrie::Resource>]
       def find_all_of_model(model:)
@@ -73,11 +95,14 @@ module Wings
         end
       end
 
+      ##
       # Find a record using an alternate ID, and map it to a Valkyrie Resource
+      #
       # @param [Valkyrie::ID, String] id
       # @param [boolean] optionally return ActiveFedora object/errors
+      #
       # @return [Valkyrie::Resource]
-      # @raise [Hyrax::ObjectNotFoundError]
+      # @raise [Valkyrie::Persistence::ObjectNotFoundError]
       def find_by_alternate_identifier(alternate_identifier:, use_valkyrie: true)
         raise(ArgumentError, 'id must be a Valkyrie::ID') unless
           alternate_identifier.respond_to?(:to_str)
@@ -87,12 +112,15 @@ module Wings
         use_valkyrie ? resource_factory.to_resource(object: af_object) : af_object
       rescue ActiveFedora::ObjectNotFoundError, Ldp::Gone => err
         raise err unless use_valkyrie
-        raise Hyrax::ObjectNotFoundError
+        raise ::Valkyrie::Persistence::ObjectNotFoundError
       end
 
+      ##
       # Find all members of a given resource, and map to Valkyrie Resources
+      #
       # @param resource [Valkyrie::Resource]
       # @param model [Class]
+      #
       # @return [Array<Valkyrie::Resource>]
       def find_members(resource:, model: nil)
         return [] if resource.try(:member_ids).blank?
@@ -103,21 +131,27 @@ module Wings
           .select { |member_resource| model_class_for(member_resource.class) == find_model }
       end
 
+      ##
       # Find the Valkyrie Resources referenced by another Valkyrie Resource
+      #
       # @param resource [<Valkyrie::Resource>]
       # @param property [Symbol] the property holding the references to another resource
       # @return [Array<Valkyrie::Resource>]
-      def find_references_by(resource:, property:)
-        object = resource_factory.from_resource(resource: resource)
-        object.send(property).map do |reference|
-          af_id = find_id_for(reference)
-          resource_factory.to_resource(object: ::ActiveFedora::Base.find(af_id))
+      def find_references_by(resource:, property:, model: nil)
+        return find_many_by_ids(ids: Array(resource.send(property))) unless model
+
+        results = resource.public_send(property).map do |reference|
+          resource_factory.to_resource(object: ::ActiveFedora::Base.find(reference))
         end
+
+        results.select { |r| r.class.name == model.name }
       rescue ActiveFedora::ObjectNotFoundError
         []
       end
 
+      ##
       # Get all resources which link to a resource or id with a given property.
+      #
       # @param resource [Valkyrie::Resource] The resource which is being referenced by
       #   other resources.
       # @param resource [Valkyrie::ID] The id of the resource which is being referenced by
@@ -129,30 +163,37 @@ module Wings
       # @return [Array<Valkyrie::Resource>] All resources in the persistence backend
       #   which have the ID of the given `resource` in their `property` property. Not
       #   in order.
-      def find_inverse_references_by(resource: nil, id: nil, property:)
+      def find_inverse_references_by(resource: nil, id: nil, model: nil, property:)
         raise ArgumentError, "Provide resource or id" unless resource || id
-        id ||= resource.alternate_ids.first
+        id ||= resource.id
         raise ArgumentError, "Resource has no id; is it persisted?" unless id
-        uri = Hyrax::Base.id_to_uri(id.to_s)
-        ActiveFedora::Base.where("+(#{property}_ssim: \"#{uri}\" OR #{property}_ssim: \"#{id}\")").map do |obj|
+
+        active_fedora_model = model ? model_class_for(model) : ActiveFedora::Base
+
+        uri = active_fedora_model.id_to_uri(id.to_s)
+        active_fedora_model.where("+(#{property}_ssim: \"#{uri}\" OR #{property}_ssim: \"#{id}\")").map do |obj|
           resource_factory.to_resource(object: obj)
         end
       end
 
+      ##
       # Find all parents of a given resource.
+      #
       # @param resource [Valkyrie::Resource] The resource whose parents are being searched
       #   for.
       # @return [Array<Valkyrie::Resource>] All resources which are parents of the given
       #   `resource`. This means the resource's `id` appears in their `member_ids`
       #   array.
       def find_parents(resource:)
-        id = resource.alternate_ids.first
-        ActiveFedora::Base.where("member_ids_ssim: \"#{id}\"").map do |obj|
+        ActiveFedora::Base.where("member_ids_ssim: \"#{resource.id}\"").map do |obj|
           resource_factory.to_resource(object: obj)
         end
       end
 
-      # Constructs a Valkyrie::Persistence::CustomQueryContainer using this query service
+      ##
+      # Constructs a Valkyrie::Persistence::CustomQueryContainer using this
+      # query service
+      #
       # @return [Valkyrie::Persistence::CustomQueryContainer]
       def custom_queries
         @custom_queries ||= ::Valkyrie::Persistence::CustomQueryContainer.new(query_service: self)
@@ -160,7 +201,9 @@ module Wings
 
       private
 
+      ##
       # Determines whether or not an Object is a Valkyrie ID
+      #
       # @param [Object] id
       # @raise [ArgumentError]
       def validate_id(id)

data/lib/wings/valkyrie/storage.rb

@@ -19,6 +19,7 @@ module Wings
       DEFAULT_CTYPE = 'application/octet-stream'
       LINK_HEADER = "<http://www.w3.org/ns/ldp#NonRDFSource>; rel=\"type\""
       FILES_PATH = 'files'
+      VERSIONS_SLUG = '/fcr:versions'
 
       attr_reader :sha1
 
@@ -27,6 +28,14 @@ module Wings
         super
       end
 
+      ##
+      # @param key [Symbol] the key for plugin behavior to check support for
+      #
+      # @return [Boolean] whether
+      def supports?(key)
+        key == :versions
+      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)
@@ -41,7 +50,49 @@ module Wings
                         id_hint: id_hint, **extra_arguments)
              end
 
-        find_by(id: ::Valkyrie::ID.new(id.to_s.sub(/^.+\/\//, PROTOCOL)))
+        find_by(id: cast_to_valkyrie_id(id))
+      end
+
+      ##
+      # @return [Enumerable<Version> ordered list of versions
+      def find_versions(id:)
+        response = connection.http.get(fedora_identifier(id: id) + VERSIONS_SLUG)
+        return [] if response.status == 404
+
+        reader = RDF::Reader.for(content_type: response.headers['content-type'])
+        version_graph = RDF::Graph.new << reader.new(response.body)
+
+        version_graph.query(predicate: RDF::Vocab::Fcrepo4.hasVersion).objects.map do |uri|
+          timestamp =
+            version_graph.query([uri, RDF::Vocab::Fcrepo4.created, :created])
+                         .first_object
+                         .object
+          Version.new(cast_to_valkyrie_id(uri.to_s), timestamp, self)
+        end.sort
+      end
+
+      ##
+      # abstractly, {Version} objects should have an {#id} and be orderable
+      # over {#<=>} (allowing e.g. `#sort` to define a consistent order---
+      # oldest to newest---for a collection of versions). the {#id} should be a
+      # globally unique identifier for the version.
+      #
+      # this implementation uses an orderable {#version_token}. in practice
+      # the token is the fcrepo created date for the version, as extracted from
+      # the versions graph.
+      Version = Struct.new(:id, :version_token, :adapter) do
+        include Comparable
+
+        ##
+        # @return [#read]
+        def io
+          adapter.find_by(id: id)
+        end
+
+        def <=>(other)
+          raise ArgumentError unless other.respond_to?(:version_token)
+          version_token <=> other.version_token
+        end
       end
 
       private
@@ -87,6 +138,10 @@ module Wings
 
         Hyrax.config.translate_id_to_uri.call(created_file.id)
       end
+
+      def cast_to_valkyrie_id(id)
+        ::Valkyrie::ID.new(id.to_s.sub(/^.+\/\//, PROTOCOL))
+      end
     end
   end
 

data/lib/wings.rb

@@ -98,27 +98,6 @@ require 'wings/valkyrie/persister'
 require 'wings/valkyrie/storage'
 require 'wings/valkyrie/query_service'
 
-Hydra::AccessControl.send(:define_method, :valkyrie_resource) do
-  attrs = attributes.symbolize_keys
-  attrs[:new_record]  = new_record?
-  attrs[:created_at]  = create_date
-  attrs[:updated_at]  = modified_date
-
-  attrs[:permissions] = permissions.map do |permission|
-    agent = permission.type == 'group' ? "group/#{permission.agent_name}" : permission.agent_name
-
-    Hyrax::Permission.new(id: permission.id,
-                          mode: permission.access.to_sym,
-                          agent: agent,
-                          access_to: Valkyrie::ID.new(permission.access_to_id),
-                          new_record: permission.new_record?)
-  end
-
-  attrs[:access_to] = attrs[:permissions].find { |p| p.access_to&.id&.present? }&.access_to
-
-  Hyrax::AccessControl.new(**attrs)
-end
-
 begin
   require 'wings/setup'
 rescue NameError, Hyrax::SimpleSchemaLoader::UndefinedSchemaError => err

data/template.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 # Hack for https://github.com/rails/rails/issues/35153
 gsub_file 'Gemfile', /^gem ["']sqlite3["']$/, 'gem "sqlite3", "~> 1.3.0"'
-gem 'hyrax', '3.0.0'
+gem 'hyrax', '3.2.0'
 run 'bundle install'
 generate 'hyrax:install', '-f'