grunt-directory-to-html

Generate an html page from a directory structure. This can be useful for automatically creating a homepage for a project. For example, given this directory structure:

└── modules
    ├── another_test_link
    │   └── index.html
    └── test_link
        └── nested_test_link
            └── index.html

The plugin will generate this html:

<ul>
  <li>
    <h2><a href="modules/another_test_link/index.html">Another test link</a>
    </h2>
  </li>
  <li>
    <h2>Test link
    </h2>
    <ul>
      <li>
        <h3><a href="modules/test_link/nested_test_link/index.html">Nested test link</a>
        </h3>
      </li>
    </ul>
  </li>
</ul>

The plugin can also generate links based on the file name rather than folder name. For example, given this directory structure:

└── modules
    ├── another_test_link
    │   └── test-1.html
    └── test_link
        └── nested_test_link
            └── test-2.html

The plugin will generate this html:

<ul>
  <li>
    <h2>Another test link
    </h2>
    <ul>
      <li>
        <h3><a href="modules/another_test_link/test-1.html">Test 1</a>
        </h3>
      </li>
    </ul>
  </li>
  <li>
    <h2>Test link
    </h2>
    <ul>
      <li>
        <h3>Nested test link
        </h3>
        <ul>
          <li>
            <h4><a href="modules/test_link/nested_test_link/test-2.html">Test 2</a>
            </h4>
          </li>
        </ul>
      </li>
    </ul>
  </li>
</ul>

How it works

Based on the file paths you specify in your grunt.initConfig (see below) the plugin will create html markup that reflects this directory structure using unordered lists and will create links to any matching files it finds. The plugin will use the names of directories to generate the titles in the html. For example, a directory name of test_folder_link will become 'Test folder link' in the html (you can use dashes in the folder name instead of underscores).

Specifying your own data to use

If you want to specify your own title then you can create a data.json file in the directory in which you want to override the default behaviour. For example, given this directory structure:

└── modules
    ├── another_test_link
    │   ├── data.json
    │   └── index.html
    └── test_link
        └── nested_test_link
            └── index.html

And the data.json file contains this data:

{
    "title": "Your own title",
    "description": "A description"
}

The plugin will generate this html:

<ul>
  <li>
    <h2><a href="modules/another_test_link/index.html">Your own title</a>
    </h2>
    <p>A description</p>
  </li>
  <li>
    <h2>Test link
    </h2>
    <ul>
      <li>
        <h3><a href="modules/test_link/nested_test_link/index.html">Nested test link</a>
        </h3>
      </li>
    </ul>
  </li>
</ul>

The default template will look for the title and description properties. You can specify your own data that will be rendered into the html but you will need to supply your own template (see the section below on templates).

Getting Started

This plugin requires Grunt ~0.4.1

If you haven't used Grunt before, be sure to check out the Getting Started guide, as it explains how to create a Gruntfile as well as install and use Grunt plugins. Once you're familiar with that process, you may install this plugin with this command:

npm install grunt-directory-to-html --save-dev

Once the plugin has been installed, it may be enabled inside your Gruntfile with this line of JavaScript:

grunt.loadNpmTasks('grunt-directory-to-html');

The "to_html" task

Overview

In your project's Gruntfile, add a section named to_html to the data object passed into grunt.initConfig().

grunt.initConfig({
  to_html: {
    options: {
      // Task-specific options go here.
    },
    your_target: {
      // Target-specific file lists and/or options go here e.g.
      'dest/index.html': 'modules/**/index.html'
    }
  }
})

or

grunt.initConfig({
  to_html: {
    'dest/index.html': 'modules/**/index.html'
  }
})

Options

options.useFileNameAsTitle

Type: Boolean Default value: false

If set to true this will generate links based on filenames rather than folder names. See the top of this README for an example.

options.rootDirectory

Type: String Default value: modules

The root directory which contains the folders you want to link to in the html. You must ensure this is specified correctly otherwise the html that is generated will be incorrect.

options.generatePage

Type: Boolean Default value: false

If set to true this will create a full html page (including doctype and <head>). By default the plugin will only generate an html structure that corresponds to the directory structure.

options.title

Type: String Default value: Project homepage

If the generatePage option is true then the value that is supplied to the title option will be used as the text for the <title> and <h1> of the page.

options.stylesheet

Type: String Default value: false

If the generatePage option is true then the page that is output will link to a stylesheet with the href value set to whatever value is supplied to the stylesheet option.

options.template

Type: String (jade or handlebars template) Default value: false

Provide your own template to generate the html markup. Please see the templates section below for more information about how to write your own template.

options.templatingLanguage

Type: String Default value: jade

If this option is set to handlebars and a template is provided to the template option then the plugin will use handlebars to compile the template.

Templates

By default the plugin will use jade to compile the template, however, you can use handlebars instead.

Understanding templates

When the to_html task is run it will construct an object that reflects the directory structure. For example, given this folder structure:

└── modules
    ├── another_test_link
    │   └── index.html
    └── test_link
        └── nested_test_link
            └── index.html

The following object will be created:

{
  modules: [
    {
      id: 'another_test_link',
      title: 'Another test link',
      path: 'modules/another_test_link/index.html',
      level: 0
    },
    {
      id: 'test_link',
      title: 'Test link',
      level: 0,
      children: [
        {
         id: 'nested_test_link',
         title: 'Nested test link',
         path: 'modules/test_link/nested_test_link/index.html',
         level: 1
        }
      ]
    }
  ]
}

This object is then passed to the template for html rendering.

If you create a data.json file in a directory all of the data in that file will be added to the object and sent to the template. For example, given this directory structure:

└── modules
    ├── another_test_link
        ├── data.json
        └── index.html

And the data.json contains this data:

{
  "title": "Your own title",
  "description": "Lorem ipsum dolor."
  "randomData": [
    {
      "test": "test 1"
    },
    {
      "test": "test 2"
    }
  ]
}

Then the following object will be created:

{
  modules: [
    {
      id: 'another_test_link',
      title: 'Your own title',
      description: 'Lorem ipsum dolor.',
      randomData: [
        {
          test: 'test 1'
        },
        {
          test: 'test 2'
        }
      ]
      path: 'modules/another_test_link/index.html',
      level: 0
    }
  ]
}

In this way if you create your own template and data.json files you can generate html that suits your needs.

Writing a jade template

By default the plugin uses jade to generate the html. Here is the default template that the plugin uses:

mixin title(module)
    if module.path
        a(href=module.path)= module.title
    else
        = module.title

mixin generateTemplate(modules)
    ul
        each module in modules
            li
                case module.level
                    when 0
                        h2
                            +title(module)
                    when 1
                        h3
                            +title(module)
                    when 2
                        h4
                            +title(module)
                    when 3
                        h5
                            +title(module)
                    default
                        h6
                            +title(module)

                if module.description
                    p= module.description

                if module.children
                    mixin generateTemplate(module.children)

+generateTemplate(modules)

From this you should be able to determine how to write your own jade template. Note that the template uses the generateTemplate mixin so that it can recurse through the object structure.

Writing a handlebars template

You can use a handlebars template instead of jade as long as you specify handlebars as the value to the templatingLanguage option. Here is an example handlebars template:

<ul>
    {{#each modules}}
    <li>
        {{#if path}}
        <h2>
            <a href="{{path}}">{{title}}</a>
        </h2>
        {{else}}

        <h2>{{title}}</h2>

        {{/if}}

        {{#if description}}
        <p>{{description}}</p>
        {{/if}}

        {{#if children}}
            {{&recurse children}}
        {{/if}}
    </li>
    {{/each}}
</ul>

From this you should be able to determine how to write your own handlebars template. Note that the plugin registers a helper recurse so that you can recurse through the object structure.

Running the tests

After you have cloned the repo execute grunt test.