geoblacklight 6.0.0.pre.alpha.3 → 6.0.0.pre.alpha.5

data/lib/geoblacklight/references.rb

@@ -43,34 +43,6 @@ module Geoblacklight
       @refs.find { |reference| reference.type == ref_type }
     end
 
-    ##
-    # Preferred download (should be a file download)
-    # @return [Hash, nil]
-    def preferred_download
-      file_download if download.present?
-    end
-
-    ##
-    # Download hash based off of format type
-    # @return [Hash, nil]
-    def downloads_by_format
-      case format
-      when "Shapefile"
-        vector_download_formats
-      when "GeoTIFF"
-        geotiff_download_formats
-      when "ArcGRID"
-        arcgrid_download_formats
-      end
-    end
-
-    ##
-    # Generated download types from wxs services
-    # @return (see #downloads_by_format)
-    def download_types
-      downloads_by_format
-    end
-
     ##
     # Returns all of the Esri webservices for given set of references
     def esri_webservices
@@ -92,58 +64,6 @@ module Geoblacklight
       end
     end
 
-    ##
-    # Download hash for a static file download
-    # @return (see #downloads_by_format)
-    def file_download
-      {file_download: download.to_hash}
-    end
-
-    ##
-    # Download hash for a Shapefile file (currently only vector) with a wms and wfs reference
-    # present
-    # @return (see #downloads_by_format)
-    def vector_download_formats
-      return unless wms.present? && wfs.present?
-
-      download_formats = {}
-      format_list.each { |format| download_formats.merge!(web_service_hash(format)) }
-      download_formats
-    end
-
-    def format_list
-      Geoblacklight.configuration.vector_download_formats || []
-    end
-
-    def web_service_hash(format)
-      case format
-      when "Shapefile"
-        {shapefile: wfs.to_hash}
-      when "KMZ"
-        {kmz: wms.to_hash}
-      when "GeoJSON"
-        {geojson: wfs.to_hash}
-      when "CSV"
-        {csv: wfs.to_hash}
-      else
-        {}
-      end
-    end
-
-    ##
-    # Download hash for a GeoTiff file with a WMS reference present
-    # @return (see #downloads_by_format)
-    def geotiff_download_formats
-      {geotiff: wms.to_hash} if wms.present?
-    end
-
-    ##
-    # Download hash for an ArcGRID file with a WMS reference present
-    # @return (see #downloads_by_format)
-    def arcgrid_download_formats
-      {geotiff: wms.to_hash} if wms.present?
-    end
-
     ##
     # Adds a call to references for defined URI keys
     def method_missing(m, *args, &b)

data/lib/geoblacklight/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Geoblacklight
-  VERSION = "6.0.0-alpha.3"
+  VERSION = "6.0.0-alpha.5"
 end

data/lib/geoblacklight.rb

@@ -3,7 +3,6 @@
 require "zeitwerk"
 loader = Zeitwerk::Loader.for_gem
 loader.ignore("#{__dir__}/generators")
-loader.collapse("#{__dir__}/geoblacklight/download")
 loader.collapse("#{__dir__}/geoblacklight/wms_layer")
 loader.setup
 require "geoblacklight/engine"

data/lib/tasks/geoblacklight.rake

@@ -51,36 +51,6 @@ namespace :geoblacklight do
     end
   end
 
-  namespace :downloads do
-    desc "Delete all cached downloads"
-    task delete: :environment do
-      FileUtils.rm_rf Dir.glob(Rails.root.join("tmp", "cache", "downloads", "*"))
-    end
-    desc "Create download directory"
-    task mkdir: :environment do
-      FileUtils.mkdir_p(Rails.root.join("tmp", "cache", "downloads"), verbose: true)
-    end
-    desc "Precaches a download"
-    task :precache, %i[doc_id download_type timeout] => [:environment] do |_t, args|
-      unless args[:doc_id] && args[:download_type] && args[:timeout]
-        raise "Please supply required arguments [document_id, download_type and timeout]"
-      end
-
-      document = Geoblacklight::SolrDocument.find(args[:doc_id])
-      raise Blacklight::Exceptions::RecordNotFound if document[:id] != args[:doc_id]
-
-      download = "Geoblacklight::#{args[:download_type].capitalize}Download"
-        .constantize.new(document, timeout: args[:timeout].to_i)
-      download.get
-      Rails.logger.info "Successfully downloaded #{download.file_name}"
-      Rails.logger.info Geoblacklight::ShapefileDownload.file_path.to_s
-    rescue Geoblacklight::Exceptions::ExternalDownloadFailed => e
-      Rails.logger.error e.message + " " + e.url
-    rescue NameError
-      Rails.logger.error "Could not find that download type \"#{args[:download_type]}\""
-    end
-  end
-
   desc "Stdout output asset paths"
   task application_asset_paths: [:environment] do
     puts Rails.application.config.assets.paths

data/spec/components/geoblacklight/document/sidebar_component_spec.rb

@@ -10,7 +10,7 @@ RSpec.describe Geoblacklight::Document::SidebarComponent, type: :component do
   let(:document) { SolrDocument.new(JSON.parse(read_fixture(fixture))) }
 
   before do
-    allow_any_instance_of(Geoblacklight::DownloadLinksComponent).to receive(:render?).and_return(false)
+    allow_any_instance_of(Geoblacklight::Document::DownloadLinksComponent).to receive(:render?).and_return(false)
     allow_any_instance_of(Geoblacklight::LoginLinkComponent).to receive(:render?).and_return(false)
 
     allow(document).to receive(:more_like_this).and_return([])

data/spec/components/geoblacklight/download_links_component_spec.rb

@@ -2,123 +2,97 @@
 
 require "spec_helper"
 
-RSpec.describe Geoblacklight::DownloadLinksComponent, type: :component do
+RSpec.describe Geoblacklight::Document::DownloadLinksComponent, type: :component do
   let(:downloadable) { true }
-  let(:document) { instance_double(SolrDocument, id: 123, downloadable?: downloadable) }
-  let(:component) { described_class.new(document: document) }
+  let(:direct_download) { nil }
+  let(:iiif_download) { nil }
+  let(:file_format) { nil }
+  let(:iiif_manifest) { nil }
+  let(:references) { instance_double("References", iiif_manifest: iiif_manifest) }
+  let(:document) do
+    instance_double(
+      SolrDocument, id: 123,
+      downloadable?: downloadable,
+      direct_download: direct_download,
+      iiif_download: iiif_download,
+      file_format: file_format,
+      references: references
+    )
+  end
+  subject(:component) { described_class.new(document: document) }
 
   before do
     allow_any_instance_of(GeoblacklightHelper).to receive(:document_available?).and_return(true)
+    render_inline(component)
   end
 
-  context "when rendering is required" do
-    before do
-      allow(document).to receive(:direct_download).and_return(test: :test)
-      allow(document).to receive(:iiif_download).and_return({})
-      allow(document).to receive(:download_types).and_return(shapefile: {})
-    end
+  context "when not downloadable" do
+    let(:downloadable) { false }
 
-    it "shows download link" do
-      render_inline(component)
-      expect(page).to have_text("Download")
-      expect(page).to have_text("Export Shapefile")
+    it "does not render the component" do
+      is_expected.to_not be_render
     end
   end
 
-  context "when rendering is not required" do
-    context "because there are no download links" do
-      before do
-        allow(document).to receive(:direct_download).and_return({})
-        allow(document).to receive(:iiif_download).and_return({})
-        allow(document).to receive(:download_types).and_return({})
-      end
-
-      it "does not render anything" do
-        render_inline(component)
-        expect(page).not_to have_text("Download")
-        expect(page).not_to have_text("Export Shapefile")
-      end
+  context "with no download links and no IIIF links" do
+    it "does not render the component" do
+      is_expected.to_not be_render
     end
+  end
 
-    context "because you aren't allowed" do
-      let(:downloadable) { false }
+  context "with a single bare link" do
+    let(:direct_download) { {download: "file.zip"} }
+    let(:file_format) { "Shapefile" }
 
-      it "does not render anything" do
-        render_inline(component)
-        expect(page).not_to have_text("Download")
-        expect(page).not_to have_text("Export Shapefile")
-      end
+    it "renders a download link using the format to label it" do
+      expect(page).to have_link("Original Shapefile", href: "file.zip")
     end
-  end
-
-  describe "#download_link_file" do
-    let(:label) { "Test Link Text" }
-    let(:id) { "test-id" }
-    let(:url) { "http://example.com/urn:hul.harvard.edu:HARVARD.SDE2.TG10USAIANNH/data.zip" }
 
-    it "generates a link to download the original file" do
-      expect(component.download_link_file(label, id,
-        url)).to eq '<a contentUrl="http://example.com/urn:hul.harvard.edu:HARVARD.SDE2.TG10USAIANNH/data.zip" data-download="trigger" data-download-type="direct" data-download-id="test-id" href="http://example.com/urn:hul.harvard.edu:HARVARD.SDE2.TG10USAIANNH/data.zip">Test Link Text</a>'
+    it "renders a badge indicating the actual file type" do
+      expect(page).to have_css(".badge", text: "ZIP")
     end
   end
 
-  describe "#download_link_iiif" do
-    let(:references_field) { Geoblacklight.configuration.fields.references }
-    let(:document_attributes) do
-      {
-        references_field => {
-          "http://iiif.io/api/image" => "https://example.edu/image/info.json"
-        }.to_json
-      }
-    end
-    let(:document) { SolrDocument.new(document_attributes, downloadable?: downloadable) }
+  context "with multiple labelled download links available" do
+    let(:direct_download) { {download: [{"label" => "File 1", "url" => "file.zip"}, {"label" => "File 2", "url" => "file2.json"}]} }
 
-    before do
-      allow(component).to receive(:download_text).and_return("Original JPG")
-      allow_any_instance_of(Geoblacklight::Reference).to receive(:to_hash).and_return(iiif: "https://example.edu/image/info.json")
+    it "renders a labelled download link for each" do
+      expect(page).to have_link("File 1", href: "file.zip")
+      expect(page).to have_css(".badge", text: "ZIP")
+      expect(page).to have_link("File 2", href: "file2.json")
+      expect(page).to have_css(".badge", text: "JSON")
     end
+  end
+
+  context "with a IIIF link" do
+    let(:iiif_download) { {iiif: "https://example.edu/image/info.json"} }
 
     it "generates a link to download the JPG file from the IIIF server" do
-      expect(component.download_link_iiif).to eq '<a contentUrl="https://example.edu/image/full/full/0/default.jpg" data-download="trigger" href="https://example.edu/image/full/full/0/default.jpg">Original JPG</a>'
+      expect(page).to have_link(href: "https://example.edu/image/full/full/0/default.jpg")
     end
   end
 
-  describe "#iiif_jpg_url" do
-    let(:references_field) { Geoblacklight.configuration.fields.references }
-    let(:document_attributes) do
-      {
-        references_field => {
-          "http://iiif.io/api/image" => "https://example.edu/image/info.json"
-        }.to_json
-      }
-    end
-    let(:document) { SolrDocument.new(document_attributes) }
+  context "with a IIIF manifest link" do
+    let(:iiif_manifest) { instance_double("IIIFManifest", endpoint: "https://example.edu/manifest.json") }
 
-    it "returns JPG download URL when given URL to a IIIF info.json" do
-      expect(component.iiif_jpg_url).to eq "https://example.edu/image/full/full/0/default.jpg"
+    it "generates a link to download the IIIF manifest" do
+      expect(page).to have_link(href: "https://example.edu/manifest.json")
     end
   end
 
-  describe "#download_link_generated" do
-    let(:download_type) { "SHAPEFILE" }
+  context "with a generated download via WFS link" do
+    let(:direct_download) { {download: "https://geoportal.icpac.net/geoserver/ows?service=WFS&version=1.0.0&request=GetFeature&typename=geonode%3Aa__2010_TC_Bandu0&outputFormat=json&srs=EPSG%3A4326&srsName=EPSG%3A4326"} }
 
-    before do
-      allow(component).to receive(:download_path).and_return("/download/test-id?type=SHAPEFILE")
-      allow(component).to receive(:export_format_label).and_return("Shapefile Export Customization")
-      allow(document).to receive(:id).and_return("test-id")
-      allow(document).to receive(:to_s).and_return("test-id")
+    it "renders a download link with the inferred file type" do
+      expect(page).to have_link("Generated JSON", href: "https://geoportal.icpac.net/geoserver/ows?service=WFS&version=1.0.0&request=GetFeature&typename=geonode%3Aa__2010_TC_Bandu0&outputFormat=json&srs=EPSG%3A4326&srsName=EPSG%3A4326")
     end
+  end
 
-    it "generates a link to download the JPG file from the IIIF server" do
-      # Stub I18n to ensure the link can be customized via `export_` labels.
-      allow(component).to receive(:t).with("geoblacklight.download.export_shapefile_link").and_return("Shapefile Export Customization")
-      allow(component).to receive(:t).with("geoblacklight.download.export_link",
-        {download_format: "Shapefile Export Customization"}).and_return("Export Shapefile Export Customization")
-      allow(component).to receive(:t).with("geoblacklight.download.preparing").and_return("Preparing download...")
-      allow(component).to receive(:t).with("geoblacklight.download.ready", {type: "SHAPEFILE"}).and_return("Download ready (SHAPEFILE)")
-      allow(component).to receive(:t).with("geoblacklight.download.failed", {type: "SHAPEFILE"}).and_return("Download failed (SHAPEFILE)")
-      expect(component.download_link_generated(download_type,
-        document)).to eq '<a data-download-path="/download/test-id?type=SHAPEFILE" data-download="trigger" data-action="downloads#download:once" data-download-type="SHAPEFILE" data-download-id="test-id" data-download-preparing-message="Preparing download..." data-download-ready-message="Download ready (SHAPEFILE)" data-download-failed-message="Download failed (SHAPEFILE)" href="">Export Shapefile Export Customization</a>'
+  context "with a generated download using the format parameter" do
+    let(:direct_download) { {download: "https://example.edu/file?format=CSV"} }
+
+    it "renders a download link with the inferred file type" do
+      expect(page).to have_link("Generated CSV", href: "https://example.edu/file?format=CSV")
     end
   end
 end

data/spec/features/index_view_spec.rb

@@ -21,32 +21,6 @@ RSpec.feature "Index view", js: true do
     expect(page).to have_css("#per_page-dropdown")
   end
 
-  scenario "should have facets listed correctly" do
-    skip "Capybara thinks elements are not visible or interactable, but they are"
-
-    within "#facet-panel-collapse", visible: :all do
-      expect(page).to have_css("div.card.facet-limit", text: "Year", visible: :all)
-      expect(page).to have_css("div.card.facet-limit", text: "Place", visible: :all)
-      expect(page).to have_css("div.card.facet-limit", text: "Access", visible: :all)
-      expect(page).to have_css("div.card.facet-limit", text: "Resource Class", visible: :all)
-      expect(page).to have_css("div.card.facet-limit", text: "Resource Type", visible: :all)
-      expect(page).to have_css("div.card.facet-limit", text: "Format", visible: :all)
-      expect(page).to have_css("div.card.facet-limit", text: "Subject", visible: :all)
-      expect(page).to have_css("div.card.facet-limit", text: "Theme", visible: :all)
-      expect(page).to have_css("div.card.facet-limit", text: "Creator", visible: :all)
-      expect(page).to have_css("div.card.facet-limit", text: "Publisher", visible: :all)
-      expect(page).to have_css("div.card.facet-limit", text: "Provider", visible: :all)
-      expect(page).to have_css("div.card.facet-limit", text: "Georeferenced", visible: :all)
-    end
-
-    click_button "Provider", visible: :all
-
-    expect(page).to have_css("a.facet-select", text: "University of Minnesota", visible: :all)
-    expect(page).to have_css("a.facet-select", text: "MIT", visible: :all)
-    expect(page).to have_css("a.facet-select", text: "Stanford", visible: :all)
-    expect(page).to have_css(".more_facets a", text: /more\sProvider\s»/, visible: :all)
-  end
-
   scenario "hover on record should produce bounding box on map" do
     # Needed to find an svg element on the page
     visit search_catalog_path(f: {Geoblacklight.configuration.fields.provider => ["Stanford"]})
@@ -66,13 +40,6 @@ RSpec.feature "Index view", js: true do
     end
   end
 
-  scenario "spatial search should reset to page one" do
-    skip "FIXME: Only works with a headful browser?"
-    visit "/?per_page=5&q=%2A&page=2"
-    find("#leaflet-viewer").double_click
-    expect(page).to have_css ".page-entries", text: /^1 - 5 of \d.*$/
-  end
-
   scenario "clicking map search should retain current search parameters" do
     visit "/?f[#{subject_field}][]=Population"
     find("#leaflet-viewer").double_click

data/spec/features/layer_inspection_spec.rb

@@ -9,14 +9,4 @@ RSpec.feature "Layer inspection", js: true do
     find("#leaflet-viewer").click
     expect(page).not_to have_css("td.default-text")
   end
-
-  context "with a pmtiles layer" do
-    scenario "clicking map should trigger inspection" do
-      skip "FIXME: Only works with a headful browser?"
-      visit solr_document_path("princeton-t722hd30j")
-      expect(page).to have_css("th", text: "Attribute")
-      find("#openlayers-viewer").click
-      expect(page).not_to have_css("td.default-text")
-    end
-  end
 end

data/spec/features/layer_opacity_spec.rb

@@ -9,13 +9,6 @@ RSpec.feature "Layer opacity", js: true do
     expect(page.all("div.leaflet-layer")[1][:style]).to match(/opacity: 0.75;/)
   end
 
-  scenario "ESRI image service layer should have opacity control" do
-    skip "CORS error - Purdue web services are down"
-    visit solr_document_path("32653ed6-8d83-4692-8a06-bf13ffe2c018")
-    expect(page).to have_css("div.opacity-text", text: "75%")
-    expect(page.find("img.leaflet-image-layer", match: :first)[:style]).to match(/opacity: 0.75;/)
-  end
-
   scenario "IIIF layer should not have opacity control" do
     visit solr_document_path("princeton-02870w62c")
     expect(page).not_to have_css("div.opacity-text", text: "75%")

data/spec/helpers/geoblacklight_helper_spec.rb

@@ -87,7 +87,7 @@ RSpec.describe GeoblacklightHelper, type: :helper do
     context "with multiple values" do
       let(:document) { SolrDocument.new(value: %w[short description]) }
       it "wraps in correct DIV class" do
-        expect(helper.render_value_as_truncate_abstract(document)).to eq '<div class="truncate-abstract" data-read-more-text="Read more" data-close-text="Close">short description</div>'
+        expect(helper.render_value_as_truncate_abstract(document)).to eq '<div class="truncate-abstract" data-read-more-text="Read more" data-close-text="Close"><p>short</p><p>description</p></div>'
       end
     end
   end

data/spec/lib/geoblacklight/configuration/settings_builder_spec.rb

@@ -20,7 +20,6 @@ RSpec.describe Geoblacklight::Configuration::SettingsBuilder do
         {
           institution: "MIT",
           fields: {title: "my_title_s"},
-          download_formats: {vector: ["GeoJSON"]},
           leaflet: {selected_color: "#abc123", sidebar: true}
         }
       end
@@ -31,7 +30,6 @@ RSpec.describe Geoblacklight::Configuration::SettingsBuilder do
 
       it "resolves nested lowercase keys" do
         expect(config.fields.title).to eq("my_title_s")
-        expect(config.vector_download_formats).to eq(["GeoJSON"])
         expect(config.leaflet_options.selected_color).to eq("#abc123")
         expect(config.leaflet_options.sidebar).to be true
       end

data/spec/lib/geoblacklight/references_spec.rb

@@ -165,29 +165,6 @@ RSpec.describe Geoblacklight::References do
       expect(typical_ogp_shapefile.download).to be_nil
     end
   end
-  describe "preferred_download" do
-    it "returns the direct download if available" do
-      expect(complex_shapefile.preferred_download[:file_download][:download]).to eq "http://example.com/urn:hul.harvard.edu:HARVARD.SDE2.TG10USAIANNH/data.zip"
-      expect(direct_download_only.preferred_download[:file_download][:download]).to eq "http://example.com/layer-id-geotiff.tiff"
-    end
-    it "returns nil if there is no direct download" do
-      expect(typical_ogp_shapefile.preferred_download).to be_nil
-      expect(typical_ogp_geotiff.preferred_download).to be_nil
-    end
-  end
-  describe "download_types" do
-    it "returns available downloads by format" do
-      types = complex_shapefile.download_types
-      expect(types.first[1]).to eq wfs: "http://hgl.harvard.edu:8080/geoserver/wfs"
-      expect(types.count).to eq 4
-      expect(direct_download_only.download_types).to be_nil
-    end
-    it "onlies return available downloads if no direct is present" do
-      types = typical_ogp_shapefile.download_types
-      expect(types.first[1]).to eq wfs: "http://hgl.harvard.edu:8080/geoserver/wfs"
-      expect(types.count).to eq 4
-    end
-  end
   describe "#esri_webservices" do
     it "returns webservices that are esri specific" do
       expect(some_esri_services.esri_webservices.length).to eq 3
@@ -201,7 +178,7 @@ RSpec.describe Geoblacklight::References do
   describe "#respond_to_missing?" do
     context "with a valid method" do
       it "returns true" do
-        expect(typical_ogp_shapefile.respond_to?(:download_types)).to be true
+        expect(typical_ogp_shapefile.respond_to?(:esri_webservices)).to be true
       end
     end
     context "with a invalid method" do
@@ -210,37 +187,4 @@ RSpec.describe Geoblacklight::References do
       end
     end
   end
-  describe "downloads_by_format" do
-    context "using default settings for vector download formats" do
-      it "returns shapefile" do
-        expect(typical_ogp_shapefile.downloads_by_format.count).to eq 4
-        expect(typical_ogp_shapefile.downloads_by_format[:csv][:wfs]).to eq "http://hgl.harvard.edu:8080/geoserver/wfs"
-        expect(typical_ogp_shapefile.downloads_by_format[:geojson][:wfs]).to eq "http://hgl.harvard.edu:8080/geoserver/wfs"
-        expect(typical_ogp_shapefile.downloads_by_format[:kmz][:wms]).to eq "http://hgl.harvard.edu:8080/geoserver/wms"
-        expect(typical_ogp_shapefile.downloads_by_format[:shapefile][:wfs]).to eq "http://hgl.harvard.edu:8080/geoserver/wfs"
-      end
-      it "returns geotiff" do
-        expect(typical_ogp_geotiff.downloads_by_format.count).to eq 1
-        expect(typical_ogp_geotiff.downloads_by_format[:geotiff][:wms]).to eq "http://hgl.harvard.edu:8080/geoserver/wms"
-      end
-      it "returns arcgrid as geotiff" do
-        expect(typical_arcgrid.downloads_by_format.count).to eq 1
-        expect(typical_arcgrid.downloads_by_format[:geotiff][:wms]).to eq "http://hgl.harvard.edu:8080/geoserver/wms"
-      end
-      it "does not return shapefile if wms and wfs are not present" do
-        expect(no_service_shapefile.downloads_by_format).to be_nil
-      end
-      it "does not return GeoTIFF if wms is not present" do
-        expect(direct_download_only.downloads_by_format).to be_nil
-      end
-    end
-    context "using custom settings which include incorrect settings" do
-      before do
-        allow(typical_ogp_shapefile).to receive(:format_list).and_return(["noformat"])
-      end
-      it "returns no formats for download" do
-        expect(typical_ogp_shapefile.downloads_by_format.count).to eq 0
-      end
-    end
-  end
 end

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

@@ -105,13 +105,6 @@ RSpec.describe Geoblacklight::SolrDocument do
       expect(document.references).to be_an Geoblacklight::References
     end
   end
-  describe "download_types" do
-    let(:document_attributes) { {} }
-    it "calls download_types" do
-      expect_any_instance_of(Geoblacklight::References).to receive(:download_types)
-      document.download_types
-    end
-  end
   describe "direct_download" do
     let(:document_attributes) { {} }
     describe "with a direct download" do

data/template.rb

@@ -10,7 +10,7 @@ end
 run "bundle install"
 
 after_bundle do
-  generate "blacklight:install", ENV.fetch("BLACKLIGHT_INSTALL_OPTIONS", "--devise --skip-solr")
+  generate "blacklight:install", ENV.fetch("BLACKLIGHT_INSTALL_OPTIONS", "--devise")
   generate "geoblacklight:install"
   rails_command "db:migrate"
 end