geos-extensions 0.0.7 → 0.1.0

data/lib/geos/google_maps/api_3.rb

@@ -0,0 +1,169 @@
+
+module Geos::GoogleMaps::Api3
+  module Geometry
+    UNESCAPED_MARKER_OPTIONS = %w{
+      icon
+      map
+      position
+      shadow
+      shape
+    }.freeze
+
+    # Returns a new LatLngBounds object with the proper GLatLngs in place
+    # for determining the geometry bounds.
+    def to_g_lat_lng_bounds_api3(options = {})
+      "new google.maps.LatLngBounds(#{self.lower_left.to_g_lat_lng_api3(options)}, #{self.upper_right.to_g_lat_lng_api3(options)})"
+    end
+
+    # Returns a String in Google Maps' LatLngBounds#toString() format.
+    def to_g_lat_lng_bounds_string_api3(precision = 10)
+      "((#{self.lower_left.to_g_url_value_api3(precision)}), (#{self.upper_right.to_g_url_value_api3(precision)}))"
+    end
+
+    # Returns a new Polyline.
+    def to_g_polyline_api3(polyline_options = {}, options = {})
+      self.coord_seq.to_g_polyline_api3(polyline_options, options)
+    end
+
+    # Returns a new Polygon.
+    def to_g_polygon_api3(polygon_options = {}, options = {})
+      self.coord_seq.to_g_polygon_api3(polygon_options, options)
+    end
+
+    # Returns a new Marker at the centroid of the geometry. The options
+    # Hash works the same as the Google Maps API MarkerOptions class does,
+    # but allows for underscored Ruby-like options which are then converted
+    # to the appropriate camel-cased Javascript options.
+    def to_g_marker_api3(marker_options = {}, options = {})
+      options = {
+        :escape => [],
+        :lat_lng_options => {}
+      }.merge(options)
+
+      opts = Geos::Helper.camelize_keys(marker_options)
+      opts[:position] = self.centroid.to_g_lat_lng(options[:lat_lng_options])
+      json = Geos::Helper.escape_json(opts, UNESCAPED_MARKER_OPTIONS - options[:escape])
+
+      "new google.maps.Marker(#{json})"
+    end
+  end
+
+  module CoordinateSequence
+    # Returns a Ruby Array of GLatLngs.
+    def to_g_lat_lng_api3(options = {})
+      self.to_a.collect do |p|
+        "new google.maps.LatLng(#{p[1]}, #{p[0]})"
+      end
+    end
+
+    # Returns a new GPolyline. Note that this GPolyline just uses whatever
+    # coordinates are found in the sequence in order, so it might not
+    # make much sense at all.
+    #
+    # The options Hash follows the Google Maps API arguments to the
+    # GPolyline constructor and include :color, :weight, :opacity and
+    # :options. 'null' is used in place of any unset options.
+    def to_g_polyline_api3(polyline_options = {}, options = {})
+      klass = if options[:short_class]
+        'GPolyline'
+      else
+        'google.maps.Polyline'
+      end
+
+      poly_opts = if polyline_options[:polyline_options]
+        Geos::Helper.camelize_keys(polyline_options[:polyline_options])
+      end
+
+      args = [
+        (polyline_options[:color] ? "'#{Geos::Helper.escape_javascript(polyline_options[:color])}'" : 'null'),
+        (polyline_options[:weight] || 'null'),
+        (polyline_options[:opacity] || 'null'),
+        (poly_opts ? poly_opts.to_json : 'null')
+      ].join(', ')
+
+      "new #{klass}([#{self.to_g_lat_lng(options).join(', ')}], #{args})"
+    end
+
+    # Returns a new GPolygon. Note that this GPolygon just uses whatever
+    # coordinates are found in the sequence in order, so it might not
+    # make much sense at all.
+    #
+    # The options Hash follows the Google Maps API arguments to the
+    # GPolygon constructor and include :stroke_color, :stroke_weight,
+    # :stroke_opacity, :fill_color, :fill_opacity and :options. 'null' is
+    # used in place of any unset options.
+    def to_g_polygon_api3(polygon_options = {}, options = {})
+      klass = if options[:short_class]
+        'GPolygon'
+      else
+        'google.maps.Polygon'
+      end
+
+      poly_opts = if polygon_options[:polygon_options]
+        Geos::Helper.camelize_keys(polygon_options[:polygon_options])
+      end
+
+      args = [
+        (polygon_options[:stroke_color] ? "'#{Geos::Helper.escape_javascript(polygon_options[:stroke_color])}'" : 'null'),
+        (polygon_options[:stroke_weight] || 'null'),
+        (polygon_options[:stroke_opacity] || 'null'),
+        (polygon_options[:fill_color] ? "'#{Geos::Helper.escape_javascript(polygon_options[:fill_color])}'" : 'null'),
+        (polygon_options[:fill_opacity] || 'null'),
+        (poly_opts ? poly_opts.to_json : 'null')
+      ].join(', ')
+      "new #{klass}([#{self.to_g_lat_lng_api3(options).join(', ')}], #{args})"
+    end
+  end
+
+  module Point
+    # Returns a new LatLng.
+    def to_g_lat_lng_api3(options = {})
+      no_wrap = if options[:no_wrap]
+        ', true'
+      end
+
+      "new google.maps.LatLng(#{self.lat}, #{self.lng}#{no_wrap})"
+    end
+
+    # Returns a new Point
+    def to_g_point_api3(options = {})
+      "new google.maps.Point(#{self.x}, #{self.y})"
+    end
+  end
+
+  module Polygon
+    # Returns a GPolyline of the exterior ring of the Polygon. This does
+    # not take into consideration any interior rings the Polygon may
+    # have.
+    def to_g_polyline_api3(polyline_options = {}, options = {})
+      self.exterior_ring.to_g_polyline_api3(polyline_options, options)
+    end
+
+    # Returns a GPolygon of the exterior ring of the Polygon. This does
+    # not take into consideration any interior rings the Polygon may
+    # have.
+    def to_g_polygon_api3(polygon_options = {}, options = {})
+      self.exterior_ring.to_g_polygon_api3(polygon_options, options)
+    end
+  end
+
+  module GeometryCollection
+    # Returns a Ruby Array of GPolylines for each geometry in the
+    # collection.
+    def to_g_polyline_api3(polyline_options = {}, options = {})
+      self.collect do |p|
+        p.to_g_polyline_api3(polyline_options, options)
+      end
+    end
+
+    # Returns a Ruby Array of GPolygons for each geometry in the
+    # collection.
+    def to_g_polygon_api3(polygon_options = {}, options = {})
+      self.collect do |p|
+        p.to_g_polygon_api3(polygon_options, options)
+      end
+    end
+  end
+end
+
+Geos::GoogleMaps.use_api(2)

data/lib/geos/google_maps.rb

@@ -0,0 +1,28 @@
+
+module Geos
+  module GoogleMaps
+    class << self
+      def use_api(version)
+        version_const = Geos::GoogleMaps.const_get("Api#{version}")
+        version_const.constants.each do |c|
+          mod = version_const.const_get(c)
+          klass = Geos.const_get(c)
+          regex = %r{_api#{version}$}
+
+          if !klass.include?(mod)
+            klass.send(:include, mod)
+          end
+
+          mod.instance_methods.each do |method|
+            klass.send(:alias_method, method.to_s.sub(regex, ''), method)
+          end
+        end
+      end
+    end
+
+    autoload :PolylineEncoder, File.join(GEOS_EXTENSIONS_BASE, *%w{ geos google_maps polyline_encoder })
+    autoload :ApiIncluder, File.join(GEOS_EXTENSIONS_BASE, *%w{ geos google_maps api_includer })
+    autoload :Api2, File.join(GEOS_EXTENSIONS_BASE, *%w{ geos google_maps api_2 })
+    autoload :Api3, File.join(GEOS_EXTENSIONS_BASE, *%w{ geos google_maps api_3 })
+  end
+end

data/lib/geos/rails/engine.rb

@@ -0,0 +1,6 @@
+
+module Geos
+  class RailsEngine < Rails::Engine
+  end
+end
+

data/lib/geos-extensions.rb

@@ -2,12 +2,12 @@
 require File.join(File.dirname(__FILE__), *%w{ geos_extensions })
 
 if defined?(ActiveRecord)
-  require File.join(GEOS_EXTENSIONS_BASE, *%w{ active_record_extensions connection_adapters postgresql_adapter })
-  require File.join(GEOS_EXTENSIONS_BASE, *%w{ active_record_extensions geometry_columns })
-  require File.join(GEOS_EXTENSIONS_BASE, *%w{ active_record_extensions geospatial_scopes })
+  require File.join(Geos::GEOS_EXTENSIONS_BASE, *%w{ geos active_record_extensions })
 end
 
-if defined?(Rails)
-  require File.join(File.dirname(__FILE__), %w{ .. rails railtie })
+if defined?(Rails) && Rails::VERSION::MAJOR >= 3
+  require File.join(Geos::GEOS_EXTENSIONS_BASE, %w{ geos rails engine })
 end
 
+Geos::GoogleMaps.use_api(2)
+

data/lib/geos_extensions.rb

@@ -1,6 +1,4 @@
 
-GEOS_EXTENSIONS_BASE = File.join(File.dirname(__FILE__))
-
 begin
   if !ENV['USE_BINARY_GEOS']
     require 'ffi-geos'
@@ -12,9 +10,12 @@ require 'geos' unless defined?(Geos)
 
 # Some custom extensions to the SWIG-based Geos Ruby extension.
 module Geos
-  autoload :Helper, File.join(GEOS_EXTENSIONS_BASE, 'geos_helper')
-  autoload :ActiveRecord, File.join(GEOS_EXTENSIONS_BASE, 'active_record_extensions')
-  autoload :GoogleMaps, File.join(GEOS_EXTENSIONS_BASE, 'google_maps')
+  GEOS_EXTENSIONS_BASE = File.join(File.dirname(__FILE__))
+  GEOS_EXTENSIONS_VERSION = File.read(File.join(GEOS_EXTENSIONS_BASE, %w{ .. VERSION })).strip rescue nil
+
+  autoload :Helper, File.join(GEOS_EXTENSIONS_BASE, *%w{ geos geos_helper })
+  autoload :ActiveRecord, File.join(GEOS_EXTENSIONS_BASE, *%w{ geos active_record_extensions })
+  autoload :GoogleMaps, File.join(GEOS_EXTENSIONS_BASE, *%w{ geos google_maps })
 
   REGEXP_WKT = /^(?:SRID=(-?[0-9]+);)?(\s*[PLMCG].+)/i
   REGEXP_WKB_HEX = /^[A-Fa-f0-9\s]+$/
@@ -294,52 +295,6 @@ module Geos
     alias :w :left
     alias :west :left
 
-    # Returns a new GLatLngBounds object with the proper GLatLngs in place
-    # for determining the geometry bounds.
-    def to_g_lat_lng_bounds(options = {})
-      klass = if options[:short_class]
-        'GLatLngBounds'
-      else
-        'google.maps.LatLngBounds'
-      end
-
-      "new #{klass}(#{self.lower_left.to_g_lat_lng(options)}, #{self.upper_right.to_g_lat_lng(options)})"
-    end
-
-    # Returns a String in Google Maps' GLatLngBounds#toString() format.
-    def to_g_lat_lng_bounds_string(precision = 10)
-      "((#{self.lower_left.to_g_url_value(precision)}), (#{self.upper_right.to_g_url_value(precision)}))"
-    end
-
-    # Returns a new GPolyline.
-    def to_g_polyline polyline_options = {}, options = {}
-      self.coord_seq.to_g_polyline polyline_options, options
-    end
-
-    # Returns a new GPolygon.
-    def to_g_polygon polygon_options = {}, options = {}
-      self.coord_seq.to_g_polygon polygon_options, options
-    end
-
-    # Returns a new GMarker at the centroid of the geometry. The options
-    # Hash works the same as the Google Maps API GMarkerOptions class does,
-    # but allows for underscored Ruby-like options which are then converted
-    # to the appropriate camel-cased Javascript options.
-    def to_g_marker marker_options = {}, options = {}
-      klass = if options[:short_class]
-        'GMarker'
-      else
-        'google.maps.Marker'
-      end
-
-      opts = marker_options.inject({}) do |memo, (k, v)|
-        memo[Geos::Helper.camelize(k.to_s)] = v
-        memo
-      end
-
-      "new #{klass}(#{self.centroid.to_g_lat_lng(options)}, #{opts.to_json})"
-    end
-
     # Spit out Google's JSON geocoder Point format. The extra 0 is added
     # on as Google's format seems to like including the Z coordinate.
     def to_g_json_point
@@ -385,83 +340,6 @@ module Geos
 
 
   class CoordinateSequence
-    # Returns a Ruby Array of GLatLngs.
-    def to_g_lat_lng(options = {})
-      klass = if options[:short_class]
-        'GLatLng'
-      else
-        'google.maps.LatLng'
-      end
-
-      self.to_a.collect do |p|
-        "new #{klass}(#{p[1]}, #{p[0]})"
-      end
-    end
-
-    # Returns a new GPolyline. Note that this GPolyline just uses whatever
-    # coordinates are found in the sequence in order, so it might not
-    # make much sense at all.
-    #
-    # The options Hash follows the Google Maps API arguments to the
-    # GPolyline constructor and include :color, :weight, :opacity and
-    # :options. 'null' is used in place of any unset options.
-    def to_g_polyline polyline_options = {}, options = {}
-      klass = if options[:short_class]
-        'GPolyline'
-      else
-        'google.maps.Polyline'
-      end
-
-      poly_opts = if polyline_options[:polyline_options]
-        polyline_options[:polyline_options].inject({}) do |memo, (k, v)|
-          memo[Geos::Helper.camelize(k.to_s)] = v
-          memo
-        end
-      end
-
-      args = [
-        (polyline_options[:color] ? "'#{Geos::Helper.escape_javascript(polyline_options[:color])}'" : 'null'),
-        (polyline_options[:weight] || 'null'),
-        (polyline_options[:opacity] || 'null'),
-        (poly_opts ? poly_opts.to_json : 'null')
-      ].join(', ')
-
-      "new #{klass}([#{self.to_g_lat_lng(options).join(', ')}], #{args})"
-    end
-
-    # Returns a new GPolygon. Note that this GPolygon just uses whatever
-    # coordinates are found in the sequence in order, so it might not
-    # make much sense at all.
-    #
-    # The options Hash follows the Google Maps API arguments to the
-    # GPolygon constructor and include :stroke_color, :stroke_weight,
-    # :stroke_opacity, :fill_color, :fill_opacity and :options. 'null' is
-    # used in place of any unset options.
-    def to_g_polygon polygon_options = {}, options = {}
-      klass = if options[:short_class]
-        'GPolygon'
-      else
-        'google.maps.Polygon'
-      end
-
-      poly_opts = if polygon_options[:polygon_options]
-        polygon_options[:polygon_options].inject({}) do |memo, (k, v)|
-          memo[Geos::Helper.camelize(k.to_s)] = v
-          memo
-        end
-      end
-
-      args = [
-        (polygon_options[:stroke_color] ? "'#{Geos::Helper.escape_javascript(polygon_options[:stroke_color])}'" : 'null'),
-        (polygon_options[:stroke_weight] || 'null'),
-        (polygon_options[:stroke_opacity] || 'null'),
-        (polygon_options[:fill_color] ? "'#{Geos::Helper.escape_javascript(polygon_options[:fill_color])}'" : 'null'),
-        (polygon_options[:fill_opacity] || 'null'),
-        (poly_opts ? poly_opts.to_json : 'null')
-      ].join(', ')
-      "new #{klass}([#{self.to_g_lat_lng(options).join(', ')}], #{args})"
-    end
-
     # Returns a Ruby Array of Arrays of coordinates within the
     # CoordinateSequence in the form [ x, y, z ].
     def to_a
@@ -539,28 +417,6 @@ module Geos
 
 
   class Point
-    # Returns a new GLatLng.
-    def to_g_lat_lng(options = {})
-      klass = if options[:short_class]
-        'GLatLng'
-      else
-        'google.maps.LatLng'
-      end
-
-      "new #{klass}(#{self.lat}, #{self.lng})"
-    end
-
-    # Returns a new GPoint
-    def to_g_point(options = {})
-      klass = if options[:short_class]
-        'GPoint'
-      else
-        'google.maps.Point'
-      end
-
-      "new #{klass}(#{self.x}, #{self.y})"
-    end
-
     # Returns the Y coordinate of the Point, which is actually the
     # latitude.
     def lat
@@ -651,21 +507,13 @@ module Geos
   end
 
 
-  class Polygon
-    # Returns a GPolyline of the exterior ring of the Polygon. This does
-    # not take into consideration any interior rings the Polygon may
-    # have.
-    def to_g_polyline polyline_options = {}, options = {}
-      self.exterior_ring.to_g_polyline polyline_options, options
-    end
-
-    # Returns a GPolygon of the exterior ring of the Polygon. This does
-    # not take into consideration any interior rings the Polygon may
-    # have.
-    def to_g_polygon polygon_options = {}, options = {}
-      self.exterior_ring.to_g_polygon polygon_options, options
+  class LineString
+    def to_jsonable(options = {})
+      self.coord_seq.to_jsonable(options)
     end
+  end
 
+  class Polygon
     # Build some XmlMarkup for XML. You can set various KML options like
     # tessellate, altitudeMode, etc. Use Rails/Ruby-style code and it
     # will be converted automatically, i.e. :altitudeMode, not
@@ -736,6 +584,7 @@ module Geos
     def to_jsonable options = {}
       options = {
         :encoded => true,
+        :level => 3,
         :interior_rings => false
       }.merge options
 
@@ -751,7 +600,8 @@ module Geos
           :type => 'polygon',
           :encoded => true,
           :polylines => [ Geos::GoogleMaps::PolylineEncoder.encode(
-              self.exterior_ring.coord_seq.to_a
+              self.exterior_ring.coord_seq.to_a,
+              options[:level]
             ).merge(:bounds => {
               :sw => self.lower_left.to_a,
               :ne => self.upper_right.to_a
@@ -762,7 +612,10 @@ module Geos
 
         if options[:interior_rings] && self.num_interior_rings > 0
           (0..(self.num_interior_rings) - 1).to_a.each do |n|
-            ret[:polylines] << Geos::GoogleMaps::PolylineEncoder.encode(self.interior_ring_n(n).coord_seq.to_a)
+            ret[:polylines] << Geos::GoogleMaps::PolylineEncoder.encode(
+              self.interior_ring_n(n).coord_seq.to_a,
+              options[:level]
+            )
           end
         end
         ret
@@ -815,22 +668,6 @@ module Geos
       self.get_geometry_n(self.num_geometries - 1) if self.num_geometries > 0
     end
 
-    # Returns a Ruby Array of GPolylines for each geometry in the
-    # collection.
-    def to_g_polyline polyline_options = {}, options = {}
-      self.collect do |p|
-        p.to_g_polyline polyline_options, options
-      end
-    end
-
-    # Returns a Ruby Array of GPolygons for each geometry in the
-    # collection.
-    def to_g_polygon polygon_options = {}, options = {}
-      self.collect do |p|
-        p.to_g_polygon polygon_options, options
-      end
-    end
-
     # Returns a Hash suitable for converting to JSON.
     def to_jsonable options = {}
       self.collect do |p|

data/test/geospatial_scopes_test.rb

@@ -67,6 +67,15 @@ if ENV['TEST_ACTIVERECORD']
       ids_tester(:st_dwithin, [ 'POINT(5 5)', 10 ], [ 1, 2, 3 ])
     end
 
+    def test_allow_null
+      begin
+        foo = Foo.create(:name => 'four')
+        ids_tester(:st_contains, [ 'POINT(3 3)', { :allow_null => true } ], [ 3, foo.id ])
+      ensure
+        Foo.find_by_name('four').destroy
+      end
+    end
+
     def test_with_column
       assert_equal([1, 2, 3], Foo.st_disjoint('POINT(100 100)', :column => :the_other_geom).all.collect(&:id).sort)
     end

data/test/google_maps_api_2_test.rb

@@ -0,0 +1,185 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+begin
+  require 'json'
+rescue LoadError
+  # do nothing
+end
+
+class GoogleMapsApi2Tests < Test::Unit::TestCase
+  include TestHelper
+
+  def setup
+    Geos::GoogleMaps.use_api(2)
+
+    @point = Geos.read(POINT_EWKB)
+    @polygon = Geos.read(POLYGON_EWKB)
+  end
+
+  def test_to_g_lat_lng
+    assert_equal("new google.maps.LatLng(10.01, 10.0)", @point.to_g_lat_lng)
+    assert_equal("new GLatLng(10.01, 10.0)", @point.to_g_lat_lng(:short_class => true))
+  end
+
+  def test_to_jsonable
+    assert_equal({
+      :type => "point",
+      :lat => 10.01,
+      :lng => 10.0
+    }, @point.to_jsonable)
+
+    assert_equal({
+      :type => "polygon",
+      :polylines => [{
+        :points => "??_ibE_ibE_~cH_~cH_hgN_hgN~po]~po]",
+        :bounds => {
+          :sw => [ 0.0, 0.0 ],
+          :ne => [ 5.0, 5.0 ]
+        },
+        :levels=>"BBBBB"
+      }],
+      :options => {},
+      :encoded => true
+    }, @polygon.to_jsonable)
+  end
+
+  if defined?(JSON)
+    def test_to_g_polygon
+      assert_equal(
+        "new google.maps.Polygon([new google.maps.LatLng(0.0, 0.0), new google.maps.LatLng(1.0, 1.0), new google.maps.LatLng(2.5, 2.5), new google.maps.LatLng(5.0, 5.0), new google.maps.LatLng(0.0, 0.0)], null, null, null, null, null, null)",
+        @polygon.to_g_polygon
+      )
+
+      assert_equal(
+        "new GPolygon([new GLatLng(0.0, 0.0), new GLatLng(1.0, 1.0), new GLatLng(2.5, 2.5), new GLatLng(5.0, 5.0), new GLatLng(0.0, 0.0)], null, null, null, null, null, null)",
+        @polygon.to_g_polygon({}, :short_class => true)
+      )
+
+      assert_equal(
+        "new google.maps.Polygon([new google.maps.LatLng(0.0, 0.0), new google.maps.LatLng(1.0, 1.0), new google.maps.LatLng(2.5, 2.5), new google.maps.LatLng(5.0, 5.0), new google.maps.LatLng(0.0, 0.0)], '#b00b1e', 5, 0.5, '#b00b1e', null, {\"mouseOutTolerence\":5})",
+        @polygon.to_g_polygon(
+          :stroke_color => '#b00b1e',
+          :stroke_weight => 5,
+          :stroke_opacity => 0.5,
+          :fill_color => '#b00b1e',
+          :polygon_options => {
+            :mouse_out_tolerence => 5
+          }
+        )
+      )
+    end
+
+    def test_to_g_polyline
+      assert_equal(
+        "new google.maps.Polyline([new google.maps.LatLng(0.0, 0.0), new google.maps.LatLng(1.0, 1.0), new google.maps.LatLng(2.5, 2.5), new google.maps.LatLng(5.0, 5.0), new google.maps.LatLng(0.0, 0.0)], null, null, null, null)",
+        @polygon.to_g_polyline
+      )
+
+      assert_equal(
+        "new GPolyline([new GLatLng(0.0, 0.0), new GLatLng(1.0, 1.0), new GLatLng(2.5, 2.5), new GLatLng(5.0, 5.0), new GLatLng(0.0, 0.0)], null, null, null, null)",
+        @polygon.to_g_polyline({}, :short_class => true)
+      )
+
+      assert_equal(
+        "new google.maps.Polyline([new google.maps.LatLng(0.0, 0.0), new google.maps.LatLng(1.0, 1.0), new google.maps.LatLng(2.5, 2.5), new google.maps.LatLng(5.0, 5.0), new google.maps.LatLng(0.0, 0.0)], '#b00b1e', 5, 0.5, {\"mouseOutTolerence\":5})",
+        @polygon.to_g_polyline(
+          :color => '#b00b1e',
+          :weight => 5,
+          :opacity => 0.5,
+          :polyline_options => {
+            :mouse_out_tolerence => 5
+          }
+        )
+      )
+    end
+
+    def test_to_g_marker_long
+      marker = @point.to_g_marker
+
+      lat, lng, json = if marker =~ /^new\s+
+        google\.maps\.Marker\(
+          new\s+google\.maps\.LatLng\(
+            (\d+\.\d+)\s*,\s*
+            (\d+\.\d+)
+          \),\s*
+            ((\{\}))
+        \)
+        /x
+        [ $1, $2, $3 ]
+      end
+
+      assert_in_delta(lng.to_f, 10.00, 0.000001)
+      assert_in_delta(lat.to_f, 10.01, 0.000001)
+      assert_equal(
+        {},
+        JSON.load(json)
+      )
+    end
+
+    def test_to_g_marker_short_class
+      marker = @point.to_g_marker({}, :short_class => true)
+
+      lat, lng, json = if marker =~ /^new\s+
+        GMarker\(
+          new\s+GLatLng\(
+            (\d+\.\d+)\s*,\s*
+            (\d+\.\d+)
+          \),\s*
+            (\{\})
+        \)
+        /x
+        [ $1, $2, $3 ]
+      end
+
+      assert_in_delta(lng.to_f, 10.00, 0.000001)
+      assert_in_delta(lat.to_f, 10.01, 0.000001)
+      assert_equal(
+        {},
+        JSON.load(json)
+      )
+    end
+
+
+    def test_to_g_marker_with_options
+      marker = @point.to_g_marker(
+        :bounce_gravity => 1,
+        :bouncy => true
+      )
+
+      lat, lng, json = if marker =~ /^new\s+
+        google\.maps\.Marker\(
+          new\s+google\.maps\.LatLng\(
+            (\d+\.\d+)\s*,\s*
+            (\d+\.\d+)
+          \),\s*
+            (\{[^}]+\})
+        \)
+        /x
+        [ $1, $2, $3 ]
+      end
+
+      assert_in_delta(lng.to_f, 10.00, 0.000001)
+      assert_in_delta(lat.to_f, 10.01, 0.000001)
+      assert_equal(
+        { "bounceGravity" => 1, "bouncy" => true },
+        JSON.load(json)
+      )
+    end
+
+    def test_to_g_json_point
+      assert_equal(
+        { :coordinates => [ 10.0, 10.01, 0 ] },
+        @point.to_g_json_point
+      )
+    end
+
+    def test_to_g_lat_lon_box
+      assert_equal(
+        { :east => 5.0, :west => 0.0, :north => 5.0, :south => 0.0},
+        @polygon.to_g_lat_lon_box
+      )
+    end
+  end
+end