Cómo convertir archivos Markdown a Dokuwiki, en una PC

Estoy buscando una herramienta o script para convertir archivos Markdown al formato Dokuwiki , que se ejecutará en una PC.

Esto es para que pueda usar MarkdownPad en una PC para crear borradores iniciales de documentos, y luego convertirlos al formato Dokuwiki, para cargarlos en una instalación Dokuwiki sobre la que no tengo control. (Esto significa que el complemento Markdown no me sirve).

Me podía pasar tiempo escribiendo un script en Python para hacer la conversión, pero me gustaría evitar gastar tiempo en esto, si tal cosa existe ya.

Las etiquetas de Markdown que me gustaría admitir / convertir son:

• Encabezado niveles 1 - 5
• Negrita, cursiva, subrayado, fuente de ancho fijo
• Listas numeradas y no numeradas
• Hipervínculos
• Reglas horizontales

¿Existe tal herramienta o hay un buen punto de partida disponible?

Cosas que he encontrado y considerado

• Inicialmente pensé que txt2tags sería útil, pero aunque puede escribir tanto Markdown como Dokuwiki, está muy vinculado a su propio formato de entrada específico

• También he visto Markdown2Dokuwiki , y aunque ciertamente estaría dispuesto a usar un script sed, incluso en una PC, esto solo es compatible con una pequeña parte de la sintaxis de Markdown.

• python-markdown2 también sonaba prometedor, pero sólo escribe a cabo HTML.

• pandoc , pero no es compatible con la salida Dokuwiki

• MultiMarkdown : no parece admitir la salida de Dokuwiki

Stop-Press - agosto 2014

Desde Pandoc 1.13 , Pandoc ahora contiene mi implementación de escritura DokuWiki, y muchas más funciones se implementan allí que en este script. Así que este script ahora es bastante redundante.

Habiendo dicho originalmente que no quería escribir un script de Python para hacer la conversión, terminé haciendo exactamente eso.

El paso de ahorro de tiempo real fue utilizar Pandoc para analizar el texto de Markdown y escribir una representación JSON del documento. Este archivo JSON era bastante fácil de analizar y escribir en formato DokuWiki.

A continuación se muestra el script, que implementa los bits de Markdown y DokuWiki que me importaban, y algunos más. (No he subido el conjunto de pruebas correspondiente que escribí)

Requisitos para usarlo:

• Python (estaba usando 2.7 en Windows)
• Pandoc instalado y pandoc.exe en su RUTA (o edite el script para colocar en la ruta completa a Pandoc)

Espero que esto también ahorre algo de tiempo a alguien más ...

Edición 2 : 2013-06-26: ahora he puesto este código en GitHub, en https://github.com/claremacrae/markdown_to_dokuwiki.py . Tenga en cuenta que el código allí agrega soporte para más formatos y también contiene un conjunto de pruebas.

Edición 1 : ajustado para agregar código para analizar muestras de código en el estilo de retroceso 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 )

Este es un enfoque alternativo que he estado usando recientemente.

Sus ventajas son:

• convierte un rango mucho más amplio de sintaxis MarkDown que el script Python en mi otra respuesta
• no requiere la instalación de python
• no requiere la instalación de pandoc

La receta:

1. Abra el archivo Markdown en MarkdownPad 2

   

2. Seleccione Editar -> "Copiar documento como HTML"

3. Ejecuta Html2DokuWiki

   

4. Pegue el HTML en el panel superior "Entrada de HTML"

5. Seleccione Todo y copie todo el texto en el panel inferior "Salida de DokuWiki"

No es la solución ideal, sino funcional.

Markdown -> HTML -> Dokuwiki

Primera conversión realizada por pandoc

Segundo: módulo HTML-WikiConverter-DokuWiki Perl

Sugerencia: invertir acciones del código existente

silverstripe-doc-restructuring git-repo contiene código (PHP) para convertir de Dokuwiki a Markdown