rgeo-proj4 1.0.0.rc1 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9c7651625154609a01979271df45bd5229be4c1c78b10834540981408bf8240
-  data.tar.gz: 53a6f93a200983b08020f8bea256c575a27e061b78f172a03d51caba53852442
+  metadata.gz: 3e899f9ec9d4cb7036400cb716e4d414c87adf5b1b20fbcf081666d869af48ad
+  data.tar.gz: 423a52b4b72050a519b8df4c63f01058b608c9345cb0abc5e1bf2a33729c381b
 SHA512:
-  metadata.gz: 24b00ed0eb17c8e77ea5fa1efd0eedc91468c6c79ee89d06ee0940cd613a3c382942e2f881c42d66a00281c3653f566d94524a05af6de388021631e06e04a376
-  data.tar.gz: 16e019ec27581cc9bca711beca05558339c43a2e919847861be79e96fd4a8c88cf592a3ddf91490dc47ab06099c1508cb26f695d3a535759371ae325fdb0788b
+  metadata.gz: 59fda580463933b22228f0748d7ddbb38deefe04c2b01ea2979d1a2f15a2d565bfad6b3056f0f4ab9a27fa147df69e8eae9dec8dd1cd075c48c108bcce96858b
+  data.tar.gz: 1cd3d716d7c9ba6c832d3703abb2c6ddefa87985e75034ed38458bd447f6afd32e02a72547ff2014db52db0bd0d3c3709c776e97698dc0e0a792eb33168b0314

data/ext/proj4_c_impl/extconf.rb

@@ -45,14 +45,19 @@ else
 
   found_proj_ = false
   header_dirs_, lib_dirs_ = dir_config("proj", header_dirs_, lib_dirs_)
-  if have_header("proj_api.h")
+  if have_header("proj.h")
     $libs << " -lproj"
-    if have_func("pj_init_plus", "proj_api.h")
+
+    if have_func("proj_create", "proj.h")
       found_proj_ = true
+      have_func("proj_create_crs_to_crs_from_pj", "proj.h")
+      have_func("proj_normalize_for_visualization", "proj.h")
     else
       $libs.gsub!(" -lproj", "")
     end
   end
+  have_func("rb_gc_mark_movable")
+
   unless found_proj_
     puts "**** WARNING: Unable to find Proj headers or Proj version is too old."
     puts "**** Compiling without Proj support."

data/ext/proj4_c_impl/main.c

@@ -1,12 +1,21 @@
 /*
   Main initializer for Proj4 wrapper
 */
-
-#ifdef HAVE_PROJ_API_H
-#ifdef HAVE_PJ_INIT_PLUS
+#ifdef HAVE_PROJ_H
+#ifdef HAVE_PROJ_CREATE
+#ifdef HAVE_PROJ_CREATE_CRS_TO_CRS_FROM_PJ
+#ifdef HAVE_PROJ_NORMALIZE_FOR_VISUALIZATION
 #define RGEO_PROJ4_SUPPORTED
 #endif
 #endif
+#endif
+#endif
+
+#ifdef HAVE_RB_GC_MARK_MOVABLE
+#define mark rb_gc_mark_movable
+#else
+#define mark rb_gc_mark
+#endif
 
 #ifdef __cplusplus
 #define RGEO_BEGIN_C extern "C" {
@@ -20,7 +29,7 @@
 #ifdef RGEO_PROJ4_SUPPORTED
 
 #include <ruby.h>
-#include <proj_api.h>
+#include <proj.h>
 
 #endif
 
@@ -30,78 +39,112 @@ RGEO_BEGIN_C
 
 #ifdef RGEO_PROJ4_SUPPORTED
 
+#if PROJ_VERSION_MAJOR == 6 && PROJ_VERSION_MINOR < 3
+#define WKT_TYPE PJ_WKT2_2018
+#else
+#define WKT_TYPE PJ_WKT2_2019
+#endif
 
 typedef struct {
-  projPJ pj;
+  PJ *pj;
   VALUE original_str;
   char uses_radians;
 } RGeo_Proj4Data;
 
 
-#define RGEO_PROJ4_DATA_PTR(obj) ((RGeo_Proj4Data*)DATA_PTR(obj))
+// Destroy function for proj data.
+static void rgeo_proj4_free(void *ptr)
+{
+  RGeo_Proj4Data *data = (RGeo_Proj4Data *)ptr;
+  if(data->pj){
+    proj_destroy(data->pj);
+  }
+  free(data);
+}
 
+static size_t rgeo_proj4_memsize(const void *ptr)
+{
+  size_t size = 0;
+  const RGeo_Proj4Data *data = (const RGeo_Proj4Data *)ptr;
 
-// Destroy function for proj data.
+  size += sizeof(*data);
+  if(data->pj){
+    size += sizeof(data->pj);
+  }
+  return size;
+}
 
-static void destroy_proj4_func(RGeo_Proj4Data* data)
+static void rgeo_proj4_mark(void *ptr)
 {
-  if (data->pj) {
-    pj_free(data->pj);
+  RGeo_Proj4Data *data = (RGeo_Proj4Data *)ptr;
+  if(!NIL_P(data->original_str)){
+    mark(data->original_str);
   }
-  free(data);
 }
 
+#ifdef HAVE_RB_GC_MARK_MOVABLE
+static void rgeo_proj4_compact(void *ptr)
+{
+  RGeo_Proj4Data *data = (RGeo_Proj4Data *)ptr;
+  if(data && !NIL_P(data->original_str)){
+    data->original_str = rb_gc_location(data->original_str);
+  }
+}
+#endif
 
-static void mark_proj4_func(RGeo_Proj4Data* data)
+static void rgeo_proj4_clear_struct(RGeo_Proj4Data *data)
 {
-  if (!NIL_P(data->original_str)) {
-    rb_gc_mark(data->original_str);
+  if(data->pj){
+    proj_destroy(data->pj);
+    data->pj = NULL;
+    data->original_str = Qnil;
   }
 }
 
+static const rb_data_type_t rgeo_proj4_data_type = {
+    "RGeo::CoordSys::Proj4",
+    {rgeo_proj4_mark, rgeo_proj4_free, rgeo_proj4_memsize,
+#ifdef HAVE_RB_GC_MARK_MOVABLE
+    rgeo_proj4_compact
+#endif
+    },
+    0, 0,
+    RUBY_TYPED_FREE_IMMEDIATELY};
 
-static VALUE alloc_proj4(VALUE klass)
+static VALUE rgeo_proj4_data_alloc(VALUE self)
 {
   VALUE result;
-  RGeo_Proj4Data* data;
+  RGeo_Proj4Data *data = ALLOC(RGeo_Proj4Data);
 
   result = Qnil;
-  data = ALLOC(RGeo_Proj4Data);
-  if (data) {
+
+  if(data){
     data->pj = NULL;
     data->original_str = Qnil;
     data->uses_radians = 0;
-    result = Data_Wrap_Struct(klass, mark_proj4_func, destroy_proj4_func, data);
+    result = TypedData_Wrap_Struct(self, &rgeo_proj4_data_type, data);
   }
   return result;
 }
 
-
 static VALUE method_proj4_initialize_copy(VALUE self, VALUE orig)
 {
-  RGeo_Proj4Data* self_data;
-  projPJ pj;
-  RGeo_Proj4Data* orig_data;
-  char* str;
+  RGeo_Proj4Data *self_data;
+  RGeo_Proj4Data *orig_data;
+  const char* str;
 
   // Clear out any existing value
-  self_data = RGEO_PROJ4_DATA_PTR(self);
-  pj = self_data->pj;
-  if (pj) {
-    pj_free(pj);
-    self_data->pj = NULL;
-    self_data->original_str = Qnil;
-  }
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, self_data);
+  rgeo_proj4_clear_struct(self_data);
 
   // Copy value from orig
-  orig_data = RGEO_PROJ4_DATA_PTR(orig);
+  TypedData_Get_Struct(orig, RGeo_Proj4Data, &rgeo_proj4_data_type, orig_data);
   if (!NIL_P(orig_data->original_str)) {
-    self_data->pj = pj_init_plus(RSTRING_PTR(orig_data->original_str));
+    self_data->pj = proj_create(PJ_DEFAULT_CTX, StringValuePtr(orig_data->original_str));
   }
   else {
-    str = pj_get_def(orig_data->pj, 0);
-    self_data->pj = pj_init_plus(str);
-    pj_dalloc(str);
+    str = proj_as_proj_string(PJ_DEFAULT_CTX, orig_data->pj, PJ_PROJ_4, NULL);
+    self_data->pj = proj_create(PJ_DEFAULT_CTX, str);
   }
   self_data->original_str = orig_data->original_str;
   self_data->uses_radians = orig_data->uses_radians;
@@ -112,22 +155,16 @@ static VALUE method_proj4_initialize_copy(VALUE self, VALUE orig)
 
 static VALUE method_proj4_set_value(VALUE self, VALUE str, VALUE uses_radians)
 {
-  RGeo_Proj4Data* self_data;
-  projPJ pj;
+  RGeo_Proj4Data *self_data;
 
   Check_Type(str, T_STRING);
 
   // Clear out any existing value
-  self_data = RGEO_PROJ4_DATA_PTR(self);
-  pj = self_data->pj;
-  if (pj) {
-    pj_free(pj);
-    self_data->pj = NULL;
-    self_data->original_str = Qnil;
-  }
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, self_data);
+  rgeo_proj4_clear_struct(self_data);
 
   // Set new data
-  self_data->pj = pj_init_plus(RSTRING_PTR(str));
+  self_data->pj = proj_create(PJ_DEFAULT_CTX, StringValuePtr(str));
   self_data->original_str = str;
   self_data->uses_radians = RTEST(uses_radians) ? 1 : 0;
 
@@ -138,17 +175,18 @@ static VALUE method_proj4_set_value(VALUE self, VALUE str, VALUE uses_radians)
 static VALUE method_proj4_get_geographic(VALUE self)
 {
   VALUE result;
-  RGeo_Proj4Data* new_data;
-  RGeo_Proj4Data* self_data;
+  RGeo_Proj4Data *new_data;
+  RGeo_Proj4Data *self_data;
 
   result = Qnil;
   new_data = ALLOC(RGeo_Proj4Data);
   if (new_data) {
-    self_data = RGEO_PROJ4_DATA_PTR(self);
-    new_data->pj = pj_latlong_from_proj(self_data->pj);
+    TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, self_data);
+
+    new_data->pj = proj_crs_get_geodetic_crs(PJ_DEFAULT_CTX, self_data->pj);
     new_data->original_str = Qnil;
     new_data->uses_radians = self_data->uses_radians;
-    result = Data_Wrap_Struct(CLASS_OF(self), mark_proj4_func, destroy_proj4_func, new_data);
+    result = TypedData_Wrap_Struct(CLASS_OF(self), &rgeo_proj4_data_type, new_data);
   }
   return result;
 }
@@ -156,44 +194,97 @@ static VALUE method_proj4_get_geographic(VALUE self)
 
 static VALUE method_proj4_original_str(VALUE self)
 {
-  return RGEO_PROJ4_DATA_PTR(self)->original_str;
+  RGeo_Proj4Data *data;
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, data);
+  return data->original_str;
 }
 
 
 static VALUE method_proj4_uses_radians(VALUE self)
 {
-  return RGEO_PROJ4_DATA_PTR(self)->uses_radians ? Qtrue : Qfalse;
+  RGeo_Proj4Data *data;
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, data);
+  return data->uses_radians ? Qtrue : Qfalse;
 }
 
 
 static VALUE method_proj4_canonical_str(VALUE self)
 {
   VALUE result;
-  projPJ pj;
-  char* str;
+  PJ *pj;
+  const char *str;
+  RGeo_Proj4Data *data;
 
   result = Qnil;
-  pj = RGEO_PROJ4_DATA_PTR(self)->pj;
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, data);
+  pj = data->pj;
   if (pj) {
-    str = pj_get_def(pj, 0);
+    str = proj_as_proj_string(PJ_DEFAULT_CTX, pj, PJ_PROJ_4, NULL);
     if (str) {
       result = rb_str_new2(str);
-      pj_dalloc(str);
     }
   }
   return result;
 }
 
+static VALUE method_proj4_wkt_str(VALUE self)
+{
+  VALUE result;
+  PJ *pj;
+  const char *str;
+  RGeo_Proj4Data *data;
+
+  result = Qnil;
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, data);
+  pj = data->pj;
+  if (pj) {
+    const char *const options[] = {"MULTILINE=NO", NULL};
+    str = proj_as_wkt(PJ_DEFAULT_CTX, pj, WKT_TYPE, options);
+    if(str){
+      result = rb_str_new2(str);
+    }
+  }
+  return result;
+}
+
+static VALUE method_proj4_auth_name_str(VALUE self)
+{
+  VALUE result;
+  PJ *pj;
+  const char *id;
+  const char *auth;
+  RGeo_Proj4Data *data;
+
+  result = Qnil;
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, data);
+  pj = data->pj;
+  if (pj) {
+    auth = proj_get_id_auth_name(pj, 0);
+    id = proj_get_id_code(pj, 0);
+    if(id && auth){
+      result = rb_sprintf("%s:%s", auth, id);
+    }
+  }
+  return result;
+}
 
 static VALUE method_proj4_is_geographic(VALUE self)
 {
   VALUE result;
-  projPJ pj;
+  PJ *pj;
+  PJ_TYPE proj_type;
+  RGeo_Proj4Data *data;
 
   result = Qnil;
-  pj = RGEO_PROJ4_DATA_PTR(self)->pj;
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, data);
+  pj = data->pj;
   if (pj) {
-    result = pj_is_latlong(pj) ? Qtrue : Qfalse;
+    proj_type = proj_get_type(pj);
+    if(proj_type == PJ_TYPE_GEOGRAPHIC_2D_CRS || proj_type == PJ_TYPE_GEOGRAPHIC_3D_CRS){
+      result = Qtrue;
+    } else {
+      result = Qfalse;
+    }
   }
   return result;
 }
@@ -202,12 +293,16 @@ static VALUE method_proj4_is_geographic(VALUE self)
 static VALUE method_proj4_is_geocentric(VALUE self)
 {
   VALUE result;
-  projPJ pj;
+  PJ *pj;
+  PJ_TYPE proj_type;
+  RGeo_Proj4Data *data;
 
   result = Qnil;
-  pj = RGEO_PROJ4_DATA_PTR(self)->pj;
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, data);
+  pj = data->pj;
   if (pj) {
-    result = pj_is_geocent(pj) ? Qtrue : Qfalse;
+    proj_type = proj_get_type(pj);
+    result = proj_type == PJ_TYPE_GEOCENTRIC_CRS ? Qtrue : Qfalse;
   }
   return result;
 }
@@ -215,42 +310,62 @@ static VALUE method_proj4_is_geocentric(VALUE self)
 
 static VALUE method_proj4_is_valid(VALUE self)
 {
-  return RGEO_PROJ4_DATA_PTR(self)->pj ? Qtrue : Qfalse;
+  RGeo_Proj4Data *data;
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, data);
+  return data->pj ? Qtrue : Qfalse;
 }
 
 
 static VALUE cmethod_proj4_version(VALUE module)
 {
-  return INT2NUM(PJ_VERSION);
+  return rb_sprintf("%d.%d.%d", PROJ_VERSION_MAJOR, PROJ_VERSION_MINOR, PROJ_VERSION_PATCH);
 }
 
 
 static VALUE cmethod_proj4_transform(VALUE module, VALUE from, VALUE to, VALUE x, VALUE y, VALUE z)
 {
   VALUE result;
-  projPJ from_pj;
-  projPJ to_pj;
+  RGeo_Proj4Data *from_data;
+  RGeo_Proj4Data *to_data;
+  PJ *from_pj;
+  PJ *to_pj;
+  PJ *crs_to_crs;
+  PJ *gis_pj;
   double xval, yval, zval;
-  int err;
+  PJ_COORD input;
+  PJ_COORD output;
 
   result = Qnil;
-  from_pj = RGEO_PROJ4_DATA_PTR(from)->pj;
-  to_pj = RGEO_PROJ4_DATA_PTR(to)->pj;
+  TypedData_Get_Struct(from, RGeo_Proj4Data, &rgeo_proj4_data_type, from_data);
+  TypedData_Get_Struct(to, RGeo_Proj4Data, &rgeo_proj4_data_type, to_data);
+  from_pj = from_data->pj;
+  to_pj = to_data->pj;
   if (from_pj && to_pj) {
-    xval = rb_num2dbl(x);
-    yval = rb_num2dbl(y);
-    zval = 0.0;
-    if (!NIL_P(z)) {
-      zval = rb_num2dbl(z);
-    }
-    err = pj_transform(from_pj, to_pj, 1, 1, &xval, &yval, NIL_P(z) ? NULL : &zval);
-    if (!err && xval != HUGE_VAL && yval != HUGE_VAL && (NIL_P(z) || zval != HUGE_VAL)) {
-      result = rb_ary_new2(NIL_P(z) ? 2 : 3);
-      rb_ary_push(result, rb_float_new(xval));
-      rb_ary_push(result, rb_float_new(yval));
-      if (!NIL_P(z)) {
-        rb_ary_push(result, rb_float_new(zval));
+    crs_to_crs = proj_create_crs_to_crs_from_pj(PJ_DEFAULT_CTX, from_pj, to_pj, 0, NULL);
+    if(crs_to_crs){
+      // necessary to use proj_normalize_for_visualization so that we
+      // do not have to worry about the order of coordinates in every
+      // coord system.
+      gis_pj = proj_normalize_for_visualization(PJ_DEFAULT_CTX, crs_to_crs);
+      if(gis_pj){
+        proj_destroy(crs_to_crs);
+        crs_to_crs = gis_pj;
+
+        xval = rb_num2dbl(x);
+        yval = rb_num2dbl(y);
+        zval = NIL_P(z) ? 0.0 : rb_num2dbl(z);
+
+        input = proj_coord(xval, yval, zval, HUGE_VAL);
+        output = proj_trans(crs_to_crs, PJ_FWD, input);
+
+        result = rb_ary_new2(NIL_P(z) ? 2 : 3);
+        rb_ary_push(result, DBL2NUM(output.xyz.x));
+        rb_ary_push(result, DBL2NUM(output.xyz.y));
+        if(!NIL_P(z)){
+          rb_ary_push(result, DBL2NUM(output.xyz.z));
+        }
       }
+      proj_destroy(crs_to_crs);
     }
   }
   return result;
@@ -266,10 +381,10 @@ static VALUE cmethod_proj4_create(VALUE klass, VALUE str, VALUE uses_radians)
   Check_Type(str, T_STRING);
   data = ALLOC(RGeo_Proj4Data);
   if (data) {
-    data->pj = pj_init_plus(RSTRING_PTR(str));
+    data->pj = proj_create(PJ_DEFAULT_CTX, StringValuePtr(str));
     data->original_str = str;
     data->uses_radians = RTEST(uses_radians) ? 1 : 0;
-    result = Data_Wrap_Struct(klass, mark_proj4_func, destroy_proj4_func, data);
+    result = TypedData_Wrap_Struct(klass, &rgeo_proj4_data_type, data);
   }
   return result;
 }
@@ -285,12 +400,14 @@ static void rgeo_init_proj4()
   coordsys_module = rb_define_module_under(rgeo_module, "CoordSys");
   proj4_class = rb_define_class_under(coordsys_module, "Proj4", rb_cObject);
 
-  rb_define_alloc_func(proj4_class, alloc_proj4);
+  rb_define_alloc_func(proj4_class, rgeo_proj4_data_alloc);
   rb_define_module_function(proj4_class, "_create", cmethod_proj4_create, 2);
   rb_define_method(proj4_class, "initialize_copy", method_proj4_initialize_copy, 1);
   rb_define_method(proj4_class, "_set_value", method_proj4_set_value, 2);
   rb_define_method(proj4_class, "_original_str", method_proj4_original_str, 0);
   rb_define_method(proj4_class, "_canonical_str", method_proj4_canonical_str, 0);
+  rb_define_method(proj4_class, "_as_text", method_proj4_wkt_str, 0);
+  rb_define_method(proj4_class, "_auth_name", method_proj4_auth_name_str, 0);
   rb_define_method(proj4_class, "_valid?", method_proj4_is_valid, 0);
   rb_define_method(proj4_class, "_geographic?", method_proj4_is_geographic, 0);
   rb_define_method(proj4_class, "_geocentric?", method_proj4_is_geocentric, 0);

data/lib/rgeo/coord_sys/proj4.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Proj4 wrapper for RGeo
@@ -39,10 +41,10 @@ module RGeo
       # there are sometimes multiple ways to express a given coordinate
       # system.
 
-      def eql?(rhs_)
-        rhs_.class == self.class && rhs_.canonical_hash == canonical_hash && rhs_._radians? == _radians?
+      def eql?(other)
+        other.class == self.class && other.canonical_hash == canonical_hash && other._radians? == _radians?
       end
-      alias_method :==, :eql?
+      alias == eql?
 
       # Marshal support
 
@@ -76,9 +78,7 @@ module RGeo
       def canonical_str
         unless defined?(@canonical_str)
           @canonical_str = _canonical_str
-          if @canonical_str.respond_to?(:force_encoding)
-            @canonical_str.force_encoding("US-ASCII")
-          end
+          @canonical_str.force_encoding("US-ASCII") if @canonical_str.respond_to?(:force_encoding)
         end
         @canonical_str
       end
@@ -105,6 +105,21 @@ module RGeo
         _original_str
       end
 
+      # Returns the WKT representation of the CRS.
+
+      def as_text
+        _as_text
+      end
+
+      # Returns the string representing the authority and code of the
+      # CRS if it exists, nil otherwise.
+      #
+      # Ex. EPSG:4326
+
+      def auth_name
+        _auth_name
+      end
+
       # Returns true if this Proj4 object is a geographic (lat-long)
       # coordinate system.
 
@@ -172,9 +187,7 @@ module RGeo
             if defn_.is_a?(::Hash)
               defn_ = defn_.map { |k_, v_| v_ ? "+#{k_}=#{v_}" : "+#{k_}" }.join(" ")
             end
-            unless defn_ =~ /^\s*\+/
-              defn_ = defn_.sub(/^(\s*)/, '\1+').gsub(/(\s+)([^+\s])/, '\1+\2')
-            end
+
             result_ = _create(defn_, opts_[:radians])
             result_ = nil unless result_._valid?
           end
@@ -200,9 +213,7 @@ module RGeo
 
         def new(defn_, opts_ = {})
           result_ = create(defn_, opts_)
-          unless result_
-            raise Error::UnsupportedOperation, "Proj4 not supported in this installation"
-          end
+          raise Error::UnsupportedOperation, "Proj4 not supported in this installation" unless result_
           result_
         end
 
@@ -212,14 +223,15 @@ module RGeo
         # or three elements.
 
         def transform_coords(from_proj_, to_proj_, x_, y_, z_ = nil)
-          if !from_proj_._radians? && from_proj_._geographic?
-            x_ *= ImplHelper::Math::RADIANS_PER_DEGREE
-            y_ *= ImplHelper::Math::RADIANS_PER_DEGREE
+          if from_proj_._radians? && from_proj_._geographic?
+            x_ *= ImplHelper::Math::DEGREES_PER_RADIAN
+            y_ *= ImplHelper::Math::DEGREES_PER_RADIAN
           end
+
           result_ = _transform_coords(from_proj_, to_proj_, x_, y_, z_)
-          if result_ && !to_proj_._radians? && to_proj_._geographic?
-            result_[0] *= ImplHelper::Math::DEGREES_PER_RADIAN
-            result_[1] *= ImplHelper::Math::DEGREES_PER_RADIAN
+          if result_ && to_proj_._radians? && to_proj_._geographic?
+            result_[0] *= ImplHelper::Math::RADIANS_PER_DEGREE
+            result_[1] *= ImplHelper::Math::RADIANS_PER_DEGREE
           end
           result_
         end
@@ -233,27 +245,29 @@ module RGeo
         def transform(from_proj_, from_geometry_, to_proj_, to_factory_)
           case from_geometry_
           when Feature::Point
-            _transform_point(from_proj_, from_geometry_, to_proj_, to_factory_)
+            transform_point(from_proj_, from_geometry_, to_proj_, to_factory_)
           when Feature::Line
-            to_factory_.line(from_geometry_.points.map { |p_| _transform_point(from_proj_, p_, to_proj_, to_factory_) })
+            to_factory_.line(from_geometry_.points.map { |p_| transform_point(from_proj_, p_, to_proj_, to_factory_) })
           when Feature::LinearRing
-            _transform_linear_ring(from_proj_, from_geometry_, to_proj_, to_factory_)
+            transform_linear_ring(from_proj_, from_geometry_, to_proj_, to_factory_)
           when Feature::LineString
-            to_factory_.line_string(from_geometry_.points.map { |p_| _transform_point(from_proj_, p_, to_proj_, to_factory_) })
+            to_factory_.line_string(from_geometry_.points.map { |p_| transform_point(from_proj_, p_, to_proj_, to_factory_) })
           when Feature::Polygon
-            _transform_polygon(from_proj_, from_geometry_, to_proj_, to_factory_)
+            transform_polygon(from_proj_, from_geometry_, to_proj_, to_factory_)
           when Feature::MultiPoint
-            to_factory_.multi_point(from_geometry_.map { |p_| _transform_point(from_proj_, p_, to_proj_, to_factory_) })
+            to_factory_.multi_point(from_geometry_.map { |p_| transform_point(from_proj_, p_, to_proj_, to_factory_) })
           when Feature::MultiLineString
             to_factory_.multi_line_string(from_geometry_.map { |g_| transform(from_proj_, g_, to_proj_, to_factory_) })
           when Feature::MultiPolygon
-            to_factory_.multi_polygon(from_geometry_.map { |p_| _transform_polygon(from_proj_, p_, to_proj_, to_factory_) })
+            to_factory_.multi_polygon(from_geometry_.map { |p_| transform_polygon(from_proj_, p_, to_proj_, to_factory_) })
           when Feature::GeometryCollection
             to_factory_.collection(from_geometry_.map { |g_| transform(from_proj_, g_, to_proj_, to_factory_) })
           end
         end
 
-        def _transform_point(from_proj_, from_point_, to_proj_, to_factory_) # :nodoc:
+        private
+
+        def transform_point(from_proj_, from_point_, to_proj_, to_factory_)
           from_factory_ = from_point_.factory
           from_has_z_ = from_factory_.property(:has_z_coordinate)
           from_has_m_ = from_factory_.property(:has_m_coordinate)
@@ -261,30 +275,32 @@ module RGeo
           to_has_m_ = to_factory_.property(:has_m_coordinate)
           x_ = from_point_.x
           y_ = from_point_.y
-          if !from_proj_._radians? && from_proj_._geographic?
-            x_ *= ImplHelper::Math::RADIANS_PER_DEGREE
-            y_ *= ImplHelper::Math::RADIANS_PER_DEGREE
+          if from_proj_._radians? && from_proj_._geographic?
+            x_ *= ImplHelper::Math::DEGREES_PER_RADIAN
+            y_ *= ImplHelper::Math::DEGREES_PER_RADIAN
           end
           coords_ = _transform_coords(from_proj_, to_proj_, x_, y_, from_has_z_ ? from_point_.z : nil)
-          if coords_
-            if !to_proj_._radians? && to_proj_._geographic?
-              coords_[0] *= ImplHelper::Math::DEGREES_PER_RADIAN
-              coords_[1] *= ImplHelper::Math::DEGREES_PER_RADIAN
-            end
-            extras_ = []
-            extras_ << coords_[2].to_f if to_has_z_
-            extras_ << from_has_m_ ? from_point_.m : 0.0 if to_has_m_
-            to_factory_.point(coords_[0], coords_[1], *extras_)
+          return unless coords_
+
+          if to_proj_._radians? && to_proj_._geographic?
+            coords_[0] *= ImplHelper::Math::RADIANS_PER_DEGREE
+            coords_[1] *= ImplHelper::Math::RADIANS_PER_DEGREE
+          end
+          extras_ = []
+          extras_ << coords_[2].to_f if to_has_z_
+          if to_has_m_
+            extras_ << from_has_m_ ? from_point_.m : 0.0
           end
+          to_factory_.point(coords_[0], coords_[1], *extras_)
         end
 
-        def _transform_linear_ring(from_proj_, from_ring_, to_proj_, to_factory_) # :nodoc:
-          to_factory_.linear_ring(from_ring_.points[0..-2].map { |p_| _transform_point(from_proj_, p_, to_proj_, to_factory_) })
+        def transform_linear_ring(from_proj_, from_ring_, to_proj_, to_factory_)
+          to_factory_.linear_ring(from_ring_.points[0..-2].map { |p_| transform_point(from_proj_, p_, to_proj_, to_factory_) })
         end
 
-        def _transform_polygon(from_proj_, from_polygon_, to_proj_, to_factory_) # :nodoc:
-          ext_ = _transform_linear_ring(from_proj_, from_polygon_.exterior_ring, to_proj_, to_factory_)
-          int_ = from_polygon_.interior_rings.map { |r_| _transform_linear_ring(from_proj_, r_, to_proj_, to_factory_) }
+        def transform_polygon(from_proj_, from_polygon_, to_proj_, to_factory_)
+          ext_ = transform_linear_ring(from_proj_, from_polygon_.exterior_ring, to_proj_, to_factory_)
+          int_ = from_polygon_.interior_rings.map { |r_| transform_linear_ring(from_proj_, r_, to_proj_, to_factory_) }
           to_factory_.polygon(ext_, int_)
         end
       end

data/lib/rgeo/coord_sys/srs_database/proj4_data.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # SRS database interface
@@ -62,7 +64,7 @@ module RGeo
             when :read_all
               @populate_state = 1
             when :preload
-              _search_file(nil)
+              search_file(nil)
               @populate_state = 2
             else
               @populate_state = 0
@@ -77,14 +79,15 @@ module RGeo
 
         def get(ident_)
           ident_ = ident_.to_s
-          return @cache[ident_] if @cache && @cache.include?(ident_)
+          return @cache[ident_] if @cache&.include?(ident_)
           result_ = nil
-          if @populate_state == 0
-            data_ = _search_file(ident_)
+          case @populate_state
+          when 0
+            data_ = search_file(ident_)
             result_ = Entry.new(ident_, authority: @authority, authority_code: @authority ? ident_ : nil, name: data_[1], proj4: data_[2]) if data_
             @cache[ident_] = result_ if @cache
-          elsif @populate_state == 1
-            _search_file(nil)
+          when 1
+            search_file(nil)
             result_ = @cache[ident_]
             @populate_state = 2
           end
@@ -94,27 +97,27 @@ module RGeo
         # Clear the cache if one exists.
 
         def clear_cache
-          @cache.clear if @cache
+          @cache&.clear
           @populate_state = 1 if @populate_state == 2
         end
 
-        def _search_file(ident_) # :nodoc:
+        private
+
+        def search_file(ident_)
           ::File.open(@path) do |file_|
             cur_name_ = nil
             cur_ident_ = nil
             cur_text_ = nil
             file_.each do |line_|
               line_.strip!
-              if (comment_delim_ = line_.index('#'))
+              if (comment_delim_ = line_.index("#"))
                 cur_name_ = line_[comment_delim_ + 1..-1].strip
                 line_ = line_[0..comment_delim_ - 1].strip
               end
-              unless cur_ident_
-                if line_ =~ /^<(\w+)>(.*)/
-                  cur_ident_ = Regexp.last_match(1)
-                  cur_text_ = []
-                  line_ = Regexp.last_match(2).strip
-                end
+              if !cur_ident_ && (line_ =~ /^<(\w+)>(.*)/)
+                cur_ident_ = Regexp.last_match(1)
+                cur_text_ = []
+                line_ = Regexp.last_match(2).strip
               end
               next unless cur_ident_
               if line_[-2..-1] == "<>"

data/lib/rgeo/proj4.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rgeo"
 require "rgeo/proj4/version"
 require "rgeo/coord_sys/proj4"

data/lib/rgeo/proj4/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module RGeo
   module Proj4
-    VERSION = "1.0.0.rc1"
+    VERSION = "3.0.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rgeo-proj4
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc1
+  version: 3.0.1
 platform: ruby
 authors:
 - Tee Parham, Daniel Azuma
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-27 00:00:00.000000000 Z
+date: 2021-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rgeo
@@ -16,42 +16,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0.rc1
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0.rc1
+        version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '5.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '5.14'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.9.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
@@ -67,19 +81,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: test-unit
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 1.8.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 1.8.1
 description: Proj4 extension for rgeo.
 email:
 - parhameter@gmail.com, dazuma@gmail.com
@@ -107,15 +121,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.1.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.0
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Proj4 extension for rgeo.