mapplz 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9e48a7476c329db17d5f066edd761a95aa5c1911
-  data.tar.gz: fa02fbea3993691d2951d7ea22c320b82f7d8fe3
+  metadata.gz: e5045761f3327fe2be26fb1769108ca424ab1689
+  data.tar.gz: 6cf61d9ec132edbd8911b73e0317681c3c68ec43
 SHA512:
-  metadata.gz: d7de31bce69a2215c887d0ddb3ee0a0a5523853108b92a51dd57f63a6eab89ace3f97fc5f95cc393024541869540c0517133058be29655a7dd5900e9e1896e65
-  data.tar.gz: 196c08bb5e6ae90457f206f4110b8260a6d032efa1fe4f9f49063c10d597b495b47062b896f1810a1c94ebadd87e324e80ad74927a64c7fa52c928f13fc5b5b7
+  metadata.gz: 872d06ba820f726ade5184ee11b6d1977009e8209a7b0792b900eb43180abceeffcf77f3096c4b24c1b29bdd8991614af4bcbc725bfe7d9f68e0961fddea30cd
+  data.tar.gz: ae3c23126048c4a306701e3cf64f22ce7184bb45ab3143fed845826194555bb289273110e51ebd0e7197e3074da82a53ed3a25b0c35cb55f26629f529d83320e

data/README.md

@@ -22,7 +22,7 @@ mapstore << [[point1, point2, point3]]
 mapstore << [[point1, point2, point3, point1]]
 mapstore << { path: [point1, point2], label: 'hello world' }
 
-# GeoJSON string or object
+# GeoJSON string or hash
 mapstore << { type: "Feature", geometry: { type: "Point", coordinates: [lng, lat] } }
 ```
 
@@ -51,6 +51,14 @@ You can output the data anytime as GeoJSON:
 @mapper.to_geojson
 ```
 
+Each mapped item can be exported as GeoJSON or WKT
+
+```
+pt = @mapper << { lat: 40, lng: -70 }
+pt.to_wkt
+pt.to_geojson
+```
+
 You can add interactive, HTML+JavaScript maps which use Leaflet.js
 
 ```
@@ -93,6 +101,9 @@ All of these would appear as clickable map features with popups:
 All of these are valid ways to query geodata:
 
 ```
+# return all
+mapplz.query
+
 # with a value
 mapplz.where('layer = ?', name_of_layer)
 
@@ -101,6 +112,13 @@ mapplz.count
 mapplz.count('layer = ?', name_of_layer)
 ```
 
+Queries are returned as an array of GeoItems, which each can be exported as GeoJSON or WKT
+
+```
+my_features = @mapper.where('points > 10')
+collection = { type: 'FeatureCollection', features: my_features.map { |feature| JSON.parse(feature.to_geojson) } }
+```
+
 ## Databases
 
 You can store geodata in SQLite/Spatialite, Postgres/PostGIS, or MongoDB.
@@ -118,6 +136,35 @@ mapplz.choose_db('postgis')
 pt = mapstore << [lat, lng]
 pt.name = "Sears Tower"
 pt.save!
+pt.delete_item
+```
+
+### Database Setup
+
+```
+# MongoDB
+require 'mongo'
+mongo_client = Mongo::MongoClient.new
+database = mongo_client['mapplz']
+collection = database['geoitems']
+mapstore = MapPLZ.new(collection)
+mapstore.choose_db('mongodb')
+
+# PostGIS
+require 'pg'
+conn = PG.connect(dbname: 'your_db')
+conn.exec('CREATE TABLE mapplz (id SERIAL PRIMARY KEY, label VARCHAR(30), geom public.geometry)')
+mapstore = MapPLZ.new(conn)
+mapstore.choose_db('postgis')
+
+# Spatialite
+require 'sqlite3'
+db = SQLite3::Database.new('data/mapplz.sqlite')
+db.execute(".load 'libspatialite.so'")
+db.execute('CREATE TABLE mapplz (id INTEGER PRIMARY KEY AUTOINCREMENT, label VARCHAR(30), geom BLOB NOT NULL)')
+db.execute("SELECT CreateSpatialIndex('mapplz', 'geom')")
+mapstore = MapPLZ.new(db)
+mapstore.choose_db('spatialite')
 ```
 
 ### COMING SOON
@@ -135,12 +182,13 @@ You can make a map super quickly by using the MapPLZ language. A MapPLZ map
 can be described using as simply as this:
 
 ```
-map
+mymap = """map
   marker
     "The Statue of Liberty"
     [40, -70]
   plz
-plz
+plz"""
+@mapper << mymap
 ```
 
 ## License

data/lib/mapplz.rb

@@ -8,11 +8,17 @@ include Leaflet::ViewHelpers
 class MapPLZ
   DATABASES = %w(array postgres postgresql postgis sqlite spatialite mongodb)
 
-  def initialize
+  def initialize(db = {})
     @db_type = 'array'
-    @parser = SqlParser.new
+    @db_client = db
+    @db = {
+      client: @db_client,
+      type: @db_type
+    }
     @my_array = []
 
+    @parser = SqlParser.new
+
     choose_db(ActiveRecord::Base.connection.adapter_name) if defined?(ActiveRecord)
   end
 
@@ -21,12 +27,32 @@ class MapPLZ
     fail 'Database type not supported by MapPLZ' unless DATABASES.include?(db)
     db = 'postgis' if db == 'postgres' || db == 'postgresql'
     db = 'spatialite' if db == 'sqlite'
+    db = 'mongodb' if db == 'mongo'
     @db_type = db
+    @db[:type] = db
   end
 
   def add(user_geo, lonlat = false)
     geo_objects = standardize_geo(user_geo, lonlat)
-    @my_array += geo_objects
+
+    if @db_type == 'array'
+      @my_array += geo_objects
+    elsif @db_type == 'mongodb'
+      geo_objects.each do |geo_object|
+        reply = @db_client.insert(geo_object)
+        geo_object[:_id] = reply.to_s
+      end
+    elsif @db_type == 'postgis' || @db_type == 'spatialite'
+      geo_objects.each do |geo_object|
+        geom = geo_object.to_wkt
+        if @db_type == 'postgis'
+          reply = @db_client.exec("INSERT INTO mapplz (label, geom) VALUES ('#{geo_object[:label] || ''}', ST_GeomFromText('#{geom}')) RETURNING id")
+        elsif @db_type == 'spatialite'
+          reply = @db_client.execute("INSERT INTO mapplz (label, geom) VALUES ('#{geo_object[:label] || ''}', AsText('#{geom}')) RETURNING id")
+        end
+        geo_object[:id] = reply[0]['id']
+      end
+    end
 
     if geo_objects.length == 1
       geo_objects[0]
@@ -39,26 +65,98 @@ class MapPLZ
     results = query(where_clause, add_on)
     if @db_type == 'array'
       results.length
+    elsif @db_type == 'mongodb'
+      if where_clause.present?
+        # @db_client.find().count
+      else
+        @db_client.count
+      end
     else
       results.count
     end
   end
 
-  def query(where_clause, add_on = nil)
+  def query(where_clause = nil, add_on = nil)
     if where_clause.present?
       if @db_type == 'array'
-        query_array(where_clause, add_on)
+        geo_results = query_array(where_clause, add_on)
+      elsif @db_type == 'mongodb'
+        conditions = parse_sql(where_clause, add_on = nil)
+        mongo_conditions = {}
+        conditions.each do |condition|
+          field = condition[:field]
+          compare_value = add_on || condition[:value]
+          operator = condition[:operator].to_s
+
+          mongo_conditions[field] = compare_value if operator == '='
+          mongo_conditions[field] = { '$lt' => compare_value } if operator == '<'
+          mongo_conditions[field] = { '$lte' => compare_value } if operator == '<='
+          mongo_conditions[field] = { '$gt' => compare_value } if operator == '>'
+          mongo_conditions[field] = { '$gte' => compare_value } if operator == '>='
+        end
+
+        cursor = @db_client.find(mongo_conditions)
+      elsif @db_type == 'postgis' || @db_type == 'spatialite'
+        if add_on.is_a?(String)
+          where_clause = where_clause.gsub('?', "'#{add_on}'")
+        elsif add_on.is_a?(Integer) || add_on.is_a?(Float)
+          where_clause = where_clause.gsub('?', "#{add_on}")
+        end
+
+        cursor = @db_client.exec("SELECT id, ST_AsText(geom) AS geom, label FROM mapplz WHERE #{where_clause}") if @db_type == 'postgis'
+        cursor = @db_client.execute("SELECT id, AsText(geom) AS geom, label FROM mapplz WHERE #{where_clause}") if @db_type == 'spatialite'
       else
         # @my_db.where(where_clause, add_on)
       end
     else
-      # count all
+      # query all
       if @db_type == 'array'
-        @my_array
+        geo_results = @my_array
+      elsif @db_type == 'mongodb'
+        cursor = @db_client.find
+      elsif @db_type == 'postgis'
+        cursor = @db_client.exec('SELECT id, ST_AsText(geom) AS geom, label FROM mapplz')
+      elsif @db_type == 'spatialite'
+        cursor = @db_client.execute('SELECT id, AsText(geom) AS geom, label FROM mapplz')
       else
         # @my_db.all
       end
     end
+
+    unless cursor.nil?
+      geo_results = []
+      cursor.each do |geo_result|
+        geo_item = GeoItem.new
+        geo_result.keys.each do |key|
+          next if [:geom].include?(key.to_sym)
+          geo_item[key.to_sym] = geo_result[key]
+        end
+
+        if @db_type == 'postgis' || @db_type == 'spatialite'
+          geom = (geo_result['geom'] || geo_result[:geom]).upcase
+          if geom.index('POINT')
+            coordinates = geom.gsub('POINT', '').gsub('(', '').gsub(')', '').split(' ')
+            geo_item[:lat] = coordinates[1].to_f
+            geo_item[:lng] = coordinates[0].to_f
+          elsif geom.index('LINESTRING')
+            line_nodes = geom.gsub('LINESTRING', '').gsub('(', '').gsub(')', '').split(',')
+            geo_item[:path] = line_nodes.map do |pt|
+              pt = pt.split(' ')
+              [pt[1].to_f, pt[0].to_f]
+            end
+          elsif geom.index('POLYGON')
+            line_nodes = geom.gsub('POLYGON', '').gsub('(', '').gsub(')', '').split(', ')
+            geo_item[:path] = line_nodes.map do |pt|
+              pt = pt.split(' ')
+              [pt[1].to_f, pt[0].to_f]
+            end
+          end
+        end
+        geo_results << geo_item
+      end
+    end
+
+    geo_results
   end
 
   def code(mapplz_code)
@@ -74,13 +172,7 @@ class MapPLZ
   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 = { type: 'FeatureCollection', features: query.map { |feature| JSON.parse(feature.to_geojson) } }
     geojson.to_json
   end
 
@@ -110,7 +202,7 @@ class MapPLZ
       options[:markers] << { latlng: feature['geometry']['coordinates'].reverse, popup: label }
     end
 
-    render_text = map(options)
+    render_text = map(options).gsub('</script>', '')
 
     # add clickable lines and polygons after
     # Leaflet-Rails does not support clickable lines or any polygons
@@ -151,18 +243,22 @@ class MapPLZ
         flip_coordinates.map! { |coord| coord.reverse }
       end
 
-      if feature['geometry']['type'] == 'Polyline'
+      if feature['geometry']['type'] == 'LineString'
         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
+    render_text + '</script>'
+  end
+
+  def self.flip_path(path)
+    path.map! do |pt|
+      [pt[1].to_f, pt[0].to_f]
+    end
   end
 
   # alias methods
@@ -177,7 +273,7 @@ class MapPLZ
   end
 
   # aliases for query
-  def where(where_clause, add_on = nil)
+  def where(where_clause = nil, add_on = nil)
     query(where_clause, add_on)
   end
 
@@ -199,13 +295,32 @@ class MapPLZ
 
   # internal map object record
   class GeoItem < Hash
-    def initialize(db)
-      @db_type = db
+    def initialize(db = { type: 'array', client: nil })
+      @db = db
+      @db_type = db[:type]
+      @db_client = db[:client]
     end
 
     def save!
       # update record in database
-      unless @db_type == 'array'
+      if @db_type == 'mongodb'
+        consistent_id = self[:_id]
+        delete(:_id)
+        @db[:client].update({ _id: BSON::ObjectId(consistent_id) }, self)
+        self[:_id] = consistent_id
+      elsif @db_type == 'postgis' || @db_type == 'spatialite'
+        updaters = []
+        keys.each do |key|
+          next if [:id, :lat, :lng, :path, :type].include?(key)
+          updaters << "#{key} = '#{self[key]}'" if self[key].is_a?(String)
+          updaters << "#{key} = #{self[key]}" if self[key].is_a?(Integer) || self[key].is_a?(Float)
+        end
+        updaters << "geom = ST_GeomFromText('#{to_wkt}')" if @db_type == 'postgis'
+        updaters << "geom = AsText('#{to_wkt}')" if @db_type == 'spatialite'
+        if updaters.length > 0
+          @db_client.exec("UPDATE mapplz SET #{updaters.join(', ')} WHERE id = #{self[:id]}") if @db_type == 'postgis'
+          @db_client.execute("UPDATE mapplz SET #{updaters.join(', ')} WHERE id = #{self[:id]}") if @db_type == 'spatialite'
+        end
       end
     end
 
@@ -214,9 +329,69 @@ class MapPLZ
         keys.each do |key|
           delete(key)
         end
-      else
+      elsif @db_type == 'mongodb'
         # update record in database
+        @db[:client].remove(_id: BSON::ObjectId(self[:_id]))
+      elsif @db_type == 'postgis'
+        @db_client.exec("DELETE FROM mapplz WHERE id = #{self[:id]}")
+      elsif @db_type == 'spatialite'
+        @db_client.execute("DELETE FROM mapplz WHERE id = #{self[:id]}")
+      end
+    end
+
+    def to_wkt
+      if self[:type] == 'point'
+        geom = "POINT(#{self[:lng]} #{self[:lat]})"
+      elsif self[:type] == 'polyline'
+        linestring = self[:path].map do |path_pt|
+          "#{path_pt[1]} #{path_pt[0]}"
+        end
+        geom = "LINESTRING(#{linestring.join(', ')})"
+      elsif self[:type] == 'polygon'
+        linestring = self[:path][0].map do |path_pt|
+          "#{path_pt[1]} #{path_pt[0]}"
+        end
+        geom = "POLYGON((#{linestring.join(', ')}))"
       end
+      geom
+    end
+
+    def to_geojson
+      if key?(:properties)
+        property_list = { properties: self[:properties] }
+      else
+        property_list = self.clone
+        property_list.delete(:lat)
+        property_list.delete(:lng)
+        property_list.delete(:path)
+        property_list.delete(:type)
+      end
+
+      output_geo = {
+        type: 'Feature',
+        properties: property_list
+      }
+
+      if self[:type] == 'point'
+        # point
+        output_geo[:geometry] = {
+          type: 'Point',
+          coordinates: [self[:lng], self[:lat]]
+        }
+      elsif self[:type] == 'polyline'
+        # line
+        output_geo[:geometry] = {
+          type: 'LineString',
+          coordinates: MapPLZ.flip_path(self[:path])
+        }
+      elsif self[:type] == 'polygon'
+        # polygon
+        output_geo[:geometry] = {
+          type: 'Polygon',
+          coordinates: [MapPLZ.flip_path(self[:path])]
+        }
+      end
+      output_geo.to_json
     end
   end
 
@@ -266,21 +441,21 @@ class MapPLZ
       if codeline.index('plz') || codeline.index('please')
 
         if @code_level == 'marker'
-          geoitem = GeoItem.new(@db_type)
+          geoitem = GeoItem.new(@db)
           geoitem[:lat] = @code_latlngs[0][0]
           geoitem[:lng] = @code_latlngs[0][1]
           geoitem[:label] = @code_label || ''
 
           @code_layers << geoitem
         elsif @code_level == 'line'
-          geoitem = GeoItem.new(@db_type)
+          geoitem = GeoItem.new(@db)
           geoitem[:path] = @code_latlngs
           geoitem[:stroke_color] = (@code_color || '')
           geoitem[:label] = @code_label || ''
 
           @code_layers << geoitem
         elsif @code_level == 'shape'
-          geoitem = GeoItem.new(@db_type)
+          geoitem = GeoItem.new(@db)
           geoitem[:paths] = @code_latlngs
           geoitem[:stroke_color] = (@code_color || '')
           geoitem[:fill_color] = (@code_color || '')
@@ -376,7 +551,7 @@ class MapPLZ
               geo_type = 'polyline'
             end
 
-            geoitem = GeoItem.new(@db_type)
+            geoitem = GeoItem.new(@db)
             geoitem[:path] = path_pts
             geoitem[:type] = geo_type
             geoitem
@@ -398,7 +573,7 @@ class MapPLZ
       validate_lng = user_geo[1].to_f != 0 || user_geo[1].to_s == '0'
 
       if validate_lat && validate_lng
-        geo_object = GeoItem.new(@db_type)
+        geo_object = GeoItem.new(@db)
         geo_object[:type] = 'point'
 
         if lonlat
@@ -440,7 +615,7 @@ class MapPLZ
 
       if validate_lat && validate_lng
         # single hash
-        geo_object = GeoItem.new(@db_type)
+        geo_object = GeoItem.new(@db)
         geo_object[:lat] = user_geo[validate_lat].to_f
         geo_object[:lng] = user_geo[validate_lng].to_f
         geo_object[:type] = 'point'
@@ -473,7 +648,7 @@ class MapPLZ
           geo_type = 'polyline'
         end
 
-        geoitem = GeoItem.new(@db_type)
+        geoitem = GeoItem.new(@db)
         geoitem[:path] = path_pts
         geoitem[:type] = geo_type
 
@@ -488,6 +663,16 @@ class MapPLZ
         geo_objects << geoitem
       else
         # try GeoJSON
+        if user_geo.key?(:type)
+          user_geo['type'] = user_geo[:type] || ''
+          user_geo['features'] = user_geo[:features] if user_geo.key?(:features)
+          user_geo['properties'] = user_geo[:properties] || {}
+          if user_geo.key?(:geometry)
+            user_geo['geometry'] = user_geo[:geometry]
+            user_geo['geometry']['type'] = user_geo[:geometry][:type]
+            user_geo['geometry']['coordinates'] = user_geo[:geometry][:coordinates]
+          end
+        end
         if user_geo.key?('type')
           if user_geo['type'] == 'FeatureCollection' && user_geo.key?('features')
             # recursive onto features
@@ -495,46 +680,68 @@ class MapPLZ
               geo_objects += standardize_geo(feature)
             end
           elsif user_geo.key?('geometry') && user_geo['geometry'].key?('coordinates')
-            # individual feature
-            geo_object = GeoItem.new(@db_type)
+            # each feature
             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 = GeoItem.new(@db)
               geo_object[:lat] = coordinates[1].to_f
               geo_object[:lng] = coordinates[0].to_f
               geo_object[:type] = 'point'
+              geo_objects << geo_object
+            elsif user_geo['geometry']['type'] == 'LineString'
+              geo_object = GeoItem.new(@db)
+              MapPLZ.flip_path(coordinates)
+              geo_object[:path] = coordinates
+              geo_object[:type] = 'polyline'
+              geo_objects << geo_object
+            elsif user_geo['geometry']['type'] == 'Polygon'
+              geo_object = GeoItem.new(@db)
+              coordinates.map! do |ring|
+                MapPLZ.flip_path(ring)
+              end
+              geo_object[:path] = coordinates
+              geo_object[:type] = 'polygon'
+              geo_objects << geo_object
+            elsif user_geo['geometry']['type'] == 'MultiPoint'
+              coordinates.each do |point|
+                geo_object = GeoItem.new(@db)
+                geo_object[:lat] = point[1].to_f
+                geo_object[:lng] = point[0].to_f
+                geo_object[:type] = 'point'
+                geo_objects << geo_object
+              end
+            elsif user_geo['geometry']['type'] == 'MultiLineString'
+              coordinates.each do |line|
+                geo_object = GeoItem.new(@db)
+                geo_object[:path] = MapPLZ.flip_path(line)
+                geo_object[:type] = 'polyline'
+                geo_objects << geo_object
+              end
+            elsif user_geo['geometry']['type'] == 'MultiPolygon'
+              coordinates.each do |poly|
+                geo_object = GeoItem.new(@db)
+                poly.map! do |ring|
+                  MapPLZ.flip_path(ring)
+                end
+                geo_object[:path] = poly
+                geo_object[:type] = 'polygon'
+                geo_objects << geo_object
+              end
             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 = GeoItem.new(@db_type)
-            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]
+            # store properties on all generated geometries
+            prop_keys = {}
+            if user_geo.key?('properties')
+              user_geo['properties'].keys.each do |key|
+                prop_keys[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
-              geo_object[:type] = 'point'
+            geo_objects.each do |geo|
+              prop_keys.keys.each do |key|
+                geo[key] = prop_keys[key]
+              end
             end
-
-            geo_objects << geo_object
           end
         end
       end
@@ -543,57 +750,18 @@ class MapPLZ
     geo_objects
   end
 
-  def as_geojson(geo_object)
-    if geo_object.key?(:properties)
-      property_list = { properties: 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[:type] == 'point'
-      # point
-      output_geo[:geometry] = {
-        type: 'Point',
-        coordinates: [geo_object[:lng], geo_object[:lat]]
-      }
-    elsif geo_object[:type] == 'polyline'
-      # line
-      output_geo[:geometry] = {
-        type: 'Polyline',
-        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
+  def parse_sql(where_clause, add_on = nil)
     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]
+    @parser.parse(where_clause).tree[:conditions]
+  end
+
+  def query_array(where_clause, add_on = nil)
+    # prepare where clause for parse
+    conditions = parse_sql(where_clause, add_on)
 
     # filter array
     @my_array.select do |geo_obj|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mapplz
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Nick Doiron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-04 00:00:00.000000000 Z
+date: 2014-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -116,9 +116,6 @@ 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:

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

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

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

@@ -1,12 +0,0 @@
-#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

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