Conversion du format Spip à AsciiDoc - [Site WWW de Laurent Bloch]

Produire des documents, une seule fois

Conversion du format Spip à AsciiDoc

Article mis en ligne le 20 décembre 2020

dernière modification le 30 décembre 2020

par Laurent Bloch

Un article précédent annonçait mon choix d’utiliser désormais pour rédiger mes textes le format AsciiDoc, à partir duquel on peut générer facilement des sorties aux formats PDF, DocBook, LaTeX, Html et même docx : quel luxe, pouvoir créer un document Word, ce que l’on nous demande à tout bout de champ, sans avoir à utiliser ce logiciel calamiteux ni ses succédanés qui ne valent guère mieux ! Étant bien entendu que pour la vraie typographie LaTeX demeure indispensable.

Pour mon site et mon blog j’utilise le CMS Spip, qui me donne toute satisfaction. Pour information, au gré de mes collaborations et emplois successifs, j’ai eu à utiliser Typo3, Dokuwiki, Joomla !, Dotclear, Drupal, Wordpress et Nuxeo : Spip me semble le compromis le plus raisonnable, entre les CMS au mode d’emploi inextricable, ceux dont les fonctions sont rudimentaires et mal conçues et ceux percés de trop de failles de sécurité. Comme parmi les logiciels de conversion disponibles il n’en existait pas d’AsciiDoc vers Spip, j’ai écrit AsciiDoc-Spip, disponible ici, à base d’expressions régulières.

Mais je possède déjà un stock important de textes composés avec les balises de Spip, ce qui m’a amené à écrire le logiciel inverse, Spip-AsciiDoc, cette fois avec un analyseur lexical basé sur une vraie grammaire. Ce n’est pas encore parfait, il y a quelques écritures parasites qui demandent un peu de finition manuelle, il manque encore ce qu’il faut pour les textes de programmes, je n’ai pas réussi à composer les textes attachés aux URL en italique ou en gras, je persévère, mais si l’un de mes lecteurs avait un conseil à me donner, il en serait remercié.

Comme pour AsciiDoc-Spip j’ai programmé en Scheme, avec le compilateur Bigloo et ses extensions d’analyse grammaticale (voir ici pour installer Bigloo sous Ubuntu, cela marche avec l’instance Ubuntu de Windows 10). . Voici le programme :

(module Spip-AsciiDoc
   (main analyse-fichier)
   (import Spad-Grammar))

(define (analyse-fichier args)
   (let ((un-fichier (cadr args)))
      (call-with-input-file un-fichier lire-des-lignes)))

(define (lire-des-lignes flux)
   (let boucle ((ligne (read-line flux)))
      (if (not (eof-object? ligne))
	  (let ((port (open-input-string ligne)))
	     (print (read/rp spad:the-grammar port))
	     (boucle (read-line flux))))))

Le fichier .afile qui permet de localiser les modules :

((Spad-Grammar "Spad-Grammar.scm")
 (Spip-AsciiDoc "Spip-AsciiDoc.scm"))

(module Spad-Grammar
   (export spad:the-grammar))

(define spad:the-grammar
   (let ((ital? #f)
	 (bold? #f)
	 (url? #f)
	 (txturl? #f)
	 (url "")
	 (txturl "")
	 (note? #f)
	 (note "")
	 (section? #f))
      (regular-grammar ((carcomp (in "éèàùûçêîâÉÈÀÊÎÂÏïëËÇüôäöœ_!-:\\?,'’()//%&")))
	 ((when (not section?)
	     (bol "{{{"))
	  (set! section? #t)
	  (display* "== ")
	  (ignore))
	 ((when section?
	     (: (+ (in alpha carcomp digit space punct)) "}}}"))
	  (set! section? #f)
	  (print (the-substring 0 (- (the-length) 3)))
	  (newline)
	  (ignore))
	 ((when (not note?)
	     (: (+ (in alpha carcomp digit space punct)) "[["))
	  (set! note? #t)
	  (display* (the-substring 0 (- (the-length) 2)) "<<")
	  (ignore))
	 ((when note?
	     (: (+ (in alpha carcomp digit space punct)) "]]"))
	  (set! note? #f)
	  (display* (the-substring 0 (- (the-length) 2)) ">>")
	  (ignore))
	 ((when (not txturl?)
	     (: (+ (in alpha carcomp digit space punct)) "["))
	  (set! txturl? #t)
	  (display* (the-substring 0 (- (the-length) 1)))
	  (ignore))
	 ((when txturl?
	     (: (* (in alpha carcomp digit space punct "{}*")) "->"))
;;	  (set! txturl (read/rp spad:the-grammar (open-input-string (the-substring 0 (- (the-length) 2)))))
	  (set! txturl (the-substring 0 (- (the-length) 2)))
	  (set! txturl? #f)
	  (set! url? #t)
	  (ignore))
	 ((when url?
	     (: (+ (in alpha carcomp digit space punct "{}*")) "]"))
	  (set! url (the-substring 0 (- (the-length) 1)))
	  (display* url "[" txturl "]")
	  (ignore))
	 ((when (not bold?)
	     (: (+ (in alpha carcomp digit space punct)) "{{"))
	  (set! bold? #t)
	  (display* (the-substring 0 (- (the-length) 2)) "*")
	  (ignore))
	 ((when bold?
	     (: (+ (in alpha carcomp digit space punct)) "}}"))
	  (set! bold? #f)
	  (display* (the-substring 0 (- (the-length) 2)) "*")
	  (ignore))
 	 ((when (not ital?) (: (+ (in alpha carcomp digit space punct)) "{"))
 	  (set! ital? #t)
 	  (display* (the-substring 0 (- (the-length) 1))  "_")
 	  (ignore))
 	 ((when ital? (: (+ (in alpha carcomp digit space punct)) "}"))
 	  (set! ital? #f)
	  (display* (the-substring 0 (- (the-length) 1)) "_" )
	  (ignore))
	 ((: (+ (in alpha carcomp digit space punct)))
	  (print (the-string))
	  (ignore))
	 ((: #\newline)
	  (ignore))
	 ((eol #\newline)
	  (ignore))
	 ((bol #\newline)
	  (ignore))
	 )))

Pour compiler ce programme il faut avoir créé le fichier .afile, puis :

bigloo -c Spip-AsciiDoc.scm
bigloo -c Spad-Grammar.scm
bigloo Spad-Grammar.o Spip-AsciiDoc.o -o Spip-AsciiDoc

Pour pouvoir essayer, voici un exemple de texte avec des balises Spip, à traduire en AsciiDoc (les paragraphes sur une seule ligne de préférence) :

{{{Un titre}}}

Bien que l'idée soit ancienne, c'est depuis une dizaine d'années que les progrès de l'électronique ont permis l'apparition et le développement rapide des [{Solid-State Devices}->https://wakapidia.org] (SSD), c'est-à-dire d'unités de stockage qui utilisent comme support non plus des disques magnétiques en mouvement rotatif, mais des {{circuits électroniques intégrés}}, comme des [clés USB->https://ma-page.org] mais plus grosses et avec un accès plus rapide. Les premiers modèles avaient une faible capacité et un coût élevé, mais aujourd'hui la convergence avec les disques durs traditionnels est telle que l'on peut prévoir la disparition de ces derniers dans quelques années. Actuellement, {à volume égal} un SSD est 10 à 30 fois plus cher qu'un disque dur et 10 fois plus rapide. Les disques durs ont encore quelques arguments[[Fallacieux ? Cf. [arguments->https://mathe.org].]] techniques en leur faveur, mais pas pour longtemps. Les SSD sont moins fragiles parce qu'ils n'ont pas de pièces [->http://toto.fr] mobiles, plus légers, ils consomment moins d'électricité.

Et alors [{{voilà}}->https://mon-igloo.fr] là-bas.

Dans la même rubrique

Votre inscription a été enregistrée avec succès !

Au menu

Dans la même rubrique