rgeo 0.4.0 → 0.5.0

data/lib/rgeo/geos/ffi_feature_classes.rb

@@ -5,134 +5,79 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
   module Geos
-
-
-    class FFIGeometryImpl  # :nodoc:
-
-
+    class FFIGeometryImpl # :nodoc:
       include FFIGeometryMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::Geometry).include_in_class(self, true)
-
-
     end
 
-
-    class FFIPointImpl  # :nodoc:
-
-
+    class FFIPointImpl # :nodoc:
       include FFIGeometryMethods
       include FFIPointMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::Point).include_in_class(self, true)
-
-
     end
 
-
     class FFILineStringImpl  # :nodoc:
-
-
       include FFIGeometryMethods
       include FFILineStringMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::LineString).include_in_class(self, true)
-
-
     end
 
-
     class FFILinearRingImpl  # :nodoc:
-
-
       include FFIGeometryMethods
       include FFILineStringMethods
       include FFILinearRingMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::LinearRing).include_in_class(self, true)
-
-
     end
 
-
-    class FFILineImpl  # :nodoc:
-
-
+    class FFILineImpl # :nodoc:
       include FFIGeometryMethods
       include FFILineStringMethods
       include FFILineMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::Line).include_in_class(self, true)
-
-
     end
 
-
-    class FFIPolygonImpl  # :nodoc:
-
-
+    class FFIPolygonImpl # :nodoc:
       include FFIGeometryMethods
       include FFIPolygonMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::Polygon).include_in_class(self, true)
-
-
     end
 
-
-    class FFIGeometryCollectionImpl  # :nodoc:
-
-
+    class FFIGeometryCollectionImpl # :nodoc:
       include FFIGeometryMethods
       include FFIGeometryCollectionMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::GeometryCollection).include_in_class(self, true)
-
-
     end
 
-
-    class FFIMultiPointImpl  # :nodoc:
-
-
+    class FFIMultiPointImpl # :nodoc:
       include FFIGeometryMethods
       include FFIGeometryCollectionMethods
       include FFIMultiPointMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPoint).include_in_class(self, true)
-
-
     end
 
-
-    class FFIMultiLineStringImpl  # :nodoc:
-
-
+    class FFIMultiLineStringImpl # :nodoc:
       include FFIGeometryMethods
       include FFIGeometryCollectionMethods
       include FFIMultiLineStringMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::MultiLineString).include_in_class(self, true)
-
-
     end
 
-
-    class FFIMultiPolygonImpl  # :nodoc:
-
-
+    class FFIMultiPolygonImpl # :nodoc:
       include FFIGeometryMethods
       include FFIGeometryCollectionMethods
       include FFIMultiPolygonMethods
 
       Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPolygon).include_in_class(self, true)
-
-
     end
-
-
   end
-
 end

data/lib/rgeo/geos/ffi_feature_methods.rb

@@ -5,15 +5,10 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
   module Geos
-
-
-    module FFIGeometryMethods  # :nodoc:
-
+    module FFIGeometryMethods # :nodoc:
       include Feature::Instance
 
-
       def initialize(factory_, fg_geom_, klasses_)
         @factory = factory_
         @fg_geom = fg_geom_
@@ -22,19 +17,17 @@ module RGeo
         fg_geom_.srid = factory_.srid
       end
 
-
       def inspect
         "#<#{self.class}:0x#{object_id.to_s(16)} #{as_text.inspect}>"
       end
 
-
       # Marshal support
 
-      def marshal_dump  # :nodoc:
+      def marshal_dump # :nodoc:
         [@factory, @factory._write_for_marshal(self)]
       end
 
-      def marshal_load(data_)  # :nodoc:
+      def marshal_load(data_) # :nodoc:
         @factory = data_[0]
         @fg_geom = @factory._read_for_marshal(data_[1])
         @fg_geom.srid = @factory.srid
@@ -42,31 +35,28 @@ module RGeo
         @_klasses = nil
       end
 
-
       # Psych support
 
-      def encode_with(coder_)  # :nodoc:
-        coder_['factory'] = @factory
+      def encode_with(coder_) # :nodoc:
+        coder_["factory"] = @factory
         str_ = @factory._write_for_psych(self)
-        str_ = str_.encode('US-ASCII') if str_.respond_to?(:encode)
-        coder_['wkt'] = str_
+        str_ = str_.encode("US-ASCII") if str_.respond_to?(:encode)
+        coder_["wkt"] = str_
       end
 
       def init_with(coder_)  # :nodoc:
-        @factory = coder_['factory']
-        @fg_geom = @factory._read_for_psych(coder_['wkt'])
+        @factory = coder_["factory"]
+        @fg_geom = @factory._read_for_psych(coder_["wkt"])
         @fg_geom.srid = @factory.srid
         @_fg_prep = @factory._auto_prepare ? 1 : 0
         @_klasses = nil
       end
 
-
       attr_reader :factory
       attr_reader :fg_geom
 
       attr_reader :_klasses  # :nodoc:
 
-
       def initialize_copy(orig_)
         @factory = orig_.factory
         @fg_geom = orig_.fg_geom.clone
@@ -75,27 +65,22 @@ module RGeo
         @_klasses = orig_._klasses
       end
 
-
       def srid
         @fg_geom.srid
       end
 
-
       def dimension
         Utils.ffi_compute_dimension(@fg_geom)
       end
 
-
       def geometry_type
         Feature::Geometry
       end
 
-
       def prepared?
         !@_fg_prep.is_a?(::Integer)
       end
 
-
       def prepare!
         if @_fg_prep.is_a?(::Integer)
           @_fg_prep = ::Geos::PreparedGeometry.new(@fg_geom)
@@ -103,12 +88,10 @@ module RGeo
         self
       end
 
-
       def envelope
         @factory._wrap_fg_geom(@fg_geom.envelope, nil)
       end
 
-
       def boundary
         if self.class == FFIGeometryCollectionImpl
           nil
@@ -117,32 +100,27 @@ module RGeo
         end
       end
 
-
       def as_text
         str_ = @factory._generate_wkt(self)
-        str_.force_encoding('US-ASCII') if str_.respond_to?(:force_encoding)
+        str_.force_encoding("US-ASCII") if str_.respond_to?(:force_encoding)
         str_
       end
       alias_method :to_s, :as_text
 
-
       def as_binary
         @factory._generate_wkb(self)
       end
 
-
       def is_empty?
         @fg_geom.empty?
       end
 
-
       def is_simple?
         @fg_geom.simple?
       end
 
-
       def equals?(rhs_)
-        return false unless rhs_.kind_of?(::RGeo::Feature::Instance)
+        return false unless rhs_.is_a?(::RGeo::Feature::Instance)
         fg_ = factory._convert_to_fg_geometry(rhs_)
         if !fg_
           false
@@ -156,7 +134,6 @@ module RGeo
       end
       alias_method :==, :equals?
 
-
       def disjoint?(rhs_)
         fg_ = factory._convert_to_fg_geometry(rhs_)
         if fg_
@@ -167,7 +144,6 @@ module RGeo
         end
       end
 
-
       def intersects?(rhs_)
         fg_ = factory._convert_to_fg_geometry(rhs_)
         if fg_
@@ -178,7 +154,6 @@ module RGeo
         end
       end
 
-
       def touches?(rhs_)
         fg_ = factory._convert_to_fg_geometry(rhs_)
         if fg_
@@ -189,7 +164,6 @@ module RGeo
         end
       end
 
-
       def crosses?(rhs_)
         fg_ = factory._convert_to_fg_geometry(rhs_)
         if fg_
@@ -200,7 +174,6 @@ module RGeo
         end
       end
 
-
       def within?(rhs_)
         fg_ = factory._convert_to_fg_geometry(rhs_)
         if fg_
@@ -211,7 +184,6 @@ module RGeo
         end
       end
 
-
       def contains?(rhs_)
         fg_ = factory._convert_to_fg_geometry(rhs_)
         if fg_
@@ -222,7 +194,6 @@ module RGeo
         end
       end
 
-
       def overlaps?(rhs_)
         fg_ = factory._convert_to_fg_geometry(rhs_)
         if fg_
@@ -233,30 +204,25 @@ module RGeo
         end
       end
 
-
       def relate?(rhs_, pattern_)
         fg_ = factory._convert_to_fg_geometry(rhs_)
         fg_ ? @fg_geom.relate_pattern(fg_, pattern_) : nil
       end
-      alias_method :relate, :relate?  # DEPRECATED
-
+      alias_method :relate, :relate? # DEPRECATED
 
       def distance(rhs_)
         fg_ = factory._convert_to_fg_geometry(rhs_)
         fg_ ? @fg_geom.distance(fg_) : nil
       end
 
-
       def buffer(distance_)
         @factory._wrap_fg_geom(@fg_geom.buffer(distance_, @factory.buffer_resolution), nil)
       end
 
-
       def convex_hull
         @factory._wrap_fg_geom(@fg_geom.convex_hull, nil)
       end
 
-
       def intersection(rhs_)
         fg_ = factory._convert_to_fg_geometry(rhs_)
         fg_ ? @factory._wrap_fg_geom(@fg_geom.intersection(fg_), nil) : nil
@@ -264,7 +230,6 @@ module RGeo
 
       alias_method :*, :intersection
 
-
       def union(rhs_)
         fg_ = factory._convert_to_fg_geometry(rhs_)
         fg_ ? @factory._wrap_fg_geom(@fg_geom.union(fg_), nil) : nil
@@ -272,7 +237,6 @@ module RGeo
 
       alias_method :+, :union
 
-
       def difference(rhs_)
         fg_ = factory._convert_to_fg_geometry(rhs_)
         fg_ ? @factory._wrap_fg_geom(@fg_geom.difference(fg_), nil) : nil
@@ -280,26 +244,22 @@ module RGeo
 
       alias_method :-, :difference
 
-
       def sym_difference(rhs_)
         fg_ = factory._convert_to_fg_geometry(rhs_)
         fg_ ? @factory._wrap_fg_geom(@fg_geom.sym_difference(fg_), nil) : nil
       end
 
-
       def eql?(rhs_)
         rep_equals?(rhs_)
       end
 
-
-      def _detach_fg_geom  # :nodoc:
+      def _detach_fg_geom # :nodoc:
         fg_ = @fg_geom
         @fg_geom = nil
         fg_
       end
 
-
-      def _request_prepared  # :nodoc:
+      def _request_prepared # :nodoc:
         case @_fg_prep
         when 0
           nil
@@ -312,79 +272,59 @@ module RGeo
           @_fg_prep
         end
       end
-
-
     end
 
-
-    module FFIPointMethods  # :nodoc:
-
-
+    module FFIPointMethods # :nodoc:
       def x
         @fg_geom.coord_seq.get_x(0)
       end
 
-
       def y
         @fg_geom.coord_seq.get_y(0)
       end
 
-
       def z
-        if @factory.property(:has_z_coordinate)
-          @fg_geom.coord_seq.get_z(0)
-        else
-          nil
-        end
+        @fg_geom.coord_seq.get_z(0) if @factory.property(:has_z_coordinate)
       end
 
-
       def m
-        if @factory.property(:has_m_coordinate)
-          @fg_geom.coord_seq.get_z(0)
-        else
-          nil
-        end
+        @fg_geom.coord_seq.get_z(0) if @factory.property(:has_m_coordinate)
       end
 
-
       def geometry_type
         Feature::Point
       end
 
-
       def rep_equals?(rhs_)
         rhs_.class == self.class && rhs_.factory.eql?(@factory) &&
           Utils.ffi_coord_seqs_equal?(rhs_.fg_geom.coord_seq, @fg_geom.coord_seq, @factory._has_3d)
       end
 
-
       def hash
         @hash ||= Utils.ffi_coord_seq_hash(@fg_geom.coord_seq, [@factory, geometry_type].hash)
       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 FFILineStringMethods  # :nodoc:
-
-
       def geometry_type
         Feature::LineString
       end
 
-
       def length
         @fg_geom.length
       end
 
-
       def num_points
         @fg_geom.num_points
       end
 
-
       def point_n(n_)
         if n_ >= 0 && n_ < @fg_geom.num_points
           coord_seq_ = @fg_geom.coord_seq
@@ -392,22 +332,17 @@ module RGeo
           y_ = coord_seq_.get_y(n_)
           extra_ = @factory._has_3d ? [coord_seq_.get_z(n_)] : []
           @factory.point(x_, y_, *extra_)
-        else
-          nil
         end
       end
 
-
       def start_point
         point_n(0)
       end
 
-
       def end_point
         point_n(@fg_geom.num_points - 1)
       end
 
-
       def points
         coord_seq_ = @fg_geom.coord_seq
         has_3d_ = @factory._has_3d
@@ -419,106 +354,80 @@ module RGeo
         end
       end
 
-
       def is_closed?
         @fg_geom.closed?
       end
 
-
       def is_ring?
         @fg_geom.ring?
       end
 
-
       def rep_equals?(rhs_)
         rhs_.class == self.class && rhs_.factory.eql?(@factory) &&
           Utils.ffi_coord_seqs_equal?(rhs_.fg_geom.coord_seq, @fg_geom.coord_seq, @factory._has_3d)
       end
 
-
       def hash
         @hash ||= Utils.ffi_coord_seq_hash(@fg_geom.coord_seq, [@factory, geometry_type].hash)
       end
 
-
+      def coordinates
+        points.map(&:coordinates)
+      end
     end
 
-
     module FFILinearRingMethods  # :nodoc:
-
-
       def geometry_type
         Feature::LinearRing
       end
-
-
     end
 
-
-    module FFILineMethods  # :nodoc:
-
-
+    module FFILineMethods # :nodoc:
       def geometry_type
         Feature::Line
       end
-
-
     end
 
-
-    module FFIPolygonMethods  # :nodoc:
-
-
+    module FFIPolygonMethods # :nodoc:
       def geometry_type
         Feature::Polygon
       end
 
-
       def area
         @fg_geom.area
       end
 
-
       def centroid
         @factory._wrap_fg_geom(@fg_geom.centroid, FFIPointImpl)
       end
 
-
       def point_on_surface
         @factory._wrap_fg_geom(@fg_geom.point_on_surface, FFIPointImpl)
       end
 
-
       def exterior_ring
         @factory._wrap_fg_geom(@fg_geom.exterior_ring, FFILinearRingImpl)
       end
 
-
       def num_interior_rings
         @fg_geom.num_interior_rings
       end
 
-
       def interior_ring_n(n_)
         if n_ >= 0 && n_ < @fg_geom.num_interior_rings
           @factory._wrap_fg_geom(@fg_geom.interior_ring_n(n_), FFILinearRingImpl)
-        else
-          nil
         end
       end
 
-
       def interior_rings
         ::Array.new(@fg_geom.num_interior_rings) do |n_|
           @factory._wrap_fg_geom(@fg_geom.interior_ring_n(n_), FFILinearRingImpl)
         end
       end
 
-
       def rep_equals?(rhs_)
         if rhs_.class == self.class && rhs_.factory.eql?(@factory) &&
-          rhs_.exterior_ring.rep_equals?(self.exterior_ring)
-        then
+          rhs_.exterior_ring.rep_equals?(exterior_ring)
           sn_ = @fg_geom.num_interior_rings
           rn_ = rhs_.num_interior_rings
           if sn_ == rn_
@@ -531,7 +440,6 @@ module RGeo
         false
       end
 
-
       def hash
         @hash ||= begin
           hash_ = Utils.ffi_coord_seq_hash(@fg_geom.exterior_ring.coord_seq,
@@ -542,18 +450,16 @@ module RGeo
         end
       end
 
-
+      def coordinates
+        ([exterior_ring] + interior_rings).map(&:coordinates)
+      end
     end
 
-
-    module FFIGeometryCollectionMethods  # :nodoc:
-
-
+    module FFIGeometryCollectionMethods # :nodoc:
       def geometry_type
         Feature::GeometryCollection
       end
 
-
       def rep_equals?(rhs_)
         if rhs_.class == self.class && rhs_.factory.eql?(@factory)
           size_ = @fg_geom.num_geometries
@@ -567,44 +473,35 @@ module RGeo
         false
       end
 
-
       def num_geometries
         @fg_geom.num_geometries
       end
       alias_method :size, :num_geometries
 
-
       def geometry_n(n_)
         if n_ >= 0 && n_ < @fg_geom.num_geometries
           @factory._wrap_fg_geom(@fg_geom.get_geometry_n(n_),
             @_klasses ? @_klasses[n_] : nil)
-        else
-          nil
         end
       end
 
-
       def [](n_)
         n_ += @fg_geom.num_geometries if n_ < 0
         if n_ >= 0 && n_ < @fg_geom.num_geometries
           @factory._wrap_fg_geom(@fg_geom.get_geometry_n(n_),
             @_klasses ? @_klasses[n_] : nil)
-        else
-          nil
         end
       end
 
-
       def hash
         @hash ||= begin
           hash_ = [@factory, geometry_type].hash
           (0...num_geometries).inject(hash_) do |h_, i_|
-            (1664525 * h_ + geometry_n(i_).hash).hash
+            (1_664_525 * h_ + geometry_n(i_).hash).hash
           end
         end
       end
 
-
       def each
         if block_given?
           @fg_geom.num_geometries.times do |n_|
@@ -618,35 +515,27 @@ module RGeo
       end
 
       include ::Enumerable
-
-
     end
 
-
-    module FFIMultiPointMethods  # :nodoc:
-
-
+    module FFIMultiPointMethods # :nodoc:
       def geometry_type
         Feature::MultiPoint
       end
 
-
+      def coordinates
+        each.map(&:coordinates)
+      end
     end
 
-
-    module FFIMultiLineStringMethods  # :nodoc:
-
-
+    module FFIMultiLineStringMethods # :nodoc:
       def geometry_type
         Feature::MultiLineString
       end
 
-
       def length
         @fg_geom.length
       end
 
-
       def is_closed?
         size_ = num_geometries
         size_.times do |n_|
@@ -655,36 +544,31 @@ module RGeo
         true
       end
 
-
+      def coordinates
+        each.map(&:coordinates)
+      end
     end
 
-
-    module FFIMultiPolygonMethods  # :nodoc:
-
-
+    module FFIMultiPolygonMethods # :nodoc:
       def geometry_type
         Feature::MultiPolygon
       end
 
-
       def area
         @fg_geom.area
       end
 
-
       def centroid
         @factory._wrap_fg_geom(@fg_geom.centroid, FFIPointImpl)
       end
 
-
       def point_on_surface
         @factory._wrap_fg_geom(@fg_geom.point_on_surface, FFIPointImpl)
       end
 
-
+      def coordinates
+        each.map(&:coordinates)
+      end
     end
-
-
   end
-
 end