rgeo 0.3.4 → 0.3.5

data/History.rdoc

@@ -1,3 +1,9 @@
+=== 0.3.5 / 2012-02-27
+
+* Reworked the terminology on equivalence levels. The documentation now names the three levels "spatial", "representational", and "objective" equivalence.
+* Some geometry implementations didn't implement the == operator, resulting in various problems, including inability to set ActiveRecord attributes when using an implementation (such as simple_spherical polygons) that doesn't provide spatial equivalence tests. Fixed. The interfaces now specify that all implementations must implement the == operator and the eql? method, and should degrade to stronger forms of equivalence if weaker forms are not available. (Reported by Phil Murray.)
+* Added Geometry#rep_equals? to test representational equivalence without the fallback behavior of Geometry#eql?
+
 === 0.3.4 / 2012-02-21
 
 * The FFI-GEOS implementation now uses prepared geometries.

data/README.rdoc

@@ -26,8 +26,7 @@ Use the core *rgeo* gem to:
 Several optional modules are currently available:
 
 * Generate and interpret GeoJSON data for communication with common
-  location-based web services such as SimpleGeo, using the
-  <b>rgeo-geojson</b> gem.
+  location-based web services using the <b>rgeo-geojson</b> gem.
 * Read GIS datasets from ESRI shapefiles using the <b>rgeo-shapefile</b>
   gem.
 * Extend ActiveRecord to handle spatial data in MySQL Spatial, SpatiaLite,
@@ -101,7 +100,8 @@ The RGeo suite of tools is evolving rapidly. The current to-do list for
 the core library includes:
 
 * YAML and Marshal serialization support across all major entities.
-* Better JRuby support.
+* Full JRuby support.
+* Better error handling and reporting.
 * Ellipsoidal geography implementation, possibly utilizing geographiclib.
 * Windows build support.
 
@@ -110,7 +110,7 @@ we are planning on introducing more add-on modules, including:
 
 * GeoRSS and KML format support.
 * Integration with third-party APIs.
-* Possible additional ActiveRecord adapters.
+* Possible additional ActiveRecord adapters (esp. JDBC adapters)
 
 === Development and support
 
@@ -130,7 +130,7 @@ Contact the author at dazuma at gmail dot com.
 
 RGeo is written by Daniel Azuma (http://www.daniel-azuma.com).
 
-Development of RGeo is sponsored by GeoPage, Inc. (http://www.geopage.com).
+Development is supported by Pirq. (http://www.pirq.com).
 
 RGeo calls the GEOS library to handle most Cartesian geometric
 calculations, and the Proj4 library to handle projections and coordinate
@@ -143,7 +143,7 @@ gems, by J Smith (http://github.com/dark-panda).
 
 === License
 
-Copyright 2010-2011 Daniel Azuma
+Copyright 2010-2012 Daniel Azuma
 
 All rights reserved.
 

data/Spatial_Programming_With_RGeo.rdoc

@@ -186,23 +186,23 @@ I do not have space here to describe the different comparison operations in deta
  b = "foo"
  a == b        # => true
  a.eql?(b)     # => true
- a.equals?(b)  # => false  (because they are different objects)
- a.equals?(a)  # => true
+ a.equal?(b)  # => false  (because they are different objects)
+ a.equal?(a)  # => true
 
-In general, Ruby has three forms of equality: value equality (tested by the <tt>==</tt> operator), object equality (tested by the <tt>eql?</tt> method), and object identity (tested by the <tt>equals?</tt> method).
+In general, Ruby has three forms of equality: value equality (tested by the <tt>==</tt> operator), object equality (tested by the <tt>eql?</tt> method), and object identity (tested by the <tt>equal?</tt> method).
 
-Similarly, \RGeo's equality checking comes in several forms: geometric equality, object equality, and object identity. Geometric equality is tested by the SFS method <tt>equal?</tt>, as well as the <tt>==</tt> operator. This type of equality indicates two objects that may be different representations of the same geometry, for example, a LineString and its reverse, or a Point and a MultiPoint that contains only that same point. Object equality, tested by <tt>eql?</tt>, means the same representation but possibly distinct objects. Object identity, tested by <tt>equals?</tt>, represents the same object, as with other Ruby types.
+Similarly, \RGeo's equality checking comes in several forms: geometric equality, representational equality, and object identity. Geometric equality is tested by the SFS method <tt>equals?</tt>, as well as the <tt>==</tt> operator. This type of equality indicates two objects that may be different representations of the same geometry, for example, a LineString and its reverse, or a Point and a MultiPoint that contains only that same point. Representational equality, tested by <tt>eql?</tt>, means the same representation but possibly distinct objects. Object identity, tested by <tt>equal?</tt>, represents the same object, as with other Ruby types.
 
  p1 = factory.point(1, 1)
  p2 = factory.point(1, 1)
  mp = factory.multi_point([p1])
  p1 == p2        # => true
- p1.equal?(mp)   # => true
+ p1.equals?(mp)   # => true
  p1 == mp        # => true
  p1.eql?(mp)     # => false
  p1.eql?(p2)     # => true
- p1.equals?(p2)  # => false
- p1.equals?(p1)  # => true
+ p1.equal?(p2)  # => false
+ p1.equal?(p1)  # => true
 
 === 3.3. Binary Spatial Operations
 

data/Version

@@ -1 +1 @@
-0.3.4
+0.3.5

data/ext/geos_c_impl/geometry.c

@@ -969,6 +969,7 @@ void rgeo_init_geos_geometry(RGeo_Globals* globals)
   rb_define_method(geos_geometry_class, "is_simple?", method_geometry_is_simple, 0);
   rb_define_method(geos_geometry_class, "equals?", method_geometry_equals, 1);
   rb_define_method(geos_geometry_class, "==", method_geometry_equals, 1);
+  rb_define_method(geos_geometry_class, "rep_equals?", method_geometry_eql, 1);
   rb_define_method(geos_geometry_class, "eql?", method_geometry_eql, 1);
   rb_define_method(geos_geometry_class, "disjoint?", method_geometry_disjoint, 1);
   rb_define_method(geos_geometry_class, "intersects?", method_geometry_intersects, 1);

data/ext/geos_c_impl/geometry_collection.c

@@ -492,6 +492,7 @@ void rgeo_init_geos_geometry_collection(RGeo_Globals* globals)
   // Methods for GeometryCollectionImpl
   rb_define_module_function(geos_geometry_collection_class, "create", cmethod_geometry_collection_create, 2);
   rb_include_module(geos_geometry_collection_class, rb_define_module("Enumerable"));
+  rb_define_method(geos_geometry_collection_class, "rep_equals?", method_geometry_collection_eql, 1);
   rb_define_method(geos_geometry_collection_class, "eql?", method_geometry_collection_eql, 1);
   rb_define_method(geos_geometry_collection_class, "geometry_type", method_geometry_collection_geometry_type, 0);
   rb_define_method(geos_geometry_collection_class, "num_geometries", method_geometry_collection_num_geometries, 0);

data/ext/geos_c_impl/line_string.c

@@ -569,6 +569,7 @@ void rgeo_init_geos_line_string(RGeo_Globals* globals)
 
   rb_define_module_function(geos_line_string_class, "create", cmethod_create_line_string, 2);
   rb_define_module_function(geos_line_string_class, "_copy_from", cmethod_line_string_copy_from, 2);
+  rb_define_method(geos_line_string_class, "rep_equals?", method_line_string_eql, 1);
   rb_define_method(geos_line_string_class, "eql?", method_line_string_eql, 1);
   rb_define_method(geos_line_string_class, "geometry_type", method_line_string_geometry_type, 0);
   rb_define_method(geos_line_string_class, "length", method_line_string_length, 0);

data/ext/geos_c_impl/point.c

@@ -185,6 +185,7 @@ void rgeo_init_geos_point(RGeo_Globals* globals)
 
   rb_define_module_function(geos_point_class, "create", cmethod_create, 4);
 
+  rb_define_method(geos_point_class, "rep_equals?", method_point_eql, 1);
   rb_define_method(geos_point_class, "eql?", method_point_eql, 1);
   rb_define_method(geos_point_class, "geometry_type", method_point_geometry_type, 0);
   rb_define_method(geos_point_class, "x", method_point_x, 0);

data/ext/geos_c_impl/polygon.c

@@ -284,6 +284,7 @@ void rgeo_init_geos_polygon(RGeo_Globals* globals)
 
   rb_define_module_function(geos_polygon_class, "create", cmethod_create, 3);
 
+  rb_define_method(geos_polygon_class, "rep_equals?", method_polygon_eql, 1);
   rb_define_method(geos_polygon_class, "eql?", method_polygon_eql, 1);
   rb_define_method(geos_polygon_class, "geometry_type", method_polygon_geometry_type, 0);
   rb_define_method(geos_polygon_class, "area", method_polygon_area, 0);

data/lib/rgeo/feature/geometry.rb

@@ -78,25 +78,37 @@ module RGeo
     #   As a general rule, objects must have factories that are
     #   Factory#eql? in order to be spatially equivalent.
     #
-    # * <b>Objective equivalence</b> is a stronger form of equivalence,
-    #   indicating that the objects are the same representation, but may
-    #   be different objects. All objectively equivalent objects are
+    # * <b>Representational equivalence</b> is a stronger form, indicating
+    #   that the objects have the same representation, but may be
+    #   different objects. All representationally equivalent objects are
     #   spatially equivalent, but not all spatially equivalent objects are
-    #   objectively equivalent. For example, none of the examples in the
-    #   spatial equivalence section above are objectively equivalent.
-    #   However, two separate objects that both represent POINT(1 2) are
-    #   objectively equivalent as well as spatially equivalent.
+    #   representationally equivalent. For example, none of the examples
+    #   in the spatial equivalence section above are representationally
+    #   equivalent. However, two separate objects that both represent
+    #   POINT(1 2) are representationally equivalent as well as spatially
+    #   equivalent.
     #
-    # * <b>Objective identity</b> is the strongest form, indicating that
-    #   the references refer to the same object. Of course, all pairs of
-    #   references with the same objective identity are both objectively
-    #   equivalent and spatially equivalent.
+    # * <b>Objective equivalence</b> is the strongest form, indicating
+    #   that the references refer to the same object. Of course, all
+    #   pairs of references with the same objective identity are also 
+    #   both representationally and spatially equivalent.
     #
     # Different methods test for different types of equivalence:
     #
     # * <tt>equals?</tt> and <tt>==</tt> test for spatial equivalence.
-    # * <tt>eql?</tt> tests for objective equivalence.
-    # * <tt>equal?</tt> tests for objective identity.
+    # * <tt>rep_equals?</tt> and <tt>eql?</tt> test for representational
+    #   equivalence.
+    # * <tt>equal?</tt> tests for objective equivalence.
+    #
+    # All ruby objects must provide a suitable test for objective
+    # equivalence. Normally, this is simply provided by the Ruby Object
+    # base class. Geometry implementations should normally also provide
+    # tests for representational and spatial equivalence, if possible.
+    # The <tt>==</tt> operator and the <tt>eql?</tt> method are standard
+    # Ruby methods that are often expected to be usable for every object.
+    # Therefore, if an implementation cannot provide a suitable test for
+    # their equivalence types, they must degrade to use a stronger form
+    # of equivalence.
 
     module Geometry
 
@@ -115,14 +127,6 @@ module RGeo
       end
 
 
-      # Returns true if this geometric object is objectively equivalent
-      # to the given object.
-
-      def eql?(another_geometry_)
-        raise Error::UnsupportedOperation, "Method Geometry#eql? not defined."
-      end
-
-
       # === SFS 1.1 Description
       #
       # The inherent dimension of this geometric object, which must be less
@@ -279,7 +283,7 @@ module RGeo
       # Although implementations are free to attempt to handle
       # another_geometry values that do not share the same factory as
       # this geometry, strictly speaking, the result of comparing objects
-      # of different factories is undefined.
+      # from different factories is undefined.
 
       def equals?(another_geometry_)
         raise Error::UnsupportedOperation, "Method Geometry#equals? not defined."
@@ -299,7 +303,7 @@ module RGeo
       # Although implementations are free to attempt to handle
       # another_geometry values that do not share the same factory as
       # this geometry, strictly speaking, the result of comparing objects
-      # of different factories is undefined.
+      # from different factories is undefined.
 
       def disjoint?(another_geometry_)
         raise Error::UnsupportedOperation, "Method Geometry#disjoint? not defined."
@@ -319,7 +323,7 @@ module RGeo
       # Although implementations are free to attempt to handle
       # another_geometry values that do not share the same factory as
       # this geometry, strictly speaking, the result of comparing objects
-      # of different factories is undefined.
+      # from different factories is undefined.
 
       def intersects?(another_geometry_)
         raise Error::UnsupportedOperation, "Method Geometry#intersects? not defined."
@@ -339,7 +343,7 @@ module RGeo
       # Although implementations are free to attempt to handle
       # another_geometry values that do not share the same factory as
       # this geometry, strictly speaking, the result of comparing objects
-      # of different factories is undefined.
+      # from different factories is undefined.
 
       def touches?(another_geometry_)
         raise Error::UnsupportedOperation, "Method Geometry#touches? not defined."
@@ -359,7 +363,7 @@ module RGeo
       # Although implementations are free to attempt to handle
       # another_geometry values that do not share the same factory as
       # this geometry, strictly speaking, the result of comparing objects
-      # of different factories is undefined.
+      # from different factories is undefined.
 
       def crosses?(another_geometry_)
         raise Error::UnsupportedOperation, "Method Geometry#crosses? not defined."
@@ -379,7 +383,7 @@ module RGeo
       # Although implementations are free to attempt to handle
       # another_geometry values that do not share the same factory as
       # this geometry, strictly speaking, the result of comparing objects
-      # of different factories is undefined.
+      # from different factories is undefined.
 
       def within?(another_geometry_)
         raise Error::UnsupportedOperation, "Method Geometry#within? not defined."
@@ -399,7 +403,7 @@ module RGeo
       # Although implementations are free to attempt to handle
       # another_geometry values that do not share the same factory as
       # this geometry, strictly speaking, the result of comparing objects
-      # of different factories is undefined.
+      # from different factories is undefined.
 
       def contains?(another_geometry_)
         raise Error::UnsupportedOperation, "Method Geometry#contains? not defined."
@@ -419,7 +423,7 @@ module RGeo
       # Although implementations are free to attempt to handle
       # another_geometry values that do not share the same factory as
       # this geometry, strictly speaking, the result of comparing objects
-      # of different factories is undefined.
+      # from different factories is undefined.
 
       def overlaps?(another_geometry_)
         raise Error::UnsupportedOperation, "Method Geometry#overlaps? not defined."
@@ -446,7 +450,7 @@ module RGeo
       # Although implementations are free to attempt to handle
       # another_geometry values that do not share the same factory as
       # this geometry, strictly speaking, the result of comparing objects
-      # of different factories is undefined.
+      # from different factories is undefined.
 
       def relate(another_geometry_, intersection_pattern_matrix_)
         raise Error::UnsupportedOperation, "Method Geometry#relate not defined."
@@ -466,7 +470,7 @@ module RGeo
       # Although implementations are free to attempt to handle
       # another_geometry values that do not share the same factory as
       # this geometry, strictly speaking, the result of measuring the
-      # distance between objects of different factories is undefined.
+      # distance between objects from different factories is undefined.
 
       def distance(another_geometry_)
         raise Error::UnsupportedOperation, "Method Geometry#distance not defined."
@@ -515,7 +519,7 @@ module RGeo
       # Although implementations are free to attempt to handle
       # another_geometry values that do not share the same factory as
       # this geometry, strictly speaking, the result of performing
-      # operations on objects of different factories is undefined.
+      # operations on objects from different factories is undefined.
 
       def intersection(another_geometry_)
         raise Error::UnsupportedOperation, "Method Geometry#intersection not defined."
@@ -534,7 +538,7 @@ module RGeo
       # Although implementations are free to attempt to handle
       # another_geometry values that do not share the same factory as
       # this geometry, strictly speaking, the result of performing
-      # operations on objects of different factories is undefined.
+      # operations on objects from different factories is undefined.
 
       def union(another_geometry_)
         raise Error::UnsupportedOperation, "Method Geometry#union not defined."
@@ -553,7 +557,7 @@ module RGeo
       # Although implementations are free to attempt to handle
       # another_geometry values that do not share the same factory as
       # this geometry, strictly speaking, the result of performing
-      # operations on objects of different factories is undefined.
+      # operations on objects from different factories is undefined.
 
       def difference(another_geometry_)
         raise Error::UnsupportedOperation, "Method Geometry#difference not defined."
@@ -572,21 +576,78 @@ module RGeo
       # Although implementations are free to attempt to handle
       # another_geometry values that do not share the same factory as
       # this geometry, strictly speaking, the result of performing
-      # operations on objects of different factories is undefined.
+      # operations on objects from different factories is undefined.
 
       def sym_difference(another_geometry_)
         raise Error::UnsupportedOperation, "Method Geometry#sym_difference not defined."
       end
 
 
-      # This operator should behave almost the same as the equals? method.
-      # The difference is that the == operator is required to handle rhs
-      # values that are not geometry objects (returning false in such cases)
-      # in order to fulfill the standard Ruby contract for the == operator,
-      # whereas the equals? method may assume that any rhs is a geometry.
+      # Returns true if this geometric object is representationally
+      # equivalent to the given object.
+      #
+      # Although implementations are free to attempt to handle
+      # another_geometry values that do not share the same factory as
+      # this geometry, strictly speaking, the result of comparing objects
+      # from different factories is undefined.
+
+      def rep_equals?(another_geometry_)
+        raise Error::UnsupportedOperation, "Method Geometry#rep_equals? not defined."
+      end
+
+
+      # This method should behave almost the same as the rep_equals?
+      # method, with two key differences.
+      #
+      # First, the <tt>eql?</tt> method is required to handle rhs values
+      # that are not geometry objects (returning false in such cases) in
+      # order to fulfill the standard Ruby contract for the method,
+      # whereas the rep_equals? method may assume that any rhs is a
+      # geometry.
+      #
+      # Second, the <tt>eql?</tt> method should always be defined. That
+      # is, it should never raise Error::UnsupportedOperation. In cases
+      # where the underlying implementation cannot provide a
+      # representational equivalence test, this method must fall back on
+      # objective equivalence.
+
+      def eql?(rhs_)
+        if rhs_.kind_of?(::RGeo::Feature::Instance)
+          begin
+            rep_equals?(rhs_)
+          rescue Error::UnsupportedOperation
+            equal?(rhs_)
+          end
+        else
+          false
+        end
+      end
+
+
+      # This operator should behave almost the same as the equals? method,
+      # with two key differences.
+      #
+      # First, the == operator is required to handle rhs values that are
+      # not geometry objects (returning false in such cases) in order to
+      # fulfill the standard Ruby contract for the == operator, whereas
+      # the equals? method may assume that any rhs is a geometry.
+      #
+      # Second, the == operator should always be defined. That is, it
+      # should never raise Error::UnsupportedOperation. In cases where
+      # the underlying implementation cannot provide a spatial equivalence
+      # test, the == operator must fall back on representational or
+      # objective equivalence.
 
       def ==(rhs_)
-        rhs_.kind_of?(::RGeo::Feature::Instance) ? equals?(rhs_) : false
+        if rhs_.kind_of?(::RGeo::Feature::Instance)
+          begin
+            equals?(rhs_)
+          rescue Error::UnsupportedOperation
+            eql?(rhs_)
+          end
+        else
+          false
+        end
       end
 
 

data/lib/rgeo/geos/ffi_classes.rb

@@ -164,21 +164,6 @@ module RGeo
       end
 
 
-      def _request_prepared  # :nodoc:
-        case @_fg_prep
-        when 0
-          nil
-        when 1
-          @_fg_prep = 2
-          nil
-        when 2
-          @_fg_prep = ::Geos::PreparedGeometry.new(@fg_geom)
-        else
-          @_fg_prep
-        end
-      end
-
-
       def envelope
         fg_geom_ = @fg_geom.envelope
         # GEOS returns an "empty" point for an empty collection's envelope.
@@ -359,6 +344,11 @@ module RGeo
       end
 
 
+      def eql?(rhs_)
+        rep_equals?(rhs_)
+      end
+
+
       def _detach_fg_geom  # :nodoc:
         fg_ = @fg_geom
         @fg_geom = nil
@@ -366,6 +356,21 @@ module RGeo
       end
 
 
+      def _request_prepared  # :nodoc:
+        case @_fg_prep
+        when 0
+          nil
+        when 1
+          @_fg_prep = 2
+          nil
+        when 2
+          @_fg_prep = ::Geos::PreparedGeometry.new(@fg_geom)
+        else
+          @_fg_prep
+        end
+      end
+
+
     end
 
 
@@ -407,7 +412,7 @@ module RGeo
       end
 
 
-      def eql?(rhs_)
+      def rep_equals?(rhs_)
         rhs_.class == self.class && rhs_.factory.eql?(@factory) &&
           FFIUtils.coord_seqs_equal?(rhs_.fg_geom.coord_seq, @fg_geom.coord_seq, @factory._has_3d)
       end
@@ -483,7 +488,7 @@ module RGeo
       end
 
 
-      def eql?(rhs_)
+      def rep_equals?(rhs_)
         rhs_.class == self.class && rhs_.factory.eql?(@factory) &&
           FFIUtils.coord_seqs_equal?(rhs_.fg_geom.coord_seq, @fg_geom.coord_seq, @factory._has_3d)
       end
@@ -573,15 +578,15 @@ module RGeo
       end
 
 
-      def eql?(rhs_)
+      def rep_equals?(rhs_)
         if rhs_.class == self.class && rhs_.factory.eql?(@factory) &&
-          rhs_.exterior_ring.eql?(self.exterior_ring)
+          rhs_.exterior_ring.rep_equals?(self.exterior_ring)
         then
           sn_ = @fg_geom.num_interior_rings
           rn_ = rhs_.num_interior_rings
           if sn_ == rn_
             sn_.times do |i_|
-              return false unless interior_ring_n(i_).eql?(rhs_.interior_ring_n(i_))
+              return false unless interior_ring_n(i_).rep_equals?(rhs_.interior_ring_n(i_))
             end
             return true
           end
@@ -604,12 +609,12 @@ module RGeo
       end
 
 
-      def eql?(rhs_)
+      def rep_equals?(rhs_)
         if rhs_.class == self.class && rhs_.factory.eql?(@factory)
           size_ = @fg_geom.num_geometries
           if size_ == rhs_.num_geometries
             size_.times do |n_|
-              return false unless geometry_n(n_).eql?(rhs_.geometry_n(n_))
+              return false unless geometry_n(n_).rep_equals?(rhs_.geometry_n(n_))
             end
             return true
           end

data/lib/rgeo/geos/zm_impl.rb

@@ -75,11 +75,6 @@ module RGeo
       end
 
 
-      def eql?(rhs_)
-        rhs_.is_a?(self.class) && @factory.eql?(rhs_.factory) && @zgeometry.eql?(rhs_.z_geometry) && @mgeometry.eql?(rhs_.m_geometry)
-      end
-
-
       def dimension
         @zgeometry.dimension
       end
@@ -205,7 +200,14 @@ module RGeo
       end
 
 
+      def rep_equals?(rhs_)
+        rhs_.is_a?(self.class) && @factory.eql?(rhs_.factory) && @zgeometry.rep_equals?(rhs_.z_geometry) && @mgeometry.rep_equals?(rhs_.m_geometry)
+      end
+
+
+      alias_method :eql?, :rep_equals?
       alias_method :==, :equals?
+
       alias_method :-, :difference
       alias_method :+, :union
       alias_method :*, :intersection

data/lib/rgeo/impl_helper/basic_geometry_collection_methods.rb

@@ -55,15 +55,6 @@ module RGeo
       end
 
 
-      def eql?(rhs_)
-        if rhs_.is_a?(self.class) && rhs_.factory.eql?(@factory) && @elements.size == rhs_.num_geometries
-          rhs_.each_with_index{ |p_, i_| return false unless @elements[i_].eql?(p_) }
-        else
-          false
-        end
-      end
-
-
       def num_geometries
         @elements.size
       end
@@ -106,6 +97,15 @@ module RGeo
       end
 
 
+      def rep_equals?(rhs_)
+        if rhs_.is_a?(self.class) && rhs_.factory.eql?(@factory) && @elements.size == rhs_.num_geometries
+          rhs_.each_with_index{ |p_, i_| return false unless @elements[i_].rep_equals?(p_) }
+        else
+          false
+        end
+      end
+
+
     end
 
 

data/lib/rgeo/impl_helper/basic_line_string_methods.rb

@@ -62,15 +62,6 @@ module RGeo
       end
 
 
-      def eql?(rhs_)
-        if rhs_.is_a?(self.class) && rhs_.factory.eql?(@factory) && @points.size == rhs_.num_points
-          rhs_.points.each_with_index{ |p_, i_| return false unless @points[i_].eql?(p_) }
-        else
-          false
-        end
-      end
-
-
       def num_points
         @points.size
       end
@@ -133,6 +124,15 @@ module RGeo
       end
 
 
+      def rep_equals?(rhs_)
+        if rhs_.is_a?(self.class) && rhs_.factory.eql?(@factory) && @points.size == rhs_.num_points
+          rhs_.points.each_with_index{ |p_, i_| return false unless @points[i_].rep_equals?(p_) }
+        else
+          false
+        end
+      end
+
+
     end
 
 

data/lib/rgeo/impl_helper/basic_point_methods.rb

@@ -75,11 +75,6 @@ module RGeo
       end
 
 
-      def eql?(rhs_)
-        rhs_.is_a?(self.class) && rhs_.factory.eql?(@factory) && @x == rhs_.x && @y == rhs_.y && @z == rhs_.z && @m == rhs_.m
-      end
-
-
       def dimension
         0
       end
@@ -130,6 +125,11 @@ module RGeo
       end
 
 
+      def rep_equals?(rhs_)
+        rhs_.is_a?(self.class) && rhs_.factory.eql?(@factory) && @x == rhs_.x && @y == rhs_.y && @z == rhs_.z && @m == rhs_.m
+      end
+
+
     end
 
 

data/lib/rgeo/impl_helper/basic_polygon_methods.rb

@@ -59,15 +59,6 @@ module RGeo
       end
 
 
-      def eql?(rhs_)
-        if rhs_.is_a?(self.class) && rhs_.factory.eql?(@factory) && @exterior_ring.eql?(rhs_.exterior_ring) && @interior_rings.size == rhs_.num_interior_rings
-          rhs_.interior_rings.each_with_index{ |r_, i_| return false unless @interior_rings[i_].eql?(r_) }
-        else
-          false
-        end
-      end
-
-
       def exterior_ring
         @exterior_ring
       end
@@ -113,6 +104,15 @@ module RGeo
       end
 
 
+      def rep_equals?(rhs_)
+        if rhs_.is_a?(self.class) && rhs_.factory.eql?(@factory) && @exterior_ring.rep_equals?(rhs_.exterior_ring) && @interior_rings.size == rhs_.num_interior_rings
+          rhs_.interior_rings.each_with_index{ |r_, i_| return false unless @interior_rings[i_].rep_equals?(r_) }
+        else
+          false
+        end
+      end
+
+
     end
 
 

data/test/common/geometry_collection_tests.rb

@@ -118,10 +118,18 @@ module RGeo
         end
 
 
-        def test_fully_equal
+        def test_required_equivalences
           geom1_ = @factory.collection([@point1, @line1])
           geom2_ = @factory.collection([@point1, @line1])
           assert(geom1_.eql?(geom2_))
+          assert(geom1_ == geom2_)
+        end
+
+
+        def test_fully_equal
+          geom1_ = @factory.collection([@point1, @line1])
+          geom2_ = @factory.collection([@point1, @line1])
+          assert(geom1_.rep_equals?(geom2_))
           assert(geom1_.equals?(geom2_))
         end
 
@@ -129,7 +137,7 @@ module RGeo
         def test_geometrically_equal
           geom1_ = @factory.collection([@point2, @line2])
           geom2_ = @factory.collection([@point2, @line1, @line2])
-          assert(!geom1_.eql?(geom2_))
+          assert(!geom1_.rep_equals?(geom2_))
           assert(geom1_.equals?(geom2_))
         end
 
@@ -137,7 +145,7 @@ module RGeo
         def test_empty_equal
           geom1_ = @factory.collection([])
           geom2_ = @factory.collection([])
-          assert(geom1_.eql?(geom2_))
+          assert(geom1_.rep_equals?(geom2_))
           assert(geom1_.equals?(geom2_))
         end
 
@@ -145,7 +153,7 @@ module RGeo
         def test_not_equal
           geom1_ = @factory.collection([@point1, @line1])
           geom2_ = @factory.collection([@point2, @line1])
-          assert(!geom1_.eql?(geom2_))
+          assert(!geom1_.rep_equals?(geom2_))
           assert(!geom1_.equals?(geom2_))
         end
 

data/test/common/line_string_tests.rb

@@ -151,7 +151,7 @@ module RGeo
         end
 
 
-        def test_fully_equal
+        def test_required_equivalences
           point1_ = @factory.point(0, 0)
           point2_ = @factory.point(0, 1)
           point3_ = @factory.point(1, 0)
@@ -161,6 +161,20 @@ module RGeo
           point6_ = @factory.point(1, 0)
           line2_ = @factory.line_string([point4_, point5_, point6_])
           assert(line1_.eql?(line2_))
+          assert(line1_ == line2_)
+        end
+
+
+        def test_fully_equal
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 1)
+          point3_ = @factory.point(1, 0)
+          line1_ = @factory.line_string([point1_, point2_, point3_])
+          point4_ = @factory.point(0, 0)
+          point5_ = @factory.point(0, 1)
+          point6_ = @factory.point(1, 0)
+          line2_ = @factory.line_string([point4_, point5_, point6_])
+          assert(line1_.rep_equals?(line2_))
           assert(line1_.equals?(line2_))
         end
 
@@ -172,7 +186,7 @@ module RGeo
           point4_ = @factory.point(0, 0)
           point5_ = @factory.point(0, 1)
           line2_ = @factory.line(point4_, point5_)
-          assert(!line1_.eql?(line2_))
+          assert(!line1_.rep_equals?(line2_))
           assert(line1_.equals?(line2_))
         end
 
@@ -186,7 +200,7 @@ module RGeo
           point5_ = @factory.point(0, 1)
           point6_ = @factory.point(1, 0)
           line2_ = @factory.linear_ring([point4_, point5_, point6_, point4_])
-          assert(!line1_.eql?(line2_))
+          assert(!line1_.rep_equals?(line2_))
           assert(line1_.equals?(line2_))
         end
 
@@ -200,7 +214,7 @@ module RGeo
           point5_ = @factory.point(0, 1)
           point6_ = @factory.point(1, 0)
           line2_ = @factory.line_string([point4_, point5_, point6_, point5_])
-          assert(!line1_.eql?(line2_))
+          assert(!line1_.rep_equals?(line2_))
           assert(line1_.equals?(line2_))
         end
 
@@ -208,7 +222,7 @@ module RGeo
         def test_empty_equal
           line1_ = @factory.line_string([])
           line2_ = @factory.line_string([])
-          assert(line1_.eql?(line2_))
+          assert(line1_.rep_equals?(line2_))
           assert(line1_.equals?(line2_))
         end
 
@@ -221,7 +235,7 @@ module RGeo
           point5_ = @factory.point(0, 1)
           point6_ = @factory.point(1, 0)
           line2_ = @factory.line_string([point4_, point5_, point6_])
-          assert(!line1_.eql?(line2_))
+          assert(!line1_.rep_equals?(line2_))
           assert(!line1_.equals?(line2_))
         end
 

data/test/common/multi_line_string_tests.rb

@@ -104,10 +104,18 @@ module RGeo
         end
 
 
-        def test_fully_equal
+        def test_required_equivalences
           geom1_ = @factory.multi_line_string([@linestring1, @linestring2])
           geom2_ = @factory.multi_line_string([@linestring1, @linestring2])
           assert(geom1_.eql?(geom2_))
+          assert(geom1_ == geom2_)
+        end
+
+
+        def test_fully_equal
+          geom1_ = @factory.multi_line_string([@linestring1, @linestring2])
+          geom2_ = @factory.multi_line_string([@linestring1, @linestring2])
+          assert(geom1_.rep_equals?(geom2_))
           assert(geom1_.equals?(geom2_))
         end
 
@@ -115,7 +123,7 @@ module RGeo
         def test_geometrically_equal
           geom1_ = @factory.multi_line_string([@linestring1, @linestring2, @linearring1])
           geom2_ = @factory.multi_line_string([@line1, @linearring1])
-          assert(!geom1_.eql?(geom2_))
+          assert(!geom1_.rep_equals?(geom2_))
           assert(geom1_.equals?(geom2_))
         end
 
@@ -123,7 +131,7 @@ module RGeo
         def test_not_equal
           geom1_ = @factory.multi_line_string([@linestring2])
           geom2_ = @factory.multi_line_string([@linearring1])
-          assert(!geom1_.eql?(geom2_))
+          assert(!geom1_.rep_equals?(geom2_))
           assert(!geom1_.equals?(geom2_))
         end
 

data/test/common/multi_point_tests.rb

@@ -96,10 +96,18 @@ module RGeo
         end
 
 
-        def test_fully_equal
+        def test_required_equivalences
           geom1_ = @factory.multi_point([@point1, @point2])
           geom2_ = @factory.multi_point([@point1, @point2])
           assert(geom1_.eql?(geom2_))
+          assert(geom1_ == geom2_)
+        end
+
+
+        def test_fully_equal
+          geom1_ = @factory.multi_point([@point1, @point2])
+          geom2_ = @factory.multi_point([@point1, @point2])
+          assert(geom1_.rep_equals?(geom2_))
           assert(geom1_.equals?(geom2_))
         end
 
@@ -107,7 +115,7 @@ module RGeo
         def test_geometrically_equal
           geom1_ = @factory.multi_point([@point1, @point4])
           geom2_ = @factory.multi_point([@point1, @point4, @point5])
-          assert(!geom1_.eql?(geom2_))
+          assert(!geom1_.rep_equals?(geom2_))
           assert(geom1_.equals?(geom2_))
         end
 
@@ -115,7 +123,7 @@ module RGeo
         def test_not_equal
           geom1_ = @factory.multi_point([@point1, @point2])
           geom2_ = @factory.multi_point([@point1])
-          assert(!geom1_.eql?(geom2_))
+          assert(!geom1_.rep_equals?(geom2_))
           assert(!geom1_.equals?(geom2_))
         end
 

data/test/common/multi_polygon_tests.rb

@@ -111,10 +111,18 @@ module RGeo
         end
 
 
-        def test_equal
+        def test_required_equivalences
           geom1_ = @factory.multi_polygon([@poly1, @poly2])
           geom2_ = @factory.multi_polygon([@poly1, @poly2])
           assert(geom1_.eql?(geom2_))
+          assert(geom1_ == geom2_)
+        end
+
+
+        def test_equal
+          geom1_ = @factory.multi_polygon([@poly1, @poly2])
+          geom2_ = @factory.multi_polygon([@poly1, @poly2])
+          assert(geom1_.rep_equals?(geom2_))
           assert(geom1_.equals?(geom2_))
         end
 
@@ -122,7 +130,7 @@ module RGeo
         def test_not_equal
           geom1_ = @factory.multi_polygon([@poly1])
           geom2_ = @factory.multi_polygon([@poly2])
-          assert(!geom1_.eql?(geom2_))
+          assert(!geom1_.rep_equals?(geom2_))
           assert(!geom1_.equals?(geom2_))
         end
 

data/test/common/point_tests.rb

@@ -153,9 +153,11 @@ module RGeo
           point3_ = @factory.point(13, 12)
           assert(point1_.equals?(point2_))
           assert(point1_ == point2_)
+          assert(point1_.rep_equals?(point2_))
           assert(point1_.eql?(point2_))
           assert(!point1_.equals?(point3_))
           assert(point1_ != point3_)
+          assert(!point1_.rep_equals?(point3_))
           assert(!point1_.eql?(point3_))
           assert(point1_ != 'hello')
           assert(!point1_.eql?('hello'))

data/test/common/polygon_tests.rb

@@ -82,7 +82,7 @@ module RGeo
         end
 
 
-        def test_fully_equal
+        def test_required_equivalences
           point1_ = @factory.point(0, 0)
           point2_ = @factory.point(0, 1)
           point3_ = @factory.point(1, 0)
@@ -94,6 +94,22 @@ module RGeo
           exterior2_ = @factory.linear_ring([point4_, point5_, point6_, point4_])
           poly2_ = @factory.polygon(exterior2_)
           assert(poly1_.eql?(poly2_))
+          assert(poly1_ == poly2_)
+        end
+
+
+        def test_fully_equal
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 1)
+          point3_ = @factory.point(1, 0)
+          exterior1_ = @factory.linear_ring([point1_, point2_, point3_, point1_])
+          poly1_ = @factory.polygon(exterior1_)
+          point4_ = @factory.point(0, 0)
+          point5_ = @factory.point(0, 1)
+          point6_ = @factory.point(1, 0)
+          exterior2_ = @factory.linear_ring([point4_, point5_, point6_, point4_])
+          poly2_ = @factory.polygon(exterior2_)
+          assert(poly1_.rep_equals?(poly2_))
           assert(poly1_.equals?(poly2_))
         end
 
@@ -106,7 +122,7 @@ module RGeo
           poly1_ = @factory.polygon(exterior1_)
           exterior2_ = @factory.linear_ring([point2_, point3_, point1_, point2_])
           poly2_ = @factory.polygon(exterior2_)
-          assert(!poly1_.eql?(poly2_))
+          assert(!poly1_.rep_equals?(poly2_))
           assert(poly1_.equals?(poly2_))
         end
 
@@ -119,7 +135,7 @@ module RGeo
           poly1_ = @factory.polygon(exterior1_)
           exterior2_ = @factory.linear_ring([point1_, point3_, point2_, point1_])
           poly2_ = @factory.polygon(exterior2_)
-          assert(!poly1_.eql?(poly2_))
+          assert(!poly1_.rep_equals?(poly2_))
           assert(poly1_.equals?(poly2_))
         end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rgeo
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-22 00:00:00.000000000 Z
+date: 2012-02-27 00:00:00.000000000 Z
 dependencies: []
 description: RGeo is a geospatial data library for Ruby. It provides an implementation
   of the Open Geospatial Consortium's Simple Features Specification, used by most