blacklight-maps 0.5.2 → 1.2.0

data/lib/blacklight/maps/export.rb

@@ -1,5 +1,6 @@
-module BlacklightMaps
+# frozen_string_literal: true
 
+module BlacklightMaps
   # This class provides the ability to export a response document to GeoJSON.
   # The export is formated as a GeoJSON FeatureCollection, where the features
   # consist of an array of Point features.  For more on the GeoJSON
@@ -8,146 +9,166 @@ module BlacklightMaps
   class GeojsonExport
     include BlacklightMaps
 
-    # controller is a Blacklight CatalogController object passed by a helper
-    # action is the controller action
-    # response_docs is passed by a helper, and is either:
+    # @param controller [CatalogController]
+    # @param action [Symbol] the controller action
+    # @param response_docs [Array || SolrDocument] either:
     #  - index view, map view: an array of facet values
     #  - show view: the document object
-    # options is an optional hash of possible configuration options
-    def initialize(controller, action, response_docs, options={})
+    # @param options [Hash] optional hash of configuration options
+    def initialize(controller, action, response_docs, options = {})
       @controller = controller
       @action = action
       @response_docs = response_docs
       @options = options
+      @features = []
     end
 
-    # build the GeoJSON FeatureCollection
+    # builds the GeoJSON FeatureCollection
     def to_geojson
-      geojson_docs = { type: 'FeatureCollection',
-                       features: build_geojson_features }
-      geojson_docs.to_json
+      { type: 'FeatureCollection', features: build_geojson_features }.to_json
     end
 
     private
 
-    def blacklight_maps_config
+    def maps_config
       @controller.blacklight_config.view.maps
     end
 
     def geojson_field
-      blacklight_maps_config.geojson_field
+      maps_config.geojson_field
     end
 
     def coordinates_field
-      blacklight_maps_config.coordinates_field
+      maps_config.coordinates_field
     end
 
-    def search_mode
-      blacklight_maps_config.search_mode
+    def build_geojson_features
+      if @action == :index || @action == :map
+        build_index_features
+      elsif @action == :show
+        build_show_features
+      end
+      @features
     end
 
-    def facet_mode
-      blacklight_maps_config.facet_mode
+    # build GeoJSON features array for index and map views
+    def build_index_features
+      @response_docs.each do |geofacet|
+        @features << if maps_config.facet_mode == 'coordinates'
+                       build_feature_from_coords(geofacet.value, geofacet.hits)
+                     else
+                       build_feature_from_geojson(geofacet.value, geofacet.hits)
+                     end
+      end
     end
 
-    def placename_property
-      blacklight_maps_config.placename_property
+    # build GeoJSON features array for show view
+    def build_show_features
+      doc = @response_docs
+      return unless doc[geojson_field] || doc[coordinates_field]
+
+      if doc[geojson_field]
+        build_features_from_geojson(doc[geojson_field])
+      elsif doc[coordinates_field]
+        build_features_from_coords(doc[coordinates_field])
+      end
     end
 
-    # build GeoJSON features array
-    # determine how to build GeoJSON feature based on config and controller#action
-    def build_geojson_features
-      features = []
-      case @action
-        when "index", "map"
-          @response_docs.each do |geofacet|
-            if facet_mode == "coordinates"
-              features.push(build_feature_from_coords(geofacet.value, geofacet.hits))
-            else
-              features.push(build_feature_from_geojson(geofacet.value, geofacet.hits))
-            end
-          end
-        when "show"
-          doc = @response_docs
-          return unless doc[geojson_field] || doc[coordinates_field]
-          if doc[geojson_field]
-            doc[geojson_field].uniq.each do |loc|
-              features.push(build_feature_from_geojson(loc))
-            end
-          elsif doc[coordinates_field]
-            doc[coordinates_field].uniq.each do |coords|
-              features.push(build_feature_from_coords(coords))
-            end
-          end
+    def build_features_from_geojson(geojson_field_values)
+      return unless geojson_field_values
+
+      geojson_field_values.uniq.each do |loc|
+        @features << build_feature_from_geojson(loc)
       end
-      features
     end
 
-    # build blacklight-maps GeoJSON feature from GeoJSON-formatted data
+    def build_features_from_coords(coordinates_field_values)
+      return unless coordinates_field_values
+
+      coordinates_field_values.uniq.each do |coords|
+        @features << build_feature_from_coords(coords)
+      end
+    end
+
+    # build GeoJSON feature from incoming GeoJSON data
     # turn bboxes into points for index view so we don't get weird mix of boxes and markers
+    # @param loc [Hash]
+    # @param hits [Integer]
+    # rubocop:disable Metrics/AbcSize
     def build_feature_from_geojson(loc, hits = nil)
-      geojson_hash = JSON.parse(loc).deep_symbolize_keys
-      if @action != "show" && geojson_hash[:bbox]
-        geojson_hash[:geometry][:coordinates] = Geometry::Point.new(Geometry::BoundingBox.new(geojson_hash[:bbox]).find_center).normalize_for_search
-        geojson_hash[:geometry][:type] = "Point"
-        geojson_hash.delete(:bbox)
+      geojson = JSON.parse(loc).deep_symbolize_keys
+      if @action != :show && geojson[:bbox]
+        bbox = Geometry::BoundingBox.new(geojson[:bbox])
+        geojson[:geometry][:coordinates] = Geometry::Point.new(bbox.find_center).normalize_for_search
+        geojson[:geometry][:type] = 'Point'
+        geojson.delete(:bbox)
       end
-      geojson_hash[:properties] ||= {}
-      geojson_hash[:properties][:hits] = hits.to_i if hits
-      geojson_hash[:properties][:popup] = render_leaflet_popup_content(geojson_hash, hits)
-      geojson_hash
+      geojson[:properties] ||= {}
+      geojson[:properties][:hits] = hits.to_i if hits
+      geojson[:properties][:popup] = render_leaflet_popup_content(geojson, hits)
+      geojson
     end
+    # rubocop:enable Metrics/AbcSize
 
-    # build blacklight-maps GeoJSON feature from coordinate data
+    # build GeoJSON feature from incoming raw coordinate data
     # turn bboxes into points for index view so we don't get weird mix of boxes and markers
+    # @param coords [String]
+    # @param hits [Integer]
     def build_feature_from_coords(coords, hits = nil)
-      geojson_hash = {type: "Feature", geometry: {}, properties: {}}
-      if coords.scan(/[\s]/).length == 3 # bbox
-        if @action != "show"
-          geojson_hash[:geometry][:type] = "Point"
-          geojson_hash[:geometry][:coordinates] = Geometry::Point.new(Geometry::BoundingBox.from_lon_lat_string(coords).find_center).normalize_for_search
-        else
-          coords_array = coords.split(' ').map { |v| v.to_f }
-          geojson_hash[:bbox] = coords_array
-          geojson_hash[:geometry][:type] = "Polygon"
-          geojson_hash[:geometry][:coordinates] = [[[coords_array[0],coords_array[1]],
-                                                    [coords_array[2],coords_array[1]],
-                                                    [coords_array[2],coords_array[3]],
-                                                    [coords_array[0],coords_array[3]],
-                                                    [coords_array[0],coords_array[1]]]]
-        end
-      elsif coords.match(/^[-]?[\d]*[\.]?[\d]*[ ,][-]?[\d]*[\.]?[\d]*$/) # point
-        geojson_hash[:geometry][:type] = "Point"
-        if coords.match(/,/)
-          coords_array = coords.split(',').reverse
-        else
-          coords_array = coords.split(' ')
-        end
-        geojson_hash[:geometry][:coordinates] = coords_array.map { |v| v.to_f }
+      geojson = { type: 'Feature', properties: {} }
+      if coords =~ /ENVELOPE/ # bbox
+        geojson.merge!(build_bbox_feature_from_coords(coords))
+      elsif coords =~ /^-?\d*\.?\d*[ ,]-?\d*\.?\d*$/ # point
+        geojson[:geometry] = build_point_geometry(coords)
       else
         Rails.logger.error("This coordinate format is not yet supported: '#{coords}'")
       end
-      geojson_hash[:properties] = { popup: render_leaflet_popup_content(geojson_hash, hits) } if geojson_hash[:geometry][:coordinates]
-      geojson_hash[:properties][:hits] = hits.to_i if hits
-      geojson_hash
+      geojson[:properties] = { popup: render_leaflet_popup_content(geojson, hits) } if geojson[:geometry][:coordinates]
+      geojson[:properties][:hits] = hits.to_i if hits
+      geojson
+    end
+
+    # @param coords [String]
+    def build_bbox_feature_from_coords(coords)
+      geojson = { geometry: {} }
+      bbox = Geometry::BoundingBox.from_wkt_envelope(coords)
+      if @action != :show
+        geojson[:geometry][:type] = 'Point'
+        geojson[:geometry][:coordinates] = Geometry::Point.new(bbox.find_center).normalize_for_search
+      else
+        coords_array = bbox.to_a
+        geojson[:bbox] = coords_array
+        geojson[:geometry][:type] = 'Polygon'
+        geojson[:geometry][:coordinates] = bbox.geojson_geometry_array
+      end
+      geojson
+    end
+
+    # @param coords [String]
+    def build_point_geometry(coords)
+      geometry = { type: 'Point' }
+      coords_array = coords =~ /,/ ? coords.split(',').reverse : coords.split(' ')
+      geometry[:coordinates] = coords_array.map(&:to_f)
+      geometry
     end
 
-    # Render to string the partial for each individual doc.
+    # Render to string the partial for each individual feature.
     # For placename searching, render catalog/map_placename_search partial,
-    #  full geojson hash is passed to the partial for easier local customization
+    #  pass the full geojson hash to the partial for easier local customization
     # For coordinate searches (or features with only coordinate data),
     #  render catalog/map_coordinate_search partial
-    def render_leaflet_popup_content(geojson_hash, hits=nil)
-      if search_mode == 'placename' && geojson_hash[:properties][placename_property.to_sym]
-        @controller.render_to_string partial: 'catalog/map_placename_search',
-                                     locals: { geojson_hash: geojson_hash, hits: hits }
+    # @param geojson [Hash]
+    # @param hits [Integer]
+    def render_leaflet_popup_content(geojson, hits = nil)
+      if maps_config.search_mode == 'placename' &&
+         geojson[:properties][maps_config.placename_property.to_sym]
+        partial = 'catalog/map_placename_search'
+        locals = { geojson_hash: geojson, hits: hits }
       else
-        @controller.render_to_string partial: 'catalog/map_spatial_search',
-                                     locals: { coordinates: geojson_hash[:bbox].presence || geojson_hash[:geometry][:coordinates],
-                                               hits: hits }
+        partial = 'catalog/map_spatial_search'
+        locals = { coordinates: geojson[:bbox].presence || geojson[:geometry][:coordinates], hits: hits }
       end
+      @controller.render_to_string(partial: partial, locals: locals)
     end
-
   end
-
 end

data/lib/blacklight/maps/geometry.rb

@@ -1,15 +1,14 @@
-module BlacklightMaps
+# frozen_string_literal: true
 
+module BlacklightMaps
   # Parent class of geospatial objects used in BlacklightMaps
   class Geometry
-
     # This class contains Bounding Box objects and methods for interacting with
     # them.
     class BoundingBox
-
       # points is an array containing longitude and latitude values which
       # relate to the southwest and northeast points of a bounding box
-      # [west, south, east, north] ([swlng, swlat, nelng, nelat]).
+      # [west, south, east, north] ([minX, minY, maxX, maxY]).
       def initialize(points)
         @west = points[0].to_f
         @south = points[1].to_f
@@ -17,15 +16,24 @@ module BlacklightMaps
         @north = points[3].to_f
       end
 
+      def geojson_geometry_array
+        [
+          [
+            [@west, @south],
+            [@east, @south],
+            [@east, @north],
+            [@west, @north],
+            [@west, @south]
+          ]
+        ]
+      end
+
       # Returns an array [lng, lat] which is the centerpoint of a BoundingBox.
       def find_center
         center = []
         center[0] = (@west + @east) / 2
         center[1] = (@south + @north) / 2
-
-        # Handle bounding boxes that cross the dateline
-        center[0] -= 180 if @west > @east
-
+        center[0] -= 180 if @west > @east # handle bboxes that cross the dateline
         center
       end
 
@@ -34,11 +42,21 @@ module BlacklightMaps
       def self.from_lon_lat_string(points)
         new(points.split(' '))
       end
+
+      # Creates a new bounding box from from a Solr WKT Envelope string
+      # "ENVELOPE(34.26, 35.89, 33.33, 29.47)" (minX, maxX, maxY, minY)
+      def self.from_wkt_envelope(envelope)
+        coords = envelope.gsub(/[[A-Z]()]/, '')&.split(', ')
+        new([coords[0], coords[3], coords[1], coords[2]])
+      end
+
+      def to_a
+        [@west, @south, @east, @north]
+      end
     end
 
     # This class contains Point objects and methods for working with them
     class Point
-
       # points is an array corresponding to the longitude and latitude values
       # [long, lat]
       def initialize(points)
@@ -49,13 +67,9 @@ module BlacklightMaps
       # returns a string that can be used as the value of solr_parameters[:pt]
       # normalizes any long values >180 or <-180
       def normalize_for_search
-        case
-          when @long > 180
-            @long -= 360
-          when @long < -180
-            @long += 360
-        end
-        [@long,@lat]
+        @long -= 360 if @long > 180
+        @long += 360 if @long < -180
+        [@long, @lat]
       end
 
       # Creates a new point from from a coordinate string
@@ -63,8 +77,6 @@ module BlacklightMaps
       def self.from_lat_lon_string(points)
         new(points.split(',').reverse)
       end
-
     end
-
   end
 end

data/lib/blacklight/maps/maps_search_builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module BlacklightMaps
   module MapsSearchBuilderBehavior
     extend ActiveSupport::Concern
@@ -11,7 +13,7 @@ module BlacklightMaps
       if blacklight_params[:spatial_search_type] && blacklight_params[:coordinates]
         solr_parameters[:fq] ||= []
         if blacklight_params[:spatial_search_type] == 'bbox'
-          solr_parameters[:fq] << blacklight_config.view.maps.coordinates_field + ":" + blacklight_params[:coordinates]
+          solr_parameters[:fq] << "#{blacklight_config.view.maps.coordinates_field}:#{blacklight_params[:coordinates]}"
         else
           solr_parameters[:fq] << "{!geofilt sfield=#{blacklight_config.view.maps.coordinates_field}}"
           solr_parameters[:pt] = blacklight_params[:coordinates]
@@ -20,6 +22,5 @@ module BlacklightMaps
       end
       solr_parameters
     end
-
   end
-end
+end

data/lib/blacklight/maps/render_constraints_override.rb

@@ -1,61 +1,95 @@
+# frozen_string_literal: true
+
 # Meant to be applied on top of Blacklight view helpers, to over-ride
 # certain methods from RenderConstraintsHelper (newish in BL),
 # to affect constraints rendering
 module BlacklightMaps
-
   module RenderConstraintsOverride
-
-    # BlacklightMaps override: update to look for spatial query params
-    def has_search_parameters?
-      has_spatial_parameters? || super
-    end
-
-    def has_spatial_parameters?
-      !params[:coordinates].blank?
+    # @param search_state [Blacklight::SearchState]
+    # @return [Boolean]
+    def has_spatial_parameters?(search_state)
+      search_state.params[:coordinates].present?
     end
 
     # BlacklightMaps override: check for coordinate parameters
-    def query_has_constraints?(localized_params = params)
-      has_search_parameters? || super
+    # @param params_or_search_state [Blacklight::SearchState || ActionController::Parameters]
+    # @return [Boolean]
+    def query_has_constraints?(params_or_search_state = search_state)
+      search_state = convert_to_search_state(params_or_search_state)
+      has_spatial_parameters?(search_state) || super
     end
 
     # BlacklightMaps override: include render_spatial_query() in rendered constraints
-    def render_constraints(localized_params = params)
-      render_spatial_query(localized_params) + super
+    # @param localized_params [Hash] localized_params query parameters
+    # @param local_search_state [Blacklight::SearchState]
+    # @return [String]
+    def render_constraints(localized_params = params, local_search_state = search_state)
+      params_or_search_state = if localized_params != params
+                                 localized_params
+                               else
+                                 local_search_state
+                               end
+      render_spatial_query(params_or_search_state) + super
     end
 
     # BlacklightMaps override: include render_search_to_s_coord() in rendered constraints
     # Simpler textual version of constraints, used on Search History page.
+    # @param params [Hash]
+    # @return [String]
     def render_search_to_s(params)
       render_search_to_s_coord(params) + super
     end
 
     ##
     # Render the search query constraint
+    # @param params [Hash]
+    # @return [String]
     def render_search_to_s_coord(params)
-      return "".html_safe if params[:coordinates].blank?
-      render_search_to_s_element(spatial_constraint_label(params), render_filter_value(params[:coordinates]) )
+      return ''.html_safe if params[:coordinates].blank?
+
+      render_search_to_s_element(spatial_constraint_label(params),
+                                 render_filter_value(params[:coordinates]))
     end
 
     # Render the spatial query constraints
-    def render_spatial_query(localized_params = params)
+    # @param params_or_search_state [Blacklight::SearchState || ActionController::Parameters]
+    # @return [String]
+    def render_spatial_query(params_or_search_state = search_state)
+      search_state = convert_to_search_state(params_or_search_state)
+
       # So simple don't need a view template, we can just do it here.
-      return ''.html_safe if localized_params[:coordinates].blank?
+      return ''.html_safe if search_state.params[:coordinates].blank?
 
-      render_constraint_element(spatial_constraint_label(localized_params),
-                                localized_params[:coordinates],
-                                :classes => ['coordinates'],
-                                :remove => remove_constraint_url(localized_params.merge(:coordinates=>nil,
-                                                                                        :spatial_search_type=>nil,
-                                                                                        :action=>'index')))
+      render_constraint_element(spatial_constraint_label(search_state),
+                                search_state.params[:coordinates],
+                                classes: ['coordinates'],
+                                remove: remove_spatial_params(search_state)) # _params.except!(:coordinates, :spatial_search_type)
     end
 
-    def spatial_constraint_label(params)
-      (params[:spatial_search_type] && params[:spatial_search_type] == 'bbox') ?
-          t('blacklight.search.filters.coordinates.bbox') :
-          t('blacklight.search.filters.coordinates.point')
+    ##
+    #
+    # @param search_state [Blacklight::SearchState]
+    # @return [String]
+    # remove the spatial params from params
+    def remove_spatial_params(search_state)
+      search_action_path(search_state.params.dup.except!(:coordinates, :spatial_search_type))
     end
 
+    ##
+    # render the label for the spatial constraint
+    # @param params_or_search_state [Blacklight::SearchState || ActionController::Parameters]
+    # @return [String]
+    def spatial_constraint_label(params_or_search_state)
+      search_params = if params_or_search_state.is_a?(Blacklight::SearchState)
+                        params_or_search_state.params
+                      else
+                        params_or_search_state
+                      end
+      if search_params[:spatial_search_type] && search_params[:spatial_search_type] == 'bbox'
+        t('blacklight.search.filters.coordinates.bbox')
+      else
+        t('blacklight.search.filters.coordinates.point')
+      end
+    end
   end
-
-end
+end

data/lib/blacklight/maps/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Blacklight
   module Maps
-    VERSION = "0.5.2"
+    VERSION = '1.2.0'
   end
 end

data/lib/blacklight/maps.rb

@@ -1,13 +1,19 @@
-require "blacklight/maps/version"
+# frozen_string_literal: true
+
+require 'blacklight/maps/version'
 
 module Blacklight
   module Maps
-    require 'blacklight/maps/controller_override'
+    require 'blacklight/maps/controller'
     require 'blacklight/maps/render_constraints_override'
     require 'blacklight/maps/engine'
     require 'blacklight/maps/export'
     require 'blacklight/maps/geometry'
     require 'blacklight/maps/maps_search_builder'
 
+    # returns the full path to the blacklight plugin installation
+    def self.root
+      @root ||= File.expand_path(File.dirname(File.dirname(File.dirname(__FILE__))))
+    end
   end
 end

data/lib/generators/blacklight_maps/install_generator.rb

@@ -1,61 +1,68 @@
+# frozen_string_literal: true
+
 require 'rails/generators'
 
 module BlacklightMaps
   class Install < Rails::Generators::Base
+    source_root File.expand_path('templates', __dir__)
+
+    desc 'Install Blacklight-Maps'
 
-    source_root File.expand_path('../templates', __FILE__)
+    def verify_blacklight_installed
+      return if IO.read('app/controllers/application_controller.rb').include?('include Blacklight::Controller')
 
-    desc "Install Blacklight-Maps"
+      say_status('info', 'BLACKLIGHT NOT INSTALLED; GENERATING BLACKLIGHT', :blue)
+      generate 'blacklight:install'
+    end
 
     def assets
-      copy_file "blacklight_maps.css.scss", "app/assets/stylesheets/blacklight_maps.css.scss"
-
-      unless IO.read("app/assets/javascripts/application.js").include?('blacklight-maps')
-        marker = IO.read("app/assets/javascripts/application.js").include?('turbolinks') ?
-          '//= require turbolinks' : "//= require jquery_ujs"
-        insert_into_file "app/assets/javascripts/application.js", :after => marker do
-          %q{
-//
-// Required by Blacklight-Maps
-//= require blacklight-maps}
-        end
+      copy_file 'blacklight_maps.css.scss', 'app/assets/stylesheets/blacklight_maps.css.scss'
+      return if IO.read('app/assets/javascripts/application.js').include?('blacklight-maps')
+
+      marker = '//= require blacklight/blacklight'
+      insert_into_file 'app/assets/javascripts/application.js', after: marker do
+        "\n// Required by BlacklightMaps" \
+        "\n//= require blacklight-maps"
       end
+      append_to_file 'config/initializers/assets.rb',
+                     "\nRails.application.config.assets.paths << Rails.root.join('vendor', 'assets', 'images')\n"
     end
 
     def inject_search_builder
-      inject_into_file 'app/models/search_builder.rb', after: /include Blacklight::Solr::SearchBuilderBehavior.*$/ do
+      inject_into_file 'app/models/search_builder.rb',
+                       after: /include Blacklight::Solr::SearchBuilderBehavior.*$/ do
         "\n  include BlacklightMaps::MapsSearchBuilderBehavior\n"
       end
     end
 
     def install_catalog_controller_mixin
-      inject_into_file "app/controllers/catalog_controller.rb", after: /include Blacklight::Catalog.*$/  do
-        "\n  include BlacklightMaps::ControllerOverride\n"
+      inject_into_file 'app/controllers/catalog_controller.rb',
+                       after: /include Blacklight::Catalog.*$/ do
+        "\n  include BlacklightMaps::Controller\n"
       end
     end
 
     def install_search_history_controller
-      target_file = "app/controllers/search_history_controller.rb"
-      if File.exists?(target_file)
-        inject_into_file target_file, after: /include Blacklight::SearchHistory/ do
+      target_file = 'app/controllers/search_history_controller.rb'
+      if File.exist?(target_file)
+        inject_into_file target_file,
+                         after: /include Blacklight::SearchHistory/ do
           "\n  helper BlacklightMaps::RenderConstraintsOverride\n"
         end
       else
-        copy_file "search_history_controller.rb", target_file
+        copy_file 'search_history_controller.rb', target_file
       end
     end
 
-    def install_saved_searches_controller
-      target_file = "app/controllers/saved_searches_controller.rb"
-      if File.exists?(target_file)
-        inject_into_file target_file, after: /include Blacklight::SavedSearches/ do
-          "\n  helper BlacklightMaps::RenderConstraintsOverride\n"
-        end
-      else
-        copy_file "saved_searches_controller.rb", target_file
+    # TODO: inject Solr configuration (if needed)
+    def inject_solr_configuration
+      target_file = 'solr/conf/schema.xml'
+      return unless File.exist?(target_file)
+
+      inject_into_file target_file,
+                       after: %r{<copyField source="title_tsim" dest="title_spell"/>} do
+        "\n  <copyField source=\"coordinates_srpt\" dest=\"coordinates_ssim\" />\n"
       end
     end
-
-
   end
-end
+end

data/lib/generators/blacklight_maps/templates/search_history_controller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class SearchHistoryController < ApplicationController
   include Blacklight::SearchHistory