Bump version to 2.0.0-alpha.1

Add italian translation

.gitignore

@@ -23,3 +23,9 @@ build/Release
 # Deployed apps should consider commenting this line out:
 # see https://npmjs.org/doc/faq.html#Should-I-check-my-node_modules-folder-into-git
 node_modules
+
+theme/javascript/vendors
+theme/vendors
+
+# vim swapfile
+*.swp

.travis.yml

@@ -1,5 +1,7 @@
+sudo: false
 language: node_js
 node_js:
   - "0.11"
   - "0.10"
-  - "0.8"
+before_install:
+  - npm install svgexport -g

AUTHORS.md

@@ -15,3 +15,4 @@ Contributors
 ------------
 
 - Nijiko Yonskai
+- Herman Starikov

CHANGES.md

@@ -0,0 +1,92 @@
+# Release notes
+
+## 1.5.0
+- Fix `serve` command, broken by `1.4.2`
+- Add nicer `dark` theme :)
+
+## 1.4.2
+- Force `process.exit` after builds, to prevent (possibly) lingering plugins
+
+## 1.4.1
+- Fix command 'install' without arguments
+
+## 1.4.0
+- Add command `gitbook install` to install plugins from book.json
+- `package.json` is no longer necessary
+
+## 1.3.4
+- Add glossary to ebooks
+- Fix autocover with new hook "finish:before"
+- Add X-UA-Compatible meta tag for IE
+
+## 1.3.3
+- Fix parsing of lexed content using the client library
+
+## 1.3.2
+- ePub files are now passing validation from epubcheck
+- Fix replacement of multiple glossary terms in a single sentence
+- Fix on windows deep relative links
+- Fix search indexer
+
+## 1.3.1
+- Fix error with links in markdown
+
+## 1.3.0
+- Bundle gitbook parsing library as a client side library in `gitbook.js` and `gitbook.min.js`
+
+## 1.2.0
+- Improvements on ebook generation
+- Fix incorrect follow of links in ebook generation
+- Move Table of Contents at the beginning of the ebook
+- Update to last highlight.js (includes Swift)
+- Includes of templates and variables (from book.json)
+
+## 1.1.1
+- Rewrite quiz logic to be more robust
+- Improve integration of glossary
+- Improve generation of ebook by using a multiple HTML pages input source
+- Fix incorrect page breaks after h1 and h2 divs
+- New options to set header and footer in PDF generation
+
+## 1.1.0
+- Plugins can now extend the ebook generation (pdf, epub, mobi)
+- Update `kramed` to version 0.4.3
+
+## 1.0.3
+- Update `mathjax` plugin and MathJAx to version 2.4
+- Update `highlight.js` to 8.2.0
+
+## 1.0.2
+- Update `mathjax` plugin, fixes issues with inline math rendering (no longer wanted)
+
+## 1.0.1
+- New inline math convention (kramdown's), using `$$` rather than `$` as delimiters
+- Fix instapaper sharing
+- The `exercises` & `quizzes` plugins are now by default
+
+## 1.0.0
+- New design
+- Support for glossary
+- Support for sharing to instapaper
+- Support for footnotes
+
+## 0.7.1
+- Update `fs-extra` to `0.10.0` (fixes potential race conditions)
+
+## 0.7.0
+- Add page break in ebook (pdf, epub, mobi) between chapters/articles
+- Start using kramed instead of marked
+- Fix display of inline math
+- Switch to graceful-fs to fix EMFILE errors
+- Add sharing to weibo.com
+
+## 0.6.2
+- Support generating a plugin's book info dynamically
+- Improve navigation on dark theme
+- Improve path normalization when parsing SUMMARY.md
+
+## 0.6.0
+- Generate header id the same as github
+- Custom links can be added at top of sidebar
+- Summary can now be transformed by plugins
+- Support importing code snippets

Gruntfile.js

@@ -2,12 +2,21 @@ module.exports = function (grunt) {
     var path = require("path");
 
     // Load NPM tasks
+    grunt.loadNpmTasks('grunt-contrib-copy');
     grunt.loadNpmTasks('grunt-contrib-less');
     grunt.loadNpmTasks('grunt-contrib-requirejs');
+    grunt.loadNpmTasks("grunt-bower-install-simple");
 
     // Init GRUNT configuraton
     grunt.initConfig({
         pkg: grunt.file.readJSON('package.json'),
+        'bower-install-simple': {
+            options: {
+                color:       true,
+                production:  false,
+                directory:   "theme/vendors"
+            }
+        },
         less: {
             development: {
                 options: {
@@ -16,27 +25,28 @@ module.exports = function (grunt) {
                     optimization: 2
                 },
                 files: {
-                    "theme/assets/style.css": "theme/stylesheets/main.less",
-                    "theme/assets/print.css": "theme/stylesheets/print.less"
+                    "theme/assets/style.css": "theme/stylesheets/website.less",
+                    "theme/assets/print.css": "theme/stylesheets/ebook.less"
                 }
             }
         },
         requirejs: {
             compile: {
                 options: {
-                    name: "app",
+                    name: "gitbook",
                     baseUrl: "theme/javascript/",
                     out: "theme/assets/app.js",
                     preserveLicenseComments: false,
-                    optimize: "uglify", //"uglify",
+                    optimize: "uglify",
                     include: ["requireLib"],
                     paths: {
-                        "jQuery": 'vendors/jquery',
-                        "lodash": 'vendors/lodash',
-                        "requireLib": 'vendors/require',
-                        "Mousetrap": 'vendors/mousetrap',
-                        "mixpanel": 'vendors/mixpanel',
-                        "lunr": path.join(__dirname, "node_modules/lunr/lunr")
+                        "jQuery": '../vendors/jquery/dist/jquery',
+                        "lodash": '../vendors/lodash/dist/lodash',
+                        "requireLib": '../vendors/requirejs/require',
+                        "Mousetrap": '../vendors/mousetrap/mousetrap',
+                        "lunr": '../vendors/lunr.js/lunr',
+                        "URIjs": '../vendors/URIjs/src/',
+                        "ace": '../vendors/ace-builds/src-noconflict/'
                     },
                     shim: {
                         'jQuery': {
@@ -48,25 +58,39 @@ module.exports = function (grunt) {
                         'Mousetrap': {
                             exports: 'Mousetrap'
                         },
-                        'mixpanel': {
-                            exports: 'mixpanel'
-                        },
                         'lunr': {
                             exports: 'lunr'
                         }
                     }
                 }
             }
+        },
+        copy: {
+            vendors: {
+                files: [
+                    {
+                        expand: true,
+                        cwd: 'theme/vendors/fontawesome/fonts/',
+                        src: ['**'],
+                        dest: 'theme/assets/fonts/fontawesome/',
+                        filter: 'isFile'
+                    }
+                ]
+            }
         }
     });
 
+    grunt.registerTask("bower-install", [ "bower-install-simple" ]);
+
     // Build
     grunt.registerTask('build', [
+        'bower-install',
         'less',
-        'requirejs'
+        'requirejs',
+        'copy:vendors'
     ]);
 
     grunt.registerTask('default', [
         'build'
     ]);
-};
+};

LICENSE

@@ -186,7 +186,7 @@ Apache License
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright {yyyy} {name of copyright owner}
+   Copyright 2014 FriendCode Inc.
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -198,4 +198,4 @@ Apache License
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
-   limitations under the License.
+   limitations under the License.

README.md

@@ -1,9 +1,12 @@
 GitBook
 =======
 
-[![Build Status](https://travis-ci.org/GitbookIO/gitbook.png?branch=master)](https://travis-ci.org/GitbookIO/gitbook)
+:warning: This branch contains the version 2.0.
 
-GitBook is a command line tool (and Node.js library) for building beautiful programming books and exercises using GitHub/Git and Markdown. You can see an example: [Learn Javascript](http://gitbookio.github.io/javascript/).
+[![Build Status](https://travis-ci.org/GitbookIO/gitbook.png?branch=master)](https://travis-ci.org/GitbookIO/gitbook)
+[![NPM version](https://badge.fury.io/js/gitbook.svg)](http://badge.fury.io/js/gitbook)
+
+GitBook is a command line tool (and Node.js library) for building beautiful books using GitHub/Git and Markdown (or AsciiDoc). Here is an example: [Learn Javascript](https://www.gitbook.com/book/GitBookIO/javascript). You can publish and host book easily online using [gitbook.com](https://www.gitbook.com), a web-editor is [also available](https://www.gitbook.com/editor). You can follow [@GitBookIO](https://twitter.com/GitBookIO) on Twitter. Complete documentation is available at [help.gitbook.io](http://help.gitbook.io/).
 
 ![Image](https://raw.github.com/GitbookIO/gitbook/master/preview.png)
 
@@ -15,6 +18,11 @@ GitBook can be installed from **NPM** using:
 $ npm install gitbook -g
 ```
 
+Create the directories and files for a book from its [SUMMARY.md](https://github.com/GitbookIO/gitbook#book-format) file using
+```
+$ gitbook init
+```
+
 You can serve a repository as a book using:
 
 ```
@@ -24,38 +32,42 @@ $ gitbook serve ./repository
 Or simply build the static website using:
 
 ```
-$ gitbook build ./repository --output=./outputFolder
+$ gitbook build ./repository ./outputFolder
 ```
 
-Options for commands `build` and `serve` are:
+## Features
 
-```
--t, --title <name> Name of the book to generate, defaults to repo name
--i, --intro <intro> Description of the book to generate
--g, --github <repo_path> ID of github repo like : username/repo
--o, --output <directory>  Path to output directory, defaults to ./_book
--f, --format <name>       Change generation format, defaults to site, availables are: site, page, pdf, json
---githubHost <url>   The url of the github host (defaults to https://github.com/)
---theme <path>            Path to theme directory
-```
+* [Output as a website or ebook (pdf, epub, mobi)](#output-formats)
+* [Multi-Languages](#multi-languages)
+* [Glossary](#glossary)
+* [Cover](#cover)
+* [AsciiDoc Support](#asciidoc)
+* [Variables and Templating](#variables-and-templating)
+* [Content References](#content-references)
+* [Plugins](#plugins)
+* Interractive reader website:
+    * Search
+    * Font Settings (Serif, Sans Serif)
+    * Themes: white, sepia, night
 
 ## Output Formats
 
 GitBook can generate your book in the following formats:
 
-* **Static Website**: This is the default format, it generates a complete interactive static website that can be for example hosted on GitHub Pages.
-* **PDF**: A complete PDF book with exercise solutions at the end of the book. Generate to this format using: ```gitbook pdf ./myrepo```, you need to have [gitbook-pdf](https://github.com/GitbookIO/gitbook-pdf) installed.
-* **eBook**: A complete eBook with exercise solutions at the end of the book. Generate to this format using: ```gitbook ebook ./myrepo```, you need to have [ebook-convert](http://manual.calibre-ebook.com/cli/ebook-convert.html) installed.
-* **Single Page**: The book will be stored in a single printable HTML page, this format is used for conversion to PDF or eBook. Generate to this format using: ```gitbook build ./myrepo -f page```.
-* **JSON**: This format is used for debugging or extracting metadata from a book. Generate to this format using: ```gitbook build ./myrepo -f json```.
+* **Static Website**: This is the default format. It generates a complete interactive static website that can be, for example, hosted on GitHub Pages.
+* **eBook**: You need to have [ebook-convert](http://manual.calibre-ebook.com/cli/ebook-convert.html) installed.  You can specify the eBook filename as the second argument, otherwise `book` will be used.
+  * Generate a **PDF** using:  `gitbook pdf ./myrepo ./mybook.pdf`
+  * Generate a **ePub** using: `gitbook epub ./myrepo ./mybook.epub`
+  * Generate a **MOBI** using: `gitbook mobi ./myrepo ./mybook.mobi`
+* **JSON**: This format is used for debugging or extracting metadata from a book. Generate this format using: ```gitbook build ./myrepo --format=json```.
 
 ## Book Format
 
-A book is a GitHub repository containing at least 2 files: `README.md` and `SUMMARY.md`.
+A book is a Git repository containing at least 2 files: `README.md` and `SUMMARY.md`.
 
 #### README.md
 
-As usual, it should contains an introduction for your book. It will be automatically added to the final summary.
+Typically, this should be the introduction for your book. It will be automatically added to the final summary.
 
 #### SUMMARY.md
 
@@ -63,7 +75,7 @@ The `SUMMARY.md` defines your book's structure. It should contain a list of chap
 
 Example:
 
-```
+```markdown
 # Summary
 
 This is the summary of my book.
@@ -75,52 +87,13 @@ This is the summary of my book.
     * [example 1](section2/example1.md)
 ```
 
-Files that are not included in the `SUMMARY.md` will not be processed by `gitbook`.
-
-#### Exercises
-
-A book can contain interactive exercises (currently only in Javascript but Python and Ruby are coming soon ;) ). An exercise is a code challenge provided to the reader, which is given a code editor to write a solution which is checked against the book author's validation code.
-
-An exercise is defined by 4 simple parts:
-
-* Exercise **Message**/Goals (in markdown/text)
-* **Initial** code to show to the user, providing a starting point
-* **Solution** code, being a correct solution to the exercise
-* **Validation** code that tests the correctness of the user's input
-
-Exercises need to start and finish with a separation bar (```---``` or ```***```). It should contain 3 code elements (**base**, **solution** and **validation**). It can contain a 4th element that provides **context** code (functions, imports of libraries etc ... that shouldn't be displayed to the user).
-
-    ---
-
-    Define a variable `x` equal to 10.
-
-    ```js
-    var x =
-    ```
-
-    ```js
-    var x = 10;
-    ```
-
-    ```js
-    assert(x == 10);
-    ```
-
-    ```js
-    // This is context code available everywhere
-    // The user will be able to call magicFunc in his code
-    function magicFunc() {
-        return 3;
-    }
-    ```
-
-    ---
+Files that are not included in `SUMMARY.md` will not be processed by `gitbook`.
 
 #### Multi-Languages
 
 GitBook supports building books written in multiple languages. Each language should be a sub-directory following the normal GitBook format, and a file named `LANGS.md` should be present at the root of the repository with the following format:
 
-```
+```markdown
 * [English](en/)
 * [French](fr/)
 * [Español](es/)
@@ -128,6 +101,138 @@ GitBook supports building books written in multiple languages. Each language sho
 
 You can see a complete example with the [Learn Git](https://github.com/GitbookIO/git) book.
 
+#### Glossary
+
+Allows you to specify terms and their respective definitions to be displayed in the glossary. Based on those terms, `gitbook` will automatically build an index and highlight those terms in pages.
+
+The `GLOSSARY.md` format is very simple :
+
+```markdown
+# term
+Definition for this term
+
+# Another term
+With it's definition, this can contain bold text and all other kinds of inline markup ...
+```
+
+#### Variables and Templating
+
+A set of variables can be defined in the `book.json`:
+
+```js
+{
+    "variables": {
+        "host": "mybook.com"
+    }
+}
+```
+
+These variables can be used in the markdown files:
+
+```
+The host is {{ book.host }}
+```
+
+You can also use condition with these variables:
+
+```
+{% if book.host == "mybook.com" %}
+
+{% else %}
+
+{% endif %}
+```
+
+Variables of `book.json` are available in the `book` namespace. You can also access informations about the `file` itself and the `gitbook` version:
+
+```
+My file is {{ file.path }}
+Modified at {{ file.mtime }}
+Book built with GitBook {{ gitbook.version }}
+```
+
+#### Content References
+
+You can use "content references," or conrefs, when writing books or documentation using GitBook.
+
+Include a file from the same book:
+
+```
+{% include "./test.md" %}
+```
+
+or from a git repository (with a specific revision):
+
+```
+{% include "git+https://github.com/GitbookIO/documentation.git/README.md#1.0.1" %}
+```
+
+Includes can be used with variables (see [Variables and Templating](#variables-and-templating)):
+
+```
+{% include book.ref_doc_readme %}
+```
+
 #### Ignoring files & folders
 
-GitBook will read the `.gitignore`, `.bookignore` and `.ignore` files to get a list of files and folders to skip. (The format inside those files, follows the same convention as `.gitignore`)
+GitBook will read the `.gitignore`, `.bookignore` and `.ignore` files to get a list of files and folders to skip. (The format inside those files follows the same convention as `.gitignore`).
+
+Best practices for the `.gitignore` is to ignore build files from **node.js** (`node_modules`, ...) and build files from GitBook: `_book`, `*.epub`, `*.mobi` and `*.pdf` ([Download GitBook.gitignore](https://github.com/github/gitignore/blob/master/GitBook.gitignore)).
+
+#### Cover
+
+A cover image can be set by creating a file: **/cover.jpg**.
+The best resolution is **1800x2360**. The generation of the cover can be done automatically using the plugin [autocover](https://github.com/GitbookIO/plugin-autocover).
+
+A small version of the cover can also be set by creating a file: **/cover_small.jpg**.
+
+#### AsciiDoc
+
+Since version 2.0.0, AsciiDoc can be used instead of Markdown, simply replace the `.md` by the `.adoc` extension. Chapters in the summary are detected from an ordered list in the `SUMMARY.adoc`.
+
+## Publish your book
+
+The platform [GitBook.com](https://www.gitbook.com/) is like an "Heroku for books": you can create a book on it (public, paid, or private) and update it using **git push**.
+
+## Plugins
+
+Plugins can be used to extend your book's functionality. Read [GitbookIO/plugin](https://github.com/GitbookIO/plugin) for more information about how to build a plugin for GitBook.
+
+Plugins needed to build a book can be installed using: `gitbook install ./`.
+
+##### Official plugins:
+
+| Name | Description |
+| ----- | ---- |
+| [exercises](https://github.com/GitbookIO/plugin-exercises) | Add interactive exercises to your book. |
+| [quizzes](https://github.com/GitbookIO/plugin-quizzes) | Add interactive quizzes to your book. |
+| [mathjax](https://github.com/GitbookIO/plugin-mathjax) | Displays mathematical notation in the book. |
+| [mixpanel](https://github.com/GitbookIO/plugin-mixpanel) | Mixpanel tracking for your book |
+| [infinitescroll](https://github.com/GitbookIO/gitbook-plugin-infinitescroll) | Infinite Scrolling |
+
+##### Other plugins:
+
+| Name | Description |
+| ----- | ---- |
+| [Google Analytics](https://github.com/GitbookIO/plugin-ga) | Google Analytics tracking for your book |
+| [Disqus](https://github.com/GitbookIO/plugin-disqus) | Disqus comments integration in your book |
+| [Autocover](https://github.com/GitbookIO/plugin-autocover) | Generate a cover for your book |
+| [Transform annoted quotes to notes](https://github.com/erixtekila/gitbook-plugin-richquotes) | Allow extra markdown markup to render blockquotes as nice notes |
+| [Send code to console](https://github.com/erixtekila/gitbook-plugin-toconsole) | Evaluate javascript block in the browser inspector's console |
+| [Revealable sections](https://github.com/mrpotes/gitbook-plugin-reveal) | Reveal sections of the page using buttons made from the first title in each section |
+| [Markdown within HTML](https://github.com/mrpotes/gitbook-plugin-nestedmd) | Process markdown within HTML blocks - allows custom layout options for individual pages |
+| [Bootstrap JavaScript plugins](https://github.com/mrpotes/gitbook-plugin-bootstrapjs) | Use the [Bootstrap JavaScript plugins](http://getbootstrap.com/javascript) in your online GitBook |
+| [Piwik Open Analytics](https://github.com/emmanuel-keller/gitbook-plugin-piwik) | Piwik Open Analytics tracking for your book |
+| [Heading Anchors](https://github.com/rlmv/gitbook-plugin-anchors) | Add linkable Github-style anchors to headings |
+| [JSBin](https://github.com/jcouyang/gitbook-plugin-jsbin) | Embedded jsbin frame into your book |
+| [GrVis](https://github.com/romanlytkin/gitbook-grvis) | Gitbook GrViz plugin is used to select from markdown dot and converting it into a picture format svg |
+| [PlantUml](https://github.com/romanlytkin/gitbook-plantuml) | Gitbook PlantUml plugin is used to select from markdown uml and converting it into a picture format svg |
+| [Mermaid](https://github.com/JozoVilcek/gitbook-plugin-mermaid) | Adds diagrams and flowcharts rendered by [mermaid](https://github.com/knsv/mermaid) |
+
+## Debugging
+
+You can use the options `--log=debug` and `--debug` to get better error messages (with stack trace). For example:
+
+```
+$ gitbook build ./ -- log=debug --debug
+```

bin/build.js

@@ -1,50 +0,0 @@
-var path = require('path');
-var Q = require('q');
-var _ = require('lodash');
-
-var utils = require('./utils');
-
-var generate = require("../lib/generate");
-var parse = require("../lib/parse");
-var fs = require('../lib/generate/fs');
-var generators = require("../lib/generate").generators;
-
-var makeBuildFunc = function(converter) {
-    return  function(dir, options) {
-        dir = dir || process.cwd();
-        outputDir = options.output
-
-        console.log('Starting build ...');
-        // Get repo's URL
-        return utils.gitURL(dir)
-        .then(function(url) {
-            // Get ID of repo
-            return utils.githubID(url);
-        }, function(err) {
-            return null;
-        })
-        .then(function(repoID) {
-            return converter(
-                _.extend(options || {}, {
-                    input: dir,
-                    output: outputDir,
-                    title: options.title,
-                    description: options.intro,
-                    github: options.github || repoID,
-                    githubHost: options.githubHost,
-                    generator: options.format,
-                    theme: options.theme
-                })
-            );
-        })
-        .then(function(output) {
-            console.log("Successfuly built !");
-            return output;
-        }, utils.logError);
-    };   
-}
-
-module.exports = {
-    folder: makeBuildFunc(generate.folder),
-    file: makeBuildFunc(generate.file)
-};

bin/gitbook.js

@@ -1,86 +1,7 @@
 #! /usr/bin/env node
 
-var Q = require('q');
-var _ = require('lodash');
-var path = require('path');
-var prog = require('commander');
+var color = require('bash-color');
 
-var pkg = require('../package.json');
-var generators = require("../lib/generate").generators;
-var initDir = require("../lib/generate/init");
-var fs = require('../lib/generate/fs');
-
-var utils = require('./utils');
-var build = require('./build');
-
-// General options
-prog
-.version(pkg.version);
-
-var buildCommand = function(command) {
-    return command
-    .option('-o, --output <directory>', 'Path to output directory, defaults to ./_book')
-    .option('-f, --format <name>', 'Change generation format, defaults to site, availables are: '+_.keys(generators).join(", "))
-    .option('-t, --title <name>', 'Name of the book to generate, default is extracted from readme')
-    .option('-i, --intro <intro>', 'Description of the book to generate, default is extracted from readme')
-    .option('-g, --github <repo_path>', 'ID of github repo like : username/repo')
-    .option('--githubHost <url>', 'The url of the github host (defaults to https://github.com/')
-    .option('--theme <path>', 'Path to theme directory');
-};
-
-buildCommand(prog.command('build [source_dir]'))
-.description('Build a gitbook from a directory')
-.action(build.folder);
-
-buildCommand(prog.command('serve [source_dir]'))
-.description('Build then serve a gitbook from a directory')
-.option('-p, --port <port>', 'Port for server to listen on', 4000)
-.action(function(dir, options) {
-    build.folder(dir, options || {})
-    .then(function(_options) {
-        console.log();
-        console.log('Starting server ...');
-        return utils.serveDir(_options.output, options.port)
-        .fail(utils.logError);
-    })
-    .then(function() {
-        console.log('Serving book on http://localhost:'+options.port);
-        console.log();
-        console.log('Press CTRL+C to quit ...');
-    });
-});
-
-buildCommand(prog.command('pdf [source_dir]'))
-.description('Build a gitbook as a PDF')
-.option('-pf, --paperformat <format>', 'PDF paper format (default is A4): "5in*7.5in", "10cm*20cm", "A4", "Letter"')
-.action(function(dir, options) {
-    build.file(dir, _.extend(options, {
-        extension: "pdf",
-        format: "pdf"
-    }));
-});
-
-buildCommand(prog.command('ebook [source_dir]'))
-.description('Build a gitbook as a eBook')
-.option('-c, --cover <path>', 'Cover image, default is cover.png if exists')
-.action(function(dir, options) {
-    var ext = options.output ? path.extname(options.output) : "epub";
-
-    build.file(dir, _.extend(options, {
-        extension: ext,
-        format: "ebook"
-    }));
-});
-
-prog
-.command('init [source_dir]')
-.description('Create files and folders based on contents of SUMMARY.md')
-.action(function(dir) {
-    dir = dir || process.cwd();
-    return initDir(dir);
-});
-
-// Parse and fallback to help if no args
-if(_.isEmpty(prog.parse(process.argv).args) && process.argv.length === 2) {
-    prog.help();
-}
+console.log(color.red("You need to install 'gitbook-cli' to have access to the gitbook command anywhere on your system."));
+console.log(color.red("If you've installe this package globally, you need to uninstall it."));
+console.log(color.red(">> Run 'npm uninstall -g gitbook' then 'npm install -g gitbook-cli'"));

bin/utils.js

@@ -1,101 +0,0 @@
-var Q = require('q');
-var _ = require('lodash');
-
-var http = require('http');
-var send = require('send');
-
-var url = require('url');
-var cp = require('child_process');
-
-
-// Get the remote of a given repo
-function gitURL(path) {
-    var d = Q.defer();
-
-    cp.exec("git config --get remote.origin.url", {
-        cwd: path,
-        env: process.env,
-    }, function(err, stdout, stderr) {
-        if(err) {
-            return d.reject(err);
-        }
-
-        return d.resolve(stdout);
-    });
-
-    return d.promise
-    .then(function(output) {
-        return output.replace(/(\r\n|\n|\r)/gm, "");
-    });
-}
-
-// Poorman's parsing
-// Parse a git URL to a github ID : username/reponame
-function githubID(_url) {
-    // Remove .git if it's in _url
-    var sliceEnd = _url.slice(-4) === '.git' ? -4 : _url.length;
-
-    // Detect HTTPS repos
-    var parsed = url.parse(_url);
-    if(parsed.protocol === 'https:' && parsed.host === 'github.com') {
-        return parsed.path.slice(1, sliceEnd);
-    }
-
-    // Detect SSH repos
-    if(_url.indexOf('git@') === 0) {
-        return _url.split(':', 2)[1].slice(0, sliceEnd);
-    }
-
-    // None found
-    return null;
-}
-
-function titleCase(str)
-{
-    return str.replace(/\w\S*/g, function(txt){return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();});
-}
-
-function serveDir(dir, port) {
-    var d = Q.defer();
-
-    var server = http.createServer(function(req, res){
-        // Render error
-        function error(err) {
-            res.statusCode = err.status || 500;
-            res.end(err.message);
-        }
-
-        // Redirect to directory's index.html
-        function redirect() {
-            res.statusCode = 301;
-            res.setHeader('Location', req.url + '/');
-            res.end('Redirecting to ' + req.url + '/');
-        }
-
-        // Send file
-        send(req, url.parse(req.url).pathname)
-        .root(dir)
-        .on('error', error)
-        .on('directory', redirect)
-        .pipe(res);
-    }).listen(port);
-
-    d.resolve(server);
-
-    return d.promise;
-}
-
-function logError(err) {
-    console.log(err.stack || err.message || err);
-    return Q.reject(err);
-};
-
-
-// Exports
-module.exports = {
-    gitURL: gitURL,
-    githubID: githubID,
-    titleCase: titleCase,
-    serveDir: serveDir,
-    logError: logError
-};

bower.json

@@ -0,0 +1,13 @@
+{
+    "name": "GitBook",
+    "version": "1.0.0",
+    "dependencies": {
+        "jquery": "2.1.1",
+        "lodash": "2.4.1",
+        "requirejs": "2.1.11",
+        "URIjs": "1.13.1",
+        "mousetrap": "1.4.6",
+        "lunr.js": "0.5.2",
+        "fontawesome": "4.1.0"
+    }
+}

lib/book.js

@@ -0,0 +1,766 @@
+var Q = require("q");
+var _ = require("lodash");
+var path = require("path");
+var util = require("util");
+var lunr = require('lunr');
+var parsers = require("gitbook-parsers");
+var color = require('bash-color');
+
+var fs = require("./utils/fs");
+var parseNavigation = require("./utils/navigation");
+var parseProgress = require("./utils/progress");
+var pageUtil = require("./utils/page");
+var links = require("./utils/links");
+var logger = require("./utils/logger");
+
+var Configuration = require("./configuration");
+var TemplateEngine = require("./template");
+var Plugin = require("./plugin");
+var PluginsList = require("./pluginslist");
+
+var generators = require("./generators");
+
+var Book = function(root, context, parent) {
+	var that = this;
+
+	this.context = _.defaults(context || {}, {
+		// Extend book configuration
+		config: {},
+
+		// Log function
+		log: function(msg) {
+			process.stdout.write(msg);
+		},
+
+		// Log level
+		logLevel: logger.LEVELS
+	});
+
+	// Log
+	this.log = logger(this.context.log, this.context.logLevel);
+
+	// Root folder of the book
+	this.root = path.resolve(root);
+
+	// Parent book
+	this.parent = parent;
+
+	// Configuration
+	this.config = new Configuration(this, this.context.config);
+	Object.defineProperty(this, "options", {
+		get: function () {
+			return this.config.options;
+		}
+	});
+
+	// Template
+	this.template = new TemplateEngine(this);
+
+	// Summary
+	this.summary = {};
+	this.navigation = [];
+
+	// Glossary
+	this.glossary = [];
+
+	// Langs
+	this.langs = [];
+
+	// Sub-books
+	this.books = [];
+
+	// Files in the book
+	this.files = [];
+
+	// List of plugins
+	this.plugins = new PluginsList(this);
+
+	// Structure files
+    this.summaryFile = null;
+    this.glossaryFile = null;
+	this.readmeFile = null;
+    this.langsFile = null;
+
+	// Search Index
+	this.searchIndex = lunr(function () {
+        this.ref('url');
+
+        this.field('title', { boost: 10 });
+        this.field('body');
+    });
+
+    // Bind methods
+	_.bindAll(this);
+};
+
+// Initialize and parse the book: config, summary, glossary
+Book.prototype.parse = function() {
+	var that = this;
+	var multilingual = false;
+
+	return this.parseConfig()
+
+	.then(function() {
+		return that.parsePlugins();
+	})
+
+	.then(function() {
+		return that.parseLangs()
+		.then(function() {
+			multilingual = that.langs.length > 0;
+			if (multilingual) that.log.info.ln("Parsing multilingual book, with", that.langs.length, "lanuages");
+
+			// Sub-books that inherit from the current book configuration
+			that.books = _.map(that.langs, function(lang) {
+				that.log.info.ln("Preparing language book", lang.lang);
+				return new Book(
+					path.join(that.root, lang.path),
+					_.merge({}, that.context, {
+						config: _.extend({}, that.options, {
+							'output': path.join(that.options.output, lang.path),
+							'language': lang.lang
+						})
+					}),
+					that
+				)
+			});
+		});
+	})
+
+	.then(function() {
+		if (multilingual) return;
+		return that.listAllFiles();
+	})
+	.then(function() {
+		if (multilingual) return;
+		return that.parseReadme();
+	})
+	.then(function() {
+		if (multilingual) return;
+		return that.parseSummary();
+	})
+	.then(function() {
+		if (multilingual) return;
+		return that.parseGlossary();
+	})
+
+	.then(function() {
+		// Init sub-books
+		return _.reduce(that.books, function(prev, book) {
+			return prev.then(function() {
+				return book.parse();
+			});
+		}, Q());
+	})
+
+	.thenResolve(this);
+};
+
+// Generate the output
+Book.prototype.generate = function(generator) {
+	var that = this;
+	that.options.generator = generator || that.options.generator;
+
+	that.log.info.ln("start generation with", that.options.generator, "generator");
+	return Q()
+
+	// Clean output folder
+	.then(function() {
+        that.log.info("clean", that.options.generator, "generator");
+		return fs.clean(that.options.output)
+        .progress(function(p) {
+            that.log.debug.ln("remove", p.file, "("+p.i+"/"+p.count+")");
+        })
+        .then(function() {
+            that.log.info.ok();
+        });
+	})
+
+	// Create generator
+	.then(function() {
+		var Generator = generators[generator];
+		if (!Generator) throw "Generator '"+that.options.generator+"' doesn't exist";
+		generator = new Generator(that);
+
+		return generator.prepare();
+	})
+
+
+
+	// Generate content
+	.then(function() {
+		if (that.isMultilingual()) {
+			return that.generateMultiLingual(generator);
+		} else {
+			// Separate list of files into the different operations needed
+			var ops = _.groupBy(that.files, function(file) {
+				if (file[file.length -1] == "/") {
+                	return "directories";
+                } else if (_.contains(parsers.extensions, path.extname(file)) && that.navigation[file]) {
+                	return "content";
+                } else {
+                	return "files";
+                }
+			});
+
+
+			return Q()
+
+			// First, let's create folder
+			.then(function() {
+				return _.reduce(ops["directories"] || [], function(prev, folder) {
+					return prev.then(function() {
+						that.log.debug.ln("transferring folder", folder);
+                    	return Q(generator.transferFolder(folder));
+					});
+				}, Q());
+			})
+
+			// Then, let's copy other files
+			.then(function() {
+				return Q.all(_.map(ops["files"] || [], function(file) {
+					that.log.debug.ln("transferring file", file);
+                    return Q(generator.transferFile(file));
+				}));
+			})
+
+			// Finally let's generate content
+			.then(function() {
+				return _.reduce(ops["content"] || [], function(prev, file) {
+					return prev.then(function() {
+						that.log.debug.ln("converting", file);
+	                    return Q(generator.convertFile(file));
+	                });
+				}, Q());
+			});
+		}
+	})
+
+	// Finish generation
+    .then(function() {
+        return generator.callHook("finish:before");
+    })
+    .then(function() {
+        return generator.finish();
+    })
+    .then(function() {
+        return generator.callHook("finish");
+    })
+    .then(function() {
+    	that.log.info.ln("generation is finished");
+    });
+};
+
+// Generate the output for a multilingual book
+Book.prototype.generateMultiLingual = function(generator) {
+	var that = this;
+
+	return Q()
+	.then(function() {
+		// Generate sub-books
+		return _.reduce(that.books, function(prev, book) {
+			return prev.then(function() {
+				return book.generate(that.options.generator);
+			});
+		}, Q());
+	})
+	.then(function() {
+		return generator.langsIndex(that.langs);
+	});
+};
+
+// Extract files from ebook generated
+Book.prototype.generateFile = function(output, options) {
+	var book = this;
+
+    options = _.defaults(options || {}, {
+        ebookFormat: path.extname(output).slice(1)
+    });
+    output = output || path.resolve(book.root, "book."+options.ebookFormat);
+
+    return fs.tmp.dir()
+    .then(function(tmpDir) {
+    	book.config.extend({
+    		output: tmpDir
+    	});
+
+        return book.generate(options.ebookFormat)
+        .then(function(_options) {
+            var copyFile = function(lang) {
+                var _outputFile = output;
+                var _tmpDir = tmpDir;
+
+                if (lang) {
+                    _outputFile = _outputFile.slice(0, -path.extname(_outputFile).length)+"_"+lang+path.extname(_outputFile);
+                    _tmpDir = path.join(_tmpDir, lang);
+                }
+
+                book.log.info("copy ebook to", output, "...");
+                return fs.copy(
+                    path.join(_tmpDir, "index."+options.ebookFormat),
+                    _outputFile
+                )
+                .then(function() {
+                	book.log.info.ok();
+                });
+            };
+
+            // Multi-langs book
+            return Q()
+            .then(function() {
+                if (book.isMultilingual()) {
+                    return Q.all(
+                        _.map(book.langs, function(lang) {
+                            return copyFile(lang.lang);
+                        })
+                    );
+                } else {
+                    return copyFile();
+                }
+            })
+            .then(function() {
+                return fs.remove(tmpDir);
+            });
+        });
+    });
+};
+
+// Parse configuration
+Book.prototype.parseConfig = function() {
+	var that = this;
+
+	that.log.info("loading book configuration....")
+	return that.config.load()
+	.then(function() {
+		that.log.info.ok();
+	});
+};
+
+// Parse list of plugins
+Book.prototype.parsePlugins = function() {
+	var that = this;
+	var failed = [];
+
+    // Load plugins
+    return that.plugins.load(that.options.plugins)
+    .then(function() {
+    	if (_.size(that.plugins.failed) > 0) return Q.reject(new Error("Error loading plugins: "+that.plugins.failed.join(",")+". Run 'gitbook install' to install plugins from NPM."));
+
+	    that.log.info.ok(that.plugins.count()+" plugins loaded");
+	    that.log.debug.ln("normalize plugins list");
+    });
+};
+
+// Parse readme to extract defaults title and description
+Book.prototype.parseReadme = function() {
+	var that = this;
+	var structure = that.config.getStructure("readme");
+	that.log.debug.ln("start parsing readme:", structure);
+
+	return that.findFile(structure)
+	.then(function(readme) {
+		if (!readme) throw "No README file";
+		if (!_.contains(that.files, readme.path)) throw "README file is ignored";
+
+		that.readmeFile = readme.path;
+        that._defaultsStructure(that.readmeFile);
+
+		that.log.debug.ln("readme located at", that.readmeFile);
+		return that.template.renderFile(that.readmeFile)
+		.then(function(content) {
+			return readme.parser.readme(content);
+		});
+	})
+	.then(function(readme) {
+		that.options.title = that.options.title || readme.title;
+		that.options.description = that.options.description || readme.description;
+	});
+};
+
+
+// Parse langs to extract list of sub-books
+Book.prototype.parseLangs = function() {
+	var that = this;
+
+	var structure = that.config.getStructure("langs");
+	that.log.debug.ln("start parsing languages index:", structure);
+
+	return that.findFile(structure)
+	.then(function(langs) {
+		if (!langs) return [];
+
+        that.langsFile = langs.path;
+        that._defaultsStructure(that.langsFile);
+
+		that.log.debug.ln("languages index located at", that.langsFile);
+		return that.template.renderFile(that.langsFile)
+		.then(function(content) {
+			return langs.parser.langs(content);
+		});
+	})
+	.then(function(langs) {
+		that.langs = langs;
+	});
+};
+
+// Parse summary to extract list of chapters
+Book.prototype.parseSummary = function() {
+	var that = this;
+
+	var structure = that.config.getStructure("summary");
+	that.log.debug.ln("start parsing summary:", structure);
+
+	return that.findFile(structure)
+	.then(function(summary) {
+		if (!summary) throw "No SUMMARY file";
+
+		// Remove the summary from the list of files to parse
+        that.summaryFile = summary.path;
+        that._defaultsStructure(that.summaryFile);
+		that.files = _.without(that.files, that.summaryFile);
+
+		that.log.debug.ln("summary located at", that.summaryFile);
+		return that.template.renderFile(that.summaryFile)
+		.then(function(content) {
+			return summary.parser.summary(content, {
+				entryPoint: that.readmeFile,
+				files: that.files
+			});
+		});
+	})
+	.then(function(summary) {
+		that.summary = summary;
+		that.navigation = parseNavigation(that.summary, that.files);
+	});
+};
+
+// Parse glossary to extract terms
+Book.prototype.parseGlossary = function() {
+	var that = this;
+
+	var structure = that.config.getStructure("glossary");
+	that.log.debug.ln("start parsing glossary: ", structure);
+
+	return that.findFile(structure)
+	.then(function(glossary) {
+		if (!glossary) return [];
+
+		// Remove the glossary from the list of files to parse
+        that.glossaryFile = glossary.path;
+        that._defaultsStructure(that.glossaryFile);
+		that.files = _.without(that.files, that.glossaryFile);
+
+		that.log.debug.ln("glossary located at", that.glossaryFile);
+		return that.template.renderFile(that.glossaryFile)
+		.then(function(content) {
+			return glossary.parser.glossary(content);
+		});
+	})
+	.then(function(glossary) {
+		that.glossary = glossary;
+	});
+};
+
+// Parse a page
+Book.prototype.parsePage = function(filename, options) {
+	var that = this, page = {};
+    options = _.defaults(options || {}, {
+    	// Transform svg images
+    	convertImages: false,
+
+        // Interpolate before templating
+        interpolateTemplate: _.identity,
+
+        // Interpolate after templating
+        interpolateContent: _.identity
+    });
+
+    var interpolate = function(fn) {
+        return Q(fn(page))
+        .then(function(_page) {
+            page = _page;
+        });
+    };
+
+	that.log.debug.ln("start parsing file", filename);
+
+	var extension = path.extname(filename);
+	var filetype = parsers.get(extension);
+
+	if (!filetype) return Q.reject(new Error("Can't parse file: "+filename));
+
+    // Type of parser used
+    page.type = filetype.name;
+
+    // Path relative to book
+    page.path = filename;
+
+    // Path absolute in the system
+    page.rawPath = path.resolve(that.root, filename);
+
+    // Progress in the book
+    page.progress = parseProgress(that.navigation, filename);
+
+	that.log.debug.ln("render template", filename);
+
+    // Read file content
+    return that.readFile(page.path)
+    .then(function(content) {
+        page.content = content;
+
+        return interpolate(options.interpolateTemplate);
+    })
+
+    // Generate template
+    .then(function() {
+        return that.template.renderPage(page);
+    })
+
+    // Parse markup
+    .then(function(content) {
+        page.content = content;
+
+        that.log.debug.ln("use file parser", filetype.name, "for", filename);
+        return filetype.parser.page(page.content);
+    })
+
+    // Post process sections
+    .then(function(_page) {
+    	return _.reduce(_page.sections, function(prev, section) {
+    		return prev.then(function(_sections) {
+    			return that.template.postProcess(section.content || "")
+    			.then(function(content) {
+    				section.content = content;
+    				return _sections.concat([section]);
+    			})
+    		});
+    	}, Q([]));
+    })
+
+    // Prepare html
+	.then(function(_sections) {
+		return pageUtil.normalize(_sections, {
+			book: that,
+			convertImages: options.convertImages,
+			input: filename,
+            navigation: that.navigation,
+            base: path.dirname(filename) || './',
+            output: path.dirname(filename) || './',
+            glossary: that.glossary
+        });
+	})
+
+	// Interpolate output
+	.then(function(_sections) {
+		page.sections = _sections;
+		return interpolate(options.interpolateContent);
+	})
+
+	.then(function() {
+		that.indexPage(page);
+		return page;
+	});
+};
+
+// Find file that can be parsed with a specific filename
+Book.prototype.findFile = function(filename) {
+	var that = this;
+
+	return _.reduce(parsers.extensions, function(prev, ext) {
+		return prev.then(function(output) {
+			// Stop if already find a parser
+			if (output) return output;
+
+			var filepath = filename+ext;
+
+			return that.fileExists(filepath)
+			.then(function(exists) {
+				if (!exists) return null;
+				return {
+					parser: parsers.get(ext).parser,
+					path: filepath
+				};
+			})
+		});
+	}, Q(null));
+};
+
+// Check if a file exists in the book
+Book.prototype.fileExists = function(filename) {
+	return fs.exists(
+		path.join(this.root, filename)
+	);
+};
+
+// Read a file
+Book.prototype.readFile = function(filename) {
+	return fs.readFile(
+		path.join(this.root, filename),
+		{ encoding: "utf8" }
+	);
+};
+
+// Return stat for a file
+Book.prototype.statFile = function(filename) {
+	return fs.stat(path.join(this.root, filename));
+};
+
+// List all files in the book
+Book.prototype.listAllFiles = function() {
+	var that = this;
+
+    return fs.list(this.root, {
+        ignoreFiles: ['.ignore', '.gitignore', '.bookignore'],
+        ignoreRules: [
+            // Skip Git stuff
+            '.git/',
+            '.gitignore',
+
+            // Skip OS X meta data
+            '.DS_Store',
+
+            // Skip stuff installed by plugins
+            'node_modules',
+
+            // Skip book outputs
+            '_book',
+            '*.pdf',
+            '*.epub',
+            '*.mobi',
+
+            // Skip config files
+            '.ignore',
+            '.bookignore',
+            'book.json',
+        ]
+    })
+    .then(function(_files) {
+        that.files = _files;
+    });
+};
+
+// Return true if the book is a multilingual book
+Book.prototype.isMultilingual = function(filename) {
+	return this.books.length > 0;
+};
+
+// Return root of the parent
+Book.prototype.parentRoot = function() {
+	if (this.parent) return this.parent.parentRoot();
+	return this.root;
+};
+
+// Resolve a path in book
+Book.prototype.resolve = function(p) {
+    return path.resolve(this.root, p);
+};
+
+// Normalize a link to .html and convert README -> index
+Book.prototype.contentLink = function(link) {
+    if (
+        path.basename(link) == "README"
+        || link == this.readmeFile
+    ) {
+        link = path.join(path.dirname(link), "index"+path.extname(link));
+    }
+
+    link = links.changeExtension(link, ".html");
+    return link;
+}
+
+// Index a page into the search index
+Book.prototype.indexPage = function(page) {
+	var nav = this.navigation[page.path];
+	if (!nav) return;
+
+	this.log.debug.ln("index page", page.path);
+	this.searchIndex.add({
+        url: this.contentLink(page.path),
+        title: nav.title,
+        body: pageUtil.extractText(page.sections),
+    });
+};
+
+// Default structure paths to an extension
+Book.prototype._defaultsStructure = function(filename) {
+    var that = this;
+    var extension = path.extname(filename);
+
+    that.readmeFile = that.readmeFile || that.config.getStructure("readme")+extension;
+    that.summaryFile = that.summaryFile || that.config.getStructure("summary")+extension;
+    that.glossaryFile = that.glossaryFile || that.config.getStructure("glossary")+extension;
+    that.langsFile = that.langsFile || that.config.getStructure("langs")+extension;
+}
+
+
+// Init and return a book
+Book.init = function(root) {
+    var book = new Book(root);
+    var extensionToUse = ".md";
+
+    var chaptersPaths = function(chapters) {
+        return _.reduce(chapters || [], function(accu, chapter) {
+            if (!chapter.path) return accu;
+            return accu.concat(
+                _.filter([
+                    {
+                        title: chapter.title,
+                        path: chapter.path
+                    }
+                ].concat(chaptersPaths(chapter.articles)))
+            );
+        }, []);
+    };
+
+    book.log.infoLn("init book at", root);
+    return fs.mkdirp(root)
+    .then(function() {
+        book.log.infoLn("detect structure from SUMMARY (if it exists)");
+        return book.parseSummary();
+    })
+    .fail(function() {
+        return Q();
+    })
+    .then(function() {
+        var summary = book.summaryFile || "SUMMARY.md";
+        var chapters = book.summary.chapters || [];
+        extensionToUse = path.extname(summary);
+
+        if (chapters.length == 0) {
+            chapters = [
+                {
+                    title: "Summary",
+                    path: "SUMMARY"+extensionToUse
+                },
+                {
+                    title: "Introduction",
+                    path: "README"+extensionToUse
+                }
+            ];
+        }
+
+        return Q(chaptersPaths(chapters));
+    })
+    .then(function(chapters) {
+        // Create files that don't exist
+        return Q.all(_.map(chapters, function(chapter) {
+            var absolutePath = path.resolve(book.root, chapter.path);
+
+            return fs.exists(absolutePath)
+            .then(function(exists) {
+                book.log.infoLn("create", chapter.path);
+                if(exists) return;
+
+                return fs.mkdirp(path.dirname(absolutePath))
+                .then(function() {
+                    return fs.writeFile(absolutePath, '# '+chapter.title+'\n');
+                });
+            });
+        }));
+    })
+    .then(function() {
+        book.log.infoLn("initialization is finished");
+    });
+};
+
+module.exports= Book;

lib/configuration.js

@@ -0,0 +1,232 @@
+var _ = require("lodash");
+var Q = require("q");
+var path = require("path");
+var semver = require('semver');
+
+var pkg = require('../package.json');
+var fs = require("./utils/fs");
+
+// Default plugins added to each books
+var defaultsPlugins = [];
+
+// Normalize a list of plugins to use
+function normalizePluginsList(plugins) {
+    // Normalize list to an array
+    plugins = _.isString(plugins) ? plugins.split(",") : (plugins || []);
+
+    // Remove empty parts
+    plugins = _.compact(plugins);
+
+    // Divide as {name, version} to handle format like "myplugin@1.0.0"
+    plugins = _.map(plugins, function(plugin) {
+        if (plugin.name) return plugin;
+
+        var parts = plugin.split("@");
+        return {
+            'name': parts[0],
+            'version': parts[1] // optional
+        }
+    });
+
+    // List plugins to remove
+    var toremove = _.chain(plugins)
+    .filter(function(plugin) {
+        return plugin.name.length > 0 && plugin.name[0] == "-";
+    })
+    .map(function(plugin) {
+        return plugin.name.slice(1);
+    })
+    .value();
+
+    // Merge with defaults
+    plugins = _.chain(plugins)
+    .concat(_.map(defaultsPlugins, function(plugin) {
+        return { 'name': plugin }
+    }))
+    .uniq()
+    .value();
+
+    // Build final list
+    plugins = _.filter(plugins, function(plugin) {
+        return !_.contains(toremove, plugin.name) && !(plugin.name.length > 0 && plugin.name[0] == "-");
+    });
+
+    return plugins;
+}
+
+// Normalize a list of plugin name to use
+function normalizePluginsNames(plugins) {
+    return _.pluck(normalizePluginsList(plugins), "name");
+};
+
+
+var Configuration = function(book, options) {
+    var that = this;
+
+	this.book = book;
+
+    this.options = _.cloneDeep(Configuration.DEFAULT);
+	this.options = _.merge(this.options, options || {});
+
+    // options.input == book.root
+    Object.defineProperty(this.options, "input", {
+        get: function () {
+            return that.book.root;
+        }
+    });
+};
+
+// Read and parse the configuration
+Configuration.prototype.load = function() {
+	var that = this;
+
+	return Q()
+    .then(function() {
+        try {
+            var _config = require(path.resolve(that.book.root, that.options.configFile));
+            that.options = _.merge(
+            	that.options,
+            	_.omit(_config, 'configFile', 'defaultsPlugins', 'generator', 'extension')
+            );
+        }
+        catch(err) {
+            if (err instanceof SyntaxError) return Q.reject(err);
+            return Q();
+        }
+    })
+    .then(function() {
+        that.options.output = path.resolve(that.options.output || path.join(that.book.root, "_book"));
+        that.options.plugins = normalizePluginsList(that.options.plugins);
+        that.options.defaultsPlugins = normalizePluginsList(that.options.defaultsPlugins || "");
+        that.options.plugins = _.union(that.options.plugins, that.options.defaultsPlugins);
+        that.options.plugins = _.uniq(that.options.plugins, "name");
+
+        if (!semver.satisfies(pkg.version, that.options.gitbook)) {
+            throw "GitBook version doesn't satisfy version required by the book: "+that.options.gitbook;
+        }
+        if (that.options.gitbook == "*") {
+            that.book.log.warn.ln("you should specify a gitbook version to use in your book.json, for example: "+(_.first(pkg.version.split("."))+".x.x"));
+        }
+    });
+};
+
+// Extend the configuration
+Configuration.prototype.extend = function(options) {
+    _.extend(this.options, options);
+};
+
+// Get structure file
+Configuration.prototype.getStructure = function(name) {
+    return this.options.structure[name].split(".").slice(0, -1).join(".");
+};
+
+// Return normalized language
+Configuration.prototype.normalizeLanguage = function() {
+    return _.first(this.options.language.split("-")).toLowerCase();
+};
+
+
+// Default configuration
+Configuration.DEFAULT = {
+    // Options that can't be extend
+    "configFile": "book",
+    "generator": "site",
+    "extension": null,
+
+    // Book metadats (somes are extracted from the README by default)
+    "title": null,
+    "description": null,
+    "isbn": null,
+    "language": "en",
+
+    // version of gitbook to use
+    "gitbook": "*",
+
+    // Structure
+    "structure": {
+        "langs": "LANGS.md",
+        "readme": "README.md",
+        "glossary": "GLOSSARY.md",
+        "summary": "SUMMARY.md"
+    },
+
+    // CSS Styles
+    "styles": {
+        "website": "styles/website.css",
+        "ebook": "styles/ebook.css",
+        "pdf": "styles/pdf.css",
+        "mobi": "styles/mobi.css",
+        "epub": "styles/epub.css"
+    },
+
+    // Plugins list, can contain "-name" for removing default plugins
+    "plugins": [],
+
+    // Global configuration for plugins
+    "pluginsConfig": {
+        "fontSettings": {
+            "theme": null, //"sepia", "night" or "white",
+            "family": "sans",// "serif" or "sans",
+            "size": 2 // 1 - 4
+        }
+    },
+
+    // Variables for templating
+    "variables": {},
+
+    // Set another theme with your own layout
+    // It's recommended to use plugins or add more options for default theme, though
+    // See https://github.com/GitbookIO/gitbook/issues/209
+    "theme": path.resolve(__dirname, '../theme'),
+
+    // Links in template (null: default, false: remove, string: new value)
+    "links": {
+        // Custom links at top of sidebar
+        "sidebar": {
+            //"Custom link name": "https://customlink.com"
+        },
+
+        // Sharing links
+        "sharing": {
+            "google": null,
+            "facebook": null,
+            "twitter": null,
+            "weibo": null,
+            "all": null
+        }
+    },
+
+
+    // Options for PDF generation
+    "pdf": {
+        // Add toc at the end of the file
+        "toc": true,
+
+        // Add page numbers to the bottom of every page
+        "pageNumbers": false,
+
+        // Font size for the file content
+        "fontSize": 12,
+
+        // Paper size for the pdf
+        // Choices are [u’a0’, u’a1’, u’a2’, u’a3’, u’a4’, u’a5’, u’a6’, u’b0’, u’b1’, u’b2’, u’b3’, u’b4’, u’b5’, u’b6’, u’legal’, u’letter’]
+        "paperSize": "a4",
+
+        // Margin (in pts)
+        // Note: 72 pts equals 1 inch
+        "margin": {
+            "right": 62,
+            "left": 62,
+            "top": 36,
+            "bottom": 36
+        },
+
+        //Header HTML template. Available variables: _PAGENUM_, _TITLE_, _AUTHOR_ and _SECTION_.
+        "headerTemplate": "",
+
+        //Footer HTML template. Available variables: _PAGENUM_, _TITLE_, _AUTHOR_ and _SECTION_.
+        "footerTemplate": ""
+    }
+};
+
+module.exports= Configuration;

lib/generate/ebook/index.js

@@ -1,70 +0,0 @@
-var util = require("util");
-var path = require("path");
-var Q = require("q");
-var _ = require("lodash");
-var exec = require('child_process').exec;
-
-var fs = require("fs");
-var parse = require("../../parse");
-var BaseGenerator = require("../page");
-
-/*
- *  This generator inherits from the single page generator
- *  and convert the page output to ebook
- */
-var Generator = function() {
-    BaseGenerator.apply(this, arguments);
-
-    // Options for eBook generation
-    this.options = _.defaults(this.options, {
-        extension: "epub"
-    });
-
-    if (!this.options.cover && fs.existsSync(path.join(this.options.input, "cover.png"))) {
-        this.options.cover = path.join(this.options.input, "cover.png")
-    }
-};
-util.inherits(Generator, BaseGenerator);
-
-Generator.prototype.finish = function() {
-    var that = this;
-
-    return BaseGenerator.prototype.finish.apply(this)
-    .then(function() {
-        var d = Q.defer();
-
-        var _options = {
-            "--cover": that.options.cover
-        };
-
-        var command = [
-            "ebook-convert",
-            path.join(that.options.output, "index.html"),
-            path.join(that.options.output, "index."+that.options.extension),
-            _.chain(_options)
-            .map(function(value, key) {
-                if (value == null) return null;
-                return key+"="+value;
-            })
-            .compact()
-            .value()
-            .join(" ")
-        ].join(" ");
-
-        exec(command, function (error, stdout, stderr) {
-            if (error) {
-                if (error.code == 127) {
-                    error.message = "Need to install ebook-convert from Calibre";
-                } else {
-                    error.message = error.message + " "+stdout;
-                }
-                return d.reject(error);
-            }
-            d.resolve();
-        });
-
-        return d.promise;
-    });
-};
-
-module.exports = Generator;

lib/generate/fs.js

@@ -1,60 +0,0 @@
-var Q = require("q");
-var fs = require("fs");
-var fsExtra = require("fs-extra");
-var Ignore = require("fstream-ignore");
-
-var getFiles = function(path) {
-    var d = Q.defer();
-
-    // Our list of files
-    var files = [];
-
-    var ig = Ignore({
-        path: path,
-        ignoreFiles: ['.ignore', '.gitignore', '.bookignore']
-    });
-
-    // Add extra rules to ignore common folders
-    ig.addIgnoreRules([
-        '.git/',
-        '.gitignore',
-    ], '__custom_stuff');
-
-    // Push each file to our list
-    ig.on('child', function (c) {
-        files.push(
-            c.path.substr(c.root.path.length + 1) + (c.props.Directory === true ? '/' : '')
-        );
-    });
-
-    ig.on('end', function() {
-        // Normalize paths on Windows
-        if(process.platform === 'win32') {
-            return d.resolve(files.map(function(file) {
-                return file.replace(/\\/g, '/');
-            }));
-        }
-
-        // Simply return paths otherwise
-        return d.resolve(files);
-    });
-
-    ig.on('error', d.reject);
-
-    return d.promise;
-};
-
-module.exports = {
-    list: getFiles,
-    readFile: Q.denodeify(fs.readFile),
-    writeFile: Q.denodeify(fs.writeFile),
-    mkdirp: Q.denodeify(fsExtra.mkdirp),
-    copy: Q.denodeify(fsExtra.copy),
-    remove: Q.denodeify(fsExtra.remove),
-    symlink: Q.denodeify(fsExtra.symlink),
-    exists: function(path) {
-        var d = Q.defer();
-        fs.exists(path, d.resolve);
-        return d.promise;
-    },
-};

lib/generate/generator.js

@@ -1,36 +0,0 @@
-var path = require("path");
-var Q = require("q");
-var fs = require("./fs");
-
-var BaseGenerator = function(options) {
-    this.options = options;
-};
-
-BaseGenerator.prototype.convertFile = function(content, input) {
-    return Q.reject(new Error("Could not convert "+input));
-};
-
-BaseGenerator.prototype.transferFile = function(input) {
-    return fs.copy(
-        path.join(this.options.input, input),
-        path.join(this.options.output, input)
-    );
-};
-
-BaseGenerator.prototype.transferFolder = function(input) {
-    return fs.mkdirp(
-        path.join(this.options.output, input)
-    );
-};
-
-BaseGenerator.prototype.langsIndex = function(langs) {
-    return Q.reject(new Error("Langs index is not supported in this generator"));
-};
-
-BaseGenerator.prototype.finish = function() {
-    return Q.reject(new Error("Could not finish generation"));
-};
-
-
-
-module.exports = BaseGenerator;

lib/generate/index.js

@@ -1,238 +0,0 @@
-var Q = require("q");
-var _ = require("lodash");
-var path = require("path");
-var swig = require('swig');
-var tmp = require('tmp');
-
-var fs = require("./fs");
-var parse = require("../parse");
-
-var generators = {
-    "site": require("./site"),
-    "page": require("./page"),
-    "pdf": require("./pdf"),
-    "ebook": require("./ebook"),
-    "json": require("./json")
-};
-
-var defaultDescription = "Book generated using GitBook";
-
-/*
- *  Use a specific generator to convert a gitbook to a site/pdf/ebook/
- *  output is always a folder
- */
-var generate = function(options) {
-    var generator = null;
-    var files;
-
-    options = _.defaults(options || {}, {
-        // Folders to use
-        input: null,
-        output: null,
-
-        // Output generator
-        generator: "site",
-
-        // Book title, keyword, description
-        title: null,
-        description: null,
-
-        // Origin github repository id
-        github: null,
-        githubHost: 'https://github.com/',
-
-        // Theming
-        theme: path.resolve(__dirname, '../../theme')
-    });
-
-    if (!options.input) {
-        return Q.reject(new Error("Need option input (book input directory)"));
-    }
-
-    if (!generators[options.generator]) {
-        return Q.reject(new Error("Invalid generator (availables are: "+_.keys(generators).join(", ")));
-    }
-
-    options.output = options.output || path.join(options.input, "_book");
-
-    // Clean output folder
-    return fs.remove(options.output)
-
-    .then(function() {
-        return fs.mkdirp(options.output);
-    })
-
-    // List all files in the repository
-    .then(function() {
-        return fs.list(options.input)
-        .then(function(_files) {
-            files = _files;
-        })
-    })
-
-    // Create the generator
-    .then(function() {
-        generator = new generators[options.generator](options);
-    })
-
-    // Detect multi-languages book
-    .then(function() {
-        if (_.contains(files, "LANGS.md")) {
-            // Multi-languages book
-            return fs.readFile(path.join(options.input, "LANGS.md"), "utf-8")
-
-            // Generate sub-books
-            .then(function(_langsSummary) {
-                options.langsSummary = parse.langs(_langsSummary);
-
-                // Generated a book for each valid entry
-                return Q.all(
-                    _.map(options.langsSummary.list, function(entry) {
-                        return generate(_.extend({}, options, {
-                            input: path.join(options.input, entry.path),
-                            output: path.join(options.output, entry.path)
-                        }));
-                    })
-                );
-            })
-
-            // Generate languages index
-            .then(function() {
-                return generator.langsIndex(options.langsSummary);
-            });
-        } else if (!_.contains(files, "SUMMARY.md") || !_.contains(files, "README.md")) {
-            // Invalid book
-            return Q.reject(new Error("Invalid gitbook repository, need SUMMARY.md and README.md"));
-        } else {
-            // Generate the book
-            return Q()
-
-            // Read readme
-            .then(function() {
-                return fs.readFile(path.join(options.input, "README.md"), "utf-8")
-                .then(function(_readme) {
-                    _readme = parse.readme(_readme);
-
-                    options.title = options.title || _readme.title;
-                    options.description = options.description || _readme.description || defaultDescription;
-                });
-            })
-
-            // Get summary
-            .then(function() {
-                return fs.readFile(path.join(options.input, "SUMMARY.md"), "utf-8")
-                .then(function(_summary) {
-                    options.summary = parse.summary(_summary);
-
-                    // Parse navigation
-                    options.navigation = parse.navigation(options.summary);
-                });
-            })
-
-            // Skip processing some files
-            .then(function() {
-                files = _.filter(files, function (file) {
-                    return !(
-                        file === 'SUMMARY.md'
-                    );
-                });
-            })
-
-            // Copy file and replace markdown file
-            .then(function() {
-                return Q.all(
-                    _.chain(files)
-                    .map(function(file) {
-                        if (!file) return;
-
-                        if (file[file.length -1] == "/") {
-                            return Q(generator.transferFolder(file));
-                        } else if (path.extname(file) == ".md" && options.navigation[file] != null) {
-                            return fs.readFile(path.join(options.input, file), "utf-8")
-                            .then(function(content) {
-                                return Q(generator.convertFile(content, file));
-                            });
-                        } else {
-                            return Q(generator.transferFile(file));
-                        }
-                    })
-                    .value()
-                );
-            })
-
-            // Finish gneration
-            .then(function() {
-                return generator.finish();
-            });
-        }
-    })
-
-    // Return all options
-    .then(function() {
-        return options;
-    });
-};
-
-/*
- *  Extract files from generate output in a temporary folder
- */
-var generateFile = function(options) {
-    options = _.defaults(options || {}, {
-        input: null,
-        output: null,
-        extension: null
-    });
-
-    return Q.nfcall(tmp.dir)
-    .then(function(tmpDir) {
-        return generate(
-            _.extend({},
-                options,
-                {
-                    output: tmpDir
-                })
-        )
-        .then(function(_options) {
-            var ext = options.extension;
-            var outputFile = options.output || path.resolve(options.input, "book."+ext);
-
-            var copyFile = function(lang) {
-                var _outputFile = outputFile;
-                var _tmpDir = tmpDir;
-
-                if (lang) {
-                    _outputFile = _outputFile.slice(0, -path.extname(_outputFile).length)+"_"+lang+path.extname(_outputFile);
-                    _tmpDir = path.join(_tmpDir, lang);
-                }
-
-                return fs.copy(
-                    path.join(_tmpDir, "index."+ext),
-                    _outputFile
-                );
-            };
-
-            // Multi-langs book
-            return Q()
-            .then(function() {
-                if (_options.langsSummary) {
-                    return Q.all(
-                        _.map(_options.langsSummary.list, function(lang) {
-                            return copyFile(lang.lang);
-                        })
-                    );
-                } else {
-                    return copyFile();
-                }
-            })
-            .then(function() {
-                return fs.remove(tmpDir);
-            });
-        });
-    });
-};
-
-module.exports = {
-    generators: generators,
-    folder: generate,
-    file: generateFile
-};

lib/generate/init.js

@@ -1,69 +0,0 @@
-var Q = require('q');
-var _ = require('lodash');
-
-var path = require('path');
-
-var fs = require('./fs');
-var parse = require('../parse');
-
-
-// Extract paths out of a summary
-function paths(summary) {
-    return _.reduce(summary.chapters, function(accu, chapter) {
-        return accu.concat(
-            _.filter([chapter.path].concat(_.pluck(chapter.articles, 'path')))
-        );
-    }, []);
-}
-
-// Get the parent folders out of a group of files
-function folders(files) {
-    return _.chain(files)
-    .map(function(file) {
-        return path.dirname(file);
-    })
-    .uniq()
-    .value();
-}
-
-function initDir(dir) {
-    return fs.readFile(path.join(dir, 'SUMMARY.md'), 'utf8')
-    .then(function(src) {
-        // Parse summary
-        return parse.summary(src);
-    })
-    .then(function(summary) {
-        // Extract paths from summary
-        return paths(summary);
-    })
-    .then(function(paths) {
-        // Convert to absolute paths
-        return _.map(paths, function(file) {
-            return path.resolve(file);
-        });
-    })
-    .then(function(files) {
-        // Create folders
-        return Q.all(_.map(folders(files), function(folder) {
-            return fs.mkdirp(folder);
-        }))
-        .then(_.constant(files));
-    })
-    .then(function(files) {
-        // Create files that don't exist
-        return Q.all(_.map(files, function(file) {
-            return fs.exists(file)
-            .then(function(exists) {
-                if(exists) return;
-                return fs.writeFile(file, '');
-            });
-        }));
-    })
-    .fail(function(err) {
-        console.error(err.stack);
-    });
-}
-
-
-// Exports
-module.exports = initDir;

lib/generate/json/index.js

@@ -1,47 +0,0 @@
-var util = require("util");
-var path = require("path");
-var Q = require("q");
-
-var fs = require("../fs");
-var parse = require("../../parse");
-var BaseGenerator = require("../generator");
-
-
-var Generator = function() {
-    BaseGenerator.apply(this, arguments);
-};
-util.inherits(Generator, BaseGenerator);
-
-Generator.prototype.transferFile = function(input) {
-    // ignore
-};
-
-Generator.prototype.convertFile = function(content, input) {
-    var that = this;
-    var json = {
-        progress: parse.progress(this.options.navigation, input)
-    };
-
-    return Q()
-    .then(function() {
-        return parse.page(content, {
-            repo: that.options.githubId,
-            dir: path.dirname(input) || '/'
-        });
-    })
-    .then(function(sections) {
-        json.sections = sections;
-    })
-    .then(function() {
-        return fs.writeFile(
-            path.join(that.options.output, input.replace(".md", ".json")),
-            JSON.stringify(json, null, 4)
-        );
-    });
-};
-
-Generator.prototype.finish = function() {
-    // ignore
-};
-
-module.exports = Generator;

lib/generate/page/index.js

@@ -1,84 +0,0 @@
-var _ = require("lodash");
-var util = require("util");
-var path = require("path");
-var Q = require("q");
-var swig = require('swig');
-var hljs = require('highlight.js');
-
-var fs = require("../fs");
-var parse = require("../../parse");
-var BaseGenerator = require("../site");
-
-// Swig filter: highlight coloration
-swig.setFilter('code', function(code, lang) {
-    try {
-        return hljs.highlight(lang, code).value;
-    } catch(e) {
-        return hljs.highlightAuto(code).value;
-    }
-});
-
-
-/*
- *  This generator will generate a simple index.html which can be converted as a PDF
- */
-var Generator = function() {
-    BaseGenerator.apply(this, arguments);
-
-    // Load base template
-    this.template = swig.compileFile(path.resolve(this.options.theme, 'templates/page.html'));
-
-    // List of pages content
-    this.pages = {};
-};
-util.inherits(Generator, BaseGenerator);
-
-Generator.prototype.convertFile = function(content, input) {
-    var that = this;
-    var json = {
-        path: input,
-        progress: parse.progress(this.options.navigation, input)
-    };
-
-    return Q()
-    .then(function() {
-        return parse.page(content, {
-            repo: that.options.githubId,
-            dir: path.dirname(input) || '/',
-            outdir: './',
-        });
-    })
-    .then(function(sections) {
-        json.content = sections;
-    })
-    .then(function() {
-        that.pages[input] = json;
-    });
-};
-
-Generator.prototype.finish = function() {
-    var that = this;
-    var basePath = ".";
-    var output = path.join(this.options.output, "index.html");
-
-    return Q()
-    // Generate html
-    .then(function(pages) {
-        return that._writeTemplate(that.template, {
-            pages: that.pages,
-
-            basePath: basePath,
-            staticBase: path.join(basePath, "gitbook"),
-        }, output);
-    })
-
-    // Copy assets
-    .then(function() {
-        return fs.copy(
-            path.join(that.options.theme, "assets"),
-            path.join(that.options.output, "gitbook")
-        );
-    });
-};
-
-module.exports = Generator;

lib/generate/pdf/index.js

@@ -1,56 +0,0 @@
-var util = require("util");
-var path = require("path");
-var Q = require("q");
-var _ = require("lodash");
-var exec = require('child_process').exec;
-
-var fs = require("../fs");
-var parse = require("../../parse");
-var BaseGenerator = require("../page");
-
-/*
- *  This generator inherits from the single page generator
- *  and convert the page output to pdf using gitbook-pdf
- */
-var Generator = function() {
-    BaseGenerator.apply(this, arguments);
-
-    // Options for PDF generation
-    this.options = _.defaults(this.options, {
-        paperformat: "A4"
-    });
-};
-util.inherits(Generator, BaseGenerator);
-
-Generator.prototype.finish = function() {
-    var that = this;
-
-    return BaseGenerator.prototype.finish.apply(this)
-    .then(function() {
-        var d = Q.defer();
-
-        var command = [
-            "gitbook-pdf",
-            "generate",
-            path.join(that.options.output, "index.html"),
-            path.join(that.options.output, "index.pdf"),
-            "--format="+that.options.paperformat
-        ].join(" ");
-
-        exec(command, function (error, stdout, stderr) {
-            if (error) {
-                if (error.code == 127) {
-                    error.message = "Need to install gitbook-pdf using: npm install gitbook-pdf -g";
-                } else {
-                    error.message = error.message + " "+stdout;
-                }
-                return d.reject(error);
-            }
-            d.resolve();
-        });
-
-        return d.promise;
-    });
-};
-
-module.exports = Generator;

lib/generate/site/index.js

@@ -1,156 +0,0 @@
-var util = require("util");
-var path = require("path");
-var Q = require("q");
-var _ = require("lodash");
-var swig = require('swig');
-
-var fs = require("../fs");
-var parse = require("../../parse");
-var BaseGenerator = require("../generator");
-
-var indexer = require('./search_indexer');
-
-// Swig filter for returning the count of lines in a code section
-swig.setFilter('lines', function(content) {
-    return content.split('\n').length;
-});
-
-// Swig filter for returning a link to the associated html file of a markdown file
-swig.setFilter('mdLink', function(link) {
-    var link = link.replace(".md", ".html");
-    if (link == "README.html") link = "index.html";
-    return link;
-});
-
-var Generator = function() {
-    BaseGenerator.apply(this, arguments);
-
-    // Attach methods to instance
-    _.bindAll(this);
-
-    this.revision = Date.now();
-    this.indexer = indexer();
-
-    // Load base template
-    this.template = swig.compileFile(path.resolve(this.options.theme, 'templates/site.html'));
-    this.langsTemplate = swig.compileFile(path.resolve(this.options.theme, 'templates/langs.html'));
-};
-util.inherits(Generator, BaseGenerator);
-
-
-// Generate a template
-Generator.prototype._writeTemplate = function(tpl, options, output) {
-    var that = this;
-    return Q()
-    .then(function(sections) {
-        return tpl(_.extend({
-            revision: that.revision,
-
-            title: that.options.title,
-            description: that.options.description,
-
-            githubAuthor: that.options.github ? that.options.github.split("/")[0] : "",
-            githubId: that.options.github,
-            githubHost: that.options.githubHost,
-
-            summary: that.options.summary,
-            allNavigation: that.options.navigation
-        }, options));
-    })
-    .then(function(html) {
-        return fs.writeFile(
-            output,
-            html
-        );
-    });
-};
-
-Generator.prototype.indexPage = function(lexed, pagePath) {
-    this.indexer.add(lexed, pagePath);
-    return Q();
-};
-
-// Convert a markdown file to html
-Generator.prototype.convertFile = function(content, _input) {
-    var that = this;
-    var progress = parse.progress(this.options.navigation, _input);
-
-    _output = _input.replace(".md", ".html");
-    if (_output == "README.html") _output = "index.html";
-
-    var input = path.join(this.options.input, _input);
-    var output = path.join(this.options.output, _output);
-    var basePath = path.relative(path.dirname(output), this.options.output) || ".";
-
-    return Q()
-    .then(function() {
-        // Lex page
-        return parse.lex(content);
-    })
-    .then(function(lexed) {
-        // Index page in search
-        return that.indexPage(lexed, _output)
-        .then(_.constant(lexed));
-    })
-    .then(function(lexed) {
-        // Get HTML generated sections
-        return parse.page(lexed, {
-            repo: that.options.githubId,
-            dir: path.dirname(_input) || '/',
-            outdir: path.dirname(_input) || '/',
-        });
-    })
-    .then(function(sections) {
-        return that._writeTemplate(that.template, {
-            progress: progress,
-
-            _input: _input,
-            content: sections,
-
-            basePath: basePath,
-            staticBase: path.join(basePath, "gitbook"),
-        }, output);
-    });
-};
-
-// Generate languages index
-Generator.prototype.langsIndex = function(langs) {
-    var that = this;
-    var basePath = ".";
-
-    return this._writeTemplate(this.langsTemplate, {
-        langs: langs.list,
-
-        basePath: basePath,
-        staticBase: path.join(basePath, "gitbook"),
-    }, path.join(this.options.output, "index.html"))
-    .then(function() {
-        // Copy assets
-        return that.copyAssets();
-    });
-};
-
-// Copy assets
-Generator.prototype.copyAssets = function() {
-    var that = this;
-
-    return fs.copy(
-        path.join(that.options.theme, "assets"),
-        path.join(that.options.output, "gitbook")
-    );
-};
-
-// Dump search index to disk
-Generator.prototype.writeSearchIndex = function() {
-    return fs.writeFile(
-        path.join(this.options.output, 'search_index.json'),
-        this.indexer.dump()
-    );
-};
-
-Generator.prototype.finish = function() {
-    return this.copyAssets()
-    .then(this.writeSearchIndex);
-};
-
-module.exports = Generator;

lib/generate/site/search_indexer.js

@@ -1,71 +0,0 @@
-var Q = require("q");
-var _ = require("lodash");
-
-var lunr = require('lunr');
-var marked = require('marked');
-var textRenderer = require('marked-text-renderer');
-
-
-function Indexer() {
-    if(!(this instanceof Indexer)) {
-        return new Indexer();
-    }
-
-    _.bindAll(this);
-
-    // Setup lunr index
-    this.idx = lunr(function () {
-        this.ref('url');
-
-        this.field('title', { boost: 10 });
-        this.field('body');
-    });
-
-    this.renderer = textRenderer();
-}
-
-Indexer.prototype.text = function(nodes) {
-    // Copy section
-    var section = _.toArray(nodes);
-
-    // marked's Render expects this, we don't use it yet
-    section.links = {};
-
-    var options = _.extend({}, marked.defaults, {
-        renderer: this.renderer
-    });
-
-    return marked.parser(section, options);
-};
-
-Indexer.prototype.addSection = function(path, section) {
-    var url = [path, section.id].join('#');
-
-    var title = this.text(
-        _.filter(section, {'type': 'heading'})
-    );
-
-    var body = this.text(
-        _.omit(section, {'type': 'heading'})
-    );
-
-    // Add to lunr index
-    this.idx.add({
-        url: url,
-        title: title,
-        body: body,
-    });
-};
-
-Indexer.prototype.add = function(lexedPage, url) {
-    var sections = lexedPage;
-
-    _.map(sections, _.partial(this.addSection, url));
-};
-
-Indexer.prototype.dump = function() {
-    return JSON.stringify(this.idx);
-};
-
-// Exports
-module.exports = Indexer;

lib/generator.js

@@ -0,0 +1,83 @@
+var _ = require("lodash");
+var path = require("path");
+var Q = require("q");
+var fs = require("./utils/fs");
+
+var Plugin = require("./plugin");
+
+var BaseGenerator = function(book) {
+    this.book = book;
+
+    Object.defineProperty(this, "options", {
+        get: function () {
+            return this.book.options;
+        }
+    });
+
+    _.bindAll(this);
+};
+
+BaseGenerator.prototype.callHook = function(name, data) {
+    return this.book.plugins.hook(name, data);
+};
+
+// Prepare the genertor
+BaseGenerator.prototype.prepare = function() {
+    var that = this;
+
+    return that.callHook("init");
+};
+
+// Write a parsed file to the output
+BaseGenerator.prototype.convertFile = function(input) {
+    return Q.reject(new Error("Could not convert "+input));
+};
+
+// Copy file to the output (non parsable)
+BaseGenerator.prototype.transferFile = function(input) {
+    return fs.copy(
+        path.join(this.book.root, input),
+        path.join(this.options.output, input)
+    );
+};
+
+// Copy a folder to the output
+BaseGenerator.prototype.transferFolder = function(input) {
+    return fs.mkdirp(
+        path.join(this.book.options.output, input)
+    );
+};
+
+// Copy the cover picture
+BaseGenerator.prototype.copyCover = function() {
+    var that = this;
+
+    return Q.all([
+        fs.copy(path.join(that.book.root, "cover.jpg"), path.join(that.options.output, "cover.jpg")),
+        fs.copy(path.join(that.book.root, "cover_small.jpg"), path.join(that.options.output, "cover_small.jpg"))
+    ])
+    .fail(function() {
+        // If orignaly from multi-lang, try copy from parent
+        if (!that.isMultilingual()) return;
+
+        return Q.all([
+            fs.copy(path.join(that.book.parentRoot(), "cover.jpg"), path.join(that.options.output, "cover.jpg")),
+            fs.copy(path.join(that.book.parentRoot(), "cover_small.jpg"), path.join(that.options.output, "cover_small.jpg"))
+        ]);
+    })
+    .fail(function(err) {
+        return Q();
+    });
+};
+
+// Generate the langs index
+BaseGenerator.prototype.langsIndex = function(langs) {
+    return Q.reject(new Error("Langs index is not supported in this generator"));
+};
+
+// At teh end of the generation
+BaseGenerator.prototype.finish = function() {
+    return Q.reject(new Error("Could not finish generation"));
+};
+
+module.exports = BaseGenerator;

lib/generators/ebook.js

@@ -0,0 +1,137 @@
+var util = require("util");
+var path = require("path");
+var Q = require("q");
+var _ = require("lodash");
+var exec = require('child_process').exec;
+
+var fs = require("../utils/fs");
+var stringUtils = require("../utils/string");
+var BaseGenerator = require("./website");
+
+var Generator = function(book, format) {
+    BaseGenerator.apply(this, arguments);
+
+    // eBook format
+    this.ebookFormat = format;
+
+    // Resources namespace
+    this.namespace = "ebook";
+
+    // Styles to use
+    this.styles = _.compact(["ebook", this.ebookFormat]);
+
+    // Convert images (svg -> png)
+    this.convertImages = true;
+};
+util.inherits(Generator, BaseGenerator);
+
+Generator.prototype.prepareTemplates = function() {
+    this.templates["page"] = this.book.plugins.template("ebook:page") || path.resolve(this.options.theme, 'templates/ebook/page.html');
+    this.templates["summary"] = this.book.plugins.template("ebook:summary") || path.resolve(this.options.theme, 'templates/ebook/summary.html');
+    this.templates["glossary"] = this.book.plugins.template("ebook:glossary") || path.resolve(this.options.theme, 'templates/ebook/glossary.html');
+
+	return Q();
+};
+
+// Generate table of contents
+Generator.prototype.writeSummary = function() {
+    var that = this;
+
+    that.book.log.info.ln("write SUMMARY.html");
+    return this._writeTemplate(this.templates["summary"], {}, path.join(this.options.output, "SUMMARY.html"));
+};
+
+
+Generator.prototype.langsIndex = function(langs) {
+    return Q();
+};
+
+Generator.prototype.finish = function() {
+    var that = this;
+
+    return BaseGenerator.prototype.finish.apply(this)
+    .then(function() {
+    	return that.writeSummary();
+    })
+    .then(function() {
+        if (!that.ebookFormat) return Q();
+
+        var d = Q.defer();
+
+        if (!that.options.cover && fs.existsSync(path.join(that.options.output, "cover.jpg"))) {
+            that.options.cover = path.join(that.options.output, "cover.jpg");
+        }
+
+        var _options = {
+            "--cover": that.options.cover,
+            "--title": that.options.title,
+            "--comments": that.options.description,
+            "--isbn": that.options.isbn,
+            "--authors": that.options.author,
+            "--publisher": "GitBook",
+            "--chapter": "descendant-or-self::*[contains(concat(' ', normalize-space(@class), ' '), ' book-chapter ')]",
+            "--chapter-mark": "pagebreak",
+            "--page-breaks-before": "/",
+            "--level1-toc": "descendant-or-self::*[contains(concat(' ', normalize-space(@class), ' '), ' book-chapter-1 ')]",
+            "--level2-toc": "descendant-or-self::*[contains(concat(' ', normalize-space(@class), ' '), ' book-chapter-2 ')]",
+            "--level3-toc": "descendant-or-self::*[contains(concat(' ', normalize-space(@class), ' '), ' book-chapter-3 ')]",
+            "--no-chapters-in-toc": true,
+            "--max-levels": "1",
+            "--breadth-first": true
+        };
+
+        if (that.ebookFormat == "pdf") {
+            var pdfOptions = that.options.pdf;
+
+            _.extend(_options, {
+                "--margin-left": String(pdfOptions.margin.left),
+                "--margin-right": String(pdfOptions.margin.right),
+                "--margin-top": String(pdfOptions.margin.top),
+                "--margin-bottom": String(pdfOptions.margin.bottom),
+                "--pdf-default-font-size": String(pdfOptions.fontSize),
+                "--pdf-mono-font-size": String(pdfOptions.fontSize),
+                "--paper-size": String(pdfOptions.paperSize),
+                "--pdf-page-numbers": Boolean(pdfOptions.pageNumbers),
+                "--pdf-header-template": String(pdfOptions.headerTemplate),
+                "--pdf-footer-template": String(pdfOptions.footerTemplate)
+            });
+        }
+
+        var command = [
+            "ebook-convert",
+            path.join(that.options.output, "SUMMARY.html"),
+            path.join(that.options.output, "index."+that.ebookFormat),
+            stringUtils.optionsToShellArgs(_options)
+        ].join(" ");
+
+        that.book.log.info("start conversion to", that.ebookFormat, "....");
+
+        var child = exec(command, function (error, stdout, stderr) {
+            if (error) {
+                that.book.log.info.fail();
+
+                if (error.code == 127) {
+                    error.message = "Need to install ebook-convert from Calibre";
+                } else {
+                    error.message = error.message + " "+stdout;
+                }
+                return d.reject(error);
+            }
+
+            that.book.log.info.ok();
+            d.resolve();
+        });
+
+        child.stdout.on('data', function (data) {
+            that.book.log.debug(data);
+        });
+
+        child.stderr.on('data', function (data) {
+            that.book.log.debug(data);
+        });
+
+        return d.promise;
+    });
+};
+
+module.exports = Generator;

lib/generators/index.js

@@ -0,0 +1,11 @@
+var _ = require("lodash");
+var EbookGenerator = require("./ebook");
+
+module.exports = {
+	json: require("./json"),
+	website: require("./website"),
+	ebook: EbookGenerator,
+	pdf: _.partialRight(EbookGenerator, "pdf"),
+	mobi: _.partialRight(EbookGenerator, "mobi"),
+	epub: _.partialRight(EbookGenerator, "epub")
+};

lib/generators/json.js

@@ -0,0 +1,72 @@
+var util = require("util");
+var path = require("path");
+var Q = require("q");
+var _ = require("lodash");
+
+var fs = require("../utils/fs");
+var BaseGenerator = require("../generator");
+var links = require("../utils/links");
+
+var Generator = function() {
+    BaseGenerator.apply(this, arguments);
+};
+util.inherits(Generator, BaseGenerator);
+
+// Ignore some methods
+Generator.prototype.transferFile = function(input) { };
+Generator.prototype.finish = function() { };
+
+// Convert an input file
+Generator.prototype.convertFile = function(input) {
+    var that = this;
+
+    return that.book.parsePage(input)
+    .then(function(page) {
+        var json = {
+            progress: page.progress,
+            sections: page.sections
+        };
+
+        var output = links.changeExtension(page.path, ".json");
+        output = path.join(that.options.output, output);
+
+        return fs.writeFile(
+            output,
+            JSON.stringify(json, null, 4)
+        );
+    });
+};
+
+// Generate languages index
+// Contains the first languages readme and langs infos
+Generator.prototype.langsIndex = function(langs) {
+    var that = this;
+
+    if (langs.length == 0) return Q.reject("Need at least one language");
+
+    var mainLang = _.first(langs).lang;
+    var readme = links.changeExtension(that.book.readmeFile, ".json");
+
+    return Q()
+    .then(function() {
+        // Read readme from main language
+        return fs.readFile(
+            path.join(that.options.output, mainLang, readme)
+        );
+    })
+    .then(function(content) {
+        // Extend it with infos about the languages
+        var json = JSON.parse(content);
+        _.extend(json, {
+            langs: langs
+        });
+
+        // Write it as README.json
+        return fs.writeFile(
+            path.join(that.options.output, "README.json"),
+            JSON.stringify(json, null, 4)
+        );
+    });
+};
+
+module.exports = Generator;

lib/generators/website.js

@@ -0,0 +1,285 @@
+var util = require("util");
+var path = require("path");
+var Q = require("q");
+var _ = require("lodash");
+
+var nunjucks = require("nunjucks");
+var AutoEscapeExtension = require("nunjucks-autoescape");
+var FilterExtension = require("nunjucks-filter");
+var I18nExtension = require("nunjucks-i18n");
+
+var fs = require("../utils/fs");
+var BaseGenerator = require("../generator");
+var links = require("../utils/links");
+var pageUtil = require("../utils/page");
+
+var pkg = require("../../package.json");
+
+var Generator = function() {
+    BaseGenerator.apply(this, arguments);
+
+    // Revision
+    this.revision = new Date();
+
+    // Resources namespace
+    this.namespace = "website";
+
+    // Style to integrates in the output
+    this.styles = ["website"];
+
+    // Convert images (svg -> png)
+    this.convertImages = false;
+
+    // Templates
+    this.templates = {};
+};
+util.inherits(Generator, BaseGenerator);
+
+// Prepare the genertor
+Generator.prototype.prepare = function() {
+    return BaseGenerator.prototype.prepare.apply(this)
+    .then(this.prepareStyles)
+    .then(this.prepareTemplates)
+    .then(this.prepareTemplateEngine);
+};
+
+// Prepare all styles
+Generator.prototype.prepareStyles = function() {
+    var that = this;
+
+    this.styles = _.chain(this.styles)
+        .map(function(style) {
+            var stylePath = that.options.styles[style];
+            if (fs.existsSync(path.resolve(that.book.root, stylePath))) {
+                return stylePath;
+            }
+            return null;
+        })
+        .compact()
+        .value();
+
+    return Q();
+};
+
+// Prepare templates
+Generator.prototype.prepareTemplates = function() {
+	this.templates["page"] = this.book.plugins.template("site:page") || path.resolve(this.options.theme, 'templates/website/page.html');
+    this.templates["langs"] = this.book.plugins.template("site:langs") || path.resolve(this.options.theme, 'templates/website/langs.html');
+    this.templates["glossary"] = this.book.plugins.template("site:glossary") || path.resolve(this.options.theme, 'templates/website/glossary.html');
+
+	return Q();
+};
+
+// Prepare template engine
+Generator.prototype.prepareTemplateEngine = function() {
+    var that = this;
+
+    return fs.readdir(path.resolve(__dirname, "../../theme/i18n"))
+    .then(function(locales) {
+        var language = that.book.config.normalizeLanguage();
+
+        locales = _.chain(locales)
+            .map(function(local) {
+                local = path.basename(local, ".json");
+                return [local, require("../../theme/i18n/"+local)];
+            })
+            .object()
+            .value();
+
+        if (!_.contains(_.keys(locales), language) && language != "en") {
+            that.book.log.warn.ln("Language '"+language+"' is not available as a layout locales (en, "+_.keys(locales).join(", ")+")");
+        }
+
+        var folders = _.chain(that.templates)
+            .values()
+            .map(path.dirname)
+            .uniq()
+            .value();
+
+        that.env = new nunjucks.Environment(
+            new nunjucks.FileSystemLoader(folders),
+            {
+                autoescape: true
+            }
+        );
+
+        // Add filter
+        that.env.addFilter("contentLink", that.book.contentLink.bind(that.book));
+        that.env.addFilter('lvl', function(lvl) {
+            return lvl.split(".").length;
+        });
+
+        // Add extension
+        that.env.addExtension('AutoEscapeExtension', new AutoEscapeExtension(that.env));
+        that.env.addExtension('FilterExtension', new FilterExtension(that.env));
+        that.env.addExtension('I18nExtension', new I18nExtension({
+            env: that.env,
+            translations: locales,
+            locale: "language"
+        }));
+    });
+};
+
+// Finis generation
+Generator.prototype.finish = function() {
+    return this.copyAssets()
+    .then(this.copyCover)
+    .then(this.writeGlossary)
+    .then(this.writeSearchIndex);
+};
+
+// Convert an input file
+Generator.prototype.convertFile = function(input) {
+    var that = this;
+
+    return that.book.parsePage(input, {
+        convertImages: that.convertImages,
+        interpolateTemplate: function(page) {
+            return that.callHook("page:before", page);
+        },
+        interpolateContent: function(page) {
+            return that.callHook("page", page);
+        }
+    })
+    .then(function(page) {
+        var relativeOutput = that.book.contentLink(page.path);
+        var output = path.join(that.options.output, relativeOutput);
+
+        var basePath = path.relative(path.dirname(output), that.options.output) || ".";
+        if (process.platform === 'win32') basePath = basePath.replace(/\\/g, '/');
+
+        that.book.log.info.ln("write parsed file", page.path, "to", relativeOutput);
+
+        return that._writeTemplate(that.templates["page"], {
+            progress: page.progress,
+
+            _input: page.path,
+            content: page.sections,
+
+            basePath: basePath,
+            staticBase: links.join(basePath, "gitbook")
+        }, output);
+    });
+};
+
+// Write the index for langs
+Generator.prototype.langsIndex = function(langs) {
+    var that = this;
+
+    return this._writeTemplate(this.templates["langs"], {
+        langs: langs
+    }, path.join(this.options.output, "index.html"));
+};
+
+// Write glossary
+Generator.prototype.writeGlossary = function() {
+    var that = this;
+
+    // No glossary
+    if (this.book.glossary.length == 0) return Q();
+
+    return this._writeTemplate(this.templates["glossary"], {}, path.join(this.options.output, "GLOSSARY.html"));
+};
+
+// Write the search index
+Generator.prototype.writeSearchIndex = function() {
+    var that = this;
+
+    return fs.writeFile(
+        path.join(this.options.output, "search_index.json"),
+        JSON.stringify(this.book.searchIndex)
+    );
+};
+
+// Convert a page into a normalized data set
+Generator.prototype.normalizePage  = function(page) {
+    var that = this;
+
+    var _callHook = function(name) {
+        return that.callHook(name, page)
+        .then(function(_page) {
+            page = _page;
+            return page;
+        });
+    };
+
+    return Q()
+    .then(function() {
+        return _callHook("page");
+    })
+    .then(function() {
+        return page;
+    });
+};
+
+// Generate a template
+Generator.prototype._writeTemplate = function(tpl, options, output, interpolate) {
+    var that = this;
+
+    interpolate = interpolate || _.identity;
+    return Q()
+    .then(function(sections) {
+    	return that.env.render(
+    		tpl,
+    		_.extend({
+                gitbook: {
+                    version: pkg.version
+                },
+
+	            styles: that.styles,
+
+	            revision: that.revision,
+
+	            title: that.options.title,
+	            description: that.options.description,
+                language: that.book.config.normalizeLanguage(),
+
+	            glossary: that.book.glossary,
+
+	            summary: that.book.summary,
+	            allNavigation: that.book.navigation,
+
+	            plugins: {
+                    resources: that.book.plugins.resources(that.namespace)
+                },
+	            pluginsConfig: JSON.stringify(that.options.pluginsConfig),
+	            htmlSnippet: _.partial(_.partialRight(that.book.plugins.html, that, options), that.namespace),
+
+	            options: that.options,
+
+                basePath: ".",
+                staticBase: path.join(".", "gitbook"),
+	        }, options)
+	    );
+    })
+    .then(interpolate)
+    .then(function(html) {
+        return fs.writeFile(
+            output,
+            html
+        );
+    });
+};
+
+// Copy assets
+Generator.prototype.copyAssets = function() {
+    var that = this;
+
+    // Copy gitbook assets
+    return fs.copy(
+        path.join(that.options.theme, "assets"),
+        path.join(that.options.output, "gitbook")
+    )
+
+    // Copy plugins assets
+    .then(function() {
+        return Q.all(
+            _.map(that.book.plugins.list, function(plugin) {
+                var pluginAssets = path.join(that.options.output, "gitbook/plugins/", plugin.name);
+                return plugin.copyAssets(pluginAssets, that.namespace);
+            })
+        );
+    });
+};
+
+module.exports = Generator;

lib/index.js

@@ -1,5 +1,210 @@
-module.exports = {
-    parse: require('./parse/'),
-    generate: require('./generate/')
+var Q = require("q");
+var _ = require("lodash");
+var path = require("path");
+var tinylr = require('tiny-lr-fork');
+var color = require('bash-color');
+
+var Book = require("./book");
+var Plugin = require("./plugin");
+var Server = require("./utils/server");
+var stringUtils = require("./utils/string");
+var watch = require("./utils/watch");
+var logger = require("./utils/logger");
+
+var LOG_OPTION = {
+	name: "log",
+	description: "Minimum log level to display",
+	values: _.chain(logger.LEVELS).keys().map(stringUtils.toLowerCase).value(),
+	defaults: "info"
 };
 
+var FORMAT_OPTION = {
+	name: "format",
+	description: "Format to build to",
+	values: ["website", "json", "ebook"],
+	defaults: "website"
+};
+
+module.exports = {
+	Book: Book,
+	LOG_LEVELS: logger.LEVELS,
+
+	commands: _.flatten([
+		{
+			name: "build [book] [output]",
+			description: "build a book",
+			options: [
+				FORMAT_OPTION,
+				LOG_OPTION
+			],
+			exec: function(args, kwargs) {
+				var input = args[0] || process.cwd();
+				var output = args[1] || path.join(input, "_book");
+
+				var book = new Book(input, _.extend({}, {
+					'config': {
+						'output': output
+					},
+					'logLevel': kwargs.log
+				}));
+
+				return book.parse()
+				.then(function() {
+					return book.generate(kwargs.format);
+				})
+				.then(function(){
+					console.log("");
+					console.log(color.green("Done, without error"));
+				});
+			}
+		},
+
+		_.map(["pdf", "epub", "mobi"], function(ebookType) {
+			return {
+				name: ebookType+" [book] [output]",
+				description: "build a book to "+ebookType,
+				options: [
+					LOG_OPTION
+				],
+				exec: function(args, kwargs) {
+					var input = args[0] || process.cwd();
+					var output = args[1];
+
+					var book = new Book(input, _.extend({}, {
+						'logLevel': kwargs.log
+					}));
+
+					return book.parse()
+					.then(function() {
+						return book.generateFile(output, {
+							ebookFormat: ebookType
+						});
+					})
+					.then(function(){
+						console.log("");
+						console.log(color.green("Done, without error"));
+					});
+				}
+			};
+		}),
+
+		{
+			name: "serve [book]",
+			description: "Build then serve a gitbook from a directory",
+			options: [
+				{
+					name: "port",
+					description: "Port for server to listen on",
+					defaults: 4000
+				},
+				{
+					name: "lrport",
+					description: "Port for livereload server to listen on",
+					defaults: 35729
+				},
+				{
+					name: "watch",
+					description: "Enable/disable file watcher",
+					defaults: true
+				},
+				FORMAT_OPTION,
+				LOG_OPTION
+			],
+			exec: function(args, kwargs) {
+				var input = args[0] || process.cwd();
+				var server = new Server();
+
+				// Init livereload server
+				var lrServer = tinylr({});
+				var lrPath = undefined;
+
+				var generate = function() {
+			        if (server.isRunning()) console.log("Stopping server");
+
+			        return server.stop()
+			        .then(function() {
+			        	var book = new Book(input, _.extend({}, {
+							'config': {
+								'defaultsPlugins': ["livereload"]
+							},
+							'logLevel': kwargs.log
+						}));
+
+						return book.parse()
+						.then(function() {
+							return book.generate(kwargs.format);
+						})
+						.thenResolve(book);
+			        })
+			        .then(function(book) {
+			            console.log();
+			            console.log('Starting server ...');
+			            return server.start(book.options.output, kwargs.port)
+			            .then(function() {
+			                console.log('Serving book on http://localhost:'+kwargs.port);
+
+			                if (lrPath) {
+			                	// trigger livereload
+			                	lrServer.changed({
+			                		body: {
+			                			files: [lrPath]
+			                		}
+			                	});
+			                }
+
+			                if (!kwargs.watch) return;
+
+			                return watch(book.root)
+			                .then(function(filepath) {
+			                    // set livereload path
+			                    lrPath = filepath;
+			                    console.log("Restart after change in files");
+			                    console.log('');
+			                    return generate();
+			                })
+			            })
+			        });
+			    };
+
+				return Q.nfcall(lrServer.listen.bind(lrServer), kwargs.lrport)
+				.then(function() {
+					console.log('Live reload server started on port:', kwargs.lrport);
+					console.log('Press CTRL+C to quit ...');
+    				console.log('')
+					return generate();
+				});
+			}
+		},
+
+		{
+			name: "install [book]",
+			description: "install plugins dependencies",
+			exec: function(args, kwargs) {
+				var input = args[0] || process.cwd();
+
+				var book = new Book(input);
+
+				return book.config.load()
+				.then(function() {
+					return book.plugins.install();
+				})
+				.then(function(){
+					console.log("");
+					console.log(color.green("Done, without error"));
+				});
+			}
+		},
+
+		{
+			name: "init [directory]",
+			description: "create files and folders based on contents of SUMMARY.md",
+			exec: function(args, kwargs) {
+				return Book.init(args[0] || process.cwd())
+				.then(function(){
+					console.log("");
+					console.log(color.green("Done, without error"));
+				});
+			}
+		}
+	])
+};

lib/parse/index.js

@@ -1,9 +0,0 @@
-module.exports = {
-    summary: require('./summary'),
-    langs: require('./langs'),
-    page: require('./page'),
-    lex: require('./lex'),
-    progress: require('./progress'),
-    navigation: require('./navigation'),
-    readme: require('./readme')
-};

lib/parse/langs.js

@@ -1,23 +0,0 @@
-var _ = require("lodash")
-var parseSummary = require("./summary");
-
-var parseLangs = function(content) {
-    var summary = parseSummary(content);
-
-    return {
-        list: _.chain(summary.chapters)
-            .filter(function(entry) {
-                return entry.path != null;
-            })
-            .map(function(entry) {
-                return {
-                    title: entry.title,
-                    path: entry.path,
-                    lang: entry.path.replace("/", "")
-                };
-            })
-            .value()
-    }
-};
-
-module.exports = parseLangs;

lib/parse/lex.js

@@ -1,125 +0,0 @@
-var _ = require('lodash');
-var marked = require('marked');
-
-// Split a page up into sections (lesson, exercises, ...)
-function splitSections(nodes) {
-    var section = [];
-
-    return _.reduce(nodes, function(sections, el) {
-        if(el.type === 'hr') {
-            sections.push(section);
-            section = [];
-        } else {
-            section.push(el);
-        }
-
-        return sections;
-    }, []).concat([section]); // Add remaining nodes
-}
-
-function isQuizNode(node) {
-    return (/^[(\[][ x][)\]]/).test(node.text || node);
-}
-
-function isExercise(nodes) {
-    var codeType = { type: 'code' };
-
-    // Number of code nodes in section
-    var len = _.filter(nodes, codeType).length;
-
-    return (
-        // Got 3 or 4 code blocks
-        (len === 3 || len === 4) &&
-        // Ensure all nodes are at the end
-        _.all(_.last(nodes, len), codeType)
-    );
-}
-
-function isQuiz(nodes) {
-    if (nodes.length < 3) {
-        return false;
-    }
-
-    // Support having a first paragraph block
-    // before our series of questions
-    var quizNodes = nodes.slice(nodes[0].type === 'paragraph' ? 1 : 0);
-
-    // No questions
-    if (!_.some(quizNodes, { type: 'blockquote_start' })) {
-        return false;
-    }
-
-    // Check if section has list of questions
-    // or table of questions
-    var listIdx = _.findIndex(quizNodes, { type: 'list_item_start' });
-    var tableIdx = _.findIndex(quizNodes, { type: 'table' });
-
-    if(
-        // List of questions
-        listIdx !== -1 && isQuizNode(quizNodes[listIdx + 1]) ||
-
-        // Table of questions
-        (
-            tableIdx !== -1 &&
-            _.every(quizNodes[tableIdx].cells[0].slice(1), isQuizNode)
-        )
-    ) {
-        return true;
-    }
-
-    return false;
-}
-
-// What is the type of this section
-function sectionType(nodes, idx) {
-    if(isExercise(nodes)) {
-        return 'exercise';
-    } else if(isQuiz(nodes)) {
-        return 'quiz';
-    }
-
-    return 'normal';
-}
-
-// Generate a uniqueId to identify this section in our code
-function sectionId(section, idx) {
-    return _.uniqueId('gitbook_');
-}
-
-function lexPage(src) {
-    // Lex file
-    var nodes = marked.lexer(src);
-
-    return _.chain(splitSections(nodes))
-    .map(function(section, idx) {
-        // Detect section type
-        section.type = sectionType(section, idx);
-        return section;
-    })
-    .map(function(section, idx) {
-        // Give each section an ID
-        section.id = sectionId(section, idx);
-        return section;
-
-    })
-    .filter(function(section) {
-        return !_.isEmpty(section);
-    })
-    .reduce(function(sections, section) {
-        var last = _.last(sections);
-
-        // Merge normal sections together
-        if(last && last.type === section.type && last.type === 'normal') {
-            last.push.apply(last, [{'type': 'hr'}].concat(section));
-        } else {
-            // Add to list of sections
-            sections.push(section);
-        }
-
-        return sections;
-    }, [])
-    .value();
-}
-
-// Exports
-module.exports = lexPage;

lib/parse/navigation.js

@@ -1,89 +0,0 @@
-var _ = require('lodash');
-
-// Cleans up an article/chapter object
-// remove 'articles' attributes
-function clean(obj) {
-    return obj && _.omit(obj, ['articles']);
-}
-
-// Returns from a summary a map of
-/*
-    {
-        "file/path.md": {
-            prev: ...,
-            next: ...,
-        },
-        ...
-    }
-*/
-function navigation(summary, files) {
-    // Support single files as well as list
-    files = _.isArray(files) ? files : (_.isString(files) ? [files] : null);
-
-    // Mapping of prev/next for a give path
-    var mapping = {};
-
-    // Special README nav
-    var README_NAV = {
-        path: 'README.md',
-        title: 'Introduction',
-    };
-
-    // Walk the chapter/article tree and create navigation entires
-    _.each(summary.chapters, function(chapter, idx, chapters) {
-        // Skip if no path
-        if(!chapter.path) return;
-
-        var currentChapter = clean(chapter);
-        var prevChapter = (idx-1 < 0) ? README_NAV : chapters[idx-1];
-        var nextChapter = (idx+1 >= chapters.length) ? null : chapters[idx+1];
-
-        var prev = (!prevChapter || _.isEmpty(prevChapter.articles)) ?
-            prevChapter : _.last(prevChapter.articles);
-        var next = (!chapter || _.isEmpty(chapter.articles)) ?
-            nextChapter : _.first(chapter.articles);
-
-        // Add chapter mapping
-        mapping[chapter.path] = {
-            title: chapter.title,
-            prev: clean(prev),
-            next: clean(next),
-            level: (idx+1).toString(),
-        };
-
-        // Check a chapter's articles
-        _.each(chapter.articles, function(article, _idx, articles) {
-            // Skip if no path
-            if(!article.path) return;
-
-            var prev = (_idx-1 < 0) ? currentChapter : clean(articles[_idx-1]);
-            var next = (_idx+1 >= articles.length) ? nextChapter : clean(articles[_idx+1]);
-
-            mapping[article.path] = {
-                title: article.title,
-                prev: clean(prev),
-                next: clean(next),
-                level: [idx+1, _idx+1].join('.'),
-            };
-        });
-    });
-
-    // Hack for README.html
-    mapping['README.md'] = {
-        title: README_NAV.title,
-        prev: null,
-        next: clean(summary.chapters[0]),
-        level: '0',
-    };
-
-    // Filter for only files we want
-    if(files) {
-        return _.pick(mapping, files);
-    }
-
-    return mapping;
-}
-
-
-// Exports
-module.exports = navigation;

lib/parse/page.js

@@ -1,156 +0,0 @@
-var _ = require('lodash');
-var marked = require('marked');
-var hljs = require('highlight.js');
-
-var lex = require('./lex');
-var renderer = require('./renderer');
-
-var lnormalize = require('../utils/lang').normalize;
-
-
-
-// Render a section using our custom renderer
-function render(section, _options) {
-    // Copy section
-    section = _.toArray(section);
-
-    // marked's Render expects this, we don't use it yet
-    section.links = {};
-
-    // Build options using defaults and our custom renderer
-    var options = _.extend({}, marked.defaults, {
-        renderer: renderer(null, _options),
-
-        // Synchronous highlighting with highlight.js
-        highlight: function (code, lang) {
-            if(!lang) return code;
-
-            // Normalize lang
-            lang = lnormalize(lang);
-
-            try {
-                return hljs.highlight(lang, code).value;
-            } catch(e) { }
-
-            return code;
-        }
-    });
-
-    return marked.parser(section, options);
-}
-
-function quizQuestion(node) {
-    if (node.text) {
-        node.text = node.text.replace(/^([\[(])x([\])])/, "$1 $2");
-    } else {
-        return node.replace(/^([\[(])x([\])])/, "$1 $2");
-    }
-}
-
-function parsePage(src, options) {
-    options = options || {};
-
-    // Lex if not already lexed
-    return (_.isArray(src) ? src : lex(src))
-    .map(function(section) {
-        // Transform given type
-        if(section.type === 'exercise') {
-            var nonCodeNodes = _.reject(section, {
-                'type': 'code'
-            });
-
-            var codeNodes = _.filter(section, {
-                'type': 'code'
-            });
-
-            // Languages in code blocks
-            var langs = _.pluck(codeNodes, 'lang').map(lnormalize);
-
-            // Check that they are all the same
-            var validLangs = _.all(_.map(langs, function(lang) {
-                return lang && lang === langs[0];
-            }));
-
-            // Main language
-            var lang = validLangs ? langs[0] : null;
-
-            return {
-                id: section.id,
-                type: section.type,
-                content: render(nonCodeNodes),
-                lang: lang,
-                code: {
-                    base: codeNodes[0].text,
-                    solution: codeNodes[1].text,
-                    validation: codeNodes[2].text,
-                    // Context is optional
-                    context: codeNodes[3] ? codeNodes[3].text : null,
-                }
-            };
-        } else if (section.type === 'quiz') {
-            var quiz = [], question, foundFeedback = false;
-            var nonQuizNodes = section[0].type === 'paragraph' && section[1].type !== 'list_start' ? [section[0]] : [];
-            var quizNodes = section.slice(0);
-            quizNodes.splice(0, nonQuizNodes.length);
-
-            for (var i = 0; i < quizNodes.length; i++) {
-                var node = quizNodes[i];
-
-                if (question && (((node.type === 'list_end' || node.type === 'blockquote_end') && i === quizNodes.length - 1)
-                                 || node.type === 'table' || (node.type === 'paragraph' && !foundFeedback))) {
-                    quiz.push({
-                        base: render(question.questionNodes),
-                        solution: render(question.solutionNodes),
-                        feedback: render(question.feedbackNodes)
-                    });
-                }
-
-                if (node.type === 'table' || (node.type === 'paragraph' && !foundFeedback)) {
-                    question = { questionNodes: [], solutionNodes: [], feedbackNodes: [] };
-                }
-
-                if (node.type === 'blockquote_start') {
-                    foundFeedback = true;
-                } else if (node.type === 'blockquote_end') {
-                    foundFeedback = false;
-                }
-
-                if (node.type === 'table') {
-                    question.solutionNodes.push(_.cloneDeep(node));
-                    node.cells = node.cells.map(function(row) {
-                        return row.map(quizQuestion);
-                    });
-                    question.questionNodes.push(node);
-                } else if (!/blockquote/.test(node.type)) {
-                    if (foundFeedback) {
-                        question.feedbackNodes.push(node);
-                    } else if (node.type === 'paragraph' || node.type === 'text'){
-                        question.solutionNodes.push(_.cloneDeep(node));
-                        quizQuestion(node);
-                        question.questionNodes.push(node);
-                    } else {
-                        question.solutionNodes.push(node);
-                        question.questionNodes.push(node);
-                    }
-                }
-            }
-
-            return {
-                id: section.id,
-                type: section.type,
-                content: render(nonQuizNodes),
-                quiz: quiz
-            };
-        }
-
-        // Render normal pages
-        return {
-            id: section.id,
-            type: section.type,
-            content: render(section, options)
-        };
-    });
-}
-
-// Exports
-module.exports = parsePage;

lib/parse/readme.js

@@ -1,32 +0,0 @@
-var _ = require('lodash');
-var marked = require('marked');
-
-function extractFirstNode(nodes, nType) {
-    return _.chain(nodes)
-    .filter(function(node) {
-        return node.type == nType;
-    })
-    .pluck("text")
-    .first()
-    .value();
-}
-
-
-function parseReadme(src) {
-    var nodes, title, description;
-
-    // Parse content
-    nodes = marked.lexer(src);
-    
-    var title = extractFirstNode(nodes, "heading");
-    var description = extractFirstNode(nodes, "paragraph");
-
-    return {
-        title: title,
-        description: description
-    };
-}
-
-
-// Exports
-module.exports = parseReadme;

lib/parse/renderer.js

@@ -1,115 +0,0 @@
-var url = require('url');
-var inherits = require('util').inherits;
-
-var path = require('path');
-
-var marked = require('marked');
-
-var rendererId = 0;
-
-function GitBookRenderer(options, extra_options) {
-    if(!(this instanceof GitBookRenderer)) {
-        return new GitBookRenderer(options, extra_options);
-    }
-    GitBookRenderer.super_.call(this, options);
-
-    this._extra_options = extra_options;
-    this.quizRowId = 0;
-    this.id = rendererId++;
-}
-inherits(GitBookRenderer, marked.Renderer);
-
-GitBookRenderer.prototype._unsanitized = function(href) {
-    var prot = '';
-    try {
-        prot = decodeURIComponent(unescape(href))
-            .replace(/[^\w:]/g, '')
-            .toLowerCase();
-
-    } catch (e) {
-        return true;
-    }
-
-    if(prot.indexOf('javascript:') === 0) {
-        return true;
-    }
-
-    return false;
-};
-
-GitBookRenderer.prototype.link = function(href, title, text) {
-    // Don't build if it looks malicious
-    if (this.options.sanitize && this._unsanitized(href)) {
-        return '';
-    }
-
-    // Parsed version of the url
-    var parsed = url.parse(href);
-
-    var o = this._extra_options;
-    // Relative link, rewrite it to point to github repo
-    if(!parsed.protocol && parsed.path && parsed.path[0] != '/' && o && o.repo && o.dir) {
-        href = url.resolve('https://github.com/' + o.repo + '/blob/', [o.dir, href].join("/"));
-        parsed = url.parse(href);
-    }
-
-    // Generate HTML for link
-    var out = '<a href="' + parsed.href + '"';
-    // Title if no null
-    if (title) {
-        out += ' title="' + title + '"';
-    }
-    // Target blank if external
-    if(parsed.protocol) {
-        out += ' target="_blank"';
-    }
-    out += '>' + text + '</a>';
-    return out;
-};
-
-GitBookRenderer.prototype.image = function(href, title, text) {
-    // Our "fixed" href
-    var _href = href;
-
-    // Parsed version of the url
-    var parsed = url.parse(href);
-
-    // Options
-    var o = this._extra_options;
-
-    // Relative image, rewrite it depending output
-    if(!parsed.protocol && parsed.path && parsed.path[0] != '/' && o && o.dir && o.outdir) {
-        var outdir = o.outdir.charAt(o.outdir.length - 1) === '/' ? o.outdir : o.outdir + '/';
-        _href = url.resolve(outdir, [o.dir, href].join('/'));
-    }
-
-    return GitBookRenderer.super_.prototype.image.call(this, _href, title, text);
-};
-
-GitBookRenderer.prototype.tablerow = function(content) {
-    this.quizRowId += 1;
-    return GitBookRenderer.super_.prototype.tablerow(content);
-};
-
-var fieldRegex = /^([(\[])([ x])[\])]/;
-GitBookRenderer.prototype._createCheckboxAndRadios = function(text) {
-    var match = fieldRegex.exec(text);
-    if (!match) {
-        return text;
-    }
-    var field = "<input name='quiz-row-" + this.id + "-" + this.quizRowId + "' type='";
-    field += match[1] === '(' ? "radio" : "checkbox";
-    field += match[2] === 'x' ? "' checked/>" : "'/>";
-    return text.replace(fieldRegex, field);
-}
-
-GitBookRenderer.prototype.tablecell = function(content, flags) {
-    return GitBookRenderer.super_.prototype.tablecell(this._createCheckboxAndRadios(content), flags);
-};
-
-GitBookRenderer.prototype.listitem = function(text) {
-    return GitBookRenderer.super_.prototype.listitem(this._createCheckboxAndRadios(text));
-};
-
-// Exports
-module.exports = GitBookRenderer;

lib/parse/summary.js

@@ -1,117 +0,0 @@
-var _ = require('lodash');
-var marked = require('marked');
-
-
-// Utility function for splitting a list into groups
-function splitBy(list, starter, ender) {
-    var starts = 0;
-    var ends = 0;
-    var group = [];
-
-    // Groups
-    return _.reduce(list, function(groups, value) {
-        // Ignore start and end delimiters in resulted groups
-        if(starter(value)) {
-            starts++;
-        } else if(ender(value)) {
-            ends++;
-        }
-
-        // Add current value to group
-        group.push(value);
-
-        // We've got a matching
-        if(starts === ends && starts !== 0) {
-            // Add group to end groups
-            // (remove starter and ender token)
-            groups.push(group.slice(1, -1));
-
-            // Reset group
-            group = [];
-        }
-
-        return groups;
-    }, []);
-}
-
-function listSplit(nodes, start_type, end_type) {
-    return splitBy(nodes, function(el) {
-        return el.type === start_type;
-    }, function(el) {
-        return el.type === end_type;
-    });
-}
-
-// Get the biggest list
-// out of a list of marked nodes
-function filterList(nodes) {
-    return _.chain(nodes)
-    .toArray()
-    .rest(function(el) {
-        // Get everything after list_start
-        return el.type !== 'list_start';
-    })
-    .reverse()
-    .rest(function(el) {
-        // Get everything after list_end (remember we're reversed)
-        return el.type !== 'list_end';
-    })
-    .reverse()
-    .value().slice(1, -1);
-}
-
-// Parses an Article or Chapter title
-// supports extracting links
-function parseTitle(src, nums) {
-    // Check if it's a link
-    var matches = marked.InlineLexer.rules.link.exec(src);
-
-    var level = nums.join('.');
-
-    // Not a link, return plain text
-    if(!matches) {
-        return {
-            title: src,
-            level: level,
-            path: null,
-        };
-    }
-
-    return {
-        title: matches[1],
-        level: level,
-
-        // Replace .md references with .html
-        path: matches[2],
-    };
-}
-
-function parseArticle(chapterNum, nodes, idx) {
-    return parseTitle(_.first(nodes).text, [chapterNum, idx+1]);
-}
-
-function parseChapter(nodes, idx) {
-    return _.extend(parseTitle(_.first(nodes).text, [idx+1]), {
-        articles: _.map(listSplit(filterList(nodes), 'list_item_start', 'list_item_end'), parseArticle.bind(null, idx+1))
-    });
-}
-
-function parseSummary(src) {
-    var nodes = marked.lexer(src);
-
-    // Get out list of chapters
-    var chapterList = filterList(nodes);
-
-    // Split out chapter sections
-    var chapters = _.chain(listSplit(chapterList, 'list_item_start', 'list_item_end'))
-    .map(parseChapter)
-    .value();
-
-    return {
-        chapters: chapters
-    };
-}
-
-
-// Exports
-module.exports = parseSummary;

lib/plugin.js

@@ -0,0 +1,180 @@
+var _ = require("lodash");
+var Q = require("q");
+var semver = require("semver");
+var path = require("path");
+var url = require("url");
+var fs = require("./utils/fs");
+var resolve = require('resolve');
+
+var pkg = require("../package.json");
+
+var Plugin = function(book, name) {
+    this.book = book;
+    this.name = name;
+    this.packageInfos = {};
+    this.infos = {};
+
+    // Bind methods
+    _.bindAll(this);
+
+    _.each([
+        "gitbook-plugin-"+name,
+        "gitbook-"+name,
+        name,
+    ], function(_name) {
+        if (this.load(_name, __dirname)) return false;
+        if (this.load(_name, book.root)) return false;
+    }, this);
+};
+
+// Type of plugins resources
+Plugin.RESOURCES = ["js", "css"];
+Plugin.HOOKS = [
+    "init", "finish"
+]
+
+// Load from a name
+Plugin.prototype.load = function(name, baseDir) {
+    try {
+        var res = resolve.sync(name+"/package.json", { basedir: baseDir });
+
+        this.baseDir = path.dirname(res);
+        this.packageInfos = require(res);
+        this.infos = require(resolve.sync(name, { basedir: baseDir }));
+        this.name = name;
+
+        return true;
+    } catch (e) {
+        this.packageInfos = {};
+        this.infos = {};
+        return false;
+    }
+};
+
+Plugin.prototype.normalizeResource = function(resource) {
+    // Parse the resource path
+    var parsed = url.parse(resource);
+
+    // This is a remote resource
+    // so we will simply link to using it's URL
+    if (parsed.protocol) {
+        return {
+            "url": resource
+        };
+    }
+
+    // This will be copied over from disk
+    // and shipped with the book's build
+    return { "path": this.name+"/"+resource };
+};
+
+// Return resources
+Plugin.prototype._getResources = function(base) {
+    base = base;
+    var book = this.infos[base];
+
+    // Compatibility with version 1.x.x
+    if (base == "website") book = book || this.infos["book"];
+
+    // Nothing specified, fallback to default
+    if (!book) {
+        return Q({});
+    }
+
+    // Dynamic function
+    if(typeof book === "function") {
+        // Call giving it the context of our book
+        return Q().then(book.bind(this.book));
+    }
+
+    // Plain data object
+    return Q(_.cloneDeep(book));
+};
+
+// Normalize resources and return them
+Plugin.prototype.getResources = function(base) {
+    var that = this;
+
+    return this._getResources(base)
+    .then(function(resources) {
+
+        _.each(Plugin.RESOURCES, function(resourceType) {
+            resources[resourceType] = (resources[resourceType] || []).map(that.normalizeResource);
+        });
+
+        return resources;
+    });
+};
+
+// Normalize filters and return them
+Plugin.prototype.getFilters = function() {
+    return this.infos.filters || {};
+};
+
+// Normalize blocks and return them
+Plugin.prototype.getBlocks = function() {
+    return this.infos.blocks || {};
+};
+
+// Test if it's a valid plugin
+Plugin.prototype.isValid = function() {
+    var that = this;
+    var isValid = (
+        this.packageInfos &&
+        this.packageInfos.name &&
+        this.packageInfos.engines &&
+        this.packageInfos.engines.gitbook &&
+        semver.satisfies(pkg.version, this.packageInfos.engines.gitbook)
+    );
+
+    // Valid hooks
+    _.each(this.infos.hooks, function(hook, hookName) {
+        if (_.contains(Plugin.HOOKS, hookName)) return;
+        that.book.log.warn.ln("Hook '"+hookName+" 'used by plugin '"+that.packageInfos.name+"' has been removed or is deprecated");
+    });
+
+    return isValid;
+};
+
+// Resolve file path
+Plugin.prototype.resolveFile = function(filename) {
+    return path.resolve(this.baseDir, filename);
+};
+
+// Resolve file path
+Plugin.prototype.callHook = function(name, data) {
+    // Our book will be the context to apply
+    var context = this.book;
+
+    var hookFunc = this.infos.hooks? this.infos.hooks[name] : null;
+    data = data || {};
+
+    if (!hookFunc) return Q(data);
+
+    this.book.log.debug.ln("call hook", name);
+    if (!_.contains(Plugin.HOOKS, name)) this.book.log.warn.ln("hook '"+name+"' used by plugin '"+this.name+"' is deprecated, and will be remove in the coming versions");
+
+    return Q()
+    .then(function() {
+        return hookFunc.apply(context, [data]);
+    });
+};
+
+// Copy plugin assets fodler
+Plugin.prototype.copyAssets = function(out, base) {
+    var that = this;
+
+    return this.getResources(base)
+    .get('assets')
+    .then(function(assets) {
+        // Assets are undefined
+        if(!assets) return false;
+
+        return fs.copy(
+            that.resolveFile(assets),
+            out
+        ).then(_.constant(true));
+    }, _.constant(false));
+};
+
+module.exports = Plugin;

lib/pluginslist.js

@@ -0,0 +1,225 @@
+var _ = require("lodash");
+var Q = require("q");
+var npmi = require('npmi');
+var npm = require('npm');
+var semver = require('semver');
+
+var Plugin = require("./plugin");
+var pkg = require("../package.json");
+
+var initNPM = _.memoize(function() {
+	return Q.nfcall(npm.load, { silent: true, loglevel: 'silent' });
+});
+
+
+var PluginsList = function(book, plugins) {
+	this.book = book;
+	this.log = this.book.log;
+
+	// List of Plugin objects
+	this.list = [];
+
+	// List of names of failed plugins
+	this.failed = [];
+
+	// Namespaces
+	this.namespaces = _.chain(["website", "ebook"])
+		.map(function(namespace) {
+			return [
+				namespace,
+				{
+					html: {},
+					resources: _.chain(Plugin.RESOURCES)
+						.map(function(type) {
+							return [type, []];
+						})
+						.object()
+						.value()
+				}
+			];
+		})
+		.object()
+		.value();
+
+	// Bind methods
+	_.bindAll(this);
+
+	if (plugins) this.load(plugins);
+};
+
+// return count of plugins
+PluginsList.prototype.count = function() {
+	return this.list.length;
+};
+
+// Add and load a plugin
+PluginsList.prototype.load = function(plugin, options) {
+	var that = this;
+
+	if (_.isArray(plugin)) {
+		return _.reduce(plugin, function(prev, p) {
+			return prev.then(function() {
+				return that.load(p);
+			});
+		}, Q());
+	}
+	if (_.isObject(plugin) && !(plugin instanceof Plugin)) plugin = plugin.name;
+	if (_.isString(plugin)) plugin = new Plugin(this.book, plugin);
+
+	that.log.info("load plugin", plugin.name, "....");
+	if (!plugin.isValid()) {
+    	that.log.info.fail();
+    	that.failed.push(plugin.name);
+    	return Q();
+    } else {
+    	that.log.info.ok();
+
+    	// Push in the list
+    	that.list.push(plugin);
+    }
+
+	// Extract filters
+	_.each(plugin.getFilters(), function(filterFunc, filterName) {
+        that.book.template.addFilter(filterName, filterFunc);
+    });
+
+    // Extract blocks
+	_.each(plugin.getBlocks(), function(block, blockName) {
+        that.book.template.addBlock(blockName, block);
+    });
+
+	return _.reduce(_.keys(that.namespaces), function(prev, namespaceName) {
+		return prev.then(function() {
+			return plugin.getResources(namespaceName)
+			.then(function(plResources) {
+				var namespace = that.namespaces[namespaceName];
+
+				// Extract js and css
+				_.each(Plugin.RESOURCES, function(resourceType) {
+					namespace.resources[resourceType] = (namespace.resources[resourceType] || []).concat(plResources[resourceType] || []);
+				});
+
+		        // Map of html resources by name added by each plugin
+		        _.each(plResources.html || {}, function(value, tag) {
+		        	// Turn into function if not one already
+		           	if (!_.isFunction(value)) value = _.constant(value);
+
+		        	namespace.html[tag] = namespace.html[tag] || [];
+		        	namespace.html[tag].push(value);
+		        });
+			})
+		});
+	}, Q());
+};
+
+// Call a hook
+PluginsList.prototype.hook = function(name, data) {
+	return _.reduce(this.list, function(prev, plugin) {
+        return prev.then(function(ret) {
+            return plugin.callHook(name, ret);
+        });
+    }, Q(data));
+};
+
+// Return a template from a plugin
+PluginsList.prototype.template = function(name) {
+	var withTpl = _.find(this.list, function(plugin) {
+        return (
+            plugin.infos.templates &&
+            plugin.infos.templates[name]
+        );
+    });
+
+    if (!withTpl) return null;
+    return withTpl.resolveFile(withTpl.infos.templates[name]);
+};
+
+// Return an html snippet
+PluginsList.prototype.html = function(namespace, tag, context, options) {
+	var htmlSnippets = this.namespaces[namespace].html[tag];
+    return _.map(htmlSnippets || [], function(code) {
+        return code.call(context, options);
+    }).join("\n");
+};
+
+// Return a resources map for a namespace
+PluginsList.prototype.resources = function(namespace) {
+	return this.namespaces[namespace].resources;
+};
+
+// Install plugins from a book
+PluginsList.prototype.install = function() {
+	var that = this;
+	var defaultsPlugins = _.pluck(that.book.options.defaultsPlugins)
+
+    // Remove defaults (no need to install)
+    var plugins = _.filter(that.book.options.plugins, function(plugin) {
+        return !_.contains(defaultsPlugins, plugin.name);
+    });
+
+    // Install plugins one by one
+    that.book.log.info.ln(plugins.length+" plugins to install");
+    return _.reduce(plugins, function(prev, plugin) {
+        return prev.then(function() {
+            var fullname = "gitbook-plugin-"+plugin.name;
+
+            return Q()
+
+            // Resolve version if needed
+            .then(function() {
+            	if (plugin.version) return plugin.version;
+
+            	that.book.log.info.ln("No version specified, resolve plugin", plugin.name);
+            	return initNPM()
+            	.then(function() {
+            		return Q.nfcall(npm.commands.view, [fullname+"@*", "engines"], true);
+            	})
+            	.then(function(versions) {
+            		return _.chain(versions)
+            			.pairs()
+            			.map(function(v) {
+            				return {
+            					version: v[0],
+            					gitbook: (v[1].engines || {})["gitbook"]
+            				}
+            			})
+            			.filter(function(v) {
+            				return v.gitbook && semver.satisfies(pkg.version, v.gitbook);
+            			})
+            			.sort(function(v1, v2) {
+            				return semver.lt(v1.version, v2.version)? 1 : -1;
+            			})
+            			.pluck("version")
+            			.first()
+            			.value();
+            	});
+            })
+
+            // Install the plugin with the resolved version
+            .then(function(version) {
+            	if (!version) {
+            		throw "Found no satisfactory version for plugin "+plugin.name;
+            	}
+
+            	that.book.log.info.ln("install plugin", plugin.name, "from npm ("+fullname+") with version", version);
+	            return Q.nfcall(npmi, {
+	                'name': fullname,
+	                'version': version,
+	                'path': that.book.root,
+	                'npmLoad': {
+	                    'loglevel': 'silent',
+	                    'loaded': true,
+	                    'prefix': that.book.root
+	                }
+	            });
+            })
+            .then(function() {
+                that.book.log.info.ok("plugin", plugin.name, "installed with success");
+            });
+        });
+    }, Q());
+};
+
+
+
+module.exports = PluginsList;

lib/template.js

@@ -0,0 +1,370 @@
+var _ = require("lodash");
+var Q = require("q");
+var path = require("path");
+var nunjucks = require("nunjucks");
+
+var git = require("./utils/git");
+var stringUtils = require("./utils/string");
+var fs = require("./utils/fs");
+var pkg = require("../package.json");
+
+
+// The loader should handle relative and git url
+var BookLoader = nunjucks.Loader.extend({
+	async: true,
+
+    init: function(book) {
+    	this.book = book;
+    },
+
+    getSource: function(fileurl, callback) {
+    	var that = this;
+
+		git.resolveFile(fileurl)
+		.then(function(filepath) {
+			// Is local file
+			if (!filepath) filepath = path.resolve(that.book.root, fileurl);
+			else that.book.log.debug.ln("resolve from git", fileurl, "to", filepath)
+
+			//  Read file from absolute path
+			return fs.readFile(filepath)
+    		.then(function(source) {
+    			return {
+    				src: source.toString(),
+    				path: filepath
+    			}
+    		});
+		})
+		.nodeify(callback);
+    },
+
+    resolve: function(from, to) {
+        return path.resolve(path.dirname(from), to);
+    }
+});
+
+
+var TemplateEngine = function(book) {
+	this.book = book;
+    this.log = this.book.log;
+
+	// Nunjucks env
+	this.env = new nunjucks.Environment(
+		new BookLoader(book),
+		{
+			// Escaping is done after by the markdown parser
+			autoescape: false,
+
+			// Tags
+			tags: {
+				blockStart: '{%',
+				blockEnd: '%}',
+				variableStart: '{{',
+				variableEnd: '}}',
+				commentStart: '{###',
+				commentEnd: '###}'
+			}
+		}
+	);
+
+    // List of tags shortcuts
+    this.shortcuts = [];
+
+    // Map of blocks
+    this.blocks = {};
+
+    // Bind methods
+    _.bindAll(this);
+
+    // Default block "html" that return html not parsed
+    this.addBlock("html", {
+        process: _.identity
+    });
+};
+
+// Process a block in a context
+TemplateEngine.prototype.processBlock = function(blk) {
+    if (_.isString(blk)) blk = { body: blk };
+
+    blk = _.defaults(blk, {
+        parse: false
+    });
+    blk.id = _.uniqueId("blk");
+
+    //Parsable block, just return it
+    if (blk.parse) {
+        return blk.body;
+    }
+
+    // Add to global map
+    this.blocks[blk.id] = blk;
+
+    // Return it as a macro
+    return "%+%"+blk.id+"%+%";
+};
+
+// Replace blocks by body after processing
+// This is done to avoid that markdown processer parse the block content
+TemplateEngine.prototype.replaceBlocks = function(content) {
+    var that = this;
+
+    return content.replace(/\%\+\%([\s\S]+?)\%\+\%/g, function(match, key) {
+        var blk = that.blocks[key];
+        if (!blk) return match;
+
+        var body = blk.body;
+
+        // Remove it from map
+        delete that.blocks[key];
+
+        return body;
+    });
+};
+
+// Bind a function to a context
+TemplateEngine.prototype.bindContext = function(func) {
+    var that = this;
+
+    return function() {
+        var ctx = {
+            ctx: this.ctx,
+            book: that.book,
+            generator: that.book.options.generator
+        };
+
+        return func.apply(ctx, arguments);
+    };
+};
+
+// Add filter
+TemplateEngine.prototype.addFilter = function(filterName, func) {
+    try {
+        this.env.getFilter(filterName);
+        this.log.warn.ln("conflict in filters, '"+filterName+"' is already set");
+        return false;
+    } catch(e) {}
+
+    this.log.debug.ln("add filter '"+filterName+"'");
+    this.env.addFilter(filterName, this.bindContext(function() {
+        var ctx = this;
+        var args = Array.prototype.slice.apply(arguments);
+        var callback = _.last(args);
+
+        Q()
+        .then(function() {
+            return func.apply(ctx, args.slice(0, -1));
+        })
+        .nodeify(callback);
+    }), true);
+    return true;
+};
+
+// Add a block
+TemplateEngine.prototype.addBlock = function(name, block) {
+    var that = this;
+
+    block = _.defaults(block || {}, {
+        shortcuts: [],
+        end: "end"+name,
+        process: _.identity,
+        blocks: []
+    });
+
+    var extName = 'Block'+name+'Extension';
+    if (this.env.getExtension(extName)) {
+        this.log.warn.ln("conflict in blocks, '"+name+"' is already defined");
+        return false;
+    }
+
+    this.log.debug.ln("add block '"+name+"'");
+
+    var Ext = function () {
+        this.tags = [name];
+
+        this.parse = function(parser, nodes, lexer) {
+            var body = null;
+            var lastBlockName = null;
+            var lastBlockArgs = null;
+            var allBlocks = block.blocks.concat([block.end]);
+            var subbodies = {};
+
+            var tok = parser.nextToken();
+            var args = parser.parseSignature(null, true);
+            parser.advanceAfterBlockEnd(tok.value);
+
+            while (1) {
+                // Read body
+                var currentBody = parser.parseUntilBlocks.apply(parser, allBlocks);
+
+                // Handle body with previous block name and args
+                if (lastBlockName) {
+                    subbodies[lastBlockName] = subbodies[lastBlockName] || [];
+                    subbodies[lastBlockName].push({
+                        body: currentBody,
+                        args: lastBlockArgs
+                    });
+                } else {
+                    body = currentBody;
+                }
+
+                // Read new block
+                lastBlockName = parser.peekToken().value;
+                if (lastBlockName == block.end) {
+                    break;
+                }
+
+                // Parse signature and move to the end of the block
+                lastBlockArgs = parser.parseSignature(null, true);
+                parser.advanceAfterBlockEnd(lastBlockName);
+            }
+            parser.advanceAfterBlockEnd();
+
+            var bodies = [body];
+            _.each(block.blocks, function(blockName) {
+                subbodies[blockName] = subbodies[blockName] || [];
+                if (subbodies[blockName].length == 0) {
+                    subbodies[blockName].push({
+                        args: new nodes.NodeList(),
+                        body: new nodes.NodeList()
+                    });
+                }
+
+                bodies.push(subbodies[blockName][0].body);
+            });
+
+            return new nodes.CallExtensionAsync(this, 'run', args, bodies);
+        };
+
+        this.run = function(context) {
+            var args = Array.prototype.slice.call(arguments, 1);
+            var callback = args.pop();
+
+            // Extract blocks body
+            var _blocks =  _.chain(block.blocks)
+                .reverse()
+                .map(function(blockName){
+                    return {
+                        name: blockName,
+                        body: args.pop()()
+                    };
+                })
+                .reverse()
+                .value();
+
+            var body = args.pop();
+            var kwargs = args.pop() || {};
+
+
+            var func = that.bindContext(block.process);
+
+            Q()
+            .then(function() {
+                return func.call(context, {
+                    body: body(),
+                    args: args,
+                    kwargs: kwargs,
+                    blocks: _blocks
+                });
+            })
+
+            // process the block returned
+            .then(that.processBlock)
+            .nodeify(callback)
+        };
+    };
+
+
+    // Add the Extension
+    this.env.addExtension(extName, new Ext());
+
+    // Add shortcuts
+    if (!_.isArray(block.shortcuts)) block.shortcuts = [block.shortcuts];
+    _.each(block.shortcuts, function(shortcut) {
+        this.log.debug.ln("add template shortcut from '"+shortcut.start+"' to block '"+name+"' for parsers ", shortcut.parsers);
+        this.shortcuts.push({
+            parsers: shortcut.parsers,
+            start: shortcut.start,
+            end: shortcut.end,
+            tag: {
+                start: name,
+                end: block.end
+            }
+        });
+    }, this);
+};
+
+// Apply a shortcut to a string
+TemplateEngine.prototype._applyShortcut = function(parser, content, shortcut) {
+    if (!_.contains(shortcut.parsers, parser)) return content;
+    var regex = new RegExp(
+        stringUtils.escapeRegex(shortcut.start) + "([\\s\\S]*?[^\\$])" + stringUtils.escapeRegex(shortcut.end),
+       'g'
+    );
+    return content.replace(regex, function(all, match) {
+        return "{% "+shortcut.tag.start+" %}"+ match + "{% "+shortcut.tag.end+" %}";
+    });
+};
+
+// Render a string from the book
+TemplateEngine.prototype.renderString = function(content, context, options) {
+    var context = _.extend({}, context, {
+        // Variables from book.json
+        book: this.book.options.variables,
+
+        // infos about gitbook
+        gitbook: {
+            version: pkg.version
+        }
+    });
+    options = _.defaults(options || {}, {
+        path: null,
+        type: null
+    });
+    if (options.path) options.path = this.book.resolve(options.path);
+
+    // Replace shortcuts
+    content = _.reduce(this.shortcuts, _.partial(this._applyShortcut.bind(this), options.type), content);
+
+    return Q.nfcall(this.env.renderString.bind(this.env), content, context, options);
+};
+
+// Render a file from the book
+TemplateEngine.prototype.renderFile = function(filename, options) {
+	var that = this, context;
+
+    return that.book.readFile(filename)
+    .then(function(content) {
+        return that.renderString(content, {}, {
+            path: filename
+        });
+    });
+};
+
+// Render a page from the book
+TemplateEngine.prototype.renderPage = function(page) {
+    var that = this, context;
+
+    return that.book.statFile(page.path)
+    .then(function(stat) {
+       context = {
+            // infos about the file
+            file: {
+                path: page.path,
+                mtime: stat.mtime
+            }
+        };
+
+        return that.renderString(page.content, context, {
+            path: page.path,
+            type: page.type
+        });
+    });
+};
+
+// Post process content
+TemplateEngine.prototype.postProcess = function(content) {
+    return Q(content)
+    .then(this.replaceBlocks);
+};
+
+module.exports = TemplateEngine;

lib/utils/fs.js

@@ -0,0 +1,178 @@
+var _ = require("lodash");
+var Q = require("q");
+var tmp = require("tmp");
+var path = require("path");
+var fs = require("graceful-fs");
+var fsExtra = require("fs-extra");
+var Ignore = require("fstream-ignore");
+
+var fsUtils = {
+    tmp: {
+        file: function(opt) {
+            return Q.nfcall(tmp.file.bind(tmp), opt).get(0)
+        },
+        dir: function() {
+            return Q.nfcall(tmp.dir.bind(tmp)).get(0)
+        }
+    },
+    list: listFiles,
+    stat: Q.denodeify(fs.stat),
+    readdir: Q.denodeify(fs.readdir),
+    readFile: Q.denodeify(fs.readFile),
+    writeFile: writeFile,
+    writeStream: writeStream,
+    mkdirp: Q.denodeify(fsExtra.mkdirp),
+    copy: Q.denodeify(fsExtra.copy),
+    remove: Q.denodeify(fsExtra.remove),
+    symlink: Q.denodeify(fsExtra.symlink),
+    exists: function(path) {
+        var d = Q.defer();
+        fs.exists(path, d.resolve);
+        return d.promise;
+    },
+    existsSync: fs.existsSync.bind(fs),
+    readFileSync: fs.readFileSync.bind(fs),
+    clean: cleanFolder,
+    getUniqueFilename: getUniqueFilename,
+}
+
+// Write a file
+function writeFile(filename, data, options) {
+    var d = Q.defer();
+
+    try {
+        fs.writeFileSync(filename, data, options)
+    } catch(err) {
+        d.reject(err);
+    }
+    d.resolve();
+
+
+    return d.promise;
+}
+
+// Write a stream to a file
+function writeStream(filename, st) {
+    var d = Q.defer();
+
+    var wstream = fs.createWriteStream(filename);
+
+    wstream.on('finish', function () {
+        d.resolve();
+    });
+    wstream.on('error', function (err) {
+        d.reject(err);
+    });
+
+    st.pipe(wstream);
+
+    return d.promise;
+}
+
+// Find a filename available
+function getUniqueFilename(base, filename) {
+    if (!filename) {
+        filename = base;
+        base = "/";
+    }
+
+    filename = path.resolve(base, filename);
+    var ext = path.extname(filename);
+    filename = path.join(path.dirname(filename), path.basename(filename, ext));
+
+    var _filename = filename+ext;
+
+    var i = 0;
+    while (1) {
+        if (!fs.existsSync(filename)) break;
+        _filename = filename+"_"+i+ext;
+        i = i + 1;
+    }
+
+    return path.relative(base, _filename);
+}
+
+
+// List files in a directory
+function listFiles(root, options) {
+    options = _.defaults(options || {}, {
+        ignoreFiles: [],
+        ignoreRules: []
+    });
+
+    var d = Q.defer();
+
+    // Our list of files
+    var files = [];
+
+    var ig = Ignore({
+        path: root,
+        ignoreFiles: options.ignoreFiles
+    });
+
+    // Add extra rules to ignore common folders
+    ig.addIgnoreRules(options.ignoreRules, '__custom_stuff');
+
+    // Push each file to our list
+    ig.on('child', function (c) {
+        files.push(
+            c.path.substr(c.root.path.length + 1) + (c.props.Directory === true ? '/' : '')
+        );
+    });
+
+    ig.on('end', function() {
+        // Normalize paths on Windows
+        if(process.platform === 'win32') {
+            return d.resolve(files.map(function(file) {
+                return file.replace(/\\/g, '/');
+            }));
+        }
+
+        // Simply return paths otherwise
+        return d.resolve(files);
+    });
+
+    ig.on('error', d.reject);
+
+    return d.promise;
+}
+
+// Clean a folder without removing .git and .svn
+// Creates it if non existant
+function cleanFolder(root) {
+    if (!fs.existsSync(root)) return fsUtils.mkdirp(root);
+
+    return listFiles(root, {
+        ignoreFiles: [],
+        ignoreRules: [
+            // Skip Git and SVN stuff
+            '.git/',
+            '.svn/'
+        ]
+    })
+    .then(function(files) {
+        var d = Q.defer();
+
+        _.reduce(files, function(prev, file, i) {
+            return prev.then(function() {
+                var _file = path.join(root, file);
+
+                d.notify({
+                    i: i+1,
+                    count: files.length,
+                    file: _file
+                });
+                return fsUtils.remove(_file);
+            });
+        }, Q())
+        .then(function() {
+            d.resolve();
+        }, function(err) {
+            d.reject(err);
+        });
+
+        return d.promise;
+    });
+}
+
+module.exports = fsUtils;

lib/utils/git.js

@@ -0,0 +1,112 @@
+var  Q = require("q");
+var _ = require("lodash");
+var url = require("url");
+var tmp = require("tmp");
+var path = require("path");
+var crc = require("crc");
+var exec = Q.denodeify(require("child_process").exec);
+var URI = require("URIjs");
+
+var fs = require("./fs");
+
+var GIT_PREFIX = "git+";
+var GIT_TMP = null;
+
+
+// Check if an url is a git dependency url
+function checkGitUrl(giturl) {
+	return (giturl.indexOf(GIT_PREFIX) === 0);
+}
+
+// Validates a SHA in hexadecimal
+function validateSha(str) {
+    return (/[0-9a-f]{40}/).test(str);
+}
+
+// Parse and extract infos
+function parseGitUrl(giturl) {
+	var ref, uri, fileParts, filepath;
+
+	if (!checkGitUrl(giturl)) return null;
+	giturl = giturl.slice(GIT_PREFIX.length);
+
+	uri = new URI(giturl);
+	ref = uri.fragment() || "master";
+	uri.fragment(null);
+
+	// Extract file inside the repo (after the .git)
+	fileParts =uri.path().split(".git");
+	filepath = fileParts.length > 1? fileParts.slice(1).join(".git") : "";
+	if (filepath[0] == "/") filepath = filepath.slice(1);
+
+	// Recreate pathname without the real filename
+	uri.path(_.first(fileParts)+".git");
+
+	return {
+		host: uri.toString(),
+		ref: ref || "master",
+		filepath: filepath
+	};
+}
+
+// Clone a git repo from a specific ref
+function cloneGitRepo(host, ref) {
+	var isBranch = false;
+
+	ref = ref || "master";
+	if (!validateSha(ref)) isBranch = true;
+
+	return Q()
+
+	// Create temporary folder to store git repos
+	.then(function() {
+		if (GIT_TMP) return;
+		return fs.tmp.dir()
+			.then(function(_tmp) {
+				GIT_TMP = _tmp;
+			});
+	})
+
+	// Return or clone the git repo
+	.then(function() {
+		// Unique ID for repo/ref combinaison
+		var repoId = crc.crc32(host+"#"+ref).toString(16);
+
+		// Absolute path to the folder
+		var repoPath = path.resolve(GIT_TMP, repoId);
+
+		return fs.exists(repoPath)
+			.then(function(doExists) {
+				if (doExists) return;
+
+				// Clone repo
+				return exec("git clone "+host+" "+repoPath)
+				.then(function() {
+					return exec("git checkout "+ref, { cwd: repoPath });
+				})
+			})
+			.thenResolve(repoPath);
+	});
+}
+
+
+// Get file from a git repo
+function resolveFileFromGit(giturl) {
+	if (_.isString(giturl)) giturl = parseGitUrl(giturl);
+	if (!giturl) return Q(null);
+
+	// Clone or get from cache
+	return cloneGitRepo(giturl.host, giturl.ref)
+	.then(function(repo) {
+
+		// Resolve relative path
+		return path.resolve(repo, giturl.filepath);
+	});
+};
+
+
+module.exports = {
+	checkUrl: checkGitUrl,
+	parseUrl: parseGitUrl,
+	resolveFile: resolveFileFromGit
+};

lib/utils/images.js

@@ -0,0 +1,34 @@
+var _ = require("lodash");
+var Q = require("q");
+var fs = require("./fs");
+var exec = require('child_process').exec;
+
+var links = require("./links");
+
+// Convert a svg file
+var convertSVG = function(source, dest, options) {
+	if (!fs.existsSync(source)) return Q.reject(new Error("File doesn't exist: "+source));
+
+	var d = Q.defer();
+
+	options = _.defaults(options || {}, {
+
+	});
+
+	var command = "svgexport "+source+" "+dest;
+
+    var child = exec(command, function (error, stdout, stderr) {
+        if (error) {
+        	if (error.code == 127) error = new Error("Need to install 'svgexport' using 'npm install svgexport -g'");
+        	return d.reject(error);
+        }
+        d.resolve();
+    });
+
+	return d.promise;
+};
+
+module.exports = {
+	convertSVG: convertSVG,
+	INVALID: [".svg"]
+};

lib/utils/index.js

@@ -1,3 +0,0 @@
-module.exports = {
-    lang: require('./lang'),
-};

lib/utils/lang.js

@@ -1,18 +0,0 @@
-var MAP = {
-    'py': 'python',
-    'js': 'javascript',
-    'rb': 'ruby',
-};
-
-function normalize(lang) {
-    if(!lang) { return null; }
-
-    var lower = lang.toLowerCase();
-    return MAP[lower] || lower;
-}
-
-// Exports
-module.exports = {
-    normalize: normalize,
-    MAP: MAP
-};

lib/utils/links.js

@@ -0,0 +1,69 @@
+var url = require('url');
+var path = require('path');
+
+// Is the link an external link
+var isExternal = function(href) {
+    try {
+        return Boolean(url.parse(href).protocol);
+    } catch(err) { }
+
+    return false;
+};
+
+// Return true if the link is relative
+var isRelative = function(href) {
+    try {
+        var parsed = url.parse(href);
+
+        return !!(!parsed.protocol && parsed.path);// && parsed.path[0] != '/';
+    } catch(err) {}
+
+    return true;
+};
+
+// Relative to absolute path
+// dir: directory parent of the file currently in rendering process
+// outdir: directory parent from the html output
+
+var toAbsolute = function(_href, dir, outdir) {
+    if (isExternal(_href)) return _href;
+
+    // Path '_href' inside the base folder
+    var hrefInRoot = path.normalize(path.join(dir, _href));
+    if (_href[0] == "/") hrefInRoot = path.normalize(_href.slice(1));
+
+    // Make it relative to output
+    _href = path.relative(outdir, hrefInRoot);
+
+    // Normalize windows paths
+    _href = _href.replace(/\\/g, '/');
+
+    return _href;
+};
+
+// Join links
+var join = function() {
+    var _href = path.join.apply(path, arguments);
+
+    if (process.platform === 'win32') {
+        _href = _href.replace(/\\/g, '/');
+    }
+
+    return _href;
+};
+
+// Change extension
+var changeExtension = function(filename, newext) {
+    return path.join(
+        path.dirname(filename),
+        path.basename(filename, path.extname(filename))+newext
+    );
+};
+
+module.exports = {
+    isRelative: isRelative,
+    isExternal: isExternal,
+    toAbsolute: toAbsolute,
+    join: join,
+    changeExtension: changeExtension
+};

lib/utils/logger.js

@@ -0,0 +1,102 @@
+var _ = require('lodash');
+var util = require('util');
+var color = require('bash-color');
+
+var LEVELS = {
+	DEBUG: 0,
+	INFO: 1,
+	WARN: 2,
+	ERROR: 3,
+	DISABLED: 10
+};
+
+var COLORS = {
+	DEBUG: color.purple,
+	INFO: color.cyan,
+	WARN: color.yellow,
+	ERROR: color.red
+};
+
+module.exports = function(_write, logLevel) {
+	var logger = {};
+	var lastChar = '\n';
+	if (_.isString(logLevel)) logLevel = LEVELS[logLevel.toUpperCase()];
+
+	// Write a simple message
+	logger.write = function(msg) {
+		msg = msg.toString();
+		lastChar = _.last(msg);
+		return _write(msg);
+	};
+
+	// Format a message
+	logger.format = function() {
+		return util.format.apply(util, arguments);
+	};
+
+	// Write a line
+	logger.writeLn = function(msg) {
+		return this.write((msg || "")+"\n");
+	};
+
+	// Write a message with a certain level
+	logger.log = function(level) {
+		if (level < logLevel) return;
+
+		var levelKey = _.findKey(LEVELS, function(v) { return v == level; });
+		var args = Array.prototype.slice.apply(arguments, [1]);
+		var msg = logger.format.apply(logger, args);
+
+		if (lastChar == '\n') {
+			msg = COLORS[levelKey](levelKey.toLowerCase()+":")+" "+msg;
+		}
+
+		return logger.write(msg);
+	};
+	logger.logLn = function() {
+		if (lastChar != '\n') logger.write("\n");
+
+		var args = Array.prototype.slice.apply(arguments);
+		args.push("\n");
+		logger.log.apply(logger, args);
+	};
+
+	// Write a OK
+	logger.ok = function(level) {
+		var args = Array.prototype.slice.apply(arguments, [1]);
+		var msg = logger.format.apply(logger, args);
+		if (arguments.length > 1) {
+			logger.logLn(level, color.green('>> ') + msg.trim().replace(/\n/g, color.green('\n>> ')));
+		} else {
+			logger.log(level, color.green("OK"), "\n");
+		}
+	};
+
+	// Write an "FAIL"
+	logger.fail = function(level) {
+		return logger.log(level, color.red("ERROR")+"\n");
+	};
+
+	_.each(_.omit(LEVELS, 'DISABLED'), function(level, levelKey) {
+		levelKey = levelKey.toLowerCase();
+
+		logger[levelKey] = _.partial(logger.log, level);
+		logger[levelKey].ln = _.partial(logger.logLn, level);
+		logger[levelKey].ok = _.partial(logger.ok, level);
+		logger[levelKey].fail = _.partial(logger.fail, level);
+		logger[levelKey].promise = function(p) {
+			return p.
+			then(function(st) {
+				logger[levelKey].ok();
+				return st;
+			}, function(err) {
+				logger[levelKey].fail();
+				throw err;
+			});
+		}
+	});
+
+	return logger;
+};
+module.exports.LEVELS = LEVELS;
+module.exports.COLORS = COLORS;

lib/utils/navigation.js

@@ -0,0 +1,80 @@
+var _ = require('lodash');
+
+// Cleans up an article/chapter object
+// remove 'articles' attributes
+function clean(obj) {
+    return obj && _.omit(obj, ['articles']);
+}
+
+function flattenChapters(chapters) {
+    return _.reduce(chapters, function(accu, chapter) {
+        return accu.concat([clean(chapter)].concat(flattenChapters(chapter.articles)));
+    }, []);
+}
+
+// Returns from a summary a map of
+/*
+    {
+        "file/path.md": {
+            prev: ...,
+            next: ...,
+        },
+        ...
+    }
+*/
+function navigation(summary, files) {
+    // Support single files as well as list
+    files = _.isArray(files) ? files : (_.isString(files) ? [files] : null);
+
+    // List of all navNodes
+    // Flatten chapters, then add in default README node if needed etc ...
+    var navNodes = flattenChapters(summary.chapters);
+
+    // Mapping of prev/next for a give path
+    var mapping = _.chain(navNodes)
+    .map(function(current, i) {
+        var prev = null, next = null;
+
+        // Skip if no path
+        if(!current.path) return null;
+
+        // Find prev
+        prev = _.chain(navNodes)
+            .slice(0, i)
+            .reverse()
+            .find(function(node) {
+                return node.exists && !node.external;
+            })
+            .value();
+
+        // Find next
+        next = _.chain(navNodes)
+            .slice(i+1)
+            .find(function(node) {
+                return node.exists && !node.external;
+            })
+            .value();
+
+
+        return [current.path, {
+            title: current.title,
+            prev: prev,
+            next: next,
+            level: current.level,
+        }];
+    })
+    .compact()
+    .object()
+    .value();
+
+    // Filter for only files we want
+    if(files) {
+        return _.pick(mapping, files);
+    }
+
+    return mapping;
+}
+
+
+// Exports
+module.exports = navigation;

lib/utils/page.js

@@ -0,0 +1,318 @@
+var Q = require('q');
+var _ = require('lodash');
+var path = require('path');
+var cheerio = require('cheerio');
+var domSerializer = require('dom-serializer');
+var request = require('request');
+
+var links = require('./links');
+var imgUtils = require('./images');
+var fs = require('./fs');
+
+// Render a cheerio dom as html
+var renderDom = function($, dom, options) {
+    if (!dom && $._root && $._root.children) {
+        dom = $._root.children;
+    }
+
+    options = options|| dom.options || $._options;
+    return domSerializer(dom, options);
+};
+
+// Map of images that have been converted
+var imgConversionCache = {};
+
+function replaceText($, el, search, replace, text_only ) {
+    return $(el).each(function(){
+        var node = this.firstChild,
+            val,
+            new_val,
+
+            // Elements to be removed at the end.
+            remove = [];
+
+        // Only continue if firstChild exists.
+        if ( node ) {
+
+            // Loop over all childNodes.
+            do {
+                // Only process text nodes.
+                if ( node.nodeType === 3 ) {
+
+                    // The original node value.
+                    val = node.nodeValue;
+
+                    // The new value.
+                    new_val = val.replace( search, replace );
+
+                    // Only replace text if the new value is actually different!
+                    if ( new_val !== val ) {
+
+                        if ( !text_only && /</.test( new_val ) ) {
+                            // The new value contains HTML, set it in a slower but far more
+                            // robust way.
+                            $(node).before( new_val );
+
+                            // Don't remove the node yet, or the loop will lose its place.
+                            remove.push( node );
+                        } else {
+                            // The new value contains no HTML, so it can be set in this
+                            // very fast, simple way.
+                            node.nodeValue = new_val;
+                        }
+                    }
+                }
+
+            } while ( node = node.nextSibling );
+        }
+
+        // Time to remove those elements!
+        remove.length && $(remove).remove();
+    });
+};
+
+function pregQuote( str ) {
+    return (str+'').replace(/([\\\.\+\*\?\[\^\]\$\(\)\{\}\=\!\<\>\|\:])/g, "\\$1");
+};
+
+
+// Adapt an html snippet to be relative to a base folder
+function normalizeHtml(src, options) {
+    var $ = cheerio.load(src, { xmlMode: false});
+    var toConvert = [];
+    var svgContent = {};
+    var outputRoot = options.book.options.output;
+
+    imgConversionCache[outputRoot] = imgConversionCache[outputRoot] || {};
+
+    // Find svg images to extract and process
+    if (options.convertImages) {
+        $("svg").each(function() {
+            var content = renderDom($, $(this));
+            var svgId = _.uniqueId("svg");
+            var dest = svgId+".svg";
+
+            // Generate filename
+            dest = "/"+fs.getUniqueFilename(outputRoot, dest);
+
+            svgContent[dest] = content;
+            $(this).replaceWith($("<img>").attr("src", dest));
+        });
+    }
+
+    // Find images to normalize
+    $("img").each(function() {
+        var origin = undefined;
+        var src = $(this).attr("src");
+        var isExternal = links.isExternal(src);
+
+        // Transform as relative to the bases
+        if (links.isRelative(src)) {
+            src = links.toAbsolute(src, options.base, options.output);
+        }
+
+        // Convert if needed
+        if (options.convertImages) {
+            // If image is external and ebook, then downlaod the images
+            if (isExternal) {
+                origin = src;
+                src = "/"+fs.getUniqueFilename(outputRoot,  path.basename(src));
+                src = links.toAbsolute(src, options.base, options.output);
+                isExternal = false;
+            }
+
+            var ext = path.extname(src);
+            var srcAbs = path.join("/", options.base, src);
+
+            // Test image extension
+            if (_.contains(imgUtils.INVALID, ext)) {
+                if (imgConversionCache[outputRoot][srcAbs]) {
+                    // Already converted
+                    src = imgConversionCache[outputRoot][srcAbs];
+                } else {
+                    // Not converted yet
+                    var dest = "";
+
+                    // Replace extension
+                    dest = path.join(path.dirname(srcAbs), path.basename(srcAbs, ext)+".png");
+                    dest = dest[0] == "/"? dest.slice(1) : dest;
+
+                    // Get a name that doesn't exists
+                    dest = fs.getUniqueFilename(outputRoot, dest);
+
+                    options.book.log.debug.ln("detect invalid image (will be converted to png):", srcAbs);
+
+                    // Add to cache
+                    imgConversionCache[outputRoot][srcAbs] = "/"+dest;
+
+                    // Push to convert
+                    toConvert.push({
+                        origin: origin,
+                        content: svgContent[srcAbs],
+                        source: isExternal? srcAbs : path.join("./", srcAbs),
+                        dest: path.join("./", dest)
+                    });
+
+                    src = path.join("/", dest);
+                }
+
+                // Reset as relative to output
+                src = links.toAbsolute(src, options.base, options.output);
+            }
+
+            else if (origin) {
+                // Need to downlaod image
+                toConvert.push({
+                    origin: origin,
+                    source: path.join("./", srcAbs)
+                });
+            }
+        }
+
+        $(this).attr("src", src);
+    });
+
+    $("a").each(function() {
+        var href = $(this).attr("href");
+
+        if (links.isRelative(href)) {
+            var absolutePath = path.join(options.base, href);
+
+            // If is in navigation relative: change extsnio nto be .html
+            if (options.navigation[absolutePath]) href = links.changeExtension(href, ".html");
+
+            // Transform as absolute
+            href = links.toAbsolute(href, options.base, options.output);
+        } else {
+            $(this).attr("target", "_blank");
+        }
+
+        // Transform extension
+        $(this).attr("href", href);
+    });
+
+    // Replace glossayr terms
+    _.each(options.glossary, function(term) {
+        var r =  new RegExp( "\\b(" + pregQuote(term.name.toLowerCase()) + ")\\b" , 'gi' );
+        var includedInFiles = false;
+
+        $("*").each(function() {
+            replaceText($, this, r, function(match) {
+                if (!includedInFiles) {
+                    includedInFiles = true;
+                    term.files = term.files || [];
+                    term.files.push(options.navigation[options.input]);
+                }
+                return "<a href='"+links.toAbsolute("GLOSSARY.html", options.base, options.output)+"#"+term.id+"' class='glossary-term' title='"+term.description+"'>"+match+"</span>";
+            });
+        });
+    });
+
+    return {
+        html: renderDom($),
+        images: toConvert
+    };
+};
+
+// Convert svg images to png
+function convertImages(images, options) {
+    if (!options.convertImages) return Q();
+
+    options.book.log.info.ln("convert ", images.length, "images to png");
+
+    return _.reduce(images, function(prev, image) {
+        var imgin = path.resolve(options.book.options.output, image.source);
+
+        return prev
+
+        // Write image if need to be download
+        .then(function() {
+            if (!image.origin) return;
+            options.book.log.info("download image", image.origin);
+            return options.book.log.info.promise(fs.writeStream(imgin, request(image.origin)));
+        })
+
+        // Write svg if content
+        .then(function() {
+            if (!image.content) return;
+            return fs.writeFile(imgin, image.content);
+        })
+
+        // Convert
+        .then(function(){
+            if (!image.dest) return;
+            var imgout = path.resolve(options.book.options.output, image.dest);
+            options.book.log.debug("convert image", image.source, "to", image.dest, "...");
+            return options.book.log.debug.promise(imgUtils.convertSVG(imgin, imgout));
+        });
+    }, Q())
+    .then(function() {
+        options.book.log.info.ok(images.length+" images converted with success");
+    });
+};
+
+
+// Adapt page content to be relative to a base folder
+function normalizePage(sections, options) {
+    options = _.defaults(options || {}, {
+        // Current book
+        book: null,
+
+        // Do we need to convert svg?
+        convertImages: false,
+
+        // Current file path
+        input: ".",
+
+        // Navigation to use to transform path
+        navigation: {},
+
+        // Directory parent of the file currently in rendering process
+        base: "./",
+
+        // Directory parent from the html output
+        output: "./",
+
+        // Glossary terms
+        glossary: []
+    });
+
+    // List of images to convert
+    var toConvert = [];
+
+    sections = _.map(sections, function(section) {
+        if (section.type != "normal") return section;
+
+        var out = normalizeHtml(section.content, options);;
+
+        toConvert = toConvert.concat(out.images);
+        section.content = out.html;
+        return section;
+    });
+
+    return Q()
+    .then(function() {
+        toConvert = _.uniq(toConvert, 'source');
+        return convertImages(toConvert, options);
+    })
+    .thenResolve(sections);
+};
+
+// Extract text from sections
+function extractText(sections) {
+    return _.reduce(sections, function(prev, section) {
+        if (section.type != "normal") return prev;
+
+        var $ = cheerio.load(section.content);
+        $("*").each(function() {
+            prev = prev+" "+$(this).text();
+        });
+
+        return prev;
+    }, "");
+};
+
+module.exports = {
+    normalize: normalizePage,
+    extractText: extractText
+};

lib/utils/progress.js

@@ -11,9 +11,6 @@ var calculProgress = function(navigation, current) {
         nav.path = path;
         return nav;
     })
-    .sortBy(function(nav) {
-        return nav.level;
-    })
     .map(function(nav, i) {
         // Calcul percent
         nav.percent = (i * 100) / Math.max((n - 1), 1);
@@ -27,7 +24,7 @@ var calculProgress = function(navigation, current) {
         } else if (done) {
             prevPercent = nav.percent;
         }
-        
+
         return nav;
     })
     .value();
@@ -47,4 +44,4 @@ var calculProgress = function(navigation, current) {
     };
 }
 
-module.exports = calculProgress;
+module.exports = calculProgress;

lib/utils/server.js

@@ -0,0 +1,96 @@
+var Q = require('q');
+var _ = require('lodash');
+
+var events = require('events');
+var http = require('http');
+var send = require('send');
+var util = require('util');
+var url = require('url');
+
+var Server = function() {
+    this.running = null;
+    this.dir = null;
+    this.port = 0;
+    this.sockets = [];
+};
+util.inherits(Server, events.EventEmitter);
+
+// Return true if the server is running
+Server.prototype.isRunning = function() {
+    return this.running != null;
+};
+
+// Stop the server
+Server.prototype.stop = function() {
+    var that = this;
+    if (!this.isRunning()) return Q();
+
+    var d = Q.defer();
+    this.running.close(function(err) {
+        that.running = null;
+        that.emit("state", false);
+
+        if (err) d.reject(err);
+        else d.resolve();
+    });
+
+    for (var i = 0; i < this.sockets.length; i++) {
+        this.sockets[i].destroy();
+    }
+
+    return d.promise;
+};
+
+Server.prototype.start = function(dir, port) {
+    var that = this, pre = Q();
+    port = port || 8004;
+
+    if (that.isRunning()) pre = this.stop();
+    return pre
+    .then(function() {
+        var d = Q.defer();
+
+        that.running = http.createServer(function(req, res){
+            // Render error
+            function error(err) {
+                res.statusCode = err.status || 500;
+                res.end(err.message);
+            }
+
+            // Redirect to directory's index.html
+            function redirect() {
+                res.statusCode = 301;
+                res.setHeader('Location', req.url + '/');
+                res.end('Redirecting to ' + req.url + '/');
+            }
+
+            // Send file
+            send(req, url.parse(req.url).pathname)
+            .root(dir)
+            .on('error', error)
+            .on('directory', redirect)
+            .pipe(res);
+        });
+
+        that.running.on('connection', function (socket) {
+            that.sockets.push(socket);
+            socket.setTimeout(4000);
+            socket.on('close', function () {
+                that.sockets.splice(that.sockets.indexOf(socket), 1);
+            });
+        });
+
+        that.running.listen(port, function(err) {
+            if (err) return d.reject(err);
+
+            that.port = port;
+            that.dir = dir;
+            that.emit("state", true);
+            d.resolve();
+        });
+
+        return d.promise;
+    });
+}
+
+module.exports = Server;

lib/utils/string.js

@@ -0,0 +1,32 @@
+var _ = require("lodash");
+
+function escapeShellArg(arg) {
+    var ret = '';
+
+    ret = arg.replace(/"/g, '\\"');
+
+    return "\"" + ret + "\"";
+}
+
+function optionsToShellArgs(options) {
+    return _.chain(options)
+    .map(function(value, key) {
+        if (value == null || value === false) return null;
+        if (value === true) return key;
+        return key+"="+escapeShellArg(value);
+    })
+    .compact()
+    .value()
+    .join(" ");
+}
+
+function escapeRegex(str) {
+    return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
+}
+
+module.exports = {
+    escapeRegex: escapeRegex,
+    escapeShellArg: escapeShellArg,
+    optionsToShellArgs: optionsToShellArgs,
+    toLowerCase: String.prototype.toLowerCase.call.bind(String.prototype.toLowerCase)
+};

lib/utils/watch.js

@@ -0,0 +1,38 @@
+var Q = require('q');
+var _ = require('lodash');
+var path = require('path');
+var Gaze = require('gaze').Gaze;
+
+var parsers = require('gitbook-parsers')
+
+function watch(dir) {
+    var d = Q.defer();
+    dir = path.resolve(dir);
+
+    var toWatch = [
+        "book.json", "book.js"
+    ];
+
+    _.each(parsers.extensions, function(ext) {
+        toWatch.push("**/*"+ext);
+    });
+
+    var gaze = new Gaze(toWatch, {
+        cwd: dir
+    });
+
+    gaze.once("all", function(e, filepath) {
+        gaze.close();
+
+        d.resolve(filepath);
+    });
+    gaze.once("error", function(err) {
+        gaze.close();
+
+        d.reject(err);
+    });
+
+    return d.promise;
+}
+
+module.exports = watch;

package.json

@@ -1,47 +1,74 @@
 {
     "name": "gitbook",
-    "version": "0.2.1",
+    "version": "2.0.0-alpha.1",
+    "homepage": "https://www.gitbook.com",
     "description": "Library and cmd utility to generate GitBooks",
     "main": "lib/index.js",
     "dependencies": {
         "q": "1.0.1",
+        "lunr": "0.5.7",
         "lodash": "2.4.1",
-        "marked": "0.3.2",
-        "marked-text-renderer": "0.0.1",
-        "lunr": "0.5.2",
-        "swig": "1.3.2",
+        "graceful-fs": "3.0.5",
+        "resolve": "0.6.3",
+        "fs-extra": "0.14.0",
+        "fstream-ignore": "1.0.2",
+        "gitbook-parsers": "0.3.0",
+        "nunjucks": "git+https://github.com/SamyPesse/nunjucks.git#4019d1b7379372336b86ce1b0bf84352a2029747",
+        "nunjucks-autoescape": "0.1.0",
+        "nunjucks-filter": "0.1.0",
+        "nunjucks-i18n": "1.0.0",
+        "semver": "2.2.1",
+        "npmi": "0.1.1",
+        "cheerio": "0.18.0",
+        "gitbook-plugin-livereload": "0.0.1",
+        "gaze": "~0.5.1",
         "send": "0.2.0",
-        "fstream-ignore": "0.0.7",
-        "commander": "2.2.0",
-        "fs-extra": "0.8.1",
-        "highlight.js": "8.0.0",
-        "tmp": "0.0.23"
+        "tiny-lr-fork": "0.0.5",
+        "tmp": "0.0.24",
+        "crc": "3.2.1",
+        "bash-color": "0.0.3",
+        "URIjs": "1.14.1",
+        "request": "2.51.0",
+        "npm": "2.4.1",
+        "dom-serializer": "git+https://github.com/SamyPesse/dom-serializer.git#58d8ea24b9b7b4137ee5f30a41abce4d7c4a922a"
     },
     "devDependencies": {
         "mocha": "1.18.2",
         "grunt": "~0.4.2",
         "grunt-cli": "0.1.11",
+        "grunt-contrib-copy": "0.5.0",
         "grunt-contrib-less": "~0.5.0",
-        "grunt-contrib-requirejs": "0.4.1"
+        "grunt-contrib-requirejs": "0.4.1",
+        "grunt-bower-install-simple": "0.9.2"
     },
     "scripts": {
-        "test": "export TESTING=true; mocha --reporter list"
-    },
-    "bin": {
-        "gitbook": "./bin/gitbook.js"
+        "test": "export TESTING=true; mocha --reporter list --timeout 15000"
     },
     "repository": {
         "type": "git",
         "url": "https://github.com/GitbookIO/gitbook.git"
     },
+    "bin": {
+        "gitbook": "./bin/gitbook.js"
+    },
     "keywords": [
         "git",
         "book",
         "gitbook"
     ],
-    "author": "Aaron O'Mullan <aaron.omullan@friendco.de>",
+    "author": "FriendCode Inc. <contact@gitbook.com>",
     "license": "Apache 2",
     "bugs": {
         "url": "https://github.com/GitbookIO/gitbook/issues"
-    }
+    },
+    "contributors": [
+        {
+            "name": "Aaron O'Mullan",
+            "email": "aaron@gitbook.com"
+        },
+        {
+            "name": "Samy Pessé",
+            "email": "samy@gitbook.com"
+        }
+    ]
 }

test/configuration.js

@@ -0,0 +1,14 @@
+var path = require('path');
+var assert = require('assert');
+
+var Book = require('../').Book;
+
+describe('Configuration parsing', function () {
+    it('should correctly load from json', function() {
+        assert(books[0].options.title == "Test");
+    });
+
+    it('should correctly load from javascript', function() {
+        assert(books[4].options.title == "Test 2");
+    });
+});

test/ebook.js

@@ -0,0 +1,40 @@
+var path = require('path');
+var _ = require('lodash');
+var assert = require('assert');
+
+var fs = require("fs");
+var fsUtil = require("../lib/utils/fs");
+
+
+describe('eBook Generator', function () {
+    it('should correctly generate ebook pages', function(done) {
+        testGeneration(books[1], "ebook", function(output) {
+            assert(fs.existsSync(path.join(output, "SUMMARY.html")));
+        }, done);
+    });
+
+    it('should correctly convert svg images to png', function(done) {
+        testGeneration(books[4], "ebook", function(output) {
+            var readmeContent = fs.readFileSync(path.join(output, "index.html"), {encoding: "utf8"});
+            var pageContent = fs.readFileSync(path.join(output, "sub/PAGE.html"), {encoding: "utf8"});
+
+            // Remote image
+            assert(pageContent.indexOf('src="../Tux.png"') >= 0);
+            assert(fs.existsSync(path.join(output, "Tux.png")));
+
+            assert(fs.existsSync(path.join(output, "test.png")));
+            assert(fs.existsSync(path.join(output, "NewTux.png")));
+
+            assert(!fs.existsSync(path.join(output, "test_0.png")));
+            assert(!fs.existsSync(path.join(output, "sub/test.png")));
+            assert(!fs.existsSync(path.join(output, "sub/NewTux.png")));
+
+            assert(pageContent.indexOf('src="../test.png"') >= 0);
+            assert(pageContent.indexOf('src="../NewTux.png"') >= 0);
+            assert(pageContent.indexOf('<svg') < 0);
+
+            assert(readmeContent.indexOf('src="test.png"') >= 0);
+            assert(readmeContent.indexOf('src="NewTux.png"') >= 0);
+        }, done);
+    });
+});

test/fixtures/GITHUB_LINKS.md

@@ -1,3 +0,0 @@
-# Nice course
-
-Check out this source file [in C++](../src/something.cpp)

test/fixtures/HR_PAGE.md

@@ -1,11 +0,0 @@
-## Wow such book
-
-Some nice content here
-
----
-
-A beautiful separator, but non an exercise or a quiz !
-
----
-
-Some more beautiful text, because `this` book is awesome ...

test/fixtures/PAGE.md

@@ -1,68 +0,0 @@
-# Python basics
-
-Python is a nice language, you can add stuff. Bla bla bla.
-
-Lets jump into an exercise :
-
----
-
-It's dead simple, `c` must be the sum of `a` and `b`
-
-```py
-a = 1
-b = 2
-```
-
-```py
-a = 1
-b = 2
-c = a + b
-```
-
-```py
-assert(c, 3)
-```
-
----
-
-Some more nice content ....
-
-[Cool stuff](http://gitbook.io)
-
-[Link to another Markdown file](./xyz/file.md)
-
-And look at this pretty picture:
-![Pretty](../assets/my-pretty-picture.png "Pretty")
-
-Lets go for another exercise but this time with some context :
-
----
-
-Exercise with some context code :
-
-Using the `double` function provided, build a `quadruple` function
-
-```py
-
-```
-
-```py
-
-def quadruple(x):
-    return double(double(x))
-
-```
-
-```py
-assert(quadruple(8), 32)
-```
-
-```py
-
-def double(x):
-    return x * 2
-
-```
-
----
-

test/fixtures/QUIZ_PAGE.md

@@ -1,48 +0,0 @@
-# Gitbook quiz
-
-Gitbook lets you write a quiz using GFM tables:
-
----
-
-Here's a quiz about Gitbook
-
-|                  | Good | Bad |
-| ---------------- | ---- | --- |
-| What is Gitbook? | (x)  | ( ) |
-
-> Gitbook is good
-
-What does Gitbook support?
-- [x] Table-based questions with radio buttons
-- [x] Table-based questions with checkboxes
-- [ ] Telepathy
-- [x] List-based questions with checkboxes
-- [x] List-based questions with radio buttons
-- [ ] Moon-on-a-stick
-
-> Gitbook supports table and list based quiz questions using either radio buttons or checkboxes.
->
-> Gitbook is not telepathic and does not give you the moon on a stick.
-
----
-
-Some more nice content ....
-
-[Cool stuff](http://gitbook.io)
-
-[Link to another Markdown file](./xyz/file.md)
-
----
-
-Quiz test 2: What does Gitbook support?
-- [x] Table-based questions with radio buttons
-- [x] Table-based questions with checkboxes
-- [ ] Telepathy
-- [x] List-based questions with checkboxes
-- [x] List-based questions with radio buttons
-- [ ] Moon-on-a-stick
-
-> Gitbook supports table and list based quiz questions using either radio buttons or checkboxes.
-
----
-

test/fixtures/README.md

@@ -1,7 +0,0 @@
-# This is the title
-
-This is the book description.
-
-other content
-...
-

test/fixtures/SECTIONS.md

@@ -1,68 +0,0 @@
-# Title
-
-Some text
-
----
-
-## NOT Exercise
-
-Simple subsection NOT exercise
-
-```
-x = 1
-```
-
-What is this
-
-```
-y = [1, 2, 3]
-```
-
-```
-z = {a: 1, b: 2}
-```
-
----
-
-## Exercise
-
-Define a variable `x` equal to 10.
-
-```js
-var x =
-```
-
-```js
-var x = 10;
-```
-
-```js
-assert(x == 10);
-```
-
-```js
-// This is context code available everywhere
-// The user will be able to call magicFunc in his code
-function magicFunc() {
-    return 3;
-}
-```
-
----
-
-## Another exercise
-
-Bla bla bla ... This time with no `context` code.
-
-
-```js
-var x =
-```
-
-```js
-var x = 10;
-```
-
-```js
-assert(x == 10);
-```

test/fixtures/SUMMARY.md

@@ -1,10 +0,0 @@
-# Summary
-
-* [Chapter 1](chapter-1/README.md)
-    * [Article 1](chapter-1/ARTICLE1.md)
-    * [Article 2](chapter-1/ARTICLE2.md)
-* [Chapter 2](chapter-2/README.md)
-* [Chapter 3](chapter-3/README.md)
-* [Chapter 4](chapter-4/README.md)
-    * Unfinished article
-* Unfinished Chapter

test/fixtures/test0/GLOSSARY.md

@@ -0,0 +1,6 @@
+# Glossary
+
+## Description
+
+This is the dexcription of a description.
+

test/fixtures/test0/README.md

@@ -0,0 +1,3 @@
+# Other Title
+
+A description

test/fixtures/test0/SUMMARY.md

@@ -0,0 +1 @@
+# Summary

test/fixtures/test0/book.json

@@ -0,0 +1,3 @@
+{
+	"title": "Test"
+}

test/fixtures/test0/styles/website.css

@@ -0,0 +1,3 @@
+body {
+	background: red;
+}

test/fixtures/test1/GLOSSARY.md

@@ -0,0 +1,9 @@
+
+# Test
+
+a test text
+
+# Test 2
+
+a second test
+

test/fixtures/test1/README.md

@@ -0,0 +1,4 @@
+# Test
+
+This file is not parsed by gitbook because the structure is defined in book.json.
+

test/fixtures/test1/SUMMARY.md

@@ -0,0 +1,6 @@
+# Summary
+
+* [Chapter 1](test.md)
+    * [Article 1](sub/test1.md)
+* [Chapter 2](test2.md)
+* [Google](https://www.google.com)

test/fixtures/test1/book.json

@@ -0,0 +1,5 @@
+{
+	"structure": {
+		"readme": "intro.md"
+	}
+}

test/fixtures/test1/intro.md

@@ -0,0 +1,4 @@
+# My Book
+
+Test description
+

test/fixtures/test1/sub/test1.md

@@ -0,0 +1,6 @@
+# This file is used to etst links transformations:
+
+This is a relative link [test](../intro.md).
+
+![image](../image.png)
+

test/fixtures/test2/LANGS.md

@@ -0,0 +1,4 @@
+# Languages
+
+* [English](en/)
+* [French](fr/)

test/fixtures/test2/README.md

@@ -0,0 +1,2 @@
+# Multi-Languages test
+

test/fixtures/test2/en/README.md

@@ -0,0 +1 @@
+# English Book

test/fixtures/test2/en/SUMMARY.md

@@ -0,0 +1 @@
+# Summary

test/fixtures/test2/fr/README.md

@@ -0,0 +1 @@
+# French Book

test/fixtures/test2/fr/SUMMARY.md

@@ -0,0 +1 @@
+# Summary

test/fixtures/test3/README.adoc

@@ -0,0 +1,4 @@
+= My Book
+
+Test description
+

test/fixtures/test3/SUMMARY.adoc

@@ -0,0 +1,5 @@
+= Summary
+
+. link:test.adoc[Chapter 1]
+.. link:test1.adoc[Article 1]
+. link:test2.adoc[Chapter 2]

test/fixtures/test4/README.md

@@ -0,0 +1,7 @@
+# Other Title
+
+A description
+
+![test image to be converted](./test.svg)
+![test url](http://upload.wikimedia.org/wikipedia/commons/b/b0/NewTux.svg)
+![test image to be converted, second use](./test.svg)

test/fixtures/test4/SUMMARY.md

@@ -0,0 +1,3 @@
+# Summary
+
+* [Page](sub/PAGE.md)

test/fixtures/test4/book.js

@@ -0,0 +1,3 @@
+module.exports = {
+	title: "Test 2"
+};

test/fixtures/test4/sub/PAGE.md

@@ -0,0 +1,18 @@
+##
+
+## Image from root page
+
+![test image to be converted](../test.svg)
+![test url](http://upload.wikimedia.org/wikipedia/commons/b/b0/NewTux.svg)
+
+## Inline svg
+
+{% html %}
+<svg width="400" height="110">
+  <rect width="300" height="100" style="fill:rgb(0,0,255);stroke-width:3;stroke:rgb(0,0,0)">
+</svg>
+{% endhtml %}
+
+## Remote image
+
+![remote url](http://upload.wikimedia.org/wikipedia/commons/a/af/Tux.png)

test/fixtures/test4/test.svg

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1 Tiny//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11-tiny.dtd">
+<svg version="1.1" baseProfile="tiny" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" id="svg-root" width="100%" height="100%" viewBox="0 0 480 360">
+	<title id="test-title">basic SVG tiny doc</title>
+	<g id="test-body-content">
+		<text font-family="Arial" font-size="14" text-anchor="middle" x="225" y="25">hello world</text>
+	</g>
+	<text id="revision" x="10" y="340" font-size="40" stroke="none" fill="black">Revision: 1.1</text>
+	<rect id="test-frame" x="1" y="1" width="478" height="358" fill="none" stroke="#000000"/>
+</svg>
+

test/fixtures/test5/README.md

@@ -0,0 +1,5 @@
+# Test Content inclusion
+
+{% include "./test.md" %}
+Git1:{% include "git+https://gist.github.com/69ea4542e4c8967d2fa7.git/test.md" %}
+Git2:{% include "git+https://gist.github.com/69ea4542e4c8967d2fa7.git/test2.md" %}

test/fixtures/test5/SUMMARY.md

@@ -0,0 +1 @@
+# Summary

test/fixtures/test5/test.md

@@ -0,0 +1 @@
+Hello World

test/git.js

@@ -0,0 +1,32 @@
+var path = require('path');
+var _ = require('lodash');
+var assert = require('assert');
+
+var fs = require("fs");
+var git = require("../lib/utils/git");
+
+describe('GIT parser and getter', function () {
+    it('should correctly parse an https url', function() {
+        var parts = git.parseUrl("git+https://gist.github.com/69ea4542e4c8967d2fa7.git/test.md");
+        assert(parts);
+        assert.equal(parts.host, "https://gist.github.com/69ea4542e4c8967d2fa7.git");
+        assert.equal(parts.ref, "master");
+        assert.equal(parts.filepath, "test.md");
+    });
+
+    it('should correctly parse an https url with a reference', function() {
+        var parts = git.parseUrl("git+https://gist.github.com/69ea4542e4c8967d2fa7.git/test.md#0.1.2");
+        assert(parts);
+        assert.equal(parts.host, "https://gist.github.com/69ea4542e4c8967d2fa7.git");
+        assert.equal(parts.ref, "0.1.2");
+        assert.equal(parts.filepath, "test.md");
+    });
+
+    it('should correctly parse an ssh url', function() {
+        var parts = git.parseUrl("git+git@github.com:GitbookIO/gitbook.git/directory/README.md#e1594cde2c32e4ff48f6c4eff3d3d461743d74e1");
+        assert(parts);
+        assert.equal(parts.host, "git@github.com:GitbookIO/gitbook.git");
+        assert.equal(parts.ref, "e1594cde2c32e4ff48f6c4eff3d3d461743d74e1");
+        assert.equal(parts.filepath, "directory/README.md");
+    });
+});

test/helper.js

@@ -0,0 +1,62 @@
+var path = require('path');
+var Q = require('q');
+var fs = require('fs');
+var _ = require('lodash');
+
+var fsUtil = require("../lib/utils/fs");
+var Book = require('../').Book;
+var LOG_LEVELS = require('../').LOG_LEVELS;
+
+// Nicety for mocha / Q
+global.qdone = function qdone(promise, done) {
+    return promise.then(function() {
+        return done();
+    }, function(err) {
+        return done(err);
+    }).done();
+};
+
+// Test generation of a book
+global.testGeneration = function(book, type, func, done) {
+    var OUTPUT_PATH = book.options.output;
+
+    qdone(
+        book.generate(type)
+            .then(function() {
+                func(OUTPUT_PATH);
+            })
+            .fin(function() {
+                return fsUtil.remove(OUTPUT_PATH);
+            }),
+        done);
+};
+
+// Books for testings
+var books = fs.readdirSync(path.join(__dirname, './fixtures/'));
+
+global.books = _.chain(books)
+    .sortBy()
+    .map(function(book) {
+        if (book.indexOf("test") !== 0) return null;
+        return new Book(path.join(__dirname, './fixtures/', book), {
+            logLevel: LOG_LEVELS.DISABLED
+        });
+    })
+    .compact()
+    .value();
+
+// Init before doing tests
+before(function(done) {
+
+    qdone(
+	    _.reduce(global.books, function(prev, book) {
+            return prev.then(function() {
+                return fsUtil.remove(path.join(book.root, "_book"));
+            })
+            .then(function() {
+                return book.parse();
+            });
+        }, Q()),
+	    done
+	);
+});

test/json.js

@@ -0,0 +1,59 @@
+var path = require('path');
+var _ = require('lodash');
+var assert = require('assert');
+
+var fs = require("fs");
+
+describe('JSON generator', function () {
+    it('should correctly generate a book to json with glossary', function(done) {
+        testGeneration(books[0], "json", function(output) {
+            assert(fs.existsSync(path.join(output, "README.json")));
+
+            var readme = JSON.parse(fs.readFileSync(path.join(output, "README.json")));
+            assert(readme.sections[0].content.indexOf('class="glossary-term"') > 0);
+        }, done);
+    });
+
+    it('should correctly generate a book to json with sub folders', function(done) {
+    	testGeneration(books[1], "json", function(output) {
+            assert(!fs.existsSync(path.join(output, "README.json")));
+            assert(fs.existsSync(path.join(output, "intro.json")));
+            assert(fs.existsSync(path.join(output, "sub/test1.json")));
+
+            var test1 = JSON.parse(fs.readFileSync(path.join(output, "sub/test1.json")));
+            assert(test1.sections[0].content.indexOf("intro.html") > 0);
+        }, done);
+    });
+
+    it('should correctly generate a multilingual book to json', function(done) {
+    	testGeneration(books[2], "json", function(output) {
+            assert(fs.existsSync(path.join(output, "README.json")));
+            assert(fs.existsSync(path.join(output, "en/README.json")));
+            assert(fs.existsSync(path.join(output, "fr/README.json")));
+        }, done);
+    });
+
+    it('should correctly generate an asciidoc book to json', function(done) {
+        testGeneration(books[3], "json", function(output) {
+            assert(fs.existsSync(path.join(output, "README.json")));
+            assert(fs.existsSync(path.join(output, "test.json")));
+            assert(fs.existsSync(path.join(output, "test1.json")));
+            assert(fs.existsSync(path.join(output, "test2.json")));
+        }, done);
+    });
+
+    it('should correctly generate a book with local inclusion', function(done) {
+        testGeneration(books[5], "json", function(output) {
+            var readme = JSON.parse(fs.readFileSync(path.join(output, "README.json")));
+            assert(readme.sections[0].content.indexOf('Hello World') > 0);
+        }, done);
+    });
+
+    it('should correctly generate a book with external inclusion', function(done) {
+        testGeneration(books[5], "json", function(output) {
+            var readme = JSON.parse(fs.readFileSync(path.join(output, "README.json")));
+            assert(readme.sections[0].content.indexOf('Git1:Hello from git') > 0);
+            assert(readme.sections[0].content.indexOf('Git2:First Hello. Hello from git') > 0);
+        }, done);
+    });
+});

test/links.js

@@ -0,0 +1,33 @@
+var path = require('path');
+var _ = require('lodash');
+var assert = require('assert');
+
+var links = require("../lib/utils/links");
+
+describe('Links', function () {
+    it('should correctly test external links', function() {
+        assert(links.isExternal("http://google.fr"));
+        assert(links.isExternal("https://google.fr"));
+        assert(!links.isExternal("test.md"));
+        assert(!links.isExternal("folder/test.md"));
+        assert(!links.isExternal("/folder/test.md"));
+    });
+
+    describe('toAbsolute', function() {
+        it('should correctly transform as absolute', function() {
+            assert.equal(links.toAbsolute("http://google.fr"), "http://google.fr");
+            assert.equal(links.toAbsolute("test.md", "./", "./"), "test.md");
+            assert.equal(links.toAbsolute("folder/test.md", "./", "./"), "folder/test.md");
+        });
+
+        it('should correctly handle windows path', function() {
+            assert.equal(links.toAbsolute("folder\\test.md", "./", "./"), "folder/test.md");
+        });
+
+        it('should correctly handle absolute path', function() {
+            assert.equal(links.toAbsolute("/test.md", "./", "./"), "test.md");
+            assert.equal(links.toAbsolute("/test.md", "test", "test"), "../test.md");
+            assert.equal(links.toAbsolute("/sub/test.md", "test", "test"), "../sub/test.md");
+        });
+    });
+});

test/navigation.js

@@ -1,74 +0,0 @@
-var fs = require('fs');
-var path = require('path');
-var assert = require('assert');
-
-var summary = require('../').parse.summary;
-var navigation = require('../').parse.navigation;
-
-
-var CONTENT = fs.readFileSync(path.join(__dirname, './fixtures/SUMMARY.md'), 'utf8');
-var LEXED = summary(CONTENT);
-
-
-describe('Summary navigation', function() {
-    it('should provide next & prev entries for a file', function() {
-        var nav = navigation(LEXED, [
-            'README.md',
-            'chapter-1/README.md',
-            'chapter-1/ARTICLE1.md',
-            'chapter-1/ARTICLE2.md',
-            'chapter-2/README.md',
-        ]);
-
-        // Make sure it found the files we gave it
-        assert(nav['README.md']);
-        assert(nav['chapter-1/README.md']);
-        assert(nav['chapter-1/ARTICLE1.md']);
-        assert(nav['chapter-1/ARTICLE2.md']);
-        assert(nav['chapter-2/README.md']);
-
-
-        assert.equal(nav['README.md'].prev, null);
-        assert.equal(nav['README.md'].next.path, 'chapter-1/README.md');
-
-        assert.equal(nav['chapter-1/README.md'].prev.path, 'README.md');
-        assert.equal(nav['chapter-1/README.md'].next.path, 'chapter-1/ARTICLE1.md');
-
-        assert.equal(nav['chapter-1/ARTICLE1.md'].prev.path, 'chapter-1/README.md');
-        assert.equal(nav['chapter-1/ARTICLE1.md'].next.path, 'chapter-1/ARTICLE2.md');
-
-        assert.equal(nav['chapter-1/ARTICLE2.md'].prev.path, 'chapter-1/ARTICLE1.md');
-        assert.equal(nav['chapter-1/ARTICLE2.md'].next.path, 'chapter-2/README.md');
-
-        assert.equal(nav['chapter-2/README.md'].prev.path, 'chapter-1/ARTICLE2.md');
-        assert.equal(nav['chapter-2/README.md'].next.path, 'chapter-3/README.md');
-    });
-
-    it('should give full tree, when not limited', function() {
-        var nav = navigation(LEXED);
-
-        assert(nav['README.md']);
-        assert(nav['chapter-1/README.md']);
-        assert(nav['chapter-1/ARTICLE1.md']);
-        assert(nav['chapter-1/ARTICLE2.md']);
-        assert(nav['chapter-2/README.md']);
-        assert(nav['chapter-3/README.md']);
-    });
-
-    it('should detect levels correctly', function() {
-        var nav = navigation(LEXED);
-
-        assert.equal(nav['README.md'].level, '0');
-        assert.equal(nav['chapter-1/README.md'].level, '1');
-        assert.equal(nav['chapter-1/ARTICLE1.md'].level, '1.1');
-        assert.equal(nav['chapter-1/ARTICLE2.md'].level, '1.2');
-        assert.equal(nav['chapter-2/README.md'].level, '2');
-        assert.equal(nav['chapter-3/README.md'].level, '3');
-    });
-
-    it('should not accept null paths', function() {
-        var nav = navigation(LEXED);
-
-        assert(!nav[null]);
-    });
-});

test/page.js

@@ -1,96 +0,0 @@
-var fs = require('fs');
-var path = require('path');
-var assert = require('assert');
-
-var page = require('../').parse.page;
-
-function loadPage (name, options) {
-    var CONTENT = fs.readFileSync(path.join(__dirname, './fixtures/' + name + '.md'), 'utf8');
-    return page(CONTENT, options);
-}
-
-var LEXED = loadPage('PAGE', {
-    dir: 'course',
-    outdir: '_book'
-});
-var QUIZ_LEXED = loadPage('QUIZ_PAGE');
-var HR_LEXED = loadPage('HR_PAGE');
-
-describe('Page parsing', function() {
-    it('should detect sections', function() {
-        assert.equal(LEXED.length, 4);
-    });
-
-    it('should detect section types', function() {
-        assert.equal(LEXED[0].type, 'normal');
-        assert.equal(LEXED[1].type, 'exercise');
-        assert.equal(LEXED[2].type, 'normal');
-        assert.equal(QUIZ_LEXED[0].type, 'normal');
-        assert.equal(QUIZ_LEXED[1].type, 'quiz');
-        assert.equal(QUIZ_LEXED[2].type, 'normal');
-        assert.equal(QUIZ_LEXED[3].type, 'quiz');
-    });
-
-    it('should gen content for normal sections', function() {
-        assert(LEXED[0].content);
-        assert(LEXED[2].content);
-    });
-
-    it('should make image URLs relative', function() {
-        assert(LEXED[2].content.indexOf('_book/assets/my-pretty-picture.png') !== -1);
-    });
-
-    it('should gen code and content for exercise sections', function() {
-        assert(LEXED[1].content);
-        assert(LEXED[1].code);
-        assert(LEXED[1].code.base);
-        assert(LEXED[1].code.solution);
-        assert(LEXED[1].code.validation);
-        assert(LEXED[1].code.context === null);
-
-        assert(LEXED[3].content);
-        assert(LEXED[3].code);
-        assert(LEXED[3].code.base);
-        assert(LEXED[3].code.solution);
-        assert(LEXED[3].code.validation);
-        assert(LEXED[3].code.context);
-    });
-
-    it('should merge sections correctly', function() {
-        // One big section
-        assert.equal(HR_LEXED.length, 1);
-
-        // HRs inserted correctly
-        assert.equal(HR_LEXED[0].content.match(/<hr>/g).length, 2);
-    });
-
-    it('should detect an exercise\'s language', function() {
-        assert.equal(LEXED[1].lang, 'python');
-    });
-
-    it('should render a quiz', function() {
-        assert(QUIZ_LEXED[1].content);
-        assert(QUIZ_LEXED[1].quiz);
-        assert(QUIZ_LEXED[1].quiz[0].base);
-        assert(QUIZ_LEXED[1].quiz[0].solution);
-        assert(QUIZ_LEXED[1].quiz[0].feedback);
-        assert(QUIZ_LEXED[1].quiz[1].base);
-        assert(QUIZ_LEXED[1].quiz[1].solution);
-        assert(QUIZ_LEXED[1].quiz[1].feedback);
-    });
-});
-
-
-describe('Relative links', function() {
-    it('should be resolved to their GitHub counterparts', function() {
-        var LEXED = loadPage('GITHUB_LINKS', {
-            // GitHub repo ID
-            repo: 'GitBookIO/javascript',
-
-            // Imaginary folder of markdown file
-            dir: 'course'
-        });
-
-        assert(LEXED[0].content.indexOf('https://github.com/GitBookIO/javascript/blob/src/something.cpp') !== -1);
-    });
-});