hyrax 3.0.0.pre.beta2 → 3.0.0.pre.beta3

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

@@ -3,7 +3,8 @@ module Hyrax
   module Transactions
     module Steps
       ##
-      # A `dry-transcation` step that applies a permission template.
+      # A `dry-transcation` step that applies a permission template for a given
+      # work's AdminSet.
       #
       # @since 2.4.0
       class ApplyPermissionTemplate

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+module Hyrax
+  module Transactions
+    module Steps
+      ##
+      # A `dry-transaction` step that interprets visibility/lease/embargo from
+      # passed arguments.
+      #
+      # @since 3.0.0
+      class ApplyVisibility
+        include Dry::Transaction::Operation
+
+        ##
+        # @param [Hyrax::WorkBehavior] work
+        # @param [String] visibility
+        # @param [String] release_date
+        # @param [String] during
+        # @param [String] after
+        #
+        # @return [Dry::Monads::Result] `Failure` if there is no
+        #   `PermissionTemplate` for the input; `Success(input)`, otherwise.
+        def call(work, visibility: nil, release_date: nil, during: nil, after: nil)
+          return Success(work) unless visibility.present?
+
+          intention = Hyrax::VisibilityIntention.new(visibility:   visibility,
+                                                     release_date: release_date,
+                                                     during:       during,
+                                                     after:        after)
+
+          Hyrax::VisibilityIntentionApplicator.apply(intention).to(model: work)
+
+          Success(work)
+        rescue Hyrax::VisibilityIntentionApplicator::InvalidIntentionError => err
+          Failure(err)
+        end
+      end
+    end
+  end
+end

data/lib/hyrax/version.rb

@@ -1,3 +1,3 @@
 module Hyrax
-  VERSION = '3.0.0-beta2'.freeze
+  VERSION = '3.0.0-beta3'.freeze
 end

data/lib/tasks/migrate.rake

@@ -34,5 +34,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::URI.new('http://dublincore.org/documents/dcmi-terms/#terms-license'))
+    end
   end
 end

data/lib/tasks/universal_viewer.rake

@@ -0,0 +1,15 @@
+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/valkyrie/indexing/solr/indexing_adapter.rb

@@ -0,0 +1,102 @@
+# 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]
+        # @!attribute [r] resource_indexer
+        #   @return [Class]
+        attr_reader :connection, :resource_indexer
+
+        ##
+        # @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)
+          @connection = connection
+          @resource_indexer = resource_indexer
+        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.new(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 default_indexer
+            Valkyrie::Persistence::Solr::MetadataAdapter::NullIndexer
+          end
+      end
+    end
+  end
+end

data/lib/valkyrie/indexing_adapter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module Valkyrie
+  # IndexingAdapter is the primary DataMapper object for indexing.
+  #  Used to register and locate adapters, for individual
+  #  indexing backends (such as solr, elasticsearch, etc)
+  class IndexingAdapter
+    class_attribute :adapters
+    self.adapters = {}
+    class << self
+      # Register an adapter by a short name.
+      # Registering an adapter by a short name makes the adapter easier to find and reference.
+      # @param adapter Adapter to register.
+      # @param short_name [Symbol] Name to register it under.
+      def register(adapter, short_name)
+        adapters[short_name.to_sym] = adapter
+      end
+
+      # Find an adapter by its short name.
+      # @param short_name [Symbol]
+      # @return adapter
+      # @raise RuntimeError when the given short_name is not found amongst the registered adapters
+      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}'"
+      end
+    end
+  end
+end

data/lib/wings.rb

@@ -21,12 +21,12 @@ module Wings; end
 
 require 'valkyrie'
 require 'wings/model_transformer'
-require 'wings/resource_factory'
 require 'wings/valkyrizable'
 require 'wings/valkyrie/metadata_adapter'
 require 'wings/valkyrie/resource_factory'
 require 'wings/valkyrie/persister'
 require 'wings/valkyrie/query_service'
+require 'wings/valkyrie/storage/active_fedora'
 
 ActiveFedora::Base.include Wings::Valkyrizable
 
@@ -37,9 +37,18 @@ end
 Valkyrie::MetadataAdapter.register(
   Wings::Valkyrie::MetadataAdapter.new, :wings_adapter
 )
+Valkyrie.config.metadata_adapter = :wings_adapter
 
 Valkyrie::StorageAdapter.register(
-  Valkyrie::Storage::Fedora
-    .new(connection: Ldp::Client.new(ActiveFedora.fedora.host)),
-  :fedora
+  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)
+end

data/lib/wings/active_fedora_converter.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require 'wings/converter_value_mapper'
+
 module Wings
   ##
-  # Converts `ValkyrieResource` objects to legacy `ActiveFedora::Base` objects.
+  # Converts `Valkyrie::Resource` objects to legacy `ActiveFedora::Base` objects.
   #
   # @example
   #   work     = GenericWork.new(title: ['Comet in Moominland'])
@@ -13,6 +15,21 @@ module Wings
   # @note the `Valkyrie::Resource` object passed to this class **must** have an
   #   `#internal_resource` mapping it to an `ActiveFedora::Base` class.
   class ActiveFedoraConverter
+    ##
+    # Accesses the Class implemented for handling resource attributes
+    # @return [Class]
+    def self.attributes_class
+      ActiveFedoraAttributes
+    end
+
+    ##
+    # @params [Valkyrie::Resource] resource
+    #
+    # @return [ActiveFedora::Base]
+    def self.convert(resource:)
+      new(resource: resource).convert
+    end
+
     ##
     # @!attribute [rw] resource
     #   @return [Valkyrie::Resource]
@@ -25,32 +42,129 @@ module Wings
     end
 
     ##
-    # @return [Hash<Symbol, Object>]
+    # Accesses and parses the attributes from the resource through ConverterValueMapper
+    # @return [Hash]
     def attributes
-      attrs = resource.attributes
-
-      # avoid reflections for now; `*_ids` can't be passed as attributes.
-      # handling for reflections needs to happen in future work
-      attrs = attrs.reject { |k, _| k.to_s.end_with? '_ids' }
-
-      attrs.delete(:internal_resource)
-      attrs.delete(:new_record)
-      attrs.delete(:id)
-      attrs.delete(:alternate_ids)
-
-      attrs.compact
+      @attribs ||= begin
+        wrapper = self.class.attributes_class.new(resource.attributes)
+        wrapper.result
+      end
     end
 
     ##
     # @return [ActiveFedora::Base]
     def convert
-      resource.internal_resource.new(attributes).tap { |obj| obj.id = id unless id.empty? }
+      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)
+      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
     end
 
     ##
+    # In the context of a Valkyrie resource, prefer to use the id if it
+    # is provided and fallback to the first of the alternate_ids. If all else fails
+    # 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 "" 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
+    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 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
+
+      # 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
+      end
+
+      def apply_depositor_to(af_object)
+        af_object.apply_depositor_metadata(attributes[:depositor]) unless attributes[:depositor].blank?
+      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
+
+        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
   end
 end

data/lib/wings/converter_value_mapper.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Wings
+  ##
+  # A base value mapper for converting property values in the
+  # `Valkyrie` type system to `ActiveFedora`/`ActiveTriples` type
+  #
+  # This top level matcher has registered several internal mappers which handle
+  # indivdual value types from the source data.
+  class ConverterValueMapper < ::Valkyrie::ValueMapper; end
+
+  class NestedEmbargoValue < ::Valkyrie::ValueMapper
+    ConverterValueMapper.register(self)
+
+    def self.handles?(value)
+      value.first == :embargo
+    end
+
+    def result
+      embargo = ActiveFedoraConverter.new(resource: Hyrax::Embargo.new(**value.last)).convert
+
+      [:embargo, embargo]
+    end
+  end
+
+  class NestedLeaseValue < ::Valkyrie::ValueMapper
+    ConverterValueMapper.register(self)
+
+    def self.handles?(value)
+      value.first == :lease
+    end
+
+    def result
+      lease = ActiveFedoraConverter.new(resource: Hyrax::Lease.new(**value.last)).convert
+
+      [:lease, lease]
+    end
+  end
+
+  class NestedResourceArrayValue < ::Valkyrie::ValueMapper
+    ConverterValueMapper.register(self)
+    def self.handles?(value)
+      value.last.is_a?(Array) && value.last.map { |x| x.try(:class) }.include?(Hash)
+    end
+
+    def result
+      ["#{value.first}_attributes".to_sym, values]
+    end
+
+    def values
+      value.last.map do |val|
+        calling_mapper.for([value.first, val]).result
+      end.flat_map(&:last)
+    end
+  end
+
+  class NestedResourceValue < ::Valkyrie::ValueMapper
+    ConverterValueMapper.register(self)
+    def self.handles?(value)
+      value.last.is_a?(Hash)
+    end
+
+    def result
+      attrs = ActiveFedoraAttributes.new(value.last).result
+      attrs.delete(:read_groups)
+      attrs.delete(:read_users)
+      attrs.delete(:edit_groups)
+      attrs.delete(:edit_users)
+
+      [value.first, attrs]
+    end
+  end
+
+  class ActiveFedoraAttributes
+    attr_reader :attributes
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def result
+      Hash[
+        filter_attributes.map do |value|
+          ConverterValueMapper.for(value).result
+        end.select(&:present?)
+      ]
+    end
+
+    ##
+    # @return [Hash<Symbol, Object>]
+    def filter_attributes
+      # avoid reflections for now; `*_ids` can't be passed as attributes.
+      # handling for reflections needs to happen in future work
+      attrs = attributes.reject { |k, _| k.to_s.end_with? '_ids' }
+
+      attrs.delete(:internal_resource)
+      attrs.delete(:new_record)
+      attrs.delete(:id)
+      attrs.delete(:alternate_ids)
+      attrs.delete(:created_at)
+      attrs.delete(:updated_at)
+      attrs.delete(:member_ids)
+
+      # remove reflection id attributes and reinsert as strings
+      attrs.select { |k| k.to_s.end_with? '_id' }.each_key do |k|
+        val = attrs.delete(k)
+        attrs[k] = val.to_s unless val.blank?
+      end
+      attrs.compact
+    end
+  end
+end