ffi-geos 1.2.2 → 2.3.0

data/lib/ffi-geos/geometry.rb

@@ -38,7 +38,7 @@ module Geos
       self.srid = source.srid
     end
 
-    def self.release(ptr) #:nodoc:
+    def self.release(ptr) # :nodoc:
       FFIGeos.GEOSGeom_destroy_r(Geos.current_handle_pointer, ptr)
     end
 
@@ -53,9 +53,7 @@ module Geos
     end
 
     def normalize!
-      if FFIGeos.GEOSNormalize_r(Geos.current_handle_pointer, ptr) == -1
-        raise Geos::Geometry::CouldntNormalizeError, self.class
-      end
+      raise Geos::Geometry::CouldntNormalizeError, self.class if FFIGeos.GEOSNormalize_r(Geos.current_handle_pointer, ptr) == -1
 
       self
     end
@@ -85,9 +83,14 @@ module Geos
       CoordinateSequence.new(FFIGeos.GEOSGeom_getCoordSeq_r(Geos.current_handle_pointer, ptr), false, self)
     end
 
-    def intersection(geom)
+    def intersection(geom, precision: nil)
       check_geometry(geom)
-      cast_geometry_ptr(FFIGeos.GEOSIntersection_r(Geos.current_handle_pointer, ptr, geom.ptr), srid_copy: pick_srid_from_geoms(srid, geom.srid))
+
+      if precision
+        cast_geometry_ptr(FFIGeos.GEOSIntersectionPrec_r(Geos.current_handle_pointer, ptr, geom.ptr, precision), srid_copy: pick_srid_from_geoms(srid, geom.srid))
+      else
+        cast_geometry_ptr(FFIGeos.GEOSIntersection_r(Geos.current_handle_pointer, ptr, geom.ptr), srid_copy: pick_srid_from_geoms(srid, geom.srid))
+      end
     end
 
     if FFIGeos.respond_to?(:GEOSBufferWithParams_r)
@@ -141,14 +144,24 @@ module Geos
       cast_geometry_ptr(FFIGeos.GEOSConvexHull_r(Geos.current_handle_pointer, ptr), srid_copy: srid)
     end
 
-    def difference(geom)
+    def difference(geom, precision: nil)
       check_geometry(geom)
-      cast_geometry_ptr(FFIGeos.GEOSDifference_r(Geos.current_handle_pointer, ptr, geom.ptr), srid_copy: pick_srid_from_geoms(srid, geom.srid))
+
+      if precision
+        cast_geometry_ptr(FFIGeos.GEOSDifferencePrec_r(Geos.current_handle_pointer, ptr, geom.ptr, precision), srid_copy: pick_srid_from_geoms(srid, geom.srid))
+      else
+        cast_geometry_ptr(FFIGeos.GEOSDifference_r(Geos.current_handle_pointer, ptr, geom.ptr), srid_copy: pick_srid_from_geoms(srid, geom.srid))
+      end
     end
 
-    def sym_difference(geom)
+    def sym_difference(geom, precision: nil)
       check_geometry(geom)
-      cast_geometry_ptr(FFIGeos.GEOSSymDifference_r(Geos.current_handle_pointer, ptr, geom.ptr), srid_copy: pick_srid_from_geoms(srid, geom.srid))
+
+      if precision
+        cast_geometry_ptr(FFIGeos.GEOSSymDifferencePrec_r(Geos.current_handle_pointer, ptr, geom.ptr, precision), srid_copy: pick_srid_from_geoms(srid, geom.srid))
+      else
+        cast_geometry_ptr(FFIGeos.GEOSSymDifference_r(Geos.current_handle_pointer, ptr, geom.ptr), srid_copy: pick_srid_from_geoms(srid, geom.srid))
+      end
     end
     alias symmetric_difference sym_difference
 
@@ -159,16 +172,19 @@ module Geos
     # Calling without a geom argument is equivalent to calling unary_union when
     # using GEOS 3.3+ and is equivalent to calling union_cascaded in older
     # versions.
-    def union(geom = nil)
+    def union(geom = nil, precision: nil)
       if geom
         check_geometry(geom)
-        cast_geometry_ptr(FFIGeos.GEOSUnion_r(Geos.current_handle_pointer, ptr, geom.ptr), srid_copy: pick_srid_from_geoms(srid, geom.srid))
-      else
-        if respond_to?(:unary_union)
-          unary_union
+
+        if precision
+          cast_geometry_ptr(FFIGeos.GEOSUnionPrec_r(Geos.current_handle_pointer, ptr, geom.ptr, precision), srid_copy: pick_srid_from_geoms(srid, geom.srid))
         else
-          union_cascaded
+          cast_geometry_ptr(FFIGeos.GEOSUnion_r(Geos.current_handle_pointer, ptr, geom.ptr), srid_copy: pick_srid_from_geoms(srid, geom.srid))
         end
+      elsif respond_to?(:unary_union)
+        unary_union
+      else
+        union_cascaded
       end
     end
 
@@ -176,10 +192,21 @@ module Geos
       cast_geometry_ptr(FFIGeos.GEOSUnionCascaded_r(Geos.current_handle_pointer, ptr), srid_copy: srid)
     end
 
+    if FFIGeos.respond_to?(:GEOSCoverageUnion_r)
+      # Added in GEOS 3.8+
+      def coverage_union
+        cast_geometry_ptr(FFIGeos.GEOSCoverageUnion_r(Geos.current_handle_pointer, ptr), srid_copy: srid)
+      end
+    end
+
     if FFIGeos.respond_to?(:GEOSUnaryUnion_r)
       # Available in GEOS 3.3+
-      def unary_union
-        cast_geometry_ptr(FFIGeos.GEOSUnaryUnion_r(Geos.current_handle_pointer, ptr), srid_copy: srid)
+      def unary_union(precision = nil)
+        if precision
+          cast_geometry_ptr(FFIGeos.GEOSUnaryUnionPrec_r(Geos.current_handle_pointer, ptr, precision), srid_copy: srid)
+        else
+          cast_geometry_ptr(FFIGeos.GEOSUnaryUnion_r(Geos.current_handle_pointer, ptr), srid_copy: srid)
+        end
       end
     end
 
@@ -208,6 +235,14 @@ module Geos
     end
     alias center centroid
 
+    if FFIGeos.respond_to?(:GEOSMinimumBoundingCircle_r)
+      # Added in GEOS 3.8+. Does not yet support the radius or center
+      # arguments.
+      def minimum_bounding_circle
+        cast_geometry_ptr(FFIGeos.GEOSMinimumBoundingCircle_r(Geos.current_handle_pointer, ptr, nil, nil), srid_copy: srid)
+      end
+    end
+
     def envelope
       cast_geometry_ptr(FFIGeos.GEOSEnvelope_r(Geos.current_handle_pointer, ptr), srid_copy: srid)
     end
@@ -295,16 +330,16 @@ module Geos
         bool_result(FFIGeos.GEOSCovers_r(Geos.current_handle_pointer, ptr, geom.ptr))
       end
     else
-      def covers?(geom) #:nodoc:
+      def covers?(geom) # :nodoc:
         check_geometry(geom)
         !!%w{
           T*****FF*
           *T****FF*
           ***T**FF*
           ****T*FF*
-        }.detect do |pattern|
+        }.detect { |pattern|
           relate_pattern(geom, pattern)
-        end
+        }
       end
     end
 
@@ -317,16 +352,16 @@ module Geos
         bool_result(FFIGeos.GEOSCoveredBy_r(Geos.current_handle_pointer, ptr, geom.ptr))
       end
     else
-      def covered_by?(geom) #:nodoc:
+      def covered_by?(geom) # :nodoc:
         check_geometry(geom)
         !!%w{
           T*F**F***
           *TF**F***
           **FT*F***
           **F*TF***
-        }.detect do |pattern|
+        }.detect { |pattern|
           relate_pattern(geom, pattern)
-        end
+        }
       end
     end
 
@@ -351,7 +386,7 @@ module Geos
 
     def eql_almost?(other, decimal = 6)
       check_geometry(other)
-      bool_result(FFIGeos.GEOSEqualsExact_r(Geos.current_handle_pointer, ptr, other.ptr, 0.5 * 10 ** -decimal))
+      bool_result(FFIGeos.GEOSEqualsExact_r(Geos.current_handle_pointer, ptr, other.ptr, 0.5 * (10 ** -decimal)))
     end
     alias equals_almost? eql_almost?
     alias almost_equals? eql_almost?
@@ -406,7 +441,7 @@ module Geos
 
     # GEOS versions prior to 3.3.0 didn't handle exceptions and can crash on
     # bad input.
-    if FFIGeos.respond_to?(:GEOSProject_r) && Geos::GEOS_VERSION >= '3.3.0'
+    if FFIGeos.respond_to?(:GEOSProject_r) && Geos::GEOS_NICE_VERSION >= '030300'
       def project(geom, normalized = false)
         raise TypeError, 'Expected Geos::Point type' unless geom.is_a?(Geos::Point)
 
@@ -467,6 +502,17 @@ module Geos
       double_ptr.read_double
     end
 
+    if FFIGeos.respond_to?(:GEOSDistanceIndexed_r)
+      # Available in GEOS 3.7+.
+      def distance_indexed(geom)
+        check_geometry(geom)
+        double_ptr = FFI::MemoryPointer.new(:double)
+        FFIGeos.GEOSDistanceIndexed_r(Geos.current_handle_pointer, ptr, geom.ptr, double_ptr)
+        double_ptr.read_double
+      end
+      alias indexed_distance distance_indexed
+    end
+
     def hausdorff_distance(geom, densify_frac = nil)
       check_geometry(geom)
 
@@ -529,20 +575,49 @@ module Geos
       }
     end
 
-    def polygonize
-      ary = FFI::MemoryPointer.new(:pointer)
-      ary.write_array_of_pointer([ ptr ])
+    def polygonize(*geoms)
+      geoms.each do |geom|
+        raise ArgumentError unless geom.is_a?(Geos::Geometry)
+      end
+
+      ary = [ptr].concat(geoms.collect(&:ptr))
+      ary_ptr = FFI::MemoryPointer.new(:pointer, ary.length)
+      ary_ptr.write_array_of_pointer(ary)
+
+      cast_geometry_ptr(FFIGeos.GEOSPolygonize_r(Geos.current_handle_pointer, ary_ptr, ary.length), srid_copy: srid).to_a
+    end
+
+    if FFIGeos.respond_to?(:GEOSPolygonize_valid_r)
+      # Added in GEOS 3.8+
+      def polygonize_valid
+        ary = FFI::MemoryPointer.new(:pointer)
+        ary.write_array_of_pointer([ptr])
 
-      cast_geometry_ptr(FFIGeos.GEOSPolygonize_r(Geos.current_handle_pointer, ary, 1), srid_copy: srid).to_a
+        cast_geometry_ptr(FFIGeos.GEOSPolygonize_valid_r(Geos.current_handle_pointer, ary, 1), srid_copy: srid)
+      end
     end
 
     def polygonize_cut_edges
       ary = FFI::MemoryPointer.new(:pointer)
-      ary.write_array_of_pointer([ ptr ])
+      ary.write_array_of_pointer([ptr])
 
       cast_geometry_ptr(FFIGeos.GEOSPolygonizer_getCutEdges_r(Geos.current_handle_pointer, ary, 1), srid_copy: srid).to_a
     end
 
+    if FFIGeos.respond_to?(:GEOSBuildArea_r)
+      # Added in GEOS 3.8+
+      def build_area
+        cast_geometry_ptr(FFIGeos.GEOSBuildArea_r(Geos.current_handle_pointer, ptr))
+      end
+    end
+
+    if FFIGeos.respond_to?(:GEOSMakeValid_r)
+      # Added in GEOS 3.8+
+      def make_valid
+        cast_geometry_ptr(FFIGeos.GEOSMakeValid_r(Geos.current_handle_pointer, ptr))
+      end
+    end
+
     if FFIGeos.respond_to?(:GEOSDelaunayTriangulation_r)
       # :call-seq:
       #   delaunay_triangulation(options = {})
@@ -644,6 +719,18 @@ module Geos
       end
     end
 
+    if FFIGeos.respond_to?(:GEOSMaximumInscribedCircle_r)
+      def maximum_inscribed_circle(precision)
+        cast_geometry_ptr(FFIGeos.GEOSMaximumInscribedCircle_r(Geos.current_handle_pointer, ptr, precision))
+      end
+    end
+
+    if FFIGeos.respond_to?(:GEOSLargestEmptyCircle_r)
+      def largest_empty_circle(precision, boundary: nil)
+        cast_geometry_ptr(FFIGeos.GEOSLargestEmptyCircle_r(Geos.current_handle_pointer, ptr, boundary ? boundary.ptr : nil, precision))
+      end
+    end
+
     if FFIGeos.respond_to?(:GEOSMinimumWidth_r)
       def minimum_width
         cast_geometry_ptr(FFIGeos.GEOSMinimumWidth_r(Geos.current_handle_pointer, ptr))

data/lib/ffi-geos/geometry_collection.rb

@@ -46,13 +46,27 @@ module Geos
 
     %w{ x y z }.each do |dimension|
       %w{ max min }.each do |op|
-        self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
-          def #{dimension}_#{op}
-            unless self.empty?
-              self.collect(&:#{dimension}_#{op}).#{op}
+        native_method = "GEOSGeom_get#{dimension.upcase}#{op[0].upcase}#{op[1..-1]}_r"
+
+        if FFIGeos.respond_to?(native_method)
+          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def #{dimension}_#{op}
+              return if empty?
+
+              double_ptr = FFI::MemoryPointer.new(:double)
+              FFIGeos.#{native_method}(Geos.current_handle_pointer, ptr, double_ptr)
+              double_ptr.read_double
             end
-          end
-        EOF
+          RUBY
+        else
+          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def #{dimension}_#{op}
+              unless self.empty?
+                self.collect(&:#{dimension}_#{op}).#{op}
+              end
+            end
+          RUBY
+        end
       end
     end
 
@@ -67,23 +81,23 @@ module Geos
       trans_scale
       translate
     }.each do |m|
-      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
-        def #{m}!(*args)
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def #{m}!(*args, **kwargs)
           unless self.empty?
             self.num_geometries.times do |i|
-              self[i].#{m}!(*args)
+              self[i].#{m}!(*args, **kwargs)
             end
           end
 
           self
         end
 
-        def #{m}(*args)
-          ret = self.dup.#{m}!(*args)
+        def #{m}(*args, **kwargs)
+          ret = self.dup.#{m}!(*args, **kwargs)
           ret.srid = pick_srid_according_to_policy(self.srid)
           ret
         end
-      EOF
+      RUBY
     end
   end
 end

data/lib/ffi-geos/interrupt.rb

@@ -25,23 +25,20 @@ module Geos
         # collector may not play nicely with GEOS and objects may get cleaned
         # up in unexpected ways while interrupts are firing.
         def register(method_or_block = nil, &block)
-          if method_or_block.nil? && !block_given?
-            raise ArgumentError, 'Expected either a method or a block for Geos::Interrupt.register'
-          elsif !method_or_block.nil? && block_given?
-            raise ArgumentError, 'Cannot use both a method and a block for Geos::Interrupt.register'
-          else
-            retval = @current_interrupt_callback
+          raise ArgumentError, 'Expected either a method or a block for Geos::Interrupt.register' if method_or_block.nil? && !block_given?
+          raise ArgumentError, 'Cannot use both a method and a block for Geos::Interrupt.register' if !method_or_block.nil? && block_given?
 
-            @current_interrupt_callback = if method_or_block
-              FFIGeos.GEOS_interruptRegisterCallback(method_or_block)
-              method_or_block
-            elsif block_given?
-              FFIGeos.GEOS_interruptRegisterCallback(block)
-              block
-            end
+          retval = @current_interrupt_callback
 
-            retval
+          @current_interrupt_callback = if method_or_block
+            FFIGeos.GEOS_interruptRegisterCallback(method_or_block)
+            method_or_block
+          elsif block_given?
+            FFIGeos.GEOS_interruptRegisterCallback(block)
+            block
           end
+
+          retval
         end
 
         # Interrupt the current operation. This method should generally be

data/lib/ffi-geos/line_string.rb

@@ -28,7 +28,7 @@ module Geos
     end
 
     def point_n(n)
-      raise Geos::IndexBoundsError if n < 0 || n >= num_points
+      raise Geos::IndexBoundsError if n.negative? || n >= num_points
 
       cast_geometry_ptr(FFIGeos.GEOSGeomGetPointN_r(Geos.current_handle_pointer, ptr, n), srid_copy: srid)
     end
@@ -42,17 +42,20 @@ module Geos
     end
     alias slice []
 
-    def offset_curve(width, options = {})
+    def offset_curve(width, **options)
       options = Constants::BUFFER_PARAM_DEFAULTS.merge(options)
 
-      cast_geometry_ptr(FFIGeos.GEOSOffsetCurve_r(
-        Geos.current_handle_pointer,
-        ptr,
-        width,
-        options[:quad_segs],
-        options[:join],
-        options[:mitre_limit]
-      ), srid_copy: srid)
+      cast_geometry_ptr(
+        FFIGeos.GEOSOffsetCurve_r(
+          Geos.current_handle_pointer,
+          ptr,
+          width,
+          options[:quad_segs],
+          options[:join],
+          options[:mitre_limit]
+        ),
+        srid_copy: srid
+      )
     end
 
     if FFIGeos.respond_to?(:GEOSisClosed_r)
@@ -78,14 +81,14 @@ module Geos
       cur_path.concat(to_a)
     end
 
-    def snap_to_grid!(*args)
-      if !self.empty?
-        cs = self.coord_seq.snap_to_grid!(*args)
+    def snap_to_grid!(*args, **)
+      unless empty?
+        cs = coord_seq.snap_to_grid!(*args)
 
-        if cs.length == 0
-          @ptr = Geos.create_empty_line_string(:srid => self.srid).ptr
+        if cs.empty?
+          @ptr = Geos.create_empty_line_string(srid: srid).ptr
         elsif cs.length <= 1
-          raise Geos::InvalidGeometryError.new("snap_to_grid! produced an invalid number of points in for a LineString - found #{cs.length} - must be 0 or > 1")
+          raise Geos::InvalidGeometryError, "snap_to_grid! produced an invalid number of points in for a LineString - found #{cs.length} - must be 0 or > 1"
         else
           @ptr = Geos.create_line_string(cs).ptr
         end
@@ -94,42 +97,40 @@ module Geos
       self
     end
 
-    def snap_to_grid(*args)
-      ret = self.dup.snap_to_grid!(*args)
-      ret.srid = pick_srid_according_to_policy(self.srid)
+    def snap_to_grid(*args, **)
+      ret = dup.snap_to_grid!(*args)
+      ret.srid = pick_srid_according_to_policy(srid)
       ret
     end
 
     def line_interpolate_point(fraction)
-      if !fraction.between?(0, 1)
-        raise ArgumentError.new("fraction must be between 0 and 1")
-      end
+      raise ArgumentError, 'fraction must be between 0 and 1' unless fraction.between?(0, 1)
 
       case fraction
         when 0
-          self.start_point
+          start_point
         when 1
-          self.end_point
+          end_point
         else
           length = self.length
           total_length = 0
-          segs = self.num_points - 1
+          segs = num_points - 1
 
           segs.times do |i|
-            p1 = self[i]
-            p2 = self[i + 1]
+            p_1 = self[i]
+            p_2 = self[i + 1]
 
-            seg_length = p1.distance(p2) / length
+            seg_length = p_1.distance(p_2) / length
 
             if fraction < total_length + seg_length
-              dseg = (fraction - total_length) / seg_length;
+              dseg = (fraction - total_length) / seg_length
 
               args = []
-              args << p1.x + ((p2.x - p1.x) * dseg)
-              args << p1.y + ((p2.y - p1.y) * dseg)
-              args << p1.z + ((p2.z - p1.z) * dseg) if self.has_z?
+              args << (p_1.x + ((p_2.x - p_1.x) * dseg))
+              args << (p_1.y + ((p_2.y - p_1.y) * dseg))
+              args << (p_1.z + ((p_2.z - p_1.z) * dseg)) if has_z?
 
-              args << { :srid => pick_srid_according_to_policy(self.srid) } unless self.srid == 0
+              args << { srid: pick_srid_according_to_policy(srid) } unless srid.zero?
 
               return Geos.create_point(*args)
             end
@@ -138,23 +139,37 @@ module Geos
           end
 
           # if all else fails...
-          self.end_point
+          end_point
       end
     end
-    alias_method :interpolate_point, :line_interpolate_point
+    alias interpolate_point line_interpolate_point
 
     %w{ max min }.each do |op|
       %w{ x y }.each do |dimension|
-        self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
-          def #{dimension}_#{op}
-            unless self.empty?
-              self.coord_seq.#{dimension}_#{op}
+        native_method = "GEOSGeom_get#{dimension.upcase}#{op[0].upcase}#{op[1..-1]}_r"
+
+        if FFIGeos.respond_to?(native_method)
+          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def #{dimension}_#{op}
+              return if empty?
+
+              double_ptr = FFI::MemoryPointer.new(:double)
+              FFIGeos.#{native_method}(Geos.current_handle_pointer, ptr, double_ptr)
+              double_ptr.read_double
             end
-          end
-        EOF
+          RUBY
+        else
+          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def #{dimension}_#{op}
+              unless self.empty?
+                self.coord_seq.#{dimension}_#{op}
+              end
+            end
+          RUBY
+        end
       end
 
-      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
         def z_#{op}
           unless self.empty?
             if self.has_z?
@@ -164,7 +179,7 @@ module Geos
             end
           end
         end
-      EOF
+      RUBY
     end
 
     %w{
@@ -177,21 +192,21 @@ module Geos
       trans_scale
       translate
     }.each do |m|
-      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
-        def #{m}!(*args)
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def #{m}!(*args, **kwargs)
           unless self.empty?
-            self.coord_seq.#{m}!(*args)
+            self.coord_seq.#{m}!(*args, **kwargs)
           end
 
           self
         end
 
-        def #{m}(*args)
-          ret = self.dup.#{m}!(*args)
+        def #{m}(*args, **kwargs)
+          ret = self.dup.#{m}!(*args, **kwargs)
           ret.srid = pick_srid_according_to_policy(self.srid)
           ret
         end
-      EOF
+      RUBY
     end
   end
 end

data/lib/ffi-geos/multi_line_string.rb

@@ -2,7 +2,7 @@
 
 module Geos
   class MultiLineString < GeometryCollection
-    if FFIGeos.respond_to?(:GEOSisClosed_r) && Geos::GEOS_VERSION >= '3.5.0'
+    if FFIGeos.respond_to?(:GEOSisClosed_r) && Geos::GEOS_NICE_VERSION >= '030500'
       # Available in GEOS 3.5.0+.
       def closed?
         bool_result(FFIGeos.GEOSisClosed_r(Geos.current_handle_pointer, ptr))

data/lib/ffi-geos/point.rb

@@ -79,31 +79,31 @@ module Geos
     end
 
     def dump_points(cur_path = [])
-      cur_path.push(self.dup)
+      cur_path.push(dup)
     end
 
     %w{ max min }.each do |op|
       %w{ x y }.each do |dimension|
-        self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
           def #{dimension}_#{op}
-            unless self.empty?
-              self.#{dimension}
+            unless empty?
+              #{dimension}
             end
           end
-        EOF
+        RUBY
       end
 
-      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
         def z_#{op}
-          unless self.empty?
-            if self.has_z?
-              self.z
+          unless empty?
+            if has_z?
+              z
             else
               0
             end
           end
         end
-      EOF
+      RUBY
     end
 
     %w{
@@ -117,21 +117,21 @@ module Geos
       trans_scale
       translate
     }.each do |m|
-      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
-        def #{m}!(*args)
-          unless self.empty?
-            self.coord_seq.#{m}!(*args)
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def #{m}!(*args, **kwargs)
+          unless empty?
+            coord_seq.#{m}!(*args, **kwargs)
           end
 
           self
         end
 
-        def #{m}(*args)
-          ret = self.dup.#{m}!(*args)
-          ret.srid = pick_srid_according_to_policy(self.srid)
+        def #{m}(*args, **kwargs)
+          ret = dup.#{m}!(*args, **kwargs)
+          ret.srid = pick_srid_according_to_policy(srid)
           ret
         end
-      EOF
+      RUBY
     end
   end
 end