Comment convertir des fichiers Markdown en Dokuwiki, sur un PC

Je recherche un outil ou un script pour convertir les fichiers Markdown au format Dokuwiki , qui s'exécutera sur un PC.

C'est pour que je puisse utiliser MarkdownPad sur un PC pour créer des ébauches initiales de documents, puis les convertir au format Dokuwiki, pour les télécharger vers une installation Dokuwiki sur laquelle je n'ai aucun contrôle. (Cela signifie que le plugin Markdown ne me sert à rien.)

Je pourrais passer du temps à écrire un script Python pour faire la conversion moi-même, mais j'aimerais éviter d'y passer du temps, si une telle chose existe déjà.

Les balises Markdown que j'aimerais avoir prises en charge / converties sont:

• Niveaux de titre 1 - 5
• Gras, italique, souligné, police à largeur fixe
• Listes numérotées et non numérotées
• Hyperliens
• Règles horizontales

Existe-t-il un tel outil ou existe-t-il un bon point de départ?

Choses que j'ai trouvées et considérées

• Au début, je pensais que txt2tags serait utile, mais bien qu'il puisse écrire à la fois markdown et Dokuwiki, il est très lié à son propre format d'entrée spécifique

• J'ai également vu Markdown2Dokuwiki , et bien que je serais certainement prêt à utiliser un script sed, même sur un PC, cela ne prend en charge qu'une toute petite partie de la syntaxe de Markdown.

• python-markdown2 semblait également prometteur, mais il n'écrit que du HTML.

• pandoc - mais il ne prend pas en charge la sortie Dokuwiki

• MultiMarkdown - ne semble pas prendre en charge la sortie Dokuwiki

Stop-Press - Août 2014

Depuis Pandoc 1.13 , Pandoc contient maintenant mon implémentation de l'écriture DokuWiki - et beaucoup plus de fonctionnalités y sont implémentées que dans ce script. Donc, ce script est maintenant à peu près redondant.

Après avoir dit à l'origine que je ne voulais pas écrire de script Python pour effectuer la conversion, j'ai fini par faire exactement cela.

La véritable économie de temps a été d'utiliser Pandoc pour analyser le texte Markdown et écrire une représentation JSON du document. Ce fichier JSON était alors assez facile à analyser et à écrire au format DokuWiki.

Ci-dessous se trouve le script, qui implémente les morceaux de Markdown et DokuWiki qui m'intéressaient - et quelques autres. (Je n'ai pas téléchargé la suite de tests correspondante que j'ai écrite)

Conditions requises pour l'utiliser:

• Python (j'utilisais 2.7 sous Windows)
• Pandoc installé et pandoc.exe dans votre CHEMIN (ou modifiez le script pour mettre le chemin complet vers Pandoc à la place)

J'espère que cela fera gagner du temps à quelqu'un d'autre ...

Edit 2 : 2013-06-26: J'ai maintenant mis ce code dans GitHub, à https://github.com/claremacrae/markdown_to_dokuwiki.py . Notez que le code ajoute la prise en charge de plus de formats et contient également une suite de tests.

Édition 1 : ajustée pour ajouter du code pour analyser des exemples de code dans le style de backtick de Markdown:

# -*- coding: latin-1 -*-

import sys
import os
import json

__doc__ = """This script will read a text file in Markdown format,
and convert it to DokuWiki format.

The basic approach is to run pandoc to convert the markdown to JSON,
and then to parse the JSON output, and convert it to dokuwiki, which
is written to standard output

Requirements:
 - pandoc is in the user's PATH
"""

# TODOs
# underlined, fixed-width
# Code quotes

list_depth = 0
list_depth_increment = 2

def process_list( list_marker, value ):
    global list_depth
    list_depth += list_depth_increment
    result = ""
    for item in value:
        result += '\n' + list_depth * unicode( ' ' ) + list_marker + process_container( item )
    list_depth -= list_depth_increment
    if list_depth == 0:
        result += '\n'
    return result

def process_container( container ):
    if isinstance( container, dict ):
        assert( len(container) == 1 )
        key = container.keys()[ 0 ]
        value = container.values()[ 0 ]
        if key == 'Para':
            return process_container( value ) + '\n\n'
        if key == 'Str':
            return value
        elif key == 'Header':
            level = value[0]
            marker = ( 7 - level ) * unicode( '=' )
            return marker + unicode(' ') + process_container( value[1] ) + unicode(' ') + marker + unicode('\n\n')
        elif key == 'Strong':
            return unicode('**') + process_container( value ) + unicode('**')
        elif key == 'Emph':
            return unicode('//') + process_container( value ) + unicode('//')
        elif key == 'Code':
            return unicode("''") + value[1] + unicode("''")
        elif key == "Link":
            url = value[1][0]
            return unicode('[[') + url + unicode('|') + process_container( value[0] ) + unicode(']]')
        elif key == "BulletList":
            return process_list( unicode( '* ' ), value)
        elif key == "OrderedList":
            return process_list( unicode( '- ' ), value[1])
        elif key == "Plain":
            return process_container( value )
        elif key == "BlockQuote":
            # There is no representation of blockquotes in DokuWiki - we'll just
            # have to spit out the unmodified text
            return '\n' + process_container( value ) + '\n'

        #elif key == 'Code':
        #    return unicode("''") + process_container( value ) + unicode("''")
        else:
            return unicode("unknown map key: ") + key + unicode( " value: " ) + str( value )

    if isinstance( container, list ):
        result = unicode("")
        for value in container:
            result += process_container( value )
        return result

    if isinstance( container, unicode ):
        if container == unicode( "Space" ):
            return unicode( " " )
        elif container == unicode( "HorizontalRule" ):
            return unicode( "----\n\n" )

    return unicode("unknown") + str( container )

def process_pandoc_jason( data ):
    assert( len(data) == 2 )
    result = unicode('')
    for values in data[1]:
        result += process_container( values )
    print result

def convert_file( filename ):
    # Use pandoc to parse the input file, and write it out as json
    tempfile = "temp_script_output.json"
    command = "pandoc --to=json \"%s\" --output=%s" % ( filename, tempfile )
    #print command
    os.system( command )

    input_file = open(tempfile, 'r' )
    input_text = input_file.readline()
    input_file.close()

    ## Parse the data
    data = json.loads( input_text )
    process_pandoc_jason( data )

def main( files ):
    for filename in files:
        convert_file( filename )

if __name__ == "__main__":
    files = sys.argv[1:]

    if len( files ) == 0:
        sys.stderr.write( "Supply one or more filenames to convert on the command line\n" )
        return_code = 1
    else:
        main( files )
        return_code = 0

    sys.exit( return_code )

Il s'agit d'une approche alternative que j'ai utilisée récemment.

Ses avantages sont:

• il convertit une gamme beaucoup plus large de syntaxe MarkDown que le script Python dans mon autre réponse
• il ne nécessite pas l'installation de python
• il ne nécessite pas l'installation de pandoc

La recette:

1. Ouvrez le fichier Markdown dans MarkdownPad 2

   

2. Sélectionnez Edition -> "Copier le document au format HTML"

3. Exécutez Html2DokuWiki

   

4. Collez le code HTML dans le volet supérieur "Entrée HTML"

5. Sélectionnez tout et copiez tout le texte dans le volet inférieur "Sortie DokuWiki"

Pas une solution idéale, mais fonctionnelle

Markdown -> HTML -> Dokuwiki

Première conversion effectuée par pandoc

Deuxième module HTML-WikiConverter-DokuWiki Perl

Astuce: Inverser les actions du code existant

silverstripe-doc-restructuration git-repo contient du code (PHP) pour la conversion de Dokuwiki en Markdown