geoblacklight 4.0.0.pre.alpha.3 → 4.0.0.pre.rc3

data/spec/models/concerns/geoblacklight/bbox_filter_field_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Geoblacklight::BboxFilterField do
+  subject(:filter) { search_state.filter('bbox') }
+
+  let(:bbox_value) { '140.143709 -65.487905 160.793791 86.107541' }
+  let(:search_state) { Blacklight::SearchState.new(params.with_indifferent_access, blacklight_config, controller) }
+  let(:params) { {} }
+  let(:blacklight_config) do
+    Blacklight::Configuration.new.configure do |config|
+      config.add_facet_field 'bbox', filter_class: described_class
+    end
+  end
+  let(:facet_config) { blacklight_config.facet_fields['bbox'] }
+  let(:controller) { double }
+
+  describe '#add' do
+    context 'with a ordinary parameter' do
+      it 'adds the parameter to the facets' do
+        new_state = filter.add(bbox_value)
+
+        expect(new_state.params).to include bbox: bbox_value
+      end
+    end
+
+    context 'with a bounding box' do
+      it 'adds the parameter to the bbox parameter' do
+        new_state = filter.add(Geoblacklight::BoundingBox.from_rectangle(bbox_value))
+
+        expect(new_state.params).to include bbox: bbox_value
+      end
+    end
+  end
+
+  context 'with some existing data' do
+    let(:params) { { bbox: bbox_value } }
+
+    describe '#add' do
+      let(:bbox_replacement) { '100.143709 -70.487905 100.793791 96.107541' }
+      it 'replaces the existing range' do
+        new_state = filter.add(Geoblacklight::BoundingBox.from_rectangle(bbox_replacement))
+
+        expect(new_state.params).to include bbox: bbox_replacement
+      end
+    end
+
+    describe '#remove' do
+      it 'removes the existing bbox' do
+        new_state = filter.remove(Geoblacklight::BoundingBox.from_rectangle(bbox_value))
+
+        expect(new_state.params[:bbox]).to be_nil
+      end
+    end
+
+    describe '#values' do
+      it 'converts the parameters to a Geoblacklight::BoundingBox' do
+        expect(filter.values.first).to be_a(Geoblacklight::BoundingBox).and(have_attributes(to_param: bbox_value))
+      end
+    end
+
+    describe '#needs_normalization?' do
+      it 'returns false for the expected keyed representation of the bounding box' do
+        expect(filter.needs_normalization?(search_state.params)).to be false
+      end
+    end
+
+    context 'when array param represented by facebook as a Hash' do
+      let(:filter) { described_class.new(facet_config, search_state) }
+      let(:params) { { bbox: { '0' => bbox_value } } }
+
+      describe '#normalize' do
+        it 'converts the parameters to a list' do
+          expect(filter.normalize(search_state.params[:bbox])).to eql [bbox_value]
+        end
+      end
+
+      describe '#needs_normalization?' do
+        it 'returns true for the hash-as-array keyed representation of the bounding box' do
+          expect(filter.needs_normalization?(search_state.params[:bbox])).to be true
+        end
+      end
+    end
+  end
+
+  context 'with a malformed bbox' do
+    let(:params) { { bbox: 'totally-not-a-bbox' } }
+
+    it 'excludes it from the values' do
+      filter = search_state.filter('bbox')
+
+      expect(filter.values).to be_empty
+    end
+  end
+end

data/spec/models/concerns/geoblacklight/bbox_filter_query_spec.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Geoblacklight::BboxFilterQuery do
+  # Subject
+  subject(:bbox_filter_query) { described_class.new(filter, solr_params) }
+
+  let(:solr_params) { {} }
+
+  # Search State
+  let(:search_state) { Blacklight::SearchState.new(params.with_indifferent_access, blacklight_config) }
+
+  let(:params) do
+    { bbox: '-180 -80 120 80' }
+  end
+
+  let(:blacklight_config) do
+    Blacklight::Configuration.new.configure do |config|
+      config.add_facet_field 'bbox', filter_class: Geoblacklight::BboxFilterField
+    end
+  end
+  let(:facet_config) { blacklight_config.facet_fields['bbox'] }
+
+  # Filter
+  let(:filter) { Geoblacklight::BboxFilterField.new(facet_config, search_state) }
+
+  describe '#initialize' do
+    it 'initializes as a BboxFilterQuery object' do
+      expect(bbox_filter_query).to be_a described_class
+    end
+  end
+
+  describe '#envelope_bounds' do
+    it 'returns an BoundingBox envelope' do
+      expect(bbox_filter_query.envelope_bounds).to eq('ENVELOPE(-180, 120, 80, -80)')
+    end
+  end
+
+  describe '#boost' do
+    context 'without an explicit boost' do
+      before do
+        facet_config.within_boost = nil
+      end
+
+      it 'returns an default boost value' do
+        expect(bbox_filter_query.boost).to eq('^10')
+      end
+    end
+
+    context 'with an explicit boost' do
+      before do
+        facet_config.within_boost = 99
+      end
+
+      it 'applies boost based on configured Settings.BBOX_WITHIN_BOOST' do
+        expect(bbox_filter_query.boost).to eq('^99')
+      end
+    end
+  end
+
+  describe '#relevancy_boost' do
+    it 'returns a relevancy_boost' do
+      expect(bbox_filter_query.relevancy_boost[:bq].to_s).to include('IsWithin')
+    end
+
+    context 'with overlap boost' do
+      before do
+        facet_config.overlap_boost = 2
+      end
+
+      it 'applies overlapRatio when Settings.OVERLAP_RATIO_BOOST is configured' do
+        expect(bbox_filter_query.relevancy_boost[:bf].to_s).to include('$overlap^2')
+      end
+    end
+
+    context 'without an overlap boost' do
+      before do
+        facet_config.overlap_boost = nil
+      end
+
+      it 'does not apply overlapRatio when Settings.OVERLAP_RATIO_BOOST not configured' do
+        expect(bbox_filter_query.relevancy_boost).not_to have_key(:overlap)
+      end
+    end
+
+    context 'when local boost parameter is present' do
+      before do
+        solr_params[:bf] = ['local_boost^5']
+        facet_config.overlap_boost = 2
+      end
+
+      it 'appends overlap and includes the local boost' do
+        expect(bbox_filter_query.relevancy_boost[:bf].to_s).to include('$overlap^2')
+        expect(bbox_filter_query.relevancy_boost[:bf].to_s).to include('local_boost^5')
+      end
+    end
+  end
+
+  describe '#intersects_filter' do
+    it 'returns an Intersects query' do
+      expect(bbox_filter_query.intersects_filter).to include('Intersects')
+    end
+  end
+end

data/spec/models/concerns/geoblacklight/solr_document/inspection_spec.rb

@@ -2,7 +2,8 @@
 require 'spec_helper'
 
 describe Geoblacklight::SolrDocument::Inspection do
-  let(:subject) { SolrDocument.new }
+  subject { SolrDocument.new }
+
   describe '#inspectable?' do
     it 'returns true for wms viewer protocol' do
       expect(subject).to receive(:viewer_protocol).and_return('wms')

data/spec/models/concerns/geoblacklight/suppressed_records_search_behavior_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Geoblacklight::SuppressedRecordsSearchBehavior do
+  subject(:searcher) { search_builder.with(user_params) }
+
+  let(:user_params) { {} }
+  let(:solr_params) { { q: 'water' } }
+  let(:blacklight_config) { CatalogController.blacklight_config.deep_copy }
+  let(:context) { CatalogController.new }
+  let(:search_builder_class) do
+    Class.new(Blacklight::SearchBuilder).tap do |klass|
+      include Blacklight::Solr::SearchBuilderBehavior
+      klass.include(described_class)
+    end
+  end
+  let(:search_builder) { search_builder_class.new(context) }
+
+  describe '#hide_suppressed_records' do
+    it 'hides/filters suppressed records' do
+      expect(searcher.hide_suppressed_records(solr_params)).to include('-gbl_suppressed_b: true')
+    end
+  end
+
+  context 'when document action call like CatalogController#web_services' do
+    it 'does not hide/filter suppressed records' do
+      solr_params[:q] = "{!lucene}#{Settings.FIELDS.ID}:"
+      expect(searcher.hide_suppressed_records(solr_params)).to be_nil
+    end
+  end
+end

data/spec/presenters/geoblacklight/bbox_item_presenter_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Geoblacklight::BboxItemPresenter, 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) }
+  let(:controller) { CatalogController.new }
+
+  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 bbox' do
+      let(:facet_item) { Geoblacklight::BoundingBox.new(-160, -80, 120, 70) }
+
+      it 'translates the bbox into some nice, human-readable html' do
+        expect(Capybara.string(presenter.label))
+          .to have_text('-160 -80 120 70')
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -4,8 +4,8 @@ ENV['RAILS_ENV'] ||= 'test'
 require 'simplecov'
 SimpleCov.formatter = SimpleCov::Formatter::HTMLFormatter
 
-if ENV['CIRCLE_ARTIFACTS']
-  dir = File.join(ENV['CIRCLE_ARTIFACTS'], 'coverage')
+if ENV.fetch('CIRCLE_ARTIFACTS', false)
+  dir = File.join(ENV.fetch('CIRCLE_ARTIFACTS'), 'coverage')
   SimpleCov.coverage_dir(dir)
 end
 
@@ -16,6 +16,7 @@ SimpleCov.start 'rails' do
   add_filter 'lib/tasks/geoblacklight.rake'
   add_filter '/spec'
   add_filter '.internal_test_app/'
+  minimum_coverage 100
 end
 
 require 'factory_bot'
@@ -30,6 +31,10 @@ require 'capybara/rspec'
 require 'selenium-webdriver'
 require 'webdrivers'
 
+# Setup webmock for specific tests
+require 'webmock/rspec'
+WebMock.allow_net_connect!(net_http_connect_on_start: true)
+
 Capybara.register_driver(:headless_chrome) do |app|
   Capybara::Selenium::Driver.load_selenium
   browser_options = ::Selenium::WebDriver::Chrome::Options.new.tap do |opts|
@@ -43,7 +48,7 @@ Capybara.register_driver(:headless_chrome) do |app|
   Capybara::Selenium::Driver.new(app,
                                  browser: :chrome,
                                  http_client: http_client,
-                                 options: browser_options)
+                                 capabilities: [browser_options])
 end
 
 Capybara.javascript_driver = :headless_chrome

data/spec/test_app_templates/Gemfile.extra

@@ -1,2 +1,3 @@
 gem 'sprockets', '< 4'
 gem 'view_component', '!= 2.26.0'
+gem 'faraday', ENV["FARADAY_VERSION"].to_s != "" ? ENV["FARADAY_VERSION"] : '>= 1.0'

data/spec/test_app_templates/lib/generators/test_app_generator.rb

@@ -20,6 +20,10 @@ class TestAppGenerator < Rails::Generators::Base
     end
   end
 
+  def install_webpacker
+    run 'bundle exec rails webpacker:install'
+  end
+
   def run_blacklight_generator
     say_status('warning', 'GENERATING BL', :yellow)
 
@@ -30,10 +34,6 @@ class TestAppGenerator < Rails::Generators::Base
     generate 'geoblacklight:install', '-f'
   end
 
-  def integrate_webpacker
-    generate 'geoblacklight:webpacker', '-f'
-  end
-
   def fixtures
     FileUtils.mkdir_p 'spec/fixtures/solr_documents'
     directory 'solr_documents', 'spec/fixtures/solr_documents'

data/spec/views/catalog/_results_pagination.html.erb_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 require 'spec_helper'
 
-describe 'catalog/_results_pagination.html.erb', type: :view do
+describe 'catalog/_results_pagination', type: :view do
   it 'will have a #pagination wrapping div' do
     allow(view).to receive_messages(show_pagination?: false)
     render

data/spec/views/catalog/_show_downloads.html.erb_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 require 'spec_helper'
 
-describe 'catalog/_show_downloads.html.erb', type: :view do
+describe 'catalog/_show_downloads', type: :view do
   context 'document is downloadable' do
     let(:document) { instance_double(SolrDocument) }
     before do
@@ -13,18 +13,18 @@ describe 'catalog/_show_downloads.html.erb', type: :view do
       allow(document).to receive(:iiif_download).and_return({})
       allow(document).to receive(:download_types).and_return(shapefile: {})
     end
-    it 'renders the button group with primary and generated partials' do
+
+    it 'renders the downloads collapse partial' do
       expect(view).to receive(:document_downloadable?).and_return(true)
 
-      stub_template 'catalog/_downloads_primary.html.erb' => 'stubbed_primary_downloads'
-      stub_template 'catalog/_downloads_generated.html.erb' => 'stubbed_generated_downloads'
+      stub_template 'catalog/_downloads_collapse.html.erb' => 'stubbed_downloads_collapse'
 
       render
 
-      expect(rendered).to have_content 'stubbed_primary_downloads'
-      expect(rendered).to have_content 'stubbed_generated_downloads'
+      expect(rendered).to have_content 'stubbed_downloads_collapse'
     end
   end
+
   context 'document is not downloadable' do
     let(:document) { instance_double(SolrDocument, restricted?: true, same_institution?: true) }
     before do

data/template.rb

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
 gem 'blacklight', '~> 7.0'
-gem 'geoblacklight', '~> 3.0'
-gem 'webpacker' unless Rails.version.to_s.start_with? '6.1.'
+gem 'geoblacklight', '~> 4.0'
 gem 'sprockets', '< 4.0' # Use sprockets less than 4.0, let webpacker users set this up themselves
 
 # Hack for https://github.com/rails/rails/issues/35153
 # Adapted from https://github.com/projectblacklight/blacklight/pull/2065
 gemfile = File.expand_path('Gemfile')
-IO.write(gemfile, File.open(gemfile) do |f|
+File.write(gemfile, File.open(gemfile) do |f|
   text = f.read
   text.gsub(/^gem 'sqlite3'$/, 'gem "sqlite3", "~> 1.3.6"')
 end)
@@ -16,6 +15,5 @@ run 'bundle install'
 
 generate 'blacklight:install', '--devise'
 generate 'geoblacklight:install', '-f'
-generate 'geoblacklight:webpacker', '-f'
 
 rake 'db:migrate'

data/vendor/assets/javascripts/Leaflet.fullscreen.js

@@ -0,0 +1,152 @@
+L.Control.Fullscreen = L.Control.extend({
+    options: {
+        position: 'topleft',
+        title: {
+            'false': 'View Fullscreen',
+            'true': 'Exit Fullscreen'
+        }
+    },
+
+    onAdd: function (map) {
+        var container = L.DomUtil.create('div', 'leaflet-control-fullscreen leaflet-bar leaflet-control');
+
+        this.link = L.DomUtil.create('a', 'leaflet-control-fullscreen-button leaflet-bar-part', container);
+        this.link.href = '#';
+
+        this._map = map;
+        this._map.on('fullscreenchange', this._toggleTitle, this);
+        this._toggleTitle();
+
+        L.DomEvent.on(this.link, 'click', this._click, this);
+
+        return container;
+    },
+
+    _click: function (e) {
+        L.DomEvent.stopPropagation(e);
+        L.DomEvent.preventDefault(e);
+        this._map.toggleFullscreen(this.options);
+    },
+
+    _toggleTitle: function() {
+        this.link.title = this.options.title[this._map.isFullscreen()];
+    }
+});
+
+L.Map.include({
+    isFullscreen: function () {
+        return this._isFullscreen || false;
+    },
+
+    toggleFullscreen: function (options) {
+        var container = this.getContainer();
+        if (this.isFullscreen()) {
+            if (options && options.pseudoFullscreen) {
+                this._disablePseudoFullscreen(container);
+            } else if (document.exitFullscreen) {
+                document.exitFullscreen();
+            } else if (document.mozCancelFullScreen) {
+                document.mozCancelFullScreen();
+            } else if (document.webkitCancelFullScreen) {
+                document.webkitCancelFullScreen();
+            } else if (document.msExitFullscreen) {
+                document.msExitFullscreen();
+            } else {
+                this._disablePseudoFullscreen(container);
+            }
+        } else {
+            if (options && options.pseudoFullscreen) {
+                this._enablePseudoFullscreen(container);
+            } else if (container.requestFullscreen) {
+                container.requestFullscreen();
+            } else if (container.mozRequestFullScreen) {
+                container.mozRequestFullScreen();
+            } else if (container.webkitRequestFullscreen) {
+                container.webkitRequestFullscreen(Element.ALLOW_KEYBOARD_INPUT);
+            } else if (container.msRequestFullscreen) {
+                container.msRequestFullscreen();
+            } else {
+                this._enablePseudoFullscreen(container);
+            }
+        }
+
+    },
+
+    _enablePseudoFullscreen: function (container) {
+        L.DomUtil.addClass(container, 'leaflet-pseudo-fullscreen');
+        this._setFullscreen(true);
+        this.fire('fullscreenchange');
+    },
+
+    _disablePseudoFullscreen: function (container) {
+        L.DomUtil.removeClass(container, 'leaflet-pseudo-fullscreen');
+        this._setFullscreen(false);
+        this.fire('fullscreenchange');
+    },
+
+    _setFullscreen: function(fullscreen) {
+        this._isFullscreen = fullscreen;
+        var container = this.getContainer();
+        if (fullscreen) {
+            L.DomUtil.addClass(container, 'leaflet-fullscreen-on');
+        } else {
+            L.DomUtil.removeClass(container, 'leaflet-fullscreen-on');
+        }
+        this.invalidateSize();
+    },
+
+    _onFullscreenChange: function (e) {
+        var fullscreenElement =
+            document.fullscreenElement ||
+            document.mozFullScreenElement ||
+            document.webkitFullscreenElement ||
+            document.msFullscreenElement;
+
+        if (fullscreenElement === this.getContainer() && !this._isFullscreen) {
+            this._setFullscreen(true);
+            this.fire('fullscreenchange');
+        } else if (fullscreenElement !== this.getContainer() && this._isFullscreen) {
+            this._setFullscreen(false);
+            this.fire('fullscreenchange');
+        }
+    }
+});
+
+L.Map.mergeOptions({
+    fullscreenControl: false
+});
+
+L.Map.addInitHook(function () {
+    if (this.options.fullscreenControl) {
+        this.fullscreenControl = new L.Control.Fullscreen(this.options.fullscreenControl);
+        this.addControl(this.fullscreenControl);
+    }
+
+    var fullscreenchange;
+
+    if ('onfullscreenchange' in document) {
+        fullscreenchange = 'fullscreenchange';
+    } else if ('onmozfullscreenchange' in document) {
+        fullscreenchange = 'mozfullscreenchange';
+    } else if ('onwebkitfullscreenchange' in document) {
+        fullscreenchange = 'webkitfullscreenchange';
+    } else if ('onmsfullscreenchange' in document) {
+        fullscreenchange = 'MSFullscreenChange';
+    }
+
+    if (fullscreenchange) {
+        var onFullscreenChange = L.bind(this._onFullscreenChange, this);
+
+        this.whenReady(function () {
+            L.DomEvent.on(document, fullscreenchange, onFullscreenChange);
+        });
+
+        this.on('unload', function () {
+            L.DomEvent.off(document, fullscreenchange, onFullscreenChange);
+        });
+    }
+});
+
+L.control.fullscreen = function (options) {
+    return new L.Control.Fullscreen(options);
+};