hyrax 2.8.0 → 3.0.0.pre.rc2

data/app/indexers/hyrax/file_set_indexer.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
 module Hyrax
   class FileSetIndexer < ActiveFedora::IndexingService
     include Hyrax::IndexesThumbnails
     include Hyrax::IndexesBasicMetadata
-    STORED_LONG = Solrizer::Descriptor.new(:long, :stored)
+    STORED_LONG = ActiveFedora::Indexing::Descriptor.new(:long, :stored)
 
-    def generate_solr_document
+    def generate_solr_document # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       super.tap do |solr_doc|
         solr_doc['hasRelatedMediaFragment_ssim'] = object.representative_id
         solr_doc['hasRelatedImage_ssim'] = object.thumbnail_id
@@ -21,41 +22,37 @@ module Hyrax
         solr_doc['mime_type_ssi']  = object.mime_type
         # Index the Fedora-generated SHA1 digest to create a linkage between
         # files on disk (in fcrepo.binary-store-path) and objects in the repository.
-        solr_doc['digest_ssim'] = digest_from_content
+        solr_doc['digest_ssim']             = [digest_from_content]
         solr_doc['page_count_tesim']        = object.page_count
         solr_doc['file_title_tesim']        = object.file_title
         solr_doc['duration_tesim']          = object.duration
         solr_doc['sample_rate_tesim']       = object.sample_rate
         solr_doc['original_checksum_tesim'] = object.original_checksum
-        solr_doc['alpha_channels_ssi']      = object.try(:alpha_channels)
+        solr_doc['alpha_channels_ssi']      = object.alpha_channels
         solr_doc['original_file_id_ssi']    = original_file_id
       end
     end
 
     private
 
-      def digest_from_content
-        return unless object.original_file
-        object.original_file.digest.first.to_s
-      end
+    def digest_from_content
+      return unless object.original_file
+      object.original_file.digest.first.to_s
+    end
 
-      def original_file_id
-        return unless object.original_file
-        if object.original_file.versions.present?
-          ActiveFedora::File.uri_to_id(object.current_content_version_uri)
-        else
-          object.original_file.id
-        end
-      end
+    def original_file_id
+      return unless object.original_file
+      Hyrax::VersioningService.versioned_file_id object.original_file
+    end
 
-      def file_format
-        if object.mime_type.present? && object.format_label.present?
-          "#{object.mime_type.split('/').last} (#{object.format_label.join(', ')})"
-        elsif object.mime_type.present?
-          object.mime_type.split('/').last
-        elsif object.format_label.present?
-          object.format_label
-        end
+    def file_format
+      if object.mime_type.present? && object.format_label.present?
+        "#{object.mime_type.split('/').last} (#{object.format_label.join(', ')})"
+      elsif object.mime_type.present?
+        object.mime_type.split('/').last
+      elsif object.format_label.present?
+        object.format_label
       end
+    end
   end
 end

data/app/indexers/hyrax/indexes_workflow.rb

@@ -1,9 +1,8 @@
+# frozen_string_literal: true
 module Hyrax
   module IndexesWorkflow
-    STORED_BOOL = Solrizer::Descriptor.new(:boolean, :stored, :indexed)
-
     mattr_accessor :suppressed_field, instance_writer: false do
-      Solrizer.solr_name('suppressed', STORED_BOOL)
+      "suppressed_bsi"
     end
 
     # Adds thumbnail indexing to the solr document
@@ -23,19 +22,19 @@ module Hyrax
     # Write the workflow roles and state so one can see where the document moves to next
     # @param [Hash] solr_document the solr document to add the field to
     def index_workflow_fields(solr_document)
-      return unless object.persisted?
-      entity = PowerConverter.convert_to_sipity_entity(object)
-      return if entity.nil?
+      entity = Sipity::Entity(object)
       solr_document[workflow_role_field] = workflow_roles(entity).map { |role| "#{entity.workflow.permission_template.source_id}-#{entity.workflow.name}-#{role}" }
       solr_document[workflow_state_name_field] = entity.workflow_state.name if entity.workflow_state
+    rescue Sipity::ConversionError
+      nil
     end
 
     def workflow_state_name_field
-      @workflow_state_name_field ||= Solrizer.solr_name('workflow_state_name', :symbol)
+      "workflow_state_name_ssim"
     end
 
     def workflow_role_field
-      @workflow_role_field ||= Solrizer.solr_name('actionable_workflow_roles', :symbol)
+      "actionable_workflow_roles_ssim"
     end
 
     def workflow_roles(entity)

data/app/indexers/hyrax/permission_indexer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # Indexes `*_groups`/`*_users` style permissions. We depend on these
+  # permissions being up-to-date in the index to support `Hyrax::Ability`.
+  #
+  # @example
+  #   class MyIndexer < Hyrax::ValkyrieIndexer
+  #     include Hyrax::PermissionIndexer
+  #   end
+  module PermissionIndexer
+    def to_solr
+      super.tap do |index_document|
+        config      = Hydra.config.permissions
+        permissions = Hyrax::PermissionManager.new(resource: resource)
+
+        index_document[config.edit.group] = permissions.edit_groups.to_a
+        index_document[config.edit.individual] = permissions.edit_users.to_a
+        index_document[config.read.group] = permissions.read_groups.to_a
+        index_document[config.read.individual] = permissions.read_users.to_a
+      end
+    end
+  end
+end

data/app/indexers/hyrax/repository_reindexer.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'active_fedora/base'
 require 'active_fedora/version'
 

data/app/indexers/hyrax/resource_indexer.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # Indexes properties common to Hyrax::Resource types
+  module ResourceIndexer
+    def to_solr
+      super.tap do |index_document|
+        index_document[:alternate_ids_sm] = resource.alternate_ids.map(&:to_s)
+      end
+    end
+  end
+end

data/app/indexers/hyrax/valkyrie_collection_indexer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # Indexes properties common to PCDM Collections
+  class ValkyrieCollectionIndexer < Hyrax::ValkyrieIndexer
+    include Hyrax::ResourceIndexer
+    include Hyrax::PermissionIndexer
+    include Hyrax::VisibilityIndexer
+    include Hyrax::Indexer(:core_metadata)
+
+    def to_solr
+      super.tap do |index_document|
+        index_document[:generic_type_sim] = ['Collection']
+        index_document[:thumbnail_path_ss] = Hyrax::CollectionThumbnailPathService.call(resource)
+      end
+    end
+  end
+end

data/app/indexers/hyrax/valkyrie_indexer.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # @api public
+  #
+  # Transforms {Valkyrie::Resource} models to solr-ready key-value hashes. Use
+  # `#to_solr` to retrieve the indexable hash.
+  #
+  # The default {Hyrax::ValkyrieIndexer} implementation provides minimal
+  # indexing for the Valkyrie id and the reserved `#created_at` and
+  # `#updated_at` attributes.
+  #
+  # Custom indexers inheriting from others are responsible for providing a full
+  # index hash. A common pattern for doing this is to employ method composition
+  # to retrieve the parent's data, then modify it:
+  # `def to_solr; super.tap { |index_document| transform(index_document) }; end`.
+  # This technique creates infinitely composible index building behavior, with
+  # indexers that can always see the state of the resource and the full current
+  # index document.
+  #
+  # It's recommended to *never* modify the state of `resource` in an indexer.
+  #
+  # @example defining a custom indexer with composition
+  #   class MyIndexer < ValkyrieIndexer
+  #     def to_solr
+  #       super.tap do |index_document|
+  #         index_document[:my_field_tesim]   = resource.my_field.map(&:to_s)
+  #         index_document[:other_field_ssim] = resource.other_field
+  #       end
+  #     end
+  #   end
+  #
+  # @example pairing an indexer with a model class
+  #   class Book < Hyrax::Resource
+  #     attribute :author
+  #   end
+  #
+  #   # match by name "#{model_class}Indexer"
+  #   class BookIndexer < ValkyrieIndexer
+  #     def to_solr
+  #       super.tap do |index_document|
+  #         index_document[:author_si] = resource.author
+  #       end
+  #     end
+  #   end
+  #
+  #   ValkyrieIndexer.for(resource: Book.new) # => #<BookIndexer:0x0000563715a9f1f8 ...>
+  #
+  # @see Valkyrie::Indexing::Solr::IndexingAdapter
+  class ValkyrieIndexer
+    ##
+    # @!attribute [r] resource
+    #   @api public
+    #   @return [Valkyrie::Resource]
+    attr_reader :resource
+
+    ##
+    # @api public
+    # @param [Valkyrie::Resource] resource
+    #
+    # @return [#to_solr]
+    def self.for(resource:)
+      indexer_class = "#{resource.class}Indexer".safe_constantize || ValkyrieIndexer
+
+      indexer_class.new(resource: resource)
+    end
+
+    ##
+    # @api private
+    # @param [Valkyrie::Resource] resource
+    def initialize(resource:)
+      @resource = resource
+    end
+
+    ##
+    # @api public
+    # @return [Hash<Symbol, Object>]
+    def to_solr
+      {
+        "id": resource.id.to_s,
+        "created_at_dtsi": resource.created_at,
+        "updated_at_dtsi": resource.updated_at
+      }
+    end
+  end
+end

data/app/indexers/hyrax/valkyrie_work_indexer.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # Indexes Hyrax::Work objects
+  class ValkyrieWorkIndexer < Hyrax::ValkyrieIndexer
+    include Hyrax::ResourceIndexer
+    include Hyrax::PermissionIndexer
+    include Hyrax::VisibilityIndexer
+    include Hyrax::Indexer(:core_metadata)
+  end
+end

data/app/indexers/hyrax/visibility_indexer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # Indexes visibility of the resource; Blacklight depends on visibility being
+  # present in the index to determine visibility of results and object show
+  # views.
+  #
+  # @example
+  #   class MyIndexer < Hyrax::ValkyrieIndexer
+  #     include Hyrax::VisibilityIndexer
+  #   end
+  module VisibilityIndexer
+    def to_solr
+      super.tap do |index_document|
+        index_document[:visibility_ssi] = visibility_reader.read
+      end
+    end
+
+    private
+
+    def visibility_reader
+      Hyrax::VisibilityReader.new(resource: resource)
+    end
+  end
+end

data/app/indexers/hyrax/work_indexer.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Hyrax
   class WorkIndexer < ActiveFedora::IndexingService
     include Hyrax::IndexesThumbnails
@@ -9,7 +10,7 @@ module Hyrax
         solr_doc['member_ids_ssim'] = object.member_ids
         solr_doc['member_of_collections_ssim']    = object.member_of_collections.map(&:first_title)
         solr_doc['member_of_collection_ids_ssim'] = object.member_of_collections.map(&:id)
-        Solrizer.set_field(solr_doc, 'generic_type', 'Work', :facetable)
+        solr_doc['generic_type_sim'] = ['Work']
 
         # This enables us to return a Work when we have a FileSet that matches
         # the search query.  While at the same time allowing us not to return Collections

data/app/inputs/controlled_vocabulary_input.rb

@@ -9,79 +9,79 @@ class ControlledVocabularyInput < MultiValueInput
 
   private
 
-    def build_field(value, index)
-      options = input_html_options.dup
-      value = value.resource if value.is_a? ActiveFedora::Base
+  def build_field(value, index)
+    options = input_html_options.dup
+    value = value.resource if value.is_a? ActiveFedora::Base
 
-      build_options(value, index, options) if value.respond_to?(:rdf_label)
-      options[:required] = nil if @rendered_first_element
-      options[:class] ||= []
-      options[:class] += ["#{input_dom_id} form-control multi-text-field"]
-      options[:'aria-labelledby'] = label_id
-      @rendered_first_element = true
-      text_field(options) + hidden_id_field(value, index) + destroy_widget(attribute_name, index)
-    end
+    build_options(value, index, options) if value.respond_to?(:rdf_label)
+    options[:required] = nil if @rendered_first_element
+    options[:class] ||= []
+    options[:class] += ["#{input_dom_id} form-control multi-text-field"]
+    options[:'aria-labelledby'] = label_id
+    @rendered_first_element = true
+    text_field(options) + hidden_id_field(value, index) + destroy_widget(attribute_name, index)
+  end
 
-    def text_field(options)
-      if options.delete(:type) == 'textarea'
-        @builder.text_area(attribute_name, options)
-      else
-        @builder.text_field(attribute_name, options)
-      end
+  def text_field(options)
+    if options.delete(:type) == 'textarea'
+      @builder.text_area(attribute_name, options)
+    else
+      @builder.text_field(attribute_name, options)
     end
+  end
 
-    def id_for_hidden_label(index)
-      id_for(attribute_name, index, 'hidden_label')
-    end
+  def id_for_hidden_label(index)
+    id_for(attribute_name, index, 'hidden_label')
+  end
 
-    def destroy_widget(attribute_name, index)
-      @builder.hidden_field(attribute_name,
-                            name: name_for(attribute_name, index, '_destroy'),
-                            id: id_for(attribute_name, index, '_destroy'),
-                            value: '', data: { destroy: true })
-    end
+  def destroy_widget(attribute_name, index)
+    @builder.hidden_field(attribute_name,
+                          name: name_for(attribute_name, index, '_destroy'),
+                          id: id_for(attribute_name, index, '_destroy'),
+                          value: '', data: { destroy: true })
+  end
 
-    def hidden_id_field(value, index)
-      name = name_for(attribute_name, index, 'id')
-      id = id_for(attribute_name, index, 'id')
-      hidden_value = value.node? ? '' : value.rdf_subject
-      @builder.hidden_field(attribute_name, name: name, id: id, value: hidden_value, data: { id: 'remote' })
-    end
+  def hidden_id_field(value, index)
+    name = name_for(attribute_name, index, 'id')
+    id = id_for(attribute_name, index, 'id')
+    hidden_value = value.node? ? '' : value.rdf_subject
+    @builder.hidden_field(attribute_name, name: name, id: id, value: hidden_value, data: { id: 'remote' })
+  end
 
-    def build_options(value, index, options)
-      options[:name] = name_for(attribute_name, index, 'hidden_label')
-      options[:data] ||= {}
-      options[:data][:attribute] = attribute_name
-      options[:id] = id_for_hidden_label(index)
-      if value.node?
-        build_options_for_new_row(attribute_name, index, options)
-      else
-        build_options_for_existing_row(attribute_name, index, value, options)
-      end
+  def build_options(value, index, options)
+    options[:name] = name_for(attribute_name, index, 'hidden_label')
+    options[:data] ||= {}
+    options[:data][:attribute] = attribute_name
+    options[:id] = id_for_hidden_label(index)
+    if value.node?
+      build_options_for_new_row(attribute_name, index, options)
+    else
+      build_options_for_existing_row(attribute_name, index, value, options)
     end
+  end
 
-    def build_options_for_new_row(_attribute_name, _index, options)
-      options[:value] = ''
-    end
+  def build_options_for_new_row(_attribute_name, _index, options)
+    options[:value] = ''
+  end
 
-    def build_options_for_existing_row(_attribute_name, _index, value, options)
-      options[:value] = value.rdf_label.first || "Unable to fetch label for #{value.rdf_subject}"
-      options[:readonly] = true
-    end
+  def build_options_for_existing_row(_attribute_name, _index, value, options)
+    options[:value] = value.rdf_label.first || "Unable to fetch label for #{value.rdf_subject}"
+    options[:readonly] = true
+  end
 
-    def name_for(attribute_name, index, field)
-      "#{@builder.object_name}[#{attribute_name}_attributes][#{index}][#{field}]"
-    end
+  def name_for(attribute_name, index, field)
+    "#{@builder.object_name}[#{attribute_name}_attributes][#{index}][#{field}]"
+  end
 
-    def id_for(attribute_name, index, field)
-      [@builder.object_name, "#{attribute_name}_attributes", index, field].join('_')
-    end
+  def id_for(attribute_name, index, field)
+    [@builder.object_name, "#{attribute_name}_attributes", index, field].join('_')
+  end
 
-    def collection
-      @collection ||= begin
-                        val = object[attribute_name]
-                        col = val.respond_to?(:to_ary) ? val.to_ary : val
-                        col.reject { |value| value.to_s.strip.blank? }
-                      end
-    end
+  def collection
+    @collection ||= begin
+                      val = object[attribute_name]
+                      col = val.respond_to?(:to_ary) ? val.to_ary : val
+                      col.reject { |value| value.to_s.strip.blank? }
+                    end
+  end
 end