blacklight_iiif_search 0.0.1.pre.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 87d986c3e753ea4a1461f64d18602f251d9a62ec
+  data.tar.gz: e2c2ea9cab056c1ff552fff249a112f7c9dd1169
+SHA512:
+  metadata.gz: f24b9614cb7c287fa918cbaac19c6a2269e9811ab619e904eea96b4d0053297a282ddffeed3a166f208b1061889a7f0b9ecc14b50f0a24cde41560fdbc000020
+  data.tar.gz: 667a16c8dda27c737bd29cc54d7a92cdf0226fc1b0c3b533ee46e97561ff5477e571561ca164ca16ddacde376f9605f9f4f47c26d8358c5ce0257f20cb8f4b16

data/Rakefile

@@ -0,0 +1,46 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'BlacklightIiifSearch'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks
+
+Rake::Task.define_task(:environment)
+
+load 'lib/railties/blacklight_iiif_search.rake'
+
+task default: :ci
+
+require 'engine_cart/rake_task'
+
+require 'solr_wrapper'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new(:rubocop)
+
+desc 'Run test suite'
+task ci: ['engine_cart:generate'] do # TODO: add rubocop
+  SolrWrapper.wrap do |solr|
+    FileUtils.cp File.join(__dir__, 'lib', 'generators', 'blacklight_iiif_search', 'templates', 'solr', 'lib', 'solr-tokenizing_suggester-7.x.jar'),
+                 File.join(solr.instance_dir, 'contrib')
+    solr.with_collection do
+      within_test_app do
+        system 'RAILS_ENV=test rake blacklight_iiif_search:index:seed'
+      end
+      Rake::Task['spec'].invoke
+    end
+  end
+end

data/app/controllers/concerns/blacklight_iiif_search/controller.rb

@@ -0,0 +1,48 @@
+# return a IIIF Content Search response
+module BlacklightIiifSearch
+  module Controller
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :set_search_builder, only: [:iiif_search]
+      after_action :set_access_headers, only: %i[iiif_search iiif_suggest]
+    end
+
+    def iiif_search
+      _parent_response, @parent_document = fetch(params[:solr_document_id])
+      iiif_search = IiifSearch.new(iiif_search_params, iiif_search_config,
+                                   @parent_document)
+      @response, _document_list = search_results(iiif_search.solr_params)
+      iiif_search_response = IiifSearchResponse.new(@response,
+                                                    @parent_document,
+                                                    self)
+      render json: iiif_search_response.annotation_list,
+             content_type: 'application/json'
+    end
+
+    def iiif_suggest
+      suggest_search = IiifSuggestSearch.new(params, repository, self)
+      render json: suggest_search.response,
+             content_type: 'application/json'
+    end
+
+    def iiif_search_config
+      blacklight_config.iiif_search || {}
+    end
+
+    def iiif_search_params
+      params.permit(:q, :motivation, :date, :user, :solr_document_id, :page)
+    end
+
+    private
+
+    def set_search_builder
+      blacklight_config.search_builder_class = IiifSearchBuilder
+    end
+
+    # allow apps to load JSON received from a remote server
+    def set_access_headers
+      response.headers['Access-Control-Allow-Origin'] = '*'
+    end
+  end
+end

data/app/models/blacklight_iiif_search/iiif_search.rb

@@ -0,0 +1,36 @@
+# IiifSearch
+module BlacklightIiifSearch
+  class IiifSearch
+    include BlacklightIiifSearch::SearchBehavior
+
+    attr_reader :id, :iiif_config, :parent_document, :q, :page, :rows
+
+    ##
+    # @param [Hash] params
+    # @param [Hash] iiif_search_config
+    # @param [SolrDocument] parent_document
+    def initialize(params, iiif_search_config, parent_document)
+      @id = params[:solr_document_id]
+      @iiif_config = iiif_search_config
+      @parent_document = parent_document
+      @q = params[:q]
+      @page = params[:page]
+      @rows = 50
+
+      # NOT IMPLEMENTED YET
+      # @motivation = params[:motivation]
+      # @date = params[:date]
+      # @user = params[:user]
+    end
+
+    ##
+    # return a hash of Solr search params
+    # if q is not supplied, have to pass some dummy params
+    # or else all records matching object_relation_solr_params are returned
+    # @return [Hash]
+    def solr_params
+      return { q: 'nil:nil' } unless q
+      { q: q, f: object_relation_solr_params, rows: rows, page: page }
+    end
+  end
+end

data/app/models/blacklight_iiif_search/iiif_search_annotation.rb

@@ -0,0 +1,43 @@
+# corresponds to IIIF Annotation resource
+module BlacklightIiifSearch
+  class IiifSearchAnnotation
+    include IIIF::Presentation
+    include BlacklightIiifSearch::AnnotationBehavior
+
+    attr_reader :document, :query, :hl_index, :snippet, :controller,
+                :parent_document
+
+    ##
+    # @param [SolrDocument] document
+    # @param [String] query
+    # @param [Integer] hl_index
+    # @param [String] snippet
+    # @param [CatalogController] controller
+    # @param [SolrDocument] parent_document
+    def initialize(document, query, hl_index, snippet, controller, parent_document)
+      @document = document
+      @query = query
+      @hl_index = hl_index
+      @snippet = snippet
+      @controller = controller
+      @parent_document = parent_document
+    end
+
+    ##
+    # @return [IIIF::Presentation::Annotation]
+    def as_hash
+      annotation = IIIF::Presentation::Annotation.new('@id' => annotation_id)
+      annotation.resource = text_resource_for_annotation if snippet
+      annotation['on'] = canvas_uri_for_annotation
+      annotation
+    end
+
+    ##
+    # @return [IIIF::Presentation::Resource]
+    def text_resource_for_annotation
+      clean_snippet = ActionView::Base.full_sanitizer.sanitize(snippet)
+      IIIF::Presentation::Resource.new('@type' => 'cnt:ContentAsText',
+                                       'chars' => clean_snippet)
+    end
+  end
+end

data/app/models/blacklight_iiif_search/iiif_search_response.rb

@@ -0,0 +1,103 @@
+# corresponds to a IIIF Annotation List
+module BlacklightIiifSearch
+  class IiifSearchResponse
+    include BlacklightIiifSearch::Ignored
+
+    attr_reader :solr_response, :controller, :iiif_config
+
+    ##
+    # @param [Blacklight::Solr::Response] solr_response
+    # @param [SolrDocument] parent_document
+    # @param [CatalogController] controller
+    def initialize(solr_response, parent_document, controller)
+      @solr_response = solr_response
+      @parent_document = parent_document
+      @controller = controller
+      @iiif_config = controller.iiif_search_config
+      @resources = []
+      @hits = []
+    end
+
+    ##
+    # constructs the IIIF::Presentation::AnnotationList
+    # @return [IIIF::OrderedHash]
+    def annotation_list
+      list_id = controller.request.original_url
+      anno_list = IIIF::Presentation::AnnotationList.new('@id' => list_id)
+      anno_list['@context'] = %w[
+        http://iiif.io/api/presentation/2/context.json
+        http://iiif.io/api/search/1/context.json
+      ]
+      anno_list['resources'] = resources
+      anno_list['hits'] = @hits
+      anno_list['within'] = within
+      anno_list['prev'] = paged_url(solr_response.prev_page) if solr_response.prev_page
+      anno_list['next'] = paged_url(solr_response.next_page) if solr_response.next_page
+      anno_list['startIndex'] = 0 unless solr_response.total_pages > 1
+      anno_list.to_ordered_hash(force: true, include_context: false)
+    end
+
+    ##
+    # Return an array of IiifSearchAnnotation objects
+    # @return [Array]
+    def resources
+      @total = 0
+      solr_response['highlighting'].each do |id, hl_hash|
+        hit = { '@type': 'search:Hit', 'annotations': [] }
+        document = solr_response.documents.select { |v| v[:id] == id }.first
+        if hl_hash.empty?
+          @total += 1
+          annotation = IiifSearchAnnotation.new(document,
+                                                solr_response.params['q'],
+                                                0, nil, controller,
+                                                @parent_document)
+          @resources << annotation.as_hash
+          hit[:annotations] << annotation.annotation_id
+        else
+          hl_hash.each_value do |hl_array|
+            hl_array.each_with_index do |hl, hl_index|
+              @total += 1
+              annotation = IiifSearchAnnotation.new(document,
+                                                    solr_response.params['q'],
+                                                    hl_index, hl, controller,
+                                                    @parent_document)
+              @resources << annotation.as_hash
+              hit[:annotations] << annotation.annotation_id
+            end
+          end
+        end
+        @hits << hit
+      end
+      @resources
+    end
+
+    ##
+    # @return [IIIF::Presentation::Layer]
+    def within
+      within_hash = IIIF::Presentation::Layer.new
+      within_hash['ignored'] = ignored
+      if solr_response.total_pages > 1
+        within_hash['first'] = paged_url(1)
+        within_hash['last'] = paged_url(solr_response.total_pages)
+      else
+        within_hash['total'] = @total
+      end
+      within_hash
+    end
+
+    ##
+    # create a URL for the previous/next page of results
+    # @return [String]
+    def paged_url(page_index)
+      controller.solr_document_iiif_search_url(clean_params.merge(page: page_index))
+    end
+
+    ##
+    # remove ignored or irrelevant params from the params hash
+    # @return [ActionController::Parameters]
+    def clean_params
+      remove = ignored.map(&:to_sym)
+      controller.iiif_search_params.except(*%i[page solr_document_id] + remove)
+    end
+  end
+end

data/app/models/blacklight_iiif_search/iiif_suggest_response.rb

@@ -0,0 +1,56 @@
+# corresponds to a IIIF search:TermList
+module BlacklightIiifSearch
+  class IiifSuggestResponse
+    include BlacklightIiifSearch::Ignored
+
+    attr_reader :solr_response, :query, :document_id, :controller, :iiif_config
+
+    ##
+    # @param [Blacklight::Solr::Response] solr_response
+    # @param [Hash] params
+    # @param [CatalogController] controller
+    def initialize(solr_response, params, controller)
+      @solr_response = solr_response
+      @query = params[:q]
+      @document_id = params[:solr_document_id]
+      @controller = controller
+      @iiif_config = controller.iiif_search_config
+    end
+
+    ##
+    # Constructs the termList as IIIF::Presentation::Resource
+    # @return [IIIF::OrderedHash]
+    def term_list
+      list_id = controller.request.original_url
+      term_list = IIIF::Presentation::Resource.new('@id' => list_id)
+      term_list['@context'] = 'http://iiif.io/api/search/1/context.json'
+      term_list['@type'] = 'search:TermList'
+      term_list['terms'] = terms
+      term_list['ignored'] = ignored
+      term_list.to_ordered_hash(force: true, include_context: false)
+    end
+
+    ##
+    # Turn solr_response into array of hashes
+    # 'try' chain pattern copied from Blacklight::Suggest::Response#suggestions
+    # @return [Array]
+    def terms
+      terms_for_list = []
+      terms_array = solr_response.try(:[], 'suggest').try(:[], iiif_config[:suggester_name]).try(:[], query).try(:[], 'suggestions') || []
+      terms = terms_array.map { |v| v['term'] }
+      terms.sort.each do |term|
+        term_hash = { match: term, url: iiif_search_url(term) }
+        terms_for_list << term_hash
+      end
+      terms_for_list
+    end
+
+    ##
+    # Create a URL corresponding to a IIIF Content Search request for the term
+    # @param [String] term
+    # @return [String]
+    def iiif_search_url(term)
+      controller.solr_document_iiif_search_url(document_id, q: term)
+    end
+  end
+end

data/app/models/blacklight_iiif_search/iiif_suggest_search.rb

@@ -0,0 +1,37 @@
+# IiifSuggestSearch
+module BlacklightIiifSearch
+  class IiifSuggestSearch
+    attr_reader :params, :query, :document_id, :iiif_config, :repository,
+                :controller
+
+    ##
+    # @param [Hash] params
+    # @param [Blacklight::AbstractRepository] repository
+    # @param [CatalogController] controller
+    def initialize(params, repository, controller)
+      @params = params
+      @query = params[:q]
+      @document_id = params[:solr_document_id]
+      @iiif_config = controller.iiif_search_config
+      @repository = repository
+      @controller = controller
+    end
+
+    ##
+    # Return the termList response
+    # @return [IIIF::OrderedHash]
+    def response
+      response = IiifSuggestResponse.new(suggest_results, params, controller)
+      response.term_list
+    end
+
+    ##
+    # Query the suggest handler
+    # @return [RSolr::HashWithResponse]
+    def suggest_results
+      suggest_params = { q: query, :'suggest.cfq' => document_id }
+      repository.connection.send_and_receive(iiif_config[:autocomplete_handler],
+                                             params: suggest_params)
+    end
+  end
+end

data/app/models/concerns/blacklight_iiif_search/annotation_behavior.rb

@@ -0,0 +1,28 @@
+# customizable behavior for IiifSearchAnnotation
+module BlacklightIiifSearch
+  module AnnotationBehavior
+    ##
+    # Create a URL for the annotation
+    # @return [String]
+    def annotation_id
+      "#{controller.solr_document_url(parent_document[:id])}/canvas/#{document[:id]}/annotation/#{hl_index}"
+    end
+
+    ##
+    # Create a URL for the canvas that the annotation refers to
+    # @return [String]
+    def canvas_uri_for_annotation
+      "#{controller.solr_document_url(parent_document[:id])}/canvas/#{document[:id]}" + coordinates
+    end
+
+    ##
+    # return a string like "#xywh=100,100,250,20"
+    # corresponding to coordinates of query term on image
+    # local implementation expected, value returned below is just a placeholder
+    # @return [String]
+    def coordinates
+      return '' unless query
+      '#xywh=0,0,0,0'
+    end
+  end
+end

data/app/models/concerns/blacklight_iiif_search/ignored.rb

@@ -0,0 +1,13 @@
+# returns ignored params
+module BlacklightIiifSearch
+  module Ignored
+    ##
+    # Return an array of ignored params
+    # @return [Array]
+    def ignored
+      relevant_keys = controller.iiif_search_params.keys
+      relevant_keys.delete('solr_document_id')
+      relevant_keys - iiif_config[:supported_params]
+    end
+  end
+end

data/app/models/concerns/blacklight_iiif_search/search_behavior.rb

@@ -0,0 +1,15 @@
+# customizable behavior for IiifSearch
+module BlacklightIiifSearch
+  module SearchBehavior
+    ##
+    # params to limit the search to items that have some relationship
+    # with the parent object (e.g. pages)
+    # for ex., return a {key: value} hash where:
+    # key:   solr field for image/file to object relationship
+    # value: identifier of parent
+    # @return [Hash]
+    def object_relation_solr_params
+      { iiif_config[:object_relation_field] => id }
+    end
+  end
+end