hyrax 3.0.0.pre.rc4 → 3.0.0

data/config/initializers/listeners.rb

@@ -19,10 +19,12 @@ end
 
 Hyrax.config.callback.set(:after_create_fileset, warn: false) do |file_set, user|
   Hyrax.publisher.publish('file.set.attached', file_set: file_set, user: user)
+  Hyrax.publisher.publish('object.metadata.updated', object: file_set, user: user)
 end
 
 Hyrax.config.callback.set(:after_revert_content, warn: false) do |file_set, user, revision|
   Hyrax.publisher.publish('file.set.restored', file_set: file_set, user: user, revision: revision)
+  Hyrax.publisher.publish('object.metadata.updated', object: file_set, user: user)
 end
 
 Hyrax.config.callback.set(:after_update_metadata, warn: false) do |curation_concern, user|

data/documentation/developing-your-hyrax-based-app.md

@@ -30,7 +30,7 @@ A Hyrax-based application includes lots of dependencies. We provide a [Docker im
 You can also try [Running Hyrax-based application in local VM](https://github.com/samvera/hyrax/wiki/Hyrax-Development-Guide#running-hyrax-based-application-in-local-vm) which uses Ubuntu.
 
 This document contains instructions specific to setting up an app with __Hyrax
-v3.0.0-rc4__. If you are looking for instructions on installing a different
+v3.0.0__. If you are looking for instructions on installing a different
 version, be sure to select the appropriate branch or tag from the drop-down
 menu above.
 
@@ -48,7 +48,7 @@ Hyrax requires the following software to work:
 1. A SQL RDBMS (MySQL, PostgreSQL), though **note** that SQLite will be used by default if you're looking to get up and running quickly
 1. [Redis](http://redis.io/), a key-value store
 1. [ImageMagick](http://www.imagemagick.org/) with JPEG-2000 support
-1. [FITS](#characterization) version 1.0.x (1.0.5 is known to be good, 1.1.0 is known to be bad: https://github.com/harvard-lts/fits/issues/140)
+1. [FITS](#characterization) (tested up to version 1.5.0 -- avoid version 1.1.0)
 1. [LibreOffice](#derivatives)
 1. [ffmpeg](#transcoding)
 
@@ -125,7 +125,7 @@ NOTE: The steps need to be done in order to create a new Hyrax based app.
 Generate a new Rails application using the template.
 
 ```
-rails _5.2.4.4_ new my_app -m https://raw.githubusercontent.com/samvera/hyrax/v3.0.0-rc4/template.rb
+rails _5.2.4.4_ new my_app -m https://raw.githubusercontent.com/samvera/hyrax/v3.0.0/template.rb
 ```
 
 Generating a new Rails application using Hyrax's template above takes cares of a number of steps for you, including:

data/lib/hyrax/transactions/container.rb

@@ -17,17 +17,19 @@ module Hyrax
     # @since 2.4.0
     #
     # @see https://dry-rb.org/gems/dry-container/
-    class Container
+    class Container # rubocop:disable Metrics/ClassLength
       require 'hyrax/transactions/apply_change_set'
       require 'hyrax/transactions/create_work'
       require 'hyrax/transactions/destroy_work'
       require 'hyrax/transactions/work_create'
+      require 'hyrax/transactions/work_destroy'
       require 'hyrax/transactions/update_work'
       require 'hyrax/transactions/steps/add_file_sets'
       require 'hyrax/transactions/steps/add_to_collections'
       require 'hyrax/transactions/steps/apply_collection_permission_template'
       require 'hyrax/transactions/steps/apply_permission_template'
       require 'hyrax/transactions/steps/apply_visibility'
+      require 'hyrax/transactions/steps/delete_resource'
       require 'hyrax/transactions/steps/destroy_work'
       require 'hyrax/transactions/steps/ensure_admin_set'
       require 'hyrax/transactions/steps/ensure_permission_template'
@@ -95,6 +97,14 @@ module Hyrax
           Steps::AddFileSets.new
         end
 
+        ops.register 'delete' do
+          Steps::DeleteResource.new
+        end
+
+        ops.register 'destroy' do
+          WorkDestroy.new
+        end
+
         ops.register 'save_acl' do
           Steps::SaveAccessControl.new
         end

data/lib/hyrax/transactions/steps/delete_resource.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require 'dry/monads'
+
+module Hyrax
+  module Transactions
+    module Steps
+      ##
+      # Deletes a resource from the persister, returning a `Dry::Monads::Result`
+      # (`Success`|`Failure`).
+      #
+      # @see https://dry-rb.org/gems/dry-monads/1.0/result/
+      class DeleteResource
+        include Dry::Monads[:result]
+
+        ##
+        # @params [#save] persister
+        def initialize(persister: Hyrax.persister)
+          @persister = persister
+        end
+
+        ##
+        # @param [Valkyrie::Resource] resource
+        # @param [::User] the user resposible for the delete action
+        #
+        # @return [Dry::Monads::Result]
+        def call(resource, user: nil)
+          return Failure(:resource_not_persisted) unless resource.persisted?
+
+          @persister.delete(resource: resource)
+          Hyrax.publisher
+               .publish('object.deleted', object: resource, id: resource.id.id, user: user)
+
+          Success(resource)
+        end
+      end
+    end
+  end
+end

data/lib/hyrax/transactions/steps/destroy_work.rb

@@ -6,6 +6,7 @@ module Hyrax
       # A `dry-transcation` step that destroys a Work.
       #
       # @since 3.0.0
+      # @deprecated
       class DestroyWork
         include Dry::Transaction::Operation
 

data/lib/hyrax/transactions/work_destroy.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+require 'hyrax/transactions/transaction'
+
+module Hyrax
+  module Transactions
+    ##
+    # Destroys a work resource
+    #
+    # @since 3.0.0
+    class WorkDestroy < Transaction
+      DEFAULT_STEPS = ['work_resource.delete'].freeze
+
+      ##
+      # @see Hyrax::Transactions::Transaction
+      def initialize(container: Container, steps: DEFAULT_STEPS)
+        super
+      end
+    end
+  end
+end

data/lib/hyrax/version.rb

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

data/lib/tasks/embargo_lease.rake

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+namespace :hyrax do
+  namespace :embargo do
+    desc 'Deactivate embargoes for which the lift date has past'
+    task deactivate_expired: :environment do
+      ids = Hyrax::EmbargoService.assets_with_expired_embargoes.map(&:id)
+
+      Hyrax.query_service.find_many_by_ids(ids: ids).each do |resource|
+        Hyrax::EmbargoManager.release_embargo_for(resource: resource) &&
+          Hyrax::AccessControlList(resource).save
+      end
+    end
+  end
+
+  namespace :lease do
+    desc 'Deactivate leases for which the expiration date has past'
+    task deactivate_expired: :environment do
+      ids = Hyrax::LeaseService.assets_with_expired_leases.map(&:id)
+
+      Hyrax.query_service.find_many_by_ids(ids: ids).each do |resource|
+        Hyrax::LeaseManager.release_lease_for(resource: resource) &&
+          Hyrax::AccessControlList(resource).save
+      end
+    end
+  end
+end

data/lib/wings/active_fedora_converter/default_work.rb

@@ -106,6 +106,10 @@ module Wings
       class << self
         delegate :human_readable_type, to: :valkyrie_class
 
+        def _to_partial_path
+          "hyrax/#{valkyrie_class.model_name.collection}/#{valkyrie_class.model_name.element}"
+        end
+
         def model_name(*)
           Hyrax::Name.new(valkyrie_class)
         end

data/lib/wings/attribute_transformer.rb

@@ -15,36 +15,46 @@ module Wings
       end
     end
 
-    def self.run(obj, keys)
-      # TODO: There is an open question about whether we want to treat all these relationships the same.  See Issue #3904.
-      attrs = keys.select { |k| k.to_s.end_with? '_ids' }.each_with_object({}) do |attr_name, mem|
-        mem[attr_name.to_sym] =
-          TransformerValueMapper.for(obj.try(attr_name)).result ||
-          TransformerValueMapper.for(attribute_ids_for(name: attr_name.chomp('_ids'), obj: obj)).result ||
-          TransformerValueMapper.for(attribute_ids_for(name: attr_name.chomp('_ids').pluralize, obj: obj)).result || []
+    def self.run(obj) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      attrs = obj.reflections.each_with_object({}) do |(key, reflection), mem|
+        case reflection
+        when ActiveFedora::Reflection::HasManyReflection,
+             ActiveFedora::Reflection::HasAndBelongsToManyReflection,
+             ActiveFedora::Reflection::IndirectlyContainsReflection
+          mem[:"#{key.to_s.singularize}_ids"] =
+            obj.association(key).ids_reader
+        when ActiveFedora::Reflection::DirectlyContainsReflection
+          mem[:"#{key.to_s.singularize}_ids"] =
+            Array(obj.public_send(reflection.name)).map(&:id)
+        when ActiveFedora::Reflection::FilterReflection,
+             ActiveFedora::Reflection::OrdersReflection,
+             ActiveFedora::Reflection::HasSubresourceReflection,
+             ActiveFedora::Reflection::BelongsToReflection,
+             ActiveFedora::Reflection::BasicContainsReflection
+          :noop
+        when ActiveFedora::Reflection::DirectlyContainsOneReflection
+          mem[:"#{key.to_s.singularize}_id"] =
+            obj.public_send(reflection.name)&.id
+        else
+          mem[reflection.foreign_key.to_sym] =
+            obj.public_send(reflection.foreign_key.to_sym)
+        end
       end
-      keys.each_with_object(attrs) do |attr_name, mem|
+
+      obj.class.delegated_attributes.keys.each_with_object(attrs) do |attr_name, mem|
         next unless obj.respond_to?(attr_name) && !mem.key?(attr_name.to_sym)
         mem[attr_name.to_sym] = TransformerValueMapper.for(obj.public_send(attr_name)).result
       end
     end
-
-    def self.attribute_ids_for(name:, obj:)
-      attribute_value = obj.try(name)
-      return if attribute_value.nil?
-      Array(attribute_value).map(&:id)
-    end
   end
 
   class FileAttributeTransformer
-    KEYMAP = {}.freeze
+    def run(obj)
+      keys = obj.metadata_node.class.fields
 
-    def run(obj, keys)
       attributes = keys.each_with_object({}) do |attr_name, mem|
         next unless obj.respond_to?(attr_name) && !mem.key?(attr_name.to_sym)
-        valkyrie_attribute = KEYMAP.fetch(attr_name.to_sym) { attr_name.to_sym }
-
-        mem[valkyrie_attribute] = TransformerValueMapper.for(obj.public_send(attr_name)).result
+        mem[attr_name.to_sym] = TransformerValueMapper.for(obj.public_send(attr_name)).result
       end
 
       attributes[:original_filename] = obj.original_name

data/lib/wings/model_transformer.rb

@@ -116,16 +116,8 @@ module Wings
     end
 
     def attributes
-      attribute_source = pcdm_object.try(:metadata_node) || pcdm_object
-
-      all_keys =
-        attribute_source.attributes.keys +
-        OrmConverter.relationship_keys_for(reflections: pcdm_object.try(:reflections))
-
-      result = AttributeTransformer.for(pcdm_object)
-                                   .run(pcdm_object, all_keys)
-                                   .merge(reflection_ids)
-                                   .merge(additional_attributes)
+      transformer = AttributeTransformer.for(pcdm_object)
+      result = transformer.run(pcdm_object).merge(additional_attributes)
 
       append_embargo(result)
       append_lease(result)
@@ -133,16 +125,9 @@ module Wings
       result
     end
 
-    def reflection_ids
-      keys = pcdm_object.try(:reflections)&.keys || []
-
-      keys.select { |k| k.to_s.end_with? '_id' }.each_with_object({}) do |k, mem|
-        mem[k] = pcdm_object.try(k)
-      end
-    end
-
     def additional_attributes
-      { :created_at => pcdm_object.try(:create_date),
+      { :id => pcdm_object.id,
+        :created_at => pcdm_object.try(:create_date),
         :updated_at => pcdm_object.try(:modified_date),
         :member_ids => member_ids,
         ::Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK => lock_token }

data/lib/wings/orm_converter.rb

@@ -2,20 +2,10 @@
 
 module Wings
   ##
+  # @api private
+  #
   # Transform AF object class to Valkyrie::Resource class representation.
   class OrmConverter
-    ##
-    # @param reflections [Hash<Symbol, Object>]
-    #
-    # @return [Array<Symbol>]
-    def self.relationship_keys_for(reflections:)
-      Hash(reflections).keys.map do |k|
-        key_string = k.to_s
-        next if key_string.include?('id') || key_string.include?('proxies')
-        key_string.singularize + '_ids'
-      end.compact
-    end
-
     ##
     # Selects an existing base class for the generated valkyrie class
     #
@@ -39,9 +29,6 @@ module Wings
     # rubocop:disable Metrics/MethodLength because metaprogramming a class
     #   results in long methods
     def self.to_valkyrie_resource_class(klass:)
-      relationship_keys = klass.respond_to?(:reflections) ? relationship_keys_for(reflections: klass.reflections) : []
-      reflection_id_keys = klass.respond_to?(:reflections) ? klass.reflections.keys.select { |k| k.to_s.end_with? '_id' } : []
-
       Class.new(base_for(klass: klass)) do
         # store a string we can resolve to the internal resource
         @internal_resource = klass.try(:to_rdf_representation) || klass.name
@@ -74,14 +61,30 @@ module Wings
           end
         end
 
-        relationship_keys.each do |linked_property_name|
-          next if fields.include?(linked_property_name.to_sym)
-          attribute linked_property_name.to_sym, ::Valkyrie::Types::Set.of(::Valkyrie::Types::ID)
+        # add reflection associations
+        ldp_reflections = (klass.try(:reflections) || []).select do |_key, reflection|
+          case reflection
+          when ActiveFedora::Reflection::FilterReflection,
+               ActiveFedora::Reflection::OrdersReflection,
+               ActiveFedora::Reflection::BasicContainsReflection,
+               ActiveFedora::Reflection::HasSubresourceReflection
+            false
+          else
+            true
+          end
         end
 
-        reflection_id_keys.each do |property_name|
-          next if fields.include?(property_name.to_sym)
-          attribute property_name, ::Valkyrie::Types::ID
+        ldp_reflections.each do |reflection_key, reflection|
+          if reflection.collection?
+            type           = ::Valkyrie::Types::Set.of(::Valkyrie::Types::ID)
+            attribute_name = (reflection_key.to_s.singularize + '_ids').to_sym
+          else
+            type           = ::Valkyrie::Types::ID.optional
+            attribute_name = (reflection_key.to_s.singularize + '_id').to_sym
+          end
+
+          next if fields.include?(attribute_name)
+          attribute attribute_name, type
         end
 
         def internal_resource

data/lib/wings/valkyrie/persister.rb

@@ -53,6 +53,7 @@ module Wings
         af_object = ActiveFedora::Base.new
         af_object.id = resource.alternate_ids.first.to_s
         af_object.delete
+        resource
       end
 
       # Deletes all resources from Fedora and Solr

data/lib/wings/valkyrie/query_service.rb

@@ -47,25 +47,30 @@ module Wings
         end
       end
 
-      # Find an array of record using Valkyrie IDs, and map them to Valkyrie Resources maintaining order based on given ids
+      ##
+      # Find an array of record using Valkyrie IDs, and map them to Valkyrie
+      # Resources maintaining order based on given ids
+      #
+      # @note ignores non-existent ids.
+      #
       # @param [Array<Valkyrie::ID, String>] ids
+      #
       # @return [Array<Valkyrie::Resource>]
-      # NOTE: Ignores non-existent ids.
+      # @raise [ArgumentError]
       def find_many_by_ids(ids:)
-        ids.each do |id|
-          id = ::Valkyrie::ID.new(id.to_s) if id.is_a?(String)
-          validate_id(id)
-        end
-        resources = []
-        ids.uniq.map(&:to_s).each do |id|
+        ids.all? { |i| i.respond_to?(:to_str) } ||
+          raise(ArgumentError, 'id must be a Valkyrie::ID')
+
+        return enum_for(:find_many_by_ids, ids: ids) unless block_given?
+
+        ids.map(&:to_s).uniq.each do |id|
           begin
             af_object = ActiveFedora::Base.find(id)
-            resources << resource_factory.to_resource(object: af_object)
+            yield resource_factory.to_resource(object: af_object)
           rescue ::ActiveFedora::ObjectNotFoundError, Ldp::Gone
             next
           end
         end
-        resources
       end
 
       # Find a record using an alternate ID, and map it to a Valkyrie Resource
@@ -74,12 +79,14 @@ module Wings
       # @return [Valkyrie::Resource]
       # @raise [Hyrax::ObjectNotFoundError]
       def find_by_alternate_identifier(alternate_identifier:, use_valkyrie: true)
-        alternate_identifier = ::Valkyrie::ID.new(alternate_identifier.to_s) if alternate_identifier.is_a?(String)
-        validate_id(alternate_identifier)
-        object = ::ActiveFedora::Base.find(alternate_identifier.to_s)
-        return object if use_valkyrie == false
-        resource_factory.to_resource(object: object)
-      rescue ActiveFedora::ObjectNotFoundError, Ldp::Gone
+        raise(ArgumentError, 'id must be a Valkyrie::ID') unless
+          alternate_identifier.respond_to?(:to_str)
+
+        af_object = ActiveFedora::Base.find(alternate_identifier.to_s)
+
+        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
       end
 
@@ -88,11 +95,12 @@ module Wings
       # @param model [Class]
       # @return [Array<Valkyrie::Resource>]
       def find_members(resource:, model: nil)
-        return [] unless resource.respond_to?(:member_ids) && resource.member_ids.present?
-        all_members = find_many_by_ids(ids: resource.member_ids)
-        return all_members unless model
+        return [] if resource.try(:member_ids).blank?
+        return find_many_by_ids(ids: resource.member_ids) unless model
+
         find_model = model_class_for(model)
-        all_members.select { |member_resource| model_class_for(member_resource.class) == find_model }
+        find_many_by_ids(ids: resource.member_ids)
+          .select { |member_resource| model_class_for(member_resource.class) == find_model }
       end
 
       # Find the Valkyrie Resources referenced by another Valkyrie Resource
@@ -160,10 +168,14 @@ module Wings
       end
 
       def find_id_for(reference)
-        return ::Hyrax::Base.uri_to_id(reference.id) if reference.class == ActiveTriples::Resource
-        return reference if reference.class == String
-        # not a supported type
-        ''
+        case reference
+        when ActiveTriples::Resource
+          ::Hyrax::Base.uri_to_id(reference.id)
+        when String
+          reference
+        else # not a supported type
+          ''
+        end
       end
 
       def model_class_for(model)