rgeo 1.1.2 → 2.0.0

data/lib/rgeo/geos/zm_feature_classes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # GEOS implementation additions written in Ruby
@@ -9,72 +11,52 @@ module RGeo
     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:
       include ZMGeometryMethods
       include ZMLineStringMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::Line).include_in_class(self, true)
     end
 
     class ZMPolygonImpl # :nodoc:
       include ZMGeometryMethods
       include ZMPolygonMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::Polygon).include_in_class(self, true)
     end
 
     class ZMGeometryCollectionImpl # :nodoc:
       include ZMGeometryMethods
       include ZMGeometryCollectionMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::GeometryCollection).include_in_class(self, true)
     end
 
     class ZMMultiPointImpl # :nodoc:
       include ZMGeometryMethods
       include ZMGeometryCollectionMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPoint).include_in_class(self, true)
     end
 
     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:
       include ZMGeometryMethods
       include ZMGeometryCollectionMethods
       include ZMMultiPolygonMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPolygon).include_in_class(self, true)
     end
 
     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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # GEOS implementation additions written in Ruby
@@ -9,10 +11,10 @@ module RGeo
     module ZMGeometryMethods # :nodoc:
       include Feature::Instance
 
-      def initialize(factory_, zgeometry_, mgeometry_)
-        @factory = factory_
-        @zgeometry = zgeometry_
-        @mgeometry = mgeometry_
+      def initialize(factory, zgeometry, mgeometry)
+        @factory = factory
+        @zgeometry = zgeometry
+        @mgeometry = mgeometry
       end
 
       def inspect # :nodoc:
@@ -52,7 +54,7 @@ module RGeo
       end
 
       def envelope
-        @factory._create_feature(nil, @zgeometry.envelope, @mgeometry.envelope)
+        @factory.create_feature(nil, @zgeometry.envelope, @mgeometry.envelope)
       end
 
       def as_text
@@ -72,81 +74,81 @@ module RGeo
       end
 
       def boundary
-        @factory._create_feature(nil, @zgeometry.boundary, @mgeometry.boundary)
+        @factory.create_feature(nil, @zgeometry.boundary, @mgeometry.boundary)
       end
 
-      def equals?(rhs_)
-        @zgeometry.equals?(RGeo::Feature.cast(rhs_, self).z_geometry)
+      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)
+      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)
+      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)
+      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)
+      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)
+      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)
+      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)
+      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_)
+      def relate?(rhs, pattern)
+        @zgeometry.relate?(RGeo::Feature.cast(rhs, self).z_geometry, pattern)
       end
       alias relate relate? # DEPRECATED
 
-      def distance(rhs_)
-        @zgeometry.distance(RGeo::Feature.cast(rhs_, self).z_geometry)
+      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_))
+        @factory.create_feature(nil, @zgeometry.buffer(distance_), @mgeometry.buffer(distance_))
       end
 
       def convex_hull
-        @factory._create_feature(nil, @zgeometry.convex_hull, @mgeometry.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))
+      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))
+      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))
+      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))
+      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)
+      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 eql? rep_equals?
@@ -156,27 +158,29 @@ module RGeo
       alias + union
       alias * intersection
 
-      def _copy_state_from(obj_) # :nodoc:
-        @factory = obj_.factory
-        @zgeometry = obj_.z_geometry
-        @mgeometry = obj_.m_geometry
+      def marshal_dump # :nodoc:
+        [@factory, @factory.marshal_wkb_generator.generate(self)]
       end
 
-      def marshal_dump # :nodoc:
-        [@factory, @factory._marshal_wkb_generator.generate(self)]
+      def marshal_load(data)  # :nodoc:
+        copy_state_from(data[0].marshal_wkb_parser.parse(data[1]))
       end
 
-      def marshal_load(data_)  # :nodoc:
-        _copy_state_from(data_[0]._marshal_wkb_parser.parse(data_[1]))
+      def encode_with(coder)  # :nodoc:
+        coder["factory"] = @factory
+        coder["wkt"] = @factory.psych_wkt_generator.generate(self)
       end
 
-      def encode_with(coder_)  # :nodoc:
-        coder_["factory"] = @factory
-        coder_["wkt"] = @factory._psych_wkt_generator.generate(self)
+      def init_with(coder) # :nodoc:
+        copy_state_from(coder["factory"].psych_wkt_parser.parse(coder["wkt"]))
       end
 
-      def init_with(coder_) # :nodoc:
-        _copy_state_from(coder_["factory"]._psych_wkt_parser.parse(coder_["wkt"]))
+      private
+
+      def copy_state_from(obj)
+        @factory = obj.factory
+        @zgeometry = obj.z_geometry
+        @mgeometry = obj.m_geometry
       end
     end
 
@@ -230,8 +234,8 @@ module RGeo
         @zgeometry.num_points
       end
 
-      def point_n(n_)
-        @factory._create_feature(ZMPointImpl, @zgeometry.point_n(n_), @mgeometry.point_n(n_))
+      def point_n(n)
+        @factory.create_feature(ZMPointImpl, @zgeometry.point_n(n), @mgeometry.point_n(n))
       end
 
       def points
@@ -239,7 +243,7 @@ module RGeo
         zpoints_ = @zgeometry.points
         mpoints_ = @mgeometry.points
         zpoints_.size.times do |i_|
-          result_ << @factory._create_feature(ZMPointImpl, zpoints_[i_], mpoints_[i_])
+          result_ << @factory.create_feature(ZMPointImpl, zpoints_[i_], mpoints_[i_])
         end
         result_
       end
@@ -255,23 +259,23 @@ module RGeo
       end
 
       def centroid
-        @factory._create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
+        @factory.create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
       end
 
       def point_on_surface
-        @factory._create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
+        @factory.create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
       end
 
       def exterior_ring
-        @factory._create_feature(ZMLineStringImpl, @zgeometry.exterior_ring, @mgeometry.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_))
+      def interior_ring_n(n)
+        @factory.create_feature(ZMLineStringImpl, @zgeometry.interior_ring_n(n), @mgeometry.interior_ring_n(n))
       end
 
       def interior_rings
@@ -279,7 +283,7 @@ module RGeo
         zrings_ = @zgeometry.interior_rings
         mrings_ = @mgeometry.interior_rings
         zrings_.size.times do |i_|
-          result_ << @factory._create_feature(ZMLineStringImpl, zrings_[i_], mrings_[i_])
+          result_ << @factory.create_feature(ZMLineStringImpl, zrings_[i_], mrings_[i_])
         end
         result_
       end
@@ -295,15 +299,15 @@ module RGeo
       end
       alias size num_geometries
 
-      def geometry_n(n_)
-        @factory._create_feature(nil, @zgeometry.geometry_n(n_), @mgeometry.geometry_n(n_))
+      def geometry_n(n)
+        @factory.create_feature(nil, @zgeometry.geometry_n(n), @mgeometry.geometry_n(n))
       end
       alias [] geometry_n
 
       def each
         if block_given?
-          num_geometries.times do |i_|
-            yield geometry_n(i_)
+          num_geometries.times do |i|
+            yield geometry_n(i)
           end
           self
         else
@@ -311,7 +315,7 @@ module RGeo
         end
       end
 
-      include ::Enumerable
+      include Enumerable
     end
 
     module ZMMultiLineStringMethods # :nodoc:
@@ -334,11 +338,11 @@ module RGeo
       end
 
       def centroid
-        @factory._create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
+        @factory.create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
       end
 
       def point_on_surface
-        @factory._create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
+        @factory.create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
       end
 
       def coordinates

data/lib/rgeo/impl_helper.rb

@@ -1,15 +1,5 @@
-# -----------------------------------------------------------------------------
-#
-# Implementation helpers namespace for RGeo
-#
-# -----------------------------------------------------------------------------
+# frozen_string_literal: true
 
-module RGeo
-  module ImplHelper # :nodoc:
-  end
-end
-
-# Implementation files
 require "rgeo/impl_helper/utils"
 require "rgeo/impl_helper/math"
 require "rgeo/impl_helper/basic_geometry_methods"

data/lib/rgeo/impl_helper/basic_geometry_collection_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Common methods for GeometryCollection features
@@ -7,41 +9,36 @@
 module RGeo
   module ImplHelper # :nodoc:
     module BasicGeometryCollectionMethods # :nodoc:
-      def initialize(factory_, elements_)
-        _set_factory(factory_)
-        @elements = elements_.map do |elem_|
-          elem_ = Feature.cast(elem_, factory_)
-          raise Error::InvalidGeometry, "Could not cast #{elem_}" unless elem_
-          elem_
+      attr_reader :elements
+
+      def initialize(factory, elements)
+        self.factory = factory
+        @elements = elements.map do |elem|
+          elem = Feature.cast(elem, factory)
+          raise Error::InvalidGeometry, "Could not cast #{elem}" unless elem
+          elem
         end
-        _validate_geometry
+        validate_geometry
       end
 
       def num_geometries
         @elements.size
       end
 
-      def geometry_n(n_)
-        n_ < 0 ? nil : @elements[n_]
+      def geometry_n(n)
+        n < 0 ? nil : @elements[n]
       end
 
-      def [](n_)
-        @elements[n_]
+      def [](n)
+        @elements[n]
       end
 
-      def each(&block_)
-        @elements.each(&block_)
+      def each(&block)
+        @elements.each(&block)
       end
 
       def dimension
-        unless defined?(@dimension)
-          @dimension = -1
-          @elements.each do |elem_|
-            dim_ = elem_.dimension
-            @dimension = dim_ if @dimension < dim_
-          end
-        end
-        @dimension
+        @dimension ||= @elements.map(&:dimension).max || -1
       end
 
       def geometry_type
@@ -52,9 +49,9 @@ module RGeo
         @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_) }
+      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) }
         else
           false
         end
@@ -62,30 +59,28 @@ module RGeo
 
       def hash
         @hash ||= begin
-          hash_ = [factory, geometry_type].hash
-          @elements.inject(hash_) { |h_, g_| (1_664_525 * h_ + g_.hash).hash }
+          hash = [factory, geometry_type].hash
+          @elements.inject(hash) { |h, g| (1_664_525 * h + g.hash).hash }
         end
       end
 
-      def _copy_state_from(obj_) # :nodoc:
-        super
-        @elements = obj_._elements
-      end
+      private
 
-      def _elements # :nodoc:
-        @elements
+      def copy_state_from(obj)
+        super
+        @elements = obj.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)
-          raise Error::InvalidGeometry, "Could not cast #{elem_}" unless elem_
-          elem_
+    module BasicMultiLineStringMethods # :nodoc:
+      def initialize(factory, elements)
+        self.factory = factory
+        @elements = elements.map do |elem|
+          elem = Feature.cast(elem, factory, Feature::LineString, :keep_subtype)
+          raise Error::InvalidGeometry, "Could not cast #{elem}" unless elem
+          elem
         end
-        _validate_geometry
+        validate_geometry
       end
 
       def geometry_type
@@ -97,43 +92,45 @@ module RGeo
       end
 
       def 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
+        @elements.inject(0.0) { |sum, obj| sum + obj.length }
       end
 
       def boundary
-        hash_ = {}
-        @elements.each do |line_|
-          if !line_.is_empty? && !line_.is_closed?
-            _add_boundary(hash_, line_.start_point)
-            _add_boundary(hash_, line_.end_point)
+        hash = {}
+        @elements.each do |line|
+          if !line.is_empty? && !line.is_closed?
+            add_boundary(hash, line.start_point)
+            add_boundary(hash, line.end_point)
           end
         end
-        array_ = []
-        hash_.each do |_hval_, data_|
-          array_ << data_[0] if data_[1].odd?
+        array = []
+        hash.each do |_hval, data_|
+          array << data_[0] if data_[1].odd?
         end
-        factory.multi_point([array_])
+        factory.multipoint([array])
       end
 
       def coordinates
         @elements.map(&:coordinates)
       end
+
+      private
+
+      def add_boundary(hash, point)
+        hval = [point.x, point.y].hash
+        (hash[hval] ||= [point, 0])[1] += 1
+      end
     end
 
     module BasicMultiPointMethods # :nodoc:
-      def initialize(factory_, elements_)
-        _set_factory(factory_)
-        @elements = elements_.map do |elem_|
-          elem_ = Feature.cast(elem_, factory_, Feature::Point, :keep_subtype)
-          raise Error::InvalidGeometry, "Could not cast #{elem_}" unless elem_
-          elem_
+      def initialize(factory, elements)
+        self.factory = factory
+        @elements = elements.map do |elem|
+          elem = Feature.cast(elem, factory, Feature::Point, :keep_subtype)
+          raise Error::InvalidGeometry, "Could not cast #{elem}" unless elem
+          elem
         end
-        _validate_geometry
+        validate_geometry
       end
 
       def geometry_type
@@ -150,14 +147,14 @@ module RGeo
     end
 
     module BasicMultiPolygonMethods # :nodoc:
-      def initialize(factory_, elements_)
-        _set_factory(factory_)
-        @elements = elements_.map do |elem_|
-          elem_ = Feature.cast(elem_, factory_, Feature::Polygon, :keep_subtype)
-          raise Error::InvalidGeometry, "Could not cast #{elem_}" unless elem_
-          elem_
+      def initialize(factory, elements)
+        self.factory = factory
+        @elements = elements.map do |elem|
+          elem = Feature.cast(elem, factory, Feature::Polygon, :keep_subtype)
+          raise Error::InvalidGeometry, "Could not cast #{elem}" unless elem
+          elem
         end
-        _validate_geometry
+        validate_geometry
       end
 
       def geometry_type
@@ -165,16 +162,16 @@ module RGeo
       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_|
-          array_ << poly_.exterior_ring unless poly_.is_empty?
-          array_.concat(poly_.interior_rings)
+        array = []
+        @elements.each do |poly|
+          array << poly.exterior_ring unless poly.is_empty?
+          array.concat(poly.interior_rings)
         end
-        factory.multi_line_string(array_)
+        factory.multilinestring(array)
       end
 
       def coordinates