geoblacklight 6.0.0.pre.alpha.1 → 6.0.0.pre.alpha.2

data/lib/geoblacklight/configuration/layer_config.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Geoblacklight
+  class Configuration
+    # Configuration for Leaflet map layer styles.
+    class LayerConfig
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+
+      attribute :color, :string
+      attribute :weight, :integer, default: 1
+      attribute :radius, :integer, default: 4
+      attribute :sr_color_name, :string
+
+      # Supports Hash-like access for backward compatibility
+      # @param [Symbol, String] key
+      def [](key)
+        respond_to?(key) ? send(key) : nil
+      end
+
+      # Returns the attributes as a symbolized hash
+      # @return [Hash]
+      def to_h
+        attributes.symbolize_keys
+      end
+    end
+  end
+end

data/lib/geoblacklight/configuration/leaflet_config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Geoblacklight
   class Configuration
     class LeafletConfig
@@ -13,24 +15,18 @@ module Geoblacklight
 
       DEFAULT_LAYERS_CONFIG = {
         index: {
-          DEFAULT: {
+          DEFAULT: LayerConfig.new(
             color: "#7FCDBB",
-            weight: 1,
-            radius: 4,
             sr_color_name: "Green"
-          },
-          UNAVAILABLE: {
-            weight: 1,
-            radius: 4,
+          ),
+          UNAVAILABLE: LayerConfig.new(
             color: "#EDF8B1",
             sr_color_name: "Yellow"
-          },
-          SELECTED: {
-            weight: 1,
-            radius: 4,
+          ),
+          SELECTED: LayerConfig.new(
             color: "#2C7FB8",
             sr_color_name: "Blue"
-          }
+          )
         }
       }.freeze
 

data/lib/geoblacklight/configuration/leaflet_layers_config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Geoblacklight
   class Configuration
     class LeafletLayersConfig
@@ -6,15 +8,25 @@ module Geoblacklight
 
       attribute :detect_retina, :boolean, default: true
 
-      attr_accessor :index
+      attr_reader :index
 
       def initialize(attributes = {})
         super
-        @index = attributes[:index]
+        self.index = attributes[:index]
+      end
+
+      def index=(values)
+        @index = (values || {}).transform_values do |val|
+          if val.is_a?(LayerConfig)
+            val
+          else
+            LayerConfig.new(val)
+          end
+        end
       end
 
       def to_h
-        attributes.merge({"index" => index})
+        attributes.merge({"index" => index.transform_values(&:to_h)})
       end
     end
   end

data/lib/geoblacklight/configuration/relationship_config.rb

@@ -0,0 +1,15 @@
+module Geoblacklight
+  class Configuration
+    # Configuration for an individual relationship displayed on a document's show page.
+    class RelationshipConfig
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+
+      attribute :field, :string
+      attribute :icon, :string
+      attribute :inverse, :string
+      attribute :label, :string
+      attribute :query_type, :string
+    end
+  end
+end

data/lib/geoblacklight/configuration/relationships_config.rb

@@ -0,0 +1,123 @@
+module Geoblacklight
+  class Configuration
+    # Hash-like configuration for the relationships displayed on a document's
+    # show page. By default it carries all of the relationships defined in the
+    # RELATIONSHIPS_SHOWN section of settings.yml, using lowercase keys.
+    class RelationshipsConfig
+      include Enumerable
+
+      DEFAULT_RELATIONSHIPS = {
+        member_of_ancestors: {
+          field: "pcdm_memberOf_sm",
+          icon: "parent-item",
+          inverse: :member_of_descendants,
+          label: "geoblacklight.relations.member_of_ancestors",
+          query_type: "ancestors"
+        },
+        member_of_descendants: {
+          field: "pcdm_memberOf_sm",
+          icon: "child-item",
+          inverse: :member_of_ancestors,
+          label: "geoblacklight.relations.member_of_descendants",
+          query_type: "descendants"
+        },
+        part_of_ancestors: {
+          field: "dct_isPartOf_sm",
+          icon: "parent-item",
+          inverse: :part_of_descendants,
+          label: "geoblacklight.relations.part_of_ancestors",
+          query_type: "ancestors"
+        },
+        part_of_descendants: {
+          field: "dct_isPartOf_sm",
+          icon: "child-item",
+          inverse: :part_of_ancestors,
+          label: "geoblacklight.relations.part_of_descendants",
+          query_type: "descendants"
+        },
+        relation_ancestors: {
+          field: "dct_relation_sm",
+          icon: nil,
+          inverse: :relation_descendants,
+          label: "geoblacklight.relations.relation_ancestors",
+          query_type: "ancestors"
+        },
+        relation_descendants: {
+          field: "dct_relation_sm",
+          icon: nil,
+          inverse: :relation_ancestors,
+          label: "geoblacklight.relations.relation_descendants",
+          query_type: "descendants"
+        },
+        replaces_ancestors: {
+          field: "dct_replaces_sm",
+          icon: nil,
+          inverse: :replaces_descendants,
+          label: "geoblacklight.relations.replaces_ancestors",
+          query_type: "ancestors"
+        },
+        replaces_descendants: {
+          field: "dct_replaces_sm",
+          icon: nil,
+          inverse: :replaces_ancestors,
+          label: "geoblacklight.relations.replaces_descendants",
+          query_type: "descendants"
+        },
+        source_ancestors: {
+          field: "dct_source_sm",
+          icon: "parent-item",
+          inverse: :source_descendants,
+          label: "geoblacklight.relations.source_ancestors",
+          query_type: "ancestors"
+        },
+        source_descendants: {
+          field: "dct_source_sm",
+          icon: "child-item",
+          inverse: :source_ancestors,
+          label: "geoblacklight.relations.source_descendants",
+          query_type: "descendants"
+        },
+        version_of_ancestors: {
+          field: "dct_isVersionOf_sm",
+          icon: "parent-item",
+          inverse: :version_of_descendants,
+          label: "geoblacklight.relations.version_of_ancestors",
+          query_type: "ancestors"
+        },
+        version_of_descendants: {
+          field: "dct_isVersionOf_sm",
+          icon: "child-item",
+          inverse: :version_of_ancestors,
+          label: "geoblacklight.relations.version_of_descendants",
+          query_type: "descendants"
+        }
+      }.freeze
+
+      def initialize(relationships = DEFAULT_RELATIONSHIPS)
+        @relationships = relationships.to_h.transform_values do |attrs|
+          attrs.is_a?(RelationshipConfig) ? attrs : RelationshipConfig.new(attrs)
+        end
+      end
+
+      def each(&block)
+        @relationships.each(&block)
+      end
+
+      def each_key(&block)
+        @relationships.each_key(&block)
+      end
+
+      def key?(key)
+        @relationships.key?(key)
+      end
+
+      def [](key)
+        @relationships[key]
+      end
+
+      def method_missing(name, *args, **kwargs, &block) # rubocop:disable Style/MissingRespondToMissing
+        @relationships.key?(name) ? @relationships[name] : super
+      end
+    end
+  end
+end

data/lib/geoblacklight/configuration/settings_builder.rb

@@ -0,0 +1,118 @@
+module Geoblacklight
+  class Configuration
+    # Builds a configuration from legacy (uppercase) settings
+    class SettingsBuilder
+      def self.build
+        new.build
+      end
+
+      def initialize(settings: Settings)
+        @configuration = Configuration.new
+        @settings = CaseInsensitiveSettings.new(settings, deprecation: Geoblacklight::Deprecation)
+      end
+
+      def build
+        @configuration.tap do |config|
+          assign(config, :arcgis_base_url, settings.ARCGIS_BASE_URL)
+          assign(config, :bbox_within_boost, settings.BBOX_WITHIN_BOOST)
+          assign(config, :overlap_ratio_boost, settings.OVERLAP_RATIO_BOOST)
+          assign(config, :display_notes_shown, build_display_notes)
+          assign(config, :institution, settings.INSTITUTION)
+          assign(config, :help_text, settings.HELP_TEXT&.to_h)
+          assign(config, :sidebar_static_map, settings.SIDEBAR_STATIC_MAP)
+          assign(config, :iiif_drag_drop_link, settings.IIIF_DRAG_DROP_LINK)
+          assign(config, :homepage_map_geom, settings.HOMEPAGE_MAP_GEOM)
+          assign(config, :vector_download_formats, settings.DOWNLOAD_FORMATS&.VECTOR)
+          assign(config, :metadata_shown, settings.METADATA_SHOWN)
+          assign(config, :webservices_shown, settings.WEBSERVICES_SHOWN)
+          assign(config, :relationships_shown, build_relationships)
+          assign(config, :timeout_download, settings.TIMEOUT_DOWNLOAD)
+          assign(config, :download_path, settings.DOWNLOAD_PATH)
+          assign(config, :gbl_params, settings.GBL_PARAMS)
+          assign(config, :wms_params, settings.WMS_PARAMS&.to_h)
+          assign(config, :timeout_wms, settings.TIMEOUT_WMS)
+
+          build_fields(config)
+          build_leaflet_options(config)
+        end
+      end
+
+      private
+
+      attr_reader :settings
+
+      # Assigns the value to the target's attribute unless it is nil, so that
+      # missing settings do not overwrite the defaults provided by Configuration.
+      def assign(target, attribute, value)
+        target.public_send("#{attribute}=", value) unless value.nil?
+      end
+
+      def build_display_notes
+        settings.DISPLAY_NOTES_SHOWN&.to_h&.transform_values do |value|
+          DisplayNoteShownConfig.new(value.to_h)
+        end
+      end
+
+      def build_relationships
+        RelationshipsConfig.new(settings.RELATIONSHIPS_SHOWN.to_h) if settings.RELATIONSHIPS_SHOWN
+      end
+
+      def build_leaflet_options(config)
+        return unless settings.LEAFLET
+
+        assign(config.leaflet_options, :bounds_overlay, settings.LEAFLET.BOUNDSOVERLAY&.to_h)
+        assign(config.leaflet_options, :selected_color, settings.LEAFLET.SELECTED_COLOR)
+        assign(config.leaflet_options, :sleep, settings.LEAFLET.SLEEP&.to_h&.transform_keys(&:downcase))
+        assign(config.leaflet_options, :sidebar, settings.LEAFLET.SIDEBAR)
+        assign(config.leaflet_options, :layers, settings.LEAFLET.LAYERS&.to_h&.transform_keys(&:downcase))
+      end
+
+      def build_fields(config)
+        return unless settings.FIELDS
+
+        assign(config.fields, :access_rights, settings.FIELDS.ACCESS_RIGHTS)
+        assign(config.fields, :alternative_title, settings.FIELDS.ALTERNATIVE_TITLE)
+        assign(config.fields, :centroid, settings.FIELDS.CENTROID)
+        assign(config.fields, :creator, settings.FIELDS.CREATOR)
+        assign(config.fields, :date_issued, settings.FIELDS.DATE_ISSUED)
+        assign(config.fields, :date_range, settings.FIELDS.DATE_RANGE)
+        assign(config.fields, :description, settings.FIELDS.DESCRIPTION)
+        assign(config.fields, :display_note, settings.FIELDS.DISPLAY_NOTE)
+        assign(config.fields, :format, settings.FIELDS.FORMAT)
+        assign(config.fields, :file_size, settings.FIELDS.FILE_SIZE)
+        assign(config.fields, :georeferenced, settings.FIELDS.GEOREFERENCED)
+        assign(config.fields, :id, settings.FIELDS.ID)
+        assign(config.fields, :identifier, settings.FIELDS.IDENTIFIER)
+        assign(config.fields, :index_year, settings.FIELDS.INDEX_YEAR)
+        assign(config.fields, :is_part_of, settings.FIELDS.IS_PART_OF)
+        assign(config.fields, :is_replaced_by, settings.FIELDS.IS_REPLACED_BY)
+        assign(config.fields, :theme, settings.FIELDS.THEME)
+        assign(config.fields, :keyword, settings.FIELDS.KEYWORD)
+        assign(config.fields, :language, settings.FIELDS.LANGUAGE)
+        assign(config.fields, :license, settings.FIELDS.LICENSE)
+        assign(config.fields, :member_of, settings.FIELDS.MEMBER_OF)
+        assign(config.fields, :metadata_version, settings.FIELDS.METADATA_VERSION)
+        assign(config.fields, :modified, settings.FIELDS.MODIFIED)
+        assign(config.fields, :overlap_field, settings.FIELDS.OVERLAP_FIELD)
+        assign(config.fields, :publisher, settings.FIELDS.PUBLISHER)
+        assign(config.fields, :provider, settings.FIELDS.PROVIDER)
+        assign(config.fields, :references, settings.FIELDS.REFERENCES)
+        assign(config.fields, :relation, settings.FIELDS.RELATION)
+        assign(config.fields, :replaces, settings.FIELDS.REPLACES)
+        assign(config.fields, :resource_class, settings.FIELDS.RESOURCE_CLASS)
+        assign(config.fields, :resource_type, settings.FIELDS.RESOURCE_TYPE)
+        assign(config.fields, :rights, settings.FIELDS.RIGHTS)
+        assign(config.fields, :rights_holder, settings.FIELDS.RIGHTS_HOLDER)
+        assign(config.fields, :source, settings.FIELDS.SOURCE)
+        assign(config.fields, :spatial_coverage, settings.FIELDS.SPATIAL_COVERAGE)
+        assign(config.fields, :geometry, settings.FIELDS.GEOMETRY)
+        assign(config.fields, :subject, settings.FIELDS.SUBJECT)
+        assign(config.fields, :suppressed, settings.FIELDS.SUPPRESSED)
+        assign(config.fields, :temporal_coverage, settings.FIELDS.TEMPORAL_COVERAGE)
+        assign(config.fields, :title, settings.FIELDS.TITLE)
+        assign(config.fields, :version, settings.FIELDS.VERSION)
+        assign(config.fields, :wxs_identifier, settings.FIELDS.WXS_IDENTIFIER)
+      end
+    end
+  end
+end

data/lib/geoblacklight/configuration.rb

@@ -54,13 +54,14 @@ module Geoblacklight
     attr_accessor :webservices_shown # typed as Array
 
     # Relationships to display
-    attr_accessor :relationships_shown # typed as Hash
+    attr_accessor :relationships_shown # typed as RelationshipsConfig
 
     attribute :download_path, :string
 
     def initialize
       super
       self.download_path ||= Rails.root.join("tmp", "cache", "downloads")
+      @relationships_shown = RelationshipsConfig.new
       @gbl_params = [
         :bbox, :email, :file, :format, :id, :logo, :provider, :type,
         :BBOX, :HEIGHT, :LAYERS, :QUERY_LAYERS, :URL, :WIDTH, :X, :Y
@@ -94,6 +95,8 @@ module Geoblacklight
         ]
       }
 
+      @vector_download_formats = ["Shapefile", "KMZ", "GeoJSON", "CSV"]
+      @metadata_shown = ["mods", "fgdc", "iso19139", "html"]
       @webservices_shown = %w[
         wms
         tms
@@ -107,7 +110,7 @@ module Geoblacklight
         dynamic_map_layer
         image_map_layer
         cog
-        pmtile
+        pmtiles
       ]
 
       @display_notes_shown = {
@@ -132,6 +135,8 @@ module Geoblacklight
           note_prefix: "Warning: "
         )
       }
+
+      @sidebar_static_map = ["iiif", "iiif_manifest"]
     end
 
     def fields

data/lib/geoblacklight/deprecation.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "active_support/deprecation"
+
+module Geoblacklight
+  Deprecation = ActiveSupport::Deprecation.new("7.0", "GeoBlacklight")
+end

data/lib/geoblacklight/version.rb

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

data/lib/geoblacklight.rb

@@ -14,7 +14,7 @@ module Geoblacklight
     ::Rails.logger
   end
 
-  mattr_accessor :configuration_builder, default: Geoblacklight::Configuration::LegacySettingsBuilder
+  mattr_accessor :configuration_builder, default: Geoblacklight::Configuration::SettingsBuilder
 
   def self.configuration
     @configuration ||= configuration_builder.build

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Geoblacklight::Document::SidebarComponent, type: :component do
+  subject(:component) { described_class.new(presenter: presenter) }
+
+  let(:view_context) { vc_test_controller.view_context }
+  let(:presenter) { view_context.document_presenter(document) }
+  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::LoginLinkComponent).to receive(:render?).and_return(false)
+
+    allow(document).to receive(:more_like_this).and_return([])
+    allow_any_instance_of(Blacklight::DocumentHelperBehavior).to receive(:current_bookmarks).and_return([])
+
+    with_controller_class(CatalogController) do
+      allow(vc_test_controller).to receive_messages(current_or_guest_user: User.new)
+      render_inline(component)
+    end
+  end
+
+  context "when the document viewer protocol is IIIF" do
+    let(:fixture) { "solr_documents/public_iiif_princeton.json" }
+
+    it "renders the static map" do
+      expect(page).to have_css("#static-map")
+    end
+
+    it "renders the Location label" do
+      expect(page).to have_content("Location")
+    end
+  end
+
+  context "when the document viewer protocol is WMS" do
+    let(:fixture) { "solr_documents/restricted-line.json" }
+
+    it "does not render the static map" do
+      expect(page).to have_no_css("#static-map")
+    end
+
+    it "does not render the Location label" do
+      expect(page).to have_no_content("Location")
+    end
+  end
+end

data/spec/components/geoblacklight/login_link_component_spec.rb

@@ -7,7 +7,7 @@ RSpec.describe Geoblacklight::LoginLinkComponent, type: :component do
 
   context "when rendering is required" do
     before do
-      allow_any_instance_of(GeoblacklightHelper).to receive(:document_available?).and_return(false)
+      allow(vc_test_controller).to receive(:user_signed_in?).and_return(false)
       allow(document).to receive(:restricted?).and_return(true)
       allow(document).to receive(:same_institution?).and_return(true)
     end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Geoblacklight::Configuration::LayerConfig do
+  subject(:config) { described_class.new(attributes) }
+
+  let(:attributes) { {} }
+
+  describe "defaults" do
+    it "has weight defaulting to 1" do
+      expect(config.weight).to eq(1)
+    end
+
+    it "has radius defaulting to 4" do
+      expect(config.radius).to eq(4)
+    end
+
+    it "has color defaulting to nil" do
+      expect(config.color).to be_nil
+    end
+
+    it "has sr_color_name defaulting to nil" do
+      expect(config.sr_color_name).to be_nil
+    end
+  end
+
+  describe "with attributes" do
+    let(:attributes) { {color: "#FF0000", sr_color_name: "Red", weight: 2, radius: 5} }
+
+    it "sets the passed-in attributes" do
+      expect(config.color).to eq("#FF0000")
+      expect(config.sr_color_name).to eq("Red")
+      expect(config.weight).to eq(2)
+      expect(config.radius).to eq(5)
+    end
+  end
+
+  describe "hash-like access []" do
+    let(:attributes) { {color: "#00FF00", sr_color_name: "Green"} }
+
+    it "supports key lookup with symbols" do
+      expect(config[:color]).to eq("#00FF00")
+      expect(config[:weight]).to eq(1)
+      expect(config[:sr_color_name]).to eq("Green")
+    end
+
+    it "supports key lookup with strings" do
+      expect(config["color"]).to eq("#00FF00")
+      expect(config["weight"]).to eq(1)
+      expect(config["sr_color_name"]).to eq("Green")
+    end
+
+    it "returns nil for non-existent attributes" do
+      expect(config[:foo]).to be_nil
+    end
+  end
+
+  describe "#to_h" do
+    let(:attributes) { {color: "#FFFF00", sr_color_name: "Yellow"} }
+
+    it "returns symbolized attributes hash" do
+      expect(config.to_h).to eq(
+        color: "#FFFF00",
+        weight: 1,
+        radius: 4,
+        sr_color_name: "Yellow"
+      )
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Geoblacklight::Configuration::LeafletLayersConfig do
+  subject(:config) { described_class.new(attributes) }
+
+  let(:attributes) do
+    {
+      detect_retina: true,
+      index: {
+        DEFAULT: {
+          color: "#7FCDBB",
+          sr_color_name: "Green"
+        },
+        UNAVAILABLE: Geoblacklight::Configuration::LayerConfig.new(
+          color: "#EDF8B1",
+          sr_color_name: "Yellow"
+        )
+      }
+    }
+  end
+
+  describe "initialization" do
+    it "sets detect_retina attribute" do
+      expect(config.detect_retina).to be(true)
+    end
+
+    it "converts hash elements under index to LayerConfig instances" do
+      expect(config.index[:DEFAULT]).to be_a(Geoblacklight::Configuration::LayerConfig)
+      expect(config.index[:DEFAULT].color).to eq("#7FCDBB")
+      expect(config.index[:DEFAULT].weight).to eq(1) # Uses default weight from LayerConfig
+    end
+
+    it "keeps existing LayerConfig instances under index" do
+      expect(config.index[:UNAVAILABLE]).to be_a(Geoblacklight::Configuration::LayerConfig)
+      expect(config.index[:UNAVAILABLE].color).to eq("#EDF8B1")
+      expect(config.index[:UNAVAILABLE].weight).to eq(1) # Uses default weight from LayerConfig
+    end
+  end
+
+  describe "#to_h" do
+    it "serializes index to a hash of hashes" do
+      expect(config.to_h).to eq(
+        "detect_retina" => true,
+        "index" => {
+          DEFAULT: {
+            color: "#7FCDBB",
+            weight: 1,
+            radius: 4,
+            sr_color_name: "Green"
+          },
+          UNAVAILABLE: {
+            color: "#EDF8B1",
+            weight: 1,
+            radius: 4,
+            sr_color_name: "Yellow"
+          }
+        }
+      )
+    end
+  end
+end