rgeo 0.4.0 → 0.5.0

data/lib/rgeo/impl_helper.rb

@@ -5,20 +5,15 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
-
-  module ImplHelper  # :nodoc:
+  module ImplHelper # :nodoc:
   end
-
-
 end
 
-
 # Implementation files
-require 'rgeo/impl_helper/utils'
-require 'rgeo/impl_helper/math'
-require 'rgeo/impl_helper/basic_geometry_methods'
-require 'rgeo/impl_helper/basic_geometry_collection_methods'
-require 'rgeo/impl_helper/basic_point_methods'
-require 'rgeo/impl_helper/basic_line_string_methods'
-require 'rgeo/impl_helper/basic_polygon_methods'
+require "rgeo/impl_helper/utils"
+require "rgeo/impl_helper/math"
+require "rgeo/impl_helper/basic_geometry_methods"
+require "rgeo/impl_helper/basic_geometry_collection_methods"
+require "rgeo/impl_helper/basic_point_methods"
+require "rgeo/impl_helper/basic_line_string_methods"
+require "rgeo/impl_helper/basic_polygon_methods"

data/lib/rgeo/impl_helper/basic_geometry_collection_methods.rb

@@ -5,46 +5,34 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
-  module ImplHelper  # :nodoc:
-
-
-    module BasicGeometryCollectionMethods  # :nodoc:
-
-
+  module ImplHelper # :nodoc:
+    module BasicGeometryCollectionMethods # :nodoc:
       def initialize(factory_, elements_)
         _set_factory(factory_)
         @elements = elements_.map do |elem_|
           elem_ = Feature.cast(elem_, factory_)
-          unless elem_
-            raise Error::InvalidGeometry, "Could not cast #{elem_}"
-          end
+          raise Error::InvalidGeometry, "Could not cast #{elem_}" unless elem_
           elem_
         end
         _validate_geometry
       end
 
-
       def num_geometries
         @elements.size
       end
 
-
       def geometry_n(n_)
         n_ < 0 ? nil : @elements[n_]
       end
 
-
       def [](n_)
         @elements[n_]
       end
 
-
       def each(&block_)
         @elements.each(&block_)
       end
 
-
       def dimension
         unless defined?(@dimension)
           @dimension = -1
@@ -56,85 +44,67 @@ module RGeo
         @dimension
       end
 
-
       def geometry_type
         Feature::GeometryCollection
       end
 
-
       def is_empty?
         @elements.size == 0
       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_) }
+          rhs_.each_with_index { |p_, i_| return false unless @elements[i_].rep_equals?(p_) }
         else
           false
         end
       end
 
-
       def hash
         @hash ||= begin
           hash_ = [factory, geometry_type].hash
-          @elements.inject(hash_){ |h_, g_| (1664525 * h_ + g_.hash).hash }
+          @elements.inject(hash_) { |h_, g_| (1_664_525 * h_ + g_.hash).hash }
         end
       end
 
-
-      def _copy_state_from(obj_)  # :nodoc:
+      def _copy_state_from(obj_) # :nodoc:
         super
         @elements = obj_._elements
       end
 
-
-      def _elements  # :nodoc:
+      def _elements # :nodoc:
         @elements
       end
-
-
     end
 
-
     module BasicMultiLineStringMethods  # :nodoc:
-
-
       def initialize(factory_, elements_)
         _set_factory(factory_)
         @elements = elements_.map do |elem_|
           elem_ = Feature.cast(elem_, factory_, Feature::LineString, :keep_subtype)
-          unless elem_
-            raise Error::InvalidGeometry, "Could not cast #{elem_}"
-          end
+          raise Error::InvalidGeometry, "Could not cast #{elem_}" unless elem_
           elem_
         end
         _validate_geometry
       end
 
-
       def geometry_type
         Feature::MultiLineString
       end
 
-
       def is_closed?
-        all?{ |elem_| elem_.is_closed? }
+        all?(&:is_closed?)
       end
 
-
       def length
-        @elements.inject(0.0){ |sum_, obj_| sum_ + obj_.length }
+        @elements.inject(0.0) { |sum_, obj_| sum_ + obj_.length }
       end
 
-
       def _add_boundary(hash_, point_)  # :nodoc:
         hval_ = [point_.x, point_.y].hash
         (hash_[hval_] ||= [point_, 0])[1] += 1
       end
 
-
       def boundary
         hash_ = {}
         @elements.each do |line_|
@@ -144,86 +114,72 @@ module RGeo
           end
         end
         array_ = []
-        hash_.each do |hval_, data_|
-          array_ << data_[0] if data_[1] % 2 == 1
+        hash_.each do |_hval_, data_|
+          array_ << data_[0] if data_[1].odd?
         end
         factory.multi_point([array_])
       end
 
-
+      def coordinates
+        @elements.map(&:coordinates)
+      end
     end
 
-
-    module BasicMultiPointMethods  # :nodoc:
-
-
+    module BasicMultiPointMethods # :nodoc:
       def initialize(factory_, elements_)
         _set_factory(factory_)
         @elements = elements_.map do |elem_|
           elem_ = Feature.cast(elem_, factory_, Feature::Point, :keep_subtype)
-          unless elem_
-            raise Error::InvalidGeometry, "Could not cast #{elem_}"
-          end
+          raise Error::InvalidGeometry, "Could not cast #{elem_}" unless elem_
           elem_
         end
         _validate_geometry
       end
 
-
       def geometry_type
         Feature::MultiPoint
       end
 
-
       def boundary
         factory.collection([])
       end
 
-
+      def coordinates
+        @elements.map(&:coordinates)
+      end
     end
 
-
-    module BasicMultiPolygonMethods  # :nodoc:
-
-
+    module BasicMultiPolygonMethods # :nodoc:
       def initialize(factory_, elements_)
         _set_factory(factory_)
         @elements = elements_.map do |elem_|
           elem_ = Feature.cast(elem_, factory_, Feature::Polygon, :keep_subtype)
-          unless elem_
-            raise Error::InvalidGeometry, "Could not cast #{elem_}"
-          end
+          raise Error::InvalidGeometry, "Could not cast #{elem_}" unless elem_
           elem_
         end
         _validate_geometry
       end
 
-
       def geometry_type
         Feature::MultiPolygon
       end
 
-
       def area
-        @elements.inject(0.0){ |sum_, obj_| sum_ + obj_.area }
+        @elements.inject(0.0) { |sum_, obj_| sum_ + obj_.area }
       end
 
-
       def boundary
         array_ = []
         @elements.each do |poly_|
-          unless poly_.is_empty?
-            array_ << poly_.exterior_ring
-          end
+          array_ << poly_.exterior_ring unless poly_.is_empty?
           array_.concat(poly_.interior_rings)
         end
         factory.multi_line_string(array_)
       end
 
-
+      def coordinates
+        @elements.map(&:coordinates)
+      end
     end
-
-
   end
-
 end

data/lib/rgeo/impl_helper/basic_geometry_methods.rb

@@ -5,54 +5,42 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
-  module ImplHelper  # :nodoc:
-
-
-    module BasicGeometryMethods  # :nodoc:
-
+  module ImplHelper # :nodoc:
+    module BasicGeometryMethods # :nodoc:
       include Feature::Instance
 
-
-      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 _validate_geometry  # :nodoc:
+      def _validate_geometry # :nodoc:
       end
 
-
       def _set_factory(factory_)  # :nodoc:
         @factory = factory_
       end
 
-
       def factory
         @factory
       end
 
-
       def as_text
         @factory._generate_wkt(self)
       end
 
-
       def as_binary
         @factory._generate_wkb(self)
       end
 
-
       def _copy_state_from(obj_)  # :nodoc:
         @factory = obj_.factory
       end
 
-
-      def marshal_dump  # :nodoc:
+      def marshal_dump # :nodoc:
         [@factory, @factory._marshal_wkb_generator.generate(self)]
       end
 
@@ -60,20 +48,14 @@ 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
-
-
   end
-
 end

data/lib/rgeo/impl_helper/basic_line_string_methods.rb

@@ -5,82 +5,62 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
-  module ImplHelper  # :nodoc:
-
-
-    module BasicLineStringMethods  # :nodoc:
-
-
+  module ImplHelper # :nodoc:
+    module BasicLineStringMethods # :nodoc:
       def initialize(factory_, points_)
         _set_factory(factory_)
         @points = points_.map do |elem_|
           elem_ = Feature.cast(elem_, factory_, Feature::Point)
-          unless elem_
-            raise Error::InvalidGeometry, "Could not cast #{elem_}"
-          end
+          raise Error::InvalidGeometry, "Could not cast #{elem_}" unless elem_
           elem_
         end
         _validate_geometry
       end
 
-
       def _validate_geometry
         if @points.size == 1
-          raise Error::InvalidGeometry, 'LineString cannot have 1 point'
+          raise Error::InvalidGeometry, "LineString cannot have 1 point"
         end
       end
 
-
       def num_points
         @points.size
       end
 
-
       def point_n(n_)
         n_ < 0 ? nil : @points[n_]
       end
 
-
       def points
         @points.dup
       end
 
-
       def dimension
         1
       end
 
-
       def geometry_type
         Feature::LineString
       end
 
-
       def is_empty?
         @points.size == 0
       end
 
-
       def boundary
         array_ = []
-        if !is_empty? && !is_closed?
-          array_ << @points.first << @points.last
-        end
+        array_ << @points.first << @points.last if !is_empty? && !is_closed?
         factory.multi_point([array_])
       end
 
-
       def start_point
         @points.first
       end
 
-
       def end_point
         @points.last
       end
 
-
       def is_closed?
         unless defined?(@is_closed)
           @is_closed = @points.size > 2 && @points.first == @points.last
@@ -88,41 +68,36 @@ module RGeo
         @is_closed
       end
 
-
       def is_ring?
         is_closed? && is_simple?
       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_) }
+          rhs_.points.each_with_index { |p_, i_| return false unless @points[i_].rep_equals?(p_) }
         else
           false
         end
       end
 
-
       def hash
         @hash ||= begin
           hash_ = [factory, geometry_type].hash
-          @points.inject(hash_){ |h_, p_| (1664525 * h_ + p_.hash).hash }
+          @points.inject(hash_) { |h_, p_| (1_664_525 * h_ + p_.hash).hash }
         end
       end
 
-
-      def _copy_state_from(obj_)  # :nodoc:
+      def _copy_state_from(obj_) # :nodoc:
         super
         @points = obj_.points
       end
 
-
+      def coordinates
+        @points.map(&:coordinates)
+      end
     end
 
-
-    module BasicLineMethods  # :nodoc:
-
-
+    module BasicLineMethods # :nodoc:
       def initialize(factory_, start_, end_)
         _set_factory(factory_)
         cstart_ = Feature.cast(start_, factory_, Feature::Point)
@@ -130,52 +105,41 @@ module RGeo
           raise Error::InvalidGeometry, "Could not cast start: #{start_}"
         end
         cend_ = Feature.cast(end_, factory_, Feature::Point)
-        unless cend_
-          raise Error::InvalidGeometry, "Could not cast end: #{end_}"
-        end
+        raise Error::InvalidGeometry, "Could not cast end: #{end_}" unless cend_
         @points = [cstart_, cend_]
         _validate_geometry
       end
 
-
-      def _validate_geometry  # :nodoc:
+      def _validate_geometry # :nodoc:
         super
         if @points.size > 2
-          raise Error::InvalidGeometry, 'Line must have 0 or 2 points'
+          raise Error::InvalidGeometry, "Line must have 0 or 2 points"
         end
       end
 
-
       def geometry_type
         Feature::Line
       end
 
-
+      def coordinates
+        @points.map(&:coordinates)
+      end
     end
 
-
-    module BasicLinearRingMethods  # :nodoc:
-
-
-      def _validate_geometry  # :nodoc:
+    module BasicLinearRingMethods # :nodoc:
+      def _validate_geometry # :nodoc:
         super
         if @points.size > 0
           @points << @points.first if @points.first != @points.last
           if !@factory.property(:uses_lenient_assertions) && !is_ring?
-            raise Error::InvalidGeometry, 'LinearRing failed ring test'
+            raise Error::InvalidGeometry, "LinearRing failed ring test"
           end
         end
       end
 
-
       def geometry_type
         Feature::LinearRing
       end
-
-
     end
-
-
   end
-
 end