hyrax 2.8.0 → 3.0.0.pre.rc2

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+require 'dry/monads'
+
+module Hyrax
+  module Transactions
+    module Steps
+      ##
+      # Validates a ChangeSet, returning `Success(change_set)` if valid, and
+      # a `Failure` including the errors otherwise.
+      #
+      # Callers provide the particular `ChangeSet` to validate, and its validity
+      # status is delegated by its own configuration/implementation.
+      #
+      # It is good practice to run this validation as a precursor to any step
+      # that will sync a ChangeSet or save its resource. A `Failure` return
+      # value in the context of a transaction will prevent the sync/save step
+      # from running.
+      #
+      # @since 3.0.0
+      class Validate
+        include Dry::Monads[:result]
+
+        ##
+        # @param [Hyrax::ChangeSet] change_set
+        #
+        # @return [Dry::Monads::Result] `Success(input)` if the change_set is valid;
+        #   `Failure`, otherwise.
+        def call(change_set)
+          return Success(change_set) if change_set.valid?
+
+          Failure([:failed_validation, change_set.errors])
+        end
+      end
+    end
+  end
+end

data/lib/hyrax/transactions/transaction.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require 'dry/monads'
+require 'dry/monads/do'
+
+module Hyrax
+  module Transactions
+    ##
+    # Queues up a set of `#steps` to run over a value via `#call`. Steps are
+    # given by name, and resolved at runtime via `container`, which defaults to
+    # `Hyrax::Transactions::Container`. This allows injection of specific
+    # handling for named steps at any time.
+    #
+    # `#call` will **ALWAYS** return a `Result` (`Success`|`Failure`) and it's
+    # recommended for users to handle the output in a way that directly
+    # addresses the `Failure` case. The simplest way to do this is to use
+    # `#value_or`: `tx.call(my_value).value_or { |failure| handle_failure(f) }`.
+    #
+    # @since 3.0.0
+    #
+    # @example running a transaction for a set of steps
+    #   steps = ['change_set.validate', 'change_set.save']
+    #   tx    = Hyrax::Transactions::Transaction.new(steps: steps)
+    #
+    #   change_set = Hyrax::ChangeSet.for(Hyrax::Work.new)
+    #   change_set.title = ['comet in moominland']
+    #
+    #   tx.call(change_set) # => Success(#<Hyrax::Work ...>)
+    #
+    # @example with a failure
+    #   class ChangeSetWithTitleValidation < Hyrax::ChangeSet
+    #     self.fields = [:title]
+    #     validates :title, presence: true
+    #   end
+    #
+    #   change_set = ChangeSetWithTitleValidation.new(Hyrax::Work.new)
+    #   change_set.title = []
+    #
+    #   tx.call(change_set)
+    #   # => Failure([:failed_validation, #<Reform::Form::ActiveModel::Errors ...>]
+    #
+    # @example unwapping values safely with handling for failures
+    #   tx.call(change_set).value_or { |failure| "uh oh: #{failure} }
+    #
+    # @example when there is no need to unwrap the value, handle errors with `#or`
+    #   tx.call(change_set).or { |failure| "uh oh: #{failure} }
+    #
+    # @example a pattern for subclassing to create new transactions
+    #   class CustomTransaction < Transaction
+    #     DEFAULT_STEPS = ['step.1', 'step.2', 'step.3'].freeze
+    #
+    #     def initialize(container: Container, steps: DEFAULT_STEPS)
+    #       super
+    #     end
+    #   end
+    #
+    #   tx = CustomTransaction.new
+    #   tx.call(:some_value)
+    #
+    class Transaction
+      include Dry::Monads[:result]
+      include Dry::Monads::Do.for(:call)
+
+      ##
+      # @!attribute [rw] container
+      #   @return [Container]
+      # @!attribute [rw] steps
+      #   @return [Array<String>]
+      attr_accessor :container, :steps
+
+      ##
+      # @api public
+      #
+      # @param [Container] container
+      # @param [Array<String>] steps
+      def initialize(container: Container, steps:)
+        self.container = container
+        self.steps     = steps
+      end
+
+      ##
+      # @api public
+      #
+      # Run each step name in `#steps` by resolving the name in the given
+      # `container` and passing a value to call. Each step must return a
+      # `Result`. In the event of a `Success`, the wrapped value is passed
+      # through to the next step; for `Failure` the whole chain is short-
+      # circuited and the failure result is given.
+      #
+      # @param [Object] value
+      #
+      # @return [Dry::Monads::Result] either the `Success` result of the entire
+      #   `#steps` chain over `value`, or a `Failure` from the failed step.
+      # @see Dry::Monads::Do
+      def call(value)
+        Success(
+          steps.inject(value) do |val, step_name|
+            yield container[step_name].call(val, *step_arguments_for(step_name))
+          end
+        )
+      end
+
+      ##
+      # Sets arguments to pass to a given step in the transaction.
+      #
+      # This makes it easy for individual steps to require pieces of information
+      # without other steps having to handle them. This is desirable since it
+      # avoids passing mutable values between steps, which commonly results in
+      # tight interdependence and less flexible composibility between steps.
+      #
+      # Instead we expect the caller to provide the correct data to each step
+      # when the transaction starts.
+      #
+      # @param [Hash<Object, Array>] args
+      #
+      # @return [Transaction] returns self
+      #
+      # @example passing arguments for a named step
+      #   tx = Hyrax::Transactions::Transaction.new(steps: [:first_step, :second_step])
+      #   result = tx.with_step_args(second_step: {named_parameter: :param_value}).call(:value)
+      #
+      def with_step_args(args)
+        raise(ArgumentError, key_err_msg(args.keys)) if
+          args.keys.any? { |key| !step?(key) }
+
+        @_step_args = args
+        self
+      end
+
+      private
+
+      ##
+      # @api private
+      # @param [String, Symbol] step_name
+      # @return [Array]
+      def step_arguments_for(step_name)
+        step_args = @_step_args || {}
+
+        Array.wrap(step_args[step_name])
+      end
+
+      ##
+      # @api private
+      # @param [Array] keys
+      # @return [String]
+      def key_err_msg(keys)
+        missing_steps = keys.select { |key| !step?(key) }
+
+        "Tried to pass step arguments for unknown steps #{missing_steps.join(', ')}\n" \
+        "\tSteps defined for this transaction are: #{@steps.join(', ')}"
+      end
+
+      ##
+      # @api private
+      # @param [String, Symbol] step_name
+      def step?(step_name)
+        steps.include?(step_name)
+      end
+    end
+  end
+end

data/lib/hyrax/transactions/update_work.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module Hyrax
+  module Transactions
+    ##
+    # @since 3.0.0
+    class UpdateWork < Transaction
+      DEFAULT_STEPS = ['change_set.apply'].freeze
+
+      ##
+      # @see Hyrax::Transactions::Transaction
+      def initialize(container: Container, steps: DEFAULT_STEPS)
+        super
+      end
+    end
+  end
+end

data/lib/hyrax/transactions/work_create.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require 'hyrax/transactions/transaction'
+
+module Hyrax
+  module Transactions
+    ##
+    # Creates a Work from a ChangeSet
+    #
+    # @since 3.0.0
+    class WorkCreate < Transaction
+      DEFAULT_STEPS = ['change_set.set_default_admin_set',
+                       'change_set.ensure_admin_set',
+                       'change_set.set_user_as_depositor',
+                       'change_set.add_to_collections',
+                       'change_set.apply'].freeze
+
+      ##
+      # @see Hyrax::Transactions::Transaction
+      def initialize(container: Container, steps: DEFAULT_STEPS)
+        super
+      end
+    end
+  end
+end

data/lib/hyrax/valkyrie_can_can_adapter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # A `CanCan::ModelAdapter` for valkyrie resources
+  class ValkyrieCanCanAdapter < CanCan::ModelAdapters::AbstractAdapter
+    ##
+    # @param [Class] member_class
+    def self.for_class?(member_class)
+      member_class == Hyrax::Resource ||
+        member_class < Hyrax::Resource
+    end
+
+    ##
+    # @param [Class] model_class
+    # @param [String] id
+    #
+    # @return [Hyrax::Resource]
+    #
+    # @raise Hyrax::ObjectNotFoundError
+    def self.find(_model_class, id)
+      Hyrax.query_service.find_by_alternate_identifier(alternate_identifier: id)
+    end
+  end
+end

data/lib/hyrax/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Hyrax
-  VERSION = '2.8.0'.freeze
+  VERSION = '3.0.0-rc2'
 end

data/lib/hyrax/zotero.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'hyrax/zotero/config'
 
 module Hyrax

data/lib/hyrax/zotero/config.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Hyrax
   module Zotero
     def self.config

data/lib/tasks/controlled_vocabularies.rake

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

data/lib/tasks/default_admin_set.rake

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 namespace :hyrax do
   namespace :default_admin_set do
     desc "Create the Default Admin Set"

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/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
@@ -34,5 +35,11 @@ namespace :hyrax do
       # added in Hyrax 2.1.0
       Hyrax::Collections::MigrationService.migrate_all_collections
     end
+
+    # 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::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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+namespace :hyrax do
+  namespace :universal_viewer do
+    desc "Install Universal Viewer"
+    task install: :environment do
+      # Copy the files into place
+      hyrax_templates_path = File.join(Gem.loaded_specs['hyrax'].full_gem_path, 'lib', 'generators', 'hyrax', 'templates')
+      copy_file File.join(hyrax_templates_path, 'package.json'), Rails.root.join('package.json')
+      Dir.mkdir(Rails.root.join('config', 'uv')) unless File.exist?(Rails.root.join('config', 'uv'))
+      copy_file File.join(hyrax_templates_path, 'uv.html'), Rails.root.join('config', 'uv', 'uv.html')
+      copy_file File.join(hyrax_templates_path, 'uv-config.json'), Rails.root.join('config', 'uv', 'uv-config.json')
+
+      puts 'Universal Viewer (UV) configs copied into place, install UV by running yarn install or rake assets:precompile'
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+require 'rsolr'
+
+module Valkyrie
+  module Indexing
+    module Solr
+      class IndexingAdapter
+        COMMIT_PARAMS = { softCommit: true }.freeze
+        ##
+        # @!attribute [r] connection
+        #   @return [RSolr::Client]
+        attr_reader :connection
+
+        ##
+        # @param connection [RSolr::Client] The RSolr connection to index to.
+        def initialize(connection: default_connection)
+          @connection = connection
+        end
+
+        def save(resource:)
+          persist([resource])
+        end
+
+        def save_all(resources:)
+          persist(resources)
+        end
+
+        # Deletes a Solr Document using the ID
+        # @return [Array<Valkyrie::Resource>] resources which have been deleted from Solr
+        def delete(resource:)
+          connection.delete_by_id resource.id.to_s, params: COMMIT_PARAMS
+        end
+
+        # Delete the Solr index of all Documents
+        def wipe!
+          connection.delete_by_query("*:*")
+          connection.commit
+        end
+
+        private
+
+        def persist(resources)
+          documents = resources.map do |resource|
+            solr_document(resource)
+          end
+          add_documents(documents)
+        end
+
+        def solr_document(resource)
+          resource_indexer.for(resource: resource).to_solr
+        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' }
+        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)
+
+          "http://#{config['host']}:#{config['port']}/solr/#{config['core']}"
+        end
+
+        def default_connection
+          RSolr.connect(url: connection_url)
+        end
+
+        def resource_indexer
+          Hyrax::ValkyrieIndexer
+        end
+      end
+    end
+  end
+end