desenv-web-rp.com

Existe um utilitário de linha de comando para renderizar o Markdown com GitHub?

Eu estou querendo saber se existe um utilitário de linha de comando para tirar um arquivo GitHub flavored Markdown e renderizá-lo para HTML.

Estou usando um wiki do GitHub para criar conteúdo do site. Eu clonei o repositório no meu servidor e, em seguida, gostaria de processá-lo em HTML regular. É importante para mim que o que aparece no GitHub seja exatamente como ele deve procurar meu site. Eu também gostaria de usar os blocos cercados com ~~~, então prefiro não usar apenas a sintaxe Markdown padrão.

Eu olhei um pouco para a pré-visualização ao vivo do JavaScript pensando que poderia conectá-la ao Node.js, mas eles dizem que ela está obsoleta. Eu olhei para o repositório redcarpet, mas não parece que tem uma interface de linha de comando.

Eu rolei minha própria solução, entretanto, desde que nenhuma solução aqui é claramente melhor que os outros, eu deixarei a pergunta sem uma resposta selecionada.

387
McLeopold

Eu escrevi um pequeno CLI em Python e adicionei suporte a GFM. É chamado Grip (Github Readme Instant Preview) .

Instale-o com:

$ pip install grip

E para usá-lo, simplesmente:

$ grip

Em seguida, visite localhost:5000 para visualizar o arquivo readme.md nesse local.

Você também pode especificar seu próprio arquivo:

$ grip CHANGES.md

E mude a porta:

$ grip 8080

E, claro, especificamente renderizar Markdown GitHub-Flavored, opcionalmente com contexto de repositório:

$ grip --gfm --context=username/repo issue.md

Recursos notáveis:

  • Renderiza páginas para aparecer exatamente como no GitHub
  • Blocos vedados
  • API do Python
  • Navegue entre arquivos vinculados (obrigado, vladwing !) adicionado em 2.0
  • Exportar para um único arquivo (obrigado, iliggio !) adicionado em 2.0
  • Novo: Lê de stdin e exporta para stdout adicionado em 3.0

Espero que isso ajude alguém aqui. confira .

424
Joe

Eu não encontrei um método rápido e fácil para o Markdown com sabor do GitHub, mas eu encontrei uma versão um pouco mais genérica - Pandoc . Converte de/para vários formatos, incluindo Markdown, Rest, HTML e outros.

Eu também desenvolvi um Makefile para converter todos os arquivos .md para .html (em grande parte para o exemplo em Writing, Markdown e Pandoc):

# 'Makefile'
MARKDOWN = pandoc --from gfm --to html --standalone
all: $(patsubst %.md,%.html,$(wildcard *.md)) Makefile

clean:
    rm -f $(patsubst %.md,%.html,$(wildcard *.md))
    rm -f *.bak *~

%.html: %.md
    $(MARKDOWN) $< --output [email protected]
110
Alister Bulman

Talvez isso possa ajudar:

gem install github-markdown

Nenhuma documentação existe, mas eu peguei da documentação do gollum . Olhando para rubydoc.info , parece que você pode usar:

require 'github/markdown'  
puts GitHub::Markdown.render_gfm('your markdown string')

no seu código Ruby. Você pode envolver isso facilmente em um script para transformá-lo em um utilitário de linha de comando:

#!/usr/bin/env Ruby

# render.rb
require 'github/markdown'

puts GitHub::Markdown.render_gfm File.read(ARGV[0])

Execute com ./render.rb path/to/my/markdown/file.md. Observe que isso não é seguro para uso na produção sem sanitização.

29
James Lim
pip3 install --user markdown
python3 -m markdown readme.md > readme.html

Não suporta extensões do GitHub, mas é melhor que nada. Eu acredito que você pode estender o módulo para lidar com as adições do GitHub.

28
Gringo Suave

Provavelmente não é o que você quer, mas desde que você mencionou o Node.js: Não consegui encontrar uma boa ferramenta para visualizar a documentação do GitHub Flavored Markdown na minha unidade local antes de enviá-los para o GitHub, então hoje criei um baseado no Node.js: - https://github.com/ypocat/gfms

Então, talvez você possa reutilizar o showdown.js dele para o seu Wiki, se a sua pergunta ainda for real. Se não, talvez outras pessoas que enfrentem o mesmo problema que eu encontrem (assim como eu) essa pergunta e essa resposta a ela.

23
youurayy

O GitHub tem ma API Markdown você pode usar.

16
kehers

Para ler um arquivo README.md no terminal eu uso:

pandoc README.md | lynx -stdin

O Pandoc faz a saída em formato HTML, que o Lynx renderiza no seu terminal.

Ele funciona muito bem: ele preenche meu terminal, os atalhos são mostrados abaixo, eu posso rolar, e os links funcionam! Há apenas um tamanho de fonte, mas as cores + recuo + alinhamento compensam isso .

instalação:

Sudo apt-get install pandoc lynx
15
Barry Staes

Use marcado . Ele suporta o GitHub Flavored Markdown, pode ser usado como um módulo Node.js e a partir da linha de comando.

Um exemplo seria:

$ marked -o hello.html
hello world
^D
$ cat hello.html
<p>hello world</p>
13
zemirco

Isso é basicamente uma continuação da resposta de @barry-staes para usar Pandoc . Homebrew também, se você estiver em um Mac:

brew install pandoc

O Pandoc suporta o GFM como um formato de entrada através do nome markdown_github.

Saída para o arquivo

cat foo.md | pandoc -f markdown_github > foo.html

Abrir em lince

cat foo.md | pandoc -f markdown_github | lynx -stdin # To open in Lynx

Abrir no navegador padrão no OS X

cat foo.md | pandoc -f markdown_github > foo.html && open foo.html # To open in the default browser on OS X`

Integração TextMate

Você pode sempre canalizar a seleção atual ou o documento atual para um dos itens acima, como a maioria dos editores permite que você faça. Você também pode configurar facilmente o ambiente para que pandoc substitua o processador Markdown padrão usado pelo pacote Markdown .

Primeiro, crie um script Shell com o seguinte conteúdo (eu chamarei de ghmarkdown):

#!/bin/bash
# Note included, optional --email-obfuscation arg
pandoc -f markdown_github --email-obfuscation=references

Você pode então definir a variável TM_MARKDOWN (em Preferences → Variables) como /path/to/ghmarkdown, e ela substituirá o processador Markdown padrão.

10
Justin Middleton

Eu criei uma ferramenta semelhante à funcionalidade de visualização do Atom, mas como um aplicativo independente. Não tenho certeza se é isso que você está procurando, mas pode ser útil. - https://github.com/yoshuawuyts/vmd

vmd

9
Yoshua Wuyts

pandoc com browser funciona bem para mim.

Uso: cat README.md | pandoc -f markdown_github | browser

Instalação (Supondo que você esteja usando o Mac OSX):

  • $ brew install pandoc

  • $ brew install browser

Ou no Debian/Ubuntu: apt-get install pandoc browser

7
binarymason

Veja também https://softwareengineering.stackexchange.com/a/128721/24257 .


Se você está interessado em como nós [Github] renderizar arquivos Markdown, você pode querer verificar Redcarpet , nossa interface Ruby para a biblioteca Sundown.

Ruby-script, que usa Redcarpet , será "utilitário de linha de comando", se você tiver Ruby local

5
Lazy Badger

Construindo em este comentário Eu escrevi um one-liner para acertar o Github Markdown API usando curl e jq.

Cole esta função bash na linha de comando ou no seu ~/.bash_profile:

mdsee(){ 
    HTMLFILE="$(mktemp -u).html"
    cat "$1" | \
      jq --Slurp --raw-input '{"text": "\(.)", "mode": "markdown"}' | \
      curl -s --data @- https://api.github.com/markdown > "$HTMLFILE"
    echo $HTMLFILE
    open "$HTMLFILE"
}

E então, para ver o HTML renderizado no navegador, execute:

mdsee readme.md

Substitua open "$HTMLFILE" por lynx "$HTMLFILE" se você precisar de uma solução de terminal pura.

3
notpeter

Existe uma ferramenta realmente agradável e simples para navegar pelos documentos de marcação do GFM:

GFMS - Github Flavored Markdown Server

É um servidor HTTP simples e leve (sem configuração necessária) que você pode iniciar em qualquer diretório que contenha arquivos de marcação para procurá-los.

Características:

  • Suporte total ao Markdown do GFM
  • Destaque da sintaxe do código-fonte
  • Navegando em arquivos e diretórios
  • Boa aparência de saída (e folhas de estilo CSS configuráveis)
  • Exportar para PDF
3
Pawel Wiejacha

O GitHub desenvolveu (desde) um editor de texto modular Nice chamado Atom (baseado no Chromium e usa Node.js modules para pacotes).

Um pacote pré-instalado padrão Markdown Preview permite exibir sua visualização em uma guia separada usando Ctrl + Shift + M.

Eu não testei sua sintaxe completa, mas desde que veio do GitHub, eu ficaria muito surpreso se a sintaxe da visualização fosse diferente da deles (blocos cercados usando o trabalho ~~~).

Agora, embora não seja tecnicamente baseado em linha de comando, ele usa Node.js e gera um renderizador baseado em DOM -, o que pode ajudar alguém a tentar renderizar HTML baseado em sintaxe do GitHub em um Node. servidor web baseado em js, ou apenas edite seu README.md offline.

3
Que

Minha solução final foi usar Python Markdown . Eu rolei minha própriaextensão que fixou os blocos da cerca.

3
McLeopold

Eu consegui usar um script Ruby de uma linha para esse propósito (apesar de ter que ir em um arquivo separado). Primeiro, execute esses comandos uma vez em cada máquina cliente para a qual você enviará documentos:

gem install github-markup
gem install commonmarker

Em seguida, instale esse script na imagem do seu cliente e chame-o de render-readme-for-javadoc.rb:

require 'github/markup'

puts GitHub::Markup.render_s(GitHub::Markups::MARKUP_MARKDOWN, File.read('README.md'))

Finalmente, invoque-o assim:

Ruby ./render-readme-for-javadoc.rb >> project/src/main/javadoc/overview.html

ETA: Isso não irá ajudá-lo com o Markdown do StackOverflow, que parece estar falhando nesta resposta.

2
user833771

Adição atrasada, mas showdownjs tem uma ferramenta CLI que você pode usar para analisar MD em HTML.

2
Tivie

Melhorando a solução de @ barry-stae. Cole este trecho em ~/.bashrc

function mdviewer(){
  pandoc $* | lynx -stdin
}

Então podemos ver rapidamente o arquivo a partir da linha de comando. Também funciona bem em sessões SSH/Telnet.

mdviewer README.md
2
Sandeep

Eu encontrei um site que fará isso para você: http://tmpvar.com/markdown.html . Cole o seu Markdown e ele será exibido para você. Parece funcionar muito bem!

No entanto, ele não parece lidar com a opção de realce de sintaxe para código; ou seja, o recurso ~~~Ruby não funciona. Apenas imprime "Ruby".

1
JESii

Eu uso o Pandoc com a opção --from=gfm para o GitHub Flavored Markdown assim:

$ pandoc my_file.md   --from=gfm -t html -o my_file.html
1
Asme Just

Com base em resposta de Jim Lim , instalei a gema do GitHub Markdown. Isso incluiu um script chamado gfm que pega um nome de arquivo na linha de comando e grava o HTML equivalente na saída padrão. Eu modifiquei um pouco para salvar o arquivo no disco e depois abrir o navegador padrão com o launchy:

#!/usr/bin/env Ruby

HELP = <<-help
  Usage: gfm [--readme | --plaintext] [<file>]
  Convert a GitHub-Flavored Markdown file to HTML and write to standard output.
  With no <file> or when <file> is '-', read Markdown source text from standard input.
  With `--readme`, the files are parsed like README.md files in GitHub.com. By default,
  the files are parsed with all the GFM extensions.
help

if ARGV.include?('--help')
  puts HELP
  exit 0
end

root = File.expand_path('../../', __FILE__)
$:.unshift File.expand_path('lib', root)

require 'github/markdown'
require 'tempfile'
require 'launchy'

mode = :gfm
mode = :markdown if ARGV.delete('--readme')
mode = :plaintext if ARGV.delete('--plaintext')

outputFilePath = File.join(Dir.tmpdir, File.basename(ARGF.path))  + ".html"

File.open(outputFilePath, "w") do |outputFile |
    outputFile.write(GitHub::Markdown.to_html(ARGF.read, mode))
end

outputFileUri = 'file:///' + outputFilePath

Launchy.open(outputFileUri)
0
gerrard00

Uma abordagem "rápida e suja" é fazer o download das páginas HTML do wiki usando o utilitário wget, em vez de cloná-lo. Por exemplo, foi assim que baixei o wiki Hystrix do GitHub (estou usando o bunt Linux):

 $ wget -e robots=off -nH -E -H -k -K -p https://github.com/Netflix/Hystrix/wiki
 $ wget -e robots=off -nH -E -H -k -K -I "Netflix/Hystrix/wiki" -r -l 1 https://github.com/Netflix/Hystrix/wiki

A primeira chamada fará o download da página de entrada do wiki e de todas as suas dependências. O segundo chama todas as subpáginas dele. Você pode navegar agora pelo wiki abrindo Netflix/Hystrix/wiki.1.html.

Note que ambas as chamadas para wget são necessárias. Se você acabou de executar o segundo, então você vai perder algumas dependências necessárias para mostrar as páginas corretamente.

0
Luis Rodero-Merino