rgeo 0.4.0 → 0.5.0

data/lib/rgeo/impl_helper/basic_point_methods.rb

@@ -5,13 +5,8 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
-  module ImplHelper  # :nodoc:
-
-
-    module BasicPointMethods  # :nodoc:
-
-
+  module ImplHelper # :nodoc:
+    module BasicPointMethods # :nodoc:
       def initialize(factory_, x_, y_, *extra_)
         _set_factory(factory_)
         @x = x_.to_f
@@ -24,88 +19,73 @@ module RGeo
         _validate_geometry
       end
 
-
       def x
         @x
       end
 
-
       def y
         @y
       end
 
-
       def z
         @z
       end
 
-
       def m
         @m
       end
 
-
       def dimension
         0
       end
 
-
       def geometry_type
         Feature::Point
       end
 
-
       def is_empty?
         false
       end
 
-
       def is_simple?
         true
       end
 
-
       def envelope
         self
       end
 
-
       def boundary
         factory.collection([])
       end
 
-
       def convex_hull
         self
       end
 
-
       def equals?(rhs_)
-        return false unless rhs_.is_a?(self.class) && rhs_.factory == self.factory
+        return false unless rhs_.is_a?(self.class) && rhs_.factory == factory
         case rhs_
         when Feature::Point
           rhs_.x == @x && rhs_.y == @y
         when Feature::LineString
-          rhs_.num_points > 0 && rhs_.points.all?{ |elem_| equals?(elem_) }
+          rhs_.num_points > 0 && rhs_.points.all? { |elem_| equals?(elem_) }
         when Feature::GeometryCollection
-          rhs_.num_geometries > 0 && rhs_.all?{ |elem_| equals?(elem_) }
+          rhs_.num_geometries > 0 && rhs_.all? { |elem_| equals?(elem_) }
         else
           false
         end
       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
 
-
       def hash
         @hash ||= [factory, geometry_type, @x, @y, @z, @m].hash
       end
 
-
-      def _copy_state_from(obj_)  # :nodoc:
+      def _copy_state_from(obj_) # :nodoc:
         super
         @x = obj_.x
         @y = obj_.y
@@ -113,10 +93,12 @@ module RGeo
         @m = obj_.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
-
-
   end
-
 end

data/lib/rgeo/impl_helper/basic_polygon_methods.rb

@@ -5,13 +5,8 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
-  module ImplHelper  # :nodoc:
-
-
-    module BasicPolygonMethods  # :nodoc:
-
-
+  module ImplHelper # :nodoc:
+    module BasicPolygonMethods # :nodoc:
       def initialize(factory_, exterior_ring_, interior_rings_)
         _set_factory(factory_)
         @exterior_ring = Feature.cast(exterior_ring_, factory_, Feature::LinearRing)
@@ -28,79 +23,65 @@ module RGeo
         _validate_geometry
       end
 
-
       def exterior_ring
         @exterior_ring
       end
 
-
       def num_interior_rings
         @interior_rings.size
       end
 
-
       def interior_ring_n(n_)
         n_ < 0 ? nil : @interior_rings[n_]
       end
 
-
       def interior_rings
         @interior_rings.dup
       end
 
-
       def dimension
         2
       end
 
-
       def geometry_type
         Feature::Polygon
       end
 
-
       def is_empty?
         @exterior_ring.is_empty?
       end
 
-
       def boundary
         array_ = []
-        unless @exterior_ring.is_empty?
-          array_ << @exterior_ring
-        end
+        array_ << @exterior_ring unless @exterior_ring.is_empty?
         array_.concat(@interior_rings)
         factory.multi_line_string(array_)
       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_) }
+          rhs_.interior_rings.each_with_index { |r_, i_| return false unless @interior_rings[i_].rep_equals?(r_) }
         else
           false
         end
       end
 
-
       def hash
         @hash ||= begin
           hash_ = [geometry_type, @exterior_ring].hash
-          @interior_rings.inject(hash_){ |h_, r_| (1664525 * h_ + r_.hash).hash }
+          @interior_rings.inject(hash_) { |h_, r_| (1_664_525 * h_ + r_.hash).hash }
         end
       end
 
-
-      def _copy_state_from(obj_)  # :nodoc:
+      def _copy_state_from(obj_) # :nodoc:
         super
         @exterior_ring = obj_.exterior_ring
         @interior_rings = obj_.interior_rings
       end
 
-
+      def coordinates
+        ([@exterior_ring] + @interior_rings).map(&:coordinates)
+      end
     end
-
-
   end
-
 end

data/lib/rgeo/impl_helper/math.rb

@@ -5,16 +5,10 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
-  module ImplHelper  # :nodoc:
-
-    module Math  # :nodoc:
-
-      RADIANS_PER_DEGREE = ::Math::PI/180.0
-      DEGREES_PER_RADIAN = 180.0/::Math::PI
-
+  module ImplHelper # :nodoc:
+    module Math # :nodoc:
+      RADIANS_PER_DEGREE = ::Math::PI / 180.0
+      DEGREES_PER_RADIAN = 180.0 / ::Math::PI
     end
-
   end
-
 end

data/lib/rgeo/impl_helper/utils.rb

@@ -5,13 +5,9 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
-  module ImplHelper  # :nodoc:
-
-    module Utils  # :nodoc:
-
+  module ImplHelper # :nodoc:
+    module Utils # :nodoc:
       class << self
-
         def stringize_hash(hash_)
           nhash_ = {}
           hash_.each do |k_, v_|
@@ -27,11 +23,7 @@ module RGeo
           end
           nhash_
         end
-
       end
-
     end
-
   end
-
 end

data/lib/rgeo/version.rb

@@ -1,3 +1,3 @@
 module RGeo
-  VERSION = "0.4.0".freeze
+  VERSION = "0.5.0".freeze
 end

data/lib/rgeo/wkrep.rb

@@ -5,8 +5,6 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
-
   # This module contains implementations of the OpenGIS well-known
   # representations: the WKT (well-known text representation) and the
   # WKB (well-known binary representation), as defined in the Simple
@@ -30,13 +28,10 @@ module RGeo
 
   module WKRep
   end
-
-
 end
 
-
 # Implementation files
-require 'rgeo/wkrep/wkt_parser'
-require 'rgeo/wkrep/wkt_generator'
-require 'rgeo/wkrep/wkb_parser'
-require 'rgeo/wkrep/wkb_generator'
+require "rgeo/wkrep/wkt_parser"
+require "rgeo/wkrep/wkt_generator"
+require "rgeo/wkrep/wkb_parser"
+require "rgeo/wkrep/wkb_generator"

data/lib/rgeo/wkrep/wkb_generator.rb

@@ -5,10 +5,7 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
   module WKRep
-
-
     # This class provides the functionality of serializing a geometry as
     # WKB (well-known binary) format. You may also customize the
     # serializer to generate PostGIS EWKB extensions to the output, or to
@@ -42,8 +39,6 @@ module RGeo
     #   big endian (XDR), or network byte order. Default is false.
 
     class WKBGenerator
-
-
       # :stopdoc:
       TYPE_CODES = {
         Feature::Point => 1,
@@ -54,15 +49,14 @@ module RGeo
         Feature::MultiPoint => 4,
         Feature::MultiLineString => 5,
         Feature::MultiPolygon => 6,
-        Feature::GeometryCollection => 7,
+        Feature::GeometryCollection => 7
       }.freeze
       # :startdoc:
 
-
       # Create and configure a WKB generator. See the WKBGenerator
       # documentation for the options that can be passed.
 
-      def initialize(opts_={})
+      def initialize(opts_ = {})
         @type_format = opts_[:type_format] || :wkb11
         @emit_ewkb_srid = @type_format == :ewkb ?
           (opts_[:emit_ewkb_srid] ? true : false) : nil
@@ -70,11 +64,8 @@ module RGeo
         @little_endian = opts_[:little_endian] ? true : false
       end
 
-
       # Returns the format for type codes. See WKBGenerator for details.
-      def type_format
-        @type_format
-      end
+      attr_reader :type_format
 
       # Returns whether SRID is embedded. See WKBGenerator for details.
       def emit_ewkb_srid?
@@ -93,17 +84,15 @@ module RGeo
         @little_endian
       end
 
-
-      def _properties  # :nodoc:
+      def _properties # :nodoc:
         {
-          'type_format' => @type_format.to_s,
-          'emit_ewkb_srid' => @emit_ewkb_srid,
-          'hex_format' => @hex_format,
-          'little_endian' => @little_endian,
+          "type_format" => @type_format.to_s,
+          "emit_ewkb_srid" => @emit_ewkb_srid,
+          "hex_format" => @hex_format,
+          "little_endian" => @little_endian
         }
       end
 
-
       # Generate and return the WKB format for the given geometry object,
       # according to the current settings.
 
@@ -122,8 +111,7 @@ module RGeo
         _finish_emitter
       end
 
-
-      def _generate_feature(obj_, toplevel_=false)  # :nodoc:
+      def _generate_feature(obj_, toplevel_ = false) # :nodoc:
         _emit_byte(@little_endian ? 1 : 0)
         type_ = obj_.geometry_type
         type_code_ = TYPE_CODES[type_]
@@ -155,25 +143,24 @@ module RGeo
           else
             _emit_integer(1 + obj_.num_interior_rings)
             _emit_line_string_coords(exterior_ring_)
-            obj_.interior_rings.each{ |r_| _emit_line_string_coords(r_) }
+            obj_.interior_rings.each { |r_| _emit_line_string_coords(r_) }
           end
         elsif type_ == Feature::GeometryCollection
           _emit_integer(obj_.num_geometries)
-          obj_.each{ |g_| _generate_feature(g_) }
+          obj_.each { |g_| _generate_feature(g_) }
         elsif type_ == Feature::MultiPoint
           _emit_integer(obj_.num_geometries)
-          obj_.each{ |g_| _generate_feature(g_) }
+          obj_.each { |g_| _generate_feature(g_) }
         elsif type_ == Feature::MultiLineString
           _emit_integer(obj_.num_geometries)
-          obj_.each{ |g_| _generate_feature(g_) }
+          obj_.each { |g_| _generate_feature(g_) }
         elsif type_ == Feature::MultiPolygon
           _emit_integer(obj_.num_geometries)
-          obj_.each{ |g_| _generate_feature(g_) }
+          obj_.each { |g_| _generate_feature(g_) }
         end
       end
 
-
-      def _point_coords(obj_, array_=[])  # :nodoc:
+      def _point_coords(obj_, array_ = []) # :nodoc:
         array_ << obj_.x
         array_ << obj_.y
         array_ << obj_.z if @cur_has_z
@@ -181,45 +168,34 @@ module RGeo
         array_
       end
 
-
-      def _emit_line_string_coords(obj_)  # :nodoc:
+      def _emit_line_string_coords(obj_) # :nodoc:
         array_ = []
-        obj_.points.each{ |p_| _point_coords(p_, array_) }
+        obj_.points.each { |p_| _point_coords(p_, array_) }
         _emit_integer(obj_.num_points)
         _emit_doubles(array_)
       end
 
-
-      def _start_emitter  # :nodoc:
+      def _start_emitter # :nodoc:
         @cur_array = []
       end
 
-
-      def _emit_byte(value_)  # :nodoc:
+      def _emit_byte(value_) # :nodoc:
         @cur_array << [value_].pack("C")
       end
 
-
       def _emit_integer(value_)  # :nodoc:
-        @cur_array << [value_].pack(@little_endian ? 'V' : 'N')
+        @cur_array << [value_].pack(@little_endian ? "V" : "N")
       end
 
-
       def _emit_doubles(array_)  # :nodoc:
-        @cur_array << array_.pack(@little_endian ? 'E*' : 'G*')
+        @cur_array << array_.pack(@little_endian ? "E*" : "G*")
       end
 
-
-      def _finish_emitter  # :nodoc:
+      def _finish_emitter # :nodoc:
         str_ = @cur_array.join
         @cur_array = nil
         @hex_format ? str_.unpack("H*")[0] : str_
       end
-
-
     end
-
-
   end
-
 end