(in-package #:topic-maps.ctm) (defstruct iri-parts scheme authority (path "") query fragment) (defun ascii-letter-p (c) (or (char<= #\a c #\z) (char<= #\A c #\Z))) (defun scheme-p (text) (and (plusp (length text)) (ascii-letter-p (char text 0)) (every (lambda (c) (or (ascii-letter-p c) (find c "0123456789+-."))) text))) (defun starts-with (prefix string) (and (<= (length prefix) (length string)) (string= prefix string :end2 (length prefix)))) (defun split-iri (iri) (let* ((fragment-position (position #\# iri)) (fragment (when fragment-position (subseq iri (1+ fragment-position)))) (remaining (subseq iri 0 fragment-position)) (query-position (position #\? remaining)) (query (when query-position (subseq remaining (1+ query-position)))) (head (subseq remaining 0 query-position)) (colon (position #\: head)) (scheme (when (and colon (scheme-p (subseq head 0 colon))) (subseq head 0 colon))) (rest (if scheme (subseq head (1+ colon)) head)) (slash (when (starts-with "//" rest) (position #\/ rest :start 2))) (authority (when (starts-with "//" rest) (subseq rest 2 slash))) (path (if authority (if slash (subseq rest slash) "") rest))) (make-iri-parts :scheme scheme :authority authority :path path :query query :fragment fragment))) (defun join-iri (parts) (with-output-to-string (out) (when (iri-parts-scheme parts) (format out "~A:" (iri-parts-scheme parts))) (when (iri-parts-authority parts) (format out "//~A" (iri-parts-authority parts))) (write-string (iri-parts-path parts) out) (when (iri-parts-query parts) (format out "?~A" (iri-parts-query parts))) (when (iri-parts-fragment parts) (format out "#~A" (iri-parts-fragment parts))))) (defun remove-dot-segments (path) ;; RFC 3986 5.2.4, preserving empty segments and terminal slashes. (let ((input path) (output "")) (loop while (plusp (length input)) do (cond ((starts-with "../" input) (setf input (subseq input 3))) ((starts-with "./" input) (setf input (subseq input 2))) ((starts-with "/./" input) (setf input (subseq input 2))) ((string= input "/.") (setf input "/")) ((or (starts-with "/../" input) (string= input "/..")) (setf input (if (string= input "/..") "/" (subseq input 3)) output (subseq output 0 (or (position #\/ output :from-end t) 0)))) ((or (string= input ".") (string= input "..")) (setf input "")) (t (let ((end (position #\/ input :start (if (char= (char input 0) #\/) 1 0)))) (setf output (concatenate 'string output (subseq input 0 end)) input (if end (subseq input end) "")))))) output)) (defun validate-iri-characters (iri position) (loop for c across iri for index from 0 do (when (or (<= (char-code c) 32) (= (char-code c) 127) (find c "<>\"{}|^`\\") (<= #xd800 (char-code c) #xdfff)) (problem 'ctm-rejection :invalid-iri (+ position index) "Illegal IRI character."))) (let* ((parts (split-iri iri)) (path (iri-parts-path parts)) (first-segment (subseq path 0 (position #\/ path)))) (when (or (> (count #\# iri) 1) (and (null (iri-parts-scheme parts)) (find #\: first-segment))) (problem 'ctm-rejection :invalid-iri position "Invalid relative path or fragment syntax."))) iri) (defun require-document-iri (iri) (unless (stringp iri) (problem 'ctm-rejection :invalid-document-iri 0 "An explicit absolute Document IRI is required.")) (validate-iri-characters iri 0) (let ((parts (split-iri iri))) (unless (and (iri-parts-scheme parts) (null (iri-parts-fragment parts))) (problem 'ctm-rejection :invalid-document-iri 0 "Document IRI must be absolute and fragment-free (RFC 3987 absolute-IRI)."))) iri) (defun resolve-iri (reference document position) "CTM 3.3.3, RFC 3986 5.2. No fetching or case normalization." (let* ((reference (validate-iri-characters (unescape-iri reference position) position)) (r (split-iri reference)) (b (split-iri document)) (target (make-iri-parts :fragment (iri-parts-fragment r)))) (cond ((iri-parts-scheme r) (setf (iri-parts-scheme target) (iri-parts-scheme r) (iri-parts-authority target) (iri-parts-authority r) (iri-parts-path target) (remove-dot-segments (iri-parts-path r)) (iri-parts-query target) (iri-parts-query r))) (t (setf (iri-parts-scheme target) (iri-parts-scheme b)) (cond ((iri-parts-authority r) (setf (iri-parts-authority target) (iri-parts-authority r) (iri-parts-path target) (remove-dot-segments (iri-parts-path r)) (iri-parts-query target) (iri-parts-query r))) (t (setf (iri-parts-authority target) (iri-parts-authority b)) (if (zerop (length (iri-parts-path r))) (setf (iri-parts-path target) (iri-parts-path b) (iri-parts-query target) (or (iri-parts-query r) (iri-parts-query b))) (setf (iri-parts-path target) (remove-dot-segments (if (starts-with "/" (iri-parts-path r)) (iri-parts-path r) (concatenate 'string (if (and (iri-parts-authority b) (zerop (length (iri-parts-path b)))) "/" (subseq (iri-parts-path b) 0 (let ((slash (position #\/ (iri-parts-path b) :from-end t))) (if slash (1+ slash) 0)))) (iri-parts-path r)))) (iri-parts-query target) (iri-parts-query r))))))) (join-iri target)))