mapplz 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7034405767e5ef4ee3c72c162821971aaa06b27c
-  data.tar.gz: 3cb3eec174363117097f84b9ea8ed093ffb49255
+  metadata.gz: 9e48a7476c329db17d5f066edd761a95aa5c1911
+  data.tar.gz: fa02fbea3993691d2951d7ea22c320b82f7d8fe3
 SHA512:
-  metadata.gz: 19aa227e8159c73ec9fbc3c63519b2613fd0829aecae4a891d48df93309bd0e9a042b44177934713e86eddf6fdd7d4c418afb059e7672e69769c1fe95e111663
-  data.tar.gz: 443b860f75737c92837f1f9ef4a1d5121670470f002229f884e1e9be337dcb319966aeb3c5c4b4a8947324d7770966635c8d670ec72460f7c5260ca309d3b076
+  metadata.gz: d7de31bce69a2215c887d0ddb3ee0a0a5523853108b92a51dd57f63a6eab89ace3f97fc5f95cc393024541869540c0517133058be29655a7dd5900e9e1896e65
+  data.tar.gz: 196c08bb5e6ae90457f206f4110b8260a6d032efa1fe4f9f49063c10d597b495b47062b896f1810a1c94ebadd87e324e80ad74927a64c7fa52c928f13fc5b5b7

data/README.md

@@ -19,6 +19,8 @@ mapstore << [point1, point2]
 
 # a line or shape
 mapstore << [[point1, point2, point3]]
+mapstore << [[point1, point2, point3, point1]]
+mapstore << { path: [point1, point2], label: 'hello world' }
 
 # GeoJSON string or object
 mapstore << { type: "Feature", geometry: { type: "Point", coordinates: [lng, lat] } }
@@ -41,7 +43,7 @@ mapstore << { type: "Feature", geometry: { type: "Point", properties: { name: "B
 
 ## Export HTML and GeoJSON
 
-Currently you can output the data as GeoJSON:
+You can output the data anytime as GeoJSON:
 
 ```
 @mapper = MapPLZ.new
@@ -49,24 +51,44 @@ Currently you can output the data as GeoJSON:
 @mapper.to_geojson
 ```
 
-You will be able to output an interactive, HTML+JavaScript map with Leaflet.js
+You can add interactive, HTML+JavaScript maps which use Leaflet.js
 
 ```
 require 'mapplz'
 
 @mapper = MapPLZ.new
-@mapper << mapplz_code
+@mapper << geo_stuff
 @mapper.render_html
 ```
 
-You would be able to use it in Rails + HAML templates, too:
+This is based on the Leaflet-Rails plugin. Set Leaflet defaults directly:
 
 ```
-div#map
-  = @mapper.embed_html
+Leaflet.tile_layer = 'http://{s}.somedomain.com/blabla/{z}/{x}/{y}.png'
+@mapper.render_html
+```
+
+You can pass options to render_html, including new default styles for lines and shapes:
+
+```
+@mapper.render_html(max_zoom: 18, fillColor: '#00f')
 ```
 
-## MapPLZ queries
+You can also add styles to your data as it's entered into the map datastore.
+
+```
+@mapper << { path: [point1, point2], color: 'red', opacity: 0.8 }
+```
+
+All of these would appear as clickable map features with popups:
+
+```
+@mapper << [40, -70, 'hello popup']
+@mapper << { lat: 40, lng: -80, label: 'hello popup' }
+@mapper << { path: [point1, point2], color: 'red', label: 'the red line' }
+```
+
+## Queries
 
 All of these are valid ways to query geodata:
 
@@ -79,23 +101,17 @@ mapplz.count
 mapplz.count('layer = ?', name_of_layer)
 ```
 
-## MapPLZ language
-You can make a map super quickly by using the MapPLZ language. A MapPLZ map
-can be described using as simply as this:
+## Databases
 
-```
-map
-  marker
-    "The Statue of Liberty"
-    [40, -70]
-  plz
-plz
-```
+You can store geodata in SQLite/Spatialite, Postgres/PostGIS, or MongoDB.
 
-## MapPLZ and Databases
+MapPLZ simplifies geodata management and queries.
 
-You can store geodata in SQLite/Spatialite databases, or in Postgres/PostGIS
-databases, using a simplified MapPLZ API.
+```
+# setting the database
+# if a site uses ActiveRecord, the database will be set automatically
+mapplz.choose_db('postgis')
+```
 
 ```
 # working with records
@@ -114,6 +130,19 @@ mapplz.near([lat, lng])
 mapplz.inside([point1, point2, point3, point1])
 ```
 
+## Language
+You can make a map super quickly by using the MapPLZ language. A MapPLZ map
+can be described using as simply as this:
+
+```
+map
+  marker
+    "The Statue of Liberty"
+    [40, -70]
+  plz
+plz
+```
+
 ## License
 
 Free BSD License

data/lib/mapplz.rb

@@ -2,17 +2,30 @@
 
 require 'sql_parser'
 require 'json'
+include Leaflet::ViewHelpers
 
 # MapPLZ datastore
 class MapPLZ
+  DATABASES = %w(array postgres postgresql postgis sqlite spatialite mongodb)
+
   def initialize
     @db_type = 'array'
     @parser = SqlParser.new
     @my_array = []
+
+    choose_db(ActiveRecord::Base.connection.adapter_name) if defined?(ActiveRecord)
   end
 
-  def add(user_geo)
-    geo_objects = standardize_geo(user_geo)
+  def choose_db(db)
+    db.downcase!
+    fail 'Database type not supported by MapPLZ' unless DATABASES.include?(db)
+    db = 'postgis' if db == 'postgres' || db == 'postgresql'
+    db = 'spatialite' if db == 'sqlite'
+    @db_type = db
+  end
+
+  def add(user_geo, lonlat = false)
+    geo_objects = standardize_geo(user_geo, lonlat)
     @my_array += geo_objects
 
     if geo_objects.length == 1
@@ -31,7 +44,7 @@ class MapPLZ
     end
   end
 
-  def query(where_clause, add_on)
+  def query(where_clause, add_on = nil)
     if where_clause.present?
       if @db_type == 'array'
         query_array(where_clause, add_on)
@@ -71,6 +84,87 @@ class MapPLZ
     geojson.to_json
   end
 
+  def render_html(options = {})
+    # Leaflet options
+    options[:tile_layer] ||= Leaflet.tile_layer
+    options[:attribution] ||= Leaflet.attribution
+    options[:max_zoom] ||= Leaflet.max_zoom
+    options[:container_id] ||= 'map'
+
+    geojson_features = JSON.parse(to_geojson)['features']
+
+    # use Leaflet to add clickable markers
+    options[:markers] = []
+    geojson_features.each do |feature|
+      next if feature['geometry']['type'] != 'Point'
+
+      if feature.key?('properties')
+        if feature['properties'].is_a?(Hash) && feature['properties'].key?('label')
+          label = feature['properties']['label']
+        elsif feature['properties'].key?('properties') && feature['properties']['properties'].is_a?(Array) && feature['properties']['properties'].length == 1
+          label = feature['properties']['properties'][0]
+        end
+      else
+        label = nil
+      end
+      options[:markers] << { latlng: feature['geometry']['coordinates'].reverse, popup: label }
+    end
+
+    render_text = map(options)
+
+    # add clickable lines and polygons after
+    # Leaflet-Rails does not support clickable lines or any polygons
+    geojson_features.each do |feature|
+      next if feature['geometry']['type'] == 'Point'
+
+      label = nil
+      path_options = {}
+      path_options[:color] = options[:color] if options.key?(:color)
+      path_options[:opacity] = options[:opacity] if options.key?(:opacity)
+      path_options[:fillColor] = options[:fillColor] if options.key?(:fillColor)
+      path_options[:fillOpacity] = options[:fillOpacity] if options.key?(:fillOpacity)
+      path_options[:weight] = options[:weight] if options.key?(:weight)
+      path_options[:stroke] = options[:stroke] if options.key?(:stroke)
+
+      if feature.key?('properties')
+        if feature['properties'].key?('label')
+          label = feature['properties']['label']
+        elsif feature['properties'].key?('properties') && feature['properties']['properties'].is_a?(Array) && feature['properties']['properties'].length == 1
+          label = feature['properties']['properties'][0]
+        end
+
+        path_options[:color] = feature['properties']['color'] if feature['properties'].key?('color')
+        path_options[:opacity] = feature['properties']['opacity'].to_f if feature['properties'].key?('opacity')
+        path_options[:fillColor] = feature['properties']['fillColor'] if feature['properties'].key?('fillColor')
+        path_options[:fillOpacity] = feature['properties']['fillOpacity'].to_f if feature['properties'].key?('fillOpacity')
+        path_options[:weight] = feature['properties']['weight'].to_i if feature['properties'].key?('weight')
+        path_options[:stroke] = feature['properties']['stroke'] if feature['properties'].key?('stroke')
+        path_options[:clickable] = true unless label.nil?
+      end
+
+      flip_coordinates = feature['geometry']['coordinates']
+      if flip_coordinates[0][0].is_a?(Array)
+        flip_coordinates.each do |segment|
+          segment.map! { |coord| coord.reverse }
+        end
+      else
+        flip_coordinates.map! { |coord| coord.reverse }
+      end
+
+      if feature['geometry']['type'] == 'Polyline'
+        render_text += ('line = L.polyline(' + flip_coordinates.to_json + ", #{path_options.to_json}).addTo(map);\n").html_safe
+        render_text += "line.bindPopup('#{label}');\n".html_safe unless label.nil?
+      elsif feature['geometry']['type'] == 'Polygon'
+        render_text += ('polygon = L.polygon(' + flip_coordinates[0].to_json + ", #{path_options.to_json}).addTo(map);\n").html_safe
+        render_text += "polygon.bindPopup('#{label}');\n".html_safe unless label.nil?
+      end
+
+      render_text
+    end
+
+    render_text
+  end
+
   # alias methods
 
   # aliases for add
@@ -82,6 +176,11 @@ class MapPLZ
     add(user_geo)
   end
 
+  # aliases for query
+  def where(where_clause, add_on = nil)
+    query(where_clause, add_on)
+  end
+
   # aliases for count
   def size(where_clause = nil, add_on = nil)
     count(where_clause, add_on)
@@ -91,8 +190,36 @@ class MapPLZ
     count(where_clause, add_on)
   end
 
+  # aliases for render_html
+  def embed_html(options = {})
+    render_html(options)
+  end
+
   private
 
+  # internal map object record
+  class GeoItem < Hash
+    def initialize(db)
+      @db_type = db
+    end
+
+    def save!
+      # update record in database
+      unless @db_type == 'array'
+      end
+    end
+
+    def delete_item
+      if @db_type == 'array'
+        keys.each do |key|
+          delete(key)
+        end
+      else
+        # update record in database
+      end
+    end
+  end
+
   def code_line(index)
     return if index >= @code_lines.length
     line = @code_lines[index].strip
@@ -139,24 +266,27 @@ class MapPLZ
       if codeline.index('plz') || codeline.index('please')
 
         if @code_level == 'marker'
-          @code_layers << {
-            lat: @code_latlngs[0][0],
-            lng: @code_latlngs[0][1],
-            label: @code_label || ''
-          }
+          geoitem = GeoItem.new(@db_type)
+          geoitem[:lat] = @code_latlngs[0][0]
+          geoitem[:lng] = @code_latlngs[0][1]
+          geoitem[:label] = @code_label || ''
+
+          @code_layers << geoitem
         elsif @code_level == 'line'
-          @code_layers << {
-            path: @code_latlngs,
-            strokeColor: (@code_color || ''),
-            label: @code_label || ''
-          }
+          geoitem = GeoItem.new(@db_type)
+          geoitem[:path] = @code_latlngs
+          geoitem[:stroke_color] = (@code_color || '')
+          geoitem[:label] = @code_label || ''
+
+          @code_layers << geoitem
         elsif @code_level == 'shape'
-          @code_layers << {
-            paths: @code_latlngs,
-            strokeColor: (@code_color || ''),
-            fillColor: (@code_color || ''),
-            label: @code_label || ''
-          }
+          geoitem = GeoItem.new(@db_type)
+          geoitem[:paths] = @code_latlngs
+          geoitem[:stroke_color] = (@code_color || '')
+          geoitem[:fill_color] = (@code_color || '')
+          geoitem[:label] = @code_label || ''
+
+          @code_layers << geoitem
         end
 
         if @code_button
@@ -210,7 +340,7 @@ class MapPLZ
     code_line(index + 1)
   end
 
-  def standardize_geo(user_geo)
+  def standardize_geo(user_geo, lonlat = false)
     geo_objects = []
 
     if user_geo.is_a?(String)
@@ -223,6 +353,38 @@ class MapPLZ
     end
 
     if user_geo.is_a?(Array) && user_geo.length > 0
+      if user_geo[0].is_a?(Array) && user_geo[0].length > 0
+        if user_geo[0][0].is_a?(Array) || (user_geo[0][0].is_a?(Hash) && user_geo[0][0].key?(:lat) && user_geo[0][0].key?(:lng))
+          # lines and shapes
+          user_geo.map! do |path|
+            path_pts = []
+            path.each do |path_pt|
+              if lonlat
+                lat = path_pt[1] || path_pt[:lat]
+                lng = path_pt[0] || path_pt[:lng]
+              else
+                lat = path_pt[0] || path_pt[:lat]
+                lng = path_pt[1] || path_pt[:lng]
+              end
+              path_pts << [lat, lng]
+            end
+
+            # polygon border repeats first point
+            if path_pts[0] == path_pts.last
+              geo_type = 'polygon'
+            else
+              geo_type = 'polyline'
+            end
+
+            geoitem = GeoItem.new(@db_type)
+            geoitem[:path] = path_pts
+            geoitem[:type] = geo_type
+            geoitem
+          end
+          return user_geo
+        end
+      end
+
       # multiple objects being added? iterate through
       if user_geo[0].is_a?(Hash) || user_geo[0].is_a?(Array)
         user_geo.each do |geo_piece|
@@ -236,10 +398,16 @@ class MapPLZ
       validate_lng = user_geo[1].to_f != 0 || user_geo[1].to_s == '0'
 
       if validate_lat && validate_lng
-        geo_object = {
-          lat: user_geo[0].to_f,
-          lng: user_geo[1].to_f
-        }
+        geo_object = GeoItem.new(@db_type)
+        geo_object[:type] = 'point'
+
+        if lonlat
+          geo_object[:lat] = user_geo[1].to_f
+          geo_object[:lng] = user_geo[0].to_f
+        else
+          geo_object[:lat] = user_geo[0].to_f
+          geo_object[:lng] = user_geo[1].to_f
+        end
       else
         fail 'no latitude or longitude found'
       end
@@ -272,15 +440,52 @@ class MapPLZ
 
       if validate_lat && validate_lng
         # single hash
-        geo_object = {
-          lat: user_geo[validate_lat].to_f,
-          lng: user_geo[validate_lng].to_f
-        }
+        geo_object = GeoItem.new(@db_type)
+        geo_object[:lat] = user_geo[validate_lat].to_f
+        geo_object[:lng] = user_geo[validate_lng].to_f
+        geo_object[:type] = 'point'
+
         user_geo.keys.each do |key|
           next if key == validate_lat || key == validate_lng
           geo_object[key.to_sym] = user_geo[key]
         end
         geo_objects << geo_object
+      elsif user_geo.key?('path') || user_geo.key?(:path)
+        # try line or polygon
+        path_pts = []
+        path = user_geo['path'] if user_geo.key?('path')
+        path = user_geo[:path] if user_geo.key?(:path)
+        path.each do |path_pt|
+          if lonlat
+            lat = path_pt[1] || path_pt[:lat]
+            lng = path_pt[0] || path_pt[:lng]
+          else
+            lat = path_pt[0] || path_pt[:lat]
+            lng = path_pt[1] || path_pt[:lng]
+          end
+          path_pts << [lat, lng]
+        end
+
+        # polygon border repeats first point
+        if path_pts[0] == path_pts.last
+          geo_type = 'polygon'
+        else
+          geo_type = 'polyline'
+        end
+
+        geoitem = GeoItem.new(@db_type)
+        geoitem[:path] = path_pts
+        geoitem[:type] = geo_type
+
+        property_list = user_geo.clone
+        property_list = property_list[:properties] if property_list.key?(:properties)
+        property_list = property_list['properties'] if property_list.key?('properties')
+        property_list.delete(:path)
+        property_list.keys.each do |prop|
+          geoitem[prop.to_sym] = property_list[prop]
+        end
+
+        geo_objects << geoitem
       else
         # try GeoJSON
         if user_geo.key?('type')
@@ -291,7 +496,7 @@ class MapPLZ
             end
           elsif user_geo.key?('geometry') && user_geo['geometry'].key?('coordinates')
             # individual feature
-            geo_object = {}
+            geo_object = GeoItem.new(@db_type)
             coordinates = user_geo['geometry']['coordinates']
             if user_geo.key?('properties')
               user_geo['properties'].keys.each do |key|
@@ -302,6 +507,7 @@ class MapPLZ
             if user_geo['geometry']['type'] == 'Point'
               geo_object[:lat] = coordinates[1].to_f
               geo_object[:lng] = coordinates[0].to_f
+              geo_object[:type] = 'point'
             end
 
             geo_objects << geo_object
@@ -314,7 +520,7 @@ class MapPLZ
             end
           elsif user_geo.key?(:geometry) && user_geo[:geometry].key?(:coordinates)
             # individual feature
-            geo_object = {}
+            geo_object = GeoItem.new(@db_type)
             coordinates = user_geo[:geometry][:coordinates]
             if user_geo.key?(:properties)
               user_geo[:properties].keys.each do |key|
@@ -325,6 +531,7 @@ class MapPLZ
             if user_geo[:geometry][:type] == 'Point'
               geo_object[:lat] = coordinates[1].to_f
               geo_object[:lng] = coordinates[0].to_f
+              geo_object[:type] = 'point'
             end
 
             geo_objects << geo_object
@@ -338,7 +545,7 @@ class MapPLZ
 
   def as_geojson(geo_object)
     if geo_object.key?(:properties)
-      property_list = geo_object[:properties]
+      property_list = { properties: geo_object[:properties] }
     else
       property_list = geo_object.clone
       property_list.delete(:lat)
@@ -351,22 +558,34 @@ class MapPLZ
       properties: property_list
     }
 
-    if geo_object.key?(:lat) && geo_object.key?(:lng)
+    if geo_object[:type] == 'point'
       # point
       output_geo[:geometry] = {
         type: 'Point',
         coordinates: [geo_object[:lng], geo_object[:lat]]
       }
-    else
-      # other geometry
+    elsif geo_object[:type] == 'polyline'
+      # line
       output_geo[:geometry] = {
         type: 'Polyline',
-        coordinates: [geo_object[:path]]
+        coordinates: flip_path(geo_object[:path])
+      }
+    elsif geo_object[:type] == 'polygon'
+      # polygon
+      output_geo[:geometry] = {
+        type: 'Polygon',
+        coordinates: [flip_path(geo_object[:path])]
       }
     end
     output_geo
   end
 
+  def flip_path(path)
+    path.map! do |pt|
+      pt.reverse
+    end
+  end
+
   def query_array(where_clause, add_on = nil)
     # prepare where clause for parse
     where_clause.downcase! unless where_clause.blank?
@@ -378,6 +597,7 @@ class MapPLZ
 
     # filter array
     @my_array.select do |geo_obj|
+      return false if geo_obj.nil?
       is_valid = true
       conditions.each do |condition|
         field = condition[:field]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mapplz
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Nick Doiron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-03 00:00:00.000000000 Z
+date: 2014-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec