ffi-gdal 1.0.0.beta5 → 1.0.0.beta6

data/lib/ogr/exceptions.rb

@@ -35,6 +35,9 @@ module OGR
   class InvalidFieldDefinition < StandardError
   end
 
+  class InvalidFieldName < StandardError
+  end
+
   class InvalidGeometry < StandardError
   end
 
@@ -70,6 +73,9 @@ module OGR
     end
   end
 
+  class UnsupportedFieldType < StandardError
+  end
+
   class UnsupportedGeometryType < StandardError
   end
 

data/lib/ogr/feature.rb

@@ -1,8 +1,7 @@
-require_relative '../ffi/ogr'
-require_relative 'feature_extensions'
-require_relative 'feature_definition'
-require_relative 'field_definition'
 require 'date'
+require_relative '../ogr'
+require_relative '../gdal'
+require_relative 'feature_extensions'
 
 module OGR
   class Feature
@@ -19,14 +18,11 @@ module OGR
                      FFI::OGR::API.OGR_F_Create(fd_or_pointer.c_pointer)
                    else
                      fd_or_pointer
-                         end
+                   end
 
       if !@c_pointer.is_a?(FFI::Pointer) || @c_pointer.null?
-        fail OGR::InvalidFeature, "Unable to create Feature with #{fd_or_pointer}"
+        raise OGR::InvalidFeature, "Unable to create Feature with #{fd_or_pointer}"
       end
-
-      close_me = -> { destroy! }
-      ObjectSpace.define_finalizer self, close_me
     end
 
     def destroy!
@@ -40,16 +36,18 @@ module OGR
     # @raise [OGR::Failure] If, for some reason, the clone fails.
     def clone
       feature_ptr = FFI::OGR::API.OGR_F_Clone(@c_pointer)
-      fail OGR::Failure, 'Unable to clone feature' if feature_ptr.nil?
+      raise OGR::Failure, 'Unable to clone feature' if feature_ptr.nil?
 
       OGR::Feature.new(feature_ptr)
     end
 
     # Dumps the feature out to the file in human-readable form.
     #
-    # @param file_name [String]
-    def dump_readable(file_name)
-      FFI::OGR::API.OGR_F_DumpReadable(@c_pointer, file_name)
+    # @param file_path [String]
+    def dump_readable(file_path = nil)
+      file_ptr = file_path ? FFI::CPL::Conv.CPLOpenShared(file_path, 'w', false) : nil
+      FFI::OGR::API.OGR_F_DumpReadable(@c_pointer, file_ptr)
+      FFI::CPL::Conv.CPLCloseShared(file_ptr) if file_ptr
     end
 
     # Overwrites the contents of this feature from the geometry and attributes
@@ -61,7 +59,7 @@ module OGR
     # @param with_map [Array<Fixnum>]
     # TODO: Implement +with_map+
     def set_from!(_other_feature, _be_forgiving = false, with_map: nil)
-      fail NotImplementedError, 'with_map: is not yet supported' if with_map
+      raise NotImplementedError, 'with_map: is not yet supported' if with_map
 
       ogr_err = FFI::OGR::API.OGR_F_SetFrom(@c_pointer, other_feature_ptr)
 
@@ -133,23 +131,17 @@ module OGR
     end
 
     # @param index [Fixnum]
-    # @param value [FFI::OGR::Field]
-    def set_field_raw(index, value)
-      raw_field_ptr = FFI::MemoryPointer.new(value)
-      usable_raw_field = FFI::OGR::Field.new(raw_field_ptr)
-
-      unless valid_raw_field?(index, usable_raw_field)
-        fail TypeError,
-          "Raw field is not of required field type: #{field_definition(index).type}"
-      end
+    # @param field [OGR::Field]
+    def set_field_raw(index, field)
+      usable_raw_field = field.c_struct
 
-      FFI::OGR::API.OGR_F_SetFieldRaw(@c_pointer, index, value)
+      FFI::OGR::API.OGR_F_SetFieldRaw(@c_pointer, index, usable_raw_field)
     end
 
     # @param index [Fixnum]
     # @param value [String]
     def set_field_binary(index, value)
-      fail TypeError, 'value must be a binary string' unless value.is_a? String
+      raise TypeError, 'value must be a binary string' unless value.is_a? String
 
       value_ptr = FFI::MemoryPointer.new(:uchar, value.length)
       value_ptr.put_bytes(0, value)
@@ -232,7 +224,7 @@ module OGR
     # @return [OGR::Geometry]
     def steal_geometry
       geometry_ptr = FFI::OGR::API.OGR_F_StealGeometry(@c_pointer)
-      fail OGR::Failure, 'Unable to steal geometry.' if geometry_ptr.nil?
+      raise OGR::Failure, 'Unable to steal geometry.' if geometry_ptr.nil?
 
       OGR::Geometry.factory(geometry_ptr)
     end
@@ -284,30 +276,25 @@ module OGR
       geometry_ptr = FFI::OGR::API.OGR_F_GetGeomFieldRef(@c_pointer, index)
       return nil if geometry_ptr.nil? || geometry_ptr.null?
 
-      geometry = OGR::Geometry.factory(geometry_ptr)
-      geometry.read_only = true
-
-      geometry
+      OGR::Geometry.factory(geometry_ptr)
     end
 
     # @param index [Fixnum]
     # @param geometry [OGR::Geometry]
     def set_geometry_field(index, geometry)
       geometry_ptr = GDAL._pointer(OGR::Geometry, geometry)
-      fail OGR::InvalidGeometry if geometry_ptr.nil?
+      raise OGR::InvalidGeometry if geometry_ptr.nil?
 
-      ogr_err =
-        # FFI::OGR::API.OGR_F_SetGeomFieldDirectly(@c_pointer, index, geometry_ptr)
-        FFI::OGR::API.OGR_F_SetGeomField(@c_pointer, index, geometry_ptr)
+      ogr_err = FFI::OGR::API.OGR_F_SetGeomField(@c_pointer, index, geometry_ptr)
 
       ogr_err.handle_result
     end
 
     # @return [Boolean]
-    def equal?(other_feature)
-      FFI::OGR::API.OGR_F_Equal(@c_pointer, c_pointer_from(other_feature))
+    def equal?(other)
+      FFI::OGR::API.OGR_F_Equal(@c_pointer, c_pointer_from(other))
     end
-    alias_method :equals?, :equal?
+    alias equals? equal?
 
     # @param index [Fixnum]
     # @return [Fixnum]
@@ -442,7 +429,7 @@ module OGR
     # @param new_style_table [OGR::StyleTable]
     def style_table=(new_style_table)
       new_style_table_ptr = GDAL._pointer(OGR::StyleTable, new_style_table)
-      fail OGR::InvalidStyleTable unless new_style_table_ptr
+      raise OGR::InvalidStyleTable unless new_style_table_ptr
 
       FFI::OGR::API.OGR_F_SetStyleTableDirectly(@c_pointer, new_style_table_ptr)
     end

data/lib/ogr/feature_definition.rb

@@ -1,7 +1,5 @@
-require_relative '../ffi/ogr'
+require_relative '../ogr'
 require_relative 'feature_definition_extensions'
-require_relative 'field_definition'
-require_relative 'geometry_field_definition'
 
 module OGR
   class FeatureDefinition
@@ -22,15 +20,15 @@ module OGR
                    end
 
       if !@c_pointer.is_a?(FFI::Pointer) || @c_pointer.null?
-        fail OGR::InvalidFeatureDefinition, "Unable to create #{self.class.name} from #{name_or_pointer}"
+        raise OGR::InvalidFeatureDefinition, "Unable to create #{self.class.name} from #{name_or_pointer}"
       end
-
-      close_me = -> { FFI::OGR::API.OGR_FD_Destroy(@c_pointer) }
-      ObjectSpace.define_finalizer self, close_me
     end
 
     def release!
+      return unless @c_pointer
+
       FFI::OGR::API.OGR_FD_Release(@c_pointer)
+      @c_pointer = nil
     end
 
     # @return [String]
@@ -58,7 +56,7 @@ module OGR
       field_definition_ptr = GDAL._pointer(OGR::FieldDefinition, field_definition)
 
       if field_definition_ptr.nil?
-        fail OGR::InvalidFieldDefinition, "Unable to add OGR::FieldDefinition: '#{field_definition}'"
+        raise OGR::InvalidFieldDefinition, "Unable to add OGR::FieldDefinition: '#{field_definition}'"
       end
 
       FFI::OGR::API.OGR_FD_AddFieldDefn(@c_pointer, field_definition_ptr)

data/lib/ogr/feature_definition_extensions.rb

@@ -6,18 +6,14 @@ module OGR
     def field_definitions
       return [] if field_count.zero?
 
-      field_count.times.map do |i|
-        field_definition(i)
-      end
+      Array.new(field_count) { |i| field_definition(i) }
     end
 
     # @return [Array<OGR::GeometryFieldDefinition>]
     def geometry_field_definitions
       return [] if geometry_field_count.zero?
 
-      geometry_field_count.times.map do |i|
-        geometry_field_definition(i)
-      end
+      Array.new(geometry_field_count) { |i| geometry_field_definition(i) }
     end
 
     # @param name [String]

data/lib/ogr/feature_extensions.rb

@@ -2,62 +2,92 @@ require 'json'
 
 module OGR
   module FeatureExtensions
+    # Retrieves the value for each field and yields it.
+    #
+    # @return [Enumerator]
+    # @yieldparam [Number, String, Array]
+    def each_field
+      return enum_for(:each_field) unless block_given?
+
+      field_count.times do |i|
+        yield field(i)
+      end
+    end
+
     # @return [Array] Uses each FieldDefinition to determine the field type at
     #   each index and returns maps the field as that value type.
     def fields
-      field_count.times.map do |i|
-        case field_definition(i).type
-        when :OFTInteger        then field_as_integer(i)
-        when :OFTIntegerList    then field_as_integer_list(i)
-        when :OFTReal           then field_as_double(i)
-        when :OFTRealList       then field_as_double_list(i)
-        when :OFTString         then field_as_string(i)
-        when :OFTStringList     then field_as_string_list(i)
-        when :OFTWideString     then field_as_string(i)
-        when :OFTWideStringList then field_as_string_list(i)
-        when :OFTBinary         then field_as_binary(i)
-        when :OFTDate, :OFTTime, :OFTDateTime then field_as_date_time(i)
-        when :OFTInteger64      then field_as_integer(i)
-        when :OFTInteger64List  then field_as_integer_lsit(i)
-        when :OFTMaxType        then field_as_date_time(i)
-        else fail "not sure about field type: #{fd.type}"
-        end
+      each_field.to_a
+    end
+
+    # Retrieves a field using +index+, but uses its type from the associated
+    # {OGR::FieldDefinition} to determine it's core type to return as. This
+    # saves from having to find out the type then call the associated
+    # +field_as_[type]+ method if you just want the data in it's originally
+    # intended form.
+    #
+    # @param index [Fixnum] Index of the field to retrieve the data for.
+    # @return [Number, String, Array]
+    # @raise [OGR::UnsupportedFieldType] if the associated FieldDefinition's
+    #   type has not yet been mapped here (to know how to return the value).
+    def field(index)
+      field_type = field_definition(index).type
+
+      case field_type
+      when :OFTInteger        then field_as_integer(index)
+      when :OFTIntegerList    then field_as_integer_list(index)
+      when :OFTReal           then field_as_double(index)
+      when :OFTRealList       then field_as_double_list(index)
+      when :OFTString         then field_as_string(index)
+      when :OFTStringList     then field_as_string_list(index)
+      when :OFTWideString     then field_as_string(index)
+      when :OFTWideStringList then field_as_string_list(index)
+      when :OFTBinary         then field_as_binary(index)
+      when :OFTDate, :OFTTime, :OFTDateTime then field_as_date_time(index)
+      when :OFTInteger64      then field_as_integer(index)
+      when :OFTInteger64List  then field_as_integer_lsit(index)
+      when :OFTMaxType        then field_as_date_time(index)
+      else raise OGR::UnsupportedFieldType,
+        "Don't know how to fetch field for field type: #{field_type}"
       end
     end
 
-    # @return [Array<OGR::Geometry>]
-    def geometry_fields
-      geometry_field_count.times.map do |i|
-        geometry_field(i)
+    # @return [Enumerator]
+    # @yieldparam [OGR::GeometryFieldDefinition]
+    def each_geometry_field_definition
+      return enum_for(:each_geometry_field_definition) unless block_given?
+
+      geometry_field_count.times do |i|
+        yield geometry_field_definition(i)
       end
     end
 
-    # TODO: this seems really wonky...
-    def valid_raw_field?(index, raw_field)
-      field_def = field_definition(index)
+    # @return [Array<OGR::GeometryFieldDefinition>]
+    def geometry_field_definitions
+      each_geometry_field_definition.to_a
+    end
+
+    # @return [Enumerator]
+    # @yieldparam [OGR::Geometry]
+    def each_geometry_field
+      return enum_for(:each_geometry_field) unless block_given?
 
-      case field_def.type
-      when :OFTInteger then !raw_field[:integer].nil?
-      when :OFTIntegerList then !raw_field[:integer_list].nil?
-      when :OFTInteger64 then !raw_field[:integer64].nil?
-      when :OFTInteger64List then !raw_field[:integer64_list].nil?
-      when :OFTReal then !raw_field[:real].nil?
-      when :OFTRealList then !raw_field[:real_list].nil?
-      when :OFTString then !raw_field[:string].nil?
-      when :OFTStringList then !raw_field[:string_list].nil?
-      when :OFTBinary then !raw_field[:binary].nil?
-      when :OFTDate then !raw_field[:date].nil?
-      else
-        fail OGR::Failure, "Not sure how to set raw type: #{field_def.type}"
+      geometry_field_count.times do |i|
+        yield geometry_field(i)
       end
     end
 
+    # @return [Array<OGR::Geometry>]
+    def geometry_fields
+      each_geometry_field.to_a
+    end
+
     # @return [Hash]
     def as_json(options = nil)
-      fields_with_nested_json = fields.map do |f|
+      fields_with_nested_json = fields.map.with_index do |f, i|
         {
-          field_definition: f[:field_definition].as_json(options),
-          value_as_string: f[:value_as_string]
+          field_definition: field_definition(i).as_json(options),
+          value: f
         }
       end
 
@@ -68,7 +98,7 @@ module OGR
         fields: fields_with_nested_json,
         geometry: geometry ? geometry.as_json(options) : nil,
         geometry_field_count: geometry_field_count,
-        geometry_field_definitions: geometry_field_definitions.map(&:as_json),
+        geometry_field_definition: each_geometry_field_definition.map { |gfd| gfd.as_json(options) },
         style_string: style_string,
         style_table: style_table ? style_table.as_json(options) : nil
       }

data/lib/ogr/field.rb

@@ -1,4 +1,5 @@
 require 'date'
+require_relative '../ogr'
 
 module OGR
   class Field
@@ -19,7 +20,7 @@ module OGR
     def integer
       @c_struct[:integer]
     end
-    alias_method :to_i, :integer
+    alias to_i integer
 
     # @param new_int [Fixnum]
     def integer=(new_int)
@@ -40,7 +41,7 @@ module OGR
     def real
       @c_struct[:real]
     end
-    alias_method :to_f, :real
+    alias to_f real
 
     # @param new_real [Float]
     def real=(new_real)
@@ -68,7 +69,7 @@ module OGR
 
     # @param new_integer_list [Array<Fixnum>]
     def integer_list=(new_integer_list)
-      list_ptr = FFI::MemoryPointer.new(:int, new_integer_list.size)
+      list_ptr = FFI::MemoryPointer.new(:int, new_integer_list.length)
       list_ptr.write_array_of_int(new_integer_list)
 
       il = FFI::OGR::FieldTypes::IntegerList.new
@@ -85,7 +86,7 @@ module OGR
 
       il[:list].read_array_of_int64(il[:count])
     end
-    alias_method :to_bignum, :integer64_list
+    alias to_bignum integer64_list
 
     # @param new_integer64_list [Array<Bignum>]
     def integer64_list=(new_integer64_list)
@@ -98,7 +99,7 @@ module OGR
 
       @c_struct[:integer64_list] = il
     end
-    alias_method :bignum_list=, :integer64_list=
+    alias bignum_list= integer64_list=
 
     # @return [Array<Float>]
     def real_list
@@ -107,7 +108,7 @@ module OGR
 
       rl[:list].read_array_of_double(rl[:count])
     end
-    alias_method :float_list, :real_list
+    alias float_list real_list
 
     # @param new_real_list [Array<Float>]
     def real_list=(new_real_list)
@@ -120,7 +121,7 @@ module OGR
 
       @c_struct[:real_list] = rl
     end
-    alias_method :float_list=, :real_list=
+    alias float_list= real_list=
 
     # @return [Array<String>]
     def string_list
@@ -194,16 +195,16 @@ module OGR
 
     # @param new_date [Date, Time, DateTime]
     def date=(new_date)
-      time = new_date.to_time
-      zone = OGR._format_time_zone_for_ogr(time.zone)
+      # All of Date's Time methods are private. Using #send to accomdate Date.
+      zone = OGR._format_time_zone_for_ogr(new_date.send(:zone))
 
       date = FFI::OGR::FieldTypes::Date.new
-      date[:year] = time.year
-      date[:month] = time.month
-      date[:day] = time.day
-      date[:hour] = time.hour
-      date[:minute] = time.min
-      date[:second] = time.sec
+      date[:year] = new_date.year
+      date[:month] = new_date.month
+      date[:day] = new_date.day
+      date[:hour] = new_date.hour
+      date[:minute] = new_date.send(:min)
+      date[:second] = new_date.send(:sec) + (new_date.to_time.usec / 1_000_000.to_f)
       date[:tz_flag] = zone
 
       @c_struct[:date] = date

data/lib/ogr/field_definition.rb

@@ -1,4 +1,4 @@
-require_relative '../ffi/ogr'
+require_relative '../ogr'
 require_relative 'field_definition_extensions'
 
 module OGR
@@ -18,13 +18,13 @@ module OGR
                    end
 
       unless @c_pointer.is_a?(FFI::Pointer) && !@c_pointer.null?
-        fail OGR::InvalidFieldDefinition, "Unable to create #{self.class.name} from #{name_or_pointer}"
+        raise OGR::InvalidFieldDefinition, "Unable to create #{self.class.name} from #{name_or_pointer}"
       end
-
-      ObjectSpace.define_finalizer(self, -> { destroy! })
     end
 
     def destroy!
+      return unless @c_pointer
+
       FFI::OGR::API.OGR_Fld_Destroy(@c_pointer)
       @c_pointer = nil
     end

data/lib/ogr/geocoder.rb

@@ -1,4 +1,4 @@
-require_relative 'layer'
+require_relative '../ogr'
 
 module OGR
   # Geocode things!  http://www.gdal.org/ogr__geocoding_8h.html
@@ -34,13 +34,13 @@ module OGR
 
       options_ptr = GDAL::Options.pointer(converted_options)
 
-      @c_pointer = FFI::GDAL.OGRGeocodeCreateSession(options_ptr)
+      @c_pointer = FFI::GDAL::GDAL.OGRGeocodeCreateSession(options_ptr)
     end
 
     def destroy!
       return unless @c_pointer
 
-      FFI::GDAL.OGRGeocodeDestroySession(@c_pointer)
+      FFI::GDAL::GDAL.OGRGeocodeDestroySession(@c_pointer)
       @c_pointer = nil
     end
 
@@ -59,7 +59,7 @@ module OGR
     def geocode(query, **options)
       options_ptr = GDAL::Options.pointer(options)
       layer_ptr =
-        FFI::GDAL.OGRGeocode(@c_pointer, query, nil, options_ptr)
+        FFI::GDAL::GDAL.OGRGeocode(@c_pointer, query, nil, options_ptr)
       return nil if layer_ptr.null?
 
       OGR::Layer.new(layer_ptr)
@@ -76,7 +76,7 @@ module OGR
     def reverse_geocode(lon, lat, **options)
       options_ptr = GDAL::Options.pointer(options)
       layer_ptr =
-        FFI::GDAL.OGRGeocodeReverse(@c_pointer, lon, lat, options_ptr)
+        FFI::GDAL::GDAL.OGRGeocodeReverse(@c_pointer, lon, lat, options_ptr)
       return nil if layer_ptr.null?
 
       OGR::Layer.new(layer_ptr)

data/lib/ogr/geometries/geometry_collection.rb

@@ -1,13 +1,16 @@
 require_relative '../geometry_types/container'
+require_relative '../geometry_types/surface'
 
 module OGR
   class GeometryCollection
     include OGR::Geometry
     include GeometryTypes::Container
+    include GeometryTypes::Surface
 
-    def initialize(geometry_ptr = nil)
+    def initialize(geometry_ptr = nil, spatial_reference: nil)
       geometry_ptr ||= OGR::Geometry.create(:wkbGeometryCollection)
       initialize_from_pointer(geometry_ptr)
+      self.spatial_reference = spatial_reference if spatial_reference
     end
   end
 end

data/lib/ogr/geometries/geometry_collection_25d.rb

@@ -0,0 +1,12 @@
+require_relative 'geometry_collection'
+
+module OGR
+  # NOTE: {{#type}} will return :wkbGeometryCollection (read: 2D instead of
+  # 2.5D) until a Z value is set.
+  class GeometryCollection25D < GeometryCollection
+    def initialize(geometry_ptr = nil, spatial_reference: nil)
+      geometry_ptr ||= OGR::Geometry.create(:wkbGeometryCollection25D)
+      super(geometry_ptr, spatial_reference: spatial_reference)
+    end
+  end
+end

data/lib/ogr/geometries/line_string.rb

@@ -5,13 +5,9 @@ module OGR
     include OGR::Geometry
     include GeometryTypes::Curve
 
-    def self.approximate_arc_angles(center_x, center_y,
-                                    z,
-                                    primary_radius, secondary_radius,
-                                    rotation,
-                                    start_angle, end_angle,
-                                    max_angle_step_size_degrees = 0)
-      geometry_ptr = FFI::GDAL.OGR_G_ApproximateArcAngles(
+    def self.approximate_arc_angles(center_x, center_y, z, primary_radius, secondary_radius,
+      rotation, start_angle, end_angle, max_angle_step_size_degrees = 0)
+      geometry_ptr = FFI::GDAL::GDAL.OGR_G_ApproximateArcAngles(
         center_x,
         center_y,
         z,
@@ -27,9 +23,35 @@ module OGR
       new(geometry_ptr)
     end
 
-    def initialize(geometry_ptr = nil)
+    def initialize(geometry_ptr = nil, spatial_reference: nil)
       geometry_ptr ||= OGR::Geometry.create(:wkbLineString)
       initialize_from_pointer(geometry_ptr)
+      self.spatial_reference = spatial_reference if spatial_reference
+    end
+
+    # Adds a point to a LineString or Point geometry.
+    #
+    # @param x [Float]
+    # @param y [Float]
+    # @param z [Float]
+    def add_point(x, y, z = nil)
+      if z
+        FFI::OGR::API.OGR_G_AddPoint(@c_pointer, x, y, z)
+      else
+        FFI::OGR::API.OGR_G_AddPoint_2D(@c_pointer, x, y)
+      end
+    end
+
+    # Wrapper for {#add_point} to allow passing in an {OGR::Point} instead of
+    # individual coordinates.
+    #
+    # @param point [OGR::Point]
+    def add_geometry(point)
+      if point.is_3d?
+        add_point(point.x, point.y, point.z)
+      else
+        add_point(point.x, point.y)
+      end
     end
   end
 end

data/lib/ogr/geometries/line_string_25d.rb

@@ -0,0 +1,21 @@
+require_relative 'line_string'
+
+module OGR
+  # NOTE: {{#type}} will return :wkbLineString (read: 2D instead of 2.5D) until
+  # a Z value is set.
+  class LineString25D < LineString
+    def initialize(geometry_ptr = nil, spatial_reference: nil)
+      geometry_ptr ||= OGR::Geometry.create(:wkbLineString25D)
+      super(geometry_ptr, spatial_reference: spatial_reference)
+    end
+
+    # Adds a point to a LineString or Point geometry.
+    #
+    # @param x [Float]
+    # @param y [Float]
+    # @param z [Float]
+    def add_point(x, y, z)
+      super(x, y, z)
+    end
+  end
+end

data/lib/ogr/geometries/linear_ring.rb

@@ -3,9 +3,18 @@ require_relative 'line_string'
 module OGR
   class LinearRing < LineString
     # @param [FFI::Pointer] geometry_ptr
-    def initialize(geometry_ptr = nil)
+    def initialize(geometry_ptr = nil, spatial_reference: nil)
       geometry_ptr ||= OGR::Geometry.create(:wkbLinearRing)
       initialize_from_pointer(geometry_ptr)
+      self.spatial_reference = spatial_reference if spatial_reference
+    end
+
+    def to_line_string
+      line_string = OGR::LineString.new
+      line_string.spatial_reference = spatial_reference if spatial_reference
+      line_string.import_from_wkt(to_wkt.sub('LINEARRING', 'LINESTRING'))
+
+      line_string
     end
   end
 end

data/lib/ogr/geometries/multi_line_string.rb

@@ -8,9 +8,10 @@ module OGR
     include GeometryTypes::Container
 
     # @param [FFI::Pointer] geometry_ptr
-    def initialize(geometry_ptr = nil)
+    def initialize(geometry_ptr = nil, spatial_reference: nil)
       geometry_ptr ||= OGR::Geometry.create(:wkbMultiLineString)
       initialize_from_pointer(geometry_ptr)
+      self.spatial_reference = spatial_reference if spatial_reference
     end
   end
 end

data/lib/ogr/geometries/multi_line_string_25d.rb

@@ -0,0 +1,13 @@
+require_relative 'multi_line_string'
+
+module OGR
+  # NOTE: {{#type}} will return :wkbMultiLineString (read: 2D instead of 2.5D)
+  # until a Z value is set.
+  class MultiLineString25D < MultiLineString
+    # @param [FFI::Pointer] geometry_ptr
+    def initialize(geometry_ptr = nil, spatial_reference: nil)
+      geometry_ptr ||= OGR::Geometry.create(:wkbMultiLineString25D)
+      super(geometry_ptr, spatial_reference: spatial_reference)
+    end
+  end
+end