rgeo-kml 0.0.1

data/lib/rgeo/kml/interface.rb

@@ -0,0 +1,99 @@
+# -----------------------------------------------------------------------------
+#
+# Kml toplevel interface
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+
+  module Kml
+
+    class << self
+
+
+      # High-level convenience routine for encoding an object as Kml.
+      # Pass the object, which may one of the geometry objects specified
+      # in RGeo::Feature, or an appropriate Kml wrapper entity such
+      # as RGeo::Kml::Feature or RGeo::Kml::FeatureCollection.
+      #
+      # The only option supported is <tt>:entity_factory</tt>, which lets
+      # you override the types of Kml entities supported. See
+      # RGeo::Kml::EntityFactory for more information. By default,
+      # encode supports objects of type RGeo::Kml::Feature and
+      # RGeo::Kml::FeatureCollection.
+
+      def encode(object_, opts_={})
+        Coder.new(opts_).encode(object_)
+      end
+
+
+      # High-level convenience routine for decoding an object from Kml.
+      # The input may be a JSON hash, a String, or an IO object from which
+      # to read the JSON string.
+      #
+      # Options include:
+      #
+      # [<tt>:geo_factory</tt>]
+      #   Specifies the geo factory to use to create geometry objects.
+      #   Defaults to the preferred cartesian factory.
+      # [<tt>:entity_factory</tt>]
+      #   Specifies an entity factory, which lets you override the types
+      #   of Kml entities that are created. It defaults to the default
+      #   RGeo::Kml::EntityFactory, which generates objects of type
+      #   RGeo::Kml::Feature or RGeo::Kml::FeatureCollection.
+      #   See RGeo::Kml::EntityFactory for more information.
+      # [<tt>:json_parser</tt>]
+      #   Specifies a JSON parser to use when decoding a String or IO
+      #   object. The value may be a Proc object taking the string as the
+      #   sole argument and returning the JSON hash, or it may be one of
+      #   the special values <tt>:json</tt>, <tt>:yajl</tt>, or
+      #   <tt>:active_support</tt>. Setting one of those special values
+      #   will require the corresponding library to be available. Note
+      #   that the <tt>:json</tt> library is present in the standard
+      #   library in Ruby 1.9, but requires the "json" gem in Ruby 1.8.
+      #   If a parser is not specified, then the decode method will not
+      #   accept a String or IO object; it will require a Hash.
+
+      def decode(input_, opts_={})
+        Coder.new(opts_).decode(input_)
+      end
+
+
+      # Creates and returns a coder object of type RGeo::Kml::Coder
+      # that encapsulates encoding and decoding settings (principally the
+      # RGeo::Feature::Factory and the RGeo::Kml::EntityFactory to be
+      # used).
+      #
+      # The geo factory is a required argument. Other options include:
+      #
+      # [<tt>:geo_factory</tt>]
+      #   Specifies the geo factory to use to create geometry objects.
+      #   Defaults to the preferred cartesian factory.
+      # [<tt>:entity_factory</tt>]
+      #   Specifies an entity factory, which lets you override the types
+      #   of Kml entities that are created. It defaults to the default
+      #   RGeo::Kml::EntityFactory, which generates objects of type
+      #   RGeo::Kml::Feature or RGeo::Kml::FeatureCollection.
+      #   See RGeo::Kml::EntityFactory for more information.
+      # [<tt>:json_parser</tt>]
+      #   Specifies a JSON parser to use when decoding a String or IO
+      #   object. The value may be a Proc object taking the string as the
+      #   sole argument and returning the JSON hash, or it may be one of
+      #   the special values <tt>:json</tt>, <tt>:yajl</tt>, or
+      #   <tt>:active_support</tt>. Setting one of those special values
+      #   will require the corresponding library to be available. Note
+      #   that the <tt>:json</tt> library is present in the standard
+      #   library in Ruby 1.9, but requires the "json" gem in Ruby 1.8.
+      #   If a parser is not specified, then the decode method will not
+      #   accept a String or IO object; it will require a Hash.
+
+      def coder(opts_={})
+        Coder.new(opts_)
+      end
+
+
+    end
+
+  end
+
+end

data/lib/rgeo/kml/kml_stream_listener.rb

@@ -0,0 +1,82 @@
+require "rexml/document"
+require "rexml/streamlistener"
+require "set"
+
+module RGeo
+  module Kml
+    
+    class KmlStreamListener
+      include REXML::StreamListener
+      
+      attr_reader :geo_factory, :tags, :current_builder, :first_builder, :result
+
+      def initialize( geo_factory, interesting_tags = %w{coordinates Point LineString LinearRing Polygon MultiGeometry}.freeze )
+        @geo_factory = geo_factory
+        @tags = interesting_tags
+      end
+
+      def tag_start(name, attrs)
+        case name
+        when "coordinates"    
+          @current_builder = CoordinatesBuilder.new(geo_factory, @current_builder)
+        when "Point"
+          @current_builder = PointBuilder.new(geo_factory, @current_builder)
+        when "LineString"
+          @current_builder = LineStringBuilder.new(geo_factory, @current_builder)
+        when "LinearRing"
+          @current_builder = LinearRingBuilder.new(geo_factory, @current_builder)
+        when "Polygon"
+          @current_builder = PolygonBuilder.new(geo_factory, @current_builder)
+        when "MultiGeometry"
+          @current_builder = MultiGeometryBuilder.new(geo_factory, @current_builder)
+        else
+          #puts "Unknown or unparsed tag #{name}"
+        end
+
+        if tags.include?(name)
+          @first_builder = @current_builder if @first_builder == nil
+        end
+      end
+
+      def tag_end(name)
+        if @first_builder == @current_builder
+          @result = @first_builder.build
+        else
+          @current_builder.build
+          
+          case name
+          when "coordinates"      
+            @current_builder.parent.points = @current_builder.points
+            @current_builder = @current_builder.parent
+          when "Point"
+            @current_builder.parent.add_point( @current_builder.point )
+            @current_builder = @current_builder.parent
+          when "LineString"
+            @current_builder.parent.add_line_string( @current_builder.line_string )
+            @current_builder = @current_builder.parent
+          when "LinearRing"
+            @current_builder.parent.add_linear_ring( @current_builder.linear_ring )
+            @current_builder = @current_builder.parent
+          when "Polygon"
+            @current_builder.parent.add_polygon( @current_builder.polygon )
+            @current_builder = @current_builder.parent
+          else
+            #puts "Unknown or unparsed tag #{name}"
+          end
+        end
+      end
+
+      def text(text)
+        @cur_text = text
+        @current_builder.text = text 
+      end
+
+      def parse(text)
+        return nil if text.nil?
+        REXML::Document.parse_stream(text, self)
+      end
+      
+    end
+
+  end
+end

data/lib/rgeo/kml/line_string_builder.rb

@@ -0,0 +1,20 @@
+module RGeo
+  module Kml
+    
+    class LineStringBuilder
+      attr_reader :parent, :geo_factory, :line_string 
+      attr_accessor :points, :text
+      
+      def initialize(geo_factory, parent)
+        @geo_factory = geo_factory
+        @parent = parent
+      end
+
+      def build
+        return nil unless points.kind_of?(::Array)
+        @line_string = @geo_factory.line_string(points)
+      end
+    end
+
+  end
+end

data/lib/rgeo/kml/linear_ring_builder.rb

@@ -0,0 +1,20 @@
+module RGeo
+  module Kml
+    
+    class LinearRingBuilder
+      attr_reader :parent, :geo_factory, :linear_ring
+      attr_accessor :points, :text
+      
+      def initialize(geo_factory, parent)
+        @geo_factory = geo_factory
+        @parent = parent
+      end
+
+      def build
+        return nil unless points.kind_of?(::Array)
+        @linear_ring = @geo_factory.linear_ring(points)
+      end
+    end
+
+  end
+end

data/lib/rgeo/kml/multi_geometry_builder.rb

@@ -0,0 +1,73 @@
+module RGeo
+  module Kml
+    
+    class MultiGeometryBuilder
+      attr_reader :geo_factory, :parent
+      attr_accessor :text, :points, :line_strings, :linear_rings, :polygons
+      
+      def initialize(geo_factory, parent)
+        @geo_factory = geo_factory
+        @parent = parent
+        @points = []
+        @linear_rings = []
+        @line_strings = []
+        @polygons = []
+      end
+      
+      def add_point(point)
+        @points << point
+      end
+
+      def add_line_string(line_string)
+        @line_strings << line_string
+      end
+      
+      def add_linear_ring(linear_ring)
+        @linear_rings << linear_ring
+      end
+      
+      def add_polygon(polygon)
+        @polygons << polygon
+      end
+
+      def multi_geometries
+        puts [points, line_strings, linear_rings, polygons].reduce(:+).inspect
+        @multi_geometries ||= [points, line_strings, linear_rings, polygons].reduce(:+)
+      end
+
+      def multi_geometries?
+        geometries_counter = 0
+        
+        geometries_counter += 1 if !points.empty?
+        geometries_counter += 1 if !line_strings.empty?
+        geometries_counter += 1 if !linear_rings.empty?
+        geometries_counter += 1 if !polygons.empty?
+
+        geometries_counter >=2 ? true : false 
+      end
+
+      def build
+        if multi_geometries?
+          @geo_factory.collection(multi_geometries)
+        elsif !points.empty?
+          return nil unless points.kind_of?(::Array)
+          @geo_factory.multi_point(points)
+        elsif !line_strings.empty?
+          return nil unless line_strings.kind_of?(::Array)
+          @geo_factory.multi_line_string(line_strings)
+        elsif !linear_rings.empty?
+          return nil unless linear_rings.kind_of?(::Array)
+          @geo_factory.multi_linear_ring(linear_rings)
+        elsif !polygons.empty?
+          return nil unless polygons.kind_of?(::Array)
+          @geo_factory.multi_polygon(polygons)
+        else
+          nil
+        end
+      end
+      
+    end
+
+  end
+end
+    

data/lib/rgeo/kml/point_builder.rb

@@ -0,0 +1,20 @@
+module RGeo
+  module Kml
+    
+    class PointBuilder
+      attr_reader :parent, :point, :geo_factory
+      attr_accessor :points, :text
+      
+      def initialize(geo_factory, parent)
+        @geo_factory = geo_factory
+        @parent = parent
+      end
+      
+      def build
+        @point = points.first
+      end
+      
+    end
+
+  end
+end

data/lib/rgeo/kml/polygon_builder.rb

@@ -0,0 +1,26 @@
+module RGeo
+  module Kml
+    
+    class PolygonBuilder
+      attr_reader :parent, :geo_factory, :polygon
+      attr_accessor :linear_rings, :text
+      
+      def initialize(geo_factory, parent)
+        @geo_factory = geo_factory
+        @parent = parent
+        @linear_rings = []
+      end
+      
+      def add_linear_ring(linear_ring)
+        linear_rings << linear_ring
+      end
+
+      def build
+        return nil unless ( linear_rings.kind_of?(::Array) || linear_rings.size != 0 )
+        @polygon = @geo_factory.polygon(linear_rings[0], linear_rings[1..-1])
+      end
+      
+    end
+
+  end
+end

data/lib/rgeo/kml/version.rb

@@ -0,0 +1,26 @@
+# -----------------------------------------------------------------------------
+#
+# Version of rgeo-kml
+#
+# -----------------------------------------------------------------------------
+
+begin
+  require 'versionomy'
+rescue ::LoadError
+end
+
+
+module RGeo
+
+  module Kml
+
+    # Current version of RGeo::Kml as a frozen string
+    VERSION_STRING = ::File.read(::File.dirname(__FILE__)+'/../../../Version').strip.freeze
+
+    # Current version of RGeo::Kml as a Versionomy object, if the
+    # Versionomy gem is available; otherwise equal to VERSION_STRING.
+    VERSION = defined?(::Versionomy) ? ::Versionomy.parse(VERSION_STRING) : VERSION_STRING
+
+  end
+
+end

data/test/tc_basic_test.rb

@@ -0,0 +1,328 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for basic Kml usage
+#
+# -----------------------------------------------------------------------------
+
+require 'test/unit'
+require 'rgeo/kml'
+
+
+module RGeo
+  module Kml
+    module Tests  # :nodoc:
+
+      class TestKml < ::Test::Unit::TestCase  # :nodoc:
+
+
+        def setup
+          @geo_factory = ::RGeo::Cartesian.simple_factory(:srid => 4326)
+          @geo_factory_z = ::RGeo::Cartesian.simple_factory(:srid => 4326, :has_z_coordinate => true)
+          @geo_factory_m = ::RGeo::Cartesian.simple_factory(:srid => 4326, :has_m_coordinate => true)
+          @geo_factory_zm = ::RGeo::Cartesian.simple_factory(:srid => 4326, :has_z_coordinate => true, :has_m_coordinate => true)
+          @entity_factory = ::RGeo::Kml::EntityFactory.instance
+        end
+
+
+        def test_has_version
+          assert_not_nil(::RGeo::Kml::VERSION)
+        end
+
+
+        def test_nil
+          assert_nil(::RGeo::Kml.encode(nil))
+          assert_nil(::RGeo::Kml.decode(nil, :geo_factory => @geo_factory))
+        end
+
+
+        def test_point
+          object_ = @geo_factory.point(10, 20)
+          kml_ = "<Point>\n<coordinates>10.0,20.0</coordinates>\n</Point>\n"
+
+          assert_equal(kml_, ::RGeo::Kml.encode(object_))
+          assert(::RGeo::Kml.decode(kml_, :geo_factory => @geo_factory) == object_ )
+        end
+
+
+        def test_point_z
+          object_ = @geo_factory_z.point(10, 20, -1)
+          kml_ = "<Point>
+<coordinates>10.0,20.0,-1.0</coordinates>
+</Point>\n"
+          
+          assert_equal(kml_, ::RGeo::Kml.encode(object_))
+          assert(::RGeo::Kml.decode(kml_, :geo_factory => @geo_factory_z).equals?(object_))
+        end
+
+
+        # def test_point_m
+        #   object_ = @geo_factory_m.point(10, 20, -1)
+        #   kml_ = "<Point>\n<coordinates>10.0,20.0,-1.0</coordinates>\n</Point>\n"
+          
+        #   assert_equal(kml_, ::RGeo::Kml.encode(object_))
+        #   assert(::RGeo::Kml.decode(kml_, :geo_factory => @geo_factory_m).eql?(object_))
+        # end
+
+
+      #   def test_point_zm
+      #     object_ = @geo_factory_zm.point(10, 20, -1, -2)
+      #     kml_ = {
+      #       'type' => 'Point',
+      #       'coordinates' => [10.0, 20.0, -1.0, -2.0],
+      #     }
+      #     assert_equal(kml_, ::RGeo::Kml.encode(object_))
+      #     assert(::RGeo::Kml.decode(kml_, :geo_factory => @geo_factory_zm).eql?(object_))
+      #   end
+
+
+        def test_line_string
+          object_ = @geo_factory.line_string([@geo_factory.point(10, 20), @geo_factory.point(12, 22), @geo_factory.point(-3, 24)])
+          kml_ = "<LineString>
+<coordinates>
+10.0,20.0
+12.0,22.0
+-3.0,24.0
+</coordinates>
+</LineString>\n"
+
+          assert_equal(kml_, ::RGeo::Kml.encode(object_))
+          assert(::RGeo::Kml.decode(kml_, :geo_factory => @geo_factory) == object_ )
+        end
+
+
+        def test_polygon
+          object_ = @geo_factory.polygon(@geo_factory.linear_ring([@geo_factory.point(10, 20), @geo_factory.point(12, 22), @geo_factory.point(-3, 24), @geo_factory.point(10, 20)]))
+          kml_ = "<Polygon>
+<outerBoundaryIs><LinearRing><coordinates>
+10.0,20.0
+12.0,22.0
+-3.0,24.0
+10.0,20.0
+</coordinates></LinearRing></outerBoundaryIs>
+</Polygon>\n"
+
+          assert_equal(kml_, ::RGeo::Kml.encode(object_))
+          assert(::RGeo::Kml.decode(kml_, :geo_factory => @geo_factory) == object_ )
+        end
+
+
+        def test_polygon_complex
+          object_ = @geo_factory.polygon(@geo_factory.linear_ring([@geo_factory.point(0, 0), @geo_factory.point(10, 0), @geo_factory.point(10, 10), @geo_factory.point(0, 10), @geo_factory.point(0, 0)]), [@geo_factory.linear_ring([@geo_factory.point(4, 4), @geo_factory.point(6, 5), @geo_factory.point(4, 6), @geo_factory.point(4, 4)])])
+
+          kml_ = "<Polygon>
+<outerBoundaryIs><LinearRing><coordinates>
+0.0,0.0
+10.0,0.0
+10.0,10.0
+0.0,10.0
+0.0,0.0
+</coordinates></LinearRing></outerBoundaryIs>
+<innerBoundaryIs><LinearRing><coordinates>
+4.0,4.0
+6.0,5.0
+4.0,6.0
+4.0,4.0
+</coordinates></LinearRing></innerBoundaryIs>
+</Polygon>\n"
+          
+          assert_equal(kml_, ::RGeo::Kml.encode(object_))
+          assert(::RGeo::Kml.decode(kml_, :geo_factory => @geo_factory) == object_ )
+        end
+
+
+        def test_multi_point
+          object_ = @geo_factory.multi_point([@geo_factory.point(10, 20), @geo_factory.point(12, 22), @geo_factory.point(-3, 24)])
+
+          kml_ = "<MultiGeometry>
+<Point>
+<coordinates>10.0,20.0</coordinates>
+</Point>
+<Point>
+<coordinates>12.0,22.0</coordinates>
+</Point>
+<Point>
+<coordinates>-3.0,24.0</coordinates>
+</Point>
+</MultiGeometry>\n"
+
+          assert_equal(kml_, ::RGeo::Kml.encode(object_))
+          assert(::RGeo::Kml.decode(kml_, :geo_factory => @geo_factory) == object_ )
+        end
+
+
+        def test_multi_line_string
+          object_ = @geo_factory.multi_line_string([@geo_factory.line_string([@geo_factory.point(10, 20), @geo_factory.point(12, 22), @geo_factory.point(-3, 24)]), @geo_factory.line_string([@geo_factory.point(1, 2), @geo_factory.point(3, 4)])])
+          kml_ = "<MultiGeometry>
+<LineString>
+<coordinates>
+10.0,20.0
+12.0,22.0
+-3.0,24.0
+</coordinates>
+</LineString>
+<LineString>
+<coordinates>
+1.0,2.0
+3.0,4.0
+</coordinates>
+</LineString>
+</MultiGeometry>\n"
+          assert_equal(kml_, ::RGeo::Kml.encode(object_))
+          assert(::RGeo::Kml.decode(kml_, :geo_factory => @geo_factory) == object_ )
+        end
+
+
+        def test_multi_polygon
+          object_ = @geo_factory.multi_polygon([@geo_factory.polygon(@geo_factory.linear_ring([@geo_factory.point(0, 0), @geo_factory.point(10, 0), @geo_factory.point(10, 10), @geo_factory.point(0, 10), @geo_factory.point(0, 0)]), [@geo_factory.linear_ring([@geo_factory.point(4, 4), @geo_factory.point(6, 5), @geo_factory.point(4, 6), @geo_factory.point(4, 4)])]), @geo_factory.polygon(@geo_factory.linear_ring([@geo_factory.point(-10,-10), @geo_factory.point(-15, -10), @geo_factory.point(-10, -15), @geo_factory.point(-10, -10)]))])
+          kml_ = "<MultiGeometry>
+<Polygon>
+<outerBoundaryIs><LinearRing><coordinates>
+0.0,0.0
+10.0,0.0
+10.0,10.0
+0.0,10.0
+0.0,0.0
+</coordinates></LinearRing></outerBoundaryIs>
+<innerBoundaryIs><LinearRing><coordinates>
+4.0,4.0
+6.0,5.0
+4.0,6.0
+4.0,4.0
+</coordinates></LinearRing></innerBoundaryIs>
+</Polygon>
+<Polygon>
+<outerBoundaryIs><LinearRing><coordinates>
+-10.0,-10.0
+-15.0,-10.0
+-10.0,-15.0
+-10.0,-10.0
+</coordinates></LinearRing></outerBoundaryIs>
+</Polygon>
+</MultiGeometry>\n"
+          assert_equal(kml_, ::RGeo::Kml.encode(object_))
+          assert(::RGeo::Kml.decode(kml_, :geo_factory => @geo_factory) == object_ )
+        end
+
+
+        def test_geometry_collection
+          object_ = @geo_factory.collection([@geo_factory.point(10, 20), @geo_factory.line_string([@geo_factory.point(12, 22), @geo_factory.point(-3, 24)])])
+          kml_ = "<MultiGeometry>
+<Point>
+<coordinates>10.0,20.0</coordinates>
+</Point>
+<LineString>
+<coordinates>
+12.0,22.0
+-3.0,24.0
+</coordinates>
+</LineString>
+</MultiGeometry>\n"
+          assert_equal(kml_, ::RGeo::Kml.encode(object_))
+          assert(::RGeo::Kml.decode(kml_, :geo_factory => @geo_factory) == object_ )
+        end
+
+
+      #   def test_feature
+      #     object_ = @entity_factory.feature(@geo_factory.point(10, 20))
+      #     kml_ = {
+      #       'type' => 'Feature',
+      #       'geometry' => {
+      #         'type' => 'Point',
+      #         'coordinates' => [10.0, 20.0],
+      #       },
+      #       'properties' => {},
+      #     }
+      #     assert_equal(kml_, ::RGeo::Kml.encode(object_))
+      #     assert(::RGeo::Kml.decode(kml_, :geo_factory => @geo_factory).eql?(object_))
+      #   end
+
+
+      #   def test_feature_nulls
+      #     kml_ = {
+      #       'type' => 'Feature',
+      #       'geometry' => nil,
+      #       'properties' => nil,
+      #     }
+      #     obj_ = ::RGeo::Kml.decode(kml_, :geo_factory => @geo_factory)
+      #     assert_not_nil(obj_)
+      #     assert_nil(obj_.geometry)
+      #     assert_equal({}, obj_.properties)
+      #   end
+
+
+      #   def test_feature_complex
+      #     object_ = @entity_factory.feature(@geo_factory.point(10, 20), 2, {'prop1' => 'foo', 'prop2' => 'bar'})
+      #     kml_ = {
+      #       'type' => 'Feature',
+      #       'geometry' => {
+      #         'type' => 'Point',
+      #         'coordinates' => [10.0, 20.0],
+      #       },
+      #       'id' => 2,
+      #       'properties' => {'prop1' => 'foo', 'prop2' => 'bar'},
+      #     }
+      #     assert_equal(kml_, ::RGeo::Kml.encode(object_))
+      #     assert(::RGeo::Kml.decode(kml_, :geo_factory => @geo_factory).eql?(object_))
+      #   end
+
+
+      #   def test_feature_with_symbol_prop_keys
+      #     object_ = @entity_factory.feature(@geo_factory.point(10, 20), 2, {:prop1 => 'foo', 'prop2' => 'bar'})
+      #     kml_ = {
+      #       'type' => 'Feature',
+      #       'geometry' => {
+      #         'type' => 'Point',
+      #         'coordinates' => [10.0, 20.0],
+      #       },
+      #       'id' => 2,
+      #       'properties' => {'prop1' => 'foo', 'prop2' => 'bar'},
+      #     }
+      #     assert_equal('foo', object_.property('prop1'))
+      #     assert_equal('bar', object_.property(:prop2))
+      #     assert_equal(kml_, ::RGeo::Kml.encode(object_))
+      #     assert(::RGeo::Kml.decode(kml_, :geo_factory => @geo_factory).eql?(object_))
+      #   end
+
+
+      #   def test_feature_collection
+      #     object_ = @entity_factory.feature_collection([@entity_factory.feature(@geo_factory.point(10, 20)), @entity_factory.feature(@geo_factory.point(11, 22)), @entity_factory.feature(@geo_factory.point(10, 20), 8)])
+      #     kml_ = {
+      #       'type' => 'FeatureCollection',
+      #       'features' => [
+      #         {
+      #           'type' => 'Feature',
+      #           'geometry' => {
+      #             'type' => 'Point',
+      #             'coordinates' => [10.0, 20.0],
+      #           },
+      #           'properties' => {},
+      #         },
+      #         {
+      #           'type' => 'Feature',
+      #           'geometry' => {
+      #             'type' => 'Point',
+      #             'coordinates' => [11.0, 22.0],
+      #           },
+      #           'properties' => {},
+      #         },
+      #         {
+      #           'type' => 'Feature',
+      #           'geometry' => {
+      #             'type' => 'Point',
+      #             'coordinates' => [10.0, 20.0],
+      #           },
+      #           'id' => 8,
+      #           'properties' => {},
+      #         },
+      #       ]
+      #     }
+      #     assert_equal(kml_, ::RGeo::Kml.encode(object_))
+      #     assert(::RGeo::Kml.decode(kml_, :geo_factory => @geo_factory).eql?(object_))
+      #   end
+
+
+      end
+
+    end
+  end
+end