hyrax 3.0.0.pre.beta3 → 3.0.0

data/lib/tasks/default_admin_set.rake

@@ -1,8 +1,14 @@
+# frozen_string_literal: true
 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)
         puts "Successfully created default admin set"
       else

data/lib/tasks/default_collection_type.rake

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 namespace :hyrax do
   namespace :default_collection_types do
     desc "Create Default Collection Types"

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/tasks/hyrax.rake

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 namespace :hyrax do
   desc 'Print a count of each object type'
   task count: [:environment] do

data/lib/tasks/hyrax_user.rake

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 namespace :hyrax do
   namespace :user do
     desc "list user's email"

data/lib/tasks/install.rake

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 namespace :hyrax do
   namespace :install do
     desc 'Copy migrations from Hyrax to application'

data/lib/tasks/migrate.rake

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 namespace :hyrax do
   namespace :migrate do
     task move_all_works_to_admin_set: :environment do
@@ -38,7 +39,7 @@ namespace :hyrax do
     # Migrate any orphan fedora data from the first to the second predicate
     task migrate_keyword_predicate: :environment do
       Hyrax::Works::MigrationService.migrate_predicate(::RDF::Vocab::DC11.relation, ::RDF::Vocab::SCHEMA.keywords)
-      Hyrax::Works::MigrationService.migrate_predicate(::RDF::Vocab::DC.rights, ::RDF::URI.new('http://dublincore.org/documents/dcmi-terms/#terms-license'))
+      Hyrax::Works::MigrationService.migrate_predicate(::RDF::Vocab::DC.rights, ::RDF::Vocab::DC.license)
     end
   end
 end

data/lib/tasks/reindex.rake

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 namespace :solr do
   desc "Enqueue a job to resolrize the repository objects"
   task reindex: :environment do

data/lib/tasks/stats_tasks.rake

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 namespace :hyrax do
   namespace :stats do
     desc "Cache work view, file view & file download stats for all users"

data/lib/tasks/universal_viewer.rake

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 namespace :hyrax do
   namespace :universal_viewer do
     desc "Install Universal Viewer"

data/lib/tasks/workflow.rake

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 namespace :hyrax do
   namespace :workflow do
     desc "Load workflow configuration into the database"

data/lib/valkyrie/indexing/null_indexing_adapter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module Valkyrie
+  module Indexing
+    # A Valkyrie indexer that does nothing for all index requests. This is
+    # useful for applications using alternate/legacy (e.g. ActiveFedora)
+    # indexing strategies that don't want the overhead of running separate
+    # index requests.
+    #
+    # rubocop:disable Lint/UnusedMethodArgument RuboCop wants us to accept all
+    #   arguments, but we actually want to raise ArgumentError when the caller
+    #   isn't using the correct signature.
+    class NullIndexingAdapter
+      def save(resource:)
+        :noop
+      end
+
+      def save_all(resources:)
+        :noop
+      end
+
+      def delete(resource:)
+        :noop
+      end
+
+      def wipe!
+        :noop
+      end
+    end
+    # rubocop:enable Lint/UnusedMethodArgument
+  end
+end

data/lib/valkyrie/indexing/solr/indexing_adapter.rb

@@ -9,17 +9,12 @@ module Valkyrie
         ##
         # @!attribute [r] connection
         #   @return [RSolr::Client]
-        # @!attribute [r] resource_indexer
-        #   @return [Class]
-        attr_reader :connection, :resource_indexer
+        attr_reader :connection
 
         ##
         # @param connection [RSolr::Client] The RSolr connection to index to.
-        # @param resource_indexer [Class, #to_solr] An indexer which is able to
-        #   receive a `resource` argument and then has an instance method `#to_solr`
-        def initialize(connection: default_connection, resource_indexer: default_indexer)
+        def initialize(connection: default_connection)
           @connection = connection
-          @resource_indexer = resource_indexer
         end
 
         def save(resource:)
@@ -44,58 +39,58 @@ module Valkyrie
 
         private
 
-          def persist(resources)
-            documents = resources.map do |resource|
-              solr_document(resource)
-            end
-            add_documents(documents)
+        def persist(resources)
+          documents = resources.map do |resource|
+            solr_document(resource)
           end
+          add_documents(documents)
+        end
 
-          def solr_document(resource)
-            resource_indexer.new(resource: resource).to_solr
-          end
+        def solr_document(resource)
+          resource_indexer.for(resource: resource).to_solr
+        end
 
-          def add_documents(documents)
-            connection.add documents, params: COMMIT_PARAMS
-          end
+        def add_documents(documents)
+          connection.add documents, params: COMMIT_PARAMS
+        end
 
-          ##
-          # Index configuration based on the blacklight connection.
-          def blacklight_based_config
-            begin
-              # If Blacklight raises an error, we're hopefully running a
-              # generator now (if not, the application has bigger problems
-              # than this missing configuration)
-              bl_index = Blacklight.default_index.connection.uri
-            rescue RuntimeError
-              return {}
-            end
-
-            { 'host' => bl_index.host,
-              'port' => bl_index.port,
-              'core' => 'hyrax-valkyrie' }
+        ##
+        # Index configuration based on the blacklight connection.
+        def blacklight_based_config
+          begin
+            # If Blacklight raises an error, we're hopefully running a
+            # generator now (if not, the application has bigger problems
+            # than this missing configuration)
+            bl_index = Blacklight.default_index.connection.uri
+          rescue RuntimeError
+            return {}
           end
 
-          def connection_url
-            config = begin
-                       Rails.application.config_for(:valkyrie_index).compact
-                     rescue RuntimeError
-                       {}
-                     end
+          { 'host' => bl_index.host,
+            'port' => bl_index.port,
+            'core' => 'hyrax-valkyrie' }
+        end
+
+        def connection_url
+          config = begin
+                     Rails.application.config_for(:valkyrie_index).compact
+                   rescue RuntimeError
+                     {}
+                   end
 
-            # if any configuration is missing, derive it from Blacklight
-            config = blacklight_based_config.merge(config)
+          # if any configuration is missing, derive it from Blacklight
+          config = blacklight_based_config.merge(config)
 
-            "http://#{config['host']}:#{config['port']}/solr/#{config['core']}"
-          end
+          "http://#{config['host']}:#{config['port']}/solr/#{config['core']}"
+        end
 
-          def default_connection
-            RSolr.connect(url: connection_url)
-          end
+        def default_connection
+          RSolr.connect(url: connection_url)
+        end
 
-          def default_indexer
-            Valkyrie::Persistence::Solr::MetadataAdapter::NullIndexer
-          end
+        def resource_indexer
+          Hyrax::ValkyrieIndexer
+        end
       end
     end
   end

data/lib/valkyrie/indexing_adapter.rb

@@ -22,7 +22,7 @@ module Valkyrie
       def find(short_name)
         symbolized_key = short_name.to_sym
         return adapters[symbolized_key] if adapters.key?(symbolized_key)
-        raise "Unable to find unregistered adapter `#{short_name}'"
+        raise KeyError, "Unable to find unregistered adapter `#{short_name}'"
       end
     end
   end

data/lib/wings.rb

@@ -15,40 +15,121 @@
 # However, these dependencies should be considered temprorary: this code will
 # be deprecated for removal in a future release.
 #
+# @example casting an ActiveFedora model to Valkyrie
+#   work     = GenericWork.create(title: ['Comet in Moominland'])
+#   resource = work.valkyrie_resource
+#
+#   resource.title # => ["Comet in Moominland"]
+#   resource.title = ["Mumintrollet på kometjakt"]
+#
+#   Hyrax.persister.save(resource: resource)
+#
+#   work.reload
+#   work.title # => ["Mumintrollet på kometjakt"]
+#
+# @example defining a native Valkyrie model for use with Wings
+#   # given an `ActiveFodora` model like
+#   class Book < ActiveFedora::Base
+#     property :author, predicate: ::RDF::URI('http://example.com/ns/author')
+#     property :title,  predicate: ::RDF::URI('http://example.com/ns/title')
+#   end
+#
+#   # define a `Valkyrie` model with matching attributes,
+#   class BookResource < Hyrax::Resource
+#     attribute :author, Valkyrie::Types::String
+#     attribute :title,  Valkyrie::Types::String
+#   end
+#
+#   # and register the relationship with `Wings`
+#   Wings::ModelRegistry.register(BookResource, Book)
+#
+#   # `Wings` will cast the `BookResource` to a `Book` to persist via `ActiveFedora`
+#   resource = BookResource.new(author: 'Tove Jansson', title: 'Comet in Moominland')
+#   adapter  = Wings::Valkyrie::MetadataAdapter.new
+#   resource = adapter.persister.save(resource: resource)
+#
+#   resource.title  # => ["Comet in Moominland"]
+#   resource.author # => ["Tove Jansson"]
+#
+#   resource.is_a?(BookResource) # => true
+#
 # @see https://wiki.duraspace.org/display/samvera/Hyrax-Valkyrie+Development+Working+Group
 #      for further context regarding the approach
-module Wings; end
+module Wings
+  ##
+  # @api public
+  #
+  # Provides a search builder for new valkyrie types that are indexed as their
+  # corresponding legacy ActiveFedora classes.
+  #
+  # @example
+  #   builder = Wings::WorkSearchBuilder(Monograph)
+  def self.WorkSearchBuilder(work_type) # rubocop:disable Naming/MethodName
+    Class.new(Hyrax::WorkSearchBuilder) do
+      class_attribute :legacy_work_type, instance_writer: false
+      self.legacy_work_type = Wings::ModelRegistry.lookup(work_type)
+
+      def work_types
+        [legacy_work_type]
+      end
+
+      def self.inspect
+        "Wings::WorkSearchBuilder(#{legacy_work_type})"
+      end
+    end
+  end
+end
 
 require 'valkyrie'
+require 'wings/active_fedora_classifier'
+require 'wings/model_registry'
 require 'wings/model_transformer'
+require 'wings/orm_converter'
+require 'wings/attribute_transformer'
+require 'wings/services/custom_queries/find_access_control'
+require 'wings/services/custom_queries/find_collections_by_type'
+require 'wings/services/custom_queries/find_file_metadata'
+require 'wings/services/custom_queries/find_ids_by_model'
+require 'wings/services/custom_queries/find_many_by_alternate_ids'
 require 'wings/valkyrizable'
 require 'wings/valkyrie/metadata_adapter'
 require 'wings/valkyrie/resource_factory'
 require 'wings/valkyrie/persister'
+require 'wings/valkyrie/storage'
 require 'wings/valkyrie/query_service'
-require 'wings/valkyrie/storage/active_fedora'
 
-ActiveFedora::Base.include Wings::Valkyrizable
+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
 
-Valkyrie.config.resource_class_resolver = lambda do |_klass_name|
-  Wings::ModelTransformer.convert_class_name_to_valkyrie_resource_class(internal_resource)
+  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
 
-Valkyrie::MetadataAdapter.register(
-  Wings::Valkyrie::MetadataAdapter.new, :wings_adapter
-)
-Valkyrie.config.metadata_adapter = :wings_adapter
-
-Valkyrie::StorageAdapter.register(
-  Wings::Storage::ActiveFedora
-    .new(connection: Ldp::Client.new(ActiveFedora.fedora.host), base_path: ActiveFedora.fedora.base_path),
-  :active_fedora
-)
-Valkyrie.config.storage_adapter = :active_fedora
-
-[Hyrax::CustomQueries::Wings,
- Hyrax::CustomQueries::Navigators::ChildCollectionsNavigator,
- Hyrax::CustomQueries::Navigators::ChildFilesetsNavigator,
- Hyrax::CustomQueries::Navigators::ChildWorksNavigator].each do |query_handler|
-  Valkyrie.config.metadata_adapter.query_service.custom_queries.register_query_handler(query_handler)
+begin
+  require 'wings/setup'
+rescue NameError, Hyrax::SimpleSchemaLoader::UndefinedSchemaError => err
+  raise(err) if ENV['RAILS_ENV'] == 'production'
+  :noop
 end
+
+# some aliases for use by diners of varying sophistication
+BuffaloWings = Wings
+MightyWings = Wings
+HotWings = Wings
+SpicyWings = Wings
+SwissWings = Wings
+BuffaloCauliflowerWings = Wings

data/lib/wings/active_fedora_classifier.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Wings
+  class ActiveFedoraClassifier < ActiveFedora::ModelClassifier
+    private
+
+    def classify(model_value)
+      if (match = model_value.match(/Wings\((.*)\)/))
+        valkyrie_class = match[1].constantize
+        Wings::ActiveFedoraConverter::DefaultWork(valkyrie_class)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/wings/active_fedora_converter.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'wings/converter_value_mapper'
+require 'wings/active_fedora_converter/default_work'
+require 'wings/active_fedora_converter/nested_resource'
 
 module Wings
   ##
@@ -22,6 +24,14 @@ module Wings
       ActiveFedoraAttributes
     end
 
+    ##
+    # A class level cache mapping from Valkyrie resource classes to generated
+    # ActiveFedora classes
+    # @return [Hash<Class, Class>]
+    def self.class_cache
+      @class_cache ||= {}
+    end
+
     ##
     # @params [Valkyrie::Resource] resource
     #
@@ -43,32 +53,36 @@ module Wings
 
     ##
     # Accesses and parses the attributes from the resource through ConverterValueMapper
-    # @return [Hash]
+    #
+    # @return [Hash] attributes with values mapped for building an ActiveFedora model
     def attributes
-      @attribs ||= begin
-        wrapper = self.class.attributes_class.new(resource.attributes)
-        wrapper.result
+      @attributes ||= attributes_class.mapped_attributes(attributes: resource.attributes).select do |attr|
+        active_fedora_class.supports_property?(attr)
       end
     end
 
     ##
     # @return [ActiveFedora::Base]
     def convert
-      active_fedora_class.new(normal_attributes).tap do |af_object|
-        af_object.id = id unless id.empty?
-        add_access_control_attributes(af_object)
-        apply_depositor_to(af_object)
-        convert_members(af_object)
-        convert_member_of_collections(af_object)
+      instance.tap do |af_object|
+        af_object.id ||= id unless id.empty?
+        apply_attributes_to_model(af_object)
       end
     end
 
     def active_fedora_class
-      klass = resource.internal_resource.constantize
-      return klass if klass <= ActiveFedora::Base
-      return Hydra::AccessControls::Embargo if klass <= Hyrax::Embargo
-      return Hydra::AccessControls::Lease   if klass <= Hyrax::Lease
-      DefaultWork
+      @active_fedora_class ||= # cache the class at the instance level
+        begin
+          klass = begin
+                    resource.internal_resource.constantize
+                  rescue NameError
+                    Wings::ActiveFedoraClassifier.new(resource.internal_resource).best_model
+                  end
+
+          return klass if klass <= ActiveFedora::Common
+
+          ModelRegistry.lookup(klass)
+        end
     end
 
     ##
@@ -77,94 +91,75 @@ module Wings
     # then the id hasn't been minted and shouldn't yet be set.
     # @return [String]
     def id
-      id_attr = resource[:id]
-      return id_attr.to_s if id_attr.present? && id_attr.is_a?(::Valkyrie::ID) && !id_attr.blank?
+      return resource[:id].to_s if resource[:id]&.is_a?(::Valkyrie::ID) && resource[:id].present?
       return "" unless resource.respond_to?(:alternate_ids)
-      resource.alternate_ids.first.to_s
-    end
-
-    # A dummy work class for valkyrie resources that don't have corresponding
-    # hyrax ActiveFedora::Base models.
-    #
-    # A possible improvement would be to dynamically generate properties based
-    # on what's found in the resource.
-    class DefaultWork < ActiveFedora::Base
-      include Hyrax::WorkBehavior
-      property :ordered_authors, predicate: ::RDF::Vocab::DC.creator
-      property :ordered_nested, predicate: ::RDF::URI("http://example.com/ordered_nested")
-      property :nested_resource, predicate: ::RDF::URI("http://example.com/nested_resource"), class_name: "Wings::ActiveFedoraConverter::NestedResource"
-      include ::Hyrax::BasicMetadata
-      accepts_nested_attributes_for :nested_resource
-
-      # self.indexer = <%= class_name %>Indexer
-    end
 
-    class NestedResource < ActiveTriples::Resource
-      property :title, predicate: ::RDF::Vocab::DC.title
-      property :ordered_authors, predicate: ::RDF::Vocab::DC.creator
-      property :ordered_nested, predicate: ::RDF::URI("http://example.com/ordered_nested")
-      def initialize(uri = RDF::Node.new, _parent = ActiveTriples::Resource.new)
-        uri = if uri.try(:node?)
-                RDF::URI("#nested_resource_#{uri.to_s.gsub('_:', '')}")
-              elsif uri.to_s.include?('#')
-                RDF::URI(uri)
-              end
-        super
-      end
-      include ::Hyrax::BasicMetadata
+      resource.alternate_ids.first.to_s
     end
 
     private
 
-      def convert_members(af_object)
-        return unless resource.respond_to?(:member_ids) && resource.member_ids
-        # TODO: It would be better to find a way to add the members without resuming all the member AF objects
-        ordered_members = []
-        resource.member_ids.each do |valkyrie_id|
-          ordered_members << ActiveFedora::Base.find(valkyrie_id.id)
-        end
-        af_object.ordered_members = ordered_members
-      end
+    def instance
+      id.present? ? active_fedora_class.find(id) : active_fedora_class.new
+    rescue ActiveFedora::ObjectNotFoundError
+      active_fedora_class.new
+    end
 
-      def convert_member_of_collections(af_object)
-        return unless resource.respond_to?(:member_of_collection_ids) && resource.member_of_collection_ids
-        # TODO: It would be better to find a way to set the parent collections without resuming all the collection AF objects
-        member_of_collections = []
-        resource.member_of_collection_ids.each do |valkyrie_id|
-          member_of_collections << ActiveFedora::Base.find(valkyrie_id.id)
-        end
-        af_object.member_of_collections = member_of_collections
-      end
+    def attributes_class
+      self.class.attributes_class
+    end
 
-      # Normalizes the attributes parsed from the resource
-      #   (This ensures that scalar values are passed to the constructor for the
-      #   ActiveFedora::Base Class)
-      # @return [Hash]
-      def normal_attributes
-        normalized = {}
-        attributes.each_pair do |attr, value|
-          property = active_fedora_class.properties[attr.to_s]
-          # This handles some cases where the attributes do not directly map to an
-          #   RDF property value
-          normalized[attr] = value
-          next if property.nil?
-          normalized[attr] = Array.wrap(value) if property.multiple?
-        end
-        normalized
+    # Normalizes the attributes parsed from the resource
+    #   (This ensures that scalar values are passed to the constructor for the
+    #   ActiveFedora::Base Class)
+    # @return [Hash]
+    def normal_attributes
+      attributes.each_with_object({}) do |(attr, value), hash|
+        property = active_fedora_class.properties[attr.to_s]
+        hash[attr] = if property.nil?
+                       value
+                     elsif property.multiple?
+                       Array.wrap(value)
+                     elsif Array.wrap(value).length < 2
+                       Array.wrap(value).first
+                     else
+                       value
+                     end
       end
+    end
 
-      def apply_depositor_to(af_object)
-        af_object.apply_depositor_metadata(attributes[:depositor]) unless attributes[:depositor].blank?
+    ##
+    # apply attributes to the ActiveFedora model
+    def apply_attributes_to_model(af_object)
+      case af_object
+      when Hydra::AccessControl
+        add_access_control_attributes(af_object)
+      when ActiveFedora::File
+        add_file_attributes(af_object)
+      else
+        converted_attrs = normal_attributes
+        members = Array.wrap(converted_attrs.delete(:members))
+        files = converted_attrs.delete(:files)
+        af_object.attributes = converted_attrs
+        members.empty? ? af_object.try(:ordered_members)&.clear : af_object.try(:ordered_members=, members)
+        af_object.try(:members)&.replace(members)
+        af_object.files.build_or_set(files) if files
       end
+    end
 
-      # Add attributes from resource which aren't AF properties into af_object
-      def add_access_control_attributes(af_object)
-        return unless af_object.is_a? Hydra::AccessControls::Permissions
+    # Add attributes from resource which aren't AF properties into af_object
+    def add_access_control_attributes(af_object)
+      normal_attributes[:permissions].each { |p| p.access_to_id = resource.access_to&.id }
+      af_object.permissions = normal_attributes[:permissions]
+    end
 
-        af_object.read_users = attributes[:read_users]
-        af_object.edit_users = attributes[:edit_users]
-        af_object.read_groups = attributes[:read_groups]
-        af_object.edit_groups = attributes[:edit_groups]
-      end
+    # for files, add attributes to metadata_node, plus some other work
+    def add_file_attributes(af_object)
+      af_object.metadata_node.attributes = normal_attributes
+      af_object.original_name = resource.original_filename
+      new_type = (resource.type - af_object.metadata_node.type.to_a).first
+      af_object.metadata_node.type = new_type if new_type
+      af_object.mime_type = resource.mime_type
+    end
   end
 end