blacklight_range_limit 8.1.0 → 8.2.0

data/lib/blacklight_range_limit/range_limit_builder.rb

@@ -12,59 +12,35 @@ module BlacklightRangeLimit
 
     # Method added to to fetch proper things for date ranges.
     def add_range_limit_params(solr_params)
-       ranged_facet_configs =
-         blacklight_config.facet_fields.select { |key, config| config.range }
-       # In ruby 1.8, hash.select returns an array of pairs, in ruby 1.9
-       # it returns a hash. Turn it into a hash either way.
-       ranged_facet_configs = Hash[ ranged_facet_configs ] unless ranged_facet_configs.kind_of?(Hash)
-
-       ranged_facet_configs.each_pair do |field_key, config|
-        solr_params["stats"] = "true"
-        solr_params["stats.field"] ||= []
-        solr_params["stats.field"] << config.field
-
-        range_config = BlacklightRangeLimit.range_config(blacklight_config, config.field)
-
-        hash =  blacklight_params["range"] && blacklight_params["range"][field_key] ?
-          blacklight_params["range"][field_key] :
-          {}
+      ranged_facet_configs = blacklight_config.facet_fields.select { |_key, config| config.range }
+      return solr_params unless ranged_facet_configs.any?
 
-        if !hash["missing"].blank?
-          # missing specified in request params
-          solr_params[:fq] ||= []
-          solr_params[:fq] << "-#{config.field}:[* TO *]"
+      solr_params["stats"] = "true"
+      solr_params["stats.field"] ||= []
 
-        elsif !(hash["begin"].blank? && hash["end"].blank?)
-          # specified in request params, begin and/or end, might just have one
-          start = hash["begin"].blank? ? "*" : hash["begin"]
-          finish = hash["end"].blank? ? "*" : hash["end"]
+      ranged_facet_configs.each do |field_key, config|
+        solr_params["stats.field"] << config.field
 
-          solr_params[:fq] ||= []
-          solr_params[:fq] << "#{config.field}: [#{start} TO #{finish}]"
+        range_config = config.range_config
+        next if range_config[:segments] == false
 
-          if (range_config[:segments] != false && start != "*" && finish != "*")
-            # Add in our calculated segments, can only do with both boundaries.
-            add_range_segments_to_solr!(solr_params, field_key, start.to_i, finish.to_i)
-          end
+        selected_value = search_state.filter(config.key).values.first
+        range = (selected_value if selected_value.is_a? Range) || range_config[:assumed_boundaries]
 
-        elsif (range_config[:segments] != false &&
-               boundaries = range_config[:assumed_boundaries])
-          # assumed_boundaries in config
-          add_range_segments_to_solr!(solr_params, field_key, boundaries[0], boundaries[1])
-        end
+        add_range_segments_to_solr!(solr_params, field_key, range.first, range.last) if range.present?
       end
 
-      return solr_params
+      solr_params
     end
 
 
     # Another processing method, this one is NOT included in default processing chain,
     # it is specifically swapped in *instead of* add_range_limit_params for
     # certain ajax requests that only want to fetch range limit segments for
-    # ONE field. 
+    # ONE field.
     #
     # It turns off facetting and sets rows to 0 as well, only results for
-    # single specified field are needed. 
+    # single specified field are needed.
     #
     # Specified field and parameters are specified in incoming parameters
     # range_field, range_start, range_end
@@ -80,7 +56,7 @@ module BlacklightRangeLimit
       solr_params.delete("facet.field".to_sym)
 
       # We don't need any actual rows either
-      solr_params[:rows] = 0      
+      solr_params[:rows] = 0
 
       return solr_params
     end

data/lib/blacklight_range_limit/segment_calculation.rb

@@ -17,11 +17,11 @@ module BlacklightRangeLimit
 
       return solr_params unless field_config
 
-      range_config = BlacklightRangeLimit.range_config(blacklight_config, facet_field)
+      range_config = field_config.range_config
 
       solr_params[:"facet.query"] ||= []
 
-      boundaries = boundaries_for_range_facets(min, max, (range_config[:num_segments] || 10) )
+      boundaries = boundaries_for_range_facets(min, max, range_config[:num_segments] || 10)
 
       # Now make the boundaries into actual filter.queries.
       0.upto(boundaries.length - 2) do |index|

data/lib/blacklight_range_limit.rb

@@ -1,9 +1,12 @@
 # BlacklightRangeLimit
+require 'deprecation'
 
 module BlacklightRangeLimit
+  extend Deprecation
+
+  require 'blacklight_range_limit/facet_field_config_override'
   require 'blacklight_range_limit/range_limit_builder'
   require 'blacklight_range_limit/controller_override'
-  require 'blacklight_range_limit/view_helper_override'
 
   require 'blacklight_range_limit/version'
   require 'blacklight_range_limit/engine'
@@ -22,24 +25,40 @@ module BlacklightRangeLimit
 
   # Add element to array only if it's not already there
   def self.safe_arr_add(array, element)
+    Deprecation.warn(BlacklightRangeLimit, 'BlacklightRangeLimit.safe_arr_add is deprecated without replacement')
     array << element unless array.include?(element)
   end
 
-  # Convenience method for returning range config hash from
-  # blacklight config, for a specific solr field, in a normalized
-  # way.
-  #
-  # Returns false if range limiting not configured.
-  # Returns hash even if configured to 'true'
-  # for consistency.
   def self.range_config(blacklight_config, solr_field)
+    Deprecation.warn(BlacklightRangeLimit, 'BlacklightRangeLimit.range_config is deprecated without replacement')
     field = blacklight_config.facet_fields[solr_field.to_s]
 
-    return false unless field && field.range
+    return false unless field&.range
 
-    config = field.range
-    config = { partial: field.partial } if config === true
+    if field.range == true
+      default_range_config
+    else
+      field.range.merge(partial: field.partial)
+    end
+  end
 
-    config
+  def self.default_range_config
+    {
+      range: true,
+      range_config: {
+        num_segments: 10,
+        chart_js: true,
+        slider_js: true,
+        segments: true,
+        assumed_boundaries: nil,
+        maxlength: nil,
+        input_label_range_begin: nil,
+        input_label_range_end: nil
+      },
+      filter_class: BlacklightRangeLimit::FilterField,
+      presenter: BlacklightRangeLimit::FacetFieldPresenter,
+      item_presenter: BlacklightRangeLimit::FacetItemPresenter,
+      component: BlacklightRangeLimit::RangeFacetComponent
+    }
   end
 end

data/lib/generators/blacklight_range_limit/install_generator.rb

@@ -4,6 +4,8 @@ module BlacklightRangeLimit
   class InstallGenerator < Rails::Generators::Base
     source_root File.expand_path('../templates', __FILE__)
 
+    class_option :'builder-path', type: :string, default: 'app/models/search_builder.rb', aliases: "-b", desc: "Set the path, relative to Rails root, to the Blacklight app's search builder class"
+
     def copy_public_assets
       generate 'blacklight_range_limit:assets'
     end
@@ -15,7 +17,7 @@ module BlacklightRangeLimit
     end
 
     def install_search_builder
-      path = 'app/models/search_builder.rb'
+      path = options[:'builder-path']
       if File.exist? path
         inject_into_file path, after: /include Blacklight::Solr::SearchBuilderBehavior.*$/ do
           "\n  include BlacklightRangeLimit::RangeLimitBuilder\n"
@@ -25,22 +27,6 @@ module BlacklightRangeLimit
       end
     end
 
-    # Adds range limit behavior to search history controller
-    def install_search_history_controller
-      path = 'app/controllers/search_history_controller.rb'
-
-      # If local copy of search history controller exists, add range limit helpers
-      if File.exist? path
-        inject_into_file path, after: /include Blacklight::SearchHistory.*$/ do
-          "\n  helper BlacklightRangeLimit::ViewHelperOverride"\
-          "\n  helper RangeLimitHelper"
-        end
-      # Otherwise copies search history controller to application
-      else
-        copy_file 'search_history_controller.rb', path
-      end
-    end
-
     def install_routing_concern
       route('concern :range_searchable, BlacklightRangeLimit::Routes::RangeSearchable.new')
     end

data/solr/conf/schema.xml

@@ -175,16 +175,6 @@
     <dynamicField name="*_coordinate" type="tdouble" indexed="true"  stored="false" />
 
 
-    <!-- location (_ll...) -->
-
-    <dynamicField name="*_lli" type="location" stored="false" indexed="true" multiValued="false"/>
-    <dynamicField name="*_llim" type="location" stored="false" indexed="true" multiValued="true"/>
-
-    <dynamicField name="*_lls" type="location" stored="true" indexed="false" multiValued="false"/>
-    <dynamicField name="*_llsm" type="location" stored="true" indexed="false" multiValued="true"/>
-    <dynamicField name="*_llsi" type="location" stored="true" indexed="true" multiValued="false"/>
-    <dynamicField name="*_llsim" type="location" stored="true" indexed="true" multiValued="true"/>
-
     <dynamicField name="*_srpt" type="location_rpt" stored="true" indexed="true" multiValued="true" />
     <dynamicField name="*_bbox" type="bbox" stored="true" indexed="true" />
 
@@ -263,9 +253,6 @@
      -->
     <fieldType name="point" class="solr.PointType" dimension="2" subFieldSuffix="_d"/>
 
-    <!-- A specialized field for geospatial search. If indexed, this fieldType must not be multivalued. -->
-    <fieldType name="location" class="solr.LatLonType" subFieldSuffix="_coordinate"/>
-
     <!-- An alternative geospatial field type new to Solr 4.  It supports multiValued and polygon shapes.
       For more information about this and other Spatial fields new to Solr 4, see:
       http://wiki.apache.org/solr/SolrAdaptersForLuceneSpatial4

data/solr/conf/solrconfig.xml

@@ -19,6 +19,7 @@
   <!-- solr lib dirs -->
   <lib dir="${solr.install.dir:../../../..}/contrib/analysis-extras/lib" />
   <lib dir="${solr.install.dir:../../../..}/contrib/analysis-extras/lucene-libs" />
+  <lib dir="${solr.install.dir:../../../..}/modules/analysis-extras/lib" />
 
   <dataDir>${solr.data.dir:}</dataDir>
 

data/spec/components/range_facet_component_spec.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe BlacklightRangeLimit::RangeFacetComponent, type: :component do
+  subject(:component) do
+    described_class.new(facet_field: facet_field)
+  end
+
+  let(:rendered) do
+    Capybara::Node::Simple.new(render_inline(component))
+  end
+
+  let(:facet_field) do
+    instance_double(
+      BlacklightRangeLimit::FacetFieldPresenter,
+      key: 'key',
+      html_id: 'id',
+      active?: false,
+      collapsed?: false,
+      in_modal?: false,
+      label: 'My facet field',
+      selected_range: nil,
+      selected_range_facet_item: nil,
+      missing_facet_item: nil,
+      missing_selected?: false,
+      min: nil,
+      max: nil,
+      search_state: Blacklight::SearchState.new({}, nil),
+      range_config: {},
+      modal_path: nil,
+      facet_field: facet_config,
+      **facet_field_params
+    )
+  end
+
+  let(:facet_config) do
+    Blacklight::Configuration::FacetField.new(key: 'key', item_presenter: BlacklightRangeLimit::FacetItemPresenter)
+  end
+
+  let(:facet_field_params) { {} }
+
+  before do
+    allow(component).to receive(:search_facet_path).and_return('/range/key')
+  end
+
+  it 'renders into the default facet layout' do
+    expect(rendered).to have_selector('h3', text: 'My facet field')
+      .and have_selector('div.collapse')
+  end
+
+  it 'renders a placeholder profile area' do
+    expect(rendered).to have_selector('div.profile', text: '')
+  end
+
+  context 'with range data' do
+    let(:facet_field_params) do
+      {
+        range_queries: [
+          OpenStruct.new(value: 100..199, hits: 5),
+          OpenStruct.new(value: 200..300, hits: 3)
+        ],
+        min: 100,
+        max: 300
+      }
+    end
+
+    it 'renders the range data into the profile' do
+      expect(rendered).to have_selector('.profile li', count: 2)
+        .and have_selector('.profile li', text: '100 to 199')
+        .and have_selector('.profile li', text: '200 to 300')
+    end
+  end
+
+  it 'renders a form for the range' do
+    expect(rendered).to have_selector('form[action="http://test.host/catalog"][method="get"]')
+      .and have_field('range[key][begin]')
+      .and have_field('range[key][end]')
+  end
+
+  it 'renders a link to the modal' do
+    expect(rendered).to have_link 'View larger', href: '/range/key'
+  end
+
+  context 'within a modal' do
+    let(:facet_field_params) { { in_modal?: true } }
+
+    it 'does not link to the modal' do
+      expect(rendered).not_to have_link 'View larger'
+    end
+  end
+
+  it 'does not render the missing link if there are no matching documents' do
+    expect(rendered).not_to have_link '[Missing]'
+  end
+
+  context 'with missing documents' do
+    let(:facet_field_params) { { missing_facet_item: facet_item } }
+    let(:facet_item) do
+      Blacklight::Solr::Response::Facets::FacetItem.new(
+        value: Blacklight::SearchState::FilterField::MISSING,
+        hits: 50
+      )
+    end
+
+    it 'renders a facet value for the documents that are missing the field data' do
+      expected_facet_query_param = Regexp.new(Regexp.escape({ f: { '-key': ['[* TO *]'] } }.to_param))
+      expect(rendered).to have_link '[Missing]', href: expected_facet_query_param
+    end
+  end
+end

data/spec/features/a_javascript_spec.rb

@@ -23,13 +23,13 @@ describe 'JavaScript', js: true do
 
   context 'when assumed boundaries configured' do
     before do
-      CatalogController.blacklight_config.facet_fields['pub_date_si'].range = {
-        assumed_boundaries: [1990, 2000]
+      CatalogController.blacklight_config.facet_fields['pub_date_si'].range_config = {
+        assumed_boundaries: 1990...2000
       }
     end
 
     after do
-      CatalogController.blacklight_config.facet_fields['pub_date_si'].range = true
+      CatalogController.blacklight_config.facet_fields['pub_date_si'].range_config = {}
     end
 
     it 'should show the range limit with set boundaries' do
@@ -48,7 +48,7 @@ describe 'JavaScript', js: true do
         click_button 'Publication Date Sort'
 
         within 'ul.subsection.missing' do
-          expect(page).to have_link 'Unknown'
+          expect(page).to have_link '[Missing]'
         end
       end
     end

data/spec/features/blacklight_range_limit_spec.rb

@@ -14,9 +14,10 @@ describe "Blacklight Range Limit" do
   it "should provide distribution information" do
     visit search_catalog_path
     click_link 'View distribution'
-
-    expect(page).to have_content("1500 to 1599 0")
-    expect(page).to have_content("2000 to 2008 12")
+    expect(page).to have_selector('a.facet-select', text: "1500 to 1599")
+    expect(page.find('a.facet-select', text: "1500 to 1599").ancestor('li')).to have_selector('span.facet-count', text: "0")
+    expect(page).to have_selector('a.facet-select', text: "2000 to 2008")
+    expect(page.find('a.facet-select', text: "2000 to 2008").ancestor('li')).to have_selector('span.facet-count', text: "12")
   end
 
   it "should limit appropriately" do
@@ -25,7 +26,7 @@ describe "Blacklight Range Limit" do
     click_link '2000 to 2008'
 
     within '.blacklight-pub_date_si' do
-      expect(page).to have_content "2000 to 2008 ✖ [remove] 12"
+      expect(page).to have_content "2000 to 2008✖[remove]12"
     end
 
     within '.constraints-container'  do
@@ -39,7 +40,7 @@ describe "Blacklight Range Limit" do
     visit search_catalog_path(page: 2)
     click_link 'View distribution'
     click_link '2000 to 2008'
-    click_button 'Apply'
+    click_button 'Apply', match: :first
     expect(page.current_url).not_to include('page')
   end
 
@@ -67,7 +68,7 @@ describe "Blacklight Range Limit with configured input labels" do
   before do
     CatalogController.blacklight_config = Blacklight::Configuration.new
     CatalogController.configure_blacklight do |config|
-      config.add_facet_field 'pub_date_si', range: {
+      config.add_facet_field 'pub_date_si', **CatalogController.default_range_config, range_config: {
         input_label_range_begin: 'from publication date',
         input_label_range_end: 'to publication date',
         maxlength: 6

data/spec/helpers/blacklight_range_limit_helper_spec.rb

@@ -1,6 +1,11 @@
 require "spec_helper"
 
 describe "Blacklight Range Limit Helper" do
+  let(:config) { Blacklight::Configuration.new }
+  before do
+    allow(helper).to receive(:blacklight_config).and_return(config)
+    allow(helper).to receive(:search_state).and_return(Blacklight::SearchState.new({}, config))
+  end
 
   it "should render range text fields with/without labels" do
     begin_html = Capybara.string(helper.render_range_input('pub_date', 'begin'))
@@ -17,21 +22,16 @@ describe "Blacklight Range Limit Helper" do
   end
 
   context "when building requests" do
-    let(:config) { Blacklight::Configuration.new }
-    before do
-      allow(helper).to receive(:blacklight_config).and_return(config)
-    end
-
     it "should exclude page when adding a range" do
       params = { q: '', page: '2' }
       updated_params = helper.add_range('test', '1900', '1995', params)
-      expect(updated_params).not_to include(:page)
+      expect(updated_params.to_h).not_to include(:page)
     end
 
     it "should exclude page when adding a missing range" do
       params = { q: '', page: '2' }
       updated_params = helper.add_range_missing('test', params)
-      expect(updated_params).not_to include(:page)
+      expect(updated_params.to_h).not_to include(:page)
     end
   end
 end

data/spec/presenters/facet_field_presenter_spec.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe BlacklightRangeLimit::FacetFieldPresenter, type: :presenter do
+  subject(:presenter) do
+    described_class.new(facet_field, display_facet, view_context, search_state)
+  end
+  let(:view_context) { controller.view_context }
+  let(:search_state) { Blacklight::SearchState.new(params, blacklight_config, view_context) }
+
+  let(:facet_field) do
+    Blacklight::Configuration::FacetField.new(
+      key: 'field_key',
+      field: 'some_field',
+      filter_class: BlacklightRangeLimit::FilterField
+    )
+  end
+  let(:blacklight_config) do
+    Blacklight::Configuration.new.tap { |x| x.facet_fields['field_key'] = facet_field }
+  end
+  let(:params) { {} }
+
+  let(:display_facet) do
+    instance_double(Blacklight::Solr::Response::Facets::FacetField, items: [], response: response)
+  end
+  let(:response) do
+    Blacklight::Solr::Response.new(
+      {
+        response: { numFound: 5 },
+        stats: {
+          stats_fields: {
+            some_field: some_field_stats
+          }
+        }
+      },
+      nil
+    )
+  end
+
+  let(:some_field_stats) { {} }
+
+  describe '#range_queries' do
+    let(:response) do
+      {
+        'facet_counts' => {
+          'facet_queries' => {
+            'some_field:[150 TO 199]' => 15,
+            'some_field:[100 TO 149]' => 5,
+            'some_field:[200 TO 249]' => 4,
+            'irrelevant_field:[A TO C]' => 18
+          }
+        }
+      }
+    end
+
+    it 'extracts range data from the facet queries response' do
+      expect(presenter.range_queries.count).to eq 3
+      expect(presenter.range_queries.map(&:value)).to eq [100..149, 150..199, 200..249]
+    end
+  end
+
+  describe '#min' do
+    let(:some_field_stats) do
+      {
+        max: 999.00,
+        min: 700.0000,
+        missing: 0
+      }
+    end
+
+    it 'extracts the min stat, stringifies it (for some reason), and truncates it' do
+      expect(presenter.min).to eq '700'
+    end
+
+    context 'when all documents in the response are missing data' do
+      let(:some_field_stats) do
+        {
+          max: -345,
+          min: -999,
+          missing: 5
+        }
+      end
+
+      it 'returns nil' do
+        expect(presenter.min).to be_nil
+      end
+    end
+  end
+
+  describe '#max' do
+    let(:some_field_stats) do
+      {
+        max: 999.00,
+        min: 700.0000,
+        missing: 0
+      }
+    end
+
+    it 'extracts the ,ax stat, stringifies it (for some reason), and truncates it' do
+      expect(presenter.max).to eq '999'
+    end
+
+    context 'when all documents in the response are missing data' do
+      let(:some_field_stats) do
+        {
+          max: -345,
+          min: -999,
+          missing: 5
+        }
+      end
+
+      it 'returns nil' do
+        expect(presenter.max).to be_nil
+      end
+    end
+  end
+
+  describe '#missing_facet_item' do
+    let(:some_field_stats) do
+      {
+        missing: 5
+      }
+    end
+
+    it 'extracts the missing stat' do
+      expect(presenter.missing_facet_item.hits).to eq 5
+    end
+  end
+
+  describe '#selected_range' do
+    it 'returns nil if no range is selected' do
+      expect(presenter.selected_range).to eq nil
+    end
+
+    context 'with a user-selected range' do
+      let(:params) { { range: { field_key: { begin: 100, end: 250 } } } }
+
+      it 'returns the selected range' do
+        expect(presenter.selected_range).to eq 100..250
+      end
+    end
+  end
+end

data/spec/presenters/facet_item_presenter_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe BlacklightRangeLimit::FacetItemPresenter, type: :presenter do
+  subject(:presenter) do
+    described_class.new(facet_item, facet_config, view_context, facet_field, search_state)
+  end
+
+  let(:facet_item) { instance_double(Blacklight::Solr::Response::Facets::FacetItem) }
+  let(:filter_field) { instance_double(Blacklight::SearchState::FilterField, include?: true) }
+  let(:facet_config) { Blacklight::Configuration::FacetField.new(key: 'key') }
+  let(:facet_field) { instance_double(Blacklight::Solr::Response::Facets::FacetField) }
+  let(:view_context) { controller.view_context }
+  let(:search_state) { instance_double(Blacklight::SearchState, filter: filter_field) }
+
+  describe '#label' do
+    context 'with a single value' do
+      let(:facet_item) { 'blah' }
+
+      it 'uses the normal logic for item values' do
+        expect(presenter.label).to eq 'blah'
+      end
+    end
+
+    context 'with a range' do
+      let(:facet_item) { 1234..2345 }
+
+      it 'translates the range into some nice, human-readable html' do
+        expect(Capybara.string(presenter.label))
+          .to have_text('1234 to 2345')
+          .and have_css('span.from[data-blrl-begin=1234]', text: '1234')
+          .and have_css('span.to[data-blrl-end=2345]', text: '2345')
+      end
+    end
+
+    context 'with a range that has the same start + end values' do
+      let(:facet_item) { 2021..2021 }
+
+      it 'translates the range into some nice, human-readable html' do
+        expect(Capybara.string(presenter.label))
+          .to have_text('2021')
+          .and have_css('span.single[data-blrl-single=2021]', text: '2021')
+      end
+    end
+  end
+end