hyrax 3.0.0.pre.rc4 → 3.1.0

data/Gemfile

@@ -1,44 +1,38 @@
 # frozen_string_literal: true
-source 'https://rubygems.org' do
-  # Please see hyrax.gemspec for dependency information.
-  gemspec
+source 'https://rubygems.org'
+# Please see hyrax.gemspec for dependency information.
+gemspec
 
-  group :development, :test do
-    gem 'benchmark-ips'
-    gem 'easy_translate'
-    gem 'i18n-tasks'
-    gem 'okcomputer'
-    gem 'pry' unless ENV['CI']
-    gem 'pry-byebug' unless ENV['CI']
-    gem 'ruby-prof', require: false
-    gem "simplecov", require: false
-  end
+group :development, :test do
+  gem 'benchmark-ips'
+  gem 'easy_translate'
+  gem 'i18n-tasks'
+  gem 'okcomputer'
+  gem 'pry' unless ENV['CI']
+  gem 'pry-byebug' unless ENV['CI']
+  gem 'ruby-prof', require: false
+  gem "simplecov", require: false
 end
 
 test_app_path = ENV['RAILS_ROOT'] ||
                 ENV.fetch('ENGINE_CART_DESTINATION', File.expand_path('.internal_test_app', File.dirname(__FILE__)))
 test_app_gemfile = File.expand_path('Gemfile', test_app_path)
 
+# rubocop:disable Bundler/DuplicatedGem
 if File.exist?(test_app_gemfile)
   begin
+    Bundler.ui.info "[Hyrax] Including test application dependencies from #{test_app_gemfile}"
     eval_gemfile test_app_gemfile
   rescue Bundler::GemfileError => e
     Bundler.ui.warn '[Hyrax] Skipping Rails application dependencies:'
     Bundler.ui.warn e.message
   end
+elsif ENV['RAILS_VERSION'] == 'edge'
+  gem 'rails', github: 'rails/rails', source: 'https://rubygems.org'
+  ENV['ENGINE_CART_RAILS_OPTIONS'] = '--edge --skip-turbolinks'
+elsif ENV['RAILS_VERSION']
+  gem 'rails', ENV['RAILS_VERSION'], source: 'https://rubygems.org'
 else
-  Bundler.ui.warn "[Hyrax] Unable to find test application dependencies in #{test_app_gemfile}, using placeholder dependencies"
-
-  # rubocop:disable Bundler/DuplicatedGem
-  if ENV['RAILS_VERSION']
-    if ENV['RAILS_VERSION'] == 'edge'
-      gem 'rails', github: 'rails/rails', source: 'https://rubygems.org'
-      ENV['ENGINE_CART_RAILS_OPTIONS'] = '--edge --skip-turbolinks'
-    else
-      gem 'rails', ENV['RAILS_VERSION'], source: 'https://rubygems.org'
-    end
-  end
-  # rubocop:enable Bundler/DuplicatedGem
-
-  eval_gemfile File.expand_path('spec/test_app_templates/Gemfile.extra', File.dirname(__FILE__))
+  Bundler.ui.warn '[Hyrax] Skipping all Rails dependency injection'
 end
+# rubocop:enable Bundler/DuplicatedGem

data/app/actors/hyrax/actors/base_actor.rb

@@ -95,7 +95,7 @@ module Hyrax
       def clean_attributes(attributes)
         attributes[:license] = Array(attributes[:license]) if attributes.key? :license
         attributes[:rights_statement] = Array(attributes[:rights_statement]) if attributes.key? :rights_statement
-        remove_blank_attributes!(attributes)
+        remove_blank_attributes!(attributes).except('file_set')
       end
 
       # If any attributes are blank remove them

data/app/actors/hyrax/actors/create_with_remote_files_actor.rb

@@ -26,64 +26,112 @@ module Hyrax
 
       private
 
-      def registered_ingest_dirs
-        Hyrax.config.registered_ingest_dirs
+      def attach_files(env, remote_files)
+        ingest_remote_files_service_class.new(user: env.user,
+                                              curation_concern: env.curation_concern,
+                                              remote_files: remote_files,
+                                              file_set_actor_class: file_set_actor_class).attach!
       end
 
-      # @param uri [URI] the uri fo the resource to import
-      def validate_remote_url(uri)
-        if uri.scheme == 'file'
-          path = File.absolute_path(CGI.unescape(uri.path))
-          registered_ingest_dirs.any? do |dir|
-            path.start_with?(dir) && path.length > dir.length
+      class IngestRemoteFilesService
+        ##
+        # @parm user [User]
+        # @parm curation_concern [Hyrax::Work]
+        # @param remote_files [HashWithIndifferentAccess]
+        # @param file_set_actor_class
+        # @param ordered_members [Array]
+        # @param ordered [Boolean]
+        # rubocop:disable Metrics/ParameterLists
+        def initialize(user:, curation_concern:, remote_files:, file_set_actor_class:, ordered_members: [], ordered: false)
+          @remote_files = remote_files
+          @user = user
+          @curation_concern = curation_concern
+          @file_set_actor_class = file_set_actor_class
+          @ordered_members = ordered_members
+          @ordered = ordered
+        end
+        # rubocop:enable Metrics/ParameterLists
+        attr_reader :remote_files, :user, :curation_concern, :ordered_members, :ordered, :file_set_actor_class
+
+        ##
+        # @return true
+        def attach!
+          return true unless remote_files
+          remote_files.each do |file_info|
+            next if file_info.blank? || file_info[:url].blank?
+            # Escape any space characters, so that this is a legal URI
+            uri = URI.parse(Addressable::URI.escape(file_info[:url]))
+            unless self.class.validate_remote_url(uri)
+              Rails.logger.error "User #{user.user_key} attempted to ingest file from url #{file_info[:url]}, which doesn't pass validation"
+              return false
+            end
+            auth_header = file_info.fetch(:auth_header, {})
+            create_file_from_url(uri, file_info[:file_name], auth_header)
           end
-        else
-          Rails.logger.debug "Assuming #{uri.scheme} uri is valid without a serious attempt to validate: #{uri}"
+          add_ordered_members! if ordered
           true
         end
-      end
 
-      # @param [HashWithIndifferentAccess] remote_files
-      # @return [TrueClass]
-      def attach_files(env, remote_files)
-        return true unless remote_files
-        remote_files.each do |file_info|
-          next if file_info.blank? || file_info[:url].blank?
-          # Escape any space characters, so that this is a legal URI
-          uri = URI.parse(Addressable::URI.escape(file_info[:url]))
-          unless validate_remote_url(uri)
-            Rails.logger.error "User #{env.user.user_key} attempted to ingest file from url #{file_info[:url]}, which doesn't pass validation"
-            return false
+        def self.registered_ingest_dirs
+          Hyrax.config.registered_ingest_dirs
+        end
+
+        # @param uri [URI] the uri fo the resource to import
+        def self.validate_remote_url(uri)
+          if uri.scheme == 'file'
+            path = File.absolute_path(CGI.unescape(uri.path))
+            registered_ingest_dirs.any? do |dir|
+              path.start_with?(dir) && path.length > dir.length
+            end
+          else
+            Rails.logger.debug "Assuming #{uri.scheme} uri is valid without a serious attempt to validate: #{uri}"
+            true
           end
-          auth_header = file_info.fetch(:auth_header, {})
-          create_file_from_url(env, uri, file_info[:file_name], auth_header)
         end
-        true
-      end
 
-      # Generic utility for creating FileSet from a URL
-      # Used in to import files using URLs from a file picker like browse_everything
-      def create_file_from_url(env, uri, file_name, auth_header = {})
-        import_url = URI.decode_www_form_component(uri.to_s)
-        ::FileSet.new(import_url: import_url, label: file_name) do |fs|
-          actor = Hyrax::Actors::FileSetActor.new(fs, env.user)
-          actor.create_metadata(visibility: env.curation_concern.visibility)
-          actor.attach_to_work(env.curation_concern)
-          fs.save!
+        private
+
+        def create_file_from_url(uri, file_name, auth_header)
+          import_url = URI.decode_www_form_component(uri.to_s)
+          use_valkyrie = false
+          case curation_concern
+          when Valkyrie::Resource
+            file_set = Hyrax.persister.save(resource: Hyrax::FileSet.new(import_url: import_url, label: file_name))
+            use_valkyrie = true
+          else
+            file_set = ::FileSet.new(import_url: import_url, label: file_name)
+          end
+          __create_file_from_url(file_set: file_set, uri: uri, auth_header: auth_header, use_valkyrie: use_valkyrie)
+        end
+
+        def __create_file_from_url(file_set:, uri:, auth_header:, use_valkyrie: Hyrax.config.use_valkyrie?)
+          actor = file_set_actor_class.new(file_set, user, use_valkyrie: use_valkyrie)
+          actor.create_metadata(visibility: curation_concern.visibility)
+          actor.attach_to_work(curation_concern)
+          file_set.save! if file_set.respond_to?(:save!)
+          # We'll remember the order, but if it's not `@ordered` we won't do anything.
+          ordered_members << file_set
           if uri.scheme == 'file'
             # Turn any %20 into spaces.
             file_path = CGI.unescape(uri.path)
-            IngestLocalFileJob.perform_later(fs, file_path, env.user)
+            IngestLocalFileJob.perform_later(file_set, file_path, user)
           else
-            ImportUrlJob.perform_later(fs, operation_for(user: actor.user), auth_header)
+            ImportUrlJob.perform_later(file_set, operation_for(user: user), auth_header)
           end
         end
-      end
 
-      def operation_for(user:)
-        Hyrax::Operation.create!(user: user,
-                                 operation_type: "Attach Remote File")
+        def operation_for(user:)
+          Hyrax::Operation.create!(user: user,
+                                   operation_type: "Attach Remote File")
+        end
+
+        def add_ordered_members!
+          actor = Hyrax::Actors::OrderedMembersActor.new(ordered_members, user)
+          actor.attach_ordered_members_to_work(curation_concern)
+        end
       end
+      class_attribute :file_set_actor_class, default: ::Hyrax::Actors::FileSetActor
+      class_attribute :ingest_remote_files_service_class, default: ::Hyrax::Actors::CreateWithRemoteFilesActor::IngestRemoteFilesService
     end
   end
 end

data/app/actors/hyrax/actors/create_with_remote_files_ordered_members_actor.rb

@@ -39,54 +39,19 @@ module Hyrax
     # url property, it may have spaces, and not be a valid URI.
     class CreateWithRemoteFilesOrderedMembersActor < CreateWithRemoteFilesActor
       attr_reader :ordered_members
+      self.file_set_actor_class = Hyrax::Actors::FileSetOrderedMembersActor
 
       # @param [HashWithIndifferentAccess] remote_files
       # @return [TrueClass]
       def attach_files(env, remote_files)
-        return true unless remote_files
         @ordered_members = env.curation_concern.ordered_members.to_a
-        remote_files.each do |file_info|
-          next if file_info.blank? || file_info[:url].blank?
-          # Escape any space characters, so that this is a legal URI
-          uri = URI.parse(Addressable::URI.escape(file_info[:url]))
-          unless validate_remote_url(uri)
-            Rails.logger.error "User #{env.user.user_key} attempted to ingest file from url #{file_info[:url]}, which doesn't pass validation"
-            return false
-          end
-          auth_header = file_info.fetch(:auth_header, {})
-          create_file_from_url(env, uri, file_info[:file_name], auth_header)
-        end
-        add_ordered_members(env.user, env.curation_concern)
-        true
-      end
-
-      # Generic utility for creating FileSet from a URL
-      # Used in to import files using URLs from a file picker like browse_everything
-      def create_file_from_url(env, uri, file_name, auth_header = {})
-        ::FileSet.new(import_url: uri.to_s, label: file_name) do |fs|
-          actor = file_set_actor_class.new(fs, env.user)
-          actor.create_metadata(visibility: env.curation_concern.visibility)
-          actor.attach_to_work(env.curation_concern)
-          fs.save!
-          ordered_members << fs
-          if uri.scheme == 'file'
-            # Turn any %20 into spaces.
-            file_path = CGI.unescape(uri.path)
-            IngestLocalFileJob.perform_later(fs, file_path, env.user)
-          else
-            ImportUrlJob.perform_later(fs, operation_for(user: actor.user), auth_header)
-          end
-        end
+        ingest_remote_files_service_class.new(user: env.user,
+                                              curation_concern: env.curation_concern,
+                                              remote_files: remote_files,
+                                              ordered_members: @ordered_members,
+                                              ordered: true,
+                                              file_set_actor_class: file_set_actor_class).attach!
       end
-
-      # Add all file_sets as ordered_members in a single action
-      def add_ordered_members(user, work)
-        actor = Hyrax::Actors::OrderedMembersActor.new(ordered_members, user)
-        actor.attach_ordered_members_to_work(work)
-      end
-
-      class_attribute :file_set_actor_class
-      self.file_set_actor_class = Hyrax::Actors::FileSetOrderedMembersActor
     end
   end
 end

data/app/actors/hyrax/actors/file_actor.rb

@@ -11,7 +11,7 @@ module Hyrax
       # @param [FileSet] file_set the parent FileSet
       # @param [Symbol, #to_sym] relation the type/use for the file
       # @param [User] user the user to record as the Agent acting upon the file
-      def initialize(file_set, relation, user, use_valkyrie: false)
+      def initialize(file_set, relation, user, use_valkyrie: Hyrax.config.query_index_from_valkyrie)
         @use_valkyrie = use_valkyrie
         @file_set = file_set
         @relation = normalize_relation(relation)
@@ -75,7 +75,7 @@ module Hyrax
         CharacterizeJob.perform_later(file_set, repository_file.id, pathhint(io))
       end
 
-      def perform_ingest_file_through_valkyrie(io)
+      def perform_ingest_file_through_valkyrie(io) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         file =
           begin
             Hyrax.storage_adapter.upload(resource: file_set, file: io, original_filename: io.original_name, use: relation)
@@ -87,7 +87,9 @@ module Hyrax
         create_version(file_metadata, user)
         id = file_metadata.file_identifier
         file_set.file_ids << id
+        file_set.original_file_id = id
         Hyrax.persister.save(resource: file_set)
+        Hyrax.publisher.publish('object.metadata.updated', object: file_set, user: user)
         CharacterizeJob.perform_later(file_set, id.to_s, pathhint(io))
         file_metadata
       end

data/app/actors/hyrax/actors/file_set_actor.rb

@@ -6,7 +6,7 @@ module Hyrax
       include Lockable
       attr_reader :file_set, :user, :attributes, :use_valkyrie
 
-      def initialize(file_set, user, use_valkyrie: false)
+      def initialize(file_set, user, use_valkyrie: Hyrax.config.query_index_from_valkyrie)
         @use_valkyrie = use_valkyrie
         @file_set = file_set
         @user = user
@@ -31,10 +31,9 @@ module Hyrax
           # hand. Do this because we don't have the underlying UploadedFile instance
           file_actor = build_file_actor(relation)
           file_actor.ingest_file(wrapper!(file: file, relation: relation))
-          # Copy visibility and permissions from parent (work) to
-          # FileSets even if they come in from BrowseEverything
-          VisibilityCopyJob.perform_later(file_set.parent)
-          InheritPermissionsJob.perform_later(file_set.parent)
+          parent = parent_for(file_set: file_set)
+          VisibilityCopyJob.perform_later(parent)
+          InheritPermissionsJob.perform_later(parent)
         else
           IngestJob.perform_later(wrapper!(file: file, relation: relation))
         end
@@ -68,7 +67,6 @@ module Hyrax
         yield(file_set) if block_given?
       end
 
-      # Adds a FileSet to the work using ore:Aggregations.
       # Locks to ensure that only one process is operating on the list at a time.
       def attach_to_work(work, file_set_params = {})
         acquire_lock_for(work.id) do
@@ -87,15 +85,18 @@ module Hyrax
       def attach_to_valkyrie_work(work, file_set_params)
         work = Hyrax.query_service.find_by(id: work.id) unless work.new_record
         file_set.visibility = work.visibility unless assign_visibility?(file_set_params)
-        Hyrax.persister.save(resource: file_set)
-        work.member_ids << file_set.id
-        work.representative_id = file_set.id if work.representative_id.blank?
-        work.thumbnail_id = file_set.id if work.thumbnail_id.blank?
+        fs = Hyrax.persister.save(resource: file_set)
+        Hyrax.publisher.publish('object.metadata.updated', object: fs, user: user)
+        work.member_ids << fs.id
+        work.representative_id = fs.id if work.representative_id.blank?
+        work.thumbnail_id = fs.id if work.thumbnail_id.blank?
         # Save the work so the association between the work and the file_set is persisted (head_id)
         # NOTE: the work may not be valid, in which case this save doesn't do anything.
         Hyrax.persister.save(resource: work)
+        Hyrax.publisher.publish('object.metadata.updated', object: work, user: user)
       end
 
+      # Adds a FileSet to the work using ore:Aggregations.
       def attach_to_af_work(work, file_set_params)
         work.reload unless work.new_record?
         file_set.visibility = work.visibility unless assign_visibility?(file_set_params)
@@ -136,6 +137,12 @@ module Hyrax
         @ability ||= ::Ability.new(user)
       end
 
+      # @param file_set [FileSet]
+      # @return [ActiveFedora::Base]
+      def parent_for(file_set:)
+        file_set.parent
+      end
+
       def build_file_actor(relation)
         fs = use_valkyrie ? file_set.valkyrie_resource : file_set
         file_actor_class.new(fs, relation, user, use_valkyrie: use_valkyrie)
@@ -177,7 +184,7 @@ module Hyrax
       # Although ActiveFedora clears the children nodes it leaves those fields in Solr populated.
       # rubocop:disable Metrics/CyclomaticComplexity
       def unlink_from_work
-        work = file_set.parent
+        work = parent_for(file_set: file_set)
         return unless work && (work.thumbnail_id == file_set.id || work.representative_id == file_set.id || work.rendering_ids.include?(file_set.id))
         work.thumbnail = nil if work.thumbnail_id == file_set.id
         work.representative = nil if work.representative_id == file_set.id

data/app/controllers/concerns/hyrax/collections_controller_behavior.rb

@@ -15,14 +15,17 @@ module Hyrax
       class_attribute :presenter_class,
                       :form_class,
                       :single_item_search_builder_class,
-                      :membership_service_class
+                      :membership_service_class,
+                      :parent_collection_query_service
 
       self.presenter_class = Hyrax::CollectionPresenter
 
       # The search builder to find the collection
       self.single_item_search_builder_class = SingleCollectionSearchBuilder
       # The search builder to find the collections' members
-      self.membership_service_class = Collections::CollectionMemberService
+      self.membership_service_class = Collections::CollectionMemberSearchService
+      # A search service to use in finding parent collections
+      self.parent_collection_query_service = Collections::NestedCollectionQueryService
     end
 
     def show
@@ -74,9 +77,9 @@ module Hyrax
     end
 
     def query_collection_members
-      member_works
-      member_subcollections if collection.collection_type.nestable?
-      parent_collections if collection.collection_type.nestable? && action_name == 'show'
+      load_member_works
+      load_member_subcollections if collection.collection_type.nestable?
+      load_parent_collections if collection.collection_type.nestable? && action_name == 'show'
     end
 
     # Instantiate the membership query service
@@ -89,12 +92,20 @@ module Hyrax
       @member_docs = @response.documents
       @members_count = @response.total
     end
+    alias load_member_works member_works
 
-    def parent_collections
+    ##
+    # Handles paged loading for parent collections.
+    #
+    # @param the query service to use when searching for the parent collections.
+    #   uses the class attribute +parent_collection_query_service+ by default.
+    def parent_collections(query_service: self.class.parent_collection_query_service)
       page = params[:parent_collection_page].to_i
-      query = Hyrax::Collections::NestedCollectionQueryService
-      collection.parent_collections = query.parent_collections(child: collection_object, scope: self, page: page)
+      collection.parent_collections = query_service.parent_collections(
+        child: collection_object, scope: self, page: page
+      )
     end
+    alias load_parent_collections parent_collections
 
     def collection_object
       action_name == 'show' ? Collection.find(collection.id) : collection
@@ -106,6 +117,7 @@ module Hyrax
       @subcollection_docs = results.documents
       @subcollection_count = @presenter.subcollection_count = results.total
     end
+    alias load_member_subcollections member_subcollections
 
     # You can override this method if you need to provide additional inputs to the search
     # builder. For example: