parser and serializer will guess format

based on file extension, closes #4

serializer also sets explicit base option

serializer defaults to print to character string if doc is NULL.

R/rdf_parse.R

@@ -3,7 +3,8 @@
 #' @param doc path, URL, or literal string of the rdf document to parse
 #' @param format rdf serialization format of the doc,
 #' one of "rdfxml", "nquads", "ntriples", "turtle"
-#' or "jsonld"
+#' or "jsonld". If not provided, will try to guess based
+#' on file extension and fall back on rdfxml.
 #' @param rdf an existing rdf triplestore to extend with triples from
 #' the parsed file.  Default will create a new rdf object.
 #' @param ... additional parameters (not implemented)
@@ -20,14 +21,19 @@
 #' rdf <- rdf_parse(doc)
 #'
 rdf_parse <- function(doc,
-                      format = c("rdfxml",
+                      format = c("guess",
+                                 "rdfxml",
                                  "nquads",
                                  "ntriples",
                                  "turtle",
                                  "jsonld"),
                       rdf = NULL,
                       ...){
+
   format <- match.arg(format)
+  if(format == "guess"){
+    format <- guess_format(doc)
+  }
 
   ## if we get a string as input, we'll store it in tmp file here
   ## which we can later be sure to clean up.

R/rdf_serialize.R

@@ -2,7 +2,7 @@
 #'
 #' @inheritParams rdf_parse
 #' @inheritParams rdf_query
-#' @param doc file path to write out to
+#' @param doc file path to write out to. If null, will write to character.
 #' @param namespace string giving the namespace to set
 #' @param prefix string giving the prefix associated with the namespace
 #' @param ... additional arguments to \code{redland::serializeToFile}
@@ -29,17 +29,22 @@
 #'           prefix = "dc")
 #'
 rdf_serialize <- function(rdf,
-                          doc,
-                          format = c("rdfxml",
+                          doc = NULL,
+                          format = c("guess",
+                                     "rdfxml",
                                      "nquads",
                                      "ntriples",
                                      "turtle",
                                      "jsonld"),
                           namespace = NULL,
                           prefix = NULL,
+                          base = getOption("rdflib_base_uri", as.character(NA)),
                           ...){
 
   format <- match.arg(format)
+  if(format == "guess"){
+    format <- guess_format(doc)
+  }
 
 
   ## redlands doesn't support jsonld. So write as nquads and then transform
@@ -61,13 +66,20 @@ rdf_serialize <- function(rdf,
                           prefix = prefix)
   }
 
-  status <-
-    redland::serializeToFile(serializer, rdf$world, rdf$model, doc, ...)
+  if(is.null(doc)){
+    doc <- redland::serializeToCharacter(serializer, rdf$world, rdf$model, baseUri = base, ...)
+  } else {
+    status <-
+      redland::serializeToFile(serializer, rdf$world, rdf$model, doc, baseUri = base, ...)
+  }
 
   if(jsonld_output){
     txt <- paste(readLines(doc), collapse = "\n")
     if(length(txt) > 0){ ## don't attempt to write empty file into json
-      json <- jsonld::jsonld_from_rdf(txt)
+      json <- jsonld::jsonld_from_rdf(txt,
+                                      options = list(
+                                        base = base,
+                                        format = "application/nquads"))
       compact_json <- jsonld_compact(json, "{}")
       writeLines(compact_json, doc)
     }

R/utilities.R

@@ -1,3 +1,17 @@
+guess_format <- function(doc){
+  switch(gsub(".*\\.(\\w+)$", "\\1", basename(doc)),
+         "xml" = "rdfxml",
+         "rdf" = "rdfxml",
+         "json" = "jsonld",
+         "nq" = "nquads",
+         "nt" = "ntriples",
+         "ttl" = "turtle",
+         "jsonld" = "jsonld",
+         "quads" = "nquads",
+         "turtle" = "turtle",
+         "rdfxml")
+}
+
 
 ## Don't explicitly type characters as strings, since this is default
 xs_class <- function(x, explicit_strings = FALSE){

tests/testthat/test-parse-serialize.R

@@ -4,6 +4,16 @@ doc <- system.file("extdata/example.rdf", package="redland")
 out <- "testing.rdf"
 
 
+
+testthat::test_that("we can serialize to character", {
+                      rdf <- rdf_parse(doc) 
+                      txt <- rdf_serialize(rdf, format = "nquads")
+                      testthat::expect_is(txt, "character")
+                      testthat::expect_match(txt, "John Smith")
+                      rdf_free(rdf)
+                      })
+
+
 testthat::test_that("we can parse (in rdfxml)
                     and serialize (in nquads) a simple rdf graph", {
                       rdf <- rdf_parse(doc) 
@@ -73,10 +83,22 @@ testthat::test_that("we can parse and serialize rdfxml", {
 
 ################################################################
 
+
+testthat::test_that("we can parse by guessing on the file extension", {
+  ex <- system.file("extdata/person.nq", package="rdflib")
+  rdf <- rdf_parse(ex)
+  rdf_serialize(rdf, "tmp.nq", base = "http://schema.org/")
+  roundtrip <- rdf_parse("tmp.nq", "turtle")
+  testthat::expect_is(roundtrip, "rdf")
+  unlink("tmp.nq")
+  rdf_free(rdf)
+})
+
+
 testthat::test_that("we can serialize turtle with a baseUri", {
   ex <- system.file("extdata/person.nq", package="rdflib")
   rdf <- rdf_parse(ex, "nquads")
-  rdf_serialize(rdf, out, "turtle", baseUri = "http://schema.org/")
+  rdf_serialize(rdf, out, "turtle", base = "http://schema.org/")
   roundtrip <- rdf_parse(out, "turtle")
   testthat::expect_is(roundtrip, "rdf")
   rdf_free(rdf)