ffi-gdal 1.0.0.beta16 → 1.0.0

data/lib/gdal/warp_operation.rb

@@ -4,95 +4,106 @@ require_relative '../gdal'
 
 module GDAL
   class WarpOperation
+    # @param pointer [FFI::Pointer]
+    def self.release(pointer)
+      return unless pointer && !pointer.null?
+
+      FFI::GDAL::Warper.GDALDestroyWarpOperation(pointer)
+    end
+
     # @return [FFI::Pointer]
     attr_reader :c_pointer
 
     # @param warp_options [GDAL::WarpOptions]
     def initialize(warp_options)
-      @c_pointer = FFI::GDAL::Warper.GDALCreateWarpOperation(warp_options.c_struct)
-      raise GDAL::Error, 'Unable to create warp operation' if @c_pointer.null?
+      pointer = FFI::GDAL::Warper.GDALCreateWarpOperation(warp_options.c_struct)
+
+      raise GDAL::Error, 'Unable to create warp operation' if pointer.null?
+
+      @c_pointer = FFI::AutoPointer.new(pointer, WarpOperation.method(:release))
     end
 
     def destroy!
-      return unless @c_pointer
+      WarpOperation.release(@c_pointer)
 
-      FFI::GDAL::Warper.GDALDestroyWarpOperation(@c_pointer)
       @c_pointer = nil
     end
 
-    # @param x_offset [Fixnum] X offset of the destination image.
-    # @param y_offset [Fixnum] Y offset of the destination image.
-    # @param x_size [Fixnum] X size (width) of the destination image.
-    # @param y_size [Fixnum] Y size (height) of the destination image.
+    # @param x_offset [Integer] X offset of the destination image.
+    # @param y_offset [Integer] Y offset of the destination image.
+    # @param x_size [Integer] X size (width) of the destination image.
+    # @param y_size [Integer] Y size (height) of the destination image.
     def chunk_and_warp_image(x_offset, y_offset, x_size, y_size)
       !!FFI::GDAL::Warper.GDALChunkAndWarpImage(@c_pointer,
-        x_offset,
-        y_offset,
-        x_size,
-        y_size)
+                                                x_offset,
+                                                y_offset,
+                                                x_size,
+                                                y_size)
     end
 
-    # @param x_offset [Fixnum] X offset of the destination image.
-    # @param y_offset [Fixnum] Y offset of the destination image.
-    # @param x_size [Fixnum] X size (width) of the destination image.
-    # @param y_size [Fixnum] Y size (height) of the destination image.
+    # @param x_offset [Integer] X offset of the destination image.
+    # @param y_offset [Integer] Y offset of the destination image.
+    # @param x_size [Integer] X size (width) of the destination image.
+    # @param y_size [Integer] Y size (height) of the destination image.
     def chunk_and_warp_multi(x_offset, y_offset, x_size, y_size)
       FFI::GDAL::Warper.GDALChunkAndWarpMulti(@c_pointer,
-        x_offset,
-        y_offset,
-        x_size,
-        y_size)
+                                              x_offset,
+                                              y_offset,
+                                              x_size,
+                                              y_size)
     end
 
-    # @param destination_x_offset [Fixnum] X offset of the destination image.
-    # @param destination_y_offset [Fixnum] Y offset of the destination image.
-    # @param destination_x_size [Fixnum] X size (width) of the destination image.
-    # @param destination_y_size [Fixnum] Y size (height) of the destination image.
-    # @param source_x_offset [Fixnum] X offset of the source image.
-    # @param source_y_offset [Fixnum] Y offset of the source image.
-    # @param source_x_size [Fixnum] X size (width) of the source image.
-    # @param source_y_size [Fixnum] Y size (height) of the source image.
+    # @param destination_x_offset [Integer] X offset of the destination image.
+    # @param destination_y_offset [Integer] Y offset of the destination image.
+    # @param destination_x_size [Integer] X size (width) of the destination image.
+    # @param destination_y_size [Integer] Y size (height) of the destination image.
+    # @param source_x_offset [Integer] X offset of the source image.
+    # @param source_y_offset [Integer] Y offset of the source image.
+    # @param source_x_size [Integer] X size (width) of the source image.
+    # @param source_y_size [Integer] Y size (height) of the source image.
     def warp_region(destination_x_offset, destination_y_offset,
       destination_x_size, destination_y_size,
       source_x_offset, source_y_offset,
       source_x_size, source_y_size)
       !!FFI::GDAL::Warper.GDALWarpRegion(@c_pointer,
-        destination_x_offset,
-        destination_y_offset,
-        destination_x_size,
-        destination_y_size,
-        source_x_offset,
-        source_y_offset,
-        source_x_size,
-        source_y_size)
+                                         destination_x_offset,
+                                         destination_y_offset,
+                                         destination_x_size,
+                                         destination_y_size,
+                                         source_x_offset,
+                                         source_y_offset,
+                                         source_x_size,
+                                         source_y_size)
     end
 
-    # @param destination_x_offset [Fixnum] X offset of the destination image.
-    # @param destination_y_offset [Fixnum] Y offset of the destination image.
-    # @param destination_x_size [Fixnum] X size (width) of the destination image.
-    # @param destination_y_size [Fixnum] Y size (height) of the destination image.
+    # @param destination_x_offset [Integer] X offset of the destination image.
+    # @param destination_y_offset [Integer] Y offset of the destination image.
+    # @param destination_x_size [Integer] X size (width) of the destination image.
+    # @param destination_y_size [Integer] Y size (height) of the destination image.
     # @param buffer [FFI::Pointer]
     # @param data_type [FFI::GDAL::DataType]
-    # @param source_x_offset [Fixnum] X offset of the source image.
-    # @param source_y_offset [Fixnum] Y offset of the source image.
-    # @param source_x_size [Fixnum] X size (width) of the source image.
-    # @param source_y_size [Fixnum] Y size (height) of the source image.
+    # @param source_x_offset [Integer] X offset of the source image.
+    # @param source_y_offset [Integer] Y offset of the source image.
+    # @param source_x_size [Integer] X size (width) of the source image.
+    # @param source_y_size [Integer] Y size (height) of the source image.
+    # rubocop:disable Metrics/ParameterLists
     def warp_region_to_buffer(destination_x_offset, destination_y_offset,
       destination_x_size, destination_y_size,
       buffer, data_type,
       source_x_offset, source_y_offset,
       source_x_size, source_y_size)
       !!FFI::GDAL::Warper.GDALWarpRegionToBuffer(@c_pointer,
-        destination_x_offset,
-        destination_y_offset,
-        destination_x_size,
-        destination_y_size,
-        buffer,
-        data_type,
-        source_x_offset,
-        source_y_offset,
-        source_x_size,
-        source_y_size)
+                                                 destination_x_offset,
+                                                 destination_y_offset,
+                                                 destination_x_size,
+                                                 destination_y_size,
+                                                 buffer,
+                                                 data_type,
+                                                 source_x_offset,
+                                                 source_y_offset,
+                                                 source_x_size,
+                                                 source_y_size)
     end
+    # rubocop:enable Metrics/ParameterLists
   end
 end

data/lib/gdal/warp_options.rb

@@ -4,10 +4,7 @@ require_relative '../gdal'
 
 module GDAL
   class WarpOptions
-    attr_reader :c_struct
-    attr_reader :source_dataset
-    attr_reader :destination_dataset
-    attr_reader :cutline
+    attr_reader :c_struct, :source_dataset, :destination_dataset, :cutline
 
     def initialize(options = {})
       @c_struct = FFI::GDAL::WarpOptions.new
@@ -23,8 +20,8 @@ module GDAL
           else
             @c_struct[k] = options[k]
           end
-        rescue ArgumentError => ex
-          new_message = "#{k}; #{ex.message}"
+        rescue ArgumentError => e
+          new_message = "#{k}; #{e.message}"
           raise $ERROR_INFO, new_message, $ERROR_INFO.backtrace
         end
       end
@@ -58,7 +55,7 @@ module GDAL
       @c_struct[:destination_dataset] = dataset.c_pointer
     end
 
-    # @param band_numbers [Array<Fixnum>]
+    # @param band_numbers [Array<Integer>]
     def source_bands=(band_numbers)
       bands_ptr = FFI::MemoryPointer.new(:int, band_numbers.length)
       bands_ptr.write_array_of_int(band_numbers)
@@ -67,7 +64,7 @@ module GDAL
       @c_struct[:band_count] = band_numbers.length if band_numbers.length > @c_struct[:band_count]
     end
 
-    # @return [Array<Fixnum>]
+    # @return [Array<Integer>]
     def source_bands
       pointer = @c_struct[:source_bands]
       return [] if pointer.null?
@@ -75,7 +72,7 @@ module GDAL
       pointer.read_array_of_int(@c_struct[:band_count])
     end
 
-    # @param band_numbers [Array<Fixnum>]
+    # @param band_numbers [Array<Integer>]
     def destination_bands=(band_numbers)
       bands_ptr = FFI::MemoryPointer.new(:pointer, band_numbers.length)
       bands_ptr.write_array_of_int(band_numbers)
@@ -84,7 +81,7 @@ module GDAL
       @c_struct[:band_count] = band_numbers.length if band_numbers.length > @c_struct[:band_count]
     end
 
-    # @return [Array<Fixnum>]
+    # @return [Array<Integer>]
     def destination_bands
       pointer = @c_struct[:destination_bands]
       return [] if pointer.null?
@@ -101,6 +98,7 @@ module GDAL
     # @param geometry [OGR::Geometry]
     def cutline=(geometry)
       raise 'Not a geom' unless geometry.is_a?(OGR::Geometry)
+
       @cutline = geometry
 
       @c_struct[:cutline] = geometry.c_pointer
@@ -171,7 +169,7 @@ module GDAL
     end
 
     # Set a Proc per source band; number of procs in +band_procs+ should equal
-    # {band_count}.
+    # the internal +band_count+.
     #
     # @param band_procs [Array<Proc>]
     def source_per_band_validity_mask_function=(band_procs)

data/lib/ogr/coordinate_transformation.rb

@@ -13,10 +13,17 @@ module OGR
         FFI::GDAL::GDAL.OCTProj4Normalize(proj4_source)
       else
         raise OGR::UnsupportedOperation,
-          'Your version of GDAL/OGR does not support OCTProj4Normalize'
+              'Your version of GDAL/OGR does not support OCTProj4Normalize'
       end
     end
 
+    # @param pointer [FFI::Pointer]
+    def self.release(pointer)
+      return unless pointer && !pointer.null?
+
+      FFI::OGR::SRSAPI.OCTDestroyCoordinateTransformation(pointer)
+    end
+
     # @return [OGR::SpatialReference]
     attr_reader :source_coordinate_system
 
@@ -31,16 +38,23 @@ module OGR
     def initialize(source_srs, destination_srs)
       source_ptr = GDAL._pointer(OGR::SpatialReference, source_srs)
       destination_ptr = GDAL._pointer(OGR::SpatialReference, destination_srs)
-      @c_pointer = FFI::OGR::SRSAPI.OCTNewCoordinateTransformation(source_ptr, destination_ptr)
 
-      raise OGR::Failure, 'Unable to create coordinate transformation' if @c_pointer.null?
+      # Input spatial reference system objects are assigned by copy (calling clone() method)
+      # and no ownership transfer occurs.
+      # NOTE: In GDAL 3, this will cause the GDAL error handler to raise a
+      # GDAL::Error; in < 3, this just returns a null pointer, then gets handled
+      # by the null-pointer check below.
+      pointer = FFI::OGR::SRSAPI.OCTNewCoordinateTransformation(source_ptr, destination_ptr)
+
+      raise GDAL::Error, 'Unable to create coordinate transformation' if pointer.null?
+
+      @c_pointer = pointer
     end
 
     # Deletes the object and deallocates all related C resources.
     def destroy!
-      return unless @c_pointer
+      CoordinateTransformation.release(@c_pointer)
 
-      FFI::OGR::SRSAPI.OCTDestroyCoordinateTransformation(@c_pointer)
       @c_pointer = nil
     end
 
@@ -83,10 +97,10 @@ module OGR
     # @param x_vertices [Array<Float>]
     # @param y_vertices [Array<Float>]
     # @param z_vertices [Array<Float>]
-    # @yieldparam point_count [Fixnum]
-    # @yieldparam x_ptr [FFI::MemortyPointer]
-    # @yieldparam y_ptr [FFI::MemortyPointer]
-    # @yieldparam z_ptr [FFI::MemortyPointer]
+    # @yieldparam point_count [Integer]
+    # @yieldparam x_ptr [FFI::MemoryPointer]
+    # @yieldparam y_ptr [FFI::MemoryPointer]
+    # @yieldparam z_ptr [FFI::MemoryPointer]
     # @yieldreturn [Boolean]
     # @return [Array<Array<Float>,Array<Float>,Array<Float>>] [[x1, x2, etc], [y1, y2, etc]]
     #   Will include a 3rd array of Z values if z vertices are given.

data/lib/ogr/data_source.rb

@@ -1,18 +1,13 @@
 # frozen_string_literal: true
 
-require 'json'
 require_relative '../gdal'
 require_relative '../ogr'
-require_relative 'data_source_extensions'
-require_relative 'data_source_mixins/capability_methods'
 require_relative '../gdal/major_object'
 
 module OGR
   class DataSource
     include GDAL::MajorObject
     include GDAL::Logger
-    include DataSourceExtensions
-    include DataSourceMixins::CapabilityMethods
 
     # Same as +.new+.
     #
@@ -31,6 +26,23 @@ module OGR
       end
     end
 
+    # @param pointer [FFI::Pointer]
+    def self.release(pointer)
+      return unless pointer && !pointer.null?
+
+      FFI::OGR::API.OGR_DS_Destroy(pointer)
+    end
+
+    # Use to release the resulting data pointer from #execute_sql.
+    #
+    # @param data_source_pointer [FFI::Pointer]
+    # @param layer_pointer [FFI::Pointer]
+    def self.release_result_set(data_source_pointer, layer_pointer)
+      return unless data_source_pointer && !data_source_pointer.null? && layer_pointer && !layer_pointer.null?
+
+      FFI::OGR::API.OGR_DS_ReleaseResultSet(data_source_pointer, layer_pointer)
+    end
+
     # @return [FFI::Pointer]
     attr_reader :c_pointer
 
@@ -45,16 +57,23 @@ module OGR
           path_or_pointer
         end
 
-      raise OGR::OpenFailure, path_or_pointer if @c_pointer.null?
+      if @c_pointer.null?
+        error_msg, ptr = FFI::CPL::Error.CPLGetLastErrorMsg
+        ptr.autorelease = false
+
+        error_type = FFI::CPL::Error.CPLGetLastErrorType
+        FFI::CPL::Error.CPLErrorReset
+
+        raise OGR::OpenFailure, "#{error_type}: #{error_msg} (#{path_or_pointer})"
+      end
 
       @layers = []
     end
 
     # Closes opened data source and releases allocated resources.
     def destroy!
-      return unless @c_pointer
+      DataSource.release(@c_pointer)
 
-      FFI::OGR::API.OGR_DS_Destroy(@c_pointer)
       @c_pointer = nil
     end
     alias close destroy!
@@ -63,7 +82,11 @@ module OGR
     #
     # @return [String]
     def name
-      FFI::OGR::API.OGR_DS_GetName(@c_pointer)
+      # This is an internal string and should not be modified or freed.
+      name_ptr = FFI::OGR::API.OGR_DS_GetName(@c_pointer)
+      name_ptr.autorelease = false
+
+      name_ptr.read_string_to_null
     end
 
     # @return [OGR::Driver]
@@ -74,16 +97,19 @@ module OGR
       OGR::Driver.new(driver_ptr)
     end
 
-    # @return [Fixnum]
+    # @return [Integer]
     def layer_count
       FFI::OGR::API.OGR_DS_GetLayerCount(@c_pointer)
     end
 
-    # @param index [Fixnum] 0-offset index of the layer to retrieve.
+    # @param index [Integer] 0-offset index of the layer to retrieve.
     # @return [OGR::Layer]
     def layer(index)
       @layers.fetch(index) do
+        # The returned layer remains owned by the OGRDataSource and should not be deleted by the application.
         layer_pointer = FFI::OGR::API.OGR_DS_GetLayer(@c_pointer, index)
+        layer_pointer.autorelease = false
+
         return nil if layer_pointer.null?
 
         l = OGR::Layer.new(layer_pointer)
@@ -96,7 +122,10 @@ module OGR
     # @param name [String]
     # @return [OGR::Layer]
     def layer_by_name(name)
+      # The returned layer remains owned by the OGRDataSource and should not be deleted by the application.
       layer_pointer = FFI::OGR::API.OGR_DS_GetLayerByName(@c_pointer, name)
+      layer_pointer.autorelease = false
+
       return nil if layer_pointer.null?
 
       OGR::Layer.new(layer_pointer)
@@ -109,13 +138,16 @@ module OGR
     # @param options [Hash] Driver-specific options.
     # @return [OGR::Layer]
     def create_layer(name, geometry_type: :wkbUnknown, spatial_reference: nil, **options)
-      raise OGR::UnsupportedOperation, 'This data source does not support creating layers.' unless can_create_layer?
+      unless test_capability('CreateLayer')
+        raise OGR::UnsupportedOperation,
+              'This data source does not support creating layers.'
+      end
 
-      spatial_ref_ptr = GDAL._pointer(OGR::SpatialReference, spatial_reference) if spatial_reference
+      spatial_ref_ptr = GDAL._pointer(OGR::SpatialReference, spatial_reference, autorelease: false) if spatial_reference
       options_obj = GDAL::Options.pointer(options)
 
-      layer_ptr = FFI::OGR::API.OGR_DS_CreateLayer(@c_pointer, name,
-        spatial_ref_ptr, geometry_type, options_obj)
+      layer_ptr =
+        FFI::OGR::API.OGR_DS_CreateLayer(@c_pointer, name, spatial_ref_ptr, geometry_type, options_obj)
 
       raise OGR::InvalidLayer, "Unable to create layer '#{name}'." unless layer_ptr
 
@@ -133,20 +165,23 @@ module OGR
       options_ptr = GDAL::Options.pointer(options)
 
       layer_ptr = FFI::OGR::API.OGR_DS_CopyLayer(@c_pointer, source_layer_ptr,
-        new_name, options_ptr)
+                                                 new_name, options_ptr)
       return nil if layer_ptr.null?
 
       OGR::Layer.new(layer_ptr)
     end
 
-    # @param index [Fixnum]
-    # @return +true+ if successful, otherwise raises an OGR exception.
+    # @param index [Integer]
+    # @raise [OGR::Failure]
     def delete_layer(index)
-      raise OGR::UnsupportedOperation, 'This data source does not support deleting layers.' unless can_delete_layer?
-
-      ogr_err = FFI::OGR::API.OGR_DS_DeleteLayer(@c_pointer, index)
+      unless test_capability('DeleteLayer')
+        raise OGR::UnsupportedOperation,
+              'This data source does not support deleting layers.'
+      end
 
-      ogr_err.handle_result "Unable to delete layer #{index}"
+      OGR::ErrorHandling.handle_ogr_err("Unable to delete layer at index #{index}") do
+        FFI::OGR::API.OGR_DS_DeleteLayer(@c_pointer, index)
+      end
     end
 
     # @param command [String] The SQL to execute.
@@ -158,25 +193,21 @@ module OGR
     def execute_sql(command, spatial_filter = nil, dialect = nil)
       geometry_ptr = GDAL._pointer(OGR::Geometry, spatial_filter) if spatial_filter
 
-      layer_ptr = FFI::OGR::API.OGR_DS_ExecuteSQL(@c_pointer, command, geometry_ptr,
-        dialect)
+      layer_ptr = FFI::OGR::API.OGR_DS_ExecuteSQL(@c_pointer, command, geometry_ptr, dialect)
+      layer_ptr.autorelease = false
 
       return nil if layer_ptr.null?
 
-      OGR::Layer.new(layer_ptr)
-    end
-
-    # Use to release the resulting data pointer from #execute_sql.
-    #
-    # @param layer [OGR::Layer, FFI::Pointer]
-    def release_result_set(layer)
-      layer_ptr = GDAL._pointer(OGR::Layer, layer)
-      FFI::OGR::API.OGR_DS_ReleaseResultSet(@c_pointer, layer_ptr)
+      OGR::Layer.new(FFI::AutoPointer.new(layer_ptr, lambda { |ptr|
+        DataSource.release_result_set(@c_pointer, ptr)
+      }))
     end
 
     # @return [OGR::StyleTable, nil]
     def style_table
       style_table_ptr = FFI::OGR::API.OGR_DS_GetStyleTable(@c_pointer)
+      style_table_ptr.autorelease = false
+
       return nil if style_table_ptr.null?
 
       OGR::StyleTable.new(style_table_ptr)
@@ -203,11 +234,11 @@ module OGR
       FFI::OGR::API.OGR_DS_TestCapability(@c_pointer, capability)
     end
 
-    # @return [Boolean]
+    # @raise [OGR::Failure]
     def sync_to_disk
-      ogr_err = FFI::OGR::API.OGR_DS_SyncToDisk(@c_pointer)
-
-      ogr_err.handle_result
+      OGR::ErrorHandling.handle_ogr_err('Unable to syn datasource to disk') do
+        FFI::OGR::API.OGR_DS_SyncToDisk(@c_pointer)
+      end
     end
   end
 end

data/lib/ogr/driver.rb

@@ -3,7 +3,6 @@
 require_relative '../ogr'
 require_relative '../gdal'
 require_relative '../gdal/major_object'
-require_relative 'driver_mixins/capability_methods'
 
 module OGR
   # Wrapper for OGR's Driver class.  In this case, to use a driver, find the
@@ -14,9 +13,8 @@ module OGR
   class Driver
     include GDAL::MajorObject
     include GDAL::Logger
-    include DriverMixins::CapabilityMethods
 
-    # @return [Fixnum]
+    # @return [Integer]
     def self.count
       FFI::OGR::API.OGRGetDriverCount
     end
@@ -31,7 +29,7 @@ module OGR
       new(driver_ptr)
     end
 
-    # @param index [Fixnum] Index of the registered driver.  Must be less than
+    # @param index [Integer] Index of the registered driver.  Must be less than
     #   OGR::Driver.count.
     # @return [OGR::Driver]
     # @raise [OGR::DriverNotFound] if a driver at +index+ isn't found.
@@ -39,7 +37,6 @@ module OGR
       raise OGR::DriverNotFound, index if index > count
 
       driver_ptr = FFI::OGR::API.OGRGetDriver(index)
-      return nil if driver_ptr.null?
       raise OGR::DriverNotFound, index if driver_ptr.null?
 
       new(driver_ptr)
@@ -63,7 +60,10 @@ module OGR
 
     # @return [String]
     def name
-      FFI::OGR::API.OGR_Dr_GetName(@c_pointer)
+      name, ptr = FFI::OGR::API.OGR_Dr_GetName(@c_pointer)
+      ptr.autorelease = false
+
+      name
     end
 
     # @param file_name [String]
@@ -87,15 +87,15 @@ module OGR
     # @param options [Hash]
     # @return [OGR::DataSource, nil]
     def create_data_source(file_name, **options)
-      unless can_create_data_source?
+      unless test_capability('CreateDataSource')
         raise OGR::UnsupportedOperation, 'This driver does not support data source creation.'
       end
 
       options_ptr = GDAL::Options.pointer(options)
 
       data_source_ptr = FFI::OGR::API.OGR_Dr_CreateDataSource(@c_pointer,
-        file_name, options_ptr)
-      return nil if data_source_ptr.null?
+                                                              file_name, options_ptr)
+      raise OGR::CreateFailure, "Unable to create DataSource '#{file_name}'" if data_source_ptr.null?
 
       ds = OGR::DataSource.new(data_source_ptr, 'w')
       yield ds if block_given?
@@ -104,15 +104,15 @@ module OGR
     end
 
     # @param file_name [String]
-    # @return +true+ if successful, otherwise raises an OGR exception.
+    # @raise [OGR::Failure]
     def delete_data_source(file_name)
-      unless can_delete_data_source?
+      unless test_capability('DeleteDataSource')
         raise OGR::UnsupportedOperation, 'This driver does not support deleting data sources.'
       end
 
-      ogr_err = FFI::OGR::API.OGR_Dr_DeleteDataSource(@c_pointer, file_name)
-
-      ogr_err.handle_result
+      OGR::ErrorHandling.handle_ogr_err("Unable to delete data source '#{file_name}'") do
+        FFI::OGR::API.OGR_Dr_DeleteDataSource(@c_pointer, file_name)
+      end
     end
 
     # @param source_data_source [OGR::DataSource, FFI::Pointer]
@@ -126,9 +126,10 @@ module OGR
 
       options_ptr = GDAL::Options.pointer(options)
 
-      data_source_ptr = FFI::OGR::API.OGR_Dr_CopyDataSource(@c_pointer,
-        source_ptr, new_file_name, options_ptr)
-      return nil if data_source_ptr.null?
+      data_source_ptr =
+        FFI::OGR::API.OGR_Dr_CopyDataSource(@c_pointer, source_ptr, new_file_name, options_ptr)
+
+      raise OGR::InvalidDataSource, "Unable to copy data source to #{new_file_name}" if data_source_ptr.null?
 
       OGR::DataSource.new(data_source_ptr, nil)
     end

data/lib/ogr/envelope.rb

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
 
 require_relative '../ogr'
-require_relative 'envelope_extensions'
 
 module OGR
   class Envelope
-    include EnvelopeExtensions
-
     # @return [FFI::OGR::Envelope, FFI::OGR::Envelope3D] The C struct that this
     #   object wraps.
     attr_reader :c_struct