rgeo 1.1.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0760bb96d9e6654cf7cb09bd88b4a799f5ba249f573fd4c0484df2269ba50a0
-  data.tar.gz: 73928442258c96603367a340aac3cd1f93bed12471854e17cf14a712d58bb711
+  metadata.gz: b8472a195fa15704c94ed5074f539d815477b9d05e1354e4a47dcf7110235f5e
+  data.tar.gz: 81914f85026703454776fd5816c25869a35ba00f77f6509dc815205d2f35b604
 SHA512:
-  metadata.gz: 961f639e7a8985cbcdff0b166cdf2923a6a8a4c4143e55b66a2769d5897abdacb42a6abceaa2b92c870f648e867154df996e55d5ab9a50bbbe70a6c4eef5c7bd
-  data.tar.gz: ff8f393c6c5ef195c790836a4ba844867d54c7cf4e8a7266d86c4bd0f44025a58a90debad8a77521288ef1ffe8db0906575e52de9a5dc49d5507fb03aee43765
+  metadata.gz: 6a6e0a821118e84e0052585431df5af8956a9f89882ce3314eeca72ff386617859bbe52a857b7761b8f8d8bc644a60734b5197fe209b20dd0d9fc294121735af
+  data.tar.gz: 2f68c55105f188e1f8c1b9c4bc1a5ae32e20b4dd630a3ade0038169a9d62fb3409cc85bad3c08bfb60bf0c73331f7c33192fb5c94622073974021e5b6447e9ae

data/ext/geos_c_impl/extconf.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Makefile builder for GEOS wrapper
 #
 # -----------------------------------------------------------------------------
 def create_dummy_makefile
-  ::File.open("Makefile", "w") { |f_| f_.write(".PHONY: install\ninstall:\n") }
+  File.open("Makefile", "w") { |f_| f_.write(".PHONY: install\ninstall:\n") }
 end
 
-if ::RUBY_DESCRIPTION =~ /^jruby\s/
+if RUBY_DESCRIPTION =~ /^jruby\s/
   create_dummy_makefile
 else
   require "mkmf"
@@ -15,7 +17,7 @@ else
   geosconfig = with_config("geos-config") || find_executable("geos-config")
 
   if geosconfig
-    puts "Using GEOS compile configuration from %s" [geosconfig]
+    puts "Using GEOS compile configuration from #{geosconfig}"
     $INCFLAGS << " " << `#{geosconfig} --cflags`.strip
     geos_libs = `#{geosconfig} --clibs`.tr("\n", " ")
     geos_libs.split(/\s+/).each do |flag|

data/ext/geos_c_impl/factory.c

@@ -623,10 +623,10 @@ RGeo_Globals* rgeo_init_geos_factory()
   rb_define_method(geos_factory_class, "_wkb_generator", method_get_wkb_generator, 0);
   rb_define_method(geos_factory_class, "_wkt_parser", method_get_wkt_parser, 0);
   rb_define_method(geos_factory_class, "_wkb_parser", method_get_wkb_parser, 0);
-  rb_define_method(geos_factory_class, "_read_for_marshal", method_factory_read_for_marshal, 1);
-  rb_define_method(geos_factory_class, "_write_for_marshal", method_factory_write_for_marshal, 1);
-  rb_define_method(geos_factory_class, "_read_for_psych", method_factory_read_for_psych, 1);
-  rb_define_method(geos_factory_class, "_write_for_psych", method_factory_write_for_psych, 1);
+  rb_define_method(geos_factory_class, "read_for_marshal", method_factory_read_for_marshal, 1);
+  rb_define_method(geos_factory_class, "write_for_marshal", method_factory_write_for_marshal, 1);
+  rb_define_method(geos_factory_class, "read_for_psych", method_factory_read_for_psych, 1);
+  rb_define_method(geos_factory_class, "write_for_psych", method_factory_write_for_psych, 1);
   rb_define_module_function(geos_factory_class, "_create", cmethod_factory_create, 7);
   rb_define_module_function(geos_factory_class, "_geos_version", cmethod_factory_geos_version, 0);
   rb_define_module_function(geos_factory_class, "_supports_unary_union?", cmethod_factory_supports_unary_union, 0);

data/ext/geos_c_impl/geometry.c

@@ -1063,7 +1063,7 @@ void rgeo_init_geos_geometry(RGeo_Globals* globals)
 
   geos_geometry_methods = rb_define_module_under(globals->geos_module, "CAPIGeometryMethods");
 
-  rb_define_method(geos_geometry_methods, "_set_factory", method_geometry_set_factory, 1);
+  rb_define_method(geos_geometry_methods, "factory=", method_geometry_set_factory, 1);
   rb_define_method(geos_geometry_methods, "initialize_copy", method_geometry_initialize_copy, 1);
   rb_define_method(geos_geometry_methods, "_steal", method_geometry_steal, 1);
   rb_define_method(geos_geometry_methods, "initialized?", method_geometry_initialized_p, 0);

data/lib/rgeo.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # RGeo is a spatial data library for Ruby. It focuses on the storage and
 # manipulation of spatial data types such as points, lines, and polygons.
 #
@@ -73,10 +75,6 @@
 #   database, and based on the postgresql adapter. Available as the
 #   activerecord-postgis-adapter gem.
 
-module RGeo
-end
-
-# Core modules
 require "rgeo/version"
 require "rgeo/error"
 require "rgeo/feature"

data/lib/rgeo/cartesian.rb

@@ -1,21 +1,11 @@
-# -----------------------------------------------------------------------------
-#
-# Cartesian features for RGeo
-#
-# -----------------------------------------------------------------------------
+# frozen_string_literal: true
 
-module RGeo
-  # The Cartesian module is a gateway to implementations that use the
-  # Cartesian (i.e. flat) coordinate system. It provides convenient
-  # access to Cartesian factories such as the Geos implementation and
-  # the simple Cartesian implementation. It also provides a namespace
-  # for Cartesian-specific analysis tools.
+# The Cartesian module is a gateway to implementations that use the
+# Cartesian (i.e. flat) coordinate system. It provides convenient
+# access to Cartesian factories such as the Geos implementation and
+# the simple Cartesian implementation. It also provides a namespace
+# for Cartesian-specific analysis tools.
 
-  module Cartesian
-  end
-end
-
-# Implementation files.
 require "rgeo/cartesian/calculations"
 require "rgeo/cartesian/feature_methods"
 require "rgeo/cartesian/feature_classes"

data/lib/rgeo/cartesian/analysis.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Cartesian geometric analysis utilities
@@ -19,33 +21,33 @@ module RGeo
         # The return value is undefined if the object is not a ring, or
         # is not in a Cartesian coordinate system.
 
-        def ring_direction(ring_)
-          size_ = ring_.num_points - 1
-          return 0 if size_ == 0
+        def ring_direction(ring)
+          size = ring.num_points - 1
+          return 0 if size == 0
 
           # Extract unit-length segments from the ring.
-          segs_ = []
-          size_.times do |i_|
-            p0_ = ring_.point_n(i_)
-            p1_ = ring_.point_n(i_ + 1)
-            x_ = p1_.x - p0_.x
-            y_ = p1_.y - p0_.y
-            r_ = ::Math.sqrt(x_ * x_ + y_ * y_)
-            if r_ > 0.0
-              segs_ << x_ / r_ << y_ / r_
+          segs = []
+          size.times do |i|
+            p0 = ring.point_n(i)
+            p1 = ring.point_n(i + 1)
+            x = p1.x - p0.x
+            y = p1.y - p0.y
+            r = Math.sqrt(x * x + y * y)
+            if r > 0.0
+              segs << x / r << y / r
             else
-              size_ -= 1
+              size -= 1
             end
           end
-          segs_ << segs_[0] << segs_[1]
+          segs << segs[0] << segs[1]
 
           # Extract angles from the segments by subtracting the segments.
           # Note angles are represented as cos/sin pairs so we don't
           # have to calculate any trig functions.
-          angs_ = []
-          size_.times do |i_|
-            x0_, y0_, x1_, y1_ = segs_[i_ * 2, 4]
-            angs_ << x0_ * x1_ + y0_ * y1_ << x0_ * y1_ - x1_ * y0_
+          angs = []
+          size.times do |i|
+            x0, y0, x1, y1 = segs[i * 2, 4]
+            angs << x0 * x1 + y0 * y1 << x0 * y1 - x1 * y0
           end
 
           # Now add the angles and count revolutions.
@@ -54,12 +56,12 @@ module RGeo
           direction = nil
           sin = 0.0
           cos = 1.0
-          angs_.each_slice(2) do |(x, y)|
+          angs.each_slice(2) do |(x, y)|
             ready = y > 0.0 && (sin > 0.0 || sin == 0.0 && direction == -1) || y < 0.0 && (sin < 0.0 || sin == 0.0 && direction == 1)
             if y != 0.0
               s = sin * x + cos * y
               c = cos * x - sin * y
-              r = ::Math.sqrt(s * s + c * c)
+              r = Math.sqrt(s * s + c * c)
               sin = s / r
               cos = c / r
             end

data/lib/rgeo/cartesian/bounding_box.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Cartesian bounding box
@@ -24,9 +26,9 @@ module RGeo
       # You may also provide the same options available to
       # BoundingBox.new.
 
-      def self.create_from_points(point1_, point2_, opts_ = {})
-        factory_ = point1_.factory
-        new(factory_, opts_)._add_geometry(point1_).add(point2_)
+      def self.create_from_points(point1, point2, opts = {})
+        factory = point1.factory
+        new(factory, opts).add_geometry(point1).add(point2)
       end
 
       # Create a bounding box given a geometry to surround.
@@ -34,9 +36,9 @@ module RGeo
       # You may also provide the same options available to
       # BoundingBox.new.
 
-      def self.create_from_geometry(geom_, opts_ = {})
-        factory_ = geom_.factory
-        new(factory_, opts_)._add_geometry(geom_)
+      def self.create_from_geometry(geom, opts = {})
+        factory = geom.factory
+        new(factory, opts).add_geometry(geom)
       end
 
       # Create a new empty bounding box with the given factory.
@@ -56,23 +58,23 @@ module RGeo
       #   If true, ignore m coordinates even if the factory supports them.
       #   Default is false.
 
-      def initialize(factory_, opts_ = {})
-        @factory = factory_
-        if (values_ = opts_[:raw])
-          @has_z, @has_m, @min_x, @max_x, @min_y, @max_y, @min_z, @max_z, @min_m, @max_m = values_
+      def initialize(factory, opts = {})
+        @factory = factory
+        if (values = opts[:raw])
+          @has_z, @has_m, @min_x, @max_x, @min_y, @max_y, @min_z, @max_z, @min_m, @max_m = values
         else
-          @has_z = !opts_[:ignore_z] && factory_.property(:has_z_coordinate) ? true : false
-          @has_m = !opts_[:ignore_m] && factory_.property(:has_m_coordinate) ? true : false
+          @has_z = !opts[:ignore_z] && factory.property(:has_z_coordinate) ? true : false
+          @has_m = !opts[:ignore_m] && factory.property(:has_m_coordinate) ? true : false
           @min_x = @max_x = @min_y = @max_y = @min_z = @max_z = @min_m = @max_m = nil
         end
       end
 
-      def eql?(rhs_) # :nodoc:
-        rhs_.is_a?(BoundingBox) && @factory == rhs_.factory &&
-          @min_x == rhs_.min_x && @max_x == rhs_.max_x &&
-          @min_y == rhs_.min_y && @max_y == rhs_.max_y &&
-          @min_z == rhs_.min_z && @max_z == rhs_.max_z &&
-          @min_m == rhs_.min_m && @max_m == rhs_.max_m
+      def eql?(rhs) # :nodoc:
+        rhs.is_a?(BoundingBox) && @factory == rhs.factory &&
+          @min_x == rhs.min_x && @max_x == rhs.max_x &&
+          @min_y == rhs.min_y && @max_y == rhs.max_y &&
+          @min_z == rhs.min_z && @max_z == rhs.max_z &&
+          @min_m == rhs.min_m && @max_m == rhs.max_m
       end
       alias == eql?
 
@@ -196,10 +198,10 @@ module RGeo
 
       def min_point
         if @min_x
-          extras_ = []
-          extras_ << @min_z if @has_z
-          extras_ << @min_m if @has_m
-          @factory.point(@min_x, @min_y, *extras_)
+          extras = []
+          extras << @min_z if @has_z
+          extras << @min_m if @has_m
+          @factory.point(@min_x, @min_y, *extras)
         end
       end
 
@@ -208,10 +210,10 @@ module RGeo
 
       def max_point
         if @min_x
-          extras_ = []
-          extras_ << @max_z if @has_z
-          extras_ << @max_m if @has_m
-          @factory.point(@max_x, @max_y, *extras_)
+          extras = []
+          extras << @max_z if @has_z
+          extras << @max_m if @has_m
+          @factory.point(@max_x, @max_y, *extras)
         end
       end
 
@@ -219,16 +221,16 @@ module RGeo
       # object, which may be a geometry or another bounding box.
       # Returns self.
 
-      def add(geometry_)
-        case geometry_
+      def add(geometry)
+        case geometry
         when BoundingBox
-          add(geometry_.min_point)
-          add(geometry_.max_point)
+          add(geometry.min_point)
+          add(geometry.max_point)
         when Feature::Geometry
-          if geometry_.factory == @factory
-            _add_geometry(geometry_)
+          if geometry.factory == @factory
+            add_geometry(geometry)
           else
-            _add_geometry(Feature.cast(geometry_, @factory))
+            add_geometry(Feature.cast(geometry, @factory))
           end
         end
         self
@@ -241,23 +243,23 @@ module RGeo
 
       def to_geometry
         if @min_x
-          extras_ = []
-          extras_ << @min_z if @has_z
-          extras_ << @min_m if @has_m
-          point_min_ = @factory.point(@min_x, @min_y, *extras_)
+          extras = []
+          extras << @min_z if @has_z
+          extras << @min_m if @has_m
+          point_min = @factory.point(@min_x, @min_y, *extras)
           if infinitesimal?
-            point_min_
+            point_min
           else
-            extras_ = []
-            extras_ << @max_z if @has_z
-            extras_ << @max_m if @has_m
-            point_max_ = @factory.point(@max_x, @max_y, *extras_)
+            extras = []
+            extras << @max_z if @has_z
+            extras << @max_m if @has_m
+            point_max = @factory.point(@max_x, @max_y, *extras)
             if degenerate?
-              @factory.line(point_min_, point_max_)
+              @factory.line(point_min, point_max)
             else
-              @factory.polygon(@factory.linear_ring([point_min_,
-                                                     @factory.point(@max_x, @min_y, *extras_), point_max_,
-                                                     @factory.point(@min_x, @max_y, *extras_), point_min_]))
+              @factory.polygon(@factory.linear_ring([point_min,
+                                                     @factory.point(@max_x, @min_y, *extras), point_max,
+                                                     @factory.point(@min_x, @max_y, *extras), point_min]))
             end
           end
         else
@@ -277,18 +279,18 @@ module RGeo
       #   Ignore the M coordinate when testing, even if both objects
       #   have M. Default is false.
 
-      def contains?(rhs_, opts_ = {})
-        if Feature::Geometry === rhs_
-          contains?(BoundingBox.new(@factory).add(rhs_))
-        elsif rhs_.empty?
+      def contains?(rhs, opts = {})
+        if Feature::Geometry === rhs
+          contains?(BoundingBox.new(@factory).add(rhs))
+        elsif rhs.empty?
           true
         elsif empty?
           false
-        elsif @min_x > rhs_.min_x || @max_x < rhs_.max_x || @min_y > rhs_.min_y || @max_y < rhs_.max_y
+        elsif @min_x > rhs.min_x || @max_x < rhs.max_x || @min_y > rhs.min_y || @max_y < rhs.max_y
           false
-        elsif @has_m && rhs_.has_m && !opts_[:ignore_m] && (@min_m > rhs_.min_m || @max_m < rhs_.max_m)
+        elsif @has_m && rhs.has_m && !opts[:ignore_m] && (@min_m > rhs.min_m || @max_m < rhs.max_m)
           false
-        elsif @has_z && rhs_.has_z && !opts_[:ignore_z] && (@min_z > rhs_.min_z || @max_z < rhs_.max_z)
+        elsif @has_z && rhs.has_z && !opts[:ignore_z] && (@min_z > rhs.min_z || @max_z < rhs.max_z)
           false
         else
           true
@@ -309,7 +311,7 @@ module RGeo
       #   greater than this factor, the bounding box is divided only in
       #   half instead of fourths.
 
-      def subdivide(opts_ = {})
+      def subdivide(opts = {})
         return [] if empty?
         if infinitesimal?
           return [
@@ -317,17 +319,17 @@ module RGeo
                                             @min_x, @max_x, @min_y, @max_y, @min_z, @max_z, @min_m, @max_m])
           ]
         end
-        factor_ = opts_[:bisect_factor]
-        factor_ ||= 1 if degenerate?
-        if factor_
-          if x_span > y_span * factor_
+        factor = opts[:bisect_factor]
+        factor ||= 1 if degenerate?
+        if factor
+          if x_span > y_span * factor
             return [
               BoundingBox.new(@factory, raw: [@has_z, @has_m,
                                               @min_x, center_x, @min_y, @max_y, @min_z, @max_z, @min_m, @max_m]),
               BoundingBox.new(@factory, raw: [@has_z, @has_m,
                                               center_x, @max_x, @min_y, @max_y, @min_z, @max_z, @min_m, @max_m])
             ]
-          elsif y_span > x_span * factor_
+          elsif y_span > x_span * factor
             return [
               BoundingBox.new(@factory, raw: [@has_z, @has_m,
                                               @min_x, @max_x, @min_y, center_y, @min_z, @max_z, @min_m, @max_m]),
@@ -348,49 +350,51 @@ module RGeo
         ]
       end
 
-      def _add_geometry(geometry_) # :nodoc:
-        case geometry_
+      def add_geometry(geometry)
+        case geometry
         when Feature::Point
-          _add_point(geometry_)
+          add_point(geometry)
         when Feature::LineString
-          geometry_.points.each { |p_| _add_point(p_) }
+          geometry.points.each { |p| add_point(p) }
         when Feature::Polygon
-          geometry_.exterior_ring.points.each { |p_| _add_point(p_) }
+          geometry.exterior_ring.points.each { |p| add_point(p) }
         when Feature::MultiPoint
-          geometry_.each { |p_| _add_point(p_) }
+          geometry.each { |p| add_point(p) }
         when Feature::MultiLineString
-          geometry_.each { |line_| line_.points.each { |p_| _add_point(p_) } }
+          geometry.each { |line| line.points.each { |p| add_point(p) } }
         when Feature::MultiPolygon
-          geometry_.each { |poly_| poly_.exterior_ring.points.each { |p_| _add_point(p_) } }
+          geometry.each { |poly| poly.exterior_ring.points.each { |p| add_point(p) } }
         when Feature::GeometryCollection
-          geometry_.each { |g_| _add_geometry(g_) }
+          geometry.each { |g| add_geometry(g) }
         end
         self
       end
 
-      def _add_point(point_) # :nodoc:
+      private
+
+      def add_point(point)
         if @min_x
-          x_ = point_.x
-          @min_x = x_ if x_ < @min_x
-          @max_x = x_ if x_ > @max_x
-          y_ = point_.y
+          x = point.x
+          @min_x = x if x < @min_x
+          @max_x = x if x > @max_x
+          y_ = point.y
           @min_y = y_ if y_ < @min_y
           @max_y = y_ if y_ > @max_y
           if @has_z
-            z_ = point_.z
+            z_ = point.z
             @min_z = z_ if z_ < @min_z
             @max_z = z_ if z_ > @max_z
           end
           if @has_m
-            m_ = point_.m
+            m_ = point.m
             @min_m = m_ if m_ < @min_m
             @max_m = m_ if m_ > @max_m
           end
         else
-          @min_x = @max_x = point_.x
-          @min_y = @max_y = point_.y
-          @min_z = @max_z = point_.z if @has_z
-          @min_m = @max_m = point_.m if @has_m
+          @min_x = @max_x = point.x
+          @min_y = @max_y = point.y
+          @min_z = @max_z = point.z if @has_z
+          @min_m = @max_m = point.m if @has_m
         end
       end
     end