rgeo 1.1.2 → 2.0.0

data/lib/rgeo/cartesian/feature_classes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Cartesian feature classes
@@ -12,8 +14,6 @@ module RGeo
       include RGeo::ImplHelper::BasicPointMethods
       include RGeo::Cartesian::GeometryMethods
       include RGeo::Cartesian::PointMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::Point).include_in_class(self, true)
     end
 
     class LineStringImpl # :nodoc:
@@ -22,8 +22,6 @@ module RGeo
       include RGeo::ImplHelper::BasicLineStringMethods
       include RGeo::Cartesian::GeometryMethods
       include RGeo::Cartesian::LineStringMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::LineString).include_in_class(self, true)
     end
 
     class LineImpl # :nodoc:
@@ -33,8 +31,6 @@ module RGeo
       include RGeo::ImplHelper::BasicLineMethods
       include RGeo::Cartesian::GeometryMethods
       include RGeo::Cartesian::LineStringMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::Line).include_in_class(self, true)
     end
 
     class LinearRingImpl # :nodoc:
@@ -44,8 +40,6 @@ module RGeo
       include RGeo::ImplHelper::BasicLinearRingMethods
       include RGeo::Cartesian::GeometryMethods
       include RGeo::Cartesian::LineStringMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::LinearRing).include_in_class(self, true)
     end
 
     class PolygonImpl # :nodoc:
@@ -53,8 +47,6 @@ module RGeo
       include RGeo::ImplHelper::BasicGeometryMethods
       include RGeo::ImplHelper::BasicPolygonMethods
       include RGeo::Cartesian::GeometryMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::Polygon).include_in_class(self, true)
     end
 
     class GeometryCollectionImpl # :nodoc:
@@ -62,8 +54,6 @@ module RGeo
       include RGeo::ImplHelper::BasicGeometryMethods
       include RGeo::ImplHelper::BasicGeometryCollectionMethods
       include RGeo::Cartesian::GeometryMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::GeometryCollection).include_in_class(self, true)
     end
 
     class MultiPointImpl # :nodoc:
@@ -72,8 +62,6 @@ module RGeo
       include RGeo::ImplHelper::BasicGeometryCollectionMethods
       include RGeo::ImplHelper::BasicMultiPointMethods
       include RGeo::Cartesian::GeometryMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPoint).include_in_class(self, true)
     end
 
     class MultiLineStringImpl # :nodoc:
@@ -83,8 +71,6 @@ module RGeo
       include RGeo::ImplHelper::BasicMultiLineStringMethods
       include RGeo::Cartesian::GeometryMethods
       include RGeo::Cartesian::MultiLineStringMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiLineString).include_in_class(self, true)
     end
 
     class MultiPolygonImpl # :nodoc:
@@ -93,8 +79,6 @@ module RGeo
       include RGeo::ImplHelper::BasicGeometryCollectionMethods
       include RGeo::ImplHelper::BasicMultiPolygonMethods
       include RGeo::Cartesian::GeometryMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPolygon).include_in_class(self, true)
     end
   end
 end

data/lib/rgeo/cartesian/feature_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Cartesian common methods
@@ -17,71 +19,67 @@ module RGeo
     end
 
     module PointMethods # :nodoc:
-      def distance(rhs_)
-        rhs_ = RGeo::Feature.cast(rhs_, @factory)
-        case rhs_
+      def distance(rhs)
+        rhs = RGeo::Feature.cast(rhs, @factory)
+        case rhs
         when PointImpl
-          dx_ = @x - rhs_.x
-          dy_ = @y - rhs_.y
-          ::Math.sqrt(dx_ * dx_ + dy_ * dy_)
+          dx = @x - rhs.x
+          dy = @y - rhs.y
+          Math.sqrt(dx * dx + dy * dy)
         else
           super
         end
       end
 
-      def buffer(distance_)
-        point_count_ = factory.property(:buffer_resolution) * 4
-        angle_ = -::Math::PI * 2.0 / point_count_
-        points_ = (0...point_count_).map do |i_|
-          r_ = angle_ * i_
-          factory.point(@x + distance_ * ::Math.cos(r_), @y + distance_ * ::Math.sin(r_))
+      def buffer(distance)
+        point_count = factory.property(:buffer_resolution) * 4
+        angle = -::Math::PI * 2.0 / point_count
+        points = (0...point_count).map do |i|
+          r = angle * i
+          factory.point(@x + distance * Math.cos(r), @y + distance * Math.sin(r))
         end
-        factory.polygon(factory.linear_ring(points_))
+        factory.polygon(factory.linear_ring(points))
       end
     end
 
     module LineStringMethods # :nodoc:
-      def _segments
-        unless defined?(@segments)
-          @segments = (0..num_points - 2).map do |i_|
-            Segment.new(point_n(i_), point_n(i_ + 1))
-          end
+      def segments
+        @segments ||= (0..num_points - 2).map do |i|
+          Segment.new(point_n(i), point_n(i + 1))
         end
-        @segments
       end
 
       def is_simple?
-        segs_ = _segments
-        len_ = segs_.length
-        return false if segs_.any?(&:degenerate?)
-        return true if len_ == 1
-        return segs_[0].s != segs_[1].e if len_ == 2
-        segs_.each_with_index do |seg_, index_|
-          nindex_ = index_ + 1
-          nindex_ = nil if nindex_ == len_
-          return false if nindex_ && seg_.contains_point?(segs_[nindex_].e)
-          pindex_ = index_ - 1
-          pindex_ = nil if pindex_ < 0
-          return false if pindex_ && seg_.contains_point?(segs_[pindex_].s)
-          next unless nindex_
-          oindex_ = nindex_ + 1
-          while oindex_ < len_
-            oseg_ = segs_[oindex_]
-            return false if !(index_ == 0 && oindex_ == len_ - 1 && seg_.s == oseg_.e) && seg_.intersects_segment?(oseg_)
-            oindex_ += 1
+        len = segments.length
+        return false if segments.any?(&:degenerate?)
+        return true if len == 1
+        return segments[0].s != segments[1].e if len == 2
+        segments.each_with_index do |seg, index|
+          nindex = index + 1
+          nindex = nil if nindex == len
+          return false if nindex && seg.contains_point?(segments[nindex].e)
+          pindex = index - 1
+          pindex = nil if pindex < 0
+          return false if pindex && seg.contains_point?(segments[pindex].s)
+          next unless nindex
+          oindex = nindex + 1
+          while oindex < len
+            oseg = segments[oindex]
+            return false if !(index == 0 && oindex == len - 1 && seg.s == oseg.e) && seg.intersects_segment?(oseg)
+            oindex += 1
           end
         end
         true
       end
 
       def length
-        _segments.inject(0.0) { |sum_, seg_| sum_ + seg_.length }
+        segments.inject(0.0) { |sum, seg| sum + seg.length }
       end
     end
 
     module MultiLineStringMethods # :nodoc:
       def length
-        inject(0.0) { |sum_, geom_| sum_ + geom_.length }
+        inject(0.0) { |sum, geom| sum + geom.length }
       end
     end
   end

data/lib/rgeo/cartesian/interface.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Cartesian toplevel interface
@@ -24,11 +26,11 @@ module RGeo
       # RGeo::Cartesian.simple_factory for details. Unsupported options
       # are ignored.
 
-      def preferred_factory(opts_ = {})
+      def preferred_factory(opts = {})
         if RGeo::Geos.supported?
-          RGeo::Geos.factory(opts_)
+          RGeo::Geos.factory(opts)
         else
-          simple_factory(opts_)
+          simple_factory(opts)
         end
       end
       alias factory preferred_factory
@@ -102,8 +104,8 @@ module RGeo
       #   Default is the empty hash, indicating the default configuration
       #   for WKRep::WKBGenerator.
 
-      def simple_factory(opts_ = {})
-        Cartesian::Factory.new(opts_)
+      def simple_factory(opts = {})
+        Cartesian::Factory.new(opts)
       end
 
       # Returns a Feature::FactoryGenerator that creates preferred
@@ -114,8 +116,8 @@ module RGeo
       # an SRID and it will automatically fetch the appropriate Proj4
       # and CoordSys objects.
 
-      def preferred_factory_generator(defaults_ = {})
-        ::Proc.new { |c_| preferred_factory(defaults_.merge(c_)) }
+      def preferred_factory_generator(defaults = {})
+        proc { |c| preferred_factory(defaults.merge(c)) }
       end
       alias factory_generator preferred_factory_generator
 
@@ -127,8 +129,8 @@ module RGeo
       # an SRID and it will automatically fetch the appropriate Proj4
       # and CoordSys objects.
 
-      def simple_factory_generator(defaults_ = {})
-        ::Proc.new { |c_| simple_factory(defaults_.merge(c_)) }
+      def simple_factory_generator(defaults = {})
+        proc { |c| simple_factory(defaults.merge(c)) }
       end
     end
   end

data/lib/rgeo/coord_sys.rb

@@ -1,9 +1,18 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Coordinate systems for RGeo
 #
 # -----------------------------------------------------------------------------
 
+require "rgeo/coord_sys/cs/factories"
+require "rgeo/coord_sys/cs/entities"
+require "rgeo/coord_sys/cs/wkt_parser"
+require "rgeo/coord_sys/srs_database/entry"
+require "rgeo/coord_sys/srs_database/url_reader"
+require "rgeo/coord_sys/srs_database/sr_org"
+
 module RGeo
   # This module provides data structures and tools related to coordinate
   # systems and coordinate transforms. It comprises the following parts:
@@ -37,11 +46,3 @@ module RGeo
     end
   end
 end
-
-# Implementation files
-require "rgeo/coord_sys/cs/factories"
-require "rgeo/coord_sys/cs/entities"
-require "rgeo/coord_sys/cs/wkt_parser"
-require "rgeo/coord_sys/srs_database/interface.rb"
-require "rgeo/coord_sys/srs_database/url_reader.rb"
-require "rgeo/coord_sys/srs_database/sr_org.rb"

data/lib/rgeo/coord_sys/cs/entities.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # OGC CS objects for RGeo
@@ -148,8 +150,8 @@ module RGeo
         # Tests for equality. Two objects are defined as equal if they
         # have the same type (class) and the same WKT representation.
 
-        def eql?(rhs_)
-          rhs_.class == self.class && rhs_.to_wkt == to_wkt
+        def eql?(rhs)
+          rhs.class == self.class && rhs.to_wkt == to_wkt
         end
         alias == eql?
 
@@ -165,33 +167,25 @@ module RGeo
           to_wkt
         end
 
-        # Computes the WKT representation. Options include:
+        # Return the WKT representation.
         #
-        # [<tt>:standard_brackets</tt>]
-        #   If set to true, outputs parentheses rather than square
+        # <tt>:standard_brackets</tt>
+        #   If true, outputs parentheses rather than square
         #   brackets. Default is false.
-
-        def to_wkt(opts_ = {})
-          if opts_[:standard_brackets]
-            @standard_wkt ||= _to_wkt("(", ")")
-          else
-            @square_wkt ||= _to_wkt("[", "]")
-          end
-        end
-
-        def _to_wkt(open_, close_) # :nodoc:
-          content_ = _wkt_content(open_, close_).map { |obj_| ",#{obj_}" }.join
+        def to_wkt(standard_brackets = false)
+          open, close = brackets(standard_brackets)
+          content = wkt_content(standard_brackets).map { |obj| ",#{obj}" }.join
           if defined?(@authority) && @authority
-            authority_ = ",AUTHORITY#{open_}#{@authority.inspect},#{@authority_code.inspect}#{close_}"
+            authority = ",AUTHORITY#{open}#{@authority.inspect},#{@authority_code.inspect}#{close}"
           else
-            authority_ = ""
+            authority = ""
           end
           if defined?(@extensions) && @extensions
-            extensions_ = @extensions.map { |k_, v_| ",EXTENSION#{open_}#{k_.inspect},#{v_.inspect}#{close_}" }.join
+            extensions = @extensions.map { |k, v| ",EXTENSION#{open}#{k.inspect},#{v.inspect}#{close}" }.join
           else
-            extensions_ = ""
+            extensions = ""
           end
-          "#{_wkt_typename}#{open_}#{@name.inspect}#{content_}#{extensions_}#{authority_}#{close_}"
+          "#{wkt_typename}#{open}#{@name.inspect}#{content}#{extensions}#{authority}#{close}"
         end
 
         # Marshal support
@@ -200,38 +194,44 @@ module RGeo
           to_wkt
         end
 
-        def marshal_load(data_) # :nodoc:
-          data_ = data_["wkt"] if data_.is_a?(::Hash)
-          temp_ = CS.create_from_wkt(data_)
-          if temp_.class == self.class
-            temp_.instance_variables.each do |iv_|
-              instance_variable_set(iv_, temp_.instance_variable_get(iv_))
+        def marshal_load(data) # :nodoc:
+          data = data["wkt"] if data.is_a?(Hash)
+          temp = CS.create_from_wkt(data)
+          if temp.class == self.class
+            temp.instance_variables.each do |iv|
+              instance_variable_set(iv, temp.instance_variable_get(iv))
             end
           else
-            raise ::TypeError, "Bad Marshal data"
+            raise TypeError, "Bad Marshal data"
           end
         end
 
         # Psych support
 
-        def encode_with(coder_) # :nodoc:
-          coder_["wkt"] = to_wkt
+        def encode_with(coder) # :nodoc:
+          coder["wkt"] = to_wkt
         end
 
-        def init_with(coder_) # :nodoc:
-          temp_ = CS.create_from_wkt(coder_.type == :scalar ? coder_.scalar : coder_["wkt"])
-          if temp_.class == self.class
-            temp_.instance_variables.each do |iv_|
-              instance_variable_set(iv_, temp_.instance_variable_get(iv_))
+        def init_with(coder) # :nodoc:
+          temp = CS.create_from_wkt(coder.type == :scalar ? coder.scalar : coder["wkt"])
+          if temp.class == self.class
+            temp.instance_variables.each do |iv|
+              instance_variable_set(iv, temp.instance_variable_get(iv))
             end
           else
-            raise ::TypeError, "Bad YAML data"
+            raise TypeError, "Bad YAML data"
           end
         end
 
         class << self
           private :new
         end
+
+        private
+
+        def brackets(standard)
+          standard ? %w[( )] : %w([ ])
+        end
       end
 
       # == OGC spec description
@@ -241,16 +241,16 @@ module RGeo
 
       class AxisInfo < Base
         # :stopdoc:
-        NAMES_BY_VALUE = %w(OTHER NORTH SOUTH EAST WEST UP DOWN)
+        NAMES_BY_VALUE = %w[OTHER NORTH SOUTH EAST WEST UP DOWN].freeze
         # :startdoc:
 
-        def initialize(name_, orientation_) # :nodoc:
-          @name = name_
-          case orientation_
-          when ::String, ::Symbol
-            @orientation = NAMES_BY_VALUE.index(orientation_.to_s.upcase).to_i
+        def initialize(name, orientation) # :nodoc:
+          @name = name
+          case orientation
+          when String, Symbol
+            @orientation = NAMES_BY_VALUE.index(orientation.to_s.upcase).to_i
           else
-            @orientation = orientation_.to_i
+            @orientation = orientation.to_i
           end
         end
 
@@ -261,14 +261,10 @@ module RGeo
         # Gets enumerated value for orientation.
         attr_reader :orientation
 
-        def _wkt_typename # :nodoc:
+        def wkt_typename
           "AXIS"
         end
 
-        def _wkt_content(_open_, _close_) # :nodoc:
-          [NAMES_BY_VALUE[@orientation]]
-        end
-
         class << self
           # Creates an AxisInfo. you must pass the human readable name for
           # the axis (e.g. "X", "Y", "Long", "Lat", or other short string)
@@ -278,10 +274,16 @@ module RGeo
           # "<tt>UP</tt>", and "<tt>DOWN</tt>", or the corresponding
           # integer values 0-5.
 
-          def create(name_, orientation_)
-            new(name_, orientation_)
+          def create(name, orientation)
+            new(name, orientation)
           end
         end
+
+        private
+
+        def wkt_content(_)
+          [NAMES_BY_VALUE[@orientation]]
+        end
       end
 
       # == OGC spec description
@@ -293,9 +295,9 @@ module RGeo
       # system that the projected coordinate system is based on.
 
       class ProjectionParameter < Base
-        def initialize(name_, value_) # :nodoc:
-          @name = name_
-          @value = value_.to_f
+        def initialize(name, value) # :nodoc:
+          @name = name
+          @value = value.to_f
         end
 
         # The parameter name.
@@ -304,21 +306,23 @@ module RGeo
         # The parameter value.
         attr_reader :value
 
-        def _wkt_typename # :nodoc:
+        def wkt_typename
           "PARAMETER"
         end
 
-        def _wkt_content(_open_, _close_) # :nodoc:
-          [@value]
-        end
-
         class << self
           # Create a parameter given the name and value.
 
-          def create(name_, value_)
-            new(name_, value_)
+          def create(name, value)
+            new(name, value)
           end
         end
+
+        private
+
+        def wkt_content(_)
+          [@value]
+        end
       end
 
       # == OGC spec description
@@ -329,14 +333,14 @@ module RGeo
       # points East, and the Z axis points North.
 
       class WGS84ConversionInfo < Base
-        def initialize(dx_, dy_, dz_, ex_, ey_, ez_, ppm_) # :nodoc:
-          @dx = dx_.to_f
-          @dy = dy_.to_f
-          @dz = dz_.to_f
-          @ex = ex_.to_f
-          @ey = ey_.to_f
-          @ez = ez_.to_f
-          @ppm = ppm_.to_f
+        def initialize(dx, dy, dz, ex, ey, ez, ppm) # :nodoc:
+          @dx = dx.to_f
+          @dy = dy.to_f
+          @dz = dz.to_f
+          @ex = ex.to_f
+          @ey = ey.to_f
+          @ez = ez.to_f
+          @ppm = ppm.to_f
         end
 
         # Bursa Wolf shift in meters.
@@ -360,8 +364,9 @@ module RGeo
         # Bursa Wolf scaling in in parts per million.
         attr_reader :ppm
 
-        def _to_wkt(open_, close_) # :nodoc:
-          "TOWGS84#{open_}#{@dx},#{@dy},#{@dz},#{@ex},#{@ey},#{@ez},#{@ppm}#{close_}"
+        def to_wkt(standard_brackets = false)
+          open, close = brackets(standard_brackets)
+          "TOWGS84#{open}#{@dx},#{@dy},#{@dz},#{@ex},#{@ey},#{@ez},#{@ppm}#{close}"
         end
 
         class << self
@@ -370,8 +375,8 @@ module RGeo
           # The Bursa Wolf shift should be in meters, the rotation in arc
           # seconds, and the scaling in parts per million.
 
-          def create(dx_, dy_, dz_, ex_, ey_, ez_, ppm_)
-            new(dx_, dy_, dz_, ex_, ey_, ez_, ppm_)
+          def create(dx, dy, dz, ex, ey, ez, ppm)
+            new(dx, dy, dz, ex, ey, ez, ppm)
           end
         end
       end
@@ -381,7 +386,7 @@ module RGeo
       # A base interface for metadata applicable to coordinate system
       # objects.
       #
-      # The metadata items "Abbreviation"’, "Alias", "Authority",
+      # The metadata items "Abbreviation", "Alias", "Authority",
       # "AuthorityCode", "Name" and "Remarks" were specified in the Simple
       # Features interfaces, so they have been kept here.
       #
@@ -416,17 +421,15 @@ module RGeo
       # * <b>extensions</b>: a hash of extension keys and values
 
       class Info < Base
-        def initialize(name_, authority_ = nil, authority_code_ = nil, abbreviation_ = nil, alias_ = nil, remarks_ = nil, extensions_ = nil) # :nodoc:
-          @name = name_
-          @authority = authority_ ? authority_.to_s : nil
-          @authority_code = authority_code_ ? authority_code_.to_s : nil
-          @abbreviation = abbreviation_ ? abbreviation_.to_s : nil
-          @alias = alias_ ? alias_.to_s : nil
-          @remarks = remarks_ ? remarks_.to_s : nil
+        def initialize(name, authority = nil, authority_code = nil, abbreviation = nil, init_alias = nil, remarks = nil, extensions = nil) # :nodoc:
+          @name = name
+          @authority = authority ? authority.to_s : nil
+          @authority_code = authority_code ? authority_code.to_s : nil
+          @abbreviation = abbreviation ? abbreviation.to_s : nil
+          @alias = init_alias ? init_alias.to_s : nil
+          @remarks = remarks ? remarks.to_s : nil
           @extensions = {}
-          if extensions_
-            extensions_.each { |k_, v_| @extensions[k_.to_s] = v_.to_s }
-          end
+          extensions&.each { |k, v| @extensions[k.to_s] = v.to_s }
         end
 
         # Gets the abbreviation.
@@ -463,8 +466,8 @@ module RGeo
         # This is not part of the OGC spec, but it is supported because
         # some coordinate system databases (such as the spatial_ref_sys
         # table for PostGIS 2.0) include it.
-        def extension(key_)
-          @extensions[key_.to_s]
+        def extension(key)
+          @extensions[key.to_s]
         end
       end
 
@@ -479,9 +482,9 @@ module RGeo
       # not clear whether the data refers to a LinearUnit or AngularUnit.
 
       class Unit < Info
-        def initialize(name_, conversion_factor_, *optional_) # :nodoc:
-          super(name_, *optional_)
-          @conversion_factor = conversion_factor_.to_f
+        def initialize(name, conversion_factor, *optional) # :nodoc:
+          super(name, *optional)
+          @conversion_factor = conversion_factor.to_f
         end
 
         # This field is not part of the OGC CT spec, but is part of the
@@ -489,24 +492,26 @@ module RGeo
         # i.e. LinearUnit#meters_per_unit or AngularUnit#radians_per_unit.
         attr_reader :conversion_factor
 
-        def _wkt_typename # :nodoc:
+        def wkt_typename
           "UNIT"
         end
 
-        def _wkt_content(_open_, _close_) # :nodoc:
-          [@conversion_factor]
-        end
-
         class << self
           # Create a bare Unit that does not specify whether it is a
           # LinearUnit or an AngularUnit, given a unit name and a
           # conversion factor. You may also provide the optional
           # parameters specified by the Info interface.
 
-          def create(name_, conversion_factor_, *optional_)
-            new(name_, conversion_factor_, *optional_)
+          def create(name, conversion_factor, *optional)
+            new(name, conversion_factor, *optional)
           end
         end
+
+        private
+
+        def wkt_content(_)
+          [@conversion_factor]
+        end
       end
 
       # == OGC spec description
@@ -526,8 +531,8 @@ module RGeo
           # in meters per unit. You may also provide the optional
           # parameters specified by the Info interface.
 
-          def create(name_, meters_per_unit_, *optional_)
-            new(name_, meters_per_unit_, *optional_)
+          def create(name, meters_per_unit, *optional)
+            new(name, meters_per_unit, *optional)
           end
         end
       end
@@ -549,8 +554,8 @@ module RGeo
           # factor in radians per unit. You may also provide the optional
           # parameters specified by the Info interface.
 
-          def create(name_, radians_per_unit_, *optional_)
-            new(name_, radians_per_unit_, *optional_)
+          def create(name, radians_per_unit, *optional)
+            new(name, radians_per_unit, *optional)
           end
         end
       end
@@ -560,10 +565,10 @@ module RGeo
       # A meridian used to take longitude measurements from.
 
       class PrimeMeridian < Info
-        def initialize(name_, angular_unit_, longitude_, *optional_) # :nodoc:
-          super(name_, *optional_)
-          @angular_unit = angular_unit_
-          @longitude = longitude_.to_f
+        def initialize(name, angular_unit, longitude, *optional) # :nodoc:
+          super(name, *optional)
+          @angular_unit = angular_unit
+          @longitude = longitude.to_f
         end
 
         # Returns the AngularUnits.
@@ -573,24 +578,26 @@ module RGeo
         # The longitude is expressed in this objects angular units.
         attr_reader :longitude
 
-        def _wkt_typename # :nodoc:
+        def wkt_typename
           "PRIMEM"
         end
 
-        def _wkt_content(_open_, _close_) # :nodoc:
-          [@longitude]
-        end
-
         class << self
           # Create a PrimeMeridian given a name, AngularUnits, and the
           # longitude relative to the Greenwich Meridian, expressed in
           # the AngularUnits. You may also provide the optional parameters
           # specified by the Info interface.
 
-          def create(name_, angular_unit_, longitude_, *optional_)
-            new(name_, angular_unit_, longitude_, *optional_)
+          def create(name, angular_unit, longitude, *optional)
+            new(name, angular_unit, longitude, *optional)
           end
         end
+
+        private
+
+        def wkt_content(_)
+          [@longitude]
+        end
       end
 
       # == OGC spec description
@@ -598,13 +605,13 @@ module RGeo
       # An approximation of the Earth's surface as a squashed sphere.
 
       class Ellipsoid < Info
-        def initialize(name_, semi_major_axis_, semi_minor_axis_, inverse_flattening_, ivf_definitive_, linear_unit_, *optional_) # :nodoc:
-          super(name_, *optional_)
-          @semi_major_axis = semi_major_axis_.to_f
-          @semi_minor_axis = semi_minor_axis_.to_f
-          @inverse_flattening = inverse_flattening_.to_f
-          @ivf_definitive = ivf_definitive_ ? true : false
-          @linear_unit = linear_unit_
+        def initialize(name, semi_major_axis, semi_minor_axis, inverse_flattening, ivf_definitive, linear_unit, *optional) # :nodoc:
+          super(name, *optional)
+          @semi_major_axis = semi_major_axis.to_f
+          @semi_minor_axis = semi_minor_axis.to_f
+          @inverse_flattening = inverse_flattening.to_f
+          @ivf_definitive = ivf_definitive ? true : false
+          @linear_unit = linear_unit
         end
 
         # Gets the equatorial radius. The returned length is expressed in
@@ -630,16 +637,12 @@ module RGeo
 
         # Returns the LinearUnit. The units of the semi-major and
         # semi-minor axis values.
-        attr_reader :axis_unit
+        attr_reader :axisunit
 
-        def _wkt_typename # :nodoc:
+        def wkt_typename
           "SPHEROID"
         end
 
-        def _wkt_content(_open_, _close_) # :nodoc:
-          [@semi_major_axis, @inverse_flattening]
-        end
-
         class << self
           # Create an Ellipsoid given a name, semi-major and semi-minor
           # axes, the inverse flattening, a boolean indicating whether
@@ -648,8 +651,8 @@ module RGeo
           # may be set to nil. You may also provide the optional parameters
           # specified by the Info interface.
 
-          def create(name_, semi_major_axis_, semi_minor_axis_, inverse_flattening_, ivf_definitive_, linear_unit_, *optional_)
-            new(name_, semi_major_axis_, semi_minor_axis_, inverse_flattening_, ivf_definitive_, linear_unit_, *optional_)
+          def create(name, semi_major_axis, semi_minor_axis, inverse_flattening, ivf_definitive, linear_unit, *optional)
+            new(name, semi_major_axis, semi_minor_axis, inverse_flattening, ivf_definitive, linear_unit, *optional)
           end
 
           # Create an Ellipsoid given a name, semi-major and semi-minor
@@ -658,12 +661,12 @@ module RGeo
           # The LinearUnit is optional and may be set to nil. You may also
           # provide the optional parameters specified by the Info interface.
 
-          def create_ellipsoid(name_, semi_major_axis_, semi_minor_axis_, linear_unit_, *optional_)
-            semi_major_axis_ = semi_major_axis_.to_f
-            semi_minor_axis_ = semi_minor_axis_.to_f
-            inverse_flattening_ = semi_major_axis_ / (semi_major_axis_ - semi_minor_axis_)
-            inverse_flattening_ = 0.0 if inverse_flattening_.infinite?
-            new(name_, semi_major_axis_, semi_minor_axis_, inverse_flattening_, false, linear_unit_, *optional_)
+          def create_ellipsoid(name, semi_major_axis, semi_minor_axis, linear_unit, *optional)
+            semi_major_axis = semi_major_axis.to_f
+            semi_minor_axis = semi_minor_axis.to_f
+            inverse_flattening = semi_major_axis / (semi_major_axis - semi_minor_axis)
+            inverse_flattening = 0.0 if inverse_flattening.infinite?
+            new(name, semi_major_axis, semi_minor_axis, inverse_flattening, false, linear_unit, *optional)
           end
 
           # Create an Ellipsoid given a name, semi-major axis, inverse
@@ -672,14 +675,20 @@ module RGeo
           # The LinearUnit is optional and may be set to nil. You may also
           # provide the optional parameters specified by the Info interface.
 
-          def create_flattened_sphere(name_, semi_major_axis_, inverse_flattening_, linear_unit_, *optional_)
-            semi_major_axis_ = semi_major_axis_.to_f
-            inverse_flattening_ = inverse_flattening_.to_f
-            semi_minor_axis_ = semi_major_axis_ - semi_major_axis_ / inverse_flattening_
-            semi_minor_axis_ = semi_major_axis_ if semi_minor_axis_.infinite?
-            new(name_, semi_major_axis_, semi_minor_axis_, inverse_flattening_, true, linear_unit_, *optional_)
+          def create_flattened_sphere(name, semi_major_axis, inverse_flattening, linear_unit, *optional)
+            semi_major_axis = semi_major_axis.to_f
+            inverse_flattening = inverse_flattening.to_f
+            semi_minor_axis = semi_major_axis - semi_major_axis / inverse_flattening
+            semi_minor_axis = semi_major_axis if semi_minor_axis.infinite?
+            new(name, semi_major_axis, semi_minor_axis, inverse_flattening, true, linear_unit, *optional)
           end
         end
+
+        private
+
+        def wkt_content(_)
+          [@semi_major_axis, @inverse_flattening]
+        end
       end
 
       # == OGC spec description
@@ -703,15 +712,17 @@ module RGeo
       # LocalDatum.
 
       class Datum < Info
-        def initialize(name_, datum_type_, *optional_) # :nodoc:
-          super(name_, *optional_)
-          @datum_type = datum_type_.to_i
+        def initialize(name, datum_type, *optional) # :nodoc:
+          super(name, *optional)
+          @datum_type = datum_type.to_i
         end
 
         # Gets the type of the datum as an enumerated code.
         attr_reader :datum_type
 
-        def _wkt_content(_open_, _close_) # :nodoc:
+        private
+
+        def wkt_content(_)
           []
         end
       end
@@ -721,23 +732,25 @@ module RGeo
       # Procedure used to measure vertical distances.
 
       class VerticalDatum < Datum
-        def _wkt_typename # :nodoc:
+        def wkt_typename
           "VERT_DATUM"
         end
 
-        def _wkt_content(_open_, _close_) # :nodoc:
-          [@datum_type]
-        end
-
         class << self
           # Create a VerticalDatum given a name and a datum type code.
           # You may also provide the optional parameters specified by the
           # Info interface.
 
-          def create(name_, datum_type_, *optional_)
-            new(name_, datum_type_, *optional_)
+          def create(name, datum_type, *optional)
+            new(name, datum_type, *optional)
           end
         end
+
+        private
+
+        def wkt_content(_)
+          [@datum_type]
+        end
       end
 
       # == OGC spec description
@@ -749,23 +762,25 @@ module RGeo
       # datum.
 
       class LocalDatum < Datum
-        def _wkt_typename # :nodoc:
+        def wkt_typename
           "LOCAL_DATUM"
         end
 
-        def _wkt_content(_open_, _close_) # :nodoc:
-          [@datum_type]
-        end
-
         class << self
           # Create a LocalDatum given a name and a datum type code. You
           # may also provide the optional parameters specified by the
           # Info interface.
 
-          def create(name_, datum_type_, *optional_)
-            new(name_, datum_type_, *optional_)
+          def create(name, datum_type, *optional)
+            new(name, datum_type, *optional)
           end
         end
+
+        private
+
+        def wkt_content(_)
+          [@datum_type]
+        end
       end
 
       # == OGC spec description
@@ -773,10 +788,10 @@ module RGeo
       # Procedure used to measure positions on the surface of the Earth.
 
       class HorizontalDatum < Datum
-        def initialize(name_, datum_type_, ellipsoid_, wgs84_parameters_, *optional_) # :nodoc:
-          super(name_, datum_type_, *optional_)
-          @ellipsoid = ellipsoid_
-          @wgs84_parameters = wgs84_parameters_
+        def initialize(name, datum_type, ellipsoid, wgs84_parameters, *optional) # :nodoc:
+          super(name, datum_type, *optional)
+          @ellipsoid = ellipsoid
+          @wgs84_parameters = wgs84_parameters
         end
 
         # Returns the Ellipsoid.
@@ -787,26 +802,28 @@ module RGeo
         # (ex,ey,ez) in arc-seconds, and scaling in parts-per-million.
         attr_reader :wgs84_parameters
 
-        def _wkt_typename # :nodoc:
+        def wkt_typename
           "DATUM"
         end
 
-        def _wkt_content(open_, close_) # :nodoc:
-          array_ = [@ellipsoid._to_wkt(open_, close_)]
-          array_ << @wgs84_parameters._to_wkt(open_, close_) if @wgs84_parameters
-          array_
-        end
-
         class << self
           # Create a HorizontalDatum given a name, datum type code,
           # Ellipsoid, and WGS84ConversionInfo. The WGS84ConversionInfo
           # is optional and may be set to nil. You may also provide the
           # optional parameters specified by the Info interface.
 
-          def create(name_, datum_type_, ellipsoid_, wgs84_parameters_, *optional_)
-            new(name_, datum_type_, ellipsoid_, wgs84_parameters_, *optional_)
+          def create(name, datum_type, ellipsoid, wgs84_parameters, *optional)
+            new(name, datum_type, ellipsoid, wgs84_parameters, *optional)
           end
         end
+
+        private
+
+        def wkt_content(standard_brackets)
+          array = [@ellipsoid.to_wkt(standard_brackets)]
+          array << @wgs84_parameters.to_wkt(standard_brackets) if @wgs84_parameters
+          array
+        end
       end
 
       # == OGC spec description
@@ -814,10 +831,10 @@ module RGeo
       # A projection from geographic coordinates to projected coordinates.
 
       class Projection < Info
-        def initialize(name_, class_name_, parameters_, *optional_) # :nodoc:
-          super(name_, *optional_)
-          @class_name = class_name_.to_s
-          @parameters = parameters_ ? parameters_.dup : []
+        def initialize(name, class_name, parameters, *optional) # :nodoc:
+          super(name, *optional)
+          @class_name = class_name.to_s
+          @parameters = parameters ? parameters.dup : []
         end
 
         # Gets the projection classification name
@@ -832,33 +849,35 @@ module RGeo
 
         # Gets an inexed parameter of the projection.
 
-        def get_parameter(index_)
-          @parameters[index_]
+        def get_parameter(index)
+          @parameters[index]
         end
 
         # Iterates over the parameters of the projection.
 
-        def each_parameter(&block_)
-          @parameters.each(&block_)
+        def each_parameter(&block)
+          @parameters.each(&block)
         end
 
-        def _wkt_typename # :nodoc:
+        def wkt_typename
           "PROJECTION"
         end
 
-        def _wkt_content(_open_, _close_) # :nodoc:
-          []
-        end
-
         class << self
           # Create a Projection given a name, a projection class, and an
           # array of ProjectionParameter. You may also provide the
           # optional parameters specified by the Info interface.
 
-          def create(name_, class_name_, parameters_, *optional_)
-            new(name_, class_name_, parameters_, *optional_)
+          def create(name, class_name, parameters, *optional)
+            new(name, class_name, parameters, *optional)
           end
         end
+
+        private
+
+        def wkt_content(_)
+          []
+        end
       end
 
       # == OGC spec description
@@ -891,9 +910,9 @@ module RGeo
       # CompoundCoordinateSystem.
 
       class CoordinateSystem < Info
-        def initialize(name_, dimension_, *optional_) # :nodoc:
-          super(name_, *optional_)
-          @dimension = dimension_.to_i
+        def initialize(name, dimension, *optional) # :nodoc:
+          super(name, *optional)
+          @dimension = dimension.to_i
         end
 
         # Dimension of the coordinate system
@@ -902,14 +921,14 @@ module RGeo
         # Gets axis details for dimension within coordinate system. Each
         # dimension in the coordinate system has a corresponding axis.
 
-        def get_axis(_dimension_)
+        def get_axis(dimension)
           nil
         end
 
         # Gets units for dimension within coordinate system. Each
         # dimension in the coordinate system has corresponding units.
 
-        def get_units(_dimension_)
+        def get_units(dimension)
           nil
         end
       end
@@ -923,10 +942,10 @@ module RGeo
       # coordinate system with a vertical datum.
 
       class CompoundCoordinateSystem < CoordinateSystem
-        def initialize(name_, head_, tail_, *optional_) # :nodoc:
-          super(name_, head_.dimension + tail_.dimension, *optional_)
-          @head = head_
-          @tail = tail_
+        def initialize(name, head, tail, *optional) # :nodoc:
+          super(name, head.dimension + tail.dimension, *optional)
+          @head = head
+          @tail = tail
         end
 
         # Gets first sub-coordinate system.
@@ -937,35 +956,37 @@ module RGeo
 
         # Implements CoordinateSystem#get_axis
 
-        def get_axis(index_)
-          hd_ = @head.dimension
-          index_ < hd_ ? @head.get_axis(index_) : @tail.get_axis(index_ - hd_)
+        def get_axis(index)
+          hd = @head.dimension
+          index < hd ? @head.get_axis(index) : @tail.get_axis(index - hd)
         end
 
         # Implements CoordinateSystem#get_units
 
-        def get_units(index_)
-          hd_ = @head.dimension
-          index_ < hd_ ? @head.get_units(index_) : @tail.get_units(index_ - hd_)
+        def get_units(index)
+          hd = @head.dimension
+          index < hd ? @head.get_units(index) : @tail.get_units(index - hd)
         end
 
-        def _wkt_typename # :nodoc:
+        def wkt_typename
           "COMPD_CS"
         end
 
-        def _wkt_content(open_, close_) # :nodoc:
-          [@head._to_wkt(open_, close_), @tail._to_wkt(open_, close_)]
-        end
-
         class << self
           # Create a CompoundCoordinateSystem given two sub-coordinate
           # systems. You may also provide the optional parameters
           # specified by the Info interface.
 
-          def create(name_, head_, tail_, *optional_)
-            new(name_, head_, tail_, *optional_)
+          def create(name, head, tail, *optional)
+            new(name, head, tail, *optional)
           end
         end
+
+        private
+
+        def wkt_content(standard_brackets)
+          [@head.to_wkt(standard_brackets), @tail.to_wkt(standard_brackets)]
+        end
       end
 
       # == OGC spec description
@@ -988,11 +1009,11 @@ module RGeo
       # Transformation (CT) package.
 
       class LocalCoordinateSystem < CoordinateSystem
-        def initialize(name_, local_datum_, unit_, axes_, *optional_) # :nodoc:
-          super(name_, axes_.size, *optional_)
-          @local_datum = local_datum_
-          @unit = unit_
-          @axes = axes_.dup
+        def initialize(name, local_datum, unit, axes, *optional) # :nodoc:
+          super(name, axes.size, *optional)
+          @local_datum = local_datum
+          @unit = unit
+          @axes = axes.dup
         end
 
         # Gets the local datum.
@@ -1000,34 +1021,39 @@ module RGeo
 
         # Implements CoordinateSystem#get_axis
 
-        def get_axis(index_)
-          @axes[index_]
+        def get_axis(index)
+          @axes[index]
         end
 
         # Implements CoordinateSystem#get_units
 
-        def get_units(_index_)
+        def get_units(index)
           @unit
         end
 
-        def _wkt_typename # :nodoc:
+        def wkt_typename
           "LOCAL_CS"
         end
 
-        def _wkt_content(open_, close_) # :nodoc:
-          [@local_datum._to_wkt(open_, close_), @unit._to_wkt(open_, close_)] + @axes.map { |ax_| ax_._to_wkt(open_, close_) }
-        end
-
         class << self
           # Create a LocalCoordinateSystem given a name, a LocalDatum, a
           # Unit, and an array of at least one AxisInfo. You may also
           # provide the optional parameters specified by the Info
           # interface.
 
-          def create(name_, local_datum_, unit_, axes_, *optional_)
-            new(name_, local_datum_, unit_, axes_, *optional_)
+          def create(name, local_datum, unit, axes, *optional)
+            new(name, local_datum, unit, axes, *optional)
           end
         end
+
+        private
+
+        def wkt_content(standard_brackets)
+          [
+            @local_datum.to_wkt(standard_brackets),
+            @unit.to_wkt(standard_brackets)
+          ] + @axes.map { |ax| ax.to_wkt(standard_brackets) }
+        end
       end
 
       # == OGC spec description
@@ -1040,14 +1066,14 @@ module RGeo
       # non-default values.
 
       class GeocentricCoordinateSystem < CoordinateSystem
-        def initialize(name_, horizontal_datum_, prime_meridian_, linear_unit_, axis0_, axis1_, axis2_, *optional_) # :nodoc:
-          super(name_, 3, *optional_)
-          @horizontal_datum = horizontal_datum_
-          @prime_meridian = prime_meridian_
-          @linear_unit = linear_unit_
-          @axis0 = axis0_
-          @axis1 = axis1_
-          @axis2 = axis2_
+        def initialize(name, horizontal_datum, prime_meridian, linear_unit, axis0, axis1, axis2, *optional) # :nodoc:
+          super(name, 3, *optional)
+          @horizontal_datum = horizontal_datum
+          @prime_meridian = prime_meridian
+          @linear_unit = linear_unit
+          @axis0 = axis0
+          @axis1 = axis1
+          @axis2 = axis2
         end
 
         # Returns the HorizontalDatum. The horizontal datum is used to
@@ -1064,28 +1090,20 @@ module RGeo
 
         # Implements CoordinateSystem#get_units
 
-        def get_units(_index_)
+        def get_units(index)
           @linear_unit
         end
 
         # Implements CoordinateSystem#get_axis
 
-        def get_axis(index_)
-          [@axis0, @axis1, @axis2][index_]
+        def get_axis(index)
+          [@axis0, @axis1, @axis2][index]
         end
 
-        def _wkt_typename # :nodoc:
+        def wkt_typename
           "GEOCCS"
         end
 
-        def _wkt_content(open_, close_) # :nodoc:
-          arr_ = [@horizontal_datum._to_wkt(open_, close_), @prime_meridian._to_wkt(open_, close_), @linear_unit._to_wkt(open_, close_)]
-          arr_ << @axis0._to_wkt(open_, close_) if @axis0
-          arr_ << @axis1._to_wkt(open_, close_) if @axis1
-          arr_ << @axis2._to_wkt(open_, close_) if @axis2
-          arr_
-        end
-
         class << self
           # Create a GeocentricCoordinateSystem given a name, a
           # HorizontalDatum, a PrimeMeridian, a LinearUnit, and three
@@ -1093,10 +1111,24 @@ module RGeo
           # You may also provide the optional parameters specified by the
           # Info interface.
 
-          def create(name_, horizontal_datum_, prime_meridian_, linear_unit_, axis0_, axis1_, axis2_, *optional_)
-            new(name_, horizontal_datum_, prime_meridian_, linear_unit_, axis0_, axis1_, axis2_, *optional_)
+          def create(name, horizontal_datum, prime_meridian, linear_unit, axis0, axis1, axis2, *optional)
+            new(name, horizontal_datum, prime_meridian, linear_unit, axis0, axis1, axis2, *optional)
           end
         end
+
+        private
+
+        def wkt_content(standard_brackets)
+          arr = [
+            @horizontal_datum.to_wkt(standard_brackets),
+            @prime_meridian.to_wkt(standard_brackets),
+            @linear_unit.to_wkt(standard_brackets)
+          ]
+          arr << @axis0.to_wkt(standard_brackets) if @axis0
+          arr << @axis1.to_wkt(standard_brackets) if @axis1
+          arr << @axis2.to_wkt(standard_brackets) if @axis2
+          arr
+        end
       end
 
       # == OGC spec description
@@ -1105,11 +1137,11 @@ module RGeo
       # measurements.
 
       class VerticalCoordinateSystem < CoordinateSystem
-        def initialize(name_, vertical_datum_, vertical_unit_, axis_, *optional_) # :nodoc:
-          super(name_, 1, *optional_)
-          @vertical_datum = vertical_datum_
-          @vertical_unit = vertical_unit_
-          @axis = axis_
+        def initialize(name, vertical_datum, vertical_unit, axis, *optional) # :nodoc:
+          super(name, 1, *optional)
+          @vertical_datum = vertical_datum
+          @vertical_unit = vertical_unit
+          @axis = axis
         end
 
         # Gets the vertical datum, which indicates the measurement method.
@@ -1121,36 +1153,38 @@ module RGeo
 
         # Implements CoordinateSystem#get_units
 
-        def get_units(_index_)
+        def get_units(index)
           @vertical_unit
         end
 
         # Implements CoordinateSystem#get_axis
 
-        def get_axis(_index_)
+        def get_axis(index)
           @axis
         end
 
-        def _wkt_typename # :nodoc:
+        def wkt_typename
           "VERT_CS"
         end
 
-        def _wkt_content(open_, close_) # :nodoc:
-          arr_ = [@vertical_datum._to_wkt(open_, close_), @vertical_unit._to_wkt(open_, close_)]
-          arr_ << @axis._to_wkt(open_, close_) if @axis
-          arr_
-        end
-
         class << self
           # Create a VerticalCoordinateSystem given a name, a
           # VerticalDatum, a LinearUnit, and an AxisInfo. The AxisInfo is
           # optional and may be nil. You may also provide the optional
           # parameters specified by the Info interface.
 
-          def create(name_, vertical_datum_, vertical_unit_, axis_, *optional_)
-            new(name_, vertical_datum_, vertical_unit_, axis_, *optional_)
+          def create(name, vertical_datum, vertical_unit, axis, *optional)
+            new(name, vertical_datum, vertical_unit, axis, *optional)
           end
         end
+
+        private
+
+        def wkt_content(standard_brackets)
+          arr = [@vertical_datum.to_wkt(standard_brackets), @vertical_unit.to_wkt(standard_brackets)]
+          arr << @axis.to_wkt(standard_brackets) if @axis
+          arr
+        end
       end
 
       # == OGC spec description
@@ -1164,9 +1198,9 @@ module RGeo
       # ProjectedCoordinateSystem.
 
       class HorizontalCoordinateSystem < CoordinateSystem
-        def initialize(name_, horizontal_datum_, *optional_) # :nodoc:
-          super(name_, 2, *optional_)
-          @horizontal_datum = horizontal_datum_
+        def initialize(name, horizontal_datum, *optional) # :nodoc:
+          super(name, 2, *optional)
+          @horizontal_datum = horizontal_datum
         end
 
         # Returns the HorizontalDatum.
@@ -1182,12 +1216,12 @@ module RGeo
       # systems use degrees.
 
       class GeographicCoordinateSystem < HorizontalCoordinateSystem
-        def initialize(name_, angular_unit_, horizontal_datum_, prime_meridian_, axis0_, axis1_, *optional_) # :nodoc:
-          super(name_, horizontal_datum_, *optional_)
-          @prime_meridian = prime_meridian_
-          @angular_unit = angular_unit_
-          @axis0 = axis0_
-          @axis1 = axis1_
+        def initialize(name, angular_unit, horizontal_datum, prime_meridian, axis0, axis1, *optional) # :nodoc:
+          super(name, horizontal_datum, *optional)
+          @prime_meridian = prime_meridian
+          @angular_unit = angular_unit
+          @axis0 = axis0
+          @axis1 = axis1
         end
 
         # Returns the PrimeMeridian.
@@ -1199,14 +1233,14 @@ module RGeo
 
         # Implements CoordinateSystem#get_units
 
-        def get_units(_index_)
+        def get_units(index)
           @angular_unit
         end
 
         # Implements CoordinateSystem#get_axis
 
-        def get_axis(index_)
-          index_ == 1 ? @axis1 : @axis0
+        def get_axis(index)
+          index == 1 ? @axis1 : @axis0
         end
 
         # Gets the number of available conversions to WGS84 coordinates.
@@ -1221,21 +1255,14 @@ module RGeo
         # of interest. The first conversion (with index=0) should provide
         # acceptable accuracy over the largest possible area of interest.
 
-        def get_wgs84_conversion_info(_index_)
+        def get_wgs84_conversion_info(index)
           @horizontal_datum.wgs84_parameters
         end
 
-        def _wkt_typename # :nodoc:
+        def wkt_typename
           "GEOGCS"
         end
 
-        def _wkt_content(open_, close_) # :nodoc:
-          arr_ = [@horizontal_datum._to_wkt(open_, close_), @prime_meridian._to_wkt(open_, close_), @angular_unit._to_wkt(open_, close_)]
-          arr_ << @axis0._to_wkt(open_, close_) if @axis0
-          arr_ << @axis1._to_wkt(open_, close_) if @axis1
-          arr_
-        end
-
         class << self
           # Create a GeographicCoordinateSystem, given a name, an
           # AngularUnit, a HorizontalDatum, a PrimeMeridian, and two
@@ -1243,10 +1270,23 @@ module RGeo
           # be set to nil. You may also provide the optional parameters
           # specified by the Info interface.
 
-          def create(name_, angular_unit_, horizontal_datum_, prime_meridian_, axis0_, axis1_, *optional_)
-            new(name_, angular_unit_, horizontal_datum_, prime_meridian_, axis0_, axis1_, *optional_)
+          def create(name, angular_unit, horizontal_datum, prime_meridian, axis0, axis1, *optional)
+            new(name, angular_unit, horizontal_datum, prime_meridian, axis0, axis1, *optional)
           end
         end
+
+        private
+
+        def wkt_content(standard_brackets)
+          arr = [
+            @horizontal_datum.to_wkt(standard_brackets),
+            @prime_meridian.to_wkt(standard_brackets),
+            @angular_unit.to_wkt(standard_brackets)
+          ]
+          arr << @axis0.to_wkt(standard_brackets) if @axis0
+          arr << @axis1.to_wkt(standard_brackets) if @axis1
+          arr
+        end
       end
 
       # == OGC spec description
@@ -1254,13 +1294,13 @@ module RGeo
       # A 2D cartographic coordinate system.
 
       class ProjectedCoordinateSystem < HorizontalCoordinateSystem
-        def initialize(name_, geographic_coordinate_system_, projection_, linear_unit_, axis0_, axis1_, *optional_) # :nodoc:
-          super(name_, geographic_coordinate_system_.horizontal_datum, *optional_)
-          @geographic_coordinate_system = geographic_coordinate_system_
-          @projection = projection_
-          @linear_unit = linear_unit_
-          @axis0 = axis0_
-          @axis1 = axis1_
+        def initialize(name, geographic_coordinate_system, projection, linear_unit, axis0, axis1, *optional) # :nodoc:
+          super(name, geographic_coordinate_system.horizontal_datum, *optional)
+          @geographic_coordinate_system = geographic_coordinate_system
+          @projection = projection
+          @linear_unit = linear_unit
+          @axis0 = axis0
+          @axis1 = axis1
         end
 
         # Returns the GeographicCoordinateSystem.
@@ -1275,29 +1315,20 @@ module RGeo
 
         # Implements CoordinateSystem#get_units
 
-        def get_units(_index_)
+        def get_units(index)
           @linear_unit
         end
 
         # Implements CoordinateSystem#get_axis
 
-        def get_axis(index_)
-          index_ == 1 ? @axis1 : @axis0
+        def get_axis(index)
+          index == 1 ? @axis1 : @axis0
         end
 
-        def _wkt_typename # :nodoc:
+        def wkt_typename
           "PROJCS"
         end
 
-        def _wkt_content(open_, close_) # :nodoc:
-          arr_ = [@geographic_coordinate_system._to_wkt(open_, close_), @projection._to_wkt(open_, close_)]
-          @projection.each_parameter { |param_| arr_ << param_._to_wkt(open_, close_) }
-          arr_ << @linear_unit._to_wkt(open_, close_)
-          arr_ << @axis0._to_wkt(open_, close_) if @axis0
-          arr_ << @axis1._to_wkt(open_, close_) if @axis1
-          arr_
-        end
-
         class << self
           # Create a ProjectedCoordinateSystem given a name, a
           # GeographicCoordinateSystem, and Projection, a LinearUnit, and
@@ -1305,10 +1336,21 @@ module RGeo
           # may be set to nil. You may also provide the optional
           # parameters specified by the Info interface.
 
-          def create(name_, geographic_coordinate_system_, projection_, linear_unit_, axis0_, axis1_, *optional_)
-            new(name_, geographic_coordinate_system_, projection_, linear_unit_, axis0_, axis1_, *optional_)
+          def create(name, geographic_coordinate_system, projection, linear_unit, axis0, axis1, *optional)
+            new(name, geographic_coordinate_system, projection, linear_unit, axis0, axis1, *optional)
           end
         end
+
+        private
+
+        def wkt_content(standard_brackets)
+          arr = [@geographic_coordinate_system.to_wkt(standard_brackets), @projection.to_wkt(standard_brackets)]
+          @projection.each_parameter { |param| arr << param.to_wkt(standard_brackets) }
+          arr << @linear_unit.to_wkt(standard_brackets)
+          arr << @axis0.to_wkt(standard_brackets) if @axis0
+          arr << @axis1.to_wkt(standard_brackets) if @axis1
+          arr
+        end
       end
     end
   end