ffi-gdal 1.0.2 → 1.0.3

data/lib/gdal/dataset/raster_band_methods.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require_relative "../dataset/internal_functions"
+
+module GDAL
+  class Dataset
+    module RasterBandMethods
+      # Lets you pass in :GMF_ symbols that represent mask band flags and bitwise
+      # ors them.
+      #
+      # @param flags [Symbol]
+      # @return [Integer]
+      def self.parse_mask_flag_symbols(*flags)
+        flags.reduce(0) do |result, flag|
+          result | case flag
+                   when :GMF_ALL_VALID then 0x01
+                   when :GMF_PER_DATASET then 0x02
+                   when :GMF_PER_ALPHA then 0x04
+                   when :GMF_NODATA then 0x08
+                   else 0
+                   end
+        end
+      end
+
+      # @param buffer_data_type [FFI::GDAL::GDAL::DataType]
+      # @param x_buffer_size [Integer]
+      # @param y_buffer_size [Integer]
+      # @return [Integer]
+      def self.valid_min_buffer_size(buffer_data_type, x_buffer_size, y_buffer_size)
+        data_type_bytes = GDAL::DataType.size(buffer_data_type) / 8
+
+        data_type_bytes * x_buffer_size * y_buffer_size
+      end
+
+      # @return [Integer, nil]
+      def raster_x_size
+        return nil if null?
+
+        FFI::GDAL::GDAL.GDALGetRasterXSize(@c_pointer)
+      end
+
+      # @return [Integer, nil]
+      def raster_y_size
+        return nil if null?
+
+        FFI::GDAL::GDAL.GDALGetRasterYSize(@c_pointer)
+      end
+
+      # @return [Integer]
+      def raster_count
+        return 0 if null?
+
+        FFI::GDAL::GDAL.GDALGetRasterCount(@c_pointer)
+      end
+
+      # @param raster_index [Integer]
+      # @return [GDAL::RasterBand]
+      def raster_band(raster_index)
+        if raster_index > raster_count
+          raise GDAL::InvalidRasterBand, "Invalid raster band number '#{raster_index}'. Must be <= #{raster_count}"
+        end
+
+        raster_band_ptr = FFI::GDAL::GDAL.GDALGetRasterBand(@c_pointer, raster_index)
+        raster_band_ptr.autorelease = false
+
+        GDAL::RasterBand.new(raster_band_ptr, self)
+      end
+
+      # @param type [FFI::GDAL::GDAL::DataType]
+      # @param options [Hash]
+      # @raise [GDAL::Error]
+      # @return [GDAL::RasterBand, nil]
+      def add_band(type, **options)
+        options_ptr = GDAL::Options.pointer(options)
+
+        GDAL::CPLErrorHandler.manually_handle("Unable to add band") do
+          FFI::GDAL::GDAL.GDALAddBand(@c_pointer, type, options_ptr)
+        end
+
+        raster_band(raster_count)
+      end
+
+      # Adds a mask band to the dataset.
+      #
+      # @param flags [Array<Symbol>, Symbol] Any of the :GMF symbols.
+      # @raise [GDAL::Error]
+      def create_mask_band(*flags)
+        flag_value = RasterBandMethods.parse_mask_flag_symbols(flags)
+
+        GDAL::CPLErrorHandler.manually_handle("Unable to create Dataset mask band") do
+          FFI::GDAL::GDAL.GDALCreateDatasetMaskBand(@c_pointer, flag_value)
+        end
+      end
+
+      # @param access_flag [String] 'r' or 'w'.
+      # @param buffer [FFI::MemoryPointer] The pointer to the data to read/write
+      #   to the dataset.
+      # @param x_size [Integer] If not given, uses {{#raster_x_size}}.
+      # @param y_size [Integer] If not given, uses {{#raster_y_size}}.
+      # @param x_offset [Integer] The pixel number in the line to start operating
+      #   on. Note that when using this, +x_size+ - +x_offset+ should be >= 0,
+      #   otherwise this means you're telling the method to read past the end of
+      #   the line. Defaults to 0.
+      # @param y_offset [Integer] The line number to start operating on. Note that
+      #   when using this, +y_size+ - +y_offset+ should be >= 0, otherwise this
+      #   means you're telling the method to read more lines than the raster has.
+      #   Defaults to 0.
+      # @param buffer_x_size [Integer] The width of the buffer image in which to
+      #   read/write the raster data into/from. Typically this should be the same
+      #   size as +x_size+; if it's different, GDAL will resample accordingly.
+      # @param buffer_y_size [Integer] The height of the buffer image in which to
+      #   read/write the raster data into/from. Typically this should be the same
+      #   size as +y_size+; if it's different, GDAL will resample accordingly.
+      # @param buffer_data_type [FFI::GDAL::GDAL::DataType] Can be used to convert the
+      #   data to a different type. You must account for this when reading/writing
+      #   to/from your buffer--your buffer size must be +buffer_x_size+ *
+      #   +buffer_y_size+.
+      # @param band_numbers [Array<Integer>] The numbers of the bands to do IO on.
+      #   Pass +nil+ defaults to choose the first band.
+      # @param pixel_space [Integer] The byte offset from the start of one pixel
+      #   value in the buffer to the start of the next pixel value within a line.
+      #   If defaulted (0), the size of +buffer_data_type+ is used.
+      # @param line_space [Integer] The byte offset from the start of one line in
+      #   the buffer to the start of the next. If defaulted (0), the size of
+      #   +buffer_data_type+ * +buffer_x_size* is used.
+      # @param band_space [Integer] The byte offset from the start of one band's
+      #   data to the start of the next. If defaulted (0), the size of
+      #   +line_space+ * +buffer_y_size* is used.
+      # @return [FFI::MemoryPointer] The buffer that was passed in.
+      # @raise [GDAL::Error] On failure.
+      # rubocop:disable Metrics/ParameterLists
+      def raster_io(access_flag, buffer = nil,
+        x_size: nil, y_size: nil, x_offset: 0, y_offset: 0,
+        buffer_x_size: nil, buffer_y_size: nil, buffer_data_type: nil,
+        band_numbers: nil,
+        pixel_space: 0, line_space: 0, band_space: 0)
+        x_size ||= raster_x_size
+        y_size ||= raster_y_size
+        buffer_x_size ||= x_size
+        buffer_y_size ||= y_size
+        buffer_data_type ||= raster_band(1).data_type
+
+        band_numbers_ptr, band_count = InternalFunctions.band_numbers_args(band_numbers)
+        band_count = raster_count if band_count.zero?
+
+        buffer ||= GDAL._pointer_from_data_type(buffer_data_type, buffer_x_size * buffer_y_size * band_count)
+
+        gdal_access_flag = GDAL._gdal_access_flag(access_flag)
+
+        min_buffer_size = RasterBandMethods.valid_min_buffer_size(buffer_data_type, buffer_x_size, buffer_y_size)
+
+        unless buffer.size >= min_buffer_size
+          raise GDAL::BufferTooSmall, "Buffer size (#{buffer.size}) too small (#{min_buffer_size})"
+        end
+
+        GDAL::CPLErrorHandler.manually_handle("Unable to perform raster band IO") do
+          FFI::GDAL::GDAL::GDALDatasetRasterIO(
+            @c_pointer,                     # hDS
+            gdal_access_flag,               # eRWFlag
+            x_offset,                       # nXOff
+            y_offset,                       # nYOff
+            x_size,                         # nXSize
+            y_size,                         # nYSize
+            buffer,                         # pData
+            buffer_x_size,                  # nBufXSize
+            buffer_y_size,                  # nBufYSize
+            buffer_data_type,               # eBufType
+            band_count,                     # nBandCount
+            band_numbers_ptr,               # panBandMap (WTH is this?)
+            pixel_space,                    # nPixelSpace
+            line_space,                     # nLineSpace
+            band_space                      # nBandSpace
+          )
+        end
+
+        buffer
+      end
+      # rubocop:enable Metrics/ParameterLists
+    end
+  end
+end

data/lib/gdal/{dataset_mixins → dataset}/warp_methods.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module GDAL
-  module DatasetMixins
+  class Dataset
     # Methods used for warping; most taken from gdalwarper.h.
     module WarpMethods
       # @param destination_dataset [GDAL::Dataset]

data/lib/gdal/dataset.rb

@@ -1,90 +1,36 @@
 # frozen_string_literal: true
 
-require_relative '../gdal'
-require_relative '../ogr'
-require_relative 'major_object'
-require_relative 'dataset_mixins/matching'
-require_relative 'dataset_mixins/algorithm_methods'
-require_relative 'dataset_mixins/warp_methods'
+require_relative "../gdal"
+require_relative "../ogr"
+require_relative "major_object"
+require_relative "dataset/internal_functions"
+require_relative "dataset/class_methods"
+require_relative "dataset/accessors"
+require_relative "dataset/raster_band_methods"
+require_relative "dataset/matching"
+require_relative "dataset/algorithm_methods"
+require_relative "dataset/warp_methods"
 
 module GDAL
   # A set of associated raster bands and info common to them all.  It's also
   # responsible for the georeferencing transform and coordinate system
   # definition of all bands.
   class Dataset
+    extend Dataset::ClassMethods
+
     include MajorObject
-    include DatasetMixins::Matching
-    include DatasetMixins::AlgorithmMethods
-    include DatasetMixins::WarpMethods
+    include Dataset::Accessors
+    include Dataset::RasterBandMethods
+    include Dataset::Matching
+    include Dataset::AlgorithmMethods
+    include Dataset::WarpMethods
     include GDAL::Logger
 
     ACCESS_FLAGS = {
-      'r' => :GA_ReadOnly,
-      'w' => :GA_Update
+      "r" => :GA_ReadOnly,
+      "w" => :GA_Update
     }.freeze
 
-    # @param path [String] Path to the file that contains the dataset.  Can be
-    #   a local file or a URL.
-    # @param access_flag [String] 'r' or 'w'.
-    # @param shared [Boolean] Whether or not to open using GDALOpenShared
-    #   vs GDALOpen. Defaults to +true+.
-    def self.open(path, access_flag, shared: true)
-      ds = new(path, access_flag, shared_open: shared)
-
-      if block_given?
-        result = yield ds
-        ds.close
-        result
-      else
-        ds
-      end
-    end
-
-    # Copy all dataset raster data.
-    #
-    # This function copies the complete raster contents of one dataset to
-    # another similarly configured dataset. The source and destination dataset
-    # must have the same number of bands, and the same width and height. The
-    # bands do not have to have the same data type.
-    #
-    # This function is primarily intended to support implementation of driver
-    # specific CreateCopy() functions. It implements efficient copying, in
-    # particular "chunking" the copy in substantial blocks and, if appropriate,
-    # performing the transfer in a pixel interleaved fashion.
-    #
-    # @param source [GDAL::Dataset, FFI::Pointer]
-    # @param destination [GDAL::Dataset, FFI::Pointer]
-    # @param options [Hash]
-    # @option options interleave: 'pixel'
-    # @option options compressed: true
-    # @option options skip_holes: true
-    # @param progress_function [Proc]
-    # @raise [GDAL::Error]
-    def self.copy_whole_raster(source, destination, options = {}, progress_function = nil)
-      source_ptr = GDAL._pointer(GDAL::Dataset, source, autorelease: false)
-      dest_ptr = GDAL._pointer(GDAL::Dataset, destination, autorelease: false)
-      options_ptr = GDAL::Options.pointer(options)
-
-      GDAL::CPLErrorHandler.manually_handle('Unable to copy whole raster') do
-        FFI::GDAL::GDAL.GDALDatasetCopyWholeRaster(source_ptr, dest_ptr, options_ptr, progress_function, nil)
-      end
-    end
-
-    # @param dataset [GDAL::Dataset]
-    # @return [FFI::AutoPointer]
-    def self.new_pointer(dataset, warn_on_nil: true)
-      ptr = GDAL._pointer(GDAL::Dataset, dataset, warn_on_nil: warn_on_nil, autorelease: false)
-
-      FFI::AutoPointer.new(ptr, Dataset.method(:release))
-    end
-
-    # @param pointer [FFI::Pointer]
-    def self.release(pointer)
-      return unless pointer && !pointer.null?
-
-      FFI::GDAL::GDAL.GDALClose(pointer)
-    end
-
     #---------------------------------------------------------------------------
     # Instance methods
     #---------------------------------------------------------------------------
@@ -115,7 +61,6 @@ module GDAL
 
       @geo_transform = nil
       @spatial_reference = nil
-      @raster_bands = Array.new(raster_count)
     end
 
     # Close the dataset.
@@ -132,14 +77,6 @@ module GDAL
       FFI::GDAL::GDAL::Access[flag]
     end
 
-    # @return [GDAL::Driver] The driver to be used for working with this
-    #   dataset.
-    def driver
-      driver_ptr = FFI::GDAL::GDAL.GDALGetDatasetDriver(@c_pointer)
-
-      Driver.new(driver_ptr)
-    end
-
     # Fetches all files that form the dataset.
     # @return [Array<String>]
     def file_list
@@ -157,141 +94,6 @@ module GDAL
       FFI::GDAL::GDAL.GDALFlushCache(@c_pointer)
     end
 
-    # @return [Integer]
-    def raster_x_size
-      return nil if null?
-
-      FFI::GDAL::GDAL.GDALGetRasterXSize(@c_pointer)
-    end
-
-    # @return [Integer]
-    def raster_y_size
-      return nil if null?
-
-      FFI::GDAL::GDAL.GDALGetRasterYSize(@c_pointer)
-    end
-
-    # @return [Integer]
-    def raster_count
-      return 0 if null?
-
-      FFI::GDAL::GDAL.GDALGetRasterCount(@c_pointer)
-    end
-
-    # @param raster_index [Integer]
-    # @return [GDAL::RasterBand]
-    def raster_band(raster_index)
-      if raster_index > raster_count
-        raise GDAL::InvalidRasterBand, "Invalid raster band number '#{raster_index}'. Must be <= #{raster_count}"
-      end
-
-      raster_band_ptr = FFI::GDAL::GDAL.GDALGetRasterBand(@c_pointer, raster_index)
-      raster_band_ptr.autorelease = false
-
-      GDAL::RasterBand.new(raster_band_ptr, self)
-    end
-
-    # @param type [FFI::GDAL::GDAL::DataType]
-    # @param options [Hash]
-    # @raise [GDAL::Error]
-    # @return [GDAL::RasterBand, nil]
-    def add_band(type, **options)
-      options_ptr = GDAL::Options.pointer(options)
-
-      GDAL::CPLErrorHandler.manually_handle('Unable to add band') do
-        FFI::GDAL::GDAL.GDALAddBand(@c_pointer, type, options_ptr)
-      end
-
-      raster_band(raster_count)
-    end
-
-    # Adds a mask band to the dataset.
-    #
-    # @param flags [Array<Symbol>, Symbol] Any of the :GMF symbols.
-    # @raise [GDAL::Error]
-    def create_mask_band(*flags)
-      flag_value = parse_mask_flag_symbols(flags)
-
-      GDAL::CPLErrorHandler.manually_handle('Unable to create Dataset mask band') do
-        FFI::GDAL::GDAL.GDALCreateDatasetMaskBand(@c_pointer, flag_value)
-      end
-    end
-
-    # @return [String]
-    def projection
-      # Returns a pointer to an internal projection reference string. It should
-      # not be altered, freed or expected to last for long.
-      proj, ptr = FFI::GDAL::GDAL.GDALGetProjectionRef(@c_pointer)
-      ptr.autorelease = false
-
-      proj || ''
-    end
-
-    # @param new_projection [String] Should be in WKT or PROJ.4 format.
-    # @raise [GDAL::Error]
-    def projection=(new_projection)
-      GDAL::CPLErrorHandler.manually_handle('Unable to set projection') do
-        FFI::GDAL::GDAL.GDALSetProjection(@c_pointer, new_projection.to_s)
-      end
-    end
-
-    # @return [GDAL::GeoTransform]
-    # @raise [GDAL::Error]
-    def geo_transform
-      return @geo_transform if @geo_transform
-
-      geo_transform_pointer = GDAL::GeoTransform.new_pointer
-
-      GDAL::CPLErrorHandler.manually_handle('Unable to get geo_transform') do
-        FFI::GDAL::GDAL.GDALGetGeoTransform(@c_pointer, geo_transform_pointer)
-      end
-
-      @geo_transform = GeoTransform.new(geo_transform_pointer)
-    end
-
-    # @param new_transform [GDAL::GeoTransform, FFI::Pointer]
-    # @return [GDAL::GeoTransform]
-    # @raise [GDAL::Error]
-    def geo_transform=(new_transform)
-      new_pointer = GDAL._pointer(GDAL::GeoTransform, new_transform)
-
-      GDAL::CPLErrorHandler.manually_handle('Unable to set geo_transform') do
-        FFI::GDAL::GDAL.GDALSetGeoTransform(@c_pointer, new_pointer)
-      end
-
-      @geo_transform = new_transform.is_a?(FFI::Pointer) ? GeoTransform.new(new_pointer) : new_transform
-    end
-
-    # @return [Integer]
-    def gcp_count
-      return 0 if null?
-
-      FFI::GDAL::GDAL.GDALGetGCPCount(@c_pointer)
-    end
-
-    # @return [String]
-    def gcp_projection
-      return '' if null?
-
-      proj, ptr = FFI::GDAL::GDAL.GDALGetGCPProjection(@c_pointer)
-      ptr.autorelease = false
-
-      proj
-    end
-
-    # @return [FFI::GDAL::GCP]
-    def gcps
-      return FFI::GDAL::GCP.new if null?
-
-      gcp_array_pointer = FFI::GDAL::GDAL.GDALGetGCPs(@c_pointer)
-
-      if gcp_array_pointer.null?
-        FFI::GDAL::GCP.new
-      else
-        FFI::GDAL::GCP.new(gcp_array_pointer)
-      end
-    end
-
     # @param resampling [String, Symbol] One of:
     #   * :nearest          - Nearest neighbor resampling
     #   * :gauss            - Gaussian kernel resampling
@@ -316,9 +118,9 @@ module GDAL
 
       overview_levels_ptr = FFI::MemoryPointer.new(:int, overview_levels.size)
       overview_levels_ptr.write_array_of_int(overview_levels)
-      band_numbers_ptr, band_count = band_numbers_args(band_numbers)
+      band_numbers_ptr, band_count = InternalFunctions.band_numbers_args(band_numbers)
 
-      GDAL::CPLErrorHandler.manually_handle('Unable to build overviews') do
+      GDAL::CPLErrorHandler.manually_handle("Unable to build overviews") do
         FFI::GDAL::GDAL.GDALBuildOverviews(
           @c_pointer,
           resampling_string,
@@ -331,145 +133,5 @@ module GDAL
         )
       end
     end
-
-    # @param access_flag [String] 'r' or 'w'.
-    # @param buffer [FFI::MemoryPointer] The pointer to the data to read/write
-    #   to the dataset.
-    # @param x_size [Integer] If not given, uses {{#raster_x_size}}.
-    # @param y_size [Integer] If not given, uses {{#raster_y_size}}.
-    # @param x_offset [Integer] The pixel number in the line to start operating
-    #   on. Note that when using this, +x_size+ - +x_offset+ should be >= 0,
-    #   otherwise this means you're telling the method to read past the end of
-    #   the line. Defaults to 0.
-    # @param y_offset [Integer] The line number to start operating on. Note that
-    #   when using this, +y_size+ - +y_offset+ should be >= 0, otherwise this
-    #   means you're telling the method to read more lines than the raster has.
-    #   Defaults to 0.
-    # @param buffer_x_size [Integer] The width of the buffer image in which to
-    #   read/write the raster data into/from. Typically this should be the same
-    #   size as +x_size+; if it's different, GDAL will resample accordingly.
-    # @param buffer_y_size [Integer] The height of the buffer image in which to
-    #   read/write the raster data into/from. Typically this should be the same
-    #   size as +y_size+; if it's different, GDAL will resample accordingly.
-    # @param buffer_data_type [FFI::GDAL::GDAL::DataType] Can be used to convert the
-    #   data to a different type. You must account for this when reading/writing
-    #   to/from your buffer--your buffer size must be +buffer_x_size+ *
-    #   +buffer_y_size+.
-    # @param band_numbers [Array<Integer>] The numbers of the bands to do IO on.
-    #   Pass +nil+ defaults to choose the first band.
-    # @param pixel_space [Integer] The byte offset from the start of one pixel
-    #   value in the buffer to the start of the next pixel value within a line.
-    #   If defaulted (0), the size of +buffer_data_type+ is used.
-    # @param line_space [Integer] The byte offset from the start of one line in
-    #   the buffer to the start of the next. If defaulted (0), the size of
-    #   +buffer_data_type+ * +buffer_x_size* is used.
-    # @param band_space [Integer] The byte offset from the start of one band's
-    #   data to the start of the next. If defaulted (0), the size of
-    #   +line_space+ * +buffer_y_size* is used.
-    # @return [FFI::MemoryPointer] The buffer that was passed in.
-    # @raise [GDAL::Error] On failure.
-    # rubocop:disable Metrics/ParameterLists
-    def raster_io(access_flag, buffer = nil,
-      x_size: nil, y_size: nil, x_offset: 0, y_offset: 0,
-      buffer_x_size: nil, buffer_y_size: nil, buffer_data_type: nil,
-      band_numbers: nil,
-      pixel_space: 0, line_space: 0, band_space: 0)
-      x_size ||= raster_x_size
-      y_size ||= raster_y_size
-      buffer_x_size ||= x_size
-      buffer_y_size ||= y_size
-      buffer_data_type ||= raster_band(1).data_type
-
-      band_numbers_ptr, band_count = band_numbers_args(band_numbers)
-      band_count = raster_count if band_count.zero?
-
-      buffer ||= GDAL._pointer_from_data_type(buffer_data_type, buffer_x_size * buffer_y_size * band_count)
-
-      gdal_access_flag = GDAL._gdal_access_flag(access_flag)
-
-      min_buffer_size = valid_min_buffer_size(buffer_data_type, buffer_x_size, buffer_y_size)
-
-      unless buffer.size >= min_buffer_size
-        raise GDAL::BufferTooSmall, "Buffer size (#{buffer.size}) too small (#{min_buffer_size})"
-      end
-
-      GDAL::CPLErrorHandler.manually_handle('Unable to perform raster band IO') do
-        FFI::GDAL::GDAL::GDALDatasetRasterIO(
-          @c_pointer,                     # hDS
-          gdal_access_flag,               # eRWFlag
-          x_offset,                       # nXOff
-          y_offset,                       # nYOff
-          x_size,                         # nXSize
-          y_size,                         # nYSize
-          buffer,                         # pData
-          buffer_x_size,                  # nBufXSize
-          buffer_y_size,                  # nBufYSize
-          buffer_data_type,               # eBufType
-          band_count,                     # nBandCount
-          band_numbers_ptr,               # panBandMap (WTH is this?)
-          pixel_space,                    # nPixelSpace
-          line_space,                     # nLineSpace
-          band_space                      # nBandSpace
-        )
-      end
-
-      buffer
-    end
-    # rubocop:enable Metrics/ParameterLists
-
-    # Creates a OGR::SpatialReference object from the dataset's projection.
-    #
-    # @return [OGR::SpatialReference]
-    def spatial_reference
-      return @spatial_reference if @spatial_reference
-
-      return nil if projection.empty?
-
-      @spatial_reference = OGR::SpatialReference.new(projection)
-    end
-
-    private
-
-    # Lets you pass in :GMF_ symbols that represent mask band flags and bitwise
-    # ors them.
-    #
-    # @param flags [Symbol]
-    # @return [Integer]
-    def parse_mask_flag_symbols(*flags)
-      flags.reduce(0) do |result, flag|
-        result | case flag
-                 when :GMF_ALL_VALID then 0x01
-                 when :GMF_PER_DATASET then 0x02
-                 when :GMF_PER_ALPHA then 0x04
-                 when :GMF_NODATA then 0x08
-                 else 0
-                 end
-      end
-    end
-
-    # @param buffer_data_type [FFI::GDAL::GDAL::DataType]
-    # @param x_buffer_size [Integer]
-    # @param y_buffer_size [Integer]
-    # @return [Integer]
-    def valid_min_buffer_size(buffer_data_type, x_buffer_size, y_buffer_size)
-      data_type_bytes = GDAL::DataType.size(buffer_data_type) / 8
-
-      data_type_bytes * x_buffer_size * y_buffer_size
-    end
-
-    # Makes a pointer of +band_numbers+.
-    #
-    # @param band_numbers [Array<Integer>]
-    # @return [Array<FFI::MemoryPointer, Integer>]
-    def band_numbers_args(band_numbers)
-      band_count = band_numbers&.size || 0
-      ptr = FFI::MemoryPointer.new(:int, band_count)
-
-      ptr.write_array_of_int(band_numbers) if band_numbers
-
-      ptr.autorelease = false
-
-      [ptr, band_count]
-    end
   end
 end

data/lib/gdal/driver.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'multi_xml'
-require_relative '../gdal'
-require_relative 'major_object'
+require "multi_xml"
+require_relative "../gdal"
+require_relative "major_object"
 
 module GDAL
   # Wrapper for GDAL drivers (aka "formats"). Useful for opening and working
@@ -11,7 +11,7 @@ module GDAL
     include MajorObject
     include GDAL::Logger
 
-    GDAL_DOCS_URL = 'http://gdal.org'
+    GDAL_DOCS_URL = "http://gdal.org"
 
     # @return [Integer]
     def self.count
@@ -99,10 +99,10 @@ module GDAL
 
       return [] if root.nil? || root.empty?
 
-      list = root['CreationOptionList']
+      list = root["CreationOptionList"]
       return [] if list.nil? || list.empty?
 
-      list['Option']
+      list["Option"]
     end
 
     # @param options [Hash]
@@ -156,7 +156,7 @@ module GDAL
 
       raise CreateFail if dataset_pointer.null?
 
-      dataset = GDAL::Dataset.new(dataset_pointer, 'w')
+      dataset = GDAL::Dataset.new(dataset_pointer, "w")
 
       if block_given?
         result = yield(dataset)
@@ -204,7 +204,7 @@ module GDAL
       raise CreateFail if destination_dataset_ptr.nil? || destination_dataset_ptr.null?
 
       if block_given?
-        dataset = Dataset.new(destination_dataset_ptr, 'w')
+        dataset = Dataset.new(destination_dataset_ptr, "w")
         yield(dataset)
         dataset.close
       end
@@ -239,7 +239,7 @@ module GDAL
     # @return [GDAL::Dataset]
     def make_dataset_pointer(dataset)
       if dataset.is_a? String
-        GDAL::Dataset.open(dataset, 'r').c_pointer
+        GDAL::Dataset.open(dataset, "r").c_pointer
       else
         GDAL._pointer(GDAL::Dataset, dataset, autorelease: false)
       end
@@ -247,4 +247,4 @@ module GDAL
   end
 end
 
-require_relative 'dataset'
+require_relative "dataset"

data/lib/gdal/environment_methods.rb

@@ -40,7 +40,7 @@ module GDAL
 
     # @param file_path [String]
     def dump_open_datasets(file_path)
-      file_ptr = FFI::CPL::Conv.CPLOpenShared(file_path, 'w', false)
+      file_ptr = FFI::CPL::Conv.CPLOpenShared(file_path, "w", false)
       FFI::GDAL::GDAL.GDALDumpOpenDatasets(file_ptr)
       FFI::CPL::Conv.CPLCloseShared(file_ptr)
     end