mapwkt 1.0.0

data/lib/mapwkt/gmap/map.rb

@@ -0,0 +1,140 @@
+# encoding: UTF-8
+
+class MapWKT::Map
+  def center
+    return @center if @center
+    return if self.overlays.empty?
+    
+    n, s, e, w = nil
+    
+    self.overlays.each do |o|
+      n = o.center.y if !n || o.center.y > n
+      s = o.center.y if !s || o.center.y < s
+      e = o.center.x if !e || o.center.x > e
+      w = o.center.x if !w || o.center.x < w
+    end
+    
+    x = (e + w) / 2
+    y = (n + s) / 2
+    
+    @center = MapWKT::Geometry::Point.new(y, x)
+  end
+  
+  def center= (center)
+    return unless MapWKT::Geometry::Point === center
+    @center = center
+  end
+  
+  def id
+    @id
+  end
+  
+  def id= (id)
+    return unless id
+    raise(ArgumentError, "invalid HTML id: #{id.to_json}") unless id =~ /^[a-zA-Z][\w\d.:-]*$/
+    @id = id
+  end
+  
+  def initialize (arg = {})
+    @overlays = []
+    
+    self.options = case arg
+      when String then { id: arg }
+      when Hash then arg
+      else {}
+    end
+  end
+  
+  def js_initialize
+    "mapwkt_#{self.object_id}_initialize()"
+  end
+  
+  def js_output (arg = {})
+    self.options = case arg
+      when String then { id: arg }
+      when Hash then arg
+      else {}
+    end
+    
+    raise(ArgumentError, "HMTL id is required") unless self.id
+    
+<<-JAVASCRIPT.gsub('new google.maps.LatLng','new p')
+function mapwkt_#{self.object_id}_initialize ()
+{
+  var p = google.maps.LatLng
+  var element = document.getElementById('#{self.id}')
+  var options = { center: new google.maps.LatLng(#{self.center.latitude_f},#{self.center.longitude_f}), mapTypeId: google.maps.MapTypeId.#{self.map_type_id}, zoom: #{self.zoom} }
+  var map = new google.maps.Map(element, options)
+  #{self.overlays.map {|obj| obj.js_output('map') }.join("\n  ")}
+}
+JAVASCRIPT
+  end
+  
+  def map_type_id
+    @map_type_id ||= 'ROADMAP'
+  end
+  
+  def map_type_id= (map_type_id)
+    return unless map_type_id
+    @map_type_id = ([map_type_id.to_s.upcase] & %w:HYBRID ROADMAP SATELLITE TERRAIN:).first || 'ROADMAP'
+  end
+  
+  def options
+    {
+      center: self.center,
+      id: self.id,
+      map_type_id: self.map_type_id,
+      zoom: self.zoom
+    }
+  end
+  
+  def options= (options)
+    options.symbolize_keys!
+    self.center = options[:center] || self.center
+    self.id = options[:id] || self.id
+    self.map_type_id = options[:map_type_id] || options[:mapTypeId] || self.map_type_id
+    self.zoom = options[:zoom] || self.zoom || 10
+  end
+  
+  def overlays
+    self.refresh!
+    @overlays
+  end
+  
+  def refresh!
+    return self if @refreshed
+    @refreshed = true
+    
+    self.overlays.select! {|p| MapWKT::Overlay === p }
+    self
+  end
+  
+  def zoom
+    @zoom ||= 10
+  end
+  
+  def zoom= (zoom)
+    return unless zoom
+    @zoom = [0,[zoom.to_i, 25].min].max
+  end
+  
+  def << (obj)
+    overlays = case obj
+      when MapWKT::Geometry then [MapWKT::Overlay.new(obj)]
+      when MapWKT::Overlay then [obj]
+    else
+      raise(TypeError, "method `wkt' is not defined for #{obj.inspect}") unless obj.respond_to?(:wkt)
+      
+      MapWKT::Geometry.parse_wkt(obj.wkt).map do |g|
+        {
+          MapWKT::Geometry::Point => MapWKT::Overlay::Marker,
+          MapWKT::Geometry::LineString => MapWKT::Overlay::Polyline,
+          MapWKT::Geometry::Polygon => MapWKT::Overlay::Polygon
+        }[g.class].new(g, obj)
+      end
+    end
+    
+    self.overlays.push(*overlays)
+    self
+  end
+end

data/lib/mapwkt/gmap/marker.rb

@@ -0,0 +1,7 @@
+# encoding: UTF-8
+
+class MapWKT::Overlay::Marker < MapWKT::Overlay
+  def js_output (map_name = nil)
+    "new google.maps.Marker({#{" map: #{map_name}," if map_name} position: new google.maps.LatLng(#{self.geometry.latitude_f},#{self.geometry.longitude_f}) })"
+  end
+end

data/lib/mapwkt/gmap/overlay.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+
+class MapWKT::Overlay
+  def center
+    self.geometry.center
+  end
+  
+  def geometry
+    @geometry
+  end
+  
+  def initialize (geometry, source)
+    @geometry = geometry
+    @source = source
+  end
+  
+  def source
+    @source
+  end
+end

data/lib/mapwkt/gmap/polygon.rb

@@ -0,0 +1,12 @@
+# encoding: UTF-8
+
+class MapWKT::Overlay::Polygon < MapWKT::Overlay
+  def js_output (map_name = nil)
+    paths = [self.geometry.perimeter, *self.geometry.lacunae].map do |g|
+      points = [*g.points, g.points.first]
+      "[#{points.map {|p| "new google.maps.LatLng(#{p.latitude_f},#{p.longitude_f})" }.join(?,)}]"
+    end.join(?,)
+    
+    "new google.maps.Polygon({#{" map: #{map_name}," if map_name} paths: [#{paths}] })"
+  end
+end

data/lib/mapwkt/gmap/polyline.rb

@@ -0,0 +1,10 @@
+# encoding: UTF-8
+
+class MapWKT::Overlay::Polyline < MapWKT::Overlay
+  def js_output (map_name = nil)
+    points = self.geometry.open? ? self.geometry.points : [*self.geometry.points, self.geometry.points.first]
+    path = "[#{points.map {|p| "new google.maps.LatLng(#{p.latitude_f},#{p.longitude_f})" }.join(?,)}]"
+    
+    "new google.maps.Polyline({#{" map: #{map_name}," if map_name} path: #{path} })"
+  end
+end

data/lib/mapwkt/wkt/geometry.rb

@@ -0,0 +1,77 @@
+# encoding: UTF-8
+
+class MapWKT::Geometry
+  def self.parse_wkt (wkt_string)
+    # Remove extraneous whitespace.
+    s = wkt_string.to_s.upcase.strip.gsub(/\s*([),(])\s*/,'\1').gsub(/\s+/,' ')
+    
+    case s
+      when /^POINT\(([\d\s.-]*?)\)$/
+        x, y = self.parse_x_y $1
+        [MapWKT::Geometry::Point.new(y,x)]
+      
+      when /^LINESTRING\(([\d\s,.-]*?)\)$/
+        points = self.parse_points $1
+        [MapWKT::Geometry::LineString.new(*points)]
+      
+      when /^POLYGON\((\([\d\s,.-]*?\)(?:,\([\d\s,.-]*?\))*)\)$/
+        perimeter, lacunae = self.parse_linestrings $1
+        [MapWKT::Geometry::Polygon.new(perimeter, *lacunae)]
+      
+      when /^MULTIPOINT\(([\d\s,.-]*?)\)$/
+        self.parse_points $1
+      
+      when /^MULTIPOINT\((\([\d\s,.-]*?\)(?:,\([\d\s,.-]*?\))*)\)$/
+        points_string = $1.gsub(/[()]/,'')
+        self.parse_points(points_string)
+      
+      when /^MULTILINESTRING\((\([\d\s,.-]*?\)(?:,\([\d\s,.-]*?\))*)\)$/
+        self.parse_linestrings $1
+      
+      when /^MULTIPOLYGON\((\(\([\d\s,.-]*?\)(?:,\([\d\s,.-]*?\))*\)(?:,\(\([\d\s,.-]*?\)(?:,\([\d\s,.-]*?\))*\))*)\)$/
+        self.parse_polygons $1
+      
+      when /^GEOMETRYCOLLECTION\((.*?)\)$/
+        wkt_strings = $1.scan(/([A-Z]+\(.*?\))(?=,[A-Z]|$)/).flatten
+        wkt_strings.map {|wkt_string| self.parse_wkt(wkt_string) }.flatten
+      
+    else
+      raise SyntaxError
+    end
+    
+  rescue SyntaxError
+    raise SyntaxError, "not a valid WKT string: #{wkt_string.inspect}"
+  end
+  
+  def self.parse_polygons (polygons_string)
+    # Create Polygons from each "((x y, …), (x y, …))" in the polygons string.
+    polygons_string.scan(/\((\(.*?\))\)/).flatten.map do |linestrings_string|
+      perimeter, lacunae = self.parse_linestrings(linestrings_string)
+      MapWKT::Geometry::Polygon.new(perimeter, *lacunae)
+    end
+  end
+  
+  def self.parse_linestrings (linestrings_string)
+    # Create LineStrings from each "(x y, …)" in the linestrings string.
+    linestrings_string.scan(/\((.*?)\)/).flatten.map do |points_string|
+      points = self.parse_points(points_string)
+      MapWKT::Geometry::LineString.new(*points)
+    end
+  end
+  
+  def self.parse_points (points_string)
+    # Create Points from each "x y" in the points string.
+    points_string.split(?,).map do |x_y_string|
+      x, y = self.parse_x_y(x_y_string)
+      MapWKT::Geometry::Point.new(y,x)
+    end
+  end
+  
+  def self.parse_x_y (x_y_string)
+    # Check the string.
+    raise SyntaxError unless x_y_string =~ /^(-?\d+(?:\.\d+)?)\s(-?\d+(?:\.\d+)?)$/
+    
+    # Return the x and y values.
+    [$1, $2].map(&:to_f)
+  end
+end

data/lib/mapwkt/wkt/line_string.rb

@@ -0,0 +1,97 @@
+# encoding: UTF-8
+
+class MapWKT::Geometry::LineString < MapWKT::Geometry
+  # Returns a Point midway between the N/S- & E/W-most Points in the LineString.
+  def center
+    return if self.points.empty?
+    n, s, e, w = nil
+    
+    self.points.each do |p|
+      n = p.y if !n || p.y > n
+      s = p.y if !s || p.y < s
+      e = p.x if !e || p.x > e
+      w = p.x if !w || p.x < w
+    end
+    
+    x = (e + w) / 2
+    y = (n + s) / 2
+    
+    Point.new(y, x)
+  end
+  
+  # Returns this LineString after closing its endpoints.
+  def close!
+    self.refresh! unless @refreshed
+    @closed = true
+    self
+  end
+  
+  # Returns true if this LineString is closed, false otherwise.
+  def closed?
+    self.refresh!
+    @closed ||= false
+  end
+  
+  # Returns a new LineString with the same geographic Points as this LineString.
+  def dup
+    points = self.points.map(&:dup)
+    LineString(*points).tap {|ls| ls.close! if self.closed? }
+  end
+  
+  # Returns a new LineString containing the given Points.
+  def initialize (*points)
+    @points = points
+    self.refresh!
+  end
+  
+  # Returns false if this LineString is closed, true otherwise.
+  def open?
+    !self.closed?
+  end
+  
+  # Returns this LineString after opening its endpoints.
+  def open!
+    self.refresh!
+    @closed = false
+    self
+  end
+  
+  # Returns the array of Points in this LineString.
+  def points
+    self.refresh!
+    @points
+  end
+  
+  # Removes any non-Point objects from this LineString's #points array. If the
+  # first Point has been added to the end of the #points array, closes the
+  # LineString and removes the Point. Returns this LineString.
+  def refresh!
+    return self if @refreshed
+    @refreshed = true
+    
+    self.points.select! {|p| MapWKT::Geometry::Point === p }
+    
+    while (self.points.many?) && (self.points.last == self.points.first)
+      self.points.pop
+      @closed = true
+    end
+    
+    self
+  end
+  
+  # Returns a string representation of this LineString. ⤿ indicates an open
+  # LineString, while ⟲ indicates a closed LineString.
+  def to_s
+    points = self.points.join(", ")
+    marker = self.closed? ? ?⟲ : ?⤿
+    
+    "#{marker} #{points} #{marker} "
+  end
+  
+  # Returns this LineString's WKT representation, with latitudes and longitudes
+  # rounded to 7 decimal places.
+  def wkt
+    points = self.open? ? self.points : [*self.points, self.points.first]
+    "LINESTRING(#{points.map {|p| "#{p.longitude_f} #{p.latitude_f}" }.join(", ")})"
+  end
+end

data/lib/mapwkt/wkt/point.rb

@@ -0,0 +1,123 @@
+# encoding: UTF-8
+
+class MapWKT::Geometry::Point < MapWKT::Geometry
+  # Returns a new Point with the same latitude and longitude as this Point.
+  def center
+    self.dup
+  end
+  
+  # Returns true if this Point lies in the eastern hemisphere, false otherwise.
+  def east?
+    self.longitude > 0
+  end
+  
+  # Returns true if this Point lies on the equator, false otherwise.
+  def equator?
+    self.latitude == 0
+  end
+  
+  # Returns a new MapWKT::Geometry::Point with latitude and longitude normalized
+  # to fit within the range [-90,90] for latitude and (-180,180] for longitude.
+  def initialize (φ, λ)
+    # Check arguments.
+    if [φ, λ].all? {|arg| arg.respond_to?(:to_f) }
+      φ = φ.to_f
+      λ = λ.to_f
+    else
+      raise ArgumentError, "expected (latitude, longitude), got (#{φ.inspect}, #{λ.inspect})"
+    end
+    
+    # Normalize latitude (-90..90) and longitude (-179..180).
+    λ += 180 * (((φ / 90 + 1).floor / 2) % 2)
+    @y = 90 - (((90 + φ) % 360) - 180).abs
+    @x = self.pole? ? 0 : (λ - 180) % -360 + 180
+  end
+  
+  # Returns this Point's latitude as a float, rounded to 7 decimal places.
+  def latitude
+    self.y.round(7)
+  end
+  
+  # Returns this Point's latitude as a string, rounded to 7 decimal places.
+  def latitude_f
+    sprintf("%.7f", self.latitude).gsub(/\.?0*$/,'')
+  end
+  
+  # Returns this Point's latitude in degrees N/S, rounded to 7 decimal places.
+  def latitude_°
+    φ = self.latitude
+    direction = (φ == 0) ? "" : (φ > 0) ? "N" : "S"
+    
+    sprintf("%.7f°%s", φ.abs, direction).gsub(/\.?0*(?=°)/,'')
+  end
+  
+  # Returns this Point's longitude as a float, rounded to 7 decimal places.
+  def longitude
+    self.x.round(7)
+  end
+  
+  # Returns this Point's longitude as a string, rounded to 7 decimal places.
+  def longitude_f
+    sprintf("%.7f", self.longitude).gsub(/\.?0*$/,'')
+  end
+  
+  # Returns this Point's longitude in degrees E/W, rounded to 7 decimal places.
+  def longitude_°
+    λ = self.longitude
+    direction = [0, 180].include?(λ) ? "" : (λ > 0) ? "E" : "W"
+    
+    sprintf("%.7f°%s", λ.abs, direction).gsub(/\.?0*(?=°)/,'')
+  end
+  
+  # Returns 1 if this Point is the north pole, -1 if it is the south pole, or nil
+  # if it is neither.
+  def pole?
+    return 1 if self.north_pole?
+    return -1 if self.south_pole?
+  end
+  
+  # Returns true if this Point is the north pole.
+  def north_pole?
+    self.latitude == 90
+  end
+  
+  # Returns true if this Point is the south pole.
+  def south_pole?
+    self.latitude == -90
+  end
+  
+  # Returns a string representation of this Point.
+  def to_s
+    "#{self.latitude_°} #{self.longitude_°}"
+  end
+  
+  # Returns true if this Point lies in the western hemisphere, false otherwise.
+  def west?
+    self.longitude < 0
+  end
+  
+  # Returns this Point's WKT representation, rounded to 7 decimal places.
+  def wkt
+    "POINT(#{self.longitude_f} #{self.latitude_f})"
+  end
+  
+  # Returns this Point's longitude as a float.
+  def x
+    @x
+  end
+  
+  # Returns this Point's latitude as a float.
+  def y
+    @y
+  end
+  
+  # Returns true if this Point matches the other Point, within 7 decimal places.
+  def == (other)
+    [self.latitude, self.longitude] == [other.latitude, other.longitude]
+  end
+  
+  # Returns true if this Point matches the other Point exactly.
+  def === (other)
+    [self.x, self.y] == [other.x, other.y]
+  end
+end

data/lib/mapwkt/wkt/polygon.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+
+class MapWKT::Geometry::Polygon < MapWKT::Geometry
+  # Returns a Point midway between the N/S- & E/W-most Points in the perimeter.
+  def center
+    self.perimeter.center
+  end
+  
+  # Returns a new MapWKT::Geometry::Polygon with the given outer perimeter and
+  # internal lacunae. If the given LineStrings were unclosed, closes them for
+  # use in the Polygon, but leaves the original LineStrings unchanged.
+  def initialize (perimeter, *lacunae)
+    @perimeter = perimeter.dup.close!
+    @lacunae = lacunae.map {|lacuna| lacuna.dup.close! }
+  end
+  
+  # Returns an array of LineStrings representing the geographical areas treated
+  # as lacunae in this Polygon's enclosed area. Does not return the objects
+  # themselves, nor the actual array containing them.
+  def lacunae
+    @lacunae.map(&:dup)
+  end
+  
+  # Returns a LineString representing the geographical area treated as the
+  # outer perimeter of this Polygon's enclosed area. Does not return the actual
+  # LineString object used in this Polygon.
+  def perimeter
+    @perimeter.dup
+  end
+  
+  # Returns a string representation of this Polygon. ⭓ indicates the perimeter
+  # LineString, while ⬠ indicates a lacuna LineString.
+  def to_s
+    "⭓ #{@perimeter.points.join(", ")} ⭓#{@lacunae.map {|lacuna| " | ⬠ #{lacuna.points.join(", ")} ⬠" }.join} "
+  end
+  
+  # Returns this Polygon's WKT representation, with latitudes and longitudes
+  # rounded to 7 decimal places.
+  def wkt
+    "POLYGON((#{[*@perimeter.points, @perimeter.points.first].map {|p| "#{p.longitude_f} #{p.latitude_f}" }.join(", ")})#{@lacunae.map {|lacuna| ", (#{[*lacuna.points, lacuna.points.first].map {|p| "#{p.longitude_f} #{p.latitude_f}" }.join(", ")})" }.join })"
+  end
+end

data/lib/mapwkt-safe.rb

@@ -0,0 +1,17 @@
+# encoding: UTF-8
+
+module MapWKT
+  require 'bundler/setup'
+  require 'active_support/all'
+  
+  require_relative 'mapwkt/gmap/overlay'
+  require_relative 'mapwkt/gmap/map'
+  require_relative 'mapwkt/gmap/marker'
+  require_relative 'mapwkt/gmap/polygon'
+  require_relative 'mapwkt/gmap/polyline'
+  
+  require_relative 'mapwkt/wkt/geometry'
+  require_relative 'mapwkt/wkt/line_string'
+  require_relative 'mapwkt/wkt/point'
+  require_relative 'mapwkt/wkt/polygon'
+end

data/lib/mapwkt.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+
+Geometry = Class.new
+Map = Class.new
+Overlay = Class.new
+
+LineString = Class.new(Geometry)
+Point = Class.new(Geometry)
+Polygon = Class.new(Geometry)
+
+Marker = Class.new(Overlay)
+PolygonOverlay = Class.new(Overlay)
+Polyline = Class.new(Overlay)
+
+# Register the class names in the top-level namespace.
+[
+  Geometry, LineString, Map, Marker, Overlay,
+  Point, Polygon, PolygonOverlay, Polyline
+].map(&:name)
+
+# Create the namespaced constants pointing to the classes.
+module MapWKT
+  Geometry = ::Geometry
+  Map = ::Map
+  Overlay = ::Overlay
+  
+  class Geometry
+    LineString = ::LineString
+    Point = ::Point
+    Polygon = ::Polygon
+  end
+  
+  class Overlay
+    Marker = ::Marker
+    Polygon = ::PolygonOverlay
+    Polyline = ::Polyline
+  end
+  
+  require_relative 'mapwkt-safe'
+end
+
+def Point (*args) Point.new(*args) end
+def LineString (*args) LineString.new(*args) end
+def Polygon (*args) Polygon.new(*args) end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: mapwkt
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Jesse Sielaff
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-11 00:00:00.000000000 Z
+dependencies: []
+description: .
+email: jesse.sielaff@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ./lib/mapwkt/gmap/map.rb
+- ./lib/mapwkt/gmap/marker.rb
+- ./lib/mapwkt/gmap/overlay.rb
+- ./lib/mapwkt/gmap/polygon.rb
+- ./lib/mapwkt/gmap/polyline.rb
+- ./lib/mapwkt/wkt/geometry.rb
+- ./lib/mapwkt/wkt/line_string.rb
+- ./lib/mapwkt/wkt/point.rb
+- ./lib/mapwkt/wkt/polygon.rb
+- ./lib/mapwkt-safe.rb
+- ./lib/mapwkt.rb
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: An object library for converting Ruby objects with WKT to JavaScript for
+  Google Maps.
+test_files: []