rgeo 0.4.0 → 0.5.0

data/lib/rgeo/feature/polygon.rb

@@ -5,10 +5,7 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
   module Feature
-
-
     # == SFS 1.1 Description
     #
     # A Polygon is a planar Surface defined by 1 exterior boundary and 0 or
@@ -48,11 +45,9 @@ module RGeo
     # class method (or === operator) defined in the Type module.
 
     module Polygon
-
       include Surface
       extend Type
 
-
       # === SFS 1.1 Description
       #
       # Returns the exterior ring of this Polygon.
@@ -65,7 +60,6 @@ module RGeo
         raise Error::UnsupportedOperation, "Method Polygon#exterior_ring not defined."
       end
 
-
       # === SFS 1.1 Description
       #
       # Returns the number of interiorRings in this Polygon.
@@ -78,7 +72,6 @@ module RGeo
         raise Error::UnsupportedOperation, "Method Polygon#num_interior_rings not defined."
       end
 
-
       # === SFS 1.1 Description
       #
       # Returns the Nth interiorRing for this Polygon as a LineString.
@@ -89,22 +82,16 @@ 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(_n_)
         raise Error::UnsupportedOperation, "Method Polygon#interior_ring_n not defined."
       end
 
-
       # Returns the interior rings as a (possibly empty) array of objects
       # that support the LinearRing interface.
 
       def interior_rings
         raise Error::UnsupportedOperation, "Method Polygon#interior_rings not defined."
       end
-
-
     end
-
-
   end
-
 end

data/lib/rgeo/feature/surface.rb

@@ -5,10 +5,7 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
   module Feature
-
-
     # == SFS 1.1 Description
     #
     # A Surface is a 2-dimensional geometric object.
@@ -37,11 +34,9 @@ module RGeo
     # Some implementations may support higher dimensional points.
 
     module Surface
-
       include Geometry
       extend Type
 
-
       # === SFS 1.1 Description
       #
       # The area of this Surface, as measured in the spatial reference
@@ -55,7 +50,6 @@ module RGeo
         raise Error::UnsupportedOperation, "Method Surface#area not defined."
       end
 
-
       # === SFS 1.1 Description
       #
       # The mathematical centroid for this Surface as a Point. The result
@@ -69,7 +63,6 @@ module RGeo
         raise Error::UnsupportedOperation, "Method Surface#centroid not defined."
       end
 
-
       # === SFS 1.1 Description
       #
       # A Point guaranteed to be on this Surface.
@@ -81,11 +74,6 @@ module RGeo
       def point_on_surface
         raise Error::UnsupportedOperation, "Method Surface#point_on_surface not defined."
       end
-
-
     end
-
-
   end
-
 end

data/lib/rgeo/feature/types.rb

@@ -5,10 +5,7 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
   module Feature
-
-
     # All geometry implementations MUST include this submodule.
     # This serves as a marker that may be used to test an object for
     # feature-ness.
@@ -16,7 +13,6 @@ module RGeo
     module Instance
     end
 
-
     # This module provides the API for geometry type objects. Technically
     # these objects are modules (such as ::RGeo::Feature::Point), but as
     # objects they respond to the methods documented here.
@@ -53,12 +49,9 @@ module RGeo
     #   ::RGeo::Feature::Type === object.geometry_type  # true
 
     module Type
-
-
       # Deprecated alias for RGeo::Feature::Instance
       Instance = Feature::Instance
 
-
       # Returns true if the given object is this type or a subtype
       # thereof, or if it is a feature object whose geometry_type is
       # this type or a subtype thereof.
@@ -67,12 +60,11 @@ module RGeo
       # Therefore, the is_a? method will generally not work.
 
       def check_type(rhs_)
-        rhs_ = rhs_.geometry_type if rhs_.kind_of?(Feature::Instance)
-        rhs_.kind_of?(Type) && (rhs_ == self || rhs_.include?(self))
+        rhs_ = rhs_.geometry_type if rhs_.is_a?(Feature::Instance)
+        rhs_.is_a?(Type) && (rhs_ == self || rhs_.include?(self))
       end
       alias_method :===, :check_type
 
-
       # Returns true if this type is the same type or a subtype of the
       # given type.
 
@@ -80,7 +72,6 @@ module RGeo
         self == type_ || self.include?(type_)
       end
 
-
       # Returns the supertype of this type. The supertype of Geometry
       # is nil.
 
@@ -88,42 +79,33 @@ module RGeo
         @supertype
       end
 
-
       # Iterates over the known immediate subtypes of this type.
 
       def each_immediate_subtype(&block_)
         @subtypes.each(&block_) if defined?(@subtypes) && @subtypes
       end
 
-
       # Returns the OpenGIS type name of this type. For example:
       #
       #   ::RGeo::Feature::Point.type_name  # "Point"
 
       def type_name
-        self.name.sub('RGeo::Feature::', '')
+        name.sub("RGeo::Feature::", "")
       end
       alias_method :to_s, :type_name
 
-
-      def _add_subtype(type_)  # :nodoc:
+      def _add_subtype(type_) # :nodoc:
         (@subtypes ||= []) << type_
       end
 
-
-      def self.extended(type_)  # :nodoc:
-        supertype_ = type_.included_modules.find{ |m_| m_.kind_of?(self) }
+      def self.extended(type_) # :nodoc:
+        supertype_ = type_.included_modules.find { |m_| m_.is_a?(self) }
         type_.instance_variable_set(:@supertype, supertype_)
         supertype_._add_subtype(type_) if supertype_
       end
-
-
     end
 
-
     class << self
-
-
       # Cast the given object according to the given parameters, if
       # possible, and return the resulting object. If the requested cast
       # is not possible, nil is returned.
@@ -232,22 +214,20 @@ module RGeo
             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_) })
+              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_) })
+              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_) })
+                                obj_.interior_rings.map { |r_| cast(r_, nfactory_, opts_) })
             elsif type_ == MultiPoint
-              nfactory_.multi_point(obj_.map{ |g_| cast(g_, nfactory_, opts_) })
+              nfactory_.multi_point(obj_.map { |g_| cast(g_, nfactory_, opts_) })
             elsif type_ == MultiLineString
-              nfactory_.multi_line_string(obj_.map{ |g_| cast(g_, nfactory_, opts_) })
+              nfactory_.multi_line_string(obj_.map { |g_| cast(g_, nfactory_, opts_) })
             elsif type_ == MultiPolygon
-              nfactory_.multi_polygon(obj_.map{ |g_| cast(g_, nfactory_, opts_) })
+              nfactory_.multi_polygon(obj_.map { |g_| cast(g_, nfactory_, opts_) })
             elsif type_ == GeometryCollection
-              nfactory_.collection(obj_.map{ |g_| cast(g_, nfactory_, opts_) })
-            else
-              nil
+              nfactory_.collection(obj_.map { |g_| cast(g_, nfactory_, opts_) })
             end
           end
         else
@@ -255,72 +235,50 @@ module RGeo
           if ntype_ == Point && (type_ == MultiPoint || type_ == GeometryCollection) ||
               (ntype_ == Line || ntype_ == LineString || ntype_ == LinearRing) && (type_ == MultiLineString || type_ == GeometryCollection) ||
               ntype_ == Polygon && (type_ == MultiPolygon || type_ == GeometryCollection)
-          then
             if obj_.num_geometries == 1
               cast(obj_.geometry_n(0), nfactory_, ntype_, opts_)
-            else
-              nil
             end
           elsif ntype_ == Point
             nil
           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_))
-            else
-              nil
             end
           elsif ntype_ == LinearRing
             if type_ == LineString
-              nfactory_.linear_ring(obj_.points.map{ |p_| cast(p_, nfactory_, opts_) })
-            else
-              nil
+              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_) })
-            else
-              nil
+              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{ |g_| cast(p_, nfactory_, opts_) })
-            else
-              nil
+              nfactory_.multi_point(obj_.map { |_g_| 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{ |g_| cast(p_, nfactory_, opts_) })
-            else
-              nil
+              nfactory_.multi_line_string(obj_.map { |_g_| 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{ |g_| cast(p_, nfactory_, opts_) })
-            else
-              nil
+              nfactory_.multi_polygon(obj_.map { |_g_| cast(p_, nfactory_, opts_) })
             end
           elsif ntype_ == GeometryCollection
             if type_ == MultiPoint || type_ == MultiLineString || type_ == MultiPolygon
-              nfactory_.collection(obj_.map{ |g_| cast(p_, nfactory_, opts_) })
+              nfactory_.collection(obj_.map { |_g_| cast(p_, nfactory_, opts_) })
             else
               nfactory_.collection([cast(obj_, nfactory_, opts_)])
             end
-          else
-            nil
           end
         end
       end
-
-
     end
-
-
   end
-
 end

data/lib/rgeo/geographic.rb

@@ -5,8 +5,6 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
-
   # The Geographic implementation actually comprises a suite of
   # implementations with one common feature: they represent geographic
   # latitude/longitude coordinates measured in degrees. The "x"
@@ -27,19 +25,16 @@ module RGeo
 
   module Geographic
   end
-
-
 end
 
-
 # Implementation files.
-require 'rgeo/geographic/factory'
-require 'rgeo/geographic/projected_window'
-require 'rgeo/geographic/interface'
-require 'rgeo/geographic/spherical_math'
-require 'rgeo/geographic/spherical_feature_methods'
-require 'rgeo/geographic/spherical_feature_classes'
-require 'rgeo/geographic/proj4_projector'
-require 'rgeo/geographic/simple_mercator_projector'
-require 'rgeo/geographic/projected_feature_methods'
-require 'rgeo/geographic/projected_feature_classes'
+require "rgeo/geographic/factory"
+require "rgeo/geographic/projected_window"
+require "rgeo/geographic/interface"
+require "rgeo/geographic/spherical_math"
+require "rgeo/geographic/spherical_feature_methods"
+require "rgeo/geographic/spherical_feature_classes"
+require "rgeo/geographic/proj4_projector"
+require "rgeo/geographic/simple_mercator_projector"
+require "rgeo/geographic/projected_feature_methods"
+require "rgeo/geographic/projected_feature_classes"

data/lib/rgeo/geographic/factory.rb

@@ -5,20 +5,15 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
   module Geographic
-
-
     # 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
 
-
-      def initialize(impl_prefix_, opts_={})  # :nodoc:
+      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")
@@ -34,15 +29,19 @@ module RGeo
         @srid = (opts_[:srid] || 4326).to_i
         @proj4 = opts_[:proj4]
         if CoordSys::Proj4.supported?
-          if @proj4.kind_of?(::String) || @proj4.kind_of?(::Hash)
+          if @proj4.is_a?(::String) || @proj4.is_a?(::Hash)
             @proj4 = CoordSys::Proj4.create(@proj4)
           end
         else
           @proj4 = nil
         end
         @coord_sys = opts_[:coord_sys]
-        if @coord_sys.kind_of?(::String)
-          @coord_sys = CoordSys::CS.create_from_wkt(@coord_sys) rescue nil
+        if @coord_sys.is_a?(::String)
+          @coord_sys = begin
+                         CoordSys::CS.create_from_wkt(@coord_sys)
+                       rescue
+                         nil
+                       end
         end
         @lenient_assertions = opts_[:uses_lenient_assertions] ? true : false
         @buffer_resolution = opts_[:buffer_resolution].to_i
@@ -53,7 +52,7 @@ module RGeo
         when ::Hash
           @wkt_generator = WKRep::WKTGenerator.new(wkt_generator_)
         else
-          @wkt_generator = WKRep::WKTGenerator.new(:convert_case => :upper)
+          @wkt_generator = WKRep::WKTGenerator.new(convert_case: :upper)
         end
         wkb_generator_ = opts_[:wkb_generator]
         case wkb_generator_
@@ -79,12 +78,10 @@ module RGeo
         @projector = nil
       end
 
-
-      def _set_projector(projector_)  # :nodoc:
+      def _set_projector(projector_) # :nodoc:
         @projector = projector_
       end
 
-
       # Equivalence test.
 
       def eql?(rhs_)
@@ -96,65 +93,67 @@ module RGeo
       end
       alias_method :==, :eql?
 
-
       # Standard hash code
 
       def hash
         @hash ||= [@impl_prefix, @support_z, @support_m, @proj4].hash
       end
 
-
       # Marshal support
 
-      def marshal_dump  # :nodoc:
+      def marshal_dump # :nodoc:
         hash_ = {
-          'pref' => @impl_prefix,
-          'hasz' => @support_z,
-          'hasm' => @support_m,
-          'srid' => @srid,
-          'wktg' => @wkt_generator._properties,
-          'wkbg' => @wkb_generator._properties,
-          'wktp' => @wkt_parser._properties,
-          'wkbp' => @wkb_parser._properties,
-          'lena' => @lenient_assertions,
-          'bufr' => @buffer_resolution,
+          "pref" => @impl_prefix,
+          "hasz" => @support_z,
+          "hasm" => @support_m,
+          "srid" => @srid,
+          "wktg" => @wkt_generator._properties,
+          "wkbg" => @wkb_generator._properties,
+          "wktp" => @wkt_parser._properties,
+          "wkbp" => @wkb_parser._properties,
+          "lena" => @lenient_assertions,
+          "bufr" => @buffer_resolution
         }
-        hash_['proj4'] = @proj4.marshal_dump if @proj4
-        hash_['cs'] = @coord_sys.to_wkt if @coord_sys
+        hash_["proj4"] = @proj4.marshal_dump if @proj4
+        hash_["cs"] = @coord_sys.to_wkt if @coord_sys
         if @projector
-          hash_['prjc'] = @projector.class.name.sub(/.*::/, '')
-          hash_['prjf'] = @projector.projection_factory
+          hash_["prjc"] = @projector.class.name.sub(/.*::/, "")
+          hash_["prjf"] = @projector.projection_factory
         end
         hash_
       end
 
-      def marshal_load(data_)  # :nodoc:
-        if CoordSys::Proj4.supported? && (proj4_data_ = data_['proj4'])
+      def marshal_load(data_) # :nodoc:
+        if CoordSys::Proj4.supported? && (proj4_data_ = data_["proj4"])
           proj4_ = CoordSys::Proj4.allocate
           proj4_.marshal_load(proj4_data_)
         else
           proj4_ = nil
         end
-        if (coord_sys_data_ = data_['cs'])
+        if (coord_sys_data_ = data_["cs"])
           coord_sys_ = CoordSys::CS.create_from_wkt(coord_sys_data_)
         else
           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']),
-          :uses_lenient_assertions => data_['lena'],
-          :buffer_resolution => data_['bufr'],
-          :proj4 => proj4_,
-          :coord_sys => coord_sys_
-        )
-        if (projklass_ = data_['prjc']) && (projfactory_ = data_['prjf'])
-          klass_ = ::RGeo::Geographic.const_get(projklass_) rescue nil
+        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"]),
+          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
           if klass_
             projector_ = klass_.allocate
             projector_._set_factories(self, projfactory_)
@@ -163,61 +162,64 @@ module RGeo
         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_
+          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_["projector_class"] = @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"])
           if proj4_data_.is_a?(::Hash)
-            proj4_ = CoordSys::Proj4.create(proj4_data_['proj4'], :radians => proj4_data_['radians'])
+            proj4_ = CoordSys::Proj4.create(proj4_data_["proj4"], radians: proj4_data_["radians"])
           else
             proj4_ = CoordSys::Proj4.create(proj4_data_.to_s)
           end
         else
           proj4_ = nil
         end
-        if (coord_sys_data_ = coder_['cs'])
+        if (coord_sys_data_ = coder_["cs"])
           coord_sys_ = CoordSys::CS.create_from_wkt(coord_sys_data_.to_s)
         else
           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_ = ::RGeo::Geographic.const_get(projklass_) rescue nil
+        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
           if klass_
             projector_ = klass_.allocate
             projector_._set_factories(self, projfactory_)
@@ -226,13 +228,9 @@ module RGeo
         end
       end
 
-
       # Returns the srid reported by this factory.
 
-      def srid
-        @srid
-      end
-
+      attr_reader :srid
 
       # Returns true if this factory supports a projection.
 
@@ -240,7 +238,6 @@ module RGeo
         !@projector.nil?
       end
 
-
       # Returns the factory for the projected coordinate space,
       # or nil if this factory does not support a projection.
 
@@ -248,7 +245,6 @@ module RGeo
         @projector ? @projector.projection_factory : nil
       end
 
-
       # Projects the given geometry into the projected coordinate space,
       # and returns the projected geometry.
       # Returns nil if this factory does not support a projection.
@@ -258,12 +254,11 @@ module RGeo
       def project(geometry_)
         return nil unless @projector && geometry_
         unless geometry_.factory == self
-          raise Error::InvalidGeometry, 'Wrong geometry type'
+          raise Error::InvalidGeometry, "Wrong geometry type"
         end
         @projector.project(geometry_)
       end
 
-
       # Reverse-projects the given geometry from the projected coordinate
       # space into lat-long space.
       # Raises Error::InvalidGeometry if the given geometry is not of
@@ -272,12 +267,11 @@ module RGeo
       def unproject(geometry_)
         return nil unless geometry_
         unless @projector && @projector.projection_factory == geometry_.factory
-          raise Error::InvalidGeometry, 'You can unproject only features that are in the projected coordinate space.'
+          raise Error::InvalidGeometry, "You can unproject only features that are in the projected coordinate space."
         end
         @projector.unproject(geometry_)
       end
 
-
       # Returns true if this factory supports a projection and the
       # projection wraps its x (easting) direction. For example, a
       # Mercator projection wraps, but a local projection that is valid
@@ -289,7 +283,6 @@ module RGeo
         @projector ? @projector.wraps? : nil
       end
 
-
       # Returns a ProjectedWindow specifying the limits of the domain of
       # the projection space.
       # Returns nil if this factory does not support a projection, or the
@@ -301,12 +294,9 @@ module RGeo
             @projection_limits_window = @projector.limits_window
           end
           @projection_limits_window
-        else
-          nil
         end
       end
 
-
       # See ::RGeo::Feature::Factory#property
 
       def property(name_)
@@ -321,151 +311,140 @@ module RGeo
           @buffer_resolution
         when :is_geographic
           true
-        else
-          nil
         end
       end
 
-
       # See ::RGeo::Feature::Factory#parse_wkt
 
       def parse_wkt(str_)
         @wkt_parser.parse(str_)
       end
 
-
       # See ::RGeo::Feature::Factory#parse_wkb
 
       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
+        @point_class.new(self, x_, y_, *extra_)
+      rescue
+        nil
       end
 
-
       # See ::RGeo::Feature::Factory#line_string
 
       def line_string(points_)
-        @line_string_class.new(self, points_) rescue nil
+        @line_string_class.new(self, points_)
+      rescue
+        nil
       end
 
-
       # See ::RGeo::Feature::Factory#line
 
       def line(start_, end_)
-        @line_class.new(self, start_, end_) rescue nil
+        @line_class.new(self, start_, end_)
+      rescue
+        nil
       end
 
-
       # See ::RGeo::Feature::Factory#linear_ring
 
       def linear_ring(points_)
-        @linear_ring_class.new(self, points_) rescue nil
+        @linear_ring_class.new(self, points_)
+      rescue
+        nil
       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_)
+      rescue
+        nil
       end
 
-
       # See ::RGeo::Feature::Factory#collection
 
       def collection(elems_)
-        @geometry_collection_class.new(self, elems_) rescue nil
+        @geometry_collection_class.new(self, elems_)
+      rescue
+        nil
       end
 
-
       # See ::RGeo::Feature::Factory#multi_point
 
       def multi_point(elems_)
-        @multi_point_class.new(self, elems_) rescue nil
+        @multi_point_class.new(self, elems_)
+      rescue
+        nil
       end
 
-
       # See ::RGeo::Feature::Factory#multi_line_string
 
       def multi_line_string(elems_)
-        @multi_line_string_class.new(self, elems_) rescue nil
+        @multi_line_string_class.new(self, elems_)
+      rescue
+        nil
       end
 
-
       # See ::RGeo::Feature::Factory#multi_polygon
 
       def multi_polygon(elems_)
-        @multi_polygon_class.new(self, elems_) rescue nil
+        @multi_polygon_class.new(self, elems_)
+      rescue
+        nil
       end
 
-
       # See ::RGeo::Feature::Factory#proj4
 
-      def proj4
-        @proj4
-      end
-
+      attr_reader :proj4
 
       # See ::RGeo::Feature::Factory#coord_sys
 
-      def coord_sys
-        @coord_sys
-      end
-
+      attr_reader :coord_sys
 
       def _generate_wkt(obj_)  # :nodoc:
         @wkt_generator.generate(obj_)
       end
 
-
       def _generate_wkb(obj_)  # :nodoc:
         @wkb_generator.generate(obj_)
       end
 
-
-      def _marshal_wkb_generator  # :nodoc:
+      def _marshal_wkb_generator # :nodoc:
         unless defined?(@marshal_wkb_generator)
           @marshal_wkb_generator = ::RGeo::WKRep::WKBGenerator.new(
-            :type_format => :wkb12)
+            type_format: :wkb12)
         end
         @marshal_wkb_generator
       end
 
-
-      def _marshal_wkb_parser  # :nodoc:
+      def _marshal_wkb_parser # :nodoc:
         unless defined?(@marshal_wkb_parser)
           @marshal_wkb_parser = ::RGeo::WKRep::WKBParser.new(self,
-            :support_wkb12 => true)
+            support_wkb12: true)
         end
         @marshal_wkb_parser
       end
 
-
-      def _psych_wkt_generator  # :nodoc:
+      def _psych_wkt_generator # :nodoc:
         unless defined?(@psych_wkt_generator)
           @psych_wkt_generator = ::RGeo::WKRep::WKTGenerator.new(
-            :tag_format => :wkt12)
+            tag_format: :wkt12)
         end
         @psych_wkt_generator
       end
 
-
-      def _psych_wkt_parser  # :nodoc:
+      def _psych_wkt_parser # :nodoc:
         unless defined?(@psych_wkt_parser)
           @psych_wkt_parser = ::RGeo::WKRep::WKTParser.new(self,
-            :support_wkt12 => true, :support_ewkt => true)
+            support_wkt12: true, support_ewkt: true)
         end
         @psych_wkt_parser
       end
-
-
     end
-
   end
-
 end