rgeo 0.4.0 → 0.5.0

data/lib/rgeo/geographic/spherical_math.rb

@@ -5,14 +5,9 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
   module Geographic
-
-    module SphericalMath  # :nodoc:
-
-
-      RADIUS = 6378137.0
-
+    module SphericalMath # :nodoc:
+      RADIUS = 6_378_137.0
 
       # Represents a point on the unit sphere in (x,y,z) coordinates
       # instead of lat-lon. This form is often faster, more convenient,
@@ -25,8 +20,7 @@ module RGeo
       # This object is also used to represent a great circle, as its axis
       # of rotation.
 
-      class PointXYZ  # :nodoc:
-
+      class PointXYZ # :nodoc:
         def initialize(x_, y_, z_)
           r_ = ::Math.sqrt(x_ * x_ + y_ * y_ + z_ * z_)
           @x = (x_ / r_).to_f
@@ -35,39 +29,41 @@ module RGeo
           raise "Not a number" if @x.nan? || @y.nan? || @z.nan?
         end
 
-
         def to_s
           "(#{@x}, #{@y}, #{@z})"
         end
 
-
         attr_reader :x
         attr_reader :y
         attr_reader :z
 
-
         def eql?(rhs_)
-          rhs_.kind_of?(PointXYZ) && @x == rhs_.x && @y == rhs_.y && @z == rhs_.z
+          rhs_.is_a?(PointXYZ) && @x == rhs_.x && @y == rhs_.y && @z == rhs_.z
         end
         alias_method :==, :eql?
 
-
         def latlon
           lat_rad_ = ::Math.asin(@z)
-          lon_rad_ = ::Math.atan2(@y, @x) rescue 0.0
+          lon_rad_ = begin
+                       ::Math.atan2(@y, @x)
+                     rescue
+                       0.0
+                     end
           rpd_ = ImplHelper::Math::RADIANS_PER_DEGREE
           [lat_rad_ / rpd_, lon_rad_ / rpd_]
         end
 
-
         def lonlat
           lat_rad_ = ::Math.asin(@z)
-          lon_rad_ = ::Math.atan2(@y, @x) rescue 0.0
+          lon_rad_ = begin
+                       ::Math.atan2(@y, @x)
+                     rescue
+                       0.0
+                     end
           rpd_ = ImplHelper::Math::RADIANS_PER_DEGREE
           [lon_rad_ / rpd_, lat_rad_ / rpd_]
         end
 
-
         def *(rhs_)
           val_ = @x * rhs_.x + @y * rhs_.y + @z * rhs_.z
           val_ = 1.0 if val_ > 1.0
@@ -75,15 +71,17 @@ module RGeo
           val_
         end
 
-
         def %(rhs_)
           rx_ = rhs_.x
           ry_ = rhs_.y
           rz_ = rhs_.z
-          PointXYZ.new(@y*rz_-@z*ry_, @z*rx_-@x*rz_, @x*ry_-@y*rx_) rescue nil
+          begin
+            PointXYZ.new(@y * rz_ - @z * ry_, @z * rx_ - @x * rz_, @x * ry_ - @y * rx_)
+          rescue
+            nil
+          end
         end
 
-
         def dist_to_point(rhs_)
           rx_ = rhs_.x
           ry_ = rhs_.y
@@ -92,15 +90,14 @@ module RGeo
           if dot_ > -0.8 && dot_ < 0.8
             ::Math.acos(dot_)
           else
-            x_ = @y*rz_-@z*ry_
-            y_ = @z*rx_-@x*rz_
-            z_ = @x*ry_-@y*rx_
-            as_ = ::Math.asin(::Math.sqrt(x_*x_ + y_*y_ + z_*z_))
+            x_ = @y * rz_ - @z * ry_
+            y_ = @z * rx_ - @x * rz_
+            z_ = @x * ry_ - @y * rx_
+            as_ = ::Math.asin(::Math.sqrt(x_ * x_ + y_ * y_ + z_ * z_))
             dot_ > 0.0 ? as_ : ::Math::PI - as_
           end
         end
 
-
         # Creates some point that is perpendicular to this point
 
         def create_perpendicular
@@ -111,7 +108,6 @@ module RGeo
           p1dot_ < p2dot_ ? (self % P1) : (self % P2)
         end
 
-
         def self.from_latlon(lat_, lon_)
           rpd_ = ImplHelper::Math::RADIANS_PER_DEGREE
           lat_rad_ = rpd_ * lat_
@@ -123,58 +119,45 @@ module RGeo
           new(x_, y_, z_)
         end
 
-
         def self.weighted_combination(p1_, w1_, p2_, w2_)
           new(p1_.x * w1_ + p2_.x * w2_, p1_.y * w1_ + p2_.y * w2_, p1_.z * w1_ + p2_.z * w2_)
         end
 
-
         P1 = new(1, 0, 0)
         P2 = new(0, 1, 0)
-
       end
 
-
       # Represents a finite arc on the sphere.
 
-      class ArcXYZ  # :nodoc:
-
+      class ArcXYZ # :nodoc:
         def initialize(start_, end_)
           @s = start_
           @e = end_
           @axis = false
         end
 
-
         attr_reader :s
         attr_reader :e
 
-
         def to_s
           "#{@s} - #{@e}"
         end
 
-
         def eql?(rhs_)
-          rhs_.kind_of?(ArcXYZ) && @s == rhs_.s && @e == rhs_.e
+          rhs_.is_a?(ArcXYZ) && @s == rhs_.s && @e == rhs_.e
         end
         alias_method :==, :eql?
 
-
         def degenerate?
           axis_ = axis
           axis_.x == 0 && axis_.y == 0 && axis_.z == 0
         end
 
-
         def axis
-          if @axis == false
-            @axis = @s % @e
-          end
+          @axis = @s % @e if @axis == false
           @axis
         end
 
-
         def contains_point?(obj_)
           axis_ = axis
           saxis_ = ArcXYZ.new(@s, obj_).axis
@@ -182,7 +165,6 @@ module RGeo
           !saxis_ || !eaxis_ || obj_ * axis_ == 0.0 && saxis_ * axis_ > 0 && eaxis_ * axis_ > 0
         end
 
-
         def intersects_arc?(obj_)
           my_axis_ = axis
           dot1_ = my_axis_ * obj_.s
@@ -197,17 +179,10 @@ module RGeo
           end
         end
 
-
         def length
           @s.dist_to_point(@e)
         end
-
-
       end
-
-
     end
-
   end
-
 end

data/lib/rgeo/geos.rb

@@ -5,8 +5,6 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
-
   # The Geos module provides general tools for creating and manipulating
   # a GEOS-backed implementation of the SFS. This is a full implementation
   # of the SFS using a Cartesian coordinate system. It uses the GEOS C++
@@ -26,40 +24,36 @@ module RGeo
 
   module Geos
   end
-
-
 end
 
-
 # :stopdoc:
 
 module RGeo
   module Geos
-
     # Implementation files
-    require 'rgeo/geos/utils'
-    require 'rgeo/geos/interface'
+    require "rgeo/geos/utils"
+    require "rgeo/geos/interface"
     begin
-      require 'rgeo/geos/geos_c_impl'
+      require "rgeo/geos/geos_c_impl"
     rescue ::LoadError; end
     CAPI_SUPPORTED = ::RGeo::Geos.const_defined?(:CAPIGeometryMethods)
     if CAPI_SUPPORTED
-      require 'rgeo/geos/capi_feature_classes'
-      require 'rgeo/geos/capi_factory'
+      require "rgeo/geos/capi_feature_classes"
+      require "rgeo/geos/capi_factory"
     end
-    require 'rgeo/geos/ffi_feature_methods'
-    require 'rgeo/geos/ffi_feature_classes'
-    require 'rgeo/geos/ffi_factory'
-    require 'rgeo/geos/zm_feature_methods'
-    require 'rgeo/geos/zm_feature_classes'
-    require 'rgeo/geos/zm_factory'
+    require "rgeo/geos/ffi_feature_methods"
+    require "rgeo/geos/ffi_feature_classes"
+    require "rgeo/geos/ffi_factory"
+    require "rgeo/geos/zm_feature_methods"
+    require "rgeo/geos/zm_feature_classes"
+    require "rgeo/geos/zm_factory"
 
     # Determine ffi support.
     begin
-      require 'ffi-geos'
+      require "ffi-geos"
       # An additional check to make sure FFI loaded okay. This can fail on
       # some versions of ffi-geos and some versions of Rubinius.
-      raise 'Problem loading FFI' unless ::FFI::AutoPointer
+      raise "Problem loading FFI" unless ::FFI::AutoPointer
       FFI_SUPPORTED = true
       FFI_SUPPORT_EXCEPTION = nil
     rescue ::LoadError => ex_
@@ -77,9 +71,18 @@ module RGeo
       self.preferred_native_interface = :ffi
     end
 
+    # There is some trouble with END_CAP in GEOS
+    # In docs CAP_ROUND = 1, but it's work properly with 0
+    CAP_ROUND  = 0
+    CAP_FLAT   = 1
+    CAP_SQUARE = 2
+
+    JOIN_ROUND = 0
+    JOIN_MITRE = 1
+    JOIN_BEVEL = 2
+
     # Init internal utilities
     Utils._init
-
   end
 end
 

data/lib/rgeo/geos/capi_factory.rb

@@ -5,27 +5,19 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
   module Geos
-
-
     # This the GEOS CAPI implementation of ::RGeo::Feature::Factory.
 
     class CAPIFactory
-
-
       include Feature::Factory::Instance
 
-
       class << self
-
-
         # Create a new factory. Returns nil if the GEOS CAPI implementation
         # is not supported.
         #
         # See ::RGeo::Geos.factory for a list of supported options.
 
-        def create(opts_={})
+        def create(opts_ = {})
           # Make sure GEOS is available
           return nil unless respond_to?(:_create)
 
@@ -51,7 +43,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_
@@ -67,15 +59,19 @@ module RGeo
           srid_ = opts_[:srid]
           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
           if (!proj4_ || !coord_sys_) && srid_ && (db_ = opts_[:srs_database])
             entry_ = db_.get(srid_.to_i)
@@ -115,18 +111,14 @@ module RGeo
           result_
         end
         alias_method :new, :create
-
-
       end
 
-
       # Standard object inspection output
 
       def inspect
         "#<#{self.class}:0x#{object_id.to_s(16)} srid=#{_srid} bufres=#{_buffer_resolution} flags=#{_flags}>"
       end
 
-
       # Factory equivalence test.
 
       def eql?(rhs_)
@@ -136,128 +128,123 @@ module RGeo
       end
       alias_method :==, :eql?
 
-
       # Standard hash code
 
       def hash
         @hash ||= [_srid, _buffer_resolution, _flags, _proj4].hash
       end
 
-
       # Marshal support
 
-      def marshal_dump  # :nodoc:
+      def marshal_dump # :nodoc:
         hash_ = {
-          'hasz' => (_flags & 0x2 != 0),
-          'hasm' => (_flags & 0x4 != 0),
-          'srid' => _srid,
-          'bufr' => _buffer_resolution,
-          'wktg' => _wkt_generator ? _wkt_generator._properties : {},
-          'wkbg' => _wkb_generator ? _wkb_generator._properties : {},
-          'wktp' => _wkt_parser ? _wkt_parser._properties : {},
-          'wkbp' => _wkb_parser ? _wkb_parser._properties : {},
-          'lmpa' => (_flags & 0x1 != 0),
-          'apre' => ((_flags & 0x8) >> 3),
+          "hasz" => (_flags & 0x2 != 0),
+          "hasm" => (_flags & 0x4 != 0),
+          "srid" => _srid,
+          "bufr" => _buffer_resolution,
+          "wktg" => _wkt_generator ? _wkt_generator._properties : {},
+          "wkbg" => _wkb_generator ? _wkb_generator._properties : {},
+          "wktp" => _wkt_parser ? _wkt_parser._properties : {},
+          "wkbp" => _wkb_parser ? _wkb_parser._properties : {},
+          "lmpa" => (_flags & 0x1 != 0),
+          "apre" => ((_flags & 0x8) >> 3)
         }
-        if (proj4_ = self._proj4)
-          hash_['proj4'] = proj4_.marshal_dump
+        if (proj4_ = _proj4)
+          hash_["proj4"] = proj4_.marshal_dump
         end
-        if (coord_sys_ = self._coord_sys)
-          hash_['cs'] = coord_sys_.to_wkt
+        if (coord_sys_ = _coord_sys)
+          hash_["cs"] = coord_sys_.to_wkt
         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_copy(CAPIFactory.create(
-          :has_z_coordinate => data_['hasz'],
-          :has_m_coordinate => data_['hasm'],
-          :srid => data_['srid'],
-          :buffer_resolution => data_['bufr'],
-          :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_multi_polygon_assertions => data_['lmpa'],
-          :auto_prepare => (data_['apre'] == 0 ? :disabled : :simple),
-          :proj4 => proj4_,
-          :coord_sys => coord_sys_
+                          has_z_coordinate: data_["hasz"],
+                          has_m_coordinate: data_["hasm"],
+                          srid: data_["srid"],
+                          buffer_resolution: data_["bufr"],
+                          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_multi_polygon_assertions: data_["lmpa"],
+                          auto_prepare: (data_["apre"] == 0 ? :disabled : :simple),
+                          proj4: proj4_,
+                          coord_sys: coord_sys_
         ))
       end
 
-
       # Psych support
 
-      def encode_with(coder_)  # :nodoc:
-        coder_['has_z_coordinate'] = (_flags & 0x2 != 0)
-        coder_['has_m_coordinate'] = (_flags & 0x4 != 0)
-        coder_['srid'] = _srid
-        coder_['buffer_resolution'] = _buffer_resolution
-        coder_['lenient_multi_polygon_assertions'] = (_flags & 0x1 != 0)
-        coder_['wkt_generator'] = _wkt_generator ? _wkt_generator._properties : {}
-        coder_['wkb_generator'] = _wkb_generator ? _wkb_generator._properties : {}
-        coder_['wkt_parser'] = _wkt_parser ? _wkt_parser._properties : {}
-        coder_['wkb_parser'] = _wkb_parser ? _wkb_parser._properties : {}
-        coder_['auto_prepare'] = ((_flags & 0x8) == 0 ? 'disabled' : 'simple')
-        if (proj4_ = self._proj4)
+      def encode_with(coder_) # :nodoc:
+        coder_["has_z_coordinate"] = (_flags & 0x2 != 0)
+        coder_["has_m_coordinate"] = (_flags & 0x4 != 0)
+        coder_["srid"] = _srid
+        coder_["buffer_resolution"] = _buffer_resolution
+        coder_["lenient_multi_polygon_assertions"] = (_flags & 0x1 != 0)
+        coder_["wkt_generator"] = _wkt_generator ? _wkt_generator._properties : {}
+        coder_["wkb_generator"] = _wkb_generator ? _wkb_generator._properties : {}
+        coder_["wkt_parser"] = _wkt_parser ? _wkt_parser._properties : {}
+        coder_["wkb_parser"] = _wkb_parser ? _wkb_parser._properties : {}
+        coder_["auto_prepare"] = ((_flags & 0x8) == 0 ? "disabled" : "simple")
+        if (proj4_ = _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
-        if (coord_sys_ = self._coord_sys)
-          coder_['coord_sys'] = coord_sys_.to_wkt
+        if (coord_sys_ = _coord_sys)
+          coder_["coord_sys"] = coord_sys_.to_wkt
         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_copy(CAPIFactory.create(
-          :has_z_coordinate => coder_['has_z_coordinate'],
-          :has_m_coordinate => coder_['has_m_coordinate'],
-          :srid => coder_['srid'],
-          :buffer_resolution => coder_['buffer_resolution'],
-          :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']),
-          :auto_prepare => coder_['auto_prepare'] == 'disabled' ? :disabled : :simple,
-          :uses_lenient_multi_polygon_assertions => coder_['lenient_multi_polygon_assertions'],
-          :proj4 => proj4_,
-          :coord_sys => coord_sys_
+                          has_z_coordinate: coder_["has_z_coordinate"],
+                          has_m_coordinate: coder_["has_m_coordinate"],
+                          srid: coder_["srid"],
+                          buffer_resolution: coder_["buffer_resolution"],
+                          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"]),
+                          auto_prepare: coder_["auto_prepare"] == "disabled" ? :disabled : :simple,
+                          uses_lenient_multi_polygon_assertions: coder_["lenient_multi_polygon_assertions"],
+                          proj4: proj4_,
+                          coord_sys: coord_sys_
         ))
       end
 
-
       # Returns the SRID of geometries created by this factory.
 
       def srid
         _srid
       end
 
-
       # Returns the resolution used by buffer calculations on geometries
       # created by this factory
 
@@ -265,14 +252,12 @@ module RGeo
         _buffer_resolution
       end
 
-
       # Returns true if this factory is lenient with MultiPolygon assertions
 
       def lenient_multi_polygon_assertions?
         _flags & 0x1 != 0
       end
 
-
       # See ::RGeo::Feature::Factory#property
 
       def property(name_)
@@ -289,128 +274,146 @@ module RGeo
           _buffer_resolution
         when :auto_prepare
           _flags & 0x8 != 0 ? :simple : :disabled
-        else
-          nil
         end
       end
 
-
       # See ::RGeo::Feature::Factory#parse_wkt
 
       def parse_wkt(str_)
-        if (wkt_parser_ = self._wkt_parser)
+        if (wkt_parser_ = _wkt_parser)
           wkt_parser_.parse(str_)
         else
           _parse_wkt_impl(str_)
         end
       end
 
-
       # See ::RGeo::Feature::Factory#parse_wkb
 
       def parse_wkb(str_)
-        if (wkb_parser_ = self._wkb_parser)
+        if (wkb_parser_ = _wkb_parser)
           wkb_parser_.parse(str_)
         else
           _parse_wkb_impl(str_)
         end
       end
 
-
       # See ::RGeo::Feature::Factory#point
 
       def point(x_, y_, *extra_)
         if extra_.length > (_flags & 6 == 0 ? 0 : 1)
           nil
         else
-          CAPIPointImpl.create(self, x_, y_, extra_[0].to_f) rescue nil
+          begin
+            CAPIPointImpl.create(self, x_, y_, extra_[0].to_f)
+          rescue
+            nil
+          end
         end
       end
 
-
       # See ::RGeo::Feature::Factory#line_string
 
       def line_string(points_)
-        points_ = points_.to_a unless points_.kind_of?(::Array)
-        CAPILineStringImpl.create(self, points_) rescue nil
+        points_ = points_.to_a unless points_.is_a?(::Array)
+        begin
+          CAPILineStringImpl.create(self, points_)
+        rescue
+          nil
+        end
       end
 
-
       # See ::RGeo::Feature::Factory#line
 
       def line(start_, end_)
-        CAPILineImpl.create(self, start_, end_) rescue nil
+        CAPILineImpl.create(self, start_, end_)
+      rescue
+        nil
       end
 
-
       # See ::RGeo::Feature::Factory#linear_ring
 
       def linear_ring(points_)
-        points_ = points_.to_a unless points_.kind_of?(::Array)
-        CAPILinearRingImpl.create(self, points_) rescue nil
+        points_ = points_.to_a unless points_.is_a?(::Array)
+        begin
+          CAPILinearRingImpl.create(self, points_)
+        rescue
+          nil
+        end
       end
 
-
       # See ::RGeo::Feature::Factory#polygon
 
-      def polygon(outer_ring_, inner_rings_=nil)
-        inner_rings_ = inner_rings_.to_a unless inner_rings_.kind_of?(::Array)
-        CAPIPolygonImpl.create(self, outer_ring_, inner_rings_) rescue nil
+      def polygon(outer_ring_, inner_rings_ = nil)
+        inner_rings_ = inner_rings_.to_a unless inner_rings_.is_a?(::Array)
+        begin
+          CAPIPolygonImpl.create(self, outer_ring_, inner_rings_)
+        rescue
+          nil
+        end
       end
 
-
       # See ::RGeo::Feature::Factory#collection
 
       def collection(elems_)
-        elems_ = elems_.to_a unless elems_.kind_of?(::Array)
-        CAPIGeometryCollectionImpl.create(self, elems_) rescue nil
+        elems_ = elems_.to_a unless elems_.is_a?(::Array)
+        begin
+          CAPIGeometryCollectionImpl.create(self, elems_)
+        rescue
+          nil
+        end
       end
 
-
       # See ::RGeo::Feature::Factory#multi_point
 
       def multi_point(elems_)
-        elems_ = elems_.to_a unless elems_.kind_of?(::Array)
-        CAPIMultiPointImpl.create(self, elems_) rescue nil
+        elems_ = elems_.to_a unless elems_.is_a?(::Array)
+        begin
+          CAPIMultiPointImpl.create(self, elems_)
+        rescue
+          nil
+        end
       end
 
-
       # See ::RGeo::Feature::Factory#multi_line_string
 
       def multi_line_string(elems_)
-        elems_ = elems_.to_a unless elems_.kind_of?(::Array)
-        CAPIMultiLineStringImpl.create(self, elems_) rescue nil
+        elems_ = elems_.to_a unless elems_.is_a?(::Array)
+        begin
+          CAPIMultiLineStringImpl.create(self, elems_)
+        rescue
+          nil
+        end
       end
 
-
       # See ::RGeo::Feature::Factory#multi_polygon
 
       def multi_polygon(elems_)
-        elems_ = elems_.to_a unless elems_.kind_of?(::Array)
-        CAPIMultiPolygonImpl.create(self, elems_) rescue nil
+        elems_ = elems_.to_a unless elems_.is_a?(::Array)
+        begin
+          CAPIMultiPolygonImpl.create(self, elems_)
+        rescue
+          nil
+        end
       end
 
-
       # See ::RGeo::Feature::Factory#proj4
 
       def proj4
         _proj4
       end
 
-
       # See ::RGeo::Feature::Factory#coord_sys
 
       def coord_sys
         _coord_sys
       end
 
-
       # See ::RGeo::Feature::Factory#override_cast
 
       def override_cast(original_, ntype_, flags_)
         return nil unless Geos.supported?
         keep_subtype_ = flags_[:keep_subtype]
-        #force_new_ = flags_[:force_new]
+        # force_new_ = flags_[:force_new]
         project_ = flags_[:project]
         type_ = original_.geometry_type
         ntype_ = type_ if keep_subtype_ && type_.include?(ntype_)
@@ -421,7 +424,6 @@ module RGeo
           if original_.factory != self && ntype_ == type_ &&
               original_.factory._flags & 0x6 == _flags & 0x6 &&
               (!project_ || original_.factory.proj4 == _proj4)
-          then
             result_ = original_.dup
             result_._set_factory(self)
             return result_
@@ -431,7 +433,6 @@ module RGeo
               original_.factory._flags & 0x6 == _flags & 0x6 &&
               (!project_ || original_.factory.proj4 == _proj4) &&
               type_.subtype_of?(Feature::LineString) && ntype_.subtype_of?(Feature::LineString)
-          then
             return IMPL_CLASSES[ntype_]._copy_from(self, original_)
           end
         when ZMGeometryMethods
@@ -446,7 +447,6 @@ module RGeo
         false
       end
 
-
       # :stopdoc:
 
       IMPL_CLASSES = {
@@ -457,20 +457,14 @@ module RGeo
         Feature::GeometryCollection => CAPIGeometryCollectionImpl,
         Feature::MultiPoint => CAPIMultiPointImpl,
         Feature::MultiLineString => CAPIMultiLineStringImpl,
-        Feature::MultiPolygon => CAPIMultiPolygonImpl,
+        Feature::MultiPolygon => CAPIMultiPolygonImpl
       }.freeze
 
       # :startdoc:
-
-
     end
 
-
     # Deprecated alias of CAPIFactory.
     # Defined primarily to support old YAML serializations.
     Factory = CAPIFactory
-
-
   end
-
 end