rgeo 1.1.2 → 2.0.0

data/lib/rgeo/impl_helper/basic_geometry_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Basic methods used by geometry objects
@@ -9,6 +11,8 @@ module RGeo
     module BasicGeometryMethods # :nodoc:
       include Feature::Instance
 
+      attr_accessor :factory
+
       def inspect # :nodoc:
         "#<#{self.class}:0x#{object_id.to_s(16)} #{as_text.inspect}>"
       end
@@ -17,44 +21,38 @@ module RGeo
         as_text
       end
 
-      def _validate_geometry # :nodoc:
-      end
-
-      def _set_factory(factory_)  # :nodoc:
-        @factory = factory_
+      def as_text
+        @factory.generate_wkt(self)
       end
 
-      def factory
-        @factory
+      def as_binary
+        @factory.generate_wkb(self)
       end
 
-      def as_text
-        @factory._generate_wkt(self)
+      def marshal_dump # :nodoc:
+        [@factory, @factory.marshal_wkb_generator.generate(self)]
       end
 
-      def as_binary
-        @factory._generate_wkb(self)
+      def marshal_load(data)  # :nodoc:
+        copy_state_from(data[0].marshal_wkb_parser.parse(data[1]))
       end
 
-      def _copy_state_from(obj_)  # :nodoc:
-        @factory = obj_.factory
+      def encode_with(coder)  # :nodoc:
+        coder["factory"] = @factory
+        coder["wkt"] = @factory.psych_wkt_generator.generate(self)
       end
 
-      def marshal_dump # :nodoc:
-        [@factory, @factory._marshal_wkb_generator.generate(self)]
+      def init_with(coder) # :nodoc:
+        copy_state_from(coder["factory"].psych_wkt_parser.parse(coder["wkt"]))
       end
 
-      def marshal_load(data_)  # :nodoc:
-        _copy_state_from(data_[0]._marshal_wkb_parser.parse(data_[1]))
-      end
+      private
 
-      def encode_with(coder_)  # :nodoc:
-        coder_["factory"] = @factory
-        coder_["wkt"] = @factory._psych_wkt_generator.generate(self)
+      def copy_state_from(obj)
+        @factory = obj.factory
       end
 
-      def init_with(coder_) # :nodoc:
-        _copy_state_from(coder_["factory"]._psych_wkt_parser.parse(coder_["wkt"]))
+      def validate_geometry
       end
     end
   end

data/lib/rgeo/impl_helper/basic_line_string_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Common methods for LineString features
@@ -7,28 +9,22 @@
 module RGeo
   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)
-          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"
+      def initialize(factory, points)
+        self.factory = factory
+        @points = points.map do |elem|
+          elem = Feature.cast(elem, factory, Feature::Point)
+          raise Error::InvalidGeometry, "Could not cast #{elem}" unless elem
+          elem
         end
+        validate_geometry
       end
 
       def num_points
         @points.size
       end
 
-      def point_n(n_)
-        n_ < 0 ? nil : @points[n_]
+      def point_n(n)
+        n < 0 ? nil : @points[n]
       end
 
       def points
@@ -48,9 +44,9 @@ module RGeo
       end
 
       def boundary
-        array_ = []
-        array_ << @points.first << @points.last if !is_empty? && !is_closed?
-        factory.multi_point([array_])
+        array = []
+        array << @points.first << @points.last if !is_empty? && !is_closed?
+        factory.multipoint([array])
       end
 
       def start_point
@@ -72,9 +68,9 @@ module RGeo
         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_) }
+      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
@@ -82,39 +78,40 @@ module RGeo
 
       def hash
         @hash ||= begin
-          hash_ = [factory, geometry_type].hash
-          @points.inject(hash_) { |h_, p_| (1_664_525 * h_ + p_.hash).hash }
+          hash = [factory, geometry_type].hash
+          @points.inject(hash) { |h, p| (1_664_525 * h + p.hash).hash }
         end
       end
 
-      def _copy_state_from(obj_) # :nodoc:
-        super
-        @points = obj_.points
-      end
-
       def coordinates
         @points.map(&:coordinates)
       end
-    end
 
-    module BasicLineMethods # :nodoc:
-      def initialize(factory_, start_, end_)
-        _set_factory(factory_)
-        cstart_ = Feature.cast(start_, factory_, Feature::Point)
-        unless cstart_
-          raise Error::InvalidGeometry, "Could not cast start: #{start_}"
+      private
+
+      def copy_state_from(obj)
+        super
+        @points = obj.points
+      end
+
+      def validate_geometry
+        if @points.size == 1
+          raise Error::InvalidGeometry, "LineString cannot have 1 point"
         end
-        cend_ = Feature.cast(end_, factory_, Feature::Point)
-        raise Error::InvalidGeometry, "Could not cast end: #{end_}" unless cend_
-        @points = [cstart_, cend_]
-        _validate_geometry
       end
+    end
 
-      def _validate_geometry # :nodoc:
-        super
-        if @points.size > 2
-          raise Error::InvalidGeometry, "Line must have 0 or 2 points"
+    module BasicLineMethods # :nodoc:
+      def initialize(factory, start, stop)
+        self.factory = factory
+        cstart = Feature.cast(start, factory, Feature::Point)
+        unless cstart
+          raise Error::InvalidGeometry, "Could not cast start: #{start}"
         end
+        cstop = Feature.cast(stop, factory, Feature::Point)
+        raise Error::InvalidGeometry, "Could not cast end: #{stop}" unless cstop
+        @points = [cstart, cstop]
+        validate_geometry
       end
 
       def geometry_type
@@ -124,23 +121,34 @@ module RGeo
       def coordinates
         @points.map(&:coordinates)
       end
+
+      private
+
+      def validate_geometry
+        super
+        if @points.size > 2
+          raise Error::InvalidGeometry, "Line must have 0 or 2 points"
+        end
+      end
     end
 
     module BasicLinearRingMethods # :nodoc:
-      def _validate_geometry # :nodoc:
+      def geometry_type
+        Feature::LinearRing
+      end
+
+      private
+
+      def validate_geometry
         super
         if @points.size > 0
           @points << @points.first if @points.first != @points.last
-          @points = @points.chunk {|x| x}.map(&:first)
+          @points = @points.chunk { |x| x }.map(&:first)
           if !@factory.property(:uses_lenient_assertions) && !is_ring?
             raise Error::InvalidGeometry, "LinearRing failed ring test"
           end
         end
       end
-
-      def geometry_type
-        Feature::LinearRing
-      end
     end
   end
 end

data/lib/rgeo/impl_helper/basic_point_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Common methods for Point features
@@ -7,16 +9,16 @@
 module RGeo
   module ImplHelper # :nodoc:
     module BasicPointMethods # :nodoc:
-      def initialize(factory_, x_, y_, *extra_)
-        _set_factory(factory_)
-        @x = x_.to_f
-        @y = y_.to_f
-        @z = factory_.property(:has_z_coordinate) ? extra_.shift.to_f : nil
-        @m = factory_.property(:has_m_coordinate) ? extra_.shift.to_f : nil
-        if extra_.size > 0
-          raise ::ArgumentError, "Too many arguments for point initializer"
+      def initialize(factory, x, y, *extra)
+        self.factory = factory
+        @x = x.to_f
+        @y = y.to_f
+        @z = factory.property(:has_z_coordinate) ? extra.shift.to_f : nil
+        @m = factory.property(:has_m_coordinate) ? extra.shift.to_f : nil
+        if extra.size > 0
+          raise ArgumentError, "Too many arguments for point initializer"
         end
-        _validate_geometry
+        validate_geometry
       end
 
       def x
@@ -63,42 +65,44 @@ module RGeo
         self
       end
 
-      def equals?(rhs_)
-        return false unless rhs_.is_a?(self.class) && rhs_.factory == factory
-        case rhs_
+      def equals?(rhs)
+        return false unless rhs.is_a?(self.class) && rhs.factory == factory
+        case rhs
         when Feature::Point
-          rhs_.x == @x && rhs_.y == @y
+          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
+      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:
-        super
-        @x = obj_.x
-        @y = obj_.y
-        @z = obj_.z
-        @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
+
+      private
+
+      def copy_state_from(obj)
+        super
+        @x = obj.x
+        @y = obj.y
+        @z = obj.z
+        @m = obj.m
+      end
     end
   end
 end

data/lib/rgeo/impl_helper/basic_polygon_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Common methods for Polygon features
@@ -7,20 +9,20 @@
 module RGeo
   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)
+      def initialize(factory, exterior_ring, interior_rings)
+        self.factory = factory
+        @exterior_ring = Feature.cast(exterior_ring, factory, Feature::LinearRing)
         unless @exterior_ring
-          raise Error::InvalidGeometry, "Failed to cast exterior ring #{exterior_ring_}"
+          raise Error::InvalidGeometry, "Failed to cast exterior ring #{exterior_ring}"
         end
-        @interior_rings = (interior_rings_ || []).map do |elem_|
-          elem_ = Feature.cast(elem_, factory_, Feature::LinearRing)
-          unless elem_
-            raise Error::InvalidGeometry, "Could not cast interior ring #{elem_}"
+        @interior_rings = (interior_rings || []).map do |elem|
+          elem = Feature.cast(elem, factory, Feature::LinearRing)
+          unless elem
+            raise Error::InvalidGeometry, "Could not cast interior ring #{elem}"
           end
-          elem_
+          elem
         end
-        _validate_geometry
+        validate_geometry
       end
 
       def exterior_ring
@@ -31,8 +33,8 @@ module RGeo
         @interior_rings.size
       end
 
-      def interior_ring_n(n_)
-        n_ < 0 ? nil : @interior_rings[n_]
+      def interior_ring_n(n)
+        n < 0 ? nil : @interior_rings[n]
       end
 
       def interior_rings
@@ -52,15 +54,15 @@ module RGeo
       end
 
       def boundary
-        array_ = []
-        array_ << @exterior_ring unless @exterior_ring.is_empty?
-        array_.concat(@interior_rings)
-        factory.multi_line_string(array_)
+        array = []
+        array << @exterior_ring unless @exterior_ring.is_empty?
+        array.concat(@interior_rings)
+        factory.multiline_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_) }
+      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
@@ -68,20 +70,22 @@ module RGeo
 
       def hash
         @hash ||= begin
-          hash_ = [geometry_type, @exterior_ring].hash
-          @interior_rings.inject(hash_) { |h_, r_| (1_664_525 * h_ + r_.hash).hash }
+          hash = [geometry_type, @exterior_ring].hash
+          @interior_rings.inject(hash) { |h, r| (1_664_525 * h + r.hash).hash }
         end
       end
 
-      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
+
+      private
+
+      def copy_state_from(obj)
+        super
+        @exterior_ring = obj.exterior_ring
+        @interior_rings = obj.interior_rings
+      end
     end
   end
 end

data/lib/rgeo/impl_helper/math.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Math constants and tools

data/lib/rgeo/impl_helper/utils.rb

@@ -1,28 +1,22 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
-# Math constants and tools
+# Utility module
 #
 # -----------------------------------------------------------------------------
 
 module RGeo
   module ImplHelper # :nodoc:
     module Utils # :nodoc:
-      class << self
-        def stringize_hash(hash_)
-          nhash_ = {}
-          hash_.each do |k_, v_|
-            nhash_[k_.is_a?(::Symbol) ? k_.to_s : k_] = v_.is_a?(::Symbol) ? v_.to_s : v_
-          end
-          nhash_
-        end
+      private
 
-        def symbolize_hash(hash_)
-          nhash_ = {}
-          hash_.each do |k_, v_|
-            nhash_[k_.is_a?(::String) ? k_.to_sym : k_] = v_.is_a?(::String) ? v_.to_sym : v_
-          end
-          nhash_
+      def symbolize_hash(hash)
+        nhash = {}
+        hash.each do |k, v|
+          nhash[k.to_sym] = v.is_a?(String) ? v.to_sym : v
         end
+        nhash
       end
     end
   end