rgeo 3.0.0.pre.rc.3 → 3.0.1

data/lib/rgeo/feature/multi_surface.rb

@@ -28,7 +28,6 @@ module RGeo
     # include this module itself. Therefore, you should not depend on the
     # kind_of? method to check type. Instead, use the provided check_type
     # class method (or === operator) defined in the Type module.
-
     module MultiSurface
       include GeometryCollection
       extend Type

data/lib/rgeo/feature/point.rb

@@ -33,7 +33,6 @@ module RGeo
     # replace them with empty GeometryCollection objects. Therefore,
     # currently, every RGeo Point object represents an actual location
     # with real coordinates.
-
     module Point
       include Geometry
       extend Type

data/lib/rgeo/feature/polygon.rb

@@ -45,7 +45,6 @@ module RGeo
     # include this module itself. Therefore, you should not depend on the
     # kind_of? method to check type. Instead, use the provided check_type
     # class method (or === operator) defined in the Type module.
-
     module Polygon
       include Surface
       extend Type
@@ -84,7 +83,7 @@ module RGeo
       # if the given N is out of range. N is zero-based.
       # Does not support negative indexes.
 
-      def interior_ring_n(n)
+      def interior_ring_n(_idx)
         raise Error::UnsupportedOperation, "Method Polygon#interior_ring_n not defined."
       end
 

data/lib/rgeo/feature/surface.rb

@@ -34,7 +34,6 @@ module RGeo
     # class method (or === operator) defined in the Type module.
     #
     # Some implementations may support higher dimensional points.
-
     module Surface
       include Geometry
       extend Type

data/lib/rgeo/feature/types.rb

@@ -11,7 +11,6 @@ module RGeo
     # All geometry implementations MUST include this submodule.
     # This serves as a marker that may be used to test an object for
     # feature-ness.
-
     module Instance
     end
 
@@ -49,7 +48,6 @@ module RGeo
     # a particular object is a feature type:
     #
     #   RGeo::Feature::Type === object.geometry_type  # true
-
     module Type
       # Returns true if the given object is this type or a subtype
       # thereof, or if it is a feature object whose geometry_type is
@@ -192,92 +190,78 @@ module RGeo
           # Types are the same
           if nfactory == factory
             force_new ? obj.dup : obj
-          else
-            if type == Point
-              cs = ncs = nil
-              if project
-                cs = factory.coord_sys
-                ncs = nfactory.coord_sys
-              end
-              hasz = factory.property(:has_z_coordinate)
-              nhasz = nfactory.property(:has_z_coordinate)
-              if cs && ncs
-                coords = cs.transform_coords(ncs, obj.x, obj.y, hasz ? obj.z : nil)
-                coords << (hasz ? obj.z : 0.0) if nhasz && coords.size < 3
-              else
-                coords = [obj.x, obj.y]
-                coords << (hasz ? obj.z : 0.0) if nhasz
-              end
-              coords << (factory.property(:has_m_coordinate) ? obj.m : 0.0) if nfactory.property(:has_m_coordinate)
-              nfactory.point(*coords)
-            elsif type == Line
-              nfactory.line(cast(obj.start_point, nfactory, opts), cast(obj.end_point, nfactory, opts))
-            elsif type == LinearRing
-              nfactory.linear_ring(obj.points.map { |p| cast(p, nfactory, opts) })
-            elsif type == LineString
-              nfactory.line_string(obj.points.map { |p| cast(p, nfactory, opts) })
-            elsif type == Polygon
-              nfactory.polygon(cast(obj.exterior_ring, nfactory, opts),
-                                obj.interior_rings.map { |r| cast(r, nfactory, opts) })
-            elsif type == MultiPoint
-              nfactory.multi_point(obj.map { |g| cast(g, nfactory, opts) })
-            elsif type == MultiLineString
-              nfactory.multi_line_string(obj.map { |g| cast(g, nfactory, opts) })
-            elsif type == MultiPolygon
-              nfactory.multi_polygon(obj.map { |g| cast(g, nfactory, opts) })
-            elsif type == GeometryCollection
-              nfactory.collection(obj.map { |g| cast(g, nfactory, opts) })
-            end
+          elsif type == Point
+            z = factory.property(:has_z_coordinate) ? obj.z : nil
+            coords = if project && (cs = factory.coord_sys) && (ncs = nfactory.coord_sys)
+                       cs.transform_coords(ncs, obj.x, obj.y, z)
+                     else
+                       [obj.x, obj.y]
+                     end
+            coords << (z || 0.0) if nfactory.property(:has_z_coordinate) && coords.size < 3
+            m = factory.property(:has_m_coordinate) ? obj.m : nil
+            coords << (m || 0.0) if nfactory.property(:has_m_coordinate)
+            nfactory.point(*coords)
+          elsif type == Line
+            nfactory.line(cast(obj.start_point, nfactory, opts), cast(obj.end_point, nfactory, opts))
+          elsif type == LinearRing
+            nfactory.linear_ring(obj.points.map { |p| cast(p, nfactory, opts) })
+          elsif type == LineString
+            nfactory.line_string(obj.points.map { |p| cast(p, nfactory, opts) })
+          elsif type == Polygon
+            nfactory.polygon(
+              cast(obj.exterior_ring, nfactory, opts),
+              obj.interior_rings.map { |r| cast(r, nfactory, opts) }
+            )
+          elsif type == MultiPoint
+            nfactory.multi_point(obj.map { |g| cast(g, nfactory, opts) })
+          elsif type == MultiLineString
+            nfactory.multi_line_string(obj.map { |g| cast(g, nfactory, opts) })
+          elsif type == MultiPolygon
+            nfactory.multi_polygon(obj.map { |g| cast(g, nfactory, opts) })
+          elsif type == GeometryCollection
+            nfactory.collection(obj.map { |g| cast(g, nfactory, opts) })
           end
-        else
-          # Types are different
-          if ntype == Point && (type == MultiPoint || type == GeometryCollection) ||
-              (ntype == Line || ntype == LineString || ntype == LinearRing) && (type == MultiLineString || type == GeometryCollection) ||
-              ntype == Polygon && (type == MultiPolygon || type == GeometryCollection)
-            if obj.num_geometries == 1
-              cast(obj.geometry_n(0), nfactory, ntype, opts)
-            end
-          elsif ntype == Point
-            raise(Error::InvalidGeometry, "Cannot cast to Point")
-          elsif ntype == Line
-            if type == LineString && obj.num_points == 2
-              nfactory.line(cast(obj.point_n(0), nfactory, opts), cast(obj.point_n(1), nfactory, opts))
-            end
-          elsif ntype == LinearRing
-            if type == LineString
-              nfactory.linear_ring(obj.points.map { |p| cast(p, nfactory, opts) })
-            end
-          elsif ntype == LineString
-            if type == Line || type == LinearRing
-              nfactory.line_string(obj.points.map { |p| cast(p, nfactory, opts) })
-            end
-          elsif ntype == MultiPoint
-            if type == Point
-              nfactory.multi_point([cast(obj, nfactory, opts)])
-            elsif type == GeometryCollection
-              nfactory.multi_point(obj.map { |p| cast(p, nfactory, opts) })
-            end
-          elsif ntype == MultiLineString
-            if type == Line || type == LinearRing || type == LineString
-              nfactory.multi_line_string([cast(obj, nfactory, opts)])
-            elsif type == GeometryCollection
-              nfactory.multi_line_string(obj.map { |p| cast(p, nfactory, opts) })
-            end
-          elsif ntype == MultiPolygon
-            if type == Polygon
-              nfactory.multi_polygon([cast(obj, nfactory, opts)])
-            elsif type == GeometryCollection
-              nfactory.multi_polygon(obj.map { |p| cast(p, nfactory, opts) })
-            end
-          elsif ntype == GeometryCollection
-            if type == MultiPoint || type == MultiLineString || type == MultiPolygon
-              nfactory.collection(obj.map { |p| cast(p, nfactory, opts) })
-            else
-              nfactory.collection([cast(obj, nfactory, opts)])
-            end
+        # Types are different
+        elsif ntype == Point && [MultiPoint, GeometryCollection].include?(type) ||
+            [Line, LineString, LinearRing].include?(ntype) && [MultiLineString, GeometryCollection].include?(type) ||
+            ntype == Polygon && [MultiPolygon, GeometryCollection].include?(type)
+          cast(obj.geometry_n(0), nfactory, ntype, opts) if obj.num_geometries == 1
+        elsif ntype == Point
+          raise(Error::InvalidGeometry, "Cannot cast to Point")
+        elsif ntype == Line
+          if type == LineString && obj.num_points == 2
+            nfactory.line(cast(obj.point_n(0), nfactory, opts), cast(obj.point_n(1), nfactory, opts))
+          end
+        elsif ntype == LinearRing
+          nfactory.linear_ring(obj.points.map { |p| cast(p, nfactory, opts) }) if type == LineString
+        elsif ntype == LineString
+          nfactory.line_string(obj.points.map { |p| cast(p, nfactory, opts) }) if [Line, LinearRing].include?(type)
+        elsif ntype == MultiPoint
+          if type == Point
+            nfactory.multi_point([cast(obj, nfactory, opts)])
+          elsif type == GeometryCollection
+            nfactory.multi_point(obj.map { |p| cast(p, nfactory, opts) })
+          end
+        elsif ntype == MultiLineString
+          if [Line, LinearRing, LineString].include?(type)
+            nfactory.multi_line_string([cast(obj, nfactory, opts)])
+          elsif type == GeometryCollection
+            nfactory.multi_line_string(obj.map { |p| cast(p, nfactory, opts) })
+          end
+        elsif ntype == MultiPolygon
+          if type == Polygon
+            nfactory.multi_polygon([cast(obj, nfactory, opts)])
+          elsif type == GeometryCollection
+            nfactory.multi_polygon(obj.map { |p| cast(p, nfactory, opts) })
+          end
+        elsif ntype == GeometryCollection
+          if [MultiPoint, MultiLineString, MultiPolygon].include?(type)
+            nfactory.collection(obj.map { |p| cast(p, nfactory, opts) })
           else
-            raise(RGeo::Error::InvalidGeometry, "Undefined type cast from #{type.name} to #{ntype.name}")
+            nfactory.collection([cast(obj, nfactory, opts)])
           end
+        else
+          raise(RGeo::Error::InvalidGeometry, "Undefined type cast from #{type.name} to #{ntype.name}")
         end
       end
     end

data/lib/rgeo/geographic/factory.rb

@@ -11,13 +11,20 @@ module RGeo
     # This class implements the various factories for geography features.
     # See methods of the RGeo::Geographic module for the API for creating
     # geography factories.
-
     class Factory
       include Feature::Factory::Instance
       include ImplHelper::Utils
 
       attr_writer :projector
 
+      attr_reader :coordinate_dimension, :spatial_dimension
+
+      # Returns the srid reported by this factory.
+      attr_reader :srid
+
+      # See RGeo::Feature::Factory#coord_sys
+      attr_reader :coord_sys
+
       def initialize(impl_prefix, opts = {}) # :nodoc:
         @impl_prefix = impl_prefix
         @point_class = Geographic.const_get("#{impl_prefix}PointImpl")
@@ -45,45 +52,48 @@ 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
         @projector = nil
       end
-      attr_reader :coordinate_dimension, :spatial_dimension
 
       # Equivalence test.
 
-      def eql?(rhs_)
-        rhs_.is_a?(Geographic::Factory) &&
-          @impl_prefix == rhs_.instance_variable_get(:@impl_prefix) &&
-          @support_z == rhs_.instance_variable_get(:@support_z) &&
-          @support_m == rhs_.instance_variable_get(:@support_m) &&
-          @coord_sys == rhs_.instance_variable_get(:@coord_sys)
+      def eql?(other)
+        other.is_a?(Geographic::Factory) &&
+          @impl_prefix == other.instance_variable_get(:@impl_prefix) &&
+          @support_z == other.instance_variable_get(:@support_z) &&
+          @support_m == other.instance_variable_get(:@support_m) &&
+          @coord_sys == other.instance_variable_get(:@coord_sys)
       end
       alias == eql?
 
@@ -116,12 +126,11 @@ 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
-        initialize(data_["pref"],
+        cs_class = CoordSys::CONFIG.default_coord_sys_class
+        coord_sys = data_["cs"]&.then { |cs| cs_class.create_from_wkt(cs) }
+
+        initialize(
+          data_["pref"],
           has_z_coordinate: data_["hasz"],
           has_m_coordinate: data_["hasm"],
           srid: data_["srid"],
@@ -132,14 +141,18 @@ module RGeo
           buffer_resolution: data_["bufr"],
           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, proj_factory)
-            @projector = projector
-          end
-        end
+        proj_klass = data_["prjc"]
+        proj_factory = data_["prjf"]
+
+        return unless proj_klass && proj_factory
+
+        klass_ = RGeo::Geographic.const_get(proj_klass)
+
+        return unless klass_
+
+        projector = klass_.allocate
+        projector.set_factories(self, proj_factory)
+        @projector = projector
       end
 
       # Psych support
@@ -155,19 +168,19 @@ module RGeo
         coder["wkb_parser"] = @wkb_parser.properties
         coder["buffer_resolution"] = @buffer_resolution
         coder["coord_sys"] = @coord_sys.to_wkt if @coord_sys
-        if @projector
-          coder["projectorclass"] = @projector.class.name.sub(/.*::/, "")
-          coder["projection_factory"] = @projector.projection_factory
-        end
+
+        return unless @projector
+
+        coder["projectorclass"] = @projector.class.name.sub(/.*::/, "")
+        coder["projection_factory"] = @projector.projection_factory
       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
-        initialize(coder["impl_prefix"],
+        cs_class = CoordSys::CONFIG.default_coord_sys_class
+        coord_sys = coder["cs"]&.then { |cs| cs_class.create_from_wkt(cs) }
+
+        initialize(
+          coder["impl_prefix"],
           has_z_coordinate: coder["has_z_coordinate"],
           has_m_coordinate: coder["has_m_coordinate"],
           srid: coder["srid"],
@@ -178,19 +191,19 @@ module RGeo
           buffer_resolution: coder["buffer_resolution"],
           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, proj_factory)
-            @projector = projector
-          end
-        end
-      end
+        proj_klass = coder["projectorclass"]
+        proj_factory = coder["projection_factory"]
 
-      # Returns the srid reported by this factory.
+        return unless proj_klass && proj_factory
 
-      attr_reader :srid
+        klass_ = RGeo::Geographic.const_get(proj_klass)
+
+        return unless klass_
+
+        projector = klass_.allocate
+        projector.set_factories(self, proj_factory)
+        @projector = projector
+      end
 
       # Returns true if this factory supports a projection.
 
@@ -213,9 +226,7 @@ module RGeo
 
       def project(geometry)
         return unless @projector && geometry
-        unless geometry.factory == self
-          raise Error::InvalidGeometry, "Wrong geometry type"
-        end
+        raise Error::InvalidGeometry, "Wrong geometry type" unless geometry.factory == self
         @projector.project(geometry)
       end
 
@@ -226,9 +237,11 @@ module RGeo
 
       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)
       end
 
@@ -249,12 +262,10 @@ module RGeo
       # projection limits are not known.
 
       def projection_limits_window
-        if @projector
-          unless defined?(@projection_limits_window)
-            @projection_limits_window = @projector.limits_window
-          end
-          @projection_limits_window
-        end
+        return @projection_limits_window if defined?(@projection_limits_window)
+        return unless @projector
+
+        @projection_limits_window = @projector.limits_window
       end
 
       # See RGeo::Feature::Factory#property
@@ -338,10 +349,6 @@ module RGeo
         @multi_polygon_class.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/geographic/interface.rb

@@ -102,16 +102,18 @@ module RGeo
         coord_sys = opts[:coord_sys]
         srid = opts[:srid]
         srid ||= coord_sys.authority_code if coord_sys
-        Geographic::Factory.new("Spherical",
+        Geographic::Factory.new(
+          "Spherical",
           has_z_coordinate: opts[:has_z_coordinate],
           has_m_coordinate: opts[:has_m_coordinate],
-          coord_sys: coord_sys || coord_sys_4055,
+          coord_sys: coord_sys || coord_sys4055,
           buffer_resolution: opts[:buffer_resolution],
           wkt_parser: opts[:wkt_parser],
           wkb_parser: opts[:wkb_parser],
           wkt_generator: opts[:wkt_generator],
           wkb_generator: opts[:wkb_generator],
-          srid: (srid || 4055).to_i)
+          srid: (srid || 4055).to_i
+        )
       end
 
       # Creates and returns a geographic factory that is designed for
@@ -185,19 +187,23 @@ module RGeo
       # options. See RGeo::Geos.factory for more details.
 
       def simple_mercator_factory(opts = {})
-        factory = Geographic::Factory.new("Projected",
-          coord_sys: coord_sys_4326,
+        factory = Geographic::Factory.new(
+          "Projected",
+          coord_sys: coord_sys4326,
           srid: 4326,
           wkt_parser: opts[:wkt_parser],
           wkb_parser: opts[:wkb_parser],
           wkt_generator: opts[:wkt_generator],
           wkb_generator: opts[:wkb_generator],
           has_z_coordinate: opts[:has_z_coordinate],
-          has_m_coordinate: opts[:has_m_coordinate])
-        projector = Geographic::SimpleMercatorProjector.new(factory,
+          has_m_coordinate: opts[:has_m_coordinate]
+        )
+        projector = Geographic::SimpleMercatorProjector.new(
+          factory,
           buffer_resolution: opts[:buffer_resolution],
           has_z_coordinate: opts[:has_z_coordinate],
-          has_m_coordinate: opts[:has_m_coordinate])
+          has_m_coordinate: opts[:has_m_coordinate]
+        )
         factory.projector = projector
         factory
       end
@@ -306,6 +312,7 @@ module RGeo
           if projection_coord_sys && !projection_coord_sys.projected?
             raise ArgumentError, "The :projection_factory's coord_sys is not a ProjectedCoordinateSystem."
           end
+
           # Determine geographic coordinate system. First check parameters.
           coord_sys = opts[:coord_sys]
           srid = opts[:srid]
@@ -314,18 +321,26 @@ module RGeo
           srid ||= coord_sys.authority_code if coord_sys
           srid ||= 4326
           # Now we should have all the coordinate system info.
-          factory = Geographic::Factory.new("Projected",
+          factory = Geographic::Factory.new(
+            "Projected",
             coord_sys: coord_sys,
             srid: srid.to_i,
             has_z_coordinate: projection_factory.property(:has_z_coordinate),
             has_m_coordinate: projection_factory.property(:has_m_coordinate),
             wkt_parser: opts[:wkt_parser], wkt_generator: opts[:wkt_generator],
-            wkb_parser: opts[:wkb_parser], wkb_generator: opts[:wkb_generator])
-          projector = Geographic::Projector.create_from_existing_factory(factory,
-            projection_factory)
+            wkb_parser: opts[:wkb_parser], wkb_generator: opts[:wkb_generator]
+          )
+          projector = Geographic::Projector.create_from_existing_factory(
+            factory,
+            projection_factory
+          )
         else
           # Determine projection coordinate system. First check the parameters.
-          projection_coord_sys_info = ImplHelper::Utils.setup_coord_sys(opts[:projection_srid], opts[:projection_coord_sys], opts[:projection_coord_sys_class])
+          projection_coord_sys_info = ImplHelper::Utils.setup_coord_sys(
+            opts[:projection_srid],
+            opts[:projection_coord_sys],
+            opts[:projection_coord_sys_class]
+          )
           projection_coord_sys = projection_coord_sys_info[:coord_sys]
           projection_srid = projection_coord_sys_info[:srid]
 
@@ -338,21 +353,25 @@ module RGeo
           srid ||= coord_sys.authority_code if coord_sys
           srid ||= 4326
           # Now we should have all the coordinate system info.
-          factory = Geographic::Factory.new("Projected",
+          factory = Geographic::Factory.new(
+            "Projected",
             coord_sys: coord_sys,
             srid: srid.to_i,
             has_z_coordinate: opts[:has_z_coordinate],
             has_m_coordinate: opts[:has_m_coordinate],
             wkt_parser: opts[:wkt_parser], wkt_generator: opts[:wkt_generator],
-            wkb_parser: opts[:wkb_parser], wkb_generator: opts[:wkb_generator])
-          projector = Geographic::Projector.create_from_opts(factory,
+            wkb_parser: opts[:wkb_parser], wkb_generator: opts[:wkb_generator]
+          )
+          projector = Geographic::Projector.create_from_opts(
+            factory,
             srid: projection_srid,
             coord_sys: projection_coord_sys,
             buffer_resolution: opts[:buffer_resolution],
             has_z_coordinate: opts[:has_z_coordinate],
             has_m_coordinate: opts[:has_m_coordinate],
             wkt_parser: opts[:wkt_parser], wkt_generator: opts[:wkt_generator],
-            wkb_parser: opts[:wkb_parser], wkb_generator: opts[:wkb_generator])
+            wkb_parser: opts[:wkb_parser], wkb_generator: opts[:wkb_generator]
+          )
         end
         factory.projector = projector
         factory
@@ -360,18 +379,16 @@ module RGeo
 
       private
 
-      def coord_sys_4055
-        unless defined?(@coord_sys_4055)
-          @coord_sys_4055 = CoordSys::CONFIG.default_coord_sys_class.create(4055)
-        end
-        @coord_sys_4055
+      def coord_sys4055
+        return @coord_sys4055 if defined?(@coord_sys4055)
+
+        @coord_sys4055 = CoordSys::CONFIG.default_coord_sys_class.create(4055)
       end
 
-      def coord_sys_4326
-        unless defined?(@coord_sys_4326)
-          @coord_sys_4326 = CoordSys::CONFIG.default_coord_sys_class.create(4326)
-        end
-        @coord_sys_4326
+      def coord_sys4326
+        return @coord_sys4326 if defined?(@coord_sys4326)
+
+        @coord_sys4326 = CoordSys::CONFIG.default_coord_sys_class.create(4326)
       end
     end
   end

data/lib/rgeo/geographic/projected_feature_methods.rb

@@ -219,9 +219,7 @@ module RGeo
       # Ensure projection is available.
       def init_geometry
         super
-        unless projection
-          raise Error::InvalidGeometry, "Polygon failed assertions"
-        end
+        raise Error::InvalidGeometry, "Polygon failed assertions" unless projection
       end
     end
 
@@ -231,9 +229,7 @@ module RGeo
       # Ensure projection is available.
       def init_geometry
         super
-        unless projection
-          raise Error::InvalidGeometry, "MultiPolygon failed assertions"
-        end
+        raise Error::InvalidGeometry, "MultiPolygon failed assertions" unless projection
       end
     end
   end