Come convertire i file Markdown in Dokuwiki, su un PC


13

Sto cercando uno strumento o uno script per convertire i file Markdown in formato Dokuwiki , che verrà eseguito su un PC.

Questo è così che posso usare MarkdownPad su un PC per creare bozze iniziali di documenti e poi convertirli in formato Dokuwiki, per caricarli su un'installazione Dokuwiki su cui non ho alcun controllo. (Ciò significa che il plug-in Markdown non mi è utile.)

Ho potuto passare il tempo scrivendo uno script Python per eseguire la conversione me stesso, ma mi piacerebbe evitare di spendere tempo su questo, se una cosa del genere esiste già.

I tag Markdown che vorrei avere supportati / convertiti sono:

  • Livelli di rotta 1 - 5
  • Carattere grassetto, corsivo, sottolineato, a larghezza fissa
  • Elenchi numerati e non numerati
  • Collegamenti ipertestuali
  • Regole orizzontali

Esiste un tale strumento o è disponibile un buon punto di partenza?


Cose che ho trovato e considerato


Aggiungi filtro a PandC per l'output DW ?! E, tra l'altro, per il piccolo sottoinsieme richiesto puoi provare a iniziare con Markdown puro in DW (hai letto le regole di sintassi DW ?!)
Lazy Badger

@LazyBadger Grazie. Ho appena letto johnmacfarlane.net/pandoc/scripting.html e, per quanto posso vedere, si tratta di cambiare l'AST Pandoc. Voglio mantenere invariato l'AST, ma cambiare il formato di output. O ho frainteso?
Clare Macrae,

@LazyBadger Re il tuo secondo suggerimento, sì, io (credo di) conoscere molto bene la sintassi DW! Tuttavia, anche se DW supporta Markdown, desidero convertire il testo nella sintassi DW convenzionale, per il bene dei miei colleghi che potrebbero modificarlo.
Clare Macrae,

Ho appena scoperto che c'è un brevissimo problema di Pandoc che richiede il supporto di DokuWiki.
Clare Macrae,

Quando parlo di integrazione pandoc, ho in mente "aggiungi scrittore aggiuntivo", che, AFAICS, non cambia core come mostra il lettore MoinMoin - è solo uno script Haskell aggiuntivo
Lazy Badger

Risposte:


12

Stop-Press - Agosto 2014

Da Pandoc 1.13 , Pandoc ora contiene la mia implementazione della scrittura DokuWiki - e molte altre funzionalità sono implementate lì rispetto a questo script. Quindi questo script ora è praticamente ridondante.


Avendo inizialmente detto che non volevo scrivere uno script Python per fare la conversione, ho finito per farlo.

Il vero risparmio di tempo è stato l'uso di Pandoc per analizzare il testo di Markdown e scrivere una rappresentazione JSON del documento. Questo file JSON era quindi per lo più abbastanza facile da analizzare e scrivere in formato DokuWiki.

Di seguito è riportato lo script, che implementa i frammenti di Markdown e DokuWiki che mi interessavano - e alcuni altri. (Non ho caricato la suite di test corrispondente che ho scritto)

Requisiti per usarlo:

  • Python (stavo usando 2.7 su Windows)
  • Pandoc installato e pandoc.exe nel PERCORSO (oppure modificare lo script per inserire invece il percorso completo di Pandoc)

Spero che questo salvi anche qualcun altro ...

Modifica 2 : 26/06/2013: ho inserito questo codice in GitHub, all'indirizzo https://github.com/claremacrae/markdown_to_dokuwiki.py . Si noti che il codice lì aggiunge il supporto per più formati e contiene anche una suite di test.

Modifica 1 : modificato per aggiungere il codice per l'analisi dei campioni di codice nello stile di backtick di 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 Prego. (A proposito, ho appena notato un errore di battitura cosmetico: s / jason / json / in diversi posti ... :-))
Clare Macrae,

2

Questo è un approccio alternativo che ho usato di recente.

I suoi vantaggi sono:

  • converte una gamma molto più ampia di sintassi di MarkDown rispetto allo script Python nell'altra mia risposta
  • non richiede l'installazione di Python
  • non richiede l'installazione di pandoc

La ricetta:

  1. Apri il file Markdown in MarkdownPad 2

    Schermata MarkdownPad 2

  2. Seleziona Modifica -> "Copia documento come HTML"

  3. Esegui Html2DokuWiki

    Screenshot da HTML a DokuWiki

  4. Incolla l'HTML nel riquadro "Input HTML" in alto

  5. Seleziona Tutto e Copia tutto il testo nel riquadro "Uscita DokuWiki" in basso

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.