blacklight 6.25.0 → 7.0.0.rc1

data/app/{assets/javascripts/blacklight/ajax_modal.js → javascript/blacklight/modal.js}

@@ -1,27 +1,27 @@
 //= require blacklight/core
 
 /*
-  The ajax_modal plugin can display some interactions inside a Bootstrap
+  The blacklight modal plugin can display some interactions inside a Bootstrap
   modal window, including some multi-page interactions.
 
   It supports unobtrusive Javascript, where a link or form that would have caused
   a new page load is changed to display it's results inside a modal dialog,
   by this plugin.  The plugin assumes there is a Bootstrap modal div
-  on the page with id #ajax-modal to use as the modal -- the standard Blacklight
+  on the page with id #blacklight-modal to use as the modal -- the standard Blacklight
   layout provides this.
 
   To make a link or form have their results display inside a modal, add
-  `data-ajax-modal="trigger"` to the link or form. (Note, form itself not submit input)
+  `data-blacklight-modal="trigger"` to the link or form. (Note, form itself not submit input)
   With Rails link_to helper, you'd do that like:
 
-      link_to something, link, :data => {:ajax_modal => "trigger"}
+      link_to something, link, data: { blacklight_modal: "trigger" }
 
   The results of the link href or form submit will be displayed inside
   a modal -- they should include the proper HTML markup for a bootstrap modal's
   contents. Also, you ordinarily won't want the Rails template with wrapping
   navigational elements to be used.  The Rails controller could suppress
   the layout when a JS AJAX request is detected, OR the response
-  can include a `<div data-ajax-modal="container">` -- only the contents
+  can include a `<div data-blacklight-modal="container">` -- only the contents
   of the container will be placed inside the modal, the rest of the
   page will be ignored.
 
@@ -33,12 +33,12 @@
 
   Link or forms inside the modal will ordinarily cause page loads
   when they are triggered. However, if you'd like their results
-  to stay within the modal, just add `data-ajax-modal="preserve"`
+  to stay within the modal, just add `data-blacklight-modal="preserve"`
   to the link or form.
 
   Here's an example of what might be returned, demonstrating most of the devices available:
 
-    <div data-ajax-modal="container">
+    <div data-blacklight-modal="container">
       <div class="modal-header">
         <button type="button" class="close" data-dismiss="modal" aria-hidden="true">×</button>
         <h3 class="modal-title">Request Placed</h3>
@@ -46,47 +46,46 @@
 
       <div class="modal-body">
         <p>Some message</p>
-        <%= link_to "This result will still be within modal", some_link, :data => {:ajax_modal => "preserve"} %>
+        <%= link_to "This result will still be within modal", some_link, data: { blacklight: "preserve" } %>
       </div>
 
 
       <div class="modal-footer">
-        <%= link_to "Close the modal", request_done_path, :class => "submit button dialog-close", :data => {:dismiss => "modal"} %>
+        <%= link_to "Close the modal", request_done_path, class: "submit button dialog-close", data: { dismiss: "modal" } %>
       </div>
     </div>
 
 
   One additional feature. If the content returned from the AJAX modal load
-  has an element with `data-ajax-modal=close`, that will trigger the modal
+  has an element with `data-blacklight-modal=close`, that will trigger the modal
   to be closed. And if this element includes a node with class "flash_messages",
   the flash-messages node will be added to the main page inside #main-flahses.
 
   == Events
 
-  We'll send out an event 'loaded.blacklight.ajax-modal' with the #ajax-modal
+  We'll send out an event 'loaded.blacklight.blacklight-modal' with the #blacklight-modal
   dialog as the target, right after content is loaded into the modal but before
   it is shown (if not already a shown modal).  In an event handler, you can
   inspect loaded content by looking inside $(this).  If you call event.preventDefault(),
   we won't 'show' the dialog (although it may already have been shown, you may want to
   $(this).modal("hide") if you want to ensure hidden/closed.
 
-  The data-ajax-modal=close behavior is implemented with this event, see for example.
+  The data-blacklight-modal=close behavior is implemented with this event, see for example.
 */
 
-// We keep all our data in Blacklight.ajaxModal object.
+// We keep all our data in Blacklight.modal object.
 // Create lazily if someone else created first.
-if (Blacklight.ajaxModal === undefined) {
-  Blacklight.ajaxModal = {};
+if (Blacklight.modal === undefined) {
+  Blacklight.modal = {};
 }
 
-
 // a Bootstrap modal div that should be already on the page hidden
-Blacklight.ajaxModal.modalSelector = "#ajax-modal";
+Blacklight.modal.modalSelector = '#blacklight-modal';
 
 // Trigger selectors identify forms or hyperlinks that should open
 // inside a modal dialog.
-Blacklight.ajaxModal.triggerLinkSelector  = "a[data-ajax-modal~=trigger], a.lightboxLink,a.more_facets_link,.ajax_modal_launch";
-Blacklight.ajaxModal.triggerFormSelector  = "form[data-ajax-modal~=trigger], form.ajax_form";
+Blacklight.modal.triggerLinkSelector  = 'a[data-blacklight-modal~=trigger]';
+Blacklight.modal.triggerFormSelector  = 'form[data-blacklight-modal~=trigger]';
 
 // preserve selectors identify forms or hyperlinks that, if activated already
 // inside a modal dialog, should have destinations remain inside the modal -- but
@@ -95,57 +94,58 @@ Blacklight.ajaxModal.triggerFormSelector  = "form[data-ajax-modal~=trigger], for
 // No need to repeat selectors from trigger selectors, those will already
 // be preserved. MUST be manually prefixed with the modal selector,
 // so they only apply to things inside a modal.
-Blacklight.ajaxModal.preserveLinkSelector = Blacklight.ajaxModal.modalSelector + ' a[data-ajax-modal~=preserve]';
-Blacklight.ajaxModal.preserveFormSelector = Blacklight.ajaxModal.modalSelector + ' form[data-ajax-modal~=preserve]'
+Blacklight.modal.preserveLinkSelector = Blacklight.modal.modalSelector + ' a[data-blacklight-modal~=preserve]';
 
-Blacklight.ajaxModal.containerSelector    = "[data-ajax-modal~=container]";
+Blacklight.modal.containerSelector    = '[data-blacklight-modal~=container]';
 
-Blacklight.ajaxModal.modalCloseSelector   = "[data-ajax-modal~=close], span.ajax-close-modal";
+Blacklight.modal.modalCloseSelector   = '[data-blacklight-modal~=close]';
 
 // Called on fatal failure of ajax load, function returns content
 // to show to user in modal.  Right now called only for extreme
 // network errors.
-Blacklight.ajaxModal.onFailure = function(data) {
-  var contents =  "<div class='modal-header'>" +
-           "<button type='button' class='close' data-dismiss='modal' aria-hidden='true'>×</button>" +
-           "Network Error</div>";
-  $(Blacklight.ajaxModal.modalSelector).find('.modal-content').html(contents);
-  $(Blacklight.ajaxModal.modalSelector).modal('show');
+Blacklight.modal.onFailure = function(data) {
+  var contents =  '<div class="modal-header">' +
+            '<div class="modal-title">Network Error</div>' +
+            '<button type="button" class="blacklight-modal-close close" data-dismiss="modal" aria-label="Close">' +
+            '  <span aria-hidden="true">&times;</span>' +
+            '</button>';
+  $(Blacklight.modal.modalSelector).find('.modal-content').html(contents);
+  $(Blacklight.modal.modalSelector).modal('show');
 }
 
-Blacklight.ajaxModal.receiveAjax = function (contents) {
+Blacklight.modal.receiveAjax = function (contents) {
     // does it have a data- selector for container?
     // important we don't execute script tags, we shouldn't.
     // code modelled off of JQuery ajax.load. https://github.com/jquery/jquery/blob/master/src/ajax/load.js?source=c#L62
-    var container =  $("<div>").
-      append( jQuery.parseHTML(contents) ).find( Blacklight.ajaxModal.containerSelector ).first();
-    if (container.length !== 0) {
+    var container =  $('<div>').
+      append( jQuery.parseHTML(contents) ).find( Blacklight.modal.containerSelector ).first();
+    if (container.size() !== 0) {
       contents = container.html();
     }
 
-    $(Blacklight.ajaxModal.modalSelector).find('.modal-content').html(contents);
+    $(Blacklight.modal.modalSelector).find('.modal-content').html(contents);
 
     // send custom event with the modal dialog div as the target
-    var e    = $.Event('loaded.blacklight.ajax-modal');
-    $(Blacklight.ajaxModal.modalSelector).trigger(e);
+    var e    = $.Event('loaded.blacklight.blacklight-modal')
+    $(Blacklight.modal.modalSelector).trigger(e);
     // if they did preventDefault, don't show the dialog
     if (e.isDefaultPrevented()) return;
 
-    $(Blacklight.ajaxModal.modalSelector).modal('show');
+    $(Blacklight.modal.modalSelector).modal('show');
 };
 
 
-Blacklight.ajaxModal.modalAjaxLinkClick = function(e) {
+Blacklight.modal.modalAjaxLinkClick = function(e) {
   e.preventDefault();
 
   $.ajax({
     url: $(this).attr('href')
   })
-  .fail(Blacklight.ajaxModal.onFailure)
-  .done(Blacklight.ajaxModal.receiveAjax)
+  .fail(Blacklight.modal.onFailure)
+  .done(Blacklight.modal.receiveAjax)
 };
 
-Blacklight.ajaxModal.modalAjaxFormSubmit = function(e) {
+Blacklight.modal.modalAjaxFormSubmit = function(e) {
     e.preventDefault();
 
     $.ajax({
@@ -153,54 +153,54 @@ Blacklight.ajaxModal.modalAjaxFormSubmit = function(e) {
       data: $(this).serialize(),
       type: $(this).attr('method') // POST
     })
-    .fail(Blacklight.ajaxModal.onFailure)
-    .done(Blacklight.ajaxModal.receiveAjax)
+    .fail(Blacklight.modal.onFailure)
+    .done(Blacklight.modal.receiveAjax)
 }
 
 
 
-Blacklight.ajaxModal.setup_modal = function() {
+Blacklight.modal.setupModal = function() {
 	// Event indicating blacklight is setting up a modal link,
   // you can catch it and call e.preventDefault() to abort
   // setup.
-	var e = $.Event('setup.blacklight.ajax-modal');
-	$("body").trigger(e);
+	var e = $.Event('setup.blacklight.blacklight-modal');
+	$('body').trigger(e);
 	if (e.isDefaultPrevented()) return;
 
   // Register both trigger and preserve selectors in ONE event handler, combining
   // into one selector with a comma, so if something matches BOTH selectors, it
   // still only gets the event handler called once.
-  $("body").on("click", Blacklight.ajaxModal.triggerLinkSelector  + ", " + Blacklight.ajaxModal.preserveLinkSelector,
-    Blacklight.ajaxModal.modalAjaxLinkClick);
-  $("body").on("submit", Blacklight.ajaxModal.triggerFormSelector + ", " + Blacklight.ajaxModal.preserveFormSelector,
-    Blacklight.ajaxModal.modalAjaxFormSubmit);
+  $('body').on('click', Blacklight.modal.triggerLinkSelector + ', ' + Blacklight.modal.preserveLinkSelector,
+    Blacklight.modal.modalAjaxLinkClick);
+  $('body').on('submit', Blacklight.modal.triggerFormSelector + ', ' + Blacklight.modal.preserveFormSelector,
+    Blacklight.modal.modalAjaxFormSubmit);
 
-  // Catch our own custom loaded event to implement data-ajax-modal=closed
-  $("body").on("loaded.blacklight.ajax-modal", Blacklight.ajaxModal.check_close_ajax_modal);
+  // Catch our own custom loaded event to implement data-blacklight-modal=closed
+  $('body').on('loaded.blacklight.blacklight-modal', Blacklight.modal.checkCloseModal);
 
   // we support doing data-dismiss=modal on a <a> with a href for non-ajax
   // use, we need to suppress following the a's href that's there for
   // non-JS contexts.
-  $("body ").on("click", Blacklight.ajaxModal.modalSelector + " a[data-dismiss~=modal]", function (e) {
+  $('body').on('click', Blacklight.modal.modalSelector + ' a[data-dismiss~=modal]', function (e) {
     e.preventDefault();
   });
 };
 
-// A function used as an event handler on loaded.blacklight.ajax-modal
-// to catch contained data-ajax-modal=closed directions
-Blacklight.ajaxModal.check_close_ajax_modal = function(event) {
-  if ($(event.target).find(Blacklight.ajaxModal.modalCloseSelector).length) {
-    modal_flashes = $(this).find('.flash_messages');
+// A function used as an event handler on loaded.blacklight.blacklight-modal
+// to catch contained data-blacklight-modal=closed directions
+Blacklight.modal.checkCloseModal = function(event) {
+  if ($(event.target).find(Blacklight.modal.modalCloseSelector).length) {
+    var modalFlashes = $(this).find('.flash_messages');
 
-    $(event.target).modal("hide");
+    $(event.target).modal('hide');
     event.preventDefault();
 
-    main_flashes = $('#main-flashes');
-    main_flashes.append(modal_flashes);
-    modal_flashes.fadeIn(500);
+    var mainFlashes = $('#main-flashes');
+    mainFlashes.append(modalFlashes);
+    modalFlashes.fadeIn(500);
   }
 }
 
 Blacklight.onLoad(function() {
-  Blacklight.ajaxModal.setup_modal();
+  Blacklight.modal.setupModal();
 });

data/app/{assets/javascripts → javascript}/blacklight/search_context.js

@@ -1,12 +1,20 @@
 //= require blacklight/core
 (function($) {
-  Blacklight.do_search_context_behavior = function() {
+  Blacklight.doSearchContextBehavior = function() {
+    if (typeof Blacklight.do_search_context_behavior == 'function') {
+      console.warn("do_search_context_behavior is deprecated. Use doSearchContextBehavior instead.");
+      return Blacklight.do_search_context_behavior();
+    }
     $('a[data-context-href]').on('click.search-context', Blacklight.handleSearchContextMethod);
   };
 
   // this is the $.rails.handleMethod with a couple adjustments, described inline:
   // first, we're attaching this directly to the event handler, so we can check for meta-keys
   Blacklight.handleSearchContextMethod = function(event) {
+    if (typeof Blacklight.handle_search_context_method == 'function') {
+      console.warn("handle_search_context_method is deprecated. Use handleSearchContextMethod instead.");
+      return Blacklight.handle_search_context_method(event);
+    }
     var link = $(this);
 
     // instead of using the normal href, we need to use the context href instead
@@ -37,6 +45,6 @@
   };
 
   Blacklight.onLoad(function() {
-    Blacklight.do_search_context_behavior();
+      Blacklight.doSearchContextBehavior();
   });
 })(jQuery);

data/app/models/blacklight/facet_paginator.rb

@@ -4,7 +4,7 @@ module Blacklight
   # displayable. You have to ask Solr for limit+1, to get enough
   # results to see if 'more' are available'. That is, the all_facet_values
   # arg in constructor should be the result of asking solr for limit+1
-  # values. 
+  # values.
   # This is a workaround for the fact that Solr itself can't compute
   # the total values for a given facet field,
   # so we cannot know how many "pages" there are.
@@ -24,9 +24,9 @@ module Blacklight
     # asking solr for n+1 facet values.
     # options:
     # :limit =>  number to display per page, or (default) ?. Nil means
-    #            display all with no previous or next. 
+    #            display all with no previous or next.
     # :offset => current item offset, default 0
-    # :sort => 'count' or 'index', solr tokens for facet value sorting, default 'count'. 
+    # :sort => 'count' or 'index', solr tokens for facet value sorting, default 'count'.
     def initialize(all_facet_values, arguments = {})
       # to_s.to_i will conveniently default to 0 if nil
       @offset = arguments[:offset].to_s.to_i

data/app/models/blacklight/icon.rb

@@ -0,0 +1,53 @@
+module Blacklight
+  class Icon
+    attr_reader :icon_name
+    ##
+    # @param [String, Symbol] icon_name
+    # @param [Hash] options
+    # @param [String] classes additional classes separated by a string
+    def initialize(icon_name, classes: '')
+      @icon_name = icon_name
+      @classes = classes
+    end
+
+    ##
+    # Returns the raw source, but you could extend this to add additional attributes
+    # @return [String]
+    def svg
+      file_source
+    end
+
+    ##
+    # @return [Hash]
+    def options
+      {
+        class: classes
+      }
+    end
+
+    ##
+    # @return [String]
+    def path
+      "blacklight/#{icon_name}.svg"
+    end
+
+    ##
+    # @return [String]
+    def file_source
+      raise Blacklight::Exceptions::IconNotFound, "Could not find #{path}" if file.blank?
+      file.source.force_encoding('UTF-8')
+    end
+
+    private
+
+    def file
+      # Rails.application.assets is `nil` in production mode (where compile assets is enabled).
+      # This workaround is based off of this comment: https://github.com/fphilipe/premailer-rails/issues/145#issuecomment-225992564
+      (Rails.application.assets || ::Sprockets::Railtie.build_environment(Rails.application)).find_asset(path)
+    end
+
+    def classes
+      " blacklight-icons #{@classes} ".strip
+    end
+  end
+end

data/app/models/blacklight/solr/facet_paginator.rb

@@ -4,7 +4,7 @@ module Blacklight::Solr
   # displayable. You have to ask Solr for limit+1, to get enough
   # results to see if 'more' are available'. That is, the all_facet_values
   # arg in constructor should be the result of asking solr for limit+1
-  # values. 
+  # values.
   # This is a workaround for the fact that Solr itself can't compute
   # the total values for a given facet field,
   # so we cannot know how many "pages" there are.
@@ -14,9 +14,9 @@ module Blacklight::Solr
     # asking solr for n+1 facet values.
     # options:
     # :limit =>  number to display per page, or (default) nil. Nil means
-    #            display all with no previous or next. 
+    #            display all with no previous or next.
     # :offset => current item offset, default 0
-    # :sort => 'count' or 'index', solr tokens for facet value sorting, default 'count'. 
+    # :sort => 'count' or 'index', solr tokens for facet value sorting, default 'count'.
     def initialize(all_facet_values, arguments = {})
       super
 

data/app/models/blacklight/suggest_search.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
-
 module Blacklight
   class SuggestSearch
     attr_reader :request_params, :repository
-    
+
     ##
     # @param [Hash] params
-    # @param [Blacklight::AbstractRepository] repository
     def initialize(params, repository)
       @request_params = { q: params[:q] }
       @repository = repository
@@ -17,7 +15,20 @@ module Blacklight
     # Blacklight::Suggest::Response
     # @return [Blacklight::Suggest::Response]
     def suggestions
-      repository.suggestions(request_params)
+      Blacklight::Suggest::Response.new suggest_results, request_params, suggest_handler_path
+    end
+
+    ##
+    # Query the suggest handler using RSolr::Client::send_and_receive
+    # @return [RSolr::HashWithResponse]
+    def suggest_results
+      repository.connection.send_and_receive(suggest_handler_path, params: request_params)
+    end
+
+    ##
+    # @return [String]
+    def suggest_handler_path
+      repository.blacklight_config.autocomplete_path
     end
   end
 end

data/app/models/bookmark.rb

@@ -1,27 +1,22 @@
 # frozen_string_literal: true
-class Bookmark < ActiveRecord::Base
-  
+
+class Bookmark < ApplicationRecord
   belongs_to :user, polymorphic: true
   belongs_to :document, polymorphic: true
 
   validates :user_id, presence: true
 
-  if Blacklight::Utils.needs_attr_accessible?
-    attr_accessible :id, :document_id, :document_type, :title
-  end
-
   def document
     document_type.new document_type.unique_key => document_id
   end
-  
+
   def document_type
     value = super if defined?(super)
     value &&= value.constantize
     value ||= default_document_type
   end
-  
+
   def default_document_type
     SolrDocument
   end
-  
 end

data/app/models/concerns/blacklight/configurable.rb

@@ -5,32 +5,32 @@ module Blacklight::Configurable
   included do
     helper_method :blacklight_config if respond_to? :helper_method
   end
-  
+
   #instance methods for blacklight_config, so get a deep copy of the class-level config
   def blacklight_config
     @blacklight_config ||= self.class.blacklight_config.deep_copy
   end
   attr_writer :blacklight_config
 
-  module ClassMethods   
+  module ClassMethods
     def copy_blacklight_config_from(other_class)
-      self.blacklight_config = other_class.blacklight_config.inheritable_copy
+      self.blacklight_config = other_class.blacklight_config.inheritable_copy(self)
     end
-    
+
     # lazy load a deep_copy of superclass if present, else
-    # a default_configuration, which will be legacy load or new empty config. 
+    # a default_configuration, which will be legacy load or new empty config.
     # note the @blacklight_config variable is a ruby 'instance method on class
     # object' that won't be automatically available to subclasses, that's why
-    # we lazy load to 'inherit' how we want. 
+    # we lazy load to 'inherit' how we want.
     def blacklight_config
       @blacklight_config ||= if superclass.respond_to?(:blacklight_config)
-        superclass.blacklight_config.deep_copy
-      else
-        default_configuration
-      end
+                               superclass.blacklight_config.build(self)
+                             else
+                               default_configuration
+                             end
     end
     attr_writer :blacklight_config
-    
+
     #simply a convenience method for blacklight_config.configure
     def configure_blacklight(*args, &block)
       blacklight_config.configure(*args, &block)
@@ -39,12 +39,12 @@ module Blacklight::Configurable
     ##
     # The default configuration object
     def default_configuration
-      Blacklight::Configurable.default_configuration.inheritable_copy
+      Blacklight::Configurable.default_configuration.inheritable_copy(self)
     end
   end
 
   def self.default_configuration
-      @default_configuration ||= Blacklight::Configuration.new
+    @default_configuration ||= Blacklight::Configuration.new
   end
 
   def self.default_configuration= config

data/app/models/concerns/blacklight/document/active_model_shim.rb

@@ -29,27 +29,24 @@ module Blacklight::Document
         repository.find(id).documents.first
       end
     end
-    
+
     ##
     # Unique ID for the document
     def id
       self[self.class.unique_key]
     end
 
-    ##
-    # accessors for reading attribute
-    def [] *args
-      _source.send :[], *args
+    def ==(other)
+      super ||
+        (other.instance_of?(self.class) &&
+          id &&
+          other.id == id)
     end
-    
+
     def _read_attribute(attr)
       self[attr]
     end
 
-    def as_json(options = nil)
-      _source.as_json(options)
-    end
-    
     ##
     # ActiveRecord::Persistence method stubs to get non-AR objects to
     # play nice with e.g. Blacklight's bookmarks
@@ -60,7 +57,7 @@ module Blacklight::Document
     def destroyed?
       false
     end
-    
+
     def new_record?
       false
     end

data/app/models/concerns/blacklight/document/cache_key.rb

@@ -9,7 +9,7 @@ module Blacklight::Document::CacheKey
   def cache_key
     if new_record?
       "#{self.class.model_name.cache_key}/new"
-    elsif self.key? cache_version_key
+    elsif key? cache_version_key
       cache_version_value = self[cache_version_key]
       "#{self.class.model_name.cache_key}/#{id}-#{Array(cache_version_value).join}"
     else

data/app/models/concerns/blacklight/document/dublin_core.rb

@@ -5,7 +5,7 @@ require 'builder'
 module Blacklight::Document::DublinCore
   def self.extended(document)
     # Register our exportable formats
-    Blacklight::Document::DublinCore.register_export_formats( document )
+    Blacklight::Document::DublinCore.register_export_formats(document)
   end
 
   def self.register_export_formats(document)
@@ -26,7 +26,7 @@ module Blacklight::Document::DublinCore
              'xmlns:dc' => "http://purl.org/dc/elements/1.1/",
              'xmlns:xsi' => "http://www.w3.org/2001/XMLSchema-instance",
              'xsi:schemaLocation' => %(http://www.openarchives.org/OAI/2.0/oai_dc/ http://www.openarchives.org/OAI/2.0/oai_dc.xsd)) do
-      self.to_semantic_values.select { |field, values| dublin_core_field_name? field  }.each do |field,values|
+      to_semantic_values.select { |field, _values| dublin_core_field_name? field  }.each do |field, values|
         Array.wrap(values).each do |v|
           xml.tag! "dc:#{field}", v
         end

data/app/models/concerns/blacklight/document/email.rb

@@ -3,7 +3,7 @@
 module Blacklight::Document::Email
   # Return a text string that will be the body of the email
   def to_email_text
-    semantics = self.to_semantic_values
+    semantics = to_semantic_values
     body = []
     body << I18n.t('blacklight.email.text.title', value: semantics[:title].join(" ")) unless semantics[:title].blank?
     body << I18n.t('blacklight.email.text.author', value: semantics[:author].join(" ")) unless semantics[:author].blank?

data/app/models/concerns/blacklight/document/extensions.rb

@@ -24,8 +24,8 @@ module Blacklight::Document::Extensions
   # Needs to be called in initializer of class including this module, to
   # apply all registered extensions on a per-document basis
   def apply_extensions
-    self.class.registered_extensions.each do | registration|
-      self.extend( registration[:module_obj] ) if registration[:condition_proc].nil? || registration[:condition_proc].call( self )
+    self.class.registered_extensions.each do |registration|
+      extend(registration[:module_obj]) if registration[:condition_proc].nil? || registration[:condition_proc].call(self)
     end
   end
 
@@ -43,15 +43,15 @@ module Blacklight::Document::Extensions
     end
 
     # Register an extension module with the class. A block taking one
-    # parameter can be supplied; the block will be passed an instance of 
+    # parameter can be supplied; the block will be passed an instance of
     # a Document, and the extension will be applied only if the block
     # evaluates as true. If no condition is given, the extension will
     # be applied to every instance of the class.
     #
     # SolrDocument.use_extension( SomeExtensionModule ) { | document | should_apply_some_extension?(document) }
     # SolrDocument.use_extension( SomeExtensionModule) # will be applied to all docs
-    def use_extension( module_obj, &condition )
-      registered_extensions << {module_obj: module_obj, condition_proc: condition}    
+    def use_extension(module_obj, &condition)
+      registered_extensions << { module_obj: module_obj, condition_proc: condition }
     end
   end
 end