hyrax 3.0.0.pre.rc1 → 3.0.0.pre.rc2

data/app/actors/hyrax/actors/apply_permission_template_actor.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Hyrax
   module Actors
     # Responsible for "applying" the various edit and read attributes to the given curation concern.
@@ -12,28 +13,28 @@ module Hyrax
 
       private
 
-        def add_edit_users(env)
-          add_admin_set_participants(env)
-          add_collection_participants(env)
-        end
+      def add_edit_users(env)
+        add_admin_set_participants(env)
+        add_collection_participants(env)
+      end
 
-        def add_admin_set_participants(env)
-          return if env.attributes[:admin_set_id].blank?
-          template = Hyrax::PermissionTemplate.find_by!(source_id: env.attributes[:admin_set_id])
-          set_curation_concern_access(env, template)
-        end
+      def add_admin_set_participants(env)
+        return if env.attributes[:admin_set_id].blank?
+        template = Hyrax::PermissionTemplate.find_by!(source_id: env.attributes[:admin_set_id])
+        set_curation_concern_access(env, template)
+      end
 
-        def add_collection_participants(env)
-          return if env.attributes[:collection_id].blank?
-          collection_id = env.attributes.delete(:collection_id) # delete collection_id from attributes because works do not have a collection_id property
-          template = Hyrax::PermissionTemplate.find_by!(source_id: collection_id)
-          set_curation_concern_access(env, template)
-        end
+      def add_collection_participants(env)
+        return if env.attributes[:collection_id].blank?
+        collection_id = env.attributes.delete(:collection_id) # delete collection_id from attributes because works do not have a collection_id property
+        template = Hyrax::PermissionTemplate.find_by!(source_id: collection_id)
+        set_curation_concern_access(env, template)
+      end
 
-        def set_curation_concern_access(env, template)
-          PermissionTemplateApplicator
-            .apply(template).to(model: env.curation_concern)
-        end
+      def set_curation_concern_access(env, template)
+        PermissionTemplateApplicator
+          .apply(template).to(model: env.curation_concern)
+      end
     end
   end
 end

data/app/actors/hyrax/actors/attach_members_actor.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Hyrax
   module Actors
     # Attach or remove child works to/from this work. This decodes parameters
@@ -25,64 +26,64 @@ module Hyrax
 
       private
 
-        # Attaches any unattached members.  Deletes those that are marked _delete
-        # @param [Hash<Hash>] a collection of members
-        #
-        # rubocop:disable Metrics/CyclomaticComplexity
-        # Complexity in this method is incleased by dual AF/Valkyrie support
-        # when removing AF, we should be able to reduce it substantially.
-        def assign_nested_attributes_for_collection(env, attributes_collection)
-          return true unless attributes_collection
+      # Attaches any unattached members.  Deletes those that are marked _delete
+      # @param [Hash<Hash>] a collection of members
+      #
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # Complexity in this method is incleased by dual AF/Valkyrie support
+      # when removing AF, we should be able to reduce it substantially.
+      def assign_nested_attributes_for_collection(env, attributes_collection)
+        return true unless attributes_collection
 
-          attributes         = extract_attributes(attributes_collection)
-          cast_concern       = !env.curation_concern.is_a?(Valkyrie::Resource)
-          resource           = cast_concern ? env.curation_concern.valkyrie_resource : env.curation_concern
-          inserts, destroys  = split_inserts_and_destroys(attributes, resource)
+        attributes         = extract_attributes(attributes_collection)
+        cast_concern       = !env.curation_concern.is_a?(Valkyrie::Resource)
+        resource           = cast_concern ? env.curation_concern.valkyrie_resource : env.curation_concern
+        inserts, destroys  = split_inserts_and_destroys(attributes, resource)
 
-          # short circuit to avoid casting unnecessarily
-          return true if destroys.empty? && inserts.empty?
-          # we fail silently if we can't insert the object; this is for legacy
-          # compatibility
-          return true unless check_permissions(ability: env.current_ability,
-                                               inserts: inserts,
-                                               destroys: destroys)
+        # short circuit to avoid casting unnecessarily
+        return true if destroys.empty? && inserts.empty?
+        # we fail silently if we can't insert the object; this is for legacy
+        # compatibility
+        return true unless check_permissions(ability: env.current_ability,
+                                             inserts: inserts,
+                                             destroys: destroys)
 
-          update_members(resource: resource, inserts: inserts, destroys: destroys)
+        update_members(resource: resource, inserts: inserts, destroys: destroys)
 
-          return true unless cast_concern
-          env.curation_concern = Hyrax.metadata_adapter
-                                      .resource_factory
-                                      .from_resource(resource: resource)
-        end
-        # rubocop:enable Metrics/CyclomaticComplexity
+        return true unless cast_concern
+        env.curation_concern = Hyrax.metadata_adapter
+                                    .resource_factory
+                                    .from_resource(resource: resource)
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
 
-        def extract_attributes(collection)
-          collection
-            .sort_by { |i, _| i.to_i }
-            .map { |_, attributes| attributes }
-        end
+      def extract_attributes(collection)
+        collection
+          .sort_by { |i, _| i.to_i }
+          .map { |_, attributes| attributes }
+      end
 
-        def split_inserts_and_destroys(attributes, resource)
-          current_member_ids = resource.member_ids.map(&:id)
+      def split_inserts_and_destroys(attributes, resource)
+        current_member_ids = resource.member_ids.map(&:id)
 
-          destroys = attributes.select do |col_hash|
-            ActiveModel::Type::Boolean.new.cast(col_hash['_destroy'])
-          end
+        destroys = attributes.select do |col_hash|
+          ActiveModel::Type::Boolean.new.cast(col_hash['_destroy'])
+        end
 
-          inserts  = (attributes - destroys).map { |h| h['id'] }.compact - current_member_ids
-          destroys = destroys.map { |h| h['id'] }.compact & current_member_ids
+        inserts  = (attributes - destroys).map { |h| h['id'] }.compact - current_member_ids
+        destroys = destroys.map { |h| h['id'] }.compact & current_member_ids
 
-          [inserts, destroys]
-        end
+        [inserts, destroys]
+      end
 
-        def update_members(resource:, inserts: [], destroys: [])
-          resource.member_ids += inserts.map  { |id| Valkyrie::ID.new(id) }
-          resource.member_ids -= destroys.map { |id| Valkyrie::ID.new(id) }
-        end
+      def update_members(resource:, inserts: [], destroys: [])
+        resource.member_ids += inserts.map  { |id| Valkyrie::ID.new(id) }
+        resource.member_ids -= destroys.map { |id| Valkyrie::ID.new(id) }
+      end
 
-        def check_permissions(ability:, inserts: [], **_opts)
-          inserts.all? { |id| ability.can?(:edit, id) }
-        end
+      def check_permissions(ability:, inserts: [], **_opts)
+        inserts.all? { |id| ability.can?(:edit, id) }
+      end
     end
   end
 end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Hyrax
   module Actors
     ##
@@ -19,7 +20,7 @@ module Hyrax
         apply_creation_data_to_curation_concern(env)
         apply_save_data_to_curation_concern(env)
 
-        save(env, use_valkyrie: false) &&
+        save(env, use_valkyrie: Hyrax.config.use_valkyrie?) &&
           next_actor.create(env) &&
           run_callbacks(:after_create_concern, env)
       end
@@ -45,74 +46,84 @@ module Hyrax
 
       private
 
-        def run_callbacks(hook, env)
-          Hyrax.config.callback.run(hook, env.curation_concern, env.user)
-          true
-        end
-
-        def apply_creation_data_to_curation_concern(env)
-          apply_depositor_metadata(env)
-          apply_deposit_date(env)
-        end
+      def run_callbacks(hook, env)
+        Hyrax.config.callback.run(hook, env.curation_concern, env.user, warn: false)
+        true
+      end
 
-        def apply_update_data_to_curation_concern(_env)
-          true
-        end
+      def apply_creation_data_to_curation_concern(env)
+        apply_depositor_metadata(env)
+        apply_deposit_date(env)
+      end
 
-        def apply_depositor_metadata(env)
-          env.curation_concern.depositor = env.user.user_key
-        end
+      def apply_update_data_to_curation_concern(_env)
+        true
+      end
 
-        def apply_deposit_date(env)
-          env.curation_concern.date_uploaded = TimeService.time_in_utc
-        end
+      def apply_depositor_metadata(env)
+        env.curation_concern.depositor = env.user.user_key
+      end
 
-        def save(env, use_valkyrie: false)
-          return env.curation_concern.save unless use_valkyrie
+      def apply_deposit_date(env)
+        env.curation_concern.date_uploaded = TimeService.time_in_utc
+      end
 
-          env.curation_concern.embargo&.save
-          env.curation_concern.lease&.save
+      def save(env, use_valkyrie: false)
+        return env.curation_concern.save unless use_valkyrie
+
+        resource = valkyrie_save(resource: env.curation_concern.valkyrie_resource)
+
+        # we need to manually set the id and reload, because the actor stack requires
+        # `env.curation_concern` to be the exact same instance throughout.
+        # casting back to ActiveFedora doesn't satisfy this.
+        env.curation_concern.id = resource.alternate_ids.first.id unless env.curation_concern.id
+        env.curation_concern.reload
+      rescue Wings::Valkyrie::Persister::FailedSaveError => _err
+        # for now, just hit the validation error again
+        # later we should capture the _err.obj and pass it back
+        # through the environment
+        env.curation_concern.save
+      end
 
-          resource = Hyrax.persister.save(resource: env.curation_concern.valkyrie_resource)
+      def apply_save_data_to_curation_concern(env)
+        env.curation_concern.attributes = clean_attributes(env.attributes)
+        env.curation_concern.date_modified = TimeService.time_in_utc
+      end
 
-          env.curation_concern = Hyrax.metadata_adapter.resource_factory.from_resource(resource: resource)
-        rescue Wings::Valkyrie::Persister::FailedSaveError => _err
-          # for now, just hit the validation error again
-          # later we should capture the _err.obj and pass it back
-          # through the environment
-          env.curation_concern.save
-        end
+      # Cast any singular values from the form to multiple values for persistence
+      # also remove any blank assertions
+      # TODO this method could move to the work form.
+      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)
+      end
 
-        def apply_save_data_to_curation_concern(env)
-          env.curation_concern.attributes = clean_attributes(env.attributes)
-          env.curation_concern.date_modified = TimeService.time_in_utc
+      # If any attributes are blank remove them
+      # e.g.:
+      #   self.attributes = { 'title' => ['first', 'second', ''] }
+      #   remove_blank_attributes!
+      #   self.attributes
+      # => { 'title' => ['first', 'second'] }
+      def remove_blank_attributes!(attributes)
+        multivalued_form_attributes(attributes).each_with_object(attributes) do |(k, v), h|
+          h[k] = v.instance_of?(Array) ? v.select(&:present?) : v
         end
+      end
 
-        # Cast any singular values from the form to multiple values for persistence
-        # also remove any blank assertions
-        # TODO this method could move to the work form.
-        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)
-        end
+      # Return the hash of attributes that are multivalued and not uploaded files
+      def multivalued_form_attributes(attributes)
+        attributes.select { |_, v| v.respond_to?(:select) && !v.respond_to?(:read) }
+      end
 
-        # If any attributes are blank remove them
-        # e.g.:
-        #   self.attributes = { 'title' => ['first', 'second', ''] }
-        #   remove_blank_attributes!
-        #   self.attributes
-        # => { 'title' => ['first', 'second'] }
-        def remove_blank_attributes!(attributes)
-          multivalued_form_attributes(attributes).each_with_object(attributes) do |(k, v), h|
-            h[k] = v.instance_of?(Array) ? v.select(&:present?) : v
-          end
-        end
+      def valkyrie_save(resource:)
+        permissions = resource.permission_manager.acl.permissions
+        resource    = Hyrax.persister.save(resource: resource)
 
-        # Return the hash of attributes that are multivalued and not uploaded files
-        def multivalued_form_attributes(attributes)
-          attributes.select { |_, v| v.respond_to?(:select) && !v.respond_to?(:read) }
-        end
+        resource.permission_manager.acl.permissions = permissions
+        resource.permission_manager.acl.save
+        resource
+      end
     end
   end
 end

data/app/actors/hyrax/actors/cleanup_file_sets_actor.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module Hyrax
   module Actors
@@ -12,19 +13,19 @@ module Hyrax
 
       private
 
-        def cleanup_file_sets(curation_concern)
-          # Destroy the list source first.  This prevents each file_set from attemping to
-          # remove itself individually from the work. If hundreds of files are attached,
-          # this would take too long.
+      def cleanup_file_sets(curation_concern)
+        # Destroy the list source first.  This prevents each file_set from attemping to
+        # remove itself individually from the work. If hundreds of files are attached,
+        # this would take too long.
 
-          # Get list of member file_sets from Solr
-          fs = curation_concern.file_sets
-          curation_concern.list_source.destroy
-          # Remove Work from Solr after it was removed from Fedora so that the
-          # in_objects lookup does not break when FileSets are destroyed.
-          Hyrax::SolrService.delete(curation_concern.id)
-          fs.each(&:destroy)
-        end
+        # Get list of member file_sets from Solr
+        fs = curation_concern.file_sets
+        curation_concern.list_source.destroy
+        # Remove Work from Solr after it was removed from Fedora so that the
+        # in_objects lookup does not break when FileSets are destroyed.
+        Hyrax::SolrService.delete(curation_concern.id)
+        fs.each(&:destroy)
+      end
     end
   end
 end

data/app/actors/hyrax/actors/cleanup_trophies_actor.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module Hyrax
   module Actors
@@ -12,9 +13,9 @@ module Hyrax
 
       private
 
-        def cleanup_trophies(env)
-          Trophy.where(work_id: env.curation_concern.id).destroy_all
-        end
+      def cleanup_trophies(env)
+        Trophy.where(work_id: env.curation_concern.id).destroy_all
+      end
     end
   end
 end

data/app/actors/hyrax/actors/collections_membership_actor.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Hyrax
   module Actors
     # Adds membership to and removes membership from collections.
@@ -25,93 +26,102 @@ module Hyrax
 
       private
 
-        ##
-        # Attaches any unattached members.  Deletes those that are marked _delete
-        #
-        # @param env [Hyrax::Actors::Enviornment]
-        # @return [Boolean]
-        #
-        # rubocop:disable Metrics/MethodLength
-        def assign_nested_attributes_for_collection(env)
-          attributes_collection = env.attributes.delete(:member_of_collections_attributes)
-          return true unless attributes_collection
+      ##
+      # Attaches any unattached members.  Deletes those that are marked _delete
+      #
+      # @param env [Hyrax::Actors::Enviornment]
+      # @return [Boolean]
+      #
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def assign_nested_attributes_for_collection(env)
+        attributes_collection = env.attributes.delete(:member_of_collections_attributes)
+        return true unless attributes_collection
 
-          return false unless
-            valid_membership?(env, collection_ids: attributes_collection.map { |_, attributes| attributes['id'] })
+        return false unless
+          valid_membership?(env, collection_ids: attributes_collection.map { |_, attributes| attributes['id'] })
 
-          attributes_collection = attributes_collection.sort_by { |i, _| i.to_i }.map { |_, attributes| attributes }
-          # checking for existing works to avoid rewriting/loading works that are already attached
-          existing_collections = env.curation_concern.member_of_collection_ids
-          attributes_collection.each do |attributes|
-            next if attributes['id'].blank?
-            if existing_collections.include?(attributes['id'])
-              remove(env.curation_concern, attributes['id']) if
-                ActiveModel::Type::Boolean.new.cast(attributes['_destroy'])
-            else
-              add(env, attributes['id'])
-            end
+        attributes_collection = attributes_collection.sort_by { |i, _| i.to_i }.map { |_, attributes| attributes }
+        # checking for existing works to avoid rewriting/loading works that are already attached
+        existing_collections = env.curation_concern.member_of_collection_ids
+        boolean_type_caster = ActiveModel::Type::Boolean.new
+        attributes_collection.each do |attributes|
+          next if attributes['id'].blank?
+          if boolean_type_caster.cast(attributes['_destroy'])
+            # Likely someone in the UI sought to add the collection, then
+            # changed their mind and checked the "delete" checkbox and posted
+            # their update.
+            next unless existing_collections.include?(attributes['id'])
+            remove(env.curation_concern, attributes['id'])
+          else
+            # Let's not try to add an item already
+            next if existing_collections.include?(attributes['id'])
+            add(env, attributes['id'])
           end
-
-          true
         end
-        # rubocop:enable Metrics/MethodLength
+        true
+      end
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/CyclomaticComplexity
 
-        # Adds the item to the ordered members so that it displays in the items
-        # along side the FileSets on the show page
-        def add(env, id)
-          collection = Collection.find(id)
-          collection.reindex_extent = Hyrax::Adapters::NestingIndexAdapter::LIMITED_REINDEX
+      # Adds the item to the ordered members so that it displays in the items
+      # along side the FileSets on the show page
+      def add(env, id)
+        collection = ::Collection.find(id)
+        collection.reindex_extent = Hyrax::Adapters::NestingIndexAdapter::LIMITED_REINDEX
 
-          return unless env.current_ability.can?(:deposit, collection)
-          env.curation_concern.member_of_collections << collection
-        end
+        return unless env.current_ability.can?(:deposit, collection)
+        env.curation_concern.member_of_collections << collection
+      end
 
-        # Remove the object from the members set and the ordered members list
-        def remove(curation_concern, id)
-          collection = Collection.find(id)
-          curation_concern.member_of_collections.delete(collection)
-        end
+      # Remove the object from the members set and the ordered members list
+      def remove(curation_concern, id)
+        collection = ::Collection.find(id)
+        curation_concern.member_of_collections.delete(collection)
+      end
 
-        # Extact a singleton collection id from the collection attributes and save it in env.  Later in the actor stack,
-        # in apply_permission_template_actor.rb, `env.attributes[:collection_id]` will be used to apply the
-        # permissions of the collection to the created work.  With one and only one collection, the work is seen as
-        # being created directly in that collection.  The permissions will not be applied to the work if the collection
-        # type is configured not to allow that or if the work is being created in more than one collection.
-        #
-        # @param env [Hyrax::Actors::Enviornment]
-        #
-        # Given an array of collection_attributes when it is size:
-        # * 0 do not set `env.attributes[:collection_id]`
-        # * 1 set `env.attributes[:collection_id]` to the one and only one collection
-        # * 2+ do not set `env.attributes[:collection_id]`
-        #
-        # NOTE: Only called from create.  All collections are being added as parents of a work.  None are being removed.
-        def extract_collection_id(env)
-          attributes_collection =
-            env.attributes.fetch(:member_of_collections_attributes) { nil }
+      # Extact a singleton collection id from the collection attributes and save it in env.  Later in the actor stack,
+      # in apply_permission_template_actor.rb, `env.attributes[:collection_id]` will be used to apply the
+      # permissions of the collection to the created work.  With one and only one collection, the work is seen as
+      # being created directly in that collection.  The permissions will not be applied to the work if the collection
+      # type is configured not to allow that or if the work is being created in more than one collection.
+      #
+      # @param env [Hyrax::Actors::Enviornment]
+      #
+      # Given an array of collection_attributes when it is size:
+      # * 0 do not set `env.attributes[:collection_id]`
+      # * 1 set `env.attributes[:collection_id]` to the one and only one collection
+      # * 2+ do not set `env.attributes[:collection_id]`
+      #
+      # NOTE: Only called from create.  All collections are being added as parents of a work.  None are being removed.
+      def extract_collection_id(env)
+        attributes_collection =
+          env.attributes.fetch(:member_of_collections_attributes) { nil }
 
-          # Determine if the work is being created in one and only one collection.
-          return unless attributes_collection && attributes_collection.size == 1
+        # Determine if the work is being created in one and only one collection.
+        return unless attributes_collection && attributes_collection.size == 1
 
-          # Extract the collection id from attributes_collection,
-          collection_id = attributes_collection.first.second['id']
+        # Extract the collection id from attributes_collection,
+        collection_id = attributes_collection.first.second['id']
 
-          # Do not apply permissions to work if collection type is configured not to
-          collection = ::Collection.find(collection_id)
-          return unless collection.share_applies_to_new_works?
+        # Do not apply permissions to work if collection type is configured not to
+        collection = ::Collection.find(collection_id)
+        return unless collection.share_applies_to_new_works?
 
-          # Save the collection id in env for use in apply_permission_template_actor
-          env.attributes[:collection_id] = collection_id
-        end
+        # Save the collection id in env for use in apply_permission_template_actor
+        env.attributes[:collection_id] = collection_id
+      end
 
-        def valid_membership?(env, collection_ids:)
-          multiple_memberships = Hyrax::MultipleMembershipChecker.new(item: env.curation_concern).check(collection_ids: collection_ids)
-          if multiple_memberships
-            env.curation_concern.errors.add(:collections, multiple_memberships)
-            return false
-          end
-          true
+      def valid_membership?(env, collection_ids:)
+        multiple_memberships = Hyrax::MultipleMembershipChecker.new(item: env.curation_concern).check(collection_ids: collection_ids)
+        if multiple_memberships
+          env.curation_concern.errors.add(:collections, multiple_memberships)
+          return false
         end
+        true
+      end
     end
   end
 end