Voglio descrivere la struttura delle directory e dei file in alcuni dei miei post sul blog Jekyll, Markdown fornisce un modo pulito di presentare una cosa del genere?

Ad esempio, è possibile vedere a questo link sul sito Web Jekyll che la struttura di directory e file viene emessa sulla pagina in modo molto accurato:

.
├── _config.yml
├── _drafts
│   ├── begin-with-the-crazy-ideas.textile
│   └── on-simplicity-in-technology.markdown
├── _includes
│   ├── footer.html
│   └── header.html
├── _layouts
│   ├── default.html
│   └── post.html
├── _posts
│   ├── 2007-10-29-why-every-programmer-should-play-nethack.textile
│   └── 2009-04-26-barcamp-boston-4-roundup.textile
├── _data
│   └── members.yml
├── _site
└── index.html

Credo che i caratteri di blocco di riga sopra siano Unicode (come descritto in questa risposta qui ), ma non sono sicuro di come Markdown o browser diversi li gestiranno. Speravo che Markdown avesse incluso un modo per farlo, che forse è in uscita con i caratteri Unicode sopra.

Se sei preoccupato per i caratteri Unicode puoi usare ASCII per costruire le strutture, così diventa la tua struttura di esempio

.
+-- _config.yml
+-- _drafts
|   +-- begin-with-the-crazy-ideas.textile
|   +-- on-simplicity-in-technology.markdown
+-- _includes
|   +-- footer.html
|   +-- header.html
+-- _layouts
|   +-- default.html
|   +-- post.html
+-- _posts
|   +-- 2007-10-29-why-every-programmer-should-play-nethack.textile
|   +-- 2009-04-26-barcamp-boston-4-roundup.textile
+-- _data
|   +-- members.yml
+-- _site
+-- index.html

Che è simile al formato treeutilizzato se si seleziona l' ANSIoutput.

Ho seguito un esempio in un altro repository e ho racchiuso la struttura di directory in una coppia di triple backtick ( ```):

```
project
│   README.md
│   file001.txt    
│
└───folder1
│   │   file011.txt
│   │   file012.txt
│   │
│   └───subfolder1
│       │   file111.txt
│       │   file112.txt
│       │   ...
│   
└───folder2
    │   file021.txt
    │   file022.txt
```

Puoi usare tree per generare qualcosa di molto simile al tuo esempio. Una volta ottenuto l'output, è possibile inserirlo in un <pre>tag per preservare la formattazione del testo normale.

Se stai usando VS Code, questa è una fantastica estensione per generare alberi di file. https://marketplace.visualstudio.com/items?itemName=Shinotatwu-DS.file-tree-generator

Aggiunto direttamente al markdown ...

📦quakehunter
 ┣ 📂client
 ┣ 📂node_modules
 ┣ 📂server
 ┃ ┗ 📜index.js
 ┣ 📜.gitignore
 ┣ 📜package-lock.json
 ┗ 📜package.json

Ho creato un modulo nodo per automatizzare questo compito: mddir

uso

node mddir "../relative/path/"

Per installare: npm install mddir -g

Per generare markdown per la directory corrente: mddir

Per generare per qualsiasi percorso assoluto: mddir / absolute / path

Per generare per un percorso relativo: mddir ~ / Documents / qualunque.

Il file md viene generato nella directory di lavoro.

Attualmente ignora le cartelle node_modules e .git.

Risoluzione dei problemi

Se viene visualizzato l'errore "nodo \ r: nessun file o directory", il problema è che il sistema operativo utilizza terminazioni di linea diverse e mddir non può analizzarle senza che tu abbia impostato esplicitamente lo stile di fine linea su Unix. Questo di solito interessa Windows, ma anche alcune versioni di Linux. L'impostazione delle terminazioni di linea in stile Unix deve essere eseguita nella cartella bin globale di mddir npm.

Correzione delle terminazioni di linea

Ottieni il percorso della cartella bin npm con:

npm config get prefix

Cd in quella cartella

brew installa dos2unix

dos2unix lib / node_modules / mddir / src / mddir.js

Questo converte le terminazioni di linea in Unix anziché in Dos

Quindi eseguire normalmente: node mddir "../relative/path/".

Esempio di struttura del file di markdown generata 'directoryList.md'

    |-- .bowerrc
    |-- .jshintrc
    |-- .jshintrc2
    |-- Gruntfile.js
    |-- README.md
    |-- bower.json
    |-- karma.conf.js
    |-- package.json
    |-- app
        |-- app.js
        |-- db.js
        |-- directoryList.md
        |-- index.html
        |-- mddir.js
        |-- routing.js
        |-- server.js
        |-- _api
            |-- api.groups.js
            |-- api.posts.js
            |-- api.users.js
            |-- api.widgets.js
        |-- _components
            |-- directives
                |-- directives.module.js
                |-- vendor
                    |-- directive.draganddrop.js
            |-- helpers
                |-- helpers.module.js
                |-- proprietary
                    |-- factory.actionDispatcher.js
            |-- services
                |-- services.cardTemplates.js
                |-- services.cards.js
                |-- services.groups.js
                |-- services.posts.js
                |-- services.users.js
                |-- services.widgets.js
        |-- _mocks
            |-- mocks.groups.js
            |-- mocks.posts.js
            |-- mocks.users.js
            |-- mocks.widgets.js

Come già raccomandato, puoi usare tree. Ma per usarlo insieme al testo ristrutturato sono stati richiesti alcuni parametri aggiuntivi.

L' treeoutput standard non verrà stampato se si utilizza pandocper produrre pdf.

tree --dirsfirst --charset=ascii /path/to/directoryprodurrà un bel ASCIIalbero che può essere integrato nel tuo documento in questo modo:

.. code::
.
|-- ContentStore
|   |-- de-DE
|   |   |-- art.mshc
|   |   |-- artnoloc.mshc
|   |   |-- clientserver.mshc
|   |   |-- noarm.mshc
|   |   |-- resources.mshc
|   |   `-- windowsclient.mshc
|   `-- en-US
|       |-- art.mshc
|       |-- artnoloc.mshc
|       |-- clientserver.mshc
|       |-- noarm.mshc
|       |-- resources.mshc
|       `-- windowsclient.mshc
`-- IndexStore
    |-- de-DE
    |   |-- art.mshi
    |   |-- artnoloc.mshi
    |   |-- clientserver.mshi
    |   |-- noarm.mshi
    |   |-- resources.mshi
    |   `-- windowsclient.mshi
    `-- en-US
        |-- art.mshi
        |-- artnoloc.mshi
        |-- clientserver.mshi
        |-- noarm.mshi
        |-- resources.mshi
        `-- windowsclient.mshi

Ho scritto questo per il mio elenco di file Dropbox.

sed viene utilizzato per rimuovere i percorsi completi del percorso del file / cartella con collegamento simbolico che viene dopo ->

Sfortunatamente, le schede sono perse. utilizzandozsh sono in grado di preservare le schede.

! / usr / bin / env bash

#!/usr/bin/env zsh

F1='index-2.md' #With hyperlinks
F2='index.md'

if [ -e $F1 ];then
    rm $F1
fi

if [ -e $F2 ];then
    rm $F2
fi

DATA=`tree --dirsfirst -t -Rl --noreport | \
    sed 's/->.*$//g'`             # Remove symlink adress and ->

echo -e '```\n' ${DATA} '\n```' > $F1  # Markdown needs triple back ticks for <pre>

# With the power of piping, creating HTML tree than pipe it
# to html2markdown program, creates cool markdown file with hyperlinks.

DATA=`tree --dirsfirst -t -Rl --noreport -H http://guneysu.pancakeapps.com`
echo $DATA | \
    sed 's/\r\r/\n/g' | \
    html2markdown | \
    sed '/^\s*$/d' | \
    sed 's/\# Directory Tree//g' | \
        > $F2

Le uscite in questo modo:

```
 .
├── 2013 
│   └── index.markdown
├── 2014 
│   └── index.markdown
├── 2015 
│   └── index.markdown
├── _posts 
│   └── 2014-12-27-2014-yili-degerlendirmesi.markdown
├── _stash 
└── update.sh 
```

[BASE_URL/](BASE_URL/)
├── [2013](BASE_URL/2013/)
│   └── [index.markdown](BASE_URL/2013/index.markdown)
├── [2014](BASE_URL/2014/)
│   └── [index.markdown](BASE_URL/2014/index.markdown)
├── [2015](BASE_URL/2015/)
│   └── [index.markdown](BASE_URL/2015/index.markdown)
├── [_posts](BASE_URL/_posts/)
│   └── [2014-12-27-2014-yili-degerlendirmesi.markdown](_posts/2014-12-27-2014-yili-degerlendirmesi.markdown)
├── [_stash](BASE_URL/_stash/)
├── [index-2.md](BASE_URL/index-2.md)
└── [update.sh](BASE_URL/update.sh)
* * *
tree v1.6.0 © 1996 - 2011 by Steve Baker and Thomas Moore
HTML output hacked and copyleft © 1998 by Francesc Rocher
Charsets / OS/2 support © 2001 by Kyosuke Tokoro

Se stai usando l'editor Atom, puoi farlo con il pacchetto ascii-tree .

Puoi scrivere il seguente albero:

root
+-- dir1
    +--file1
+-- dir2
    +-- file2

e convertilo nel seguente selezionandolo e premendo ctrl-alt-t:

root
├── dir1
│   └── file1
└── dir2
    └── file2

In OSX, usando reveal.js, ho un problema di rendering se solo utente treee quindi copia / incolla l'output: compaiono strani simboli.

Ho trovato 2 possibili soluzioni.

1) Usa charset ascii e copia / incolla semplicemente l'output nel file markdown

tree -L 1 --charset=ascii

2) Utilizzare direttamente HTML e Unicode nel file markdown

<pre>
.
&#8866; README.md
&#8866; docs
&#8866; e2e
&#8866; karma.conf.js
&#8866; node_modules
&#8866; package.json
&#8866; protractor.conf.js
&#8866; src
&#8866; tsconfig.json
&#8985; tslint.json
</pre>

Spero che sia d'aiuto.

Suggerirei di usare wasabi, quindi puoi usare il markdown-ish in questo modo

root/ # entry comments can be inline after a '#'
      # or on their own line, also after a '#'

  readme.md # a child of, 'root/', it's indented
            # under its parent.

  usage.md  # indented syntax is nice for small projects
            # and short comments.

  src/          # directories MUST be identified with a '/'
    fileOne.txt # files don't need any notation
    fileTwo*    # '*' can identify executables
    fileThree@  # '@' can identify symlinks

e lancia quella sintassi esatta nella libreria js per questo

Se desideri generarlo dinamicamente ti consiglio di usare Frontend-md . E 'semplice da usare.

Esiste un modulo NPM per questo:

npm dree

Ti consente di avere una rappresentazione di un albero di directory come stringa o oggetto. Usandolo con la riga di comando ti permetterà di salvare la rappresentazione in un file txt.

Esempio:

$ npm dree parse myDirectory --dest ./generated --name tree