hyrax 2.8.0 → 3.0.0.pre.rc2

data/app/services/hyrax/persist_derivatives.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Hyrax
   class PersistDerivatives < Hydra::Derivatives::PersistOutputFileService
     # Persists a derivative to the local file system.

data/app/services/hyrax/persist_directly_contained_output_file_service.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Hyrax
   # This Service is an implementation of the Hydra::Derivatives::PersistOutputFileService
   # It supports directly contained files
@@ -24,7 +25,7 @@ module Hyrax
     def self.retrieve_file_set(directives)
       uri = URI(directives.fetch(:url))
       raise ArgumentError, "#{uri} is not an http(s) uri" unless uri.is_a?(URI::HTTP)
-      ActiveFedora::Base.find(ActiveFedora::Base.uri_to_id(uri.to_s))
+      Hyrax.query_service.find_by_alternate_identifier(alternate_identifier: Hyrax::Base.uri_to_id(uri.to_s), use_valkyrie: false)
     end
     private_class_method :retrieve_file_set
 

data/app/services/hyrax/qa_select_service.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Hyrax
   # This is an abstract class to provide select options from a
   # questioning authority backed authority
@@ -61,7 +62,7 @@ module Hyrax
     #   is an appropriate next step?
     def include_current_value(value, _index, render_options, html_options)
       unless value.blank? || active?(value)
-        html_options[:class] << ' force-select'
+        html_options[:class] += ' force-select'
         render_options += [[label(value) { value }, value]]
       end
       [render_options, html_options]

data/app/services/hyrax/quick_classification_query.rb

@@ -1,15 +1,26 @@
+# frozen_string_literal: true
 module Hyrax
+  ##
+  # Provides an enumerator of the Work classes the user is authorized to create.
+  #
+  # @example
+  #   QuickClassificationQuery.new(user: current_user).to_a
   class QuickClassificationQuery
+    ##
+    # @!attribute [r] user
+    #   @return [::User]
     attr_reader :user
 
-    # @param [User] user the current user
+    # @param [::User] user the current user
     # @param [Hash] options
     # @option options [#call] :concern_name_normalizer (String#constantize) a proc that translates names to classes
     # @option options [Array<String>] :models the options to display, defaults to everything.
-    def initialize(user, options = {})
+    def initialize(user,
+                   models: Hyrax.config.registered_curation_concern_types,
+                   concern_name_normalizer: ->(str) { str.constantize })
       @user = user
-      @concern_name_normalizer = options.fetch(:concern_name_normalizer, ->(str) { str.constantize })
-      @models = options.fetch(:models, Hyrax.config.registered_curation_concern_types)
+      @concern_name_normalizer = concern_name_normalizer
+      @models = models
     end
 
     def each(&block)
@@ -25,14 +36,15 @@ module Hyrax
     def authorized_models
       normalized_model_names.select { |klass| user.can?(:create, klass) }
     end
+    alias to_a authorized_models
 
     private
 
-      attr_reader :concern_name_normalizer, :models
+    attr_reader :concern_name_normalizer, :models
 
-      # Transform the list of requested model names into a list of class names
-      def normalized_model_names
-        models.map { |name| concern_name_normalizer.call(name) }
-      end
+    # Transform the list of requested model names into a list of class names
+    def normalized_model_names
+      models.map { |name| concern_name_normalizer.call(name) }
+    end
   end
 end

data/app/services/hyrax/repository_fixity_check_service.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Hyrax
   class RepositoryFixityCheckService
     # This is a service that folks can use in their own rake tasks,

data/app/services/hyrax/resource_status.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # Implements the Fedora objState ontology against the given resource.
+  #
+  # Use the provided constants as values for `#status` to set state. The
+  # boolean methods provide easy checking of state.
+  #
+  # We assume that no-state, means none of the three object statuses are
+  # satisfied. Errors are raised if the `#state` attribute isn't defined.
+  #
+  # @see http://fedora.info/definitions/1/0/access/ObjState
+  #
+  # @example
+  #   status = ResourceStatus.new(resource: my_resource)
+  #   status.inactive? # => false
+  #
+  #   my_resource.state = ResourceStatus::INACTIVE
+  #   status = ResourceStatus.new(resource: my_resource)
+  #   status.inactive? # => true
+  #
+  class ResourceStatus
+    ACTIVE   = Vocab::FedoraResourceStatus.active.freeze
+    DELETED  = Vocab::FedoraResourceStatus.deleted.freeze
+    INACTIVE = Vocab::FedoraResourceStatus.inactive.freeze
+
+    ##
+    # @!attribute [rw] resource
+    #   @return [#state]
+    attr_accessor :resource
+
+    ##
+    # @param [#state] resource
+    def initialize(resource:)
+      self.resource = resource
+    end
+
+    ##
+    # @return [Boolean]
+    # @raise [NoMethodError] if the resource doesn't have a state attribute
+    def active?
+      resource.state == ACTIVE
+    end
+
+    ##
+    # @return [Boolean]
+    # @raise [NoMethodError] if the resource doesn't have a state attribute
+    def deleted?
+      resource.state == DELETED
+    end
+
+    ##
+    # @return [Boolean]
+    # @raise [NoMethodError] if the resource doesn't have a state attribute
+    def inactive?
+      resource.state == INACTIVE
+    end
+  end
+end

data/app/services/hyrax/resource_types_service.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Hyrax
   module ResourceTypesService
     mattr_accessor :authority

data/app/services/hyrax/resource_visibility_propagator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # Propagates visibility from a valkyrie Work to its FileSets
+  class ResourceVisibilityPropagator
+    ##
+    # @!attribute [rw] source
+    #   @return [#visibility]
+    attr_accessor :source
+
+    ##
+    # @!attribute [r] embargo_manager
+    #   @return [Hyrax::EmbargoManager]
+    # @!attribute [r] lease_manager
+    #   @return [Hyrax::LeaseManager]
+    # @!attribute [r] persister
+    #   @return [#save]
+    # @!attribute [r] queries
+    #   @returrn [Valkyrie::Persistence::CustomQueryContainer]
+    attr_reader :embargo_manager, :lease_manager, :persister, :queries
+
+    ##
+    # @param source [#visibility] the object to propagate visibility from
+    def initialize(source:,
+                   embargo_manager: Hyrax::EmbargoManager,
+                   lease_manager:   Hyrax::LeaseManager,
+                   persister:       Hyrax.persister,
+                   queries:         Hyrax.custom_queries)
+      @persister       = persister
+      @queries         = queries
+      self.source      = source
+      @embargo_manager = embargo_manager.new(resource: source)
+      @lease_manager   = lease_manager.new(resource: source)
+    end
+
+    ##
+    # @return [void]
+    #
+    # @raise [RuntimeError] if visibility propagation fails
+    def propagate
+      queries.find_child_filesets(resource: source).each do |file_set|
+        file_set.visibility = source.visibility
+        embargo_manager.copy_embargo_to(target: file_set)
+        lease_manager.copy_lease_to(target: file_set)
+
+        file_set.permission_manager.acl.save
+        persister.save(resource: file_set)
+      end
+    end
+  end
+end

data/app/services/hyrax/restriction_service.rb

@@ -1,24 +1,25 @@
+# frozen_string_literal: true
 module Hyrax
   class RestrictionService
     class << self
       private
 
-        def presenter_class
-          raise "RestrictionService is an Abstract class and should be extended. Implement presenter_class in the subclass"
-        end
+      def presenter_class
+        raise "RestrictionService is an Abstract class and should be extended. Implement presenter_class in the subclass"
+      end
 
-        def presenters(builder)
-          response = repository.search(builder)
-          response.documents.map { |d| presenter_class.new(d) }
-        end
+      def presenters(builder)
+        response = repository.search(builder)
+        response.documents.map { |d| presenter_class.new(d) }
+      end
 
-        def repository
-          config.repository
-        end
+      def repository
+        config.repository
+      end
 
-        def config
-          @config ||= ::CatalogController.new
-        end
+      def config
+        @config ||= ::CatalogController.new
+      end
     end
   end
 end

data/app/services/hyrax/rights_statement_service.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Hyrax
   # Provide select options for the copyright status (edm:rights) field
   class RightsStatementService < QaSelectService

data/app/services/hyrax/simple_schema_loader.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # @api private
+  #
+  # This is a simple yaml config-driven schema loader
+  #
+  # @see config/metadata/basic_metadata.yaml for an example configuration
+  class SimpleSchemaLoader
+    ##
+    # @param [Symbol] schema
+    #
+    # @return [Hash<Symbol, Dry::Types::Type>] a map from attribute names to
+    #   types
+    def attributes_for(schema:)
+      definitions(schema).each_with_object({}) do |definition, hash|
+        hash[definition.name] = definition.type
+      end
+    end
+
+    ##
+    # @param [Symbol] schema
+    #
+    # @return [Hash{Symbol => Hash{Symbol => Object}}]
+    def form_definitions_for(schema:)
+      definitions(schema).each_with_object({}) do |definition, hash|
+        next if definition.form_options.empty?
+
+        hash[definition.name] = definition.form_options
+      end
+    end
+
+    ##
+    # @param [Symbol] schema
+    #
+    # @return [Hash<Symbol, Symbol>] a map from index keys to attribute names
+    def index_rules_for(schema:)
+      definitions(schema).each_with_object({}) do |definition, hash|
+        definition.index_keys.each do |key|
+          hash[key] = definition.name
+        end
+      end
+    end
+
+    ##
+    # @api private
+    class AttributeDefinition
+      ##
+      # @!attr_reader :config
+      #   @return [Hash<String, Object>]
+      # @!attr_reader :name
+      #   @return [#to_sym]
+      attr_reader :config, :name
+
+      ##
+      # @param [#to_sym] name
+      # @param [Hash<String, Object>] config
+      def initialize(name, config)
+        @config = config
+        @name   = name.to_sym
+      end
+
+      ##
+      # @return [Hash{Symbol => Object}]
+      def form_options
+        config.fetch('form', {}).symbolize_keys
+      end
+
+      ##
+      # @return [Enumerable<Symbol>]
+      def index_keys
+        config.fetch('index_keys', []).map(&:to_sym)
+      end
+
+      ##
+      # @return [Dry::Types::Type]
+      def type
+        collection_type = config['multiple'] ? Valkyrie::Types::Array : Identity
+        collection_type.of(type_for(config['type']))
+      end
+
+      ##
+      # @api private
+      #
+      # This class acts as a Valkyrie/Dry::Types collection with typed members,
+      # but instead of wrapping the given type with itself as the collection type
+      # (as in `Valkyrie::Types::Array.of(MyType)`), it returns the given type.
+      #
+      # @example
+      #   Identity.of(Valkyrie::Types::String) # => Valkyrie::Types::String
+      #
+      class Identity
+        ##
+        # @param [Dry::Types::Type]
+        # @return [Dry::Types::Type] the type passed in
+        def self.of(type)
+          type
+        end
+      end
+
+      private
+
+      ##
+      # Maps a configuration string value to a `Valkyrie::Type`.
+      #
+      # @param [String]
+      # @return [Dry::Types::Type]
+      def type_for(type)
+        case type
+        when 'uri'
+          Valkyrie::Types::URI
+        when 'date_time'
+          Valkyrie::Types::DateTime
+        else
+          "Valkyrie::Types::#{type.capitalize}".constantize
+        end
+      end
+    end
+
+    class UndefinedSchemaError < ArgumentError; end
+
+    private
+
+    ##
+    # @param [#to_s] schema_name
+    # @return [Enumerable<AttributeDefinition]
+    def definitions(schema_name)
+      schema_config(schema_name)['attributes'].map do |name, config|
+        AttributeDefinition.new(name, config)
+      end
+    end
+
+    ##
+    # @param [#to_s] schema_name
+    # @return [Hash]
+    def schema_config(schema_name)
+      schema_config_path = config_paths(schema_name).find { |path| File.exist? path }
+      raise(UndefinedSchemaError, "No schema defined: #{schema_name}") unless schema_config_path
+
+      YAML.safe_load(File.open(schema_config_path))
+    end
+
+    def config_paths(schema_name)
+      config_search_paths.collect { |root_path| root_path.to_s + "/config/metadata/#{schema_name}.yaml" }
+    end
+
+    def config_search_paths
+      [Rails.root, Hyrax::Engine.root]
+    end
+  end
+end

data/app/services/hyrax/solr_query_builder_service.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+module Hyrax
+  # Methods in this class are from/based on ActiveFedora::SolrQueryBuilder
+  class SolrQueryBuilderService
+    class << self
+      # Construct a solr query for a list of ids
+      # This is used to get a solr response based on the list of ids in an object's RELS-EXT relationhsips
+      # If the id_array is empty, defaults to a query of "id:NEVER_USE_THIS_ID", which will return an empty solr response
+      # @param [Array] id_array the ids that you want included in the query
+      def construct_query_for_ids(id_array)
+        ids = id_array.reject(&:blank?)
+        return "id:NEVER_USE_THIS_ID" if ids.empty?
+        "{!terms f=#{Hyrax.config.id_field}}#{ids.join(',')}"
+      end
+
+      # Construct a solr query from a list of pairs (e.g. [field name, values])
+      # @param [Array<Array>] field_pairs a list of pairs of property name and values
+      # @param [String] join_with ('AND') the value we're joining the clauses with
+      # @param [String] type ('field') The type of query to run. Either 'raw' or 'field'
+      # @return [String] a solr query
+      # @example
+      #   construct_query([['library_id_ssim', '123'], ['owner_ssim', 'Fred']])
+      #   # => "_query_:\"{!field f=library_id_ssim}123\" AND _query_:\"{!field f=owner_ssim}Fred\""
+      def construct_query(field_pairs, join_with = default_join_with, type = 'field')
+        clauses = pairs_to_clauses(field_pairs, type)
+        return "" if clauses.count.zero?
+        return clauses.first if clauses.count == 1
+        "(#{clauses.join(join_with)})"
+      end
+
+      def default_join_with
+        ' AND '
+      end
+
+      private
+
+      # @param [Array<Array>] pairs a list of (key, value) pairs. The value itself may
+      # @param [String] type  The type of query to run. Either 'raw' or 'field'
+      # @return [Array] a list of solr clauses
+      def pairs_to_clauses(pairs, type)
+        pairs.flat_map do |field, value|
+          condition_to_clauses(field, value, type)
+        end
+      end
+
+      # @param [String] field
+      # @param [String, Array<String>] values
+      # @param [String] type The type of query to run. Either 'raw' or 'field'
+      # @return [Array<String>]
+      def condition_to_clauses(field, values, type)
+        values = Array(values)
+        values << nil if values.empty?
+        values.map do |value|
+          if value.present?
+            query_clause(type, field, value)
+          else
+            # Check that the field is not present. In SQL: "WHERE field IS NULL"
+            "-#{field}:[* TO *]"
+          end
+        end
+      end
+
+      # Create a raw query clause suitable for sending to solr as an fq element
+      # @param [String] type The type of query to run. Either 'raw' or 'field'
+      # @param [String] key
+      # @param [String] value
+      def query_clause(type, key, value)
+        "_query_:\"{!#{type} f=#{key}}#{value.gsub('"', '\"')}\""
+      end
+    end
+  end
+end