rgeo 3.0.0.pre.rc.3 → 3.0.1

data/lib/rgeo/geographic/projected_window.rb

@@ -13,7 +13,6 @@ module RGeo
     # map visualization, an envelope in a projected coordinate system, or
     # a spatial constraint. It must be attached to a Geographic::Factory
     # that has a projection.
-
     class ProjectedWindow
       # Create a new ProjectedWindow given the Geographic::Factory, and the
       # x and y extents of the rectangle.
@@ -64,10 +63,10 @@ module RGeo
         to_s
       end
 
-      def eql?(obj_) # :nodoc:
-        return false unless obj_.is_a?(ProjectedWindow)
-        @factory == obj_.factory && @x_min == obj_.x_min && @x_max == obj_.x_max &&
-          @y_min = obj_.y_min && @y_max = obj_.y_max
+      def eql?(other) # :nodoc:
+        return false unless other.is_a?(ProjectedWindow)
+        @factory == other.factory && @x_min == other.x_min && @x_max == other.x_max &&
+          @y_min = other.y_min && @y_max = other.y_max
       end
       alias == eql?
 
@@ -79,23 +78,18 @@ module RGeo
       # Note that this factory is the overall geography factory, not the
       # projected factory (which can be obtained by calling
       # Geographic::Factory#projection_factory on this factory).
-
       attr_reader :factory
 
       # Returns the lower limit in the x (easting) direction.
-
       attr_reader :x_min
 
       # Returns the upper limit in the x (easting) direction.
-
       attr_reader :x_max
 
       # Returns the lower limit in the y (northing) direction.
-
       attr_reader :y_min
 
       # Returns the upper limit in the y (northing) direction.
-
       attr_reader :y_max
 
       # Returns true if the projection wraps along the x axis, and this
@@ -146,35 +140,45 @@ module RGeo
       # (lat/lng) space, as a Feature::Point object.
 
       def sw_point
-        @sw ||= @factory.unproject(@factory.projection_factory.point(@x_min, @y_min))
+        return @sw_point if defined?(@sw_point)
+
+        @sw_point = @factory.unproject(@factory.projection_factory.point(@x_min, @y_min))
       end
 
       # Returns the southeast corner of the rectangle in _unprojected_
       # (lat/lng) space, as a Feature::Point object.
 
       def se_point
-        @se ||= @factory.unproject(@factory.projection_factory.point(@x_max, @y_min))
+        return @se_point if defined?(@se_point)
+
+        @se_point = @factory.unproject(@factory.projection_factory.point(@x_max, @y_min))
       end
 
       # Returns the northwest corner of the rectangle in _unprojected_
       # (lat/lng) space, as a Feature::Point object.
 
       def nw_point
-        @nw ||= @factory.unproject(@factory.projection_factory.point(@x_min, @y_max))
+        return @nw_point if defined?(@nw_point)
+
+        @nw_point = @factory.unproject(@factory.projection_factory.point(@x_min, @y_max))
       end
 
       # Returns the northeast corner of the rectangle in _unprojected_
       # (lat/lng) space, as a Feature::Point object.
 
       def ne_point
-        @ne ||= @factory.unproject(@factory.projection_factory.point(@x_max, @y_max))
+        return @ne_point if defined?(@ne_point)
+
+        @ne_point = @factory.unproject(@factory.projection_factory.point(@x_max, @y_max))
       end
 
       # Returns the center of the rectangle in _unprojected_
       # (lat/lng) space, as a Feature::Point object.
 
       def center_point
-        @center ||= @factory.unproject(@factory.projection_factory.point(*center_xy))
+        return @center_point if defined?(@center_point)
+
+        @center_point = @factory.unproject(@factory.projection_factory.point(*center_xy))
       end
 
       # Returns a random point inside the rectangle in _unprojected_
@@ -233,7 +237,7 @@ module RGeo
 
       def scaled_by(x_factor_, y_factor_ = nil)
         y_factor_ ||= x_factor_
-        if x_factor_ != 1.0 || y_factor_ != 1.0
+        if x_factor_ != 1 || y_factor_ != 1
           x_, y_ = *center_xy
           xr_ = x_span * 0.5 * x_factor_
           yr_ = y_span * 0.5 * y_factor_
@@ -287,9 +291,14 @@ module RGeo
 
       def with_margin(x_margin_, y_margin_ = nil)
         y_margin_ ||= x_margin_
-        if x_margin_ != 0.0 || y_margin_ != 0.0
-          ProjectedWindow.new(@factory, @x_min - x_margin_, @y_min - y_margin_,
-            @x_max + x_margin_, @y_max + y_margin_)
+        if x_margin_ != 0 || y_margin_ != 0
+          ProjectedWindow.new(
+            @factory,
+            @x_min - x_margin_,
+            @y_min - y_margin_,
+            @x_max + x_margin_,
+            @y_max + y_margin_
+          )
         else
           self
         end
@@ -318,8 +327,13 @@ module RGeo
           y_margin_ ||= x_margin_
           factory_ = point_.factory
           projection_ = factory_.project(point_)
-          ProjectedWindow.new(factory_, projection_.x - x_margin_, projection_.y - y_margin_,
-            projection_.x + x_margin_, projection_.y + y_margin_)
+          ProjectedWindow.new(
+            factory_,
+            projection_.x - x_margin_,
+            projection_.y - y_margin_,
+            projection_.x + x_margin_,
+            projection_.y + y_margin_
+          )
         end
 
         # Creates a new window that contains all of the given points.

data/lib/rgeo/geographic/simple_mercator_projector.rb

@@ -14,7 +14,7 @@ module RGeo
       def initialize(geography_factory, opts = {})
         @geography_factory = geography_factory
         @projection_factory = Cartesian.preferred_factory(srid: 3857,
-                                                          coord_sys: SimpleMercatorProjector._coordsys_3857,
+                                                          coord_sys: SimpleMercatorProjector._coordsys3857,
                                                           buffer_resolution: opts[:buffer_resolution],
                                                           has_z_coordinate: opts[:has_z_coordinate],
                                                           has_m_coordinate: opts[:has_m_coordinate])
@@ -32,8 +32,10 @@ module RGeo
         when Feature::Point
           rpd_ = ImplHelper::Math::RADIANS_PER_DEGREE
           radius = EQUATORIAL_RADIUS
-          @projection_factory.point(geometry.x * rpd_ * radius,
-            Math.log(Math.tan(Math::PI / 4.0 + geometry.y * rpd_ / 2.0)) * radius)
+          @projection_factory.point(
+            geometry.x * rpd_ * radius,
+            Math.log(Math.tan(Math::PI / 4.0 + geometry.y * rpd_ / 2.0)) * radius
+          )
         when Feature::Line
           @projection_factory.line(project(geometry.start_point), project(geometry.end_point))
         when Feature::LinearRing
@@ -59,8 +61,10 @@ module RGeo
         when Feature::Point
           dpr = ImplHelper::Math::DEGREES_PER_RADIAN
           radius = EQUATORIAL_RADIUS
-          @geography_factory.point(geometry.x / radius * dpr,
-            (2.0 * Math.atan(Math.exp(geometry.y / radius)) - Math::PI / 2.0) * dpr)
+          @geography_factory.point(
+            geometry.x / radius * dpr,
+            (2.0 * Math.atan(Math.exp(geometry.y / radius)) - Math::PI / 2.0) * dpr
+          )
         when Feature::Line
           @geography_factory.line(unproject(geometry.start_point), unproject(geometry.end_point))
         when Feature::LinearRing
@@ -68,8 +72,10 @@ module RGeo
         when Feature::LineString
           @geography_factory.line_string(geometry.points.map { |p| unproject(p) })
         when Feature::Polygon
-          @geography_factory.polygon(unproject(geometry.exterior_ring),
-            geometry.interior_rings.map { |p| unproject(p) })
+          @geography_factory.polygon(
+            unproject(geometry.exterior_ring),
+            geometry.interior_rings.map { |p| unproject(p) }
+          )
         when Feature::MultiPoint
           @geography_factory.multi_point(geometry.map { |p| unproject(p) })
         when Feature::MultiLineString
@@ -86,16 +92,22 @@ module RGeo
       end
 
       def limits_window
-        @limits_window ||= ProjectedWindow.new(@geography_factory,
-          -20_037_508.342789, -20_037_508.342789, 20_037_508.342789, 20_037_508.342789,
-          is_limits: true)
+        return @limits_window if defined?(@limits_window)
+
+        @limits_window = ProjectedWindow.new(
+          @geography_factory,
+          -20_037_508.342789,
+          -20_037_508.342789,
+          20_037_508.342789,
+          20_037_508.342789,
+          is_limits: true
+        )
       end
 
-      def self._coordsys_3857 # :nodoc:
-        unless defined?(@coordsys_3857)
-          @coordsys_3857 = CoordSys::CONFIG.default_coord_sys_class.create(3857)
-        end
-        @coordsys_3857
+      def self._coordsys3857 # :nodoc:
+        return @coordsys3857 if defined?(@coordsys3857)
+
+        @coordsys3857 = CoordSys::CONFIG.default_coord_sys_class.create(3857)
       end
     end
   end

data/lib/rgeo/geographic/spherical_feature_methods.rb

@@ -49,9 +49,10 @@ module RGeo
         return false unless rhs.is_a?(self.class) && rhs.factory == factory
         case rhs
         when Feature::Point
-          if @y == 90
+          case @y
+          when 90
             rhs.y == 90
-          elsif @y == -90
+          when -90
             rhs.y == -90
           else
             rhs.x == @x && rhs.y == @y
@@ -193,7 +194,11 @@ module RGeo
             next unless arc.intersects_arc?(rhs_arc)
 
             # check that endpoints aren't the intersection point
-            is_endpoint = arc.contains_point?(rhs_arc.s) || arc.contains_point?(rhs_arc.e) || rhs_arc.contains_point?(arc.s) || rhs_arc.contains_point?(arc.e)
+            is_endpoint = arc.contains_point?(rhs_arc.s) ||
+              arc.contains_point?(rhs_arc.e) ||
+              rhs_arc.contains_point?(arc.s) ||
+              rhs_arc.contains_point?(arc.e)
+
             return true unless is_endpoint
           end
         end

data/lib/rgeo/geographic/spherical_math.rb

@@ -23,6 +23,8 @@ module RGeo
       # of rotation.
 
       class PointXYZ # :nodoc:
+        attr_reader :x, :y, :z
+
         def initialize(x, y, z)
           r = Math.sqrt(x * x + y * y + z * z)
           @x = (x / r).to_f
@@ -35,12 +37,8 @@ module RGeo
           "(#{@x}, #{@y}, #{@z})"
         end
 
-        attr_reader :x
-        attr_reader :y
-        attr_reader :z
-
-        def eql?(rhs)
-          rhs.is_a?(PointXYZ) && @x == rhs.x && @y == rhs.y && @z == rhs.z
+        def eql?(other)
+          other.is_a?(PointXYZ) && @x == other.x && @y == other.y && @z == other.z
         end
         alias == eql?
 
@@ -58,17 +56,17 @@ module RGeo
           [lon_rad / rpd, lat_rad / rpd]
         end
 
-        def *(rhs)
-          val = @x * rhs.x + @y * rhs.y + @z * rhs.z
+        def *(other)
+          val = @x * other.x + @y * other.y + @z * other.z
           val = 1.0 if val > 1.0
           val = -1.0 if val < -1.0
           val
         end
 
-        def %(rhs)
-          rx = rhs.x
-          ry = rhs.y
-          rz = rhs.z
+        def %(other)
+          rx = other.x
+          ry = other.y
+          rz = other.z
           begin
             PointXYZ.new(@y * rz - @z * ry, @z * rx - @x * rz, @x * ry - @y * rx)
           rescue StandardError
@@ -113,8 +111,8 @@ module RGeo
           new(x, y, z)
         end
 
-        def self.weighted_combination(p1, w1, p2, w2)
-          new(p1.x * w1 + p2.x * w2, p1.y * w1 + p2.y * w2, p1.z * w1 + p2.z * w2)
+        def self.weighted_combination(pt1, wt1, pt2, wt2)
+          new(pt1.x * wt1 + pt2.x * wt2, pt1.y * wt1 + pt2.y * wt2, pt1.z * wt1 + pt2.z * wt2)
         end
 
         P1 = new(1, 0, 0)
@@ -124,21 +122,20 @@ module RGeo
       # Represents a finite arc on the sphere.
 
       class ArcXYZ # :nodoc:
+        attr_reader :s, :e
+
         def initialize(start, stop)
           @s = start
           @e = stop
           @axis = false
         end
 
-        attr_reader :s
-        attr_reader :e
-
         def to_s
           "#{@s} - #{@e}"
         end
 
-        def eql?(rhs)
-          rhs.is_a?(ArcXYZ) && @s == rhs.s && @e == rhs.e
+        def eql?(other)
+          other.is_a?(ArcXYZ) && @s == other.s && @e == other.e
         end
         alias == eql?
 
@@ -156,7 +153,7 @@ module RGeo
           my_axis = axis
           s_axis = ArcXYZ.new(@s, obj).axis
           e_axis = ArcXYZ.new(obj, @e).axis
-          !s_axis || !e_axis || obj * my_axis == 0.0 && s_axis * my_axis > 0 && e_axis * my_axis > 0
+          !s_axis || !e_axis || obj * my_axis == 0 && s_axis * my_axis > 0 && e_axis * my_axis > 0
         end
 
         def intersects_arc?(obj)

data/lib/rgeo/geos/capi_factory.rb

@@ -9,7 +9,6 @@
 module RGeo
   module Geos
     # This the GEOS CAPI implementation of RGeo::Feature::Factory.
-
     class CAPIFactory
       include Feature::Factory::Instance
       include ImplHelper::Utils
@@ -28,9 +27,11 @@ module RGeo
           flags = 0
           flags |= 2 if opts[:has_z_coordinate]
           flags |= 4 if opts[:has_m_coordinate]
+
           if flags & 6 == 6
             raise Error::UnsupportedOperation, "GEOS cannot support both Z and M coordinates at the same time."
           end
+
           flags |= 8 unless opts[:auto_prepare] == :disabled
 
           # Buffer resolution
@@ -39,19 +40,17 @@ module RGeo
 
           # Interpret the generator options
           wkt_generator = opts[:wkt_generator]
-          case wkt_generator
-          when Hash
-            wkt_generator = WKRep::WKTGenerator.new(wkt_generator)
-          else
-            wkt_generator = nil
-          end
+          wkt_generator =
+            case wkt_generator
+            when Hash
+              WKRep::WKTGenerator.new(wkt_generator)
+            end
           wkb_generator = opts[:wkb_generator]
-          case wkb_generator
-          when Hash
-            wkb_generator = WKRep::WKBGenerator.new(wkb_generator)
-          else
-            wkb_generator = nil
-          end
+          wkb_generator =
+            case wkb_generator
+            when Hash
+              WKRep::WKBGenerator.new(wkb_generator)
+            end
 
           # Coordinate system (srid and coord_sys)
           coord_sys_info = ImplHelper::Utils.setup_coord_sys(opts[:srid], opts[:coord_sys], opts[:coord_sys_class])
@@ -59,24 +58,28 @@ module RGeo
           coord_sys = coord_sys_info[:coord_sys]
 
           # Create the factory and set instance variables
-          result = _create(flags, srid.to_i, buffer_resolution,
-            wkt_generator, wkb_generator, coord_sys)
+          result = _create(
+            flags,
+            srid.to_i,
+            buffer_resolution,
+            wkt_generator,
+            wkb_generator,
+            coord_sys
+          )
 
           # Interpret parser options
           wkt_parser = opts[:wkt_parser]
-          case wkt_parser
-          when Hash
-            wkt_parser = WKRep::WKTParser.new(result, wkt_parser)
-          else
-            wkt_parser = nil
-          end
+          wkt_parser =
+            case wkt_parser
+            when Hash
+              WKRep::WKTParser.new(result, wkt_parser)
+            end
           wkb_parser = opts[:wkb_parser]
-          case wkb_parser
-          when Hash
-            wkb_parser = WKRep::WKBParser.new(result, wkb_parser)
-          else
-            wkb_parser = nil
-          end
+          wkb_parser =
+            case wkb_parser
+            when Hash
+              WKRep::WKBParser.new(result, wkb_parser)
+            end
           result._set_wkrep_parsers(wkt_parser, wkb_parser)
 
           # Return the result
@@ -93,10 +96,10 @@ module RGeo
 
       # Factory equivalence test.
 
-      def eql?(rhs_)
-        rhs_.is_a?(CAPIFactory) && rhs_.srid == _srid &&
-          rhs_._buffer_resolution == _buffer_resolution && rhs_._flags == _flags &&
-          rhs_.coord_sys == coord_sys
+      def eql?(other)
+        other.is_a?(CAPIFactory) && other.srid == _srid &&
+          other._buffer_resolution == _buffer_resolution && other._flags == _flags &&
+          other.coord_sys == coord_sys
       end
       alias == eql?
 
@@ -127,11 +130,9 @@ module RGeo
       end
 
       def marshal_load(data_) # :nodoc:
-        if (coord_sys_data_ = data_["cs"])
-          coord_sys_ = CoordSys::CONFIG.default_coord_sys_class.create_from_wkt(coord_sys_data_)
-        else
-          coord_sys_ = nil
-        end
+        cs_class = CoordSys::CONFIG.default_coord_sys_class
+        coord_sys_ = data_["cs"]&.then { |cs| cs_class.create_from_wkt(cs) }
+
         initialize_copy(
           CAPIFactory.create(
             has_z_coordinate: data_["hasz"],
@@ -160,17 +161,16 @@ module RGeo
         coder_["wkt_parser"] = _wkt_parser ? _wkt_parser.properties : {}
         coder_["wkb_parser"] = _wkb_parser ? _wkb_parser.properties : {}
         coder_["auto_prepare"] = auto_prepare
-        if (coord_sys_ = _coord_sys)
-          coder_["coord_sys"] = coord_sys_.to_wkt
-        end
+
+        return unless (coord_sys_ = _coord_sys)
+
+        coder_["coord_sys"] = coord_sys_.to_wkt
       end
 
       def init_with(coder_) # :nodoc:
-        if (coord_sys_data_ = coder_["cs"])
-          coord_sys_ = CoordSys::CONFIG.default_coord_sys_class.create_from_wkt(coord_sys_data_.to_s)
-        else
-          coord_sys_ = nil
-        end
+        cs_class = CoordSys::CONFIG.default_coord_sys_class
+        coord_sys_ = coder_["cs"]&.then { |cs| cs_class.create_from_wkt(cs) }
+
         initialize_copy(
           CAPIFactory.create(
             has_z_coordinate: coder_["has_z_coordinate"],
@@ -239,11 +239,9 @@ module RGeo
       # See RGeo::Feature::Factory#point
 
       def point(x, y, *extra)
-        if extra.length > (supports_z_or_m? ? 1 : 0)
-          raise(RGeo::Error::InvalidGeometry, "Parse error")
-        else
-          CAPIPointImpl.create(self, x, y, extra[0].to_f)
-        end
+        raise(RGeo::Error::InvalidGeometry, "Parse error") if extra.length > (supports_z_or_m? ? 1 : 0)
+
+        CAPIPointImpl.create(self, x, y, extra[0].to_f)
       end
 
       # See RGeo::Feature::Factory#line_string
@@ -341,7 +339,9 @@ module RGeo
           # compatible factory
           if supports_z? && !supports_m? && self == original.factory.z_factory
             return Feature.cast(original.z_geometry, ntype, flags)
-          elsif supports_m? && !supports_z? && self == original.factory.m_factory
+          end
+
+          if supports_m? && !supports_z? && self == original.factory.m_factory
             return Feature.cast(original.m_geometry, ntype, flags)
           end
         end