mapplz 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7034405767e5ef4ee3c72c162821971aaa06b27c
+  data.tar.gz: 3cb3eec174363117097f84b9ea8ed093ffb49255
+SHA512:
+  metadata.gz: 19aa227e8159c73ec9fbc3c63519b2613fd0829aecae4a891d48df93309bd0e9a042b44177934713e86eddf6fdd7d4c418afb059e7672e69769c1fe95e111663
+  data.tar.gz: 443b860f75737c92837f1f9ef4a1d5121670470f002229f884e1e9be337dcb319966aeb3c5c4b4a8947324d7770966635c8d670ec72460f7c5260ca309d3b076

data/README.md

@@ -0,0 +1,119 @@
+# MapPLZ-Ruby
+
+[MapPLZ](http://mapplz.com) is a framework to make mapping quick and easy in
+your favorite language.
+
+## Getting started
+
+Extract, transform, and load geodata into MapPLZ:
+
+```
+mapstore = MapPLZ.new
+
+# a point
+mapstore << [lat, lng]
+mapstore.add( [lat, lng] )
+
+# multiple points
+mapstore << [point1, point2]
+
+# a line or shape
+mapstore << [[point1, point2, point3]]
+
+# GeoJSON string or object
+mapstore << { type: "Feature", geometry: { type: "Point", coordinates: [lng, lat] } }
+```
+
+Include properties along with the geo data:
+
+```
+# an array of attributes
+pt1 = mapstore << [lat, lng, color, cost]
+pt2 = mapstore << [lat, lng, color2, cost2]
+# pt1.properties = [color, cost]
+
+# a hash or JSON string of attributes
+mapstore << [lat, lng, { color: 'red', cost: 10 }]
+
+# GeoJSON properties
+mapstore << { type: "Feature", geometry: { type: "Point", properties: { name: "Bella" }, coordinates: [lng, lat] } }
+```
+
+## Export HTML and GeoJSON
+
+Currently you can output the data as GeoJSON:
+
+```
+@mapper = MapPLZ.new
+@mapper << mapplz_content
+@mapper.to_geojson
+```
+
+You will be able to output an interactive, HTML+JavaScript map with Leaflet.js
+
+```
+require 'mapplz'
+
+@mapper = MapPLZ.new
+@mapper << mapplz_code
+@mapper.render_html
+```
+
+You would be able to use it in Rails + HAML templates, too:
+
+```
+div#map
+  = @mapper.embed_html
+```
+
+## MapPLZ queries
+
+All of these are valid ways to query geodata:
+
+```
+# with a value
+mapplz.where('layer = ?', name_of_layer)
+
+# get a count
+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:
+
+```
+map
+  marker
+    "The Statue of Liberty"
+    [40, -70]
+  plz
+plz
+```
+
+## MapPLZ and Databases
+
+You can store geodata in SQLite/Spatialite databases, or in Postgres/PostGIS
+databases, using a simplified MapPLZ API.
+
+```
+# working with records
+pt = mapstore << [lat, lng]
+pt.name = "Sears Tower"
+pt.save!
+```
+
+### COMING SOON
+
+```
+# near a point
+mapplz.near([lat, lng])
+
+# in an area
+mapplz.inside([point1, point2, point3, point1])
+```
+
+## License
+
+Free BSD License

data/app/assets/javascripts/mapplz/mapplz.js

@@ -0,0 +1,4 @@
+(function($) {
+  $('.mapplz')
+
+})(jQuery);

data/app/assets/stylesheets/mapplz/mapplz.css.erb

@@ -0,0 +1,12 @@
+#main_map.mapplz {
+  width: 100%;
+  height: 100%;
+  /* prevent 0-height or 0-width div bug */
+  min-width: 150px;
+  min-height: 150px;
+}
+
+/* override bootstrap + Google Maps issue */
+.mapplz img {
+  max-width: 100%;
+}

data/app/views/mapplz/map.html.haml

@@ -0,0 +1 @@
+#main_map.mapplz

data/lib/mapplz.rb

@@ -0,0 +1,410 @@
+# Encoding: utf-8
+
+require 'sql_parser'
+require 'json'
+
+# MapPLZ datastore
+class MapPLZ
+  def initialize
+    @db_type = 'array'
+    @parser = SqlParser.new
+    @my_array = []
+  end
+
+  def add(user_geo)
+    geo_objects = standardize_geo(user_geo)
+    @my_array += geo_objects
+
+    if geo_objects.length == 1
+      geo_objects[0]
+    else
+      geo_objects
+    end
+  end
+
+  def count(where_clause = nil, add_on = nil)
+    results = query(where_clause, add_on)
+    if @db_type == 'array'
+      results.length
+    else
+      results.count
+    end
+  end
+
+  def query(where_clause, add_on)
+    if where_clause.present?
+      if @db_type == 'array'
+        query_array(where_clause, add_on)
+      else
+        # @my_db.where(where_clause, add_on)
+      end
+    else
+      # count all
+      if @db_type == 'array'
+        @my_array
+      else
+        # @my_db.all
+      end
+    end
+  end
+
+  def code(mapplz_code)
+    @code_lines = mapplz_code.gsub("\r", '').split("\n")
+    @code_level = 'toplevel'
+    @button_layers = []
+    @code_button = 0
+    @code_layers = []
+    @code_label = ''
+    @code_color = nil
+    code_line(0)
+    @code_layers
+  end
+
+  def to_geojson
+    feature_list = []
+    if @db_type == 'array'
+      @my_array.each do |feature|
+        feature_list << as_geojson(feature)
+      end
+    end
+    geojson = { type: 'FeatureCollection', features: feature_list }
+    geojson.to_json
+  end
+
+  # alias methods
+
+  # aliases for add
+  def <<(user_geo)
+    add(user_geo)
+  end
+
+  def push(user_geo)
+    add(user_geo)
+  end
+
+  # aliases for count
+  def size(where_clause = nil, add_on = nil)
+    count(where_clause, add_on)
+  end
+
+  def length(where_clause = nil, add_on = nil)
+    count(where_clause, add_on)
+  end
+
+  private
+
+  def code_line(index)
+    return if index >= @code_lines.length
+    line = @code_lines[index].strip
+    codeline = line.downcase.split(' ')
+
+    if @code_level == 'toplevel'
+      @code_level = 'map' if line.index('map')
+      return code_line(index + 1)
+
+    elsif @code_level == 'map' || @code_level == 'button'
+      if codeline.index('button') || codeline.index('btn')
+        @code_level = 'button'
+        @button_layers << { layers: [] }
+        @code_button = @button_layers.length
+      end
+
+      if codeline.index('marker')
+        @code_level = 'marker'
+        @code_latlngs = []
+        return code_line(index + 1)
+      elsif codeline.index('line')
+        @code_level = 'line'
+        @code_latlngs = []
+        return code_line(index + 1)
+      elsif codeline.index('shape')
+        @code_level = 'shape'
+        @code_latlngs = []
+        return code_line(index + 1)
+      end
+
+      if codeline.index('plz') || codeline.index('please')
+        if @code_level == 'map'
+          @code_level = 'toplevel'
+          return
+        elsif @code_level == 'button'
+          # add button
+          @code_level = 'map'
+          @code_button = nil
+          return code_line(index + 1)
+        end
+      end
+
+    elsif @code_level == 'marker' || @code_level == 'line' || @code_level == 'shape'
+      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 || ''
+          }
+        elsif @code_level == 'line'
+          @code_layers << {
+            path: @code_latlngs,
+            strokeColor: (@code_color || ''),
+            label: @code_label || ''
+          }
+        elsif @code_level == 'shape'
+          @code_layers << {
+            paths: @code_latlngs,
+            strokeColor: (@code_color || ''),
+            fillColor: (@code_color || ''),
+            label: @code_label || ''
+          }
+        end
+
+        if @code_button
+          @code_level = 'button'
+        else
+          @code_level = 'map'
+        end
+
+        @code_latlngs = []
+        return code_line(index + 1)
+      end
+
+    end
+
+    # geocoding starts with @
+
+    # reading a color
+    if codeline[0].index('#') == 0
+      @code_color = codeline[0]
+      if @code_color.length != 4 && @code_color.length != 7
+        # named color
+        @code_color = @code_color.gsub('#', '')
+      end
+
+      if @code_level == 'button'
+        # button color
+      end
+
+      return codeline(index + 1)
+    end
+
+    # reading a raw string (probably text for a popup)
+    if codeline[0].index('"') == 0
+      # check button
+      @code_label = line[(line.index('"') + 1)..line.length]
+      @code_label = @code_label[0..(@code_label.index('"') - 1)]
+    end
+
+    # reading a latlng coordinate
+    if line.index('[') && line.index(',') && line.index(']')
+      latlng_line = line.gsub('[', '').gsub(']', '').split(',').map! { |num| num.to_f }
+
+      # must be a 2D coordinate
+      return codeline(index + 1) if latlng_line.length != 2
+
+      @code_latlngs << latlng_line
+
+      return code_line(index + 1)
+    end
+
+    code_line(index + 1)
+  end
+
+  def standardize_geo(user_geo)
+    geo_objects = []
+
+    if user_geo.is_a?(String)
+      begin
+        user_geo = JSON.parse(user_geo)
+      rescue
+        # not JSON string - attempt mapplz parse
+        return code(user_geo)
+      end
+    end
+
+    if user_geo.is_a?(Array) && user_geo.length > 0
+      # 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|
+          geo_objects += standardize_geo(geo_piece)
+        end
+        return geo_objects
+      end
+
+      # first two spots are a coordinate
+      validate_lat = user_geo[0].to_f != 0 || user_geo[0].to_s == '0'
+      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
+        }
+      else
+        fail 'no latitude or longitude found'
+      end
+
+      # assume user properties are an ordered array of values known to the user
+      user_properties = user_geo.drop(2)
+
+      # only one property and it's a hash? it's a hash of properties
+      if user_properties.length == 1 && user_properties[0].is_a?(Hash)
+        user_properties[0].keys.each do |key|
+          geo_object[key.to_sym] = user_properties[0][key]
+        end
+      else
+        geo_object[:properties] = user_properties
+      end
+
+      geo_objects << geo_object
+
+    elsif user_geo.is_a?(Hash)
+      # check for lat and lng
+      validate_lat = false
+      validate_lat = 'lat' if user_geo.key?('lat') || user_geo.key?(:lat)
+      validate_lat ||= 'latitude' if user_geo.key?('latitude') || user_geo.key?(:latitude)
+
+      validate_lng = false
+      validate_lng = 'lng' if user_geo.key?('lng') || user_geo.key?(:lng)
+      validate_lng ||= 'lon' if user_geo.key?('lon') || user_geo.key?(:lon)
+      validate_lng ||= 'long' if user_geo.key?('long') || user_geo.key?(:long)
+      validate_lng ||= 'longitude' if user_geo.key?('longitude') || user_geo.key?(:longitude)
+
+      if validate_lat && validate_lng
+        # single hash
+        geo_object = {
+          lat: user_geo[validate_lat].to_f,
+          lng: user_geo[validate_lng].to_f
+        }
+        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
+      else
+        # try GeoJSON
+        if user_geo.key?('type')
+          if user_geo['type'] == 'FeatureCollection' && user_geo.key?('features')
+            # recursive onto features
+            user_geo['features'].each do |feature|
+              geo_objects += standardize_geo(feature)
+            end
+          elsif user_geo.key?('geometry') && user_geo['geometry'].key?('coordinates')
+            # individual feature
+            geo_object = {}
+            coordinates = user_geo['geometry']['coordinates']
+            if user_geo.key?('properties')
+              user_geo['properties'].keys.each do |key|
+                geo_object[key.to_sym] = user_geo['properties'][key]
+              end
+            end
+
+            if user_geo['geometry']['type'] == 'Point'
+              geo_object[:lat] = coordinates[1].to_f
+              geo_object[:lng] = coordinates[0].to_f
+            end
+
+            geo_objects << geo_object
+          end
+        elsif user_geo.key?(:type)
+          if user_geo[:type] == 'FeatureCollection' && user_geo.key?(:features)
+            # recursive onto features
+            user_geo[:features].each do |feature|
+              geo_objects += standardize_geo(feature)
+            end
+          elsif user_geo.key?(:geometry) && user_geo[:geometry].key?(:coordinates)
+            # individual feature
+            geo_object = {}
+            coordinates = user_geo[:geometry][:coordinates]
+            if user_geo.key?(:properties)
+              user_geo[:properties].keys.each do |key|
+                geo_object[key.to_sym] = user_geo[:properties][key]
+              end
+            end
+
+            if user_geo[:geometry][:type] == 'Point'
+              geo_object[:lat] = coordinates[1].to_f
+              geo_object[:lng] = coordinates[0].to_f
+            end
+
+            geo_objects << geo_object
+          end
+        end
+      end
+    end
+
+    geo_objects
+  end
+
+  def as_geojson(geo_object)
+    if geo_object.key?(:properties)
+      property_list = geo_object[:properties]
+    else
+      property_list = geo_object.clone
+      property_list.delete(:lat)
+      property_list.delete(:lng)
+      property_list.delete(:path)
+    end
+
+    output_geo = {
+      type: 'Feature',
+      properties: property_list
+    }
+
+    if geo_object.key?(:lat) && geo_object.key?(:lng)
+      # point
+      output_geo[:geometry] = {
+        type: 'Point',
+        coordinates: [geo_object[:lng], geo_object[:lat]]
+      }
+    else
+      # other geometry
+      output_geo[:geometry] = {
+        type: 'Polyline',
+        coordinates: [geo_object[:path]]
+      }
+    end
+    output_geo
+  end
+
+  def query_array(where_clause, add_on = nil)
+    # prepare where clause for parse
+    where_clause.downcase! unless where_clause.blank?
+    where_clause = where_clause.gsub('?', '\'?\'') if add_on.present?
+    where_clause = 'select * from bogus_table where ' + where_clause
+
+    # parse where conditions
+    conditions = @parser.parse(where_clause).tree[:conditions]
+
+    # filter array
+    @my_array.select do |geo_obj|
+      is_valid = true
+      conditions.each do |condition|
+        field = condition[:field]
+        compare_value = add_on || condition[:value]
+        operator = condition[:operator].to_s
+
+        # check that key exists
+        is_valid = geo_obj.key?(field)
+        break unless is_valid
+
+        # compare to value
+        if operator == '<'
+          is_valid = geo_obj[field] < compare_value
+        elsif operator == '<='
+          is_valid = geo_obj[field] <= compare_value
+        elsif operator == '>'
+          is_valid = geo_obj[field] > compare_value
+        elsif operator == '>='
+          is_valid = geo_obj[field] >= compare_value
+        elsif operator == '='
+          is_valid = geo_obj[field] == compare_value
+        else
+          fail "#{operator} comparison not supported by MapPLZ on arrays"
+        end
+        break unless is_valid
+      end
+      is_valid
+    end
+  end
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: mapplz
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Nick Doiron
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov-rcov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+description: Quick and easy mapping with MapPLZ
+email:
+- ndoiron@mapmeld.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mapplz.rb
+- app/assets/javascripts/mapplz/mapplz.js
+- app/assets/stylesheets/mapplz/mapplz.css.erb
+- app/views/mapplz/map.html.haml
+- README.md
+homepage: https://github.com/mapmeld/mapplz-ruby
+licenses:
+- BSD
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.10
+signing_key: 
+specification_version: 4
+summary: Quick and easy mapping with MapPLZ
+test_files: []