So konvertieren Sie Markdown-Dateien auf einem PC nach Dokuwiki

Ich bin auf der Suche nach einem Tool oder Skript zum Konvertieren von Markdown- Dateien in das Dokuwiki- Format, das auf einem PC ausgeführt werden kann.

Auf diese Weise kann ich MarkdownPad auf einem PC verwenden, um erste Entwürfe von Dokumenten zu erstellen und diese dann in das Dokuwiki-Format zu konvertieren, um sie in eine Dokuwiki-Installation hochzuladen, auf die ich keinen Einfluss habe. (Dies bedeutet, dass das Markdown-Plugin für mich keinen Nutzen hat.)

Ich könnte Zeit damit verbringen, ein Python-Skript zu schreiben, um die Konvertierung selbst durchzuführen, aber ich möchte vermeiden, Zeit damit zu verbringen, wenn so etwas bereits existiert.

Die Markdown-Tags, die ich gerne unterstützt / konvertiert hätte, sind:

• Überschriftenstufen 1 - 5
• Fett, kursiv, unterstrichen, Schrift mit fester Breite
• Nummerierte und nicht nummerierte Listen
• Hyperlinks
• Horizontale Regeln

Gibt es ein solches Tool oder gibt es einen guten Ausgangspunkt?

Dinge, die ich gefunden und in Betracht gezogen habe

• Anfangs dachte ich, dass txt2tags hilfreich wäre, aber obwohl es sowohl Markdown als auch Dokuwiki schreiben kann, ist es sehr an sein eigenes spezifisches Eingabeformat gebunden

• Ich habe auch Markdown2Dokuwiki gesehen , und obwohl ich auf jeden Fall bereit wäre, ein sed-Skript zu verwenden, unterstützt dies nur einen winzigen Teil der Markdown-Syntax.

• python-markdown2 klang ebenfalls vielversprechend, schreibt aber nur HTML.

• Pandoc - aber es unterstützt keine Dokuwiki-Ausgabe

• MultiMarkdown - unterstützt anscheinend keine Dokuwiki-Ausgabe

Stop-Press - August 2014

Seit Pandoc 1.13 enthält Pandoc nun meine Implementierung des DokuWiki-Schreibens - und dort sind viel mehr Funktionen implementiert als in diesem Skript. Also ist dieses Skript jetzt so ziemlich überflüssig.

Nachdem ich ursprünglich gesagt hatte, ich wolle kein Python-Skript schreiben, um die Konvertierung durchzuführen, habe ich genau das getan.

Der zeitsparende Schritt bestand darin, den Markdown-Text mit Pandoc zu analysieren und eine JSON-Darstellung des Dokuments zu erstellen. Diese JSON-Datei war dann meist recht einfach zu parsen und im DokuWiki-Format auszudrucken.

Unten ist das Skript, das die Teile von Markdown und DokuWiki implementiert, die mir wichtig waren - und ein paar mehr. (Ich habe die entsprechende Testuite, die ich geschrieben habe, nicht hochgeladen.)

Voraussetzungen für die Nutzung:

• Python (ich habe 2.7 unter Windows verwendet)
• Pandoc installiert und pandoc.exe in Ihrem PATH (oder bearbeiten Sie das Skript, um stattdessen den vollständigen Pfad zu Pandoc einzugeben)

Ich hoffe, das spart jemand anderem auch etwas Zeit ...

Edit 2 : 2013-06-26: Ich habe diesen Code jetzt in github unter https://github.com/claremacrae/markdown_to_dokuwiki.py eingefügt . Beachten Sie, dass der Code dort Unterstützung für weitere Formate hinzufügt und auch Testsuite enthält.

Edit 1 : Angepasst, um Code für das Parsen von Codebeispielen im Backtick-Stil von Markdown hinzuzufügen:

# -*- 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 )

Dies ist ein alternativer Ansatz, den ich in letzter Zeit verwendet habe.

Ihre Vorteile sind:

• Es konvertiert einen viel größeren Bereich der MarkDown-Syntax als das Python-Skript in meiner anderen Antwort
• Es muss kein Python installiert sein
• Es muss kein Pandoc installiert werden

Das Rezept:

1. Öffnen Sie die Markdown-Datei in MarkdownPad 2

   

2. Wählen Sie Bearbeiten -> "Dokument als HTML kopieren"

3. Führen Sie Html2DokuWiki aus

   

4. Fügen Sie den HTML-Code in den oberen Bereich "HTML-Eingabe" ein

5. Wählen Sie Alle aus und kopieren Sie den gesamten Text im unteren Bereich "DokuWiki-Ausgabe"

Nicht ideal, aber funktionale Lösung

Abschrift -> HTML -> Dokuwiki

Erste Konvertierung durch Pandoc

Zweitens - HTML-WikiConverter-DokuWiki Perl-Modul

Hinweis: Aktionen des vorhandenen Codes umkehren

Silverstripe-Doc-Restructuring Git-Repo enthält Code (PHP) für die Konvertierung von Dokuwiki nach Markdown