europeana-blacklight 0.1.0

data/lib/europeana/blacklight/document/more_like_this.rb

@@ -0,0 +1,51 @@
+module Europeana
+  module Blacklight
+    class Document
+      ##
+      # Methods for obtaining "more like this" documents
+      module MoreLikeThis
+        # @param [String] param Name of API parameter to restrict query to
+        # @return [String]
+        def more_like_this_query(param = nil)
+          queries = more_like_this_field_queries(param)
+          return nil unless queries.size > 0
+          field_queries = queries.join(' OR ')
+          "(#{field_queries}) NOT europeana_id:\"#{self.id}\""
+        end
+
+        protected
+
+        def more_like_this_logic
+          [
+            { param: 'title', fields: 'title', boost: 0.3 },
+            { param: 'who', fields: 'proxies.dcCreator', boost: 0.5 },
+            { param: 'DATA_PROVIDER', fields: 'aggregations.edmDataProvider', boost: 0.2 },
+            { param: 'what', fields: ['proxies.dcType', 'proxies.dcSubject', 'concepts.about'], boost: 0.8 },
+          ]
+        end
+
+        def more_like_this_field_terms(*fields)
+          fields.flatten.map do |field|
+            fetch(field, []).compact
+          end.flatten
+        end
+
+        def more_like_this_field_queries(param = nil)
+          logic = more_like_this_logic.select do |component|
+            param.nil? || component[:param] == param
+          end
+          logic.map do |component|
+            field_terms = more_like_this_field_terms(component[:fields])
+            more_like_this_param_query(component[:param], field_terms, component[:boost])
+          end.compact
+        end
+
+        def more_like_this_param_query(param, terms, boost)
+          return nil unless terms.present?
+          or_terms = terms.map { |v| '"' + v + '"' }.join(' OR ')
+          "#{param}: (#{or_terms})^#{boost}"
+        end
+      end
+    end
+  end
+end

data/lib/europeana/blacklight/document/relations.rb

@@ -0,0 +1,88 @@
+require 'active_support/core_ext/hash'
+
+module Europeana
+  module Blacklight
+    class Document
+      ##
+      # Methods for working with relations between objects in Europeana documents
+      module Relations
+        attr_reader :relations
+
+        def fetch_through_relation(key, *default)
+          field = nested_field_key(key)
+          container = nested_field_container(key)
+          value = [container].flatten.compact.collect do |target|
+            target.fetch(field, *default)
+          end.compact.flatten
+        end
+
+        def extract_relations(source_doc)
+          fields = source_doc.except(relation_keys)
+
+          relations = HashWithIndifferentAccess.new
+
+          relation_keys.each do |k|
+            if source_doc.key?(k)
+              if source_doc[k].is_a?(Hash)
+                relations[k] = self.class.new(source_doc[k], nil)
+              elsif source_doc[k].is_a?(Array)
+                relations[k] = source_doc[k].map { |v| self.class.new(v, nil) }
+              else
+                fail StandardError,
+                     'Relations should be a collection of objects.'
+              end
+            end
+          end
+
+          [fields, relations]
+        end
+
+        def field_in_relation?(field)
+          keys = split_edm_key(field)
+          (keys.size > 1) && relations.key?(keys.first)
+        end
+
+        def nested_field_key(field)
+          split_edm_key(field).last
+        end
+
+        def nested_field_container(field)
+          container = self
+          if field_in_relation?(field)
+            keys = split_edm_key(field)
+            field = keys.last
+            keys[0..-2].each do |relation_key|
+              container = [container].flatten.collect { |d| d.send(relation_key.to_sym) }
+            end
+          end
+          container
+        end
+
+        def method_missing(m, *args, &b)
+          if has_relation?(m)
+            relations[m.to_s]
+          elsif relation_keys.include?(m)
+            []
+          else
+            super
+          end
+        end
+
+        def has_relation?(name)
+          relations.key?(name.to_s)
+        end
+
+        protected
+
+        def split_edm_key(key)
+          key.to_s.split('.')
+        end
+
+        def relation_keys
+          [:agents, :aggregations, :concepts, :europeanaAggregation, :places,
+           :providedCHOs, :proxies, :timespans, :webResources]
+         end
+      end
+    end
+  end
+end

data/lib/europeana/blacklight/document_presenter.rb

@@ -0,0 +1,36 @@
+module Europeana
+  module Blacklight
+    ##
+    # Blacklight document presenter for Europeana documents
+    class DocumentPresenter < ::Blacklight::DocumentPresenter
+      include ActionView::Helpers::AssetTagHelper
+
+      def render_document_show_field_value(field, options = {})
+        render_nested_field_value(field, :show, options)
+      end
+
+      def render_index_field_value(field, options = {})
+        render_nested_field_value(field, :index, options)
+      end
+
+      def render_nested_field_value(field, context, options = {})
+        key = @document.nested_field_key(field)
+        container = @document.nested_field_container(field)
+
+        field_config = @configuration.send(:"#{context}_fields")[key]
+        value = options[:value] || begin
+          [container].flatten.compact.collect do |target|
+            presenter = self.class.new(target, @controller, @configuration)
+            presenter.get_field_values(key, field_config, options)
+          end.compact.flatten
+        end
+
+        render_field_value(value, field_config)
+      end
+
+      def get_field_values(field, field_config, options = {})
+        Document.localize_lang_map(super)
+      end
+    end
+  end
+end

data/lib/europeana/blacklight/facet_paginator.rb

@@ -0,0 +1,8 @@
+module Europeana
+  module Blacklight
+    ##
+    # Facet paginator for Europeana API
+    class FacetPaginator < Blacklight::FacetPaginator
+    end
+  end
+end

data/lib/europeana/blacklight/response.rb

@@ -0,0 +1,91 @@
+module Europeana
+  module Blacklight
+    ##
+    # Europeana API response for BL
+    class Response < HashWithIndifferentAccess
+      require 'europeana/blacklight/response/pagination'
+      require 'europeana/blacklight/response/facets'
+      require 'europeana/blacklight/response/more_like_this'
+
+      include Pagination
+      include Facets
+      include MoreLikeThis
+
+      attr_reader :request_params
+      attr_accessor :document_model, :blacklight_config
+
+      def initialize(data, request_params, options = {})
+        super(force_to_utf8(data))
+        @request_params = request_params
+        self.document_model = options[:document_model] || Document
+        self.blacklight_config = options[:blacklight_config]
+      end
+
+      def update(other_hash)
+        other_hash.each_pair { |key, value| self[key] = value }
+        self
+      end
+
+      def params
+        self['params'] ? self['params'] : request_params
+      end
+
+      def rows
+        params[:rows].to_i
+      end
+
+      def sort
+        params[:sort]
+      end
+
+      def documents
+        @documents ||= (self.key?('object') ? [self['object']] : (self['items'] || [])).collect do |doc|
+          document_model.new(doc, self)
+        end
+      end
+      alias_method :docs, :documents
+
+      def grouped
+        []
+      end
+
+      def group(_key)
+        nil
+      end
+
+      def grouped?
+        false
+      end
+
+      def export_formats
+        documents.map { |x| x.export_formats.keys }.flatten.uniq
+      end
+
+      def total
+        self[:totalResults].to_s.to_i
+      end
+
+      def start
+        params[:start].to_s.to_i - 1
+      end
+
+      def empty?
+        total == 0
+      end
+
+      private
+
+      def force_to_utf8(value)
+        case value
+        when Hash
+          value.each { |k, v| value[k] = force_to_utf8(v) }
+        when Array
+          value.each { |v| force_to_utf8(v) }
+        when String
+          value.force_encoding('utf-8') if value.respond_to?(:force_encoding)
+        end
+        value
+      end
+    end
+  end
+end

data/lib/europeana/blacklight/response/facets.rb

@@ -0,0 +1,145 @@
+module Europeana
+  module Blacklight
+    class Response
+      ##
+      # Facets for {Europeana::Blacklight::Response}
+      #
+      # Based on {Blacklight::SolrResponse::Facets} v5.10.2
+      module Facets
+        require 'ostruct'
+
+        # represents a facet value; which is a field value and its hit count
+        class FacetItem < OpenStruct
+          def initialize(*args)
+            options = args.extract_options!
+
+            # Backwards-compat method signature
+            value = args.shift
+            hits = args.shift
+
+            options[:value] = value if value
+            options[:hits] = hits if hits
+
+            super(options)
+          end
+
+          def label
+            super || value
+          end
+
+          def as_json(props = nil)
+            table.as_json(props)
+          end
+        end
+
+        # represents a facet; which is a field and its values
+        class FacetField
+          attr_reader :name, :items
+
+          def initialize(name, items, options = {})
+            @name, @items = name, items
+            @options = options
+          end
+
+          def limit
+            @options[:limit] || default_limit
+          end
+
+          def offset
+            @options[:offset] || default_offset
+          end
+
+          def sort
+            # Europeana API does not support facet sorting
+            nil
+          end
+
+          private
+
+          # @see http://labs.europeana.eu/api/search/#offset-and-limit-of-facets
+          def default_limit
+            100
+          end
+
+          # @see http://labs.europeana.eu/api/search/#offset-and-limit-of-facets
+          def default_offset
+            0
+          end
+        end
+
+        def aggregations
+          @aggregations ||= {}.merge(facet_field_aggregations).merge(facet_query_aggregations)
+        end
+
+        def facet_fields
+          @facet_fields ||= self['facets'] || []
+        end
+
+        def facet_queries
+          @facet_queries ||= self['facet_queries'] || {}
+        end
+
+        private
+
+        ##
+        # Convert API's facets response into a hash of
+        # {Europeana::Blacklight::Response::Facet::FacetField} objects
+        def facet_field_aggregations
+          facet_fields.each_with_object({}) do |facet, hash|
+            facet_field_name = facet['name']
+
+            items = facet['fields'].collect do |value|
+              FacetItem.new(value: value['label'], hits: value['count'])
+            end
+
+            hash[facet_field_name] = FacetField.new(facet_field_name, items, facet_field_aggregation_options(facet_field_name))
+
+            if blacklight_config && !blacklight_config.facet_fields[facet_field_name]
+              # alias all the possible blacklight config names..
+              blacklight_config.facet_fields.select { |_k, v| v.field == facet_field_name }.each do |key, _|
+                hash[key] = hash[facet_field_name]
+              end
+            end
+          end
+        end
+
+        def facet_field_aggregation_options(name)
+          options = {}
+
+          if params[:"f.#{name}.facet.limit"]
+            options[:limit] = params[:"f.#{name}.facet.limit"].to_i
+          elsif params[:'facet.limit']
+            options[:limit] = params[:'facet.limit'].to_i
+          end
+
+          if params[:"f.#{name}.facet.offset"]
+            options[:offset] = params[:"f.#{name}.facet.offset"].to_i
+          elsif params[:'facet.offset']
+            options[:offset] = params[:'facet.offset'].to_i
+          end
+
+          options
+        end
+
+        ##
+        # Aggregate API's facet_query response into the virtual facet fields
+        # defined in the blacklight configuration
+        def facet_query_aggregations
+          return {} unless blacklight_config
+
+          blacklight_config.facet_fields.select { |_k, v| v.query }.each_with_object({}) do |(field_name, facet_field), hash|
+            salient_facet_queries = facet_field.query.map { |_k, x| x[:fq] }
+            items = []
+            facet_queries.select { |k, _v| salient_facet_queries.include?(k) }.reject { |_value, hits| hits == 0 }.map do |value, hits|
+              salient_fields = facet_field.query.select { |_k, v| v[:fq] == value }
+              key = ((salient_fields.keys if salient_fields.respond_to? :keys) || salient_fields.first).first
+              items << FacetItem.new(value: key, hits: hits, label: facet_field.query[key][:label])
+            end
+
+            hash[field_name] = FacetField.new(field_name, items)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/europeana/blacklight/response/more_like_this.rb

@@ -0,0 +1,19 @@
+module Europeana
+  module Blacklight
+    class Response
+      ##
+      # MLT for{Europeana::Blacklight::Response}
+      #
+      # This will just return blank objects from the MLT methods BL expects.
+      module MoreLikeThis
+        def more_like(_document)
+          []
+        end
+
+        def more_like_this
+          {}
+        end
+      end
+    end
+  end
+end