rgeo 1.1.2 → 2.2.0

data/lib/rgeo/cartesian/calculations.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Core calculations in the plane
@@ -9,9 +11,9 @@ module RGeo
     # Represents a line segment in the plane.
 
     class Segment # :nodoc:
-      def initialize(start_, end_)
-        @s = start_
-        @e = end_
+      def initialize(start, stop)
+        @s = start
+        @e = stop
         @sx = @s.x
         @sy = @s.y
         @ex = @e.x
@@ -30,8 +32,8 @@ module RGeo
         "#{@s} - #{@e}"
       end
 
-      def eql?(rhs_)
-        rhs_.is_a?(Segment) && @s == rhs_.s && @e == rhs_.e
+      def eql?(rhs)
+        rhs.is_a?(Segment) && @s == rhs.s && @e == rhs.e
       end
       alias == eql?
 
@@ -43,70 +45,70 @@ module RGeo
       # a positive value if the point is to the right, or
       # 0 if the point is collinear to the segment.
 
-      def side(p_)
-        px_ = p_.x
-        py_ = p_.y
-        (@sx - px_) * (@ey - py_) - (@sy - py_) * (@ex - px_)
+      def side(p)
+        px = p.x
+        py = p.y
+        (@sx - px) * (@ey - py) - (@sy - py) * (@ex - px)
       end
 
-      def tproj(p_)
+      def tproj(p)
         if @lensq == 0
           nil
         else
-          (@dx * (p_.x - @sx) + @dy * (p_.y - @sy)) / @lensq
+          (@dx * (p.x - @sx) + @dy * (p.y - @sy)) / @lensq
         end
       end
 
-      def contains_point?(p_)
-        if side(p_) == 0
-          t_ = tproj(p_)
-          t_ && t_ >= 0.0 && t_ <= 1.0
+      def contains_point?(p)
+        if side(p) == 0
+          t = tproj(p)
+          t && t >= 0.0 && t <= 1.0
         else
           false
         end
       end
 
-      def intersects_segment?(seg_)
-        s2_ = seg_.s
+      def intersects_segment?(seg)
+        s2 = seg.s
         # Handle degenerate cases
-        if seg_.degenerate?
+        if seg.degenerate?
           if @lensq == 0
-            return @s == s2_
+            return @s == s2
           else
-            return contains_point?(s2_)
+            return contains_point?(s2)
           end
         elsif @lensq == 0
-          return seg_.contains_point?(@s)
+          return seg.contains_point?(@s)
         end
         # Both segments have nonzero length.
-        sx2_ = s2_.x
-        sy2_ = s2_.y
-        dx2_ = seg_.dx
-        dy2_ = seg_.dy
-        denom_ = @dx * dy2_ - @dy * dx2_
-        if denom_ == 0
+        sx2 = s2.x
+        sy2 = s2.y
+        dx2 = seg.dx
+        dy2 = seg.dy
+        denom = @dx * dy2 - @dy * dx2
+        if denom == 0
           # Segments are parallel. Make sure they are collinear.
-          return false unless side(s2_) == 0
+          return false unless side(s2) == 0
           # 1-D check.
-          ts_ = (@dx * (sx2_ - @sx) + @dy * (sy2_ - @sy)) / @lensq
-          te_ = (@dx * (sx2_ + dx2_ - @sx) + @dy * (sy2_ + dy2_ - @sy)) / @lensq
-          if ts_ < te_
-            te_ >= 0.0 && ts_ <= 1.0
+          ts = (@dx * (sx2 - @sx) + @dy * (sy2 - @sy)) / @lensq
+          te = (@dx * (sx2 + dx2 - @sx) + @dy * (sy2 + dy2 - @sy)) / @lensq
+          if ts < te
+            te >= 0.0 && ts <= 1.0
           else
-            ts_ >= 0.0 && te_ <= 1.0
+            ts >= 0.0 && te <= 1.0
           end
         else
           # Segments are not parallel. Check the intersection of their
           # containing lines.
-          t_ = (dy2_ * (sx2_ - @sx) + dx2_ * (@sy - sy2_)) / denom_
-          return false if t_ < 0.0 || t_ > 1.0
-          t2_ = (@dy * (sx2_ - @sx) + @dx * (@sy - sy2_)) / denom_
-          t2_ >= 0.0 && t2_ <= 1.0
+          t = (dy2 * (sx2 - @sx) + dx2 * (@sy - sy2)) / denom
+          return false if t < 0.0 || t > 1.0
+          t2 = (@dy * (sx2 - @sx) + @dx * (@sy - sy2)) / denom
+          t2 >= 0.0 && t2 <= 1.0
         end
       end
 
       def length
-        ::Math.sqrt(@lensq)
+        Math.sqrt(@lensq)
       end
     end
   end

data/lib/rgeo/cartesian/factory.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Geographic data factory implementation
@@ -11,67 +13,64 @@ module RGeo
 
     class Factory
       include Feature::Factory::Instance
+      include ImplHelper::Utils
 
       # Create a new simple cartesian factory.
       #
       # See RGeo::Cartesian.simple_factory for a list of supported options.
 
-      def initialize(opts_ = {})
-        @has_z = opts_[:has_z_coordinate] ? true : false
-        @has_m = opts_[:has_m_coordinate] ? true : false
-        @proj4 = opts_[:proj4]
+      def initialize(opts = {})
+        @has_z = opts[:has_z_coordinate] ? true : false
+        @has_m = opts[:has_m_coordinate] ? true : false
+        @proj4 = opts[:proj4]
         if @proj4 && CoordSys.check!(:proj4)
-          if @proj4.is_a?(::String) || @proj4.is_a?(::Hash)
+          if @proj4.is_a?(String) || @proj4.is_a?(Hash)
             @proj4 = CoordSys::Proj4.create(@proj4)
           end
         end
-        srid_ = opts_[:srid]
-        @coord_sys = opts_[:coord_sys]
-        if @coord_sys.is_a?(::String)
-          @coord_sys = begin
-                         CoordSys::CS.create_from_wkt(@coord_sys)
-                       rescue
-                         nil
-                       end
+        srid = opts[:srid]
+        @coord_sys = opts[:coord_sys]
+        if @coord_sys.is_a?(String)
+          @coord_sys = CoordSys::CS.create_from_wkt(@coord_sys)
         end
-        if (!@proj4 || !@coord_sys) && srid_ && (db_ = opts_[:srs_database])
-          entry_ = db_.get(srid_.to_i)
-          if entry_
-            @proj4 ||= entry_.proj4
-            @coord_sys ||= entry_.coord_sys
+        if (!@proj4 || !@coord_sys) && srid && (db = opts[:srs_database])
+          entry = db.get(srid.to_i)
+          if entry
+            @proj4 ||= entry.proj4
+            @coord_sys ||= entry.coord_sys
           end
         end
-        srid_ ||= @coord_sys.authority_code if @coord_sys
-        @srid = srid_.to_i
-        @lenient_assertions = opts_[:uses_lenient_assertions] ? true : false
-        @buffer_resolution = opts_[:buffer_resolution].to_i
+        srid ||= @coord_sys.authority_code if @coord_sys
+        @srid = srid.to_i
+        @lenient_assertions = opts[:uses_lenient_assertions] ? true : false
+        @buffer_resolution = opts[:buffer_resolution].to_i
         @buffer_resolution = 1 if @buffer_resolution < 1
 
-        wkt_generator_ = opts_[:wkt_generator]
-        case wkt_generator_
-        when ::Hash
-          @wkt_generator = WKRep::WKTGenerator.new(wkt_generator_)
+        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
-        wkb_generator_ = opts_[:wkb_generator]
-        case wkb_generator_
-        when ::Hash
-          @wkb_generator = WKRep::WKBGenerator.new(wkb_generator_)
+        wkb_generator = opts[:wkb_generator]
+        case wkb_generator
+        when Hash
+          @wkb_generator = WKRep::WKBGenerator.new(wkb_generator)
         else
           @wkb_generator = WKRep::WKBGenerator.new
         end
-        wkt_parser_ = opts_[:wkt_parser]
-        case wkt_parser_
-        when ::Hash
-          @wkt_parser = WKRep::WKTParser.new(self, wkt_parser_)
+        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
-        wkb_parser_ = opts_[:wkb_parser]
-        case wkb_parser_
-        when ::Hash
-          @wkb_parser = WKRep::WKBParser.new(self, wkb_parser_)
+        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
@@ -79,11 +78,11 @@ module RGeo
 
       # 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) &&
-          @proj4.eql?(rhs_.proj4)
+      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) &&
+          @proj4.eql?(rhs.proj4)
       end
       alias == eql?
 
@@ -100,10 +99,10 @@ module RGeo
           "hasz" => @has_z,
           "hasm" => @has_m,
           "srid" => @srid,
-          "wktg" => @wkt_generator._properties,
-          "wkbg" => @wkb_generator._properties,
-          "wktp" => @wkt_parser._properties,
-          "wkbp" => @wkb_parser._properties,
+          "wktg" => @wkt_generator.properties,
+          "wkbg" => @wkb_generator.properties,
+          "wktp" => @wkt_parser.properties,
+          "wkbp" => @wkb_parser.properties,
           "lena" => @lenient_assertions,
           "bufr" => @buffer_resolution
         }
@@ -112,79 +111,79 @@ module RGeo
         hash_
       end
 
-      def marshal_load(data_) # :nodoc:
-        if (proj4_data_ = data_["proj4"]) && CoordSys.check!(:proj4)
-          proj4_ = CoordSys::Proj4.allocate
-          proj4_.marshal_load(proj4_data_)
+      def marshal_load(data) # :nodoc:
+        if (proj4_data = data["proj4"]) && CoordSys.check!(:proj4)
+          proj4 = CoordSys::Proj4.allocate
+          proj4.marshal_load(proj4_data)
         else
-          proj4_ = nil
+          proj4 = nil
         end
-        if (coord_sys_data_ = data_["cs"])
-          coord_sys_ = CoordSys::CS.create_from_wkt(coord_sys_data_)
+        if (coord_sys_data = data["cs"])
+          coord_sys = CoordSys::CS.create_from_wkt(coord_sys_data)
         else
-          coord_sys_ = nil
+          coord_sys = nil
         end
         initialize(
-          has_z_coordinate: data_["hasz"],
-          has_m_coordinate: data_["hasm"],
-          srid: data_["srid"],
-          wkt_generator: ImplHelper::Utils.symbolize_hash(data_["wktg"]),
-          wkb_generator: ImplHelper::Utils.symbolize_hash(data_["wkbg"]),
-          wkt_parser: ImplHelper::Utils.symbolize_hash(data_["wktp"]),
-          wkb_parser: ImplHelper::Utils.symbolize_hash(data_["wkbp"]),
-          uses_lenient_assertions: data_["lena"],
-          buffer_resolution: data_["bufr"],
-          proj4: proj4_,
-          coord_sys: coord_sys_
+          has_z_coordinate: data["hasz"],
+          has_m_coordinate: data["hasm"],
+          srid: data["srid"],
+          wkt_generator: symbolize_hash(data["wktg"]),
+          wkb_generator: symbolize_hash(data["wkbg"]),
+          wkt_parser: symbolize_hash(data["wktp"]),
+          wkb_parser: symbolize_hash(data["wkbp"]),
+          uses_lenient_assertions: data["lena"],
+          buffer_resolution: data["bufr"],
+          proj4: proj4,
+          coord_sys: coord_sys
         )
       end
 
       # Psych support
 
-      def encode_with(coder_) # :nodoc:
-        coder_["has_z_coordinate"] = @has_z
-        coder_["has_m_coordinate"] = @has_m
-        coder_["srid"] = @srid
-        coder_["lenient_assertions"] = @lenient_assertions
-        coder_["buffer_resolution"] = @buffer_resolution
-        coder_["wkt_generator"] = @wkt_generator._properties
-        coder_["wkb_generator"] = @wkb_generator._properties
-        coder_["wkt_parser"] = @wkt_parser._properties
-        coder_["wkb_parser"] = @wkb_parser._properties
+      def encode_with(coder) # :nodoc:
+        coder["has_z_coordinate"] = @has_z
+        coder["has_m_coordinate"] = @has_m
+        coder["srid"] = @srid
+        coder["lenient_assertions"] = @lenient_assertions
+        coder["buffer_resolution"] = @buffer_resolution
+        coder["wkt_generator"] = @wkt_generator.properties
+        coder["wkb_generator"] = @wkb_generator.properties
+        coder["wkt_parser"] = @wkt_parser.properties
+        coder["wkb_parser"] = @wkb_parser.properties
         if @proj4
-          str_ = @proj4.original_str || @proj4.canonical_str
-          coder_["proj4"] = @proj4.radians? ? { "proj4" => str_, "radians" => true } : str_
+          str = @proj4.original_str || @proj4.canonical_str
+          coder["proj4"] = @proj4.radians? ? { "proj4" => str, "radians" => true } : str
         end
-        coder_["coord_sys"] = @coord_sys.to_wkt if @coord_sys
+        coder["coord_sys"] = @coord_sys.to_wkt if @coord_sys
       end
 
-      def init_with(coder_) # :nodoc:
-        if (proj4_data_ = coder_["proj4"]) && CoordSys.check!(:proj4)
-          if proj4_data_.is_a?(::Hash)
-            proj4_ = CoordSys::Proj4.create(proj4_data_["proj4"], radians: proj4_data_["radians"])
+      def init_with(coder) # :nodoc:
+        if (proj4_data = coder["proj4"]) && CoordSys.check!(:proj4)
+          if proj4_data.is_a?(Hash)
+            proj4 = CoordSys::Proj4.create(proj4_data["proj4"], radians: proj4_data["radians"])
           else
-            proj4_ = CoordSys::Proj4.create(proj4_data_.to_s)
+            proj4 = CoordSys::Proj4.create(proj4_data.to_s)
           end
         else
-          proj4_ = nil
+          proj4 = nil
         end
-        if (coord_sys_data_ = coder_["cs"])
-          coord_sys_ = CoordSys::CS.create_from_wkt(coord_sys_data_.to_s)
+        if (coord_sys_data = coder["cs"])
+          coord_sys = CoordSys::CS.create_from_wkt(coord_sys_data.to_s)
         else
-          coord_sys_ = nil
+          coord_sys = nil
         end
         initialize(
-          has_z_coordinate: coder_["has_z_coordinate"],
-          has_m_coordinate: coder_["has_m_coordinate"],
-          srid: coder_["srid"],
-          wkt_generator: ImplHelper::Utils.symbolize_hash(coder_["wkt_generator"]),
-          wkb_generator: ImplHelper::Utils.symbolize_hash(coder_["wkb_generator"]),
-          wkt_parser: ImplHelper::Utils.symbolize_hash(coder_["wkt_parser"]),
-          wkb_parser: ImplHelper::Utils.symbolize_hash(coder_["wkb_parser"]),
-          uses_lenient_assertions: coder_["lenient_assertions"],
-          buffer_resolution: coder_["buffer_resolution"],
-          proj4: proj4_,
-          coord_sys: coord_sys_
+          has_z_coordinate: coder["has_z_coordinate"],
+          has_m_coordinate: coder["has_m_coordinate"],
+          srid: coder["srid"],
+          wkt_generator: symbolize_hash(coder["wkt_generator"]),
+          wkb_generator: symbolize_hash(coder["wkb_generator"]),
+          wkt_parser: symbolize_hash(coder["wkt_parser"]),
+          wkb_parser: symbolize_hash(coder["wkb_parser"]),
+          uses_lenient_assertions: coder["lenient_assertions"],
+          buffer_resolution: coder["buffer_resolution"],
+          proj4: proj4,
+          coord_sys: coord_sys
         )
       end
 
@@ -194,8 +193,8 @@ module RGeo
 
       # See RGeo::Feature::Factory#property
 
-      def property(name_)
-        case name_
+      def property(name)
+        case name
         when :has_z_coordinate
           @has_z
         when :has_m_coordinate
@@ -211,86 +210,68 @@ module RGeo
 
       # See RGeo::Feature::Factory#parse_wkt
 
-      def parse_wkt(str_)
-        @wkt_parser.parse(str_)
+      def parse_wkt(str)
+        @wkt_parser.parse(str)
       end
 
       # See RGeo::Feature::Factory#parse_wkb
 
-      def parse_wkb(str_)
-        @wkb_parser.parse(str_)
+      def parse_wkb(str)
+        @wkb_parser.parse(str)
       end
 
       # See RGeo::Feature::Factory#point
 
-      def point(x_, y_, *extra_)
-        PointImpl.new(self, x_, y_, *extra_)
-      rescue
-        nil
+      def point(x, y, *extra)
+        PointImpl.new(self, x, y, *extra)
       end
 
       # See RGeo::Feature::Factory#line_string
 
-      def line_string(points_)
-        LineStringImpl.new(self, points_)
-      rescue
-        nil
+      def line_string(points)
+        LineStringImpl.new(self, points)
       end
 
       # See RGeo::Feature::Factory#line
 
-      def line(start_, end_)
-        LineImpl.new(self, start_, end_)
-      rescue
-        nil
+      def line(start, stop)
+        LineImpl.new(self, start, stop)
       end
 
       # See RGeo::Feature::Factory#linear_ring
 
-      def linear_ring(points_)
-        LinearRingImpl.new(self, points_)
-      rescue
-        nil
+      def linear_ring(points)
+        LinearRingImpl.new(self, points)
       end
 
       # See RGeo::Feature::Factory#polygon
 
-      def polygon(outer_ring_, inner_rings_ = nil)
-        PolygonImpl.new(self, outer_ring_, inner_rings_)
-      rescue
-        nil
+      def polygon(outer_ring, inner_rings = nil)
+        PolygonImpl.new(self, outer_ring, inner_rings)
       end
 
       # See RGeo::Feature::Factory#collection
 
-      def collection(elems_)
-        GeometryCollectionImpl.new(self, elems_)
-      rescue
-        nil
+      def collection(elems)
+        GeometryCollectionImpl.new(self, elems)
       end
 
       # See RGeo::Feature::Factory#multi_point
 
-      def multi_point(elems_)
-        MultiPointImpl.new(self, elems_)
-      rescue
-        nil
+      def multi_point(elems)
+        MultiPointImpl.new(self, elems)
       end
 
       # See RGeo::Feature::Factory#multi_line_string
 
-      def multi_line_string(elems_)
-        MultiLineStringImpl.new(self, elems_)
-      rescue
-        nil
+      def multi_line_string(elems)
+        MultiLineStringImpl.new(self, elems)
       end
 
       # See RGeo::Feature::Factory#multi_polygon
 
-      def multi_polygon(elems_)
-        MultiPolygonImpl.new(self, elems_)
-      rescue
-        nil
+      def multi_polygon(elems)
+        MultiPolygonImpl.new(self, elems)
       end
 
       # See RGeo::Feature::Factory#proj4
@@ -301,44 +282,28 @@ module RGeo
 
       attr_reader :coord_sys
 
-      def _generate_wkt(obj_)  # :nodoc:
-        @wkt_generator.generate(obj_)
+      def generate_wkt(obj)
+        @wkt_generator.generate(obj)
       end
 
-      def _generate_wkb(obj_)  # :nodoc:
-        @wkb_generator.generate(obj_)
+      def generate_wkb(obj)
+        @wkb_generator.generate(obj)
       end
 
-      def _marshal_wkb_generator # :nodoc:
-        unless defined?(@marshal_wkb_generator)
-          @marshal_wkb_generator = RGeo::WKRep::WKBGenerator.new(
-            type_format: :wkb12)
-        end
-        @marshal_wkb_generator
+      def marshal_wkb_generator
+        @marshal_wkb_generator ||= RGeo::WKRep::WKBGenerator.new(type_format: :wkb12)
       end
 
-      def _marshal_wkb_parser # :nodoc:
-        unless defined?(@marshal_wkb_parser)
-          @marshal_wkb_parser = RGeo::WKRep::WKBParser.new(self,
-            support_wkb12: true)
-        end
-        @marshal_wkb_parser
+      def marshal_wkb_parser
+        @marshal_wkb_parser ||= RGeo::WKRep::WKBParser.new(self, support_wkb12: true)
       end
 
-      def _psych_wkt_generator # :nodoc:
-        unless defined?(@psych_wkt_generator)
-          @psych_wkt_generator = RGeo::WKRep::WKTGenerator.new(
-            tag_format: :wkt12)
-        end
-        @psych_wkt_generator
+      def psych_wkt_generator
+        @psych_wkt_generator ||= RGeo::WKRep::WKTGenerator.new(tag_format: :wkt12)
       end
 
-      def _psych_wkt_parser # :nodoc:
-        unless defined?(@psych_wkt_parser)
-          @psych_wkt_parser = RGeo::WKRep::WKTParser.new(self,
-            support_wkt12: true, support_ewkt: true)
-        end
-        @psych_wkt_parser
+      def psych_wkt_parser
+        @psych_wkt_parser ||= RGeo::WKRep::WKTParser.new(self, support_wkt12: true, support_ewkt: true)
       end
     end
   end