blacklight_range_limit 8.5.0 → 9.0.0.beta2

data/package-lock.json

@@ -1,15 +1,15 @@
 {
   "name": "blacklight-range-limit",
-  "version": "8.3.0",
+  "version": "8.5.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "blacklight-range-limit",
-      "version": "8.3.0",
+      "version": "8.5.0",
       "license": "Apache-2.0",
       "devDependencies": {
-        "rollup": "^2.60.0",
+        "rollup": "^3.29.5",
         "rollup-plugin-includepaths": "^0.2.4"
       }
     },
@@ -26,15 +26,16 @@
       }
     },
     "node_modules/rollup": {
-      "version": "2.79.1",
-      "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.79.1.tgz",
-      "integrity": "sha512-uKxbd0IhMZOhjAiD5oAFp7BqvkA4Dv47qpOCtaNvng4HBwdbWtdOh8f5nZNuk2rp51PMGk3bzfWu5oayNEuYnw==",
+      "version": "3.29.5",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-3.29.5.tgz",
+      "integrity": "sha512-GVsDdsbJzzy4S/v3dqWPJ7EfvZJfCHiDqe80IyrF59LYuP+e6U1LJoUqeuqRbwAWoMNoXivMNeNAOf5E22VA1w==",
       "dev": true,
       "bin": {
         "rollup": "dist/bin/rollup"
       },
       "engines": {
-        "node": ">=10.0.0"
+        "node": ">=14.18.0",
+        "npm": ">=8.0.0"
       },
       "optionalDependencies": {
         "fsevents": "~2.3.2"

data/package.json

@@ -1,19 +1,20 @@
 {
   "name": "blacklight-range-limit",
-  "version": "8.5.0",
+  "version": "9.0.0-beta2",
   "description": "A range facet UI component plugin for blacklight",
-  "main": "app/assets/javascripts/blacklight_range_limit",
   "type": "module",
-  "scripts": {
-    "prepare": "rollup --config rollup.config.js --sourcemap && ESM=true rollup --config rollup.config.js --sourcemap"
-  },
+
+  "exports": {
+    ".": "./app/assets/javascripts/blacklight-range-limit/index.js",
+    "./*": "./app/assets/javascripts/blacklight-range-limit/*"
+   },
+
   "repository": {
     "type": "git",
     "url": "git+https://github.com/projectblacklight/blacklight_range_limit.git"
   },
   "files": [
-    "app/assets",
-    "vendor/assets"
+    "app/assets/javascripts/blacklight-range-limit/"
   ],
   "author": "",
   "license": "Apache-2.0",
@@ -21,12 +22,7 @@
     "url": "https://github.com/projectblacklight/blacklight_range_limit/issues"
   },
   "homepage": "https://github.com/projectblacklight/blacklight_range_limit#readme",
-  "browserslist": [
-    "defaults",
-    "not IE 11"
-  ],
-  "devDependencies": {
-    "rollup": "^2.60.0",
-    "rollup-plugin-includepaths": "^0.2.4"
+  "dependencies": {
+    "chart.js": "^ 4.4.1"
   }
 }

data/spec/components/range_facet_component_spec.rb

@@ -26,7 +26,7 @@ RSpec.describe BlacklightRangeLimit::RangeFacetComponent, type: :component do
       min: nil,
       max: nil,
       search_state: Blacklight::SearchState.new({}, nil),
-      range_config: {},
+      range_config: BlacklightRangeLimit.default_range_config[:range_config],
       modal_path: nil,
       facet_field: facet_config,
       **facet_field_params,
@@ -45,15 +45,6 @@ RSpec.describe BlacklightRangeLimit::RangeFacetComponent, type: :component 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
       {
@@ -66,33 +57,26 @@ RSpec.describe BlacklightRangeLimit::RangeFacetComponent, type: :component do
       }
     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')
+    it 'renders into the default facet layout' do
+      expect(rendered).to have_selector('h3', text: 'My facet field')
+        .and have_selector('div.collapse')
     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 'renders the range data into the profile' do
+      expect(rendered).to have_selector('.distribution li', count: 2)
+        .and have_selector('.distribution li', text: '100 to 199')
+        .and have_selector('.distribution li', text: '200 to 300')
+    end
 
-    it 'does not link to the modal' do
-      expect(rendered).not_to have_link 'View larger'
+    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
-  end
 
-  it 'does not render the missing link if there are no matching documents' do
-    expect(rendered).not_to have_link '[Missing]'
+    it 'does not render the missing link if there are no matching documents' do
+      expect(rendered).not_to have_link '[Missing]'
+    end
   end
 
   context 'with missing documents' do
@@ -109,4 +93,89 @@ RSpec.describe BlacklightRangeLimit::RangeFacetComponent, type: :component do
       expect(rendered).to have_link '[Missing]', href: expected_facet_query_param
     end
   end
+
+  context 'with min/max but no range segments' do
+    let(:facet_field_params) do
+      {
+        range_queries: [],
+        min: 100,
+        max: 300
+      }
+    end
+
+    it "renders a link to fetch distribution info" do
+      # need request_url for routing of links generated
+      with_request_url '/catalog' do
+        load_link = rendered.find(".distribution a.load_distribution[href]")
+        expect(load_link).to be_present
+
+        expect(load_link["href"]).to be_present
+        params = Rack::Utils.parse_nested_query(load_link["href"].split("?").try(:last))
+        expect(params["range_field"]).to eq facet_field.key
+        expect(params["range_start"]).to eq facet_field_params[:min].to_s
+        expect(params["range_end"]).to eq facet_field_params[:max].to_s
+      end
+    end
+  end
+
+  context 'with open-ended query' do
+    let(:selected_max) { 200 }
+    let(:data_max) { 300 }
+
+    let(:facet_field) do
+      instance_double(
+        BlacklightRangeLimit::FacetFieldPresenter,
+        key: 'key',
+        active?: false,
+        collapsed?: false,
+        in_modal?: false,
+        label: 'My facet field',
+        selected_range: nil,
+        selected_range_facet_item: Blacklight::Solr::Response::Facets::FacetItem.new(..selected_max),
+        missing_facet_item: nil,
+        missing_selected?: false,
+        min: nil,
+        max: nil,
+        search_state: Blacklight::SearchState.new({}, nil),
+        range_config: BlacklightRangeLimit.default_range_config[:range_config],
+        modal_path: nil,
+        facet_field: facet_config,
+        **facet_field_params,
+        **extra_facet_field_params
+      )
+    end
+
+    let(:facet_field_params) do
+      {
+        range_queries: [],
+        min: 100,
+        max: data_max
+      }
+    end
+
+    # This can be relevant in multi-valued queries, where even though you limited to
+    # < 200, some items in search can ALSO have additional values greater than 200, but
+    # we don't want to include them in our range buckets.
+    it "renders fetch distribution with expressed boundaries taking priority" do
+      # need request_url for routing of links generated
+      with_request_url '/catalog' do
+        load_link = rendered.find(".distribution a.load_distribution[href]")
+        expect(load_link).to be_present
+
+        expect(load_link["href"]).to be_present
+        params = Rack::Utils.parse_nested_query(load_link["href"].split("?").try(:last))
+        expect(params["range_field"]).to eq facet_field.key
+        expect(params["range_start"]).to eq facet_field_params[:min].to_s
+        expect(params["range_end"]).to eq selected_max.to_s
+      end
+    end
+  end
+
+  context 'with no data to display (e.g., no results page)' do
+    let(:facet_field_params) { { min: nil, max: nil, missing_facet_item: nil } }
+
+    it 'does not render the range limit facet' do
+      expect(component.render?).to be false
+    end
+  end
 end

data/spec/components/range_form_component_spec.rb

@@ -62,13 +62,13 @@ RSpec.describe BlacklightRangeLimit::RangeFormComponent, type: :component do
   context 'with range data' do
     let(:selected_range) { (100..300) }
     let(:search_params) do
-      { 
+      {
         another_field: 'another_value',
         range: {
           another_range: { begin: 128, end: 1024 },
           key: { begin: selected_range.first, end: selected_range.last }
         }
-      }      
+      }
     end
 
     it 'renders a form for the selected range' do

data/spec/components/range_segments_component_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+RSpec.describe BlacklightRangeLimit::RangeSegmentsComponent, type: :component do
+  subject(:component) do
+    described_class.new(facet_field: facet_field)
+  end
+
+  let(:raw_rendered) { render_inline(component) }
+
+  let(:rendered) do
+    Capybara::Node::Simple.new(raw_rendered)
+  end
+
+  let(:facet_field) do
+    instance_double(
+      BlacklightRangeLimit::FacetFieldPresenter,
+      key: 'key',
+      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,
+      search_state: Blacklight::SearchState.new({}, nil),
+      range_config: {},
+      modal_path: nil,
+      facet_field: facet_config,
+      **extra_facet_field_params
+    )
+  end
+
+  let(:facet_config) do
+    Blacklight::Configuration::FacetField.new(key: 'key', item_presenter: BlacklightRangeLimit::FacetItemPresenter)
+  end
+
+
+  let(:extra_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
+
+  # This is JS api and should ideally not be changed without major version
+  it "renders list with expected data attributes for JS" do
+    # <span class="from" data-blrl-begin="%{begin_value}">%{begin}</span> to <span class="to" data-blrl-end="%{end_value}">%{end}</span>'
+    list_items = rendered.all("ul.facet-values li")
+    expect(list_items.count).to eq 2
+
+    expect(list_items.first).to have_selector("span.from[data-blrl-begin=100]")
+    expect(list_items.first).to have_selector("span.to[data-blrl-end=199]")
+    expect(list_items.first).to have_selector("span.facet-count", text: 5)
+
+    expect(list_items[1]).to have_selector("span.from[data-blrl-begin=200]")
+    expect(list_items[1]).to have_selector("span.to[data-blrl-end=300]")
+    expect(list_items[1]).to have_selector("span.facet-count", text: 3)
+  end
+end

data/spec/features/blacklight_range_limit_spec.rb

@@ -6,8 +6,8 @@ describe "Blacklight Range Limit" do
     visit search_catalog_path
     expect(page).to have_selector 'input.range_begin'
     expect(page).to have_selector 'input.range_end'
-    expect(page).to have_selector 'label.sr-only[for="range_pub_date_si_begin"]', :text => 'Publication Date Sort range begin'
-    expect(page).to have_selector 'label.sr-only[for="range_pub_date_si_end"]', :text => 'Publication Date Sort range end'
+    expect(page).to have_selector 'label[for="range_pub_date_si_begin"]', :text => I18n.t("blacklight.range_limit.range_begin_short")
+    expect(page).to have_selector 'label[for="range_pub_date_si_end"]', :text => I18n.t("blacklight.range_limit.range_end_short")
     expect(page).to have_button 'Apply'
   end
 
@@ -26,7 +26,9 @@ 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"
+      # depending on version of chrome driver, the 'x' may or may not show up
+      # here before [remove]
+      expect(page).to have_content /2000 to 2008.\[remove\]12/
     end
 
     within '.constraints-container'  do
@@ -63,27 +65,33 @@ describe "Blacklight Range Limit" do
       expect(page).to_not have_content 'Publication Date Sort'
     end
   end
+
+  context 'when on a zero results found page' do
+    it 'should not render the range limit facet' do
+      visit search_catalog_path(q: 'asdfasdfasdf')
+      expect(page).to_not have_selector '#facets .facet-limit.blacklight-pub_date_si'
+      expect(page).to_not have_selector 'input#range_pub_date_si_begin'
+      expect(page).to_not have_selector 'input#range_pub_date_si_end'
+    end
+  end
 end
 
 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', **CatalogController.default_range_config, range_config: {
-        input_label_range_begin: 'from publication date',
-        input_label_range_end: 'to publication date',
-        maxlength: 6
-      }
+      config.add_facet_field 'pub_date_si', range: true
       config.default_solr_params[:'facet.field'] = config.facet_fields.keys
     end
   end
 
-  it "should show the range limit facet with configured labels and maxlength" do
+  it "should show the range limit facet with configured labels" do
     visit '/catalog'
-    expect(page).to have_selector 'label.sr-only[for="range_pub_date_si_begin"]', :text => 'from publication date'
-    expect(page).to have_selector 'label.sr-only[for="range_pub_date_si_end"]', :text => 'to publication date'
-    expect(page).to have_selector 'input#range_pub_date_si_begin[maxlength="6"]'
-    expect(page).to have_selector 'input#range_pub_date_si_end[maxlength="6"]'
+    expect(page).to have_selector 'label[for="range_pub_date_si_begin"]', :text => I18n.t("blacklight.range_limit.range_begin_short")
+    expect(page).to have_selector 'label[for="range_pub_date_si_end"]', :text => I18n.t("blacklight.range_limit.range_end_short")
+
+    expect(page).to have_selector 'input#range_pub_date_si_begin'
+    expect(page).to have_selector 'input#range_pub_date_si_end'
   end
 
 end

data/spec/features/run_through_spec.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'Run through with javascript', js: true do
+  # hacky way to inject browser logs into failure message for failed ones
+  after(:each) do |example|
+    if example.exception
+      browser_logs = page.driver.browser.logs.get(:browser).collect { |log| "#{log.level}: #{log.message}" }
+
+      if browser_logs.present?
+        # pretty hacky internal way to get browser logs into long-form failure message
+        new_exception = example.exception.class.new("#{example.exception.message}\n\nBrowser console:\n\n#{browser_logs.join("\n")}\n")
+        new_exception.set_backtrace(example.exception.backtrace)
+
+        example.display_exception = new_exception
+      end
+    end
+  end
+
+
+  let(:start_range) { "1900"}
+  let(:end_range) { "2100" }
+
+  # capybara tests are slow to setiup, we do a single basic happy path script
+  # in one test. We can only check for placement of "canvas"
+  # element, not really what's in it.
+  it "basically works" do
+    visit search_catalog_path
+
+    click_button 'Publication Date Sort'
+
+    within ".facet-limit.blacklight-pub_date_si" do
+      expect(page).to have_css('canvas')
+
+      # min/max in actual results are filled in inputs
+      expect(find("input#range_pub_date_si_begin").value).to be_present
+      expect(find("input#range_pub_date_si_end").value).to be_present
+
+      # expect expandable limits
+      find("summary", text: "Range List").click
+      expect(page).to have_css("details ul.facet-values li")
+
+      # expect "missing" facet
+      within 'ul.missing' do
+        expect(page).to have_link '[Missing]'
+      end
+
+      # fill in some limits and submit
+      find("input#range_pub_date_si_begin").set(start_range)
+      find("input#range_pub_date_si_end").set(end_range)
+
+      click_button "Apply limit"
+    end
+
+    # new page with limit
+    expect(page).to have_css(".applied-filter", text: /Publication Date Sort.*#{start_range} to #{end_range}/)
+
+    within ".facet-limit.blacklight-pub_date_si" do
+      expect(page).to have_css 'canvas'
+
+      # min/max from specified range
+      expect(find("input#range_pub_date_si_begin").value).to eq start_range
+      expect(find("input#range_pub_date_si_end").value).to eq end_range
+
+      # expect expandable limits
+      find("summary", text: "Range List").click
+      expect(page).to have_css("details ul.facet-values li")
+    end
+  end
+
+  context "for single dates" do
+    it "does not show chart or facet list" do
+      visit search_catalog_path
+
+      click_button 'Publication Date Sort'
+      last_date = nil
+      within ".facet-limit.blacklight-pub_date_si" do
+        last_date = find("input#range_pub_date_si_begin").value
+
+        find("input#range_pub_date_si_begin").set(last_date)
+        find("input#range_pub_date_si_end").set(last_date)
+        click_button "Apply limit"
+      end
+
+      expect(page).to have_css(".applied-filter", text: /Publication Date Sort.*#{last_date}/)
+      within ".facet-limit.blacklight-pub_date_si" do
+        expect(page).not_to have_css 'canvas'
+        expect(page).not_to have_css 'details'
+      end
+    end
+  end
+
+  context "open-ended range" do
+    it "can search" do
+      visit search_catalog_path
+
+      click_button 'Publication Date Sort'
+
+      within ".facet-limit.blacklight-pub_date_si" do
+        find("input#range_pub_date_si_begin").set("")
+        find("input#range_pub_date_si_end").set(end_range)
+        click_button "Apply limit"
+      end
+
+      expect(page).to have_css(".applied-filter", text: /Publication Date Sort +to #{end_range}/)
+      expect(page).not_to have_text("No entries found")
+      expect(page).to have_css(".document")
+
+      within ".facet-limit.blacklight-pub_date_si" do
+        # expect expandable limits
+        find("summary", text: "Range List").click
+        expect(page).to have_css("details ul.facet-values li")
+      end
+    end
+  end
+
+  context "submitted with empty boundaries" do
+    it "does not apply filter" do
+      visit search_catalog_path
+
+      click_button 'Publication Date Sort'
+
+      within ".facet-limit.blacklight-pub_date_si" do
+        find("input#range_pub_date_si_begin").set("")
+        find("input#range_pub_date_si_end").set("")
+        click_button "Apply limit"
+      end
+      expect(page).not_to have_css(".applied-filter")
+
+      click_button 'Publication Date Sort'
+      within ".facet-limit.blacklight-pub_date_si" do
+        expect(page).not_to have_css(".selected")
+      end
+    end
+  end
+
+  context 'when assumed boundaries configured' do
+    around do |example|
+      original = CatalogController.blacklight_config.facet_fields['pub_date_si'].range_config
+      CatalogController.blacklight_config.facet_fields['pub_date_si'].range_config = original.merge({
+         :assumed_boundaries=>1900...2100,
+      })
+
+      example.run
+
+      CatalogController.blacklight_config.facet_fields['pub_date_si'].range_config = original
+    end
+
+    it 'should show the range limit with set boundaries' do
+      visit '/catalog'
+
+      click_button 'Publication Date Sort'
+      expect(find("input#range_pub_date_si_begin").value).to be_present
+      expect(find("input#range_pub_date_si_end").value).to be_present
+    end
+  end
+
+  context 'when missing facet item is configured not to show' do
+    around do |example|
+      original = CatalogController.blacklight_config.facet_fields['pub_date_si'].range_config
+      CatalogController.blacklight_config.facet_fields['pub_date_si'].range_config = original.merge({
+        show_missing_link: false
+      })
+
+      example.run
+
+      CatalogController.blacklight_config.facet_fields['pub_date_si'].range_config = original
+    end
+
+    it 'should not show the missing facet item' do
+      visit search_catalog_path
+
+      within ".facet-limit.blacklight-pub_date_si" do
+        expect(page).not_to have_css("ul.missing")
+      end
+    end
+  end
+
+  context "Range Limit text facets" do
+    # Make sure it works with strict permitted params
+    around do |example|
+      original = ActionController::Parameters.action_on_unpermitted_parameters
+      ActionController::Parameters.action_on_unpermitted_parameters = :raise
+
+      example.run
+
+      ActionController::Parameters.action_on_unpermitted_parameters = original
+    end
+
+    it "work with strict permitted params" do
+      visit search_catalog_path
+
+      click_button 'Publication Date Sort'
+
+      from_val, to_val = nil, nil
+      within ".facet-limit.blacklight-pub_date_si" do
+        find("summary", text: "Range List").click
+
+        facet_link = first(".facet-values li a")
+        from_val = facet_link.find("span[data-blrl-begin]")["data-blrl-begin"]
+        to_val = facet_link.find("span[data-blrl-end]")["data-blrl-end"]
+
+        facet_link.click
+      end
+
+      expect(page).to have_css(".applied-filter", text: /Publication Date Sort.*#{from_val} to #{to_val}/)
+    end
+  end
+end

data/spec/presenters/facet_field_presenter_spec.rb

@@ -141,4 +141,76 @@ RSpec.describe BlacklightRangeLimit::FacetFieldPresenter, type: :presenter do
       end
     end
   end
+
+  describe '#selected_range_facet_item' do
+    before do
+      allow(presenter).to receive(:selected_range).and_return(1990..1999)
+    end
+
+    context 'when the response is not a grouped response' do
+      let(:response) do
+        Blacklight::Solr::Response.new(
+          {
+            response: { numFound: 501 }
+          },
+          nil
+        )
+      end
+
+      it 'returns the facet item with the correct value and hits' do
+        expected_facet_item = Blacklight::Solr::Response::Facets::FacetItem.new(value: 1990..1999, hits: 501)
+        expect(presenter.selected_range_facet_item).to eq expected_facet_item
+      end
+    end
+
+    context 'when the response is a grouped response with one group' do
+      let(:response) do
+        Blacklight::Solr::Response.new(
+          {
+            grouped: {
+              _root_: {
+                matches: 123
+              }
+            }
+          },
+          nil
+        )
+      end
+
+      it 'returns the facet item with the hits from the group' do
+        expected_facet_item = Blacklight::Solr::Response::Facets::FacetItem.new(value: 1990..1999, hits: 123)
+        expect(presenter.selected_range_facet_item).to eq expected_facet_item
+      end
+    end
+
+    context 'when the response is a grouped response with multiple groups' do
+      let(:response) do
+        Blacklight::Solr::Response.new(
+          {
+            grouped: {
+              field_one_ssi: {
+                matches: 123
+              },
+              field_two_ssi: {
+                matches: 456
+              }
+            }
+          },
+          nil
+        )
+      end
+
+      let(:blacklight_config) do
+        Blacklight::Configuration.new.tap do |config|
+          config.facet_fields['field_key'] = facet_field
+          config.index.group = 'field_two_ssi'
+        end
+      end
+
+      it 'returns the facet item with the hits from the configured group' do
+        expected_facet_item = Blacklight::Solr::Response::Facets::FacetItem.new(value: 1990..1999, hits: 456)
+        expect(presenter.selected_range_facet_item).to eq expected_facet_item
+      end
+    end
+  end
 end