chore: Fix typos and set up lintr (#40)

This makes it generally easier to work on in VSCode without a mountain
of blue lintr warnings!

.Rbuildignore

@@ -12,3 +12,4 @@
 ^compile_commands\.json$
 ^\.cache$
 ^cran-comments\.md$
+^\.lintr$

.github/workflows/R-CMD-check.yaml

@@ -19,8 +19,6 @@ jobs:
       matrix:
         config:
           - {os: macos-latest,   r: 'release'}
-          - {os: windows-latest, r: '3.6'}
-          - {os: windows-latest, r: '4.0'}
           - {os: windows-latest, r: 'release'}
           - {os: ubuntu-latest,   r: 'devel', http-user-agent: 'release'}
           - {os: ubuntu-latest,   r: 'release'}
@@ -43,10 +41,9 @@ jobs:
 
       - uses: r-lib/actions/setup-r-dependencies@v2
         with:
-          extra-packages: any::rcmdcheck, arrow=?ignore-before-r=4.0.0
+          extra-packages: any::rcmdcheck
           needs: check
 
       - uses: r-lib/actions/check-r-package@v2
         with:
           upload-snapshots: true
-          args: 'c("--no-manual", "--as-cran", "--no-multiarch")'

.github/workflows/lint.yaml

@@ -0,0 +1,34 @@
+# Workflow derived from https://github.com/r-lib/actions/tree/v2/examples
+# Need help debugging build failures? Start at https://github.com/r-lib/actions#where-to-find-help
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+    branches: [main, master]
+
+name: lint
+
+permissions: read-all
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    env:
+      GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: r-lib/actions/setup-r@v2
+        with:
+          use-public-rspm: true
+
+      - uses: r-lib/actions/setup-r-dependencies@v2
+        with:
+          extra-packages: any::lintr, local::.
+          needs: lint
+
+      - name: Lint
+        run: lintr::lint_package()
+        shell: Rscript {0}
+        env:
+          LINTR_ERROR_ON_LINT: true

.lintr

@@ -0,0 +1,5 @@
+linters: linters_with_defaults(
+    line_length_linter(90),
+    commented_code_linter = NULL,
+    object_name_linter = NULL
+  )

DESCRIPTION

@@ -1,5 +1,5 @@
 Package: geoarrow
-Title: Extension types for geospatial data for use with 'Arrow'
+Title: Extension types for spatial data for use with 'Arrow'
 Version: 0.1.0.9000
 Authors@R:
     c(
@@ -19,8 +19,8 @@ Authors@R:
       person("Joao Paulo", "Magalhaes", role = "cph")
     )
 Description: Provides extension types and conversions to between R-native
-  object types and 'Arrow' columnar types. This includes integrations among
-  the 'arrow', 'nanoarrow', 'sf', and 'wk' packages such that geospatial
+  object types and 'Arrow' columnar types. This includes integration among
+  the 'arrow', 'nanoarrow', 'sf', and 'wk' packages such that spatial
   metadata is preserved wherever possible. Extension type implementations
   ensure first-class geometry data type support in the 'arrow' and 'nanoarrow'
   packages.

R/array.R

@@ -26,7 +26,7 @@ as_geoarrow_array.default <- function(x, ..., schema = NULL) {
 
 #' @export
 as_geoarrow_array.nanoarrow_array <- function(x, ..., schema = NULL) {
-  schema_src <- infer_nanoarrow_schema(x)
+  schema_src <- nanoarrow::infer_nanoarrow_schema(x)
   if (is.null(schema)) {
     schema <- infer_geoarrow_schema(x)
   }
@@ -316,9 +316,8 @@ force_schema_storage <- function(schema) {
 }
 
 force_array_storage <- function(array) {
-  schema <- force_schema_storage(infer_nanoarrow_schema(array))
+  schema <- force_schema_storage(nanoarrow::infer_nanoarrow_schema(array))
   array_shallow <- nanoarrow::nanoarrow_allocate_array()
   nanoarrow::nanoarrow_pointer_export(array, array_shallow)
   nanoarrow::nanoarrow_array_set_schema(array_shallow, schema, validate = FALSE)
 }
-

R/infer-default.R

@@ -27,7 +27,6 @@ infer_geoarrow_schema.default <- function(x, ..., promote_multi = TRUE,
 
   # try vector_meta (doesn't iterate along features)
   vector_meta <- wk::wk_vector_meta(x)
-  all_types <- vector_meta$geometry_type
 
   has_mising_info <- is.na(vector_meta$geometry_type) ||
     (vector_meta$geometry_type == 0L) ||
@@ -45,7 +44,7 @@ infer_geoarrow_schema.default <- function(x, ..., promote_multi = TRUE,
     vector_meta$has_z <- any(meta$has_z, na.rm = TRUE)
     vector_meta$has_m <- any(meta$has_m, na.rm = TRUE)
 
-    schema_from_geometry_types_and_dims(
+    schema_from_types_and_dims(
       x,
       unique_types,
       has_z = any(meta$has_z, na.rm = TRUE),
@@ -54,7 +53,7 @@ infer_geoarrow_schema.default <- function(x, ..., promote_multi = TRUE,
       coord_type = coord_type
     )
   } else {
-    schema_from_geometry_types_and_dims(
+    schema_from_types_and_dims(
       x,
       vector_meta$geometry_type,
       has_z = vector_meta$has_z,
@@ -99,7 +98,7 @@ infer_geoarrow_schema.nanoarrow_array_stream <- function(x, ..., promote_multi =
   has_z <- any(unique_dims %in% c(2L, 4L))
   has_m <- any(unique_dims %in% c(3L, 4L))
 
-  schema_from_geometry_types_and_dims(
+  schema_from_types_and_dims(
     x,
     unique_types,
     has_z,
@@ -109,8 +108,9 @@ infer_geoarrow_schema.nanoarrow_array_stream <- function(x, ..., promote_multi =
   )
 }
 
-schema_from_geometry_types_and_dims <- function(x, unique_types, has_z, has_m,
-                                                promote_multi, coord_type) {
+# nolint start: cyclocomp_linter.
+schema_from_types_and_dims <- function(x, unique_types, has_z, has_m,
+                                       promote_multi, coord_type) {
   if (is.null(coord_type)) {
     coord_type <- enum$CoordType$SEPARATE
   }
@@ -149,3 +149,4 @@ schema_from_geometry_types_and_dims <- function(x, unique_types, has_z, has_m,
     coord_type = coord_type
   )
 }
+# nolint end

R/kernel.R

@@ -118,7 +118,10 @@ serialize_kernel_options <- function(vals) {
   # When this matters we can wire up nanoarrow's serializer
   tmp <- tempfile()
   con <- file(tmp, open = "w+b")
-  on.exit({close(con); unlink(tmp)})
+  on.exit({
+    close(con)
+    unlink(tmp)
+  })
 
   writeBin(length(vals), con, size = 4L)
   for (i in seq_along(vals)) {

R/pkg-arrow.R

@@ -14,7 +14,7 @@ as_chunked_array.geoarrow_vctr <- function(x, ..., type = NULL) {
     schema <- NULL
     type <- arrow::as_data_type(attr(x, "schema", exact = TRUE))
   } else {
-    schema <- as_nanoarrow_schema(type)
+    schema <- nanoarrow::as_nanoarrow_schema(type)
     type <- arrow::as_data_type(type)
   }
 
@@ -23,7 +23,7 @@ as_chunked_array.geoarrow_vctr <- function(x, ..., type = NULL) {
   chunks <- nanoarrow::collect_array_stream(stream, validate = FALSE)
   type <- arrow::as_data_type(type)
 
-  schema <- as_nanoarrow_schema(type)
+  schema <- nanoarrow::as_nanoarrow_schema(type)
   arrays <- vector("list", length(chunks))
   for (i in seq_along(arrays)) {
     tmp_schema <- nanoarrow::nanoarrow_allocate_schema()
@@ -37,14 +37,14 @@ as_chunked_array.geoarrow_vctr <- function(x, ..., type = NULL) {
 }
 
 infer_type.geoarrow_vctr <- function(x, ...) {
-  arrow::as_data_type(as_nanoarrow_schema(x))
+  arrow::as_data_type(nanoarrow::as_nanoarrow_schema(x))
 }
 
 #' @export
 as_geoarrow_array_stream.ChunkedArray <- function(x, ..., schema = NULL) {
   stream <- nanoarrow::basic_array_stream(
-    lapply(x$chunks, as_nanoarrow_array),
-    schema = as_nanoarrow_schema(x$type),
+    lapply(x$chunks, nanoarrow::as_nanoarrow_array),
+    schema = nanoarrow::as_nanoarrow_schema(x$type),
     validate = FALSE
   )
 
@@ -54,8 +54,8 @@ as_geoarrow_array_stream.ChunkedArray <- function(x, ..., schema = NULL) {
 #' @export
 as_geoarrow_array_stream.Array <- function(x, ..., schema = NULL) {
   stream <- nanoarrow::basic_array_stream(
-    list(as_nanoarrow_array(x)),
-    schema = as_nanoarrow_schema(x$type),
+    list(nanoarrow::as_nanoarrow_array(x)),
+    schema = nanoarrow::as_nanoarrow_schema(x$type),
     validate = FALSE
   )
 
@@ -69,7 +69,7 @@ GeometryExtensionType$create <- function(...) {
 
 # this runs in .onLoad(), where we can't get coverage
 # nocov start
-register_arrow_extension_type_or_set_hook <- function(...) {
+register_arrow_ext_or_set_hook <- function(...) {
   # Register a hook for the arrow package being loaded to run the extension type
   # registration
   setHook(packageEvent("arrow", "onLoad"), register_arrow_extension_type)
@@ -90,7 +90,7 @@ register_arrow_extension_type <- function(...) {
     public = list(
 
       deserialize_instance = function() {
-        private$schema <- as_nanoarrow_schema(self)
+        private$schema <- nanoarrow::as_nanoarrow_schema(self)
         private$parsed <- geoarrow_schema_parse(private$schema)
       },
 
@@ -151,7 +151,7 @@ register_arrow_extension_type <- function(...) {
   # when the Type object gets surfaced to R provided that the extension types
   # have been registered.
   GeometryExtensionType$create <- function(schema) {
-    schema <- as_nanoarrow_schema(schema)
+    schema <- nanoarrow::as_nanoarrow_schema(schema)
     parsed <- geoarrow_schema_parse(schema)
 
     arrow::new_extension_type(

R/pkg-nanoarrow.R

@@ -19,7 +19,8 @@ register_geoarrow_extension <- function() {
 
 #' @importFrom nanoarrow infer_nanoarrow_ptype_extension
 #' @export
-infer_nanoarrow_ptype_extension.geoarrow_extension_spec <- function(extension_spec, x, ...) {
+infer_nanoarrow_ptype_extension.geoarrow_extension_spec <- function(extension_spec,
+                                                                    x, ...) {
   nanoarrow::nanoarrow_vctr(schema = x, subclass = "geoarrow_vctr")
 }
 
@@ -47,5 +48,5 @@ as_nanoarrow_array_extension.geoarrow_extension_spec <- function(
 #' @importFrom nanoarrow convert_array
 #' @export
 convert_array.geoarrow_vctr <- function(array, to, ...) {
-  as_geoarrow_vctr(array, schema = as_nanoarrow_schema(to))
+  as_geoarrow_vctr(array, schema = nanoarrow::as_nanoarrow_schema(to))
 }

R/pkg-sf.R

@@ -41,15 +41,15 @@ st_as_sf.arrow_dplyr_query <- function(x, ..., promote_multi = FALSE) {
 
 as_arrow_array.sfc <- function(x, ..., type = NULL) {
   if (!is.null(type)) {
-    type <- as_nanoarrow_schema(type)
+    type <- nanoarrow::as_nanoarrow_schema(type)
   }
 
   arrow::as_arrow_array(as_geoarrow_vctr(x, schema = type))
 }
 
 as_chunked_array.sfc <- function(x, ..., type = NULL) {
   if (!is.null(type)) {
-    type <- as_nanoarrow_schema(type)
+    type <- nanoarrow::as_nanoarrow_schema(type)
   }
 
   arrow::as_chunked_array(as_geoarrow_vctr(x, schema = type))

R/pkg-wk.R

@@ -30,7 +30,7 @@ as_geoarrow_array.wk_wkt <- function(x, ..., schema = NULL) {
       return(NextMethod())
     }
   } else {
-    schema <- infer_nanoarrow_schema(x)
+    schema <- nanoarrow::infer_nanoarrow_schema(x)
   }
 
   schema_storage <- nanoarrow::nanoarrow_schema_modify(
@@ -52,7 +52,7 @@ as_geoarrow_array.wk_wkb <- function(x, ..., schema = NULL) {
       return(NextMethod())
     }
   } else {
-    schema <- infer_nanoarrow_schema(x)
+    schema <- nanoarrow::infer_nanoarrow_schema(x)
   }
 
   schema_storage <- nanoarrow::nanoarrow_schema_modify(
@@ -75,7 +75,7 @@ as_geoarrow_array.wk_xy <- function(x, ..., schema = NULL) {
     }
   }
 
-  schema <- infer_nanoarrow_schema(x)
+  schema <- nanoarrow::infer_nanoarrow_schema(x)
   data <- unclass(x)
   geoarrow_array_from_buffers(
     schema,
@@ -114,12 +114,12 @@ infer_nanoarrow_schema.wk_xy <- function(x, ...) {
 
 #' @export
 convert_array.wk_wkt <- function(array, to, ...) {
-  schema <- infer_nanoarrow_schema(array)
+  schema <- nanoarrow::infer_nanoarrow_schema(array)
   geo <- geoarrow_schema_parse(schema)
   vctr <- as_geoarrow_vctr(array)
 
   if (geo$extension_name == "geoarrow.wkt") {
-    out <- wk::new_wk_wkt(convert_array(force_array_storage(array)))
+    out <- wk::new_wk_wkt(nanoarrow::convert_array(force_array_storage(array)))
   } else {
     out <- wk::wk_handle(vctr, wk::wkt_writer())
   }
@@ -132,12 +132,12 @@ convert_array.wk_wkt <- function(array, to, ...) {
 
 #' @export
 convert_array.wk_wkb <- function(array, to, ...) {
-  schema <- infer_nanoarrow_schema(array)
+  schema <- nanoarrow::infer_nanoarrow_schema(array)
   geo <- geoarrow_schema_parse(schema)
   vctr <- as_geoarrow_vctr(array)
 
   if (geo$extension_name == "geoarrow.wkb") {
-    storage <- convert_array(force_array_storage(array))
+    storage <- nanoarrow::convert_array(force_array_storage(array))
     # Comes back as a blob::blob
     attributes(storage) <- NULL
     out <- wk::new_wk_wkb(storage)
@@ -152,12 +152,12 @@ convert_array.wk_wkb <- function(array, to, ...) {
 
 #' @export
 convert_array.wk_xy <- function(array, to, ...) {
-  schema <- infer_nanoarrow_schema(array)
+  schema <- nanoarrow::infer_nanoarrow_schema(array)
   geo <- geoarrow_schema_parse(schema)
   vctr <- as_geoarrow_vctr(array)
 
   if (geo$extension_name == "geoarrow.point") {
-    out <- wk::as_xy(convert_array(force_array_storage(array)))
+    out <- wk::as_xy(nanoarrow::convert_array(force_array_storage(array)))
   } else {
     out <- wk::wk_handle(vctr, wk::xy_writer())
   }