rgeo 3.0.0.pre.rc.3 → 3.0.0

data/lib/rgeo/cartesian/factory.rb

@@ -10,11 +10,18 @@ module RGeo
   module Cartesian
     # This class implements the factory for the simple cartesian
     # implementation.
-
     class Factory
       include Feature::Factory::Instance
       include ImplHelper::Utils
 
+      attr_reader :coordinate_dimension, :spatial_dimension
+
+      # Returns the SRID.
+      attr_reader :srid
+
+      # See RGeo::Feature::Factory#coord_sys
+      attr_reader :coord_sys
+
       # Create a new simple cartesian factory.
       #
       # See RGeo::Cartesian.simple_factory for a list of supported options.
@@ -35,43 +42,46 @@ module RGeo
         @buffer_resolution = 1 if @buffer_resolution < 1
 
         wkt_generator = opts[:wkt_generator]
-        case wkt_generator
-        when Hash
-          @wkt_generator = WKRep::WKTGenerator.new(wkt_generator)
-        else
-          @wkt_generator = WKRep::WKTGenerator.new(convert_case: :upper)
-        end
+        @wkt_generator =
+          case wkt_generator
+          when Hash
+            WKRep::WKTGenerator.new(wkt_generator)
+          else
+            WKRep::WKTGenerator.new(convert_case: :upper)
+          end
         wkb_generator = opts[:wkb_generator]
-        case wkb_generator
-        when Hash
-          @wkb_generator = WKRep::WKBGenerator.new(wkb_generator)
-        else
-          @wkb_generator = WKRep::WKBGenerator.new
-        end
+        @wkb_generator =
+          case wkb_generator
+          when Hash
+            WKRep::WKBGenerator.new(wkb_generator)
+          else
+            WKRep::WKBGenerator.new
+          end
         wkt_parser = opts[:wkt_parser]
-        case wkt_parser
-        when Hash
-          @wkt_parser = WKRep::WKTParser.new(self, wkt_parser)
-        else
-          @wkt_parser = WKRep::WKTParser.new(self)
-        end
+        @wkt_parser =
+          case wkt_parser
+          when Hash
+            WKRep::WKTParser.new(self, wkt_parser)
+          else
+            WKRep::WKTParser.new(self)
+          end
         wkb_parser = opts[:wkb_parser]
-        case wkb_parser
-        when Hash
-          @wkb_parser = WKRep::WKBParser.new(self, wkb_parser)
-        else
-          @wkb_parser = WKRep::WKBParser.new(self)
-        end
+        @wkb_parser =
+          case wkb_parser
+          when Hash
+            WKRep::WKBParser.new(self, wkb_parser)
+          else
+            WKRep::WKBParser.new(self)
+          end
       end
-      attr_reader :coordinate_dimension, :spatial_dimension
 
       # Equivalence test.
 
-      def eql?(rhs)
-        rhs.is_a?(self.class) && @srid == rhs.srid &&
-          @has_z == rhs.property(:has_z_coordinate) &&
-          @has_m == rhs.property(:has_m_coordinate) &&
-          @coord_sys == rhs.instance_variable_get(:@coord_sys)
+      def eql?(other)
+        other.is_a?(self.class) && @srid == other.srid &&
+          @has_z == other.property(:has_z_coordinate) &&
+          @has_m == other.property(:has_m_coordinate) &&
+          @coord_sys == other.instance_variable_get(:@coord_sys)
       end
       alias == eql?
 
@@ -99,11 +109,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(
           has_z_coordinate: data["hasz"],
           has_m_coordinate: data["hasm"],
@@ -132,11 +140,9 @@ module RGeo
       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(
           has_z_coordinate: coder["has_z_coordinate"],
           has_m_coordinate: coder["has_m_coordinate"],
@@ -150,10 +156,6 @@ module RGeo
         )
       end
 
-      # Returns the SRID.
-
-      attr_reader :srid
-
       # See RGeo::Feature::Factory#property
 
       def property(name)
@@ -235,10 +237,6 @@ module RGeo
         MultiPolygonImpl.new(self, elems)
       end
 
-      # See RGeo::Feature::Factory#coord_sys
-
-      attr_reader :coord_sys
-
       def generate_wkt(obj)
         @wkt_generator.generate(obj)
       end

data/lib/rgeo/cartesian/planar_graph.rb

@@ -166,17 +166,15 @@ module RGeo
           # list of intersections for that edge.
           s1_intersects = int.point != int.s1.s && int.point != int.s1.e
           if s1_intersects
-            unless intersection_map[int.s1]
-              intersection_map[int.s1] = []
-            end
+            intersection_map[int.s1] ||= []
             intersection_map[int.s1] << int.point
           end
 
           s2_intersects = int.point != int.s2.s && int.point != int.s2.e
+
           next unless s2_intersects
-          unless intersection_map[int.s2]
-            intersection_map[int.s2] = []
-          end
+
+          intersection_map[int.s2] ||= []
           intersection_map[int.s2] << int.point
         end
         intersection_map
@@ -194,11 +192,9 @@ module RGeo
         insert_half_edge(e2)
       end
 
-      def insert_half_edge(he)
-        unless incident_edges[he.origin.coordinates]
-          @incident_edges[he.origin.coordinates] = []
-        end
-        @incident_edges[he.origin.coordinates] << he
+      def insert_half_edge(half_edge)
+        @incident_edges[half_edge.origin.coordinates] ||= []
+        @incident_edges[half_edge.origin.coordinates] << half_edge
       end
 
       # Links all half-edges where possible.
@@ -299,9 +295,7 @@ module RGeo
       def add_line_string(geom)
         add_edges(geom.segments)
 
-        hedge = unless geom.empty?
-                  @incident_edges[geom.start_point.coordinates].first
-                end
+        hedge = @incident_edges[geom.start_point.coordinates].first unless geom.empty?
 
         @geom_edges << GeomEdge.new(hedge, nil)
       end
@@ -350,7 +344,7 @@ module RGeo
       # @param ccw [Boolean] true for CCW, false for CW
       # @return [HalfEdge, nil]
       def find_hedge(ring, ccw: true)
-        return nil if ring.num_points.zero?
+        return nil if ring.num_points == 0
         ccw_target = ccw ? 1 : -1
 
         coords = ring.start_point.coordinates
@@ -361,7 +355,7 @@ module RGeo
         start_seg = Segment.new(ring.start_point, ring.point_n(1))
         end_seg = Segment.new(ring.point_n(ring.num_points - 2), ring.end_point)
         colinear_hedges = hedges.select do |he|
-          start_seg.side(he.destination).zero? || end_seg.side(he.destination).zero?
+          start_seg.side(he.destination) == 0 || end_seg.side(he.destination) == 0
         end
 
         colinear_hedges.find do |hedge|

data/lib/rgeo/cartesian/sweepline_intersector.rb

@@ -46,9 +46,7 @@ module RGeo
           s2 = intersection.s2
           pt = intersection.point
 
-          unless (pt == s1.s && pt == s2.e) || (pt == s1.e && pt == s2.s)
-            @proper_intersections << intersection
-          end
+          @proper_intersections << intersection unless (pt == s1.s && pt == s2.e) || (pt == s1.e && pt == s2.s)
         end
         @proper_intersections
       end

data/lib/rgeo/cartesian/valid_op.rb

@@ -33,9 +33,7 @@ module RGeo
 
         # if additional nodes were added, there must be an intersection
         # through a boundary.
-        if poly.send(:graph).incident_edges.size > num_points
-          return Error::SELF_INTERSECTION
-        end
+        return Error::SELF_INTERSECTION if poly.send(:graph).incident_edges.size > num_points
 
         rings = [poly.exterior_ring] + poly.interior_rings
         return Error::SELF_INTERSECTION if rings.uniq.size != rings.size