Como converter arquivos Markdown para Dokuwiki, em um PC

Estou procurando uma ferramenta ou script para converter arquivos Markdown para o formato Dokuwiki , que será executado em um PC.

Isso é para que eu possa usar o MarkdownPad em um PC para criar rascunhos iniciais de documentos e depois convertê-los para o formato Dokuwiki, para fazer upload para uma instalação do Dokuwiki sobre a qual não tenho controle. (Isso significa que o plug - in Markdown não serve para mim.)

Eu poderia gastar um tempo escrevendo um script Python para fazer a conversão, mas gostaria de evitar gastar tempo com isso, se já existe.

As tags Markdown que eu gostaria de ter suportado / convertidas são:

• Níveis de título 1 - 5
• Fonte em negrito, itálico, sublinhado e largura fixa
• Listas numeradas e não numeradas
• Hiperlinks
• Regras horizontais

Existe uma ferramenta desse tipo ou existe um bom ponto de partida disponível?

Coisas que encontrei e considerei

• Inicialmente, pensei que o txt2tags seria útil, mas, embora possa escrever o markdown e o Dokuwiki, está muito ligado ao seu próprio formato de entrada específico

• Eu também vi o Markdown2Dokuwiki e, embora eu certamente estivesse disposto a usar um script sed, mesmo em um PC, isso suporta apenas uma parte minúscula da sintaxe do Markdown.

• python-markdown2 também parecia promissor, mas apenas grava HTML.

• pandoc - mas não suporta saída do Dokuwiki

• MultiMarkdown - não parece suportar a saída do Dokuwiki

Stop-Press - agosto de 2014

Desde o Pandoc 1.13 , o Pandoc agora contém minha implementação da escrita do DokuWiki - e muitos outros recursos são implementados lá do que neste script. Portanto, esse script agora é praticamente redundante.

Tendo dito originalmente que não queria escrever um script Python para fazer a conversão, acabei fazendo exatamente isso.

A etapa de economia de tempo real foi usar o Pandoc para analisar o texto do Markdown e gravar uma representação JSON do documento. Esse arquivo JSON era bastante fácil de analisar e gravar no formato DokuWiki.

Abaixo está o script, que implementa os bits do Markdown e do DokuWiki com os quais eu me importava - e mais alguns. (Eu não carreguei o testuite correspondente que escrevi)

Requisitos para usá-lo:

• Python (eu estava usando 2.7 no Windows)
• Pandoc insatlled e pandoc.exe em seu PATH (ou edite o script para colocar o caminho completo para Pandoc)

Espero que isso poupe a alguém também ...

Edit 2 : 26/06/2013: Agora coloquei esse código no github, em https://github.com/claremacrae/markdown_to_dokuwiki.py . Observe que o código lá adiciona suporte para mais formatos e também contém testsuite.

Editar 1 : ajustado para adicionar código para analisar amostras de código no estilo backtick do 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 )

Essa é uma abordagem alternativa que venho usando recentemente.

Suas vantagens são:

• ele converte uma gama muito maior de sintaxe MarkDown do que o script Python na minha outra resposta
• não requer a instalação de python
• não requer a instalação do pandoc

A receita:

1. Abra o arquivo Markdown no MarkdownPad 2

   

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

3. Execute o Html2DokuWiki

   

4. Cole o HTML no painel superior "Entrada HTML"

5. Selecione Tudo e Copie todo o texto no painel inferior "Saída do DokuWiki"

Solução não ideal, mas funcional

Remarcação -> HTML -> Dokuwiki

Primeira conversão feita por pandoc

Segundo - módulo Perl HTML-WikiConverter-DokuWiki

Dica: Revertendo ações do código existente

silverstripe-doc-reestruturando o git-repo contém código (PHP) para converter do Dokuwiki para o Markdown