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


13

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


¿Añadir filtro a pandoc para salida DW? Y, por cierto, para el pequeño subconjunto solicitado, puede intentar comenzar con Markdown puro en DW (¿leyó las reglas de sintaxis de DW?)
Lazy Badger

@LazyBadger Gracias. Acabo de leer johnmacfarlane.net/pandoc/scripting.html , y por lo que puedo ver, se trata de cambiar el AST de Pandoc. Quiero mantener el AST sin cambios, pero cambiar el formato de salida. ¿O he entendido mal?
Clare Macrae

@LazyBadger Re su segunda sugerencia, sí, (creo) conozco muy bien la sintaxis de DW. Sin embargo, incluso si DW admite Markdown, deseo convertir el texto a la sintaxis DW convencional, por el bien de mis colegas que pueden editarlo.
Clare Macrae

Acabo de descubrir que hay un breve problema de Pandoc que solicita soporte para DokuWiki.
Clare Macrae

Cuando hablo de la integración de Pandoc, tengo en mente "agregar escritor adicional", que, AFAICS, no cambia el núcleo como lo muestra el lector MoinMoin : es solo un script Haskell adicional
Lazy Badger

Respuestas:


12

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 )

@OliverSalzburg De nada. (Por cierto, acabo de notar un error tipográfico cosmético: s / jason / json / en varios lugares ... :-))
Clare Macrae

2

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

    Captura de pantalla de MarkdownPad 2

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

  3. Ejecuta Html2DokuWiki

    Captura de pantalla de HTML a DokuWiki

  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"

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.