blacklight_range_limit 8.4.0 → 9.0.0.beta1

data/package.json

@@ -1,16 +1,20 @@
 {
   "name": "blacklight-range-limit",
-  "version": "8.3.0",
+  "version": "9.0.0.beta1",
   "description": "A range facet UI component plugin for blacklight",
-  "main": "app/assets/javascripts/blacklight_range_limit",
-  "scripts": {
-  },
+  "type": "module",
+
+  "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",
@@ -18,12 +22,7 @@
     "url": "https://github.com/projectblacklight/blacklight_range_limit/issues"
   },
   "homepage": "https://github.com/projectblacklight/blacklight_range_limit#readme",
-  "devDependencies": {
-  },
-  "browserslist": [
-    "defaults",
-    "not IE 11"
-  ],
   "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,29 @@ 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
+        expect(rendered).to have_selector(".distribution a.load_distribution[href]")
+      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,157 @@
+# 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
+    before do
+      CatalogController.blacklight_config.facet_fields['pub_date_si'].range_config = {
+        assumed_boundaries: start_range.to_i...end_range.to_i
+      }
+    end
+
+    after do
+      CatalogController.blacklight_config.facet_fields['pub_date_si'].range_config = {}
+    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
+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

data/spec/presenters/filter_field_spec.rb

@@ -19,9 +19,18 @@ RSpec.describe BlacklightRangeLimit::FilterField do
   describe '#add' do
     it 'adds a new range parameter' do
       new_state = filter.add(1999..2099)
-
       expect(new_state.params.dig(:range, 'some_field')).to include begin: 1999, end: 2099
     end
+
+    it "adds end-less range" do
+      new_state = filter.add(1999..nil)
+      expect(new_state.params.dig(:range, 'some_field')).to include begin: 1999, end: nil
+    end
+
+    it "adds begin-less range" do
+      new_state = filter.add(nil..2099)
+      expect(new_state.params.dig(:range, 'some_field')).to include begin: nil, end: 2099
+    end
   end
 
   context 'with some existing data' do
@@ -32,6 +41,12 @@ RSpec.describe BlacklightRangeLimit::FilterField do
         new_state = filter.add(1999..2099)
 
         expect(new_state.params.dig(:range, 'some_field')).to include begin: 1999, end: 2099
+
+        new_state = filter.add(1999..nil)
+        expect(new_state.params.dig(:range, 'some_field')).to include begin: 1999, end: nil
+
+        new_state = filter.add(nil..2099)
+        expect(new_state.params.dig(:range, 'some_field')).to include begin: nil, end: 2099
       end
     end
 
@@ -66,6 +81,26 @@ RSpec.describe BlacklightRangeLimit::FilterField do
     end
   end
 
+  context 'with an end-less range' do
+    let(:param_values) { { range: { some_field: { begin: '2013', end: '' } } } }
+
+    describe '#values' do
+      it 'converts the parameters to a Range' do
+        expect(filter.values).to eq [2013..nil]
+      end
+    end
+  end
+
+  context 'with an begin-less range' do
+    let(:param_values) { { range: { some_field: { begin: '', end: '2022' } } } }
+
+    describe '#values' do
+      it 'converts the parameters to a Range' do
+        expect(filter.values).to eq [nil..2022]
+      end
+    end
+  end
+
   context 'with empty data' do
     let(:param_values) { { range: { some_field: { begin: '', end: '' } } } }
 

data/spec/spec_helper.rb

@@ -6,6 +6,7 @@ EngineCart.load_application!
 require 'rspec/rails'
 require 'capybara/rspec'
 require 'selenium-webdriver'
+require 'capybara-screenshot/rspec'
 
 Capybara.javascript_driver = :headless_chrome
 
@@ -16,10 +17,16 @@ Capybara.register_driver :headless_chrome do |app|
     opts.args << '--disable-gpu'
     opts.args << '--no-sandbox'
     opts.args << '--window-size=1280,1696'
+
+    opts.add_option('goog:loggingPrefs', browser: 'ALL')
   end
   Capybara::Selenium::Driver.new(app, browser: :chrome, options: browser_options)
 end
 
+Capybara::Screenshot.register_driver(:headless_chrome) do |driver, path|
+  driver.browser.save_screenshot(path)
+end
+
 # Requires supporting ruby files with custom matchers and macros, etc,
 # in spec/support/ and its subdirectories.
 Dir[Pathname.new(File.expand_path('support/**/*.rb', __dir__))].sort.each { |f| require f }
@@ -38,4 +45,7 @@ RSpec.configure do |config|
 
   config.include PresenterTestHelpers, type: :presenter
   config.include ViewComponent::TestHelpers, type: :component
+
+  config.example_status_persistence_file_path = 'spec/examples.txt'
+
 end

data/spec/test_app_templates/Gemfile.extra

@@ -1,2 +1,12 @@
 gem 'rails-controller-testing'
-gem 'blacklight', ENV['BLACKLIGHT_VERSION'] if ENV['BLACKLIGHT_VERSION']
+
+if ENV['BLACKLIGHT_VERSION']
+  # allow direct git and other with serialized json kw args
+  require 'json'
+  if ENV['BLACKLIGHT_VERSION'].start_with?("{")
+    gem "blacklight", **JSON.parse(ENV['BLACKLIGHT_VERSION'])
+  else
+    gem "blacklight", ENV['BLACKLIGHT_VERSION']
+  end
+end
+