;;;; Copyright (C) 2020 Julien Lepiller <julien@lepiller.eu>

;;;; 

;;;; This library is free software; you can redistribute it and/or

;;;; modify it under the terms of the GNU Lesser General Public

;;;; License as published by the Free Software Foundation; either

;;;; version 3 of the License, or (at your option) any later version.

;;;; 

;;;; This library is distributed in the hope that it will be useful,

;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of

;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

;;;; Lesser General Public License for more details.

;;;; 

;;;; You should have received a copy of the GNU Lesser General Public

;;;; License along with this library; if not, write to the Free Software

;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

;;;; 

(define-module (turtle fromrdf)

  #:use-module (ice-9 match)

  #:use-module (ice-9 textual-ports)

  #:use-module (iri iri)

  #:use-module (srfi srfi-1)

  #:use-module (srfi srfi-9)

  #:use-module (rdf rdf)

  #:export (rdf->turtle))

(define (turtle-escape str)

  "Escape a string for writing it to a turtle document."

  (list->string (append-map (lambda (c)

                              (match c

                                (#\\ (list #\\ #\\))

                                (#\" (list #\\ #\"))

                                (#\newline (list #\\ #\n))

                                (#\return (list #\\ #\r))

                                (#\tab (list #\\ #\t))

                                (#\backspace (list #\\ #\b))

                                (_ (list c))))

                            (string->list str))))

(define (node->turtle node)

  (cond

    ((blank-node? node)

     (string-append "_:" (number->string node)))

    ((rdf-datatype? node)

     (string-append "<" (car (rdf-datatype-iris node)) ">"))

    ((rdf-literal? node)

     (string-append "\"" (turtle-escape (rdf-literal-lexical-form node)) "\""

                    (if (rdf-literal-langtag node)

                        (string-append "@" (rdf-literal-langtag node))

                        (let ((type (rdf-literal-type node)))

                          (string-append

                            "^^<" (if (rdf-datatype? type)

                                     (car (rdf-datatype-iris type))

                                     type)

                            ">")))))

    ((string? node)

     (string-append "<" node ">"))))

(define (rdf->turtle g)

  (string-join

    (map

      (match-lambda

        (($ rdf-triple subject predicate object)

         (format #f "~a ~a ~a ."

                 (node->turtle subject)

                 (node->turtle predicate)

                 (node->turtle object))))

      g)

    "\n"))