proj4rb 4.0.0 → 4.1.1

data/lib/proj/session.rb

@@ -2,6 +2,7 @@ module Proj
   class Session
     attr_reader :context
 
+    # @!visibility private
     def self.finalize(context, pointer)
       proc do
         Api.proj_insert_object_session_destroy(context, pointer)
@@ -24,7 +25,7 @@ module Proj
     # @param authority [String] - Authority name into which the object will be inserted. Must not be nil
     # @param code [Integer] - Code with which the object will be inserted.Must not be nil
     # @param numeric_codes [Boolean] - Whether intermediate objects that can be created should use numeric codes (true), or may be alphanumeric (false)
-    # @param allowed_authorities  [Array[String]] - Authorities to which intermediate objects are allowed to refer to. "authority" will be implicitly added to it.
+    # @param allowed_authorities [Array<String>] - Authorities to which intermediate objects are allowed to refer to. "authority" will be implicitly added to it.
     #
     # @return [Strings] - List of insert statements
     def get_insert_statements(object, authority, code, numeric_codes = false, allowed_authorities = nil)

data/lib/proj/transformation.rb

@@ -1,5 +1,5 @@
 module Proj
-  # Transformations are {CoordinateOperationMix coordinate operations} that
+  # Transformations are {CoordinateOperationMixin coordinate operations} that
   # convert {Coordinate coordinates} from one {Crs} to another.
   # In Proj they are defined as operations that exert a change in reference frame
   # while {Conversion conversions } do not.
@@ -19,7 +19,7 @@ module Proj
     # @param method_auth_name [String] Method authority name. Default is nil.
     # @param method_code [String] Method code. Default is nil.
     # @param params [Array<Parameter>] Parameter descriptions
-    # @param accuracy [Double] Accuracy of the transformation in meters. A negative value means unknown.
+    # @param accuracy [Float] Accuracy of the transformation in meters. A negative value means unknown.
     #
     # @return [Transformation]
     def self.create(context, name: nil, auth_name: nil, code: nil,
@@ -58,8 +58,8 @@ module Proj
     # @see https://proj.org/development/reference/functions.html#c.proj_create_crs_to_crs_from_pj
     # @see  https://proj.org/development/reference/functions.html#c.proj_create_crs_to_crs proj_create_crs_to_crs
     #
-    # @param source [Crs | String] The source Crs. See the Crs documentation for the string format
-    # @param target [Crs | String] The target Crs. See the Crs documentation for the string format
+    # @param source [Crs, String] The source Crs. See the Crs documentation for the string format
+    # @param target [Crs, String] The target Crs. See the Crs documentation for the string format
     # @param area [Area] If an area is specified a more accurate transformation between two given systems can be chosen
     # @param context [Context]
     # @param authority [String] Restricts the authority of coordinate operations looked up in the database

data/lib/proj/unit.rb

@@ -79,7 +79,7 @@ module Proj
       self.code == other.code
     end
 
-    def type
+    def unit_type
       case self.category
       when "linear"
         :PJ_UT_LINEAR

data/lib/proj.rb

@@ -40,6 +40,8 @@ module Proj
   # Returns information about the Proj library
   #
   # @see https://proj.org/development/reference/functions.html#c.proj_info proj_info
+  #
+  # @return [PJ_INFO]
   def self.info
     Api.proj_info
   end
@@ -47,6 +49,8 @@ module Proj
   # Returns the Proj version
   #
   # @see https://proj.org/development/reference/functions.html#c.proj_info proj_info
+  #
+  # @return [String]
   def self.version
     self.info[:version]
   end
@@ -55,7 +59,7 @@ module Proj
   #
   # @see https://proj.org/development/reference/functions.html#c.proj_info proj_info
   #
-  # @return Array<string> List of search paths
+  # @return [Array<String>] List of search paths
   def self.search_paths
     self.info[:searchpath].split(";")
   end
@@ -75,9 +79,9 @@ module Proj
   #
   # see https://proj.org/development/reference/functions.html#c.proj_torad proj_torad
   #
-  # @param value [Double] Value in degrees to convert
+  # @param value [Float] Value in degrees to convert
   #
-  # @return [Double]
+  # @return [Float]
   def self.degrees_to_radians(value)
     Api.proj_torad(value)
   end
@@ -86,9 +90,9 @@ module Proj
   #
   # see https://proj.org/development/reference/functions.html#c.proj_todeg proj_todeg
   #
-  # @param value [Double] Value in radians to convert
+  # @param value [Float] Value in radians to convert
   #
-  # @return [Double]
+  # @return [Float]
   def self.radians_to_degrees(value)
     Api.proj_todeg(value)
   end
@@ -99,7 +103,7 @@ module Proj
   #
   # @param value [String] Value to be converted to radians
   #
-  # @return [Double]
+  # @return [Float]
   def self.degrees_minutes_seconds_to_radians(value)
     ptr = FFI::MemoryPointer.new(:string)
     Api.proj_dmstor(value, ptr)
@@ -110,7 +114,7 @@ module Proj
   # @see https://proj.org/development/reference/functions.html#c.proj_rtodms proj_rtodms
   # @see https://proj.org/development/reference/functions.html#c.proj_rtodms2 proj_rtodms2
   #
-  # @param value [Double] Value to be converted in radians
+  # @param value [Float] Value to be converted in radians
   # @param positive [String] Character denoting positive direction, typically 'N' or 'E'. Default 'N'
   # @param negative [String] Character denoting negative direction, typically 'S' or 'W'. Default 'S'
   #

data/proj4rb.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name = 'proj4rb'
-  spec.version = '4.0.0'
+  spec.version = '4.1.1'
   spec.summary = 'Ruby bindings for the Proj coordinate transformation library'
   spec.description = <<-EOF
     Ruby bindings for the Proj coordinate transformation library

data/test/abstract_test.rb

@@ -3,27 +3,4 @@ require 'minitest/autorun'
 require 'proj'
 
 class AbstractTest < Minitest::Test
-  def self.proj7?
-    Proj::Api::PROJ_VERSION >= Gem::Version.new("7.0.0")
-  end
-
-  def self.proj8?
-    Proj::Api::PROJ_VERSION >= Gem::Version.new("8.0.0")
-  end
-
-  def self.proj9?
-    Proj::Api::PROJ_VERSION >= Gem::Version.new("9.0.0")
-  end
-
-  def proj7?
-    self.class.proj7?
-  end
-
-  def proj8?
-    self.class.proj8?
-  end
-
-  def proj9?
-    self.class.proj9?
-  end
 end

data/test/conversion_test.rb

@@ -31,8 +31,8 @@ class ConversionTest < AbstractTest
 
     inverse = operation.create_inverse
     proj_string = inverse.to_proj_string(:PJ_PROJ_5, multiline: true, indentation_width: 4, max_line_length: 40)
-    
-    expected = if proj7?
+
+    expected = if Proj::Api::PROJ_VERSION >= '7.0.0'
                  <<~EOS
                   +proj=pipeline
                       +step +proj=axisswap +order=2,1
@@ -127,7 +127,7 @@ class ConversionTest < AbstractTest
       conversion.grid(-1)
     end
 
-    if proj9?
+    if Proj::Api::PROJ_VERSION >= '9.0.0'
       assert_equal("File not found or invalid", error.to_s)
     else
       assert_equal("Unknown error (code 4096)", error.to_s)
@@ -141,12 +141,12 @@ class ConversionTest < AbstractTest
     grid = conversion.grid(0)
 
     assert_equal("ca_nrc_ntv1_can.tif", grid.name)
-    assert_match(/ntv1_can/, grid.full_name)
     assert(grid.package_name.empty?)
     assert_equal("https://cdn.proj.org/ca_nrc_ntv1_can.tif", grid.url)
     assert(grid.downloadable?)
     assert(grid.open_license?)
-    assert(grid.available?)
+    #assert_match(/ntv1_can/, grid.full_name)
+    #assert(grid.available?)
   end
 
   def test_xy_dist
@@ -275,7 +275,7 @@ class ConversionTest < AbstractTest
     assert_in_delta(1141263.01116045, coordinate_2.y)
   end
 
-  if proj9?
+  if Proj::Api::PROJ_VERSION >= '9.0.0'
     def test_last_used_operation
       wkt = <<~EOS
       CONVERSION["UTM zone 31N",
@@ -326,16 +326,16 @@ class ConversionTest < AbstractTest
     context = Proj::Context.new
     coordinate_system = Proj::CoordinateSystem.create_ellipsoidal_2d(:PJ_ELLPS2D_LONGITUDE_LATITUDE, context)
 
-    crs = Proj::Crs.create_geographic(context, name: "WGS 84", datum_name: "World Geodetic System 1984", ellps_name: "WGS 84",
+    crs = Proj::Crs.create_geographic(context, name: "WGS 84", datum_name: "World Geodetic System 1984", ellipsoid_name: "WGS 84",
                                       semi_major_meter: 6378137, inv_flattening: 298.257223563,
-                                      prime_meridian_name: "Greenwich", prime_meridian_offset: 0.0, pm_angular_units: "Degree", pm_units_conv: 0.0174532925199433,
+                                      prime_meridian_name: "Greenwich", prime_meridian_offset: 0.0, pm_angular_units: "Degree", pm_angular_units_conv: 0.0174532925199433,
                                       coordinate_system: coordinate_system)
 
-    mercator = Proj::Projection.mercator_variant_a(context, center_lat: 0, center_long: 1,
+    mercator = Proj::Projection.mercator_variant_a(context, center_latitude: 0, center_longitude: 1,
                                                    scale: 0.99,
                                                    false_easting: 2, false_northing: 3,
-                                                   ang_unit_name: "Degree", ang_unit_conv_factor: 0.0174532925199433,
-                                                   linear_unit_name: "Metre", linear_unit_conv_factor: 1.0)
+                                                   angular_unit_name: "Degree", angular_unit_conversion_factor: 0.0174532925199433,
+                                                   linear_unit_name: "Metre", linear_unit_conversion_factor: 1.0)
 
     cartesian = Proj::CoordinateSystem.create_cartesian_2d(context, :PJ_CART2D_EASTING_NORTHING)
 

data/test/coordinate_system_test.rb

@@ -8,9 +8,9 @@ class CoordinateSystemTest < AbstractTest
     crs = Proj::Crs.new('EPSG:4326', context)
     cs = crs.coordinate_system
     axes = cs.axes
-    cs = Proj::CoordinateSystem.create(cs.type, axes, context)
+    cs = Proj::CoordinateSystem.create(cs.cs_type, axes, context)
     assert_equal(2, cs.axis_count)
-    assert_equal(:PJ_CS_TYPE_ELLIPSOIDAL, cs.type)
+    assert_equal(:PJ_CS_TYPE_ELLIPSOIDAL, cs.cs_type)
     assert_equal(:PJ_TYPE_UNKNOWN, cs.proj_type)
     refute(cs.auth_name)
     refute(cs.id_code)
@@ -20,7 +20,7 @@ class CoordinateSystemTest < AbstractTest
     context = Proj::Context.new
     cs = Proj::CoordinateSystem.create_ellipsoidal_2d(:PJ_ELLPS2D_LONGITUDE_LATITUDE, context)
     assert_equal(2, cs.axis_count)
-    assert_equal(:PJ_CS_TYPE_ELLIPSOIDAL, cs.type)
+    assert_equal(:PJ_CS_TYPE_ELLIPSOIDAL, cs.cs_type)
     assert_equal(:PJ_TYPE_UNKNOWN, cs.proj_type)
     refute(cs.auth_name)
     refute(cs.id_code)
@@ -30,7 +30,7 @@ class CoordinateSystemTest < AbstractTest
     context = Proj::Context.new
     cs = Proj::CoordinateSystem.create_ellipsoidal_3d(:PJ_ELLPS3D_LATITUDE_LONGITUDE_HEIGHT, context)
     assert_equal(3, cs.axis_count)
-    assert_equal(:PJ_CS_TYPE_ELLIPSOIDAL, cs.type)
+    assert_equal(:PJ_CS_TYPE_ELLIPSOIDAL, cs.cs_type)
     assert_equal(:PJ_TYPE_UNKNOWN, cs.proj_type)
 
     axis = cs.axis_info(0)
@@ -54,7 +54,7 @@ class CoordinateSystemTest < AbstractTest
                                                       horizontal_angular_unit_name: "foo", horizontal_angular_unit_conv_factor: 0.5,
                                                       vertical_linear_unit_name: "bar", vertical_linear_unit_conv_factor: 0.6)
     assert_equal(3, cs.axis_count)
-    assert_equal(:PJ_CS_TYPE_ELLIPSOIDAL, cs.type)
+    assert_equal(:PJ_CS_TYPE_ELLIPSOIDAL, cs.cs_type)
     assert_equal(:PJ_TYPE_UNKNOWN, cs.proj_type)
 
     axis = cs.axis_info(0)
@@ -83,7 +83,7 @@ class CoordinateSystemTest < AbstractTest
     context = Proj::Context.new
     coordinate_system = Proj::CoordinateSystem.create_cartesian_2d(context, :PJ_CART2D_EASTING_NORTHING)
     assert_equal(2, coordinate_system.axis_count)
-    assert_equal(:PJ_CS_TYPE_CARTESIAN, coordinate_system.type)
+    assert_equal(:PJ_CS_TYPE_CARTESIAN, coordinate_system.cs_type)
     assert_equal(:PJ_TYPE_UNKNOWN, coordinate_system.proj_type)
   end
 
@@ -91,7 +91,7 @@ class CoordinateSystemTest < AbstractTest
     crs = Proj::Crs.new('EPSG:4326')
     cs = crs.coordinate_system
     refute(cs.name)
-    assert_equal(:PJ_CS_TYPE_ELLIPSOIDAL, cs.type)
+    assert_equal(:PJ_CS_TYPE_ELLIPSOIDAL, cs.cs_type)
     assert_equal(:PJ_TYPE_UNKNOWN, cs.proj_type)
     assert_equal("EPSG", cs.auth_name)
     assert_equal("6422", cs.id_code)

data/test/crs_test.rb

@@ -505,9 +505,19 @@ class CrsTest < AbstractTest
 
   def test_to_json
     crs = Proj::Crs.new('EPSG:26915')
+
+    schema_version = case
+                       when Proj::Api::PROJ_VERSION >= '9.0.0'
+                         'v0.7'
+                       when Proj::Api::PROJ_VERSION >= '9.3.0'
+                         'v0.5'
+                       else
+                         'v0.4'
+                     end
+
     expected = <<~EOS
       {
-        "$schema": "https://proj.org/schemas/#{proj9? ? 'v0.5' : 'v0.4'}/projjson.schema.json",
+        "$schema": "https://proj.org/schemas/#{schema_version}/projjson.schema.json",
         "type": "ProjectedCRS",
         "name": "NAD83 / UTM zone 15N",
         "base_crs": {
@@ -702,9 +712,9 @@ class CrsTest < AbstractTest
     context = Proj::Context.new
     coordinate_system = Proj::CoordinateSystem.create_ellipsoidal_2d(:PJ_ELLPS2D_LATITUDE_LONGITUDE, context)
 
-    crs = Proj::Crs.create_geographic(context, name: "WGS 84", datum_name: "World Geodetic System 1984", ellps_name: "WGS 84",
+    crs = Proj::Crs.create_geographic(context, name: "WGS 84", datum_name: "World Geodetic System 1984", ellipsoid_name: "WGS 84",
                                       semi_major_meter: 6378137, inv_flattening: 298.257223563,
-                                      prime_meridian_name: "Greenwich", prime_meridian_offset: 0.0, pm_angular_units: "Degree", pm_units_conv: 0.0174532925199433,
+                                      prime_meridian_name: "Greenwich", prime_meridian_offset: 0.0, pm_angular_units: "Degree", pm_angular_units_conv: 0.0174532925199433,
                                       coordinate_system: coordinate_system)
 
     crs_2 = Proj::Crs.create_from_database("EPSG", "4326", :PJ_CATEGORY_CRS)
@@ -720,7 +730,7 @@ class CrsTest < AbstractTest
 
   def test_geocentric
     context = Proj::Context.new
-    crs = Proj::Crs.create_geocentric(context, name: "WGS 84", datum_name: "World Geodetic System 1984", ellps_name: "WGS 84",
+    crs = Proj::Crs.create_geocentric(context, name: "WGS 84", datum_name: "World Geodetic System 1984", ellipsoid_name: "WGS 84",
                                       semi_major_meter: 6378137, inv_flattening: 298.257223563,
                                       prime_meridian_name: "Greenwich", prime_meridian_offset: 0.0,
                                       angular_units: "Degree", angular_units_conv: 0.0174532925199433,
@@ -732,7 +742,7 @@ class CrsTest < AbstractTest
 
   def test_geocentric_datum
     context = Proj::Context.new
-    crs = Proj::Crs.create_geocentric(context, name: "WGS 84", datum_name: "World Geodetic System 1984", ellps_name: "WGS 84",
+    crs = Proj::Crs.create_geocentric(context, name: "WGS 84", datum_name: "World Geodetic System 1984", ellipsoid_name: "WGS 84",
                                       semi_major_meter: 6378137, inv_flattening: 298.257223563,
                                       prime_meridian_name: "Greenwich", prime_meridian_offset: 0.0,
                                       angular_units: "Degree", angular_units_conv: 0.0174532925199433,
@@ -791,9 +801,9 @@ class CrsTest < AbstractTest
     context = Proj::Context.new
     coordinate_system = Proj::CoordinateSystem.create_ellipsoidal_2d(:PJ_ELLPS2D_LONGITUDE_LATITUDE, context)
 
-    horizontal_crs = Proj::Crs.create_geographic(context, name: "WGS 84", datum_name: "World Geodetic System 1984", ellps_name: "WGS 84",
+    horizontal_crs = Proj::Crs.create_geographic(context, name: "WGS 84", datum_name: "World Geodetic System 1984", ellipsoid_name: "WGS 84",
                                                  semi_major_meter: 6378137, inv_flattening: 298.257223563,
-                                                 prime_meridian_name: "Greenwich", prime_meridian_offset: 0.0, pm_angular_units: "Degree", pm_units_conv: 0.0174532925199433,
+                                                 prime_meridian_name: "Greenwich", prime_meridian_offset: 0.0, pm_angular_units: "Degree", pm_angular_units_conv: 0.0174532925199433,
                                                  coordinate_system: coordinate_system)
 
     vertical_crs = Proj::Crs.create_vertical(context, name: "myVertCRS",
@@ -822,7 +832,7 @@ class CrsTest < AbstractTest
     crs = Proj::Crs.create("EPSG:4326", context)
 
     conversion = Proj::Projection.pole_rotation_grib_convention(context, south_pole_lat_in_unrotated_crs: 2, south_pole_long_in_unrotated_crs: 3,
-                                                                axis_rotation: 4, ang_unit_name: "Degree", ang_unit_conv_factor: 0.0174532925199433)
+                                                                axis_rotation: 4, angular_unit_name: "Degree", angular_unit_conversion_factor: 0.0174532925199433)
 
     coordinate_system = crs.coordinate_system
 
@@ -860,9 +870,9 @@ class CrsTest < AbstractTest
 
     coordinate_system = Proj::CoordinateSystem.create_ellipsoidal_2d(:PJ_ELLPS2D_LONGITUDE_LATITUDE, context)
     crs = Proj::Crs.create_geographic(context, name: "WGS 84", datum_name: "World Geodetic System 1984",
-                                      ellps_name: "WGS 84", semi_major_meter: 6378137, inv_flattening: 298.257223563,
+                                      ellipsoid_name: "WGS 84", semi_major_meter: 6378137, inv_flattening: 298.257223563,
                                       prime_meridian_name: "Greenwich", prime_meridian_offset: 0.0,
-                                      pm_angular_units: "Degree", pm_units_conv: 0.0174532925199433,
+                                      pm_angular_units: "Degree", pm_angular_units_conv: 0.0174532925199433,
                                       coordinate_system: coordinate_system)
 
     cartesian = Proj::CoordinateSystem.create_cartesian_2d(context, :PJ_CART2D_EASTING_NORTHING)
@@ -922,7 +932,7 @@ class CrsTest < AbstractTest
     crses = Proj::Crs.query_geodetic_from_datum(context, datum_auth_name: "EPSG", datum_code: "6326")
 
     expected = case
-               when proj9?
+               when Proj::Api::PROJ_VERSION >= '9.0.0'
                  12
                else
                  11
@@ -940,9 +950,9 @@ class CrsTest < AbstractTest
     context = Proj::Context.new
     coordinate_system = Proj::CoordinateSystem.create_ellipsoidal_2d(:PJ_ELLPS2D_LATITUDE_LONGITUDE, context)
 
-    crs = Proj::Crs.create_geographic(context, name: "WGS 84", datum_name: "World Geodetic System 1984", ellps_name: "WGS 84",
+    crs = Proj::Crs.create_geographic(context, name: "WGS 84", datum_name: "World Geodetic System 1984", ellipsoid_name: "WGS 84",
                                       semi_major_meter: 6378137, inv_flattening: 298.257223563,
-                                      prime_meridian_name: "Greenwich", prime_meridian_offset: 0.0, pm_angular_units: "Degree", pm_units_conv: 0.0174532925199433,
+                                      prime_meridian_name: "Greenwich", prime_meridian_offset: 0.0, pm_angular_units: "Degree", pm_angular_units_conv: 0.0174532925199433,
                                       coordinate_system: coordinate_system)
     assert_equal("WGS 84", crs.name)
 
@@ -955,9 +965,9 @@ class CrsTest < AbstractTest
     context = Proj::Context.new
     coordinate_system = Proj::CoordinateSystem.create_ellipsoidal_2d(:PJ_ELLPS2D_LATITUDE_LONGITUDE, context)
 
-    crs = Proj::Crs.create_geographic(context, name: "WGS 84", datum_name: "World Geodetic System 1984", ellps_name: "WGS 84",
+    crs = Proj::Crs.create_geographic(context, name: "WGS 84", datum_name: "World Geodetic System 1984", ellipsoid_name: "WGS 84",
                                       semi_major_meter: 6378137, inv_flattening: 298.257223563,
-                                      prime_meridian_name: "Greenwich", prime_meridian_offset: 0.0, pm_angular_units: "Degree", pm_units_conv: 0.0174532925199433,
+                                      prime_meridian_name: "Greenwich", prime_meridian_offset: 0.0, pm_angular_units: "Degree", pm_angular_units_conv: 0.0174532925199433,
                                       coordinate_system: coordinate_system)
     refute(crs.auth)
 

data/test/database_test.rb

@@ -49,9 +49,15 @@ class DatabaseTest < AbstractTest
   end
 
   def test_codes
-    types_with_no_codes = [:PJ_TYPE_TEMPORAL_CRS, :PJ_TYPE_BOUND_CRS, :PJ_TYPE_UNKNOWN, :PJ_TYPE_ENGINEERING_CRS,
+    if Proj::Api::PROJ_VERSION >= '9.3.0'
+      types_with_no_codes = [:PJ_TYPE_TEMPORAL_CRS, :PJ_TYPE_BOUND_CRS, :PJ_TYPE_UNKNOWN, :PJ_TYPE_ENGINEERING_CRS,
                            :PJ_TYPE_TEMPORAL_DATUM, :PJ_TYPE_ENGINEERING_DATUM, :PJ_TYPE_PARAMETRIC_DATUM,
-                           :PJ_TYPE_OTHER_COORDINATE_OPERATION]
+                           :PJ_TYPE_OTHER_COORDINATE_OPERATION, :PJ_TYPE_DERIVED_PROJECTED_CRS, :PJ_TYPE_COORDINATE_METADATA]
+    else
+      types_with_no_codes = [:PJ_TYPE_TEMPORAL_CRS, :PJ_TYPE_BOUND_CRS, :PJ_TYPE_UNKNOWN, :PJ_TYPE_ENGINEERING_CRS,
+                             :PJ_TYPE_TEMPORAL_DATUM, :PJ_TYPE_ENGINEERING_DATUM, :PJ_TYPE_PARAMETRIC_DATUM,
+                             :PJ_TYPE_OTHER_COORDINATE_OPERATION]
+    end
 
     database = Proj::Database.new(Proj::Context.current)
 
@@ -97,10 +103,12 @@ class DatabaseTest < AbstractTest
     crs_infos = database.crs_info
 
     expected = case
-               when proj9?
-                 13107
-               else
-                 12609
+                 when Proj::Api::PROJ_VERSION >= '9.3.0'
+                   13434
+                 when Proj::Api::PROJ_VERSION >= '9.0.0'
+                   13107
+                 else
+                   12609
                end
     assert_equal(expected, crs_infos.count)
 
@@ -108,7 +116,7 @@ class DatabaseTest < AbstractTest
     assert_equal("EPSG", crs_info.auth_name)
     assert_equal("2000", crs_info.code)
     assert_equal("Anguilla 1957 / British West Indies Grid", crs_info.name)
-    assert_equal(:PJ_TYPE_PROJECTED_CRS, crs_info.type)
+    assert_equal(:PJ_TYPE_PROJECTED_CRS, crs_info.crs_type)
     refute(crs_info.deprecated)
     assert(crs_info.bbox_valid)
     assert_equal(-63.22, crs_info.west_lon_degree)
@@ -125,10 +133,12 @@ class DatabaseTest < AbstractTest
     crs_infos = database.crs_info("EPSG")
 
     expected = case
-               when proj9?
-                 7251
-               else
-                 7056
+                 when Proj::Api::PROJ_VERSION >= '9.3.0'
+                   7477
+                 when Proj::Api::PROJ_VERSION >= '9.0.0'
+                   7251
+                 else
+                   7056
                end
     assert_equal(expected, crs_infos.count)
   end
@@ -140,10 +150,12 @@ class DatabaseTest < AbstractTest
     crs_infos = database.crs_info("EPSG", params)
 
     expected = case
-               when proj9?
-                 943
-               else
-                 930
+                 when Proj::Api::PROJ_VERSION >= '9.3.0'
+                   997
+                 when Proj::Api::PROJ_VERSION >= '9.0.0'
+                   943
+                 else
+                   930
                end
 
     assert_equal(expected, crs_infos.count)
@@ -156,10 +168,12 @@ class DatabaseTest < AbstractTest
     crs_infos = database.crs_info("EPSG", params)
 
     expected = case
-               when proj9?
-                 5689
-               else
-                 5534
+                 when Proj::Api::PROJ_VERSION >= '9.3.0'
+                   5839
+                 when Proj::Api::PROJ_VERSION >= '9.0.0'
+                   5689
+                 else
+                   5534
                end
 
     assert_equal(expected, crs_infos.count)
@@ -176,7 +190,15 @@ class DatabaseTest < AbstractTest
     params.north_lat_degree = 49.1
 
     crs_infos = database.crs_info("EPSG", params)
-    assert_equal(35, crs_infos.count)
+
+    expected = case
+                 when Proj::Api::PROJ_VERSION >= '9.3.0'
+                   37
+                 else
+                   35
+               end
+
+    assert_equal(expected, crs_infos.count)
   end
 
   def test_crs_info_bounds_exclusive
@@ -191,7 +213,15 @@ class DatabaseTest < AbstractTest
     params.crs_area_of_use_contains_bbox = 0
 
     crs_infos = database.crs_info("EPSG", params)
-    assert_equal(38, crs_infos.count)
+
+    expected = case
+                 when Proj::Api::PROJ_VERSION >= '9.3.0'
+                   40
+                 else
+                   38
+               end
+
+    assert_equal(expected, crs_infos.count)
   end
 
   def test_crs_info_celestial_body
@@ -201,10 +231,12 @@ class DatabaseTest < AbstractTest
     crs_infos = database.crs_info("EPSG", params)
 
     expected = case
-               when proj9?
-                 6723
-               else
-                 6532
+                 when Proj::Api::PROJ_VERSION >= '9.3.0'
+                   6951
+                 when Proj::Api::PROJ_VERSION >= '9.0.0'
+                   6723
+                 else
+                   6532
                end
 
     assert_equal(expected, crs_infos.count)
@@ -237,7 +269,7 @@ class DatabaseTest < AbstractTest
     bodies = database.celestial_bodies
 
     expected = case
-               when proj9?
+               when Proj::Api::PROJ_VERSION >= '9.0.0'
                  176
                else
                  170
@@ -255,7 +287,7 @@ class DatabaseTest < AbstractTest
     bodies = database.celestial_bodies('ESRI')
 
     expected = case
-               when proj9?
+               when Proj::Api::PROJ_VERSION >= '9.0.0'
                  78
                else
                  72
@@ -349,7 +381,7 @@ class DatabaseTest < AbstractTest
     refute(name)
   end
 
-  if proj7?
+  if Proj::Api::PROJ_VERSION >= '7.0.0'
     # This test causes a segmentation fault on proj6
     def test_metadata_invalid
       database = Proj::Database.new(Proj::Context.current)

data/test/operation_factory_context_test.rb

@@ -51,20 +51,24 @@ class OperationFactoryContextTest < AbstractTest
     index = operations.suggested_operation(:PJ_FWD, coord)
 
     expected = case
-               when proj9?
-                 2
-               else
-                 7
+                 when Proj::Api::PROJ_VERSION >= '9.3.0'
+                   3
+                 when Proj::Api::PROJ_VERSION >= '9.0.0'
+                   2
+                 else
+                   7
                end
     assert_equal(expected, index)
 
     operation = operations[index]
 
     expected = case
-               when proj9?
-                 "NAD27 to NAD83 (1)"
-               else
-                 "Ballpark geographic offset from NAD27 to NAD83"
+                 when Proj::Api::PROJ_VERSION >= '9.3.0'
+                   "NAD27 to NAD83 (7)"
+                 when Proj::Api::PROJ_VERSION >= '9.0.0'
+                   "NAD27 to NAD83 (1)"
+                 else
+                   "Ballpark geographic offset from NAD27 to NAD83"
                end
 
     assert_equal(expected, operation.name)
@@ -191,7 +195,7 @@ class OperationFactoryContextTest < AbstractTest
     assert_equal(5, operations.count)
   end
 
-  if proj9?
+  if Proj::Api::PROJ_VERSION >= '9.0.0'
     def test_set_area_of_interest_name
       context = Proj::Context.new
       factory_context = Proj::OperationFactoryContext.new(context)