blacklight-maps 0.2.0 → 0.3.0

data/lib/blacklight/maps/export.rb

@@ -9,12 +9,17 @@ module BlacklightMaps
     include BlacklightMaps
 
     # controller is a Blacklight CatalogController object passed by a helper
-    # response_docs is an array of documents passed by a helper
-    def initialize(controller, response_docs)
+    # action is the controller action
+    # response_docs is passed by a helper, and is either:
+    #  - index view, map view: an array of facet values
+    #  - show view: the document object
+    def initialize(controller, action, response_docs)
       @controller = controller
+      @action = action
       @response_docs = response_docs
     end
 
+    # build the GeoJSON FeatureCollection
     def to_geojson
       geojson_docs = { type: 'FeatureCollection',
                        features: build_geojson_features }
@@ -27,85 +32,121 @@ module BlacklightMaps
       @controller.blacklight_config.view.maps
     end
 
-    def type
-      blacklight_maps_config.type
+    def geojson_field
+      blacklight_maps_config.geojson_field
     end
 
-    def placename_coord_field
-      blacklight_maps_config.placename_coord_field
+    def coordinates_field
+      blacklight_maps_config.coordinates_field
     end
 
-    def placename_coord_delimiter
-      blacklight_maps_config.placename_coord_delimiter
+    def search_mode
+      blacklight_maps_config.search_mode
     end
 
-    def bbox_field
-      blacklight_maps_config.bbox_field
+    def facet_mode
+      blacklight_maps_config.facet_mode
     end
 
-    def build_geojson_features
-      case type
-      when 'placename_coord'
-        build_placename_coord_features
-      when 'bbox'
-        build_bbox_features
-      else
-        Rails.logger.error("Your Solr field type was not configured with a recognized type, '#{type}' is not yet supported")
-      end
+    def placename_property
+      blacklight_maps_config.placename_property
     end
 
-    # Builds the features structure for placename_coord type documents
-    def build_placename_coord_features
+    # build GeoJSON features array
+    # determine how to build GeoJSON feature based on config and controller#action
+    def build_geojson_features
       features = []
-      @response_docs.each do |doc|
-        next if doc[placename_coord_field].nil?
-        doc[placename_coord_field].uniq.each do |loc|
-          values = loc.split(placename_coord_delimiter)
-          features.push(
-            build_point_feature(values[2], values[1],
-                                name: values[0],
-                                html: render_leaflet_sidebar_partial(doc)))
-        end
+      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
       end
       features
     end
 
-    # Builds the features structure for bbox type documents
-    def build_bbox_features
-      features = []
-      @response_docs.each do |doc|
-        next if doc[bbox_field].nil?
-        doc[bbox_field].uniq.each do |loc|
-          lnglat = Geometry::BoundingBox.from_lon_lat_string(loc).find_center
-          features.push(
-            build_point_feature(lnglat[0], lnglat[1],
-                                html: render_leaflet_sidebar_partial(doc)))
-        end
+    # build blacklight-maps GeoJSON feature from GeoJSON-formatted data
+    # turn bboxes into points for index view so we don't get weird mix of boxes and markers
+    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::BoundingBox.new(geojson_hash[:bbox]).find_center
+        geojson_hash[:geometry][:type] = "Point"
+        geojson_hash.delete(:bbox)
       end
-      features
+      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
     end
 
-    # Render to string the partial for each individual doc
-    def render_leaflet_sidebar_partial(doc)
-      @controller.render_to_string partial: 'catalog/index_maps',
-                                   locals: { document: SolrDocument.new(doc) }
+    # build blacklight-maps GeoJSON feature from coordinate data
+    # turn bboxes into points for index view so we don't get weird mix of boxes and markers
+    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::BoundingBox.from_lon_lat_string(coords).find_center
+        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 }
+      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
     end
 
-    # Build the individual feature which is added to the FeatureCollection.
-    # lng is the longitude of the feature
-    # lat is the latitude of the feature
-    # *args additional arguments can be passed to the feature, these arguments
-    # will be reflected in the 'properties' member.
-    # html: "html string to show up" must be passed for the sidebar to display
-    # list items
-    def build_point_feature(lng, lat, *args)
-      properties = args.extract_options!
-      feature = { type: 'Feature',
-                  geometry: {
-                    type: 'Point',
-                    coordinates: [lng.to_f, lat.to_f] },
-                  properties: properties }
-      feature
+    # Render to string the partial for each individual doc.
+    # For placename searching, render catalog/map_placename_search partial,
+    #  full geojson hash is passed 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 }
+      else
+        @controller.render_to_string partial: 'catalog/map_spatial_search',
+                                     locals: { coordinates: geojson_hash[:bbox].presence || geojson_hash[:geometry][:coordinates],
+                                               hits: hits }
+      end
     end
+
   end
+
 end

data/lib/blacklight/maps/render_constraints_override.rb

@@ -0,0 +1,62 @@
+# 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?
+    end
+
+    # BlacklightMaps override: check for coordinate parameters
+    def query_has_constraints?(localized_params = params)
+      has_search_parameters? || super
+    end
+
+    # BlacklightMaps override: include render_spatial_query() in rendered constraints
+    def render_constraints(localized_params = params)
+      render_spatial_query(localized_params) + super
+    end
+
+    # BlacklightMaps override: include render_search_to_s_coord() in rendered constraints
+    # Simpler textual version of constraints, used on Search History page.
+    def render_search_to_s(params)
+      render_search_to_s_coord(params) + super
+    end
+
+    ##
+    # Render the search query constraint
+    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]) )
+    end
+
+    # Render the spatial query constraints
+    def render_spatial_query(localized_params = params)
+      # So simple don't need a view template, we can just do it here.
+      scope = localized_params.delete(:route_set) || self
+      return ''.html_safe if localized_params[:coordinates].blank?
+
+      render_constraint_element(spatial_constraint_label(localized_params),
+                                localized_params[:coordinates],
+                                :classes => ['coordinates'],
+                                :remove => scope.url_for(localized_params.merge(:coordinates=>nil,
+                                                                                :spatial_search_type=>nil,
+                                                                                :action=>'index')))
+    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')
+    end
+
+  end
+
+end

data/lib/blacklight/maps/version.rb

@@ -1,5 +1,5 @@
 module Blacklight
   module Maps
-    VERSION = "0.2.0"
+    VERSION = "0.3.0"
   end
 end

data/lib/generators/blacklight_maps/templates/blacklight_maps.css.scss

@@ -1,3 +1,3 @@
 /*
-*= require blacklight_maps/default
+*= require blacklight_maps/blacklight-maps
 */

data/solr_conf/conf/schema.xml

@@ -534,7 +534,10 @@
    <field name="format" type="string" indexed="true" stored="true"/>
 
    <!-- addition -->
-   <field name="placename_coords" type="string" indexed="true" stored="true" multiValued="true"/>
+   <field name="geojson" type="string" indexed="true" stored="true" multiValued="true"/>
+   <field name="coordinates" type="location_rpt" stored="true" indexed="true" multiValued="true"/>
+   <!-- copy coordinates to string field for faceting -->
+   <copyField source="coordinates" dest="coordinates_facet" />
 
    <!-- Dynamic field definitions.  If a field name is not found, dynamicFields
         will be used if the name matches any of the patterns.

data/spec/controllers/catalog_controller_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe CatalogController do
+
+  render_views
+
+  describe "GET 'map'" do
+
+    before { get :map }
+
+    it "should respond to the #map action" do
+      response.should be_success
+      assigns(:document_list).should_not be_nil
+    end
+
+    it "should render the '/map' page" do
+      response.body.should have_selector("body.blacklight-catalog-map")
+    end
+
+  end
+
+end

data/spec/features/maps_spec.rb

@@ -2,111 +2,244 @@ require 'spec_helper'
 
 describe "Map View", js: true do
 
-  describe "using placename coords" do
-    before do
-      CatalogController.blacklight_config = Blacklight::Configuration.new
-      CatalogController.configure_blacklight do |config|
-        config.view.maps.type = 'placename_coord'
-        config.view.maps.placename_coord_delimiter = '-|-'
-        # These fields also need to be added for some reason for the tests to pass
-        # Link in list is not being generated correctly if not passed
-        config.index.title_field = 'title_display'
+  before :each do
+    CatalogController.blacklight_config = Blacklight::Configuration.new
+  end
+
+  describe "catalog#index and catalog#map views" do
+
+    describe "catalog#index map view" do
+
+      before :each do
+        CatalogController.configure_blacklight do |config|
+          # use geojson facet for blacklight-maps catalog#index map view specs
+          config.add_facet_field 'geojson', :limit => -2, :label => 'GeoJSON', :show => false
+          config.add_facet_fields_to_solr_request!
+        end
+        visit catalog_index_path :q => 'korea', :view => 'maps'
       end
-    end
 
-    before { visit catalog_index_path :q => 'tibet', :view => 'maps' }
+      it "should display map elements" do
+        expect(page).to have_selector("#documents.map")
+        expect(page).to have_selector("#blacklight-index-map")
+      end
 
-    it "should display map elements" do
-      expect(page).to have_selector("#documents.map")
-      expect(page).to have_selector("#blacklight-map")
-      expect(page).to have_selector("#blacklight-map-sidebar")
-    end
+      it "should display tile layer attribution" do
+        expect(find("div.leaflet-control-container")).to have_content('OpenStreetMap contributors, CC-BY-SA')
+      end
 
-    describe "data attributes" do
+      describe "#sortAndPerPage" do
+
+        it "should show the mapped item count" do
+          expect(page).to have_selector(".mapped-count .badge", text: "4")
+        end
+
+        it "should show the mapped item caveat" do
+          expect(page).to have_selector(".mapped-caveat")
+        end
+
+        # TODO: placeholder spec: #sortAndPerPage > .view-type > .view-type-group
+        # should show active map icon. however, this spec doesn't work because
+        # Blacklight::ConfigurationHelperBehavior#has_alternative_views? returns false,
+        # so catalog/_view_type_group partial renders no content, can't figure out why
+        it "should show the map view icon" #do
+          #expect(page).to have_selector(".view-type-maps.active")
+        #end
 
-      it "maxzoom should be 8" do
-        expect(page).to have_selector("#blacklight-map[data-maxzoom='8']")
       end
 
-      it "type should be placename_coord" do
-        expect(page).to have_selector("#blacklight-map[data-type='placename_coord']")
+      describe "data attributes" do
+
+        it "maxzoom should be from config" do
+          expect(page).to have_selector("#blacklight-index-map[data-maxzoom='#{CatalogController.blacklight_config.view.maps.maxzoom}']")
+        end
+
+        it "tileurl should be from config" do
+          expect(page).to have_selector("#blacklight-index-map[data-tileurl='#{CatalogController.blacklight_config.view.maps.tileurl}']")
+        end
+
       end
 
-      it "tileurl should be OSM" do
-        expect(page).to have_selector("#blacklight-map[data-tileurl='http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png']")
+      describe "marker clusters" do
+
+        before {
+          0.upto(2) { find("a.leaflet-control-zoom-out").click } # zoom out to create cluster
+        }
+
+        it "should have marker cluster div" do
+          expect(page).to have_selector("div.marker-cluster")
+        end
+
+        it "should only have one marker cluster" do
+          expect(page).to have_selector("div.marker-cluster", count: 1)
+        end
+
+        it "should show the result count" do
+          expect(find("div.marker-cluster")).to have_content(4)
+        end
+
+        describe "click marker cluster" do
+
+          before { find("div.marker-cluster").click }
+
+          it "should split into two marker clusters" do
+            expect(page).to have_selector("div.marker-cluster", count: 2)
+          end
+
+        end
+
       end
 
-    end
+      describe "marker popups" do
 
-    describe "marker clusters" do
+        before { find(".marker-cluster:first-child").click }
+
+        it "should show a popup with correct content" do
+          expect(page).to have_selector("div.leaflet-popup-content-wrapper")
+          expect(page).to have_content("Seoul (Korea)")
+        end
+
+        describe "click search link" do
+
+          before { find("div.leaflet-popup-content a").click }
+
+          it "should run a new search" do
+            expect(page).to have_selector(".constraint-value .filterValue", text: "Seoul (Korea)")
+          end
+
+        end
 
-      it "should have marker cluster div" do
-        expect(page).to have_selector("div.marker-cluster")
       end
 
-      it "should only have one marker cluster" do
-        expect(page).to have_selector('div.marker-cluster', count: 1)
+      describe "map search control" do
+
+        it "should have a search control" do
+          expect(page).to have_selector(".leaflet-control .search-control")
+        end
+
+        describe "search control hover" do
+
+          before { find(".search-control").hover }
+
+          it "should add a border to the map" do
+            expect(page).to have_selector(".leaflet-overlay-pane path")
+          end
+
+        end
+
+        describe "search control click" do
+
+          before { find(".search-control").click }
+
+          it "should run a new search" do
+            expect(page).to have_selector(".constraint.coordinates")
+          end
+
+        end
+
       end
 
-      it "should have 4 markers" do
-        expect(find("div.marker-cluster")).to have_content(4)
+    end
+
+    describe "catalog#map view" do
+
+      before :each do
+        CatalogController.configure_blacklight do |config|
+          # use coordinates_facet facet for blacklight-maps catalog#map view specs
+          config.view.maps.facet_mode = 'coordinates'
+          config.view.maps.coordinates_facet_field = 'coordinates_facet'
+          config.add_facet_field 'coordinates_facet', :limit => -2, :label => 'Coordinates', :show => false
+          config.add_facet_fields_to_solr_request!
+        end
+        visit map_path
+        #print page.html # debugging
       end
 
-      it "should display tile layer attribution" do
-        expect(find("div.leaflet-control-container")).to have_content('OpenStreetMap contributors, CC-BY-SA')
+      it "should display map elements" do
+        expect(page).to have_selector("#documents.map")
+        expect(page).to have_selector("#blacklight-index-map")
       end
 
-      describe "Click Marker cluster" do
-        before { find("div.marker-cluster").click }
+      it "should display some markers" do
+        expect(page).to have_selector("div.marker-cluster")
+      end
+
+      describe "marker popups" do
 
-        it "should have three marker clusters" do
-          expect(page).to have_selector('div.marker-cluster', count: 3)
+        before :each do
+          0.upto(1) { find("a.leaflet-control-zoom-in").click } # zoom in
+          find(".marker-cluster:first-child").click
         end
 
-        describe "Click low level marker cluster" do
-          before { find("div.marker-cluster[title='India']").click }
+        it "should show a popup with correct content" do
+          expect(page).to have_selector("div.leaflet-popup-content-wrapper")
+          expect(page).to have_content("[35.86166, 104.195397]")
+        end
 
-          it "should show sidebar with content" do
-            expect(page).to have_content("es yon")
-          end
+        describe "click search link" do
 
-          describe "Navigate to catalog page" do
-            before { click_link("es yon") }
+          before { find("div.leaflet-popup-content a").click }
 
-            it "should show page with content" do
-              expect(page).to have_content("es yon")
-            end
+          it "should run a new search" do
+            expect(page).to have_selector(".constraint-value .filterValue", text: "35.86166,104.195397")
           end
+
         end
+
       end
+
     end
+
   end
 
-  describe "using bounding box" do
-    before do
-      CatalogController.blacklight_config = Blacklight::Configuration.new
+  describe "catalog#show maplet view" do
+
+    before :each do
       CatalogController.configure_blacklight do |config|
-        config.view.maps.type = 'bbox'
-        config.view.maps.bbox_field = 'place_bbox'
+        # add maplet to show partials
+        config.show.partials << :show_maplet
       end
+      visit catalog_path('2008308175')
+    end
+
+    it "should show the maplet" do
+      expect(page).to have_selector("#blacklight-show-map")
     end
 
-    before { visit catalog_index_path :q => 'korea', :view => 'maps' }
+    it "should show the mapped item count" do
+      expect(page).to have_selector(".mapped-count .badge", text: "2")
+    end
 
-    it "should have 4 markers" do
-      expect(find("div.marker-cluster")).to have_content(4)
+    it "should show a bounding box and a point marker" do
+      expect(page).to have_selector(".leaflet-overlay-pane path.leaflet-clickable")
+      expect(page).to have_selector(".leaflet-marker-icon")
     end
 
-    it "should display number mapped" do
-      expect(page).to have_content('4 mapped')
+    describe "click marker icon" do
+
+      before { find(".leaflet-marker-icon").click }
+
+      it "should show a popup with correct content" do
+        expect(page).to have_selector("div.leaflet-popup-content-wrapper")
+        expect(page).to have_content("India")
+      end
+
     end
 
-    describe "click marker cluster" do
-      before { find("div.marker-cluster").click }
+    describe "click bbox path" do
 
-      it "should split into 2 markers" do
-        expect(page).to have_selector('div.marker-cluster', count: 2)
+      before do
+        0.upto(4) { find("a.leaflet-control-zoom-in").click } #so bbox not covered by point
+        find(".leaflet-overlay-pane svg").click
       end
+
+      it "should show a popup with correct content" do
+        expect(page).to have_selector("div.leaflet-popup-content-wrapper")
+        expect(page).to have_content("[68.162386, 6.7535159, 97.395555, 35.5044752]")
+      end
+
     end
+
   end
+
 end