rgeo 1.1.2 → 2.0.0

data/lib/rgeo/geographic/factory.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Geographic data factory implementation
@@ -12,74 +14,69 @@ module RGeo
 
     class Factory
       include Feature::Factory::Instance
-
-      def initialize(impl_prefix_, opts_ = {}) # :nodoc:
-        @impl_prefix = impl_prefix_
-        @point_class = Geographic.const_get("#{impl_prefix_}PointImpl")
-        @line_string_class = Geographic.const_get("#{impl_prefix_}LineStringImpl")
-        @linear_ring_class = Geographic.const_get("#{impl_prefix_}LinearRingImpl")
-        @line_class = Geographic.const_get("#{impl_prefix_}LineImpl")
-        @polygon_class = Geographic.const_get("#{impl_prefix_}PolygonImpl")
-        @geometry_collection_class = Geographic.const_get("#{impl_prefix_}GeometryCollectionImpl")
-        @multi_point_class = Geographic.const_get("#{impl_prefix_}MultiPointImpl")
-        @multi_line_string_class = Geographic.const_get("#{impl_prefix_}MultiLineStringImpl")
-        @multi_polygon_class = Geographic.const_get("#{impl_prefix_}MultiPolygonImpl")
-        @support_z = opts_[:has_z_coordinate] ? true : false
-        @support_m = opts_[:has_m_coordinate] ? true : false
-        @srid = (opts_[:srid] || 4326).to_i
-        @proj4 = opts_[:proj4]
+      include ImplHelper::Utils
+
+      attr_writer :projector
+
+      def initialize(impl_prefix, opts = {}) # :nodoc:
+        @impl_prefix = impl_prefix
+        @point_class = Geographic.const_get("#{impl_prefix}PointImpl")
+        @line_string_class = Geographic.const_get("#{impl_prefix}LineStringImpl")
+        @linear_ring_class = Geographic.const_get("#{impl_prefix}LinearRingImpl")
+        @line_class = Geographic.const_get("#{impl_prefix}LineImpl")
+        @polygon_class = Geographic.const_get("#{impl_prefix}PolygonImpl")
+        @geometry_collection_class = Geographic.const_get("#{impl_prefix}GeometryCollectionImpl")
+        @multi_point_class = Geographic.const_get("#{impl_prefix}MultiPointImpl")
+        @multi_line_string_class = Geographic.const_get("#{impl_prefix}MultiLineStringImpl")
+        @multi_polygon_class = Geographic.const_get("#{impl_prefix}MultiPolygonImpl")
+        @support_z = opts[:has_z_coordinate] ? true : false
+        @support_m = opts[:has_m_coordinate] ? true : false
+        @srid = (opts[:srid] || 4326).to_i
+        @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
-        @coord_sys = opts_[:coord_sys]
-        if @coord_sys.is_a?(::String)
-          @coord_sys = begin
-                         CoordSys::CS.create_from_wkt(@coord_sys)
-                       rescue
-                         nil
-                       end
+        @coord_sys = opts[:coord_sys]
+        if @coord_sys.is_a?(String)
+          @coord_sys = CoordSys::CS.create_from_wkt(@coord_sys)
         end
-        @lenient_assertions = opts_[:uses_lenient_assertions] ? true : false
-        @buffer_resolution = opts_[:buffer_resolution].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
         @projector = nil
       end
 
-      def _set_projector(projector_) # :nodoc:
-        @projector = projector_
-      end
-
       # Equivalence test.
 
       def eql?(rhs_)
@@ -105,10 +102,10 @@ module RGeo
           "hasz" => @support_z,
           "hasm" => @support_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
         }
@@ -122,107 +119,99 @@ module RGeo
       end
 
       def marshal_load(data_) # :nodoc:
-        if (proj4_data_ = data_["proj4"]) && CoordSys.check!(:proj4)
-          proj4_ = CoordSys::Proj4.allocate
-          proj4_.marshal_load(proj4_data_)
+        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(data_["pref"],
           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"]),
+          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_
-                  )
-        if (projklass_ = data_["prjc"]) && (projfactory_ = data_["prjf"])
-          klass_ = begin
-                     RGeo::Geographic.const_get(projklass_)
-                   rescue
-                     nil
-                   end
+          proj4: proj4,
+          coord_sys: coord_sys
+        )
+        if (proj_klass = data_["prjc"]) && (proj_factory = data_["prjf"])
+          klass_ = RGeo::Geographic.const_get(proj_klass)
           if klass_
-            projector_ = klass_.allocate
-            projector_._set_factories(self, projfactory_)
-            _set_projector(projector_)
+            projector = klass_.allocate
+            projector.set_factories(self, proj_factory)
+            @projector = projector
           end
         end
       end
 
       # Psych support
 
-      def encode_with(coder_) # :nodoc:
-        coder_["impl_prefix"] = @impl_prefix
-        coder_["has_z_coordinate"] = @support_z
-        coder_["has_m_coordinate"] = @support_m
-        coder_["srid"] = @srid
-        coder_["wkt_generator"] = @wkt_generator._properties
-        coder_["wkb_generator"] = @wkb_generator._properties
-        coder_["wkt_parser"] = @wkt_parser._properties
-        coder_["wkb_parser"] = @wkb_parser._properties
-        coder_["lenient_assertions"] = @lenient_assertions
-        coder_["buffer_resolution"] = @buffer_resolution
+      def encode_with(coder) # :nodoc:
+        coder["impl_prefix"] = @impl_prefix
+        coder["has_z_coordinate"] = @support_z
+        coder["has_m_coordinate"] = @support_m
+        coder["srid"] = @srid
+        coder["wkt_generator"] = @wkt_generator.properties
+        coder["wkb_generator"] = @wkb_generator.properties
+        coder["wkt_parser"] = @wkt_parser.properties
+        coder["wkb_parser"] = @wkb_parser.properties
+        coder["lenient_assertions"] = @lenient_assertions
+        coder["buffer_resolution"] = @buffer_resolution
         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
         if @projector
-          coder_["projector_class"] = @projector.class.name.sub(/.*::/, "")
-          coder_["projection_factory"] = @projector.projection_factory
+          coder["projectorclass"] = @projector.class.name.sub(/.*::/, "")
+          coder["projection_factory"] = @projector.projection_factory
         end
       end
 
-      def init_with(coder_) # :nodoc:
-        if (proj4_data_ = coder_["proj4"])
+      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"])
+          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(coder_["impl_prefix"],
-          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_
-                  )
-        if (projklass_ = coder_["projector_class"]) && (projfactory_ = coder_["projection_factory"])
-          klass_ = begin
-                     RGeo::Geographic.const_get(projklass_)
-                   rescue
-                     nil
-                   end
+        initialize(coder["impl_prefix"],
+          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
+        )
+        if (proj_klass = coder["projectorclass"]) && (proj_factory = coder["projection_factory"])
+          klass_ = RGeo::Geographic.const_get(proj_klass)
           if klass_
-            projector_ = klass_.allocate
-            projector_._set_factories(self, projfactory_)
-            _set_projector(projector_)
+            projector = klass_.allocate
+            projector.set_factories(self, proj_factory)
+            @projector = projector
           end
         end
       end
@@ -241,7 +230,7 @@ module RGeo
       # or nil if this factory does not support a projection.
 
       def projection_factory
-        @projector ? @projector.projection_factory : nil
+        @projector&.projection_factory
       end
 
       # Projects the given geometry into the projected coordinate space,
@@ -250,12 +239,12 @@ module RGeo
       # Raises Error::InvalidGeometry if the given geometry is not of
       # this factory.
 
-      def project(geometry_)
-        return nil unless @projector && geometry_
-        unless geometry_.factory == self
+      def project(geometry)
+        return unless @projector && geometry
+        unless geometry.factory == self
           raise Error::InvalidGeometry, "Wrong geometry type"
         end
-        @projector.project(geometry_)
+        @projector.project(geometry)
       end
 
       # Reverse-projects the given geometry from the projected coordinate
@@ -263,12 +252,12 @@ module RGeo
       # Raises Error::InvalidGeometry if the given geometry is not of
       # the projection defined by this factory.
 
-      def unproject(geometry_)
-        return nil unless geometry_
-        unless @projector && @projector.projection_factory == geometry_.factory
+      def unproject(geometry)
+        return unless geometry
+        unless @projector && @projector.projection_factory == geometry.factory
           raise Error::InvalidGeometry, "You can unproject only features that are in the projected coordinate space."
         end
-        @projector.unproject(geometry_)
+        @projector.unproject(geometry)
       end
 
       # Returns true if this factory supports a projection and the
@@ -298,8 +287,8 @@ module RGeo
 
       # See RGeo::Feature::Factory#property
 
-      def property(name_)
-        case name_
+      def property(name)
+        case name
         when :has_z_coordinate
           @support_z
         when :has_m_coordinate
@@ -315,86 +304,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_)
-        @point_class.new(self, x_, y_, *extra_)
-      rescue
-        nil
+      def point(x, y, *extra)
+        @point_class.new(self, x, y, *extra)
       end
 
       # See RGeo::Feature::Factory#line_string
 
-      def line_string(points_)
-        @line_string_class.new(self, points_)
-      rescue
-        nil
+      def line_string(points)
+        @line_string_class.new(self, points)
       end
 
       # See RGeo::Feature::Factory#line
 
-      def line(start_, end_)
-        @line_class.new(self, start_, end_)
-      rescue
-        nil
+      def line(start, stop)
+        @line_class.new(self, start, stop)
       end
 
       # See RGeo::Feature::Factory#linear_ring
 
-      def linear_ring(points_)
-        @linear_ring_class.new(self, points_)
-      rescue
-        nil
+      def linear_ring(points)
+        @linear_ring_class.new(self, points)
       end
 
       # See RGeo::Feature::Factory#polygon
 
-      def polygon(outer_ring_, inner_rings_ = nil)
-        @polygon_class.new(self, outer_ring_, inner_rings_)
-      rescue
-        nil
+      def polygon(outer_ring, inner_rings = nil)
+        @polygon_class.new(self, outer_ring, inner_rings)
       end
 
       # See RGeo::Feature::Factory#collection
 
-      def collection(elems_)
-        @geometry_collection_class.new(self, elems_)
-      rescue
-        nil
+      def collection(elems)
+        @geometry_collection_class.new(self, elems)
       end
 
       # See RGeo::Feature::Factory#multi_point
 
-      def multi_point(elems_)
-        @multi_point_class.new(self, elems_)
-      rescue
-        nil
+      def multi_point(elems)
+        @multi_point_class.new(self, elems)
       end
 
       # See RGeo::Feature::Factory#multi_line_string
 
-      def multi_line_string(elems_)
-        @multi_line_string_class.new(self, elems_)
-      rescue
-        nil
+      def multi_line_string(elems)
+        @multi_line_string_class.new(self, elems)
       end
 
       # See RGeo::Feature::Factory#multi_polygon
 
-      def multi_polygon(elems_)
-        @multi_polygon_class.new(self, elems_)
-      rescue
-        nil
+      def multi_polygon(elems)
+        @multi_polygon_class.new(self, elems)
       end
 
       # See RGeo::Feature::Factory#proj4
@@ -405,44 +376,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) # :nodoc:
+        @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