rgeo 0.4.0 → 0.5.0

data/lib/rgeo/geos/zm_feature_classes.rb

@@ -5,131 +5,76 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
   module Geos
-
-
-    class ZMPointImpl  # :nodoc:
-
-
+    class ZMPointImpl # :nodoc:
       include ZMGeometryMethods
       include ZMPointMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::Point).include_in_class(self, true)
-
-
     end
 
-
     class ZMLineStringImpl  # :nodoc:
-
-
       include ZMGeometryMethods
       include ZMLineStringMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::LineString).include_in_class(self, true)
-
-
     end
 
-
     class ZMLinearRingImpl  # :nodoc:
-
-
       include ZMGeometryMethods
       include ZMLineStringMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::LinearRing).include_in_class(self, true)
-
-
     end
 
-
-    class ZMLineImpl  # :nodoc:
-
-
+    class ZMLineImpl # :nodoc:
       include ZMGeometryMethods
       include ZMLineStringMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::Line).include_in_class(self, true)
-
-
     end
 
-
-    class ZMPolygonImpl  # :nodoc:
-
-
+    class ZMPolygonImpl # :nodoc:
       include ZMGeometryMethods
       include ZMPolygonMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::Polygon).include_in_class(self, true)
-
-
     end
 
-
-    class ZMGeometryCollectionImpl  # :nodoc:
-
-
+    class ZMGeometryCollectionImpl # :nodoc:
       include ZMGeometryMethods
       include ZMGeometryCollectionMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::GeometryCollection).include_in_class(self, true)
-
-
     end
 
-
-    class ZMMultiPointImpl  # :nodoc:
-
-
+    class ZMMultiPointImpl # :nodoc:
       include ZMGeometryMethods
       include ZMGeometryCollectionMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPoint).include_in_class(self, true)
-
-
     end
 
-
-    class ZMMultiLineStringImpl  # :nodoc:
-
-
+    class ZMMultiLineStringImpl # :nodoc:
       include ZMGeometryMethods
       include ZMGeometryCollectionMethods
       include ZMMultiLineStringMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::MultiLineString).include_in_class(self, true)
-
-
     end
 
-
-    class ZMMultiPolygonImpl  # :nodoc:
-
-
+    class ZMMultiPolygonImpl # :nodoc:
       include ZMGeometryMethods
       include ZMGeometryCollectionMethods
       include ZMMultiPolygonMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPolygon).include_in_class(self, true)
-
-
     end
 
-
-    class ZMGeometryImpl  # :nodoc:
-
-
+    class ZMGeometryImpl # :nodoc:
       include ZMGeometryMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::Geometry).include_in_class(self, true)
-
-
     end
-
-
   end
-
 end

data/lib/rgeo/geos/zm_feature_methods.rb

@@ -5,187 +5,150 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
   module Geos
-
-
-    module ZMGeometryMethods  # :nodoc:
-
+    module ZMGeometryMethods # :nodoc:
       include Feature::Instance
 
-
       def initialize(factory_, zgeometry_, mgeometry_)
         @factory = factory_
         @zgeometry = zgeometry_
         @mgeometry = mgeometry_
       end
 
-
-      def inspect  # :nodoc:
+      def inspect # :nodoc:
         "#<#{self.class}:0x#{object_id.to_s(16)} #{as_text.inspect}>"
       end
 
-      def to_s  # :nodoc:
+      def to_s # :nodoc:
         as_text
       end
 
-
       def hash
         @factory.hash ^ @zgeometry.hash ^ @mgeometry.hash
       end
 
-
       def factory
         @factory
       end
 
-
       def z_geometry
         @zgeometry
       end
 
-
       def m_geometry
         @mgeometry
       end
 
-
       def dimension
         @zgeometry.dimension
       end
 
-
       def geometry_type
         @zgeometry.geometry_type
       end
 
-
       def srid
         @factory.srid
       end
 
-
       def envelope
         @factory._create_feature(nil, @zgeometry.envelope, @mgeometry.envelope)
       end
 
-
       def as_text
         @factory.instance_variable_get(:@wkt_generator).generate(self)
       end
 
-
       def as_binary
         @factory.instance_variable_get(:@wkb_generator).generate(self)
       end
 
-
       def is_empty?
         @zgeometry.is_empty?
       end
 
-
       def is_simple?
         @zgeometry.is_simple?
       end
 
-
       def boundary
         @factory._create_feature(nil, @zgeometry.boundary, @mgeometry.boundary)
       end
 
-
       def equals?(rhs_)
         @zgeometry.equals?(::RGeo::Feature.cast(rhs_, self).z_geometry)
       end
 
-
       def disjoint?(rhs_)
         @zgeometry.disjoint?(::RGeo::Feature.cast(rhs_, self).z_geometry)
       end
 
-
       def intersects?(rhs_)
         @zgeometry.intersects?(::RGeo::Feature.cast(rhs_, self).z_geometry)
       end
 
-
       def touches?(rhs_)
         @zgeometry.touches?(::RGeo::Feature.cast(rhs_, self).z_geometry)
       end
 
-
       def crosses?(rhs_)
         @zgeometry.crosses?(::RGeo::Feature.cast(rhs_, self).z_geometry)
       end
 
-
       def within?(rhs_)
         @zgeometry.within?(::RGeo::Feature.cast(rhs_, self).z_geometry)
       end
 
-
       def contains?(rhs_)
         @zgeometry.contains?(::RGeo::Feature.cast(rhs_, self).z_geometry)
       end
 
-
       def overlaps?(rhs_)
         @zgeometry.overlaps?(::RGeo::Feature.cast(rhs_, self).z_geometry)
       end
 
-
       def relate?(rhs_, pattern_)
         @zgeometry.relate?(::RGeo::Feature.cast(rhs_, self).z_geometry, pattern_)
       end
-      alias_method :relate, :relate?  # DEPRECATED
-
+      alias_method :relate, :relate? # DEPRECATED
 
       def distance(rhs_)
         @zgeometry.distance(::RGeo::Feature.cast(rhs_, self).z_geometry)
       end
 
-
       def buffer(distance_)
         @factory._create_feature(nil, @zgeometry.buffer(distance_), @mgeometry.buffer(distance_))
       end
 
-
       def convex_hull
         @factory._create_feature(nil, @zgeometry.convex_hull, @mgeometry.convex_hull)
       end
 
-
       def intersection(rhs_)
         rhs_ = ::RGeo::Feature.cast(rhs_, self)
         @factory._create_feature(nil, @zgeometry.intersection(rhs_.z_geometry), @mgeometry.intersection(rhs_.m_geometry))
       end
 
-
       def union(rhs_)
         rhs_ = ::RGeo::Feature.cast(rhs_, self)
         @factory._create_feature(nil, @zgeometry.union(rhs_.z_geometry), @mgeometry.union(rhs_.m_geometry))
       end
 
-
       def difference(rhs_)
         rhs_ = ::RGeo::Feature.cast(rhs_, self)
         @factory._create_feature(nil, @zgeometry.difference(rhs_.z_geometry), @mgeometry.difference(rhs_.m_geometry))
       end
 
-
       def sym_difference(rhs_)
         rhs_ = ::RGeo::Feature.cast(rhs_, self)
         @factory._create_feature(nil, @zgeometry.sym_difference(rhs_.z_geometry), @mgeometry.sym_difference(rhs_.m_geometry))
       end
 
-
       def rep_equals?(rhs_)
         rhs_ = ::RGeo::Feature.cast(rhs_, self)
         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?
 
@@ -193,15 +156,13 @@ module RGeo
       alias_method :+, :union
       alias_method :*, :intersection
 
-
-      def _copy_state_from(obj_)  # :nodoc:
+      def _copy_state_from(obj_) # :nodoc:
         @factory = obj_.factory
         @zgeometry = obj_.z_geometry
         @mgeometry = obj_.m_geometry
       end
 
-
-      def marshal_dump  # :nodoc:
+      def marshal_dump # :nodoc:
         [@factory, @factory._marshal_wkb_generator.generate(self)]
       end
 
@@ -209,83 +170,70 @@ module RGeo
         _copy_state_from(data_[0]._marshal_wkb_parser.parse(data_[1]))
       end
 
-
       def encode_with(coder_)  # :nodoc:
-        coder_['factory'] = @factory
-        coder_['wkt'] = @factory._psych_wkt_generator.generate(self)
+        coder_["factory"] = @factory
+        coder_["wkt"] = @factory._psych_wkt_generator.generate(self)
       end
 
-      def init_with(coder_)  # :nodoc:
-        _copy_state_from(coder_['factory']._psych_wkt_parser.parse(coder_['wkt']))
+      def init_with(coder_) # :nodoc:
+        _copy_state_from(coder_["factory"]._psych_wkt_parser.parse(coder_["wkt"]))
       end
-
     end
 
-
-    module ZMPointMethods  # :nodoc:
-
-
+    module ZMPointMethods # :nodoc:
       def x
         @zgeometry.x
       end
 
-
       def y
         @zgeometry.y
       end
 
-
       def z
         @zgeometry.z
       end
 
-
       def m
         @mgeometry.m
       end
 
-
+      def coordinates
+        [x, y].tap do |coords|
+          coords << z if @factory.property(:has_z_coordinate)
+          coords << m if @factory.property(:has_m_coordinate)
+        end
+      end
     end
 
-
-    module ZMLineStringMethods  # :nodoc:
-
-
+    module ZMLineStringMethods # :nodoc:
       def length
         @zgeometry.length
       end
 
-
       def start_point
         point_n(0)
       end
 
-
       def end_point
         point_n(num_points - 1)
       end
 
-
       def is_closed?
         @zgeometry.is_closed?
       end
 
-
       def is_ring?
         @zgeometry.is_ring?
       end
 
-
       def num_points
         @zgeometry.num_points
       end
 
-
       def point_n(n_)
         @factory._create_feature(ZMPointImpl, @zgeometry.point_n(n_), @mgeometry.point_n(n_))
       end
 
-
       def points
         result_ = []
         zpoints_ = @zgeometry.points
@@ -296,43 +244,36 @@ module RGeo
         result_
       end
 
-
+      def coordinates
+        points.map(&:coordinates)
+      end
     end
 
-
-    module ZMPolygonMethods  # :nodoc:
-
-
+    module ZMPolygonMethods # :nodoc:
       def area
         @zgeometry.area
       end
 
-
       def centroid
         @factory._create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
       end
 
-
       def point_on_surface
         @factory._create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
       end
 
-
       def exterior_ring
         @factory._create_feature(ZMLineStringImpl, @zgeometry.exterior_ring, @mgeometry.exterior_ring)
       end
 
-
       def num_interior_rings
         @zgeometry.num_interior_rings
       end
 
-
       def interior_ring_n(n_)
         @factory._create_feature(ZMLineStringImpl, @zgeometry.interior_ring_n(n_), @mgeometry.interior_ring_n(n_))
       end
 
-
       def interior_rings
         result_ = []
         zrings_ = @zgeometry.interior_rings
@@ -343,75 +284,61 @@ module RGeo
         result_
       end
 
-
+      def coordinates
+        ([exterior_ring] + interior_rings).map(&:coordinates)
+      end
     end
 
-
-    module ZMGeometryCollectionMethods  # :nodoc:
-
-
+    module ZMGeometryCollectionMethods # :nodoc:
       def num_geometries
         @zgeometry.num_geometries
       end
       alias_method :size, :num_geometries
 
-
       def geometry_n(n_)
         @factory._create_feature(nil, @zgeometry.geometry_n(n_), @mgeometry.geometry_n(n_))
       end
       alias_method :[], :geometry_n
 
-
       def each
         num_geometries.times do |i_|
           yield geometry_n(i_)
         end
       end
 
-
       include ::Enumerable
-
-
     end
 
-
-    module ZMMultiLineStringMethods  # :nodoc:
-
-
+    module ZMMultiLineStringMethods # :nodoc:
       def length
         @zgeometry.length
       end
 
-
       def is_closed?
         @zgeometry.is_closed?
       end
 
-
+      def coordinates
+        each.map(&:coordinates)
+      end
     end
 
-
-    module ZMMultiPolygonMethods  # :nodoc:
-
-
+    module ZMMultiPolygonMethods # :nodoc:
       def area
         @zgeometry.area
       end
 
-
       def centroid
         @factory._create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
       end
 
-
       def point_on_surface
         @factory._create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
       end
 
-
+      def coordinates
+        each.map(&:coordinates)
+      end
     end
-
-
   end
-
 end