Bump version to 2.5.0

Fix gitbook.state.root

.editorconfig

@@ -0,0 +1,10 @@
+# editorconfig.org
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

.eslintignore

@@ -0,0 +1 @@
+theme/**/*

.eslintrc

@@ -0,0 +1,19 @@
+{
+    "rules": {
+        "indent": [ 2, 4 ],
+        "quotes": [ 2, "single" ],
+        "linebreak-style": [ 2, "unix" ],
+        "semi": [ 2, "always" ],
+        "no-unused-vars": [ 2, {
+            "vars": "all",
+            "args": "none"
+        } ],
+        "spaced-comment": [ 2, "always" ]
+    },
+    "env": {
+        "node": true,
+        "mocha": true,
+        "browser": true
+    },
+    "extends": "eslint:recommended"
+}

.gitignore

@@ -24,7 +24,5 @@ build/Release
 # see https://npmjs.org/doc/faq.html#Should-I-check-my-node_modules-folder-into-git
 node_modules
 
-theme/javascript/vendors
-
 # vim swapfile
 *.swp

.travis.yml

@@ -1,4 +1,9 @@
+sudo: false
 language: node_js
 node_js:
+  - "4.1"
+  - "0.12"
   - "0.11"
   - "0.10"
+before_install:
+  - npm install svgexport -g

AUTHORS.md

@@ -7,12 +7,53 @@ Names below are ordered by first contribution.
 Author
 ------
 
-- Samy Pessé <samypesse@gmail.com>
-- Aaron O'Mullan <aaron.omullan@gmail.com>
+- Samy Pessé <samypesse@gmail.com> (@SamyPesse)
+- Aaron O'Mullan <aaron.omullan@gmail.com> (@AaronO)
 
 
 Contributors
 ------------
 
-- Nijiko Yonskai
-- Herman Starikov
+- Nijiko Yonskai (@Nijikokun)
+- Herman Starikov (@Hermanya)
+
+Translators
+------------
+
+- German
+    - Winnie (@winniehell)
+- Italian
+    - Giulio Bonanome (@gbonanome)
+- Russian
+    - Andrey Akinshin (@AndreyAkinshin)
+- Norwegian
+    - Knut Melvær (@kmelve)
+- Persian (Farsi)
+    - Mohammad Hossein Mojtahedi (@mhm5000)
+- Polish
+    - Łukasz Szeremeta (@lszeremeta)
+- Portuguese
+    - Ryan O'Mullan (@RyanOM)
+- Spanish
+    - Ryan O'Mullan (@RyanOM)
+- Simplifiled Chinese
+    - Hu Hao (@howiehu)
+- Traditional Chinese
+    - Hu Hao (@howiehu)
+- French
+    - Samy Pessé (@SamyPesse)
+- Romanian
+        - Iancu Aurel (@awrelll)
+- Finnish
+    - Tommi Savikko (@savikko)
+- Japanese
+    - Iancu Aurel (@awrelll)
+- Korean
+    - Iancu Aurel (@awrelll)
+    - SangYeob Yu (@deminoth)
+- Vietnamese
+    - Hong Nguyen (@nghong)
+- Hebrew
+    - @a-moses
+- Ukrainian
+    - @Karnaukhov

CHANGES.md

@@ -1,2 +1,301 @@
 # Release notes
+All notable changes to this project will be documented in this file.
+This project adheres to [Semantic Versioning](http://semver.org/).
 
+## 2.5.0
+- Add `chapterTitle` and `filepath` to `gitbook.state` JS API
+- Fix compatibility with plugins `<2.5.0`
+
+## 2.5.0-beta.7
+- Use Arial as default font for PDFs
+- Client side API provides `gitbook.state.root`
+- Normalize heading IDs like GitHub
+
+## 2.5.0-beta.6
+- Fix default style for pdf footer and header
+- Correctly handle query in image urls
+- Fix templating in imported content
+- Use helvetica as default font for PDFs
+
+## 2.5.0-beta.5
+- Fix position of sidebar toggle button
+- Update asciidoc parser to remove git dependency
+
+## 2.5.0-beta.4
+- Fix compatibility for some plugins (like `autocover`)
+- Fix position of sidebar toggle button when glossary button is present
+
+## 2.5.0-beta.3
+- Fix installation of plugins when using a pre-release
+
+## 2.5.0-beta.2
+- Fix support for pre-releases
+
+## 2.5.0-beta.1
+- Font settings, sharing and search are externalized as default plugins
+- Plugins can define a configuration schema in the manifest, this schema will be used to validate configuration during build
+- New Node.js API for plugin: `book.formatString(type, content)`
+- New client side API for website plugins: `gitbook.toolbar.createButton(opts)`
+- Better header/footer for PDF, CSS wil be inlined to easily style the header/footer
+- Cleaner table of contents for ebooks
+- Support for RTL in ebook's table of contents
+- Better colors for mobi (links and code blocks)
+
+## 2.4.3
+- Add ukrainian translation (`uk`)
+- Add `book.json` configuration for maximum size of search index
+- Improve reliability of summary parser
+
+## 2.4.2
+- Default plugins should not be installed by `gitbook install`
+- Limit search index size to avoid crash during generation
+- Fix code highlighting for html without language specified
+- Fix warning message for gitbook version when building a multilingual book
+
+## 2.4.1
+- Fix disabling of default plugins, ex: `-highlight`
+
+## 2.4.0
+- Fix page being updated when user wants to open a link in a new tab
+- Plugins can now replaced default code highlighter
+- Add semantic information for screen readers (web version)
+- Content references accept absolute paths, resolved to book folder
+- Improve overall reliability
+
+## 2.3.3
+- Fix bug in SUMMARY parsing preventing multiple entries without filenames
+
+## 2.3.2
+- Fix blocks (like maths) in Asciidoc
+- Fix error when checking gitbook version
+
+## 2.3.1
+- Fix black font color for ebooks (mobi, pdf and epub)
+- Fix ISO code for korean language
+- Fix korean translation
+- Fix syntax highlighting for asciidoc
+- Fix inline html escaping in markdown
+- Add warning for file outside SUMMARY
+- Force SUMMARY entries to be unique by filename
+
+## 2.3.0
+- Fix nunjucks issue with multiple `{% raw %}` blocks
+- Fix crash when git conref failed
+- Fix crash when failed to download remote image (better error message)
+- Fix flicking effect when changing page (big UX improvement)
+- Add Hebrew translation (`he`)
+- Add utility method `book.config.get` for plugins
+- Hooks `page:before` and `page` are no longer deprecated
+- Remove webfonts to make website lighter
+- Make glossary's order case insensitive
+
+## 2.2.0
+- Fix direction in code blocks (always LTR)
+- Add options `chapterMark` and `pageBreaksBefore` for PDF
+- Update code highlighting library
+- `book.json` accessible as `config` in templating syntax
+- Add Vietnamese translation (`vi`)
+
+## 2.1.0
+- Fix error in calcul of `levels` in table of contents, error introduced a few versions ago
+- Add optional `styles/print.css` to replace `print.css` used in ebook
+
+## 2.0.4
+- Fix `{% raw %}`, got confused with "fake" variable declarations
+- Fix title of language chooser
+- Fix the X-UA-Compatible meta tag
+- Move style sheets to the <head> section
+
+## 2.0.3
+- Fix `gitbook init` for SUMMARY with empty entries
+- Fix escaping of code blocks in markdown
+
+## 2.0.2
+- Fix relative links in windows
+- Improve watcher in serve command (switch to chokidar)
+- Add Romanian translation (`ro`)
+- Add Finish translation (`fi`)
+- Add Japanese translation (`jp`)
+- Add Korean translation (`kr`)
+
+## 2.0.1
+- Improve error logging (display file, line and column)
+- Add back support for `options.originalInput`
+- Don't process math in markdown parser (delegated to `mathjax` plugin)
+- Fix some cases of code blocks escaping
+- Fix i18n for introduction title in json format
+- Fix reload when book configuration is updated
+- Fix backslashes in url when building on windows
+
+## 2.0.0
+- Fix page title of introduction
+- Ignore codeblocks when replacing glossary terms
+- Improve Unit Tests
+- Fix scrolling position in website when preparing page
+
+## 2.0.0-beta.5
+- Fix progress order in json format
+
+## 2.0.0-beta.4
+- Fix default generator for use programmatically
+- Add option "author" for html meta tags
+- Fix links normalization (content and hash)
+
+## 2.0.0-beta.3
+- Fix odd cases with code blocks escaping
+
+## 2.0.0-beta.2
+- Fix definition of entry point title using SUMMARY.md
+
+## 2.0.0-beta.1
+- Fix windows incompatibility
+- Add support for rtl (enabled by default for `ar` and `fa`)
+- Escape code blocks in markdown parser
+- Add Persian/Farsi translation (`fa`)
+- Add Arabic translation (`ar`)
+- Add Bengali translation (`bn`)
+- Provide generator name in template context
+
+## 2.0.0-alpha.9
+- Fix links in sidebar
+- Fix normalization of html link (README to index)
+- Fix html snippets escaping
+
+## 2.0.0-alpha.8
+- Improve locale detection for i18n
+- Fix chapter name for Glossary in pdf
+- Don't escape html in glossary items
+- Fix generation of multilingual book as ebook
+- Add "post" block attribute to post-process
+
+## 2.0.0-alpha.7
+- Fix display of glossary in ebook formats
+- Add default footer and header to pdf
+- Fix generation of json format compatible with 1.x.x
+- Add Simplifiled Chinese and Traditional Chinese translations
+
+## 2.0.0-alpha.6
+- Add es and pt translations
+- Fix replacement of glossary terms
+
+## 2.0.0-alpha.5
+- Fix copy of files/covers
+- Add back `finish:before` hook
+
+## 2.0.0-alpha.4
+- Fix copy of cover for multilingal books
+
+## 2.0.0-alpha.3
+- Norwegian translation
+- Load plugins from book in priority
+
+## 2.0.0-alpha.3
+- Fix init command
+- Update parsers to fix spaces in summary (`gitbook-parsers@0.3.1`)
+
+## 2.0.0-alpha.1
+- Externalize parsing into `gitbook-parsers` module
+- Supports AsciiDoc and reStructuredText
+- Hooks for page (`page:*`) are now deprecated, plugins should extend filters and blocks instead
+- Hooks `summary` and `glossary` (after and before) have been removed
+- Exercises and Quizzes are no longer parsed in the markdown parser
+- Support for more markdown extensions: `.markdown`, `.mdown`
+- Templates are rendered with nunjucks instead of swig, syntax is almost compatible, there is some changes with contexts and filters. `{{ super() }}` should be use instead of `{% parent %}`
+- Clean output folder on build without removing `.git` and `.svn`
+- MathJAX is no longer a default plugin
+- SVG images are converted to PNG during generation of ebooks
+- i18n in website and ebook (ru, it, de, fr)
+- New templating syntax
+- Content references (both internal and external)
+- Glossary terms are handled during generation (also in ebook format)
+
+## 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

@@ -1,81 +0,0 @@
-module.exports = function (grunt) {
-    var path = require("path");
-
-    // Load NPM tasks
-    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/javascript/vendors"
-            }
-        },
-        less: {
-            development: {
-                options: {
-                    compress: true,
-                    yuicompress: true,
-                    optimization: 2
-                },
-                files: {
-                    "theme/assets/style.css": "theme/stylesheets/website.less",
-                    "theme/assets/print.css": "theme/stylesheets/ebook.less"
-                }
-            }
-        },
-        requirejs: {
-            compile: {
-                options: {
-                    name: "gitbook",
-                    baseUrl: "theme/javascript/",
-                    out: "theme/assets/app.js",
-                    preserveLicenseComments: false,
-                    optimize: "uglify", //"uglify",
-                    include: ["requireLib"],
-                    paths: {
-                        "jQuery": 'vendors/jquery/dist/jquery',
-                        "lodash": 'vendors/lodash/dist/lodash',
-                        "requireLib": 'vendors/requirejs/require',
-                        "Mousetrap": 'vendors/mousetrap/mousetrap',
-                        "lunr": 'vendors/lunr.js/lunr',
-                        "URI": 'vendors/URIjs/src/URI',
-                        "ace": 'vendors/ace-builds/src-noconflict/'
-                    },
-                    shim: {
-                        'jQuery': {
-                            exports: '$'
-                        },
-                        'lodash': {
-                            exports: '_'
-                        },
-                        'Mousetrap': {
-                            exports: 'Mousetrap'
-                        },
-                        'lunr': {
-                            exports: 'lunr'
-                        }
-                    }
-                }
-            }
-        }
-    });
-
-    grunt.registerTask("bower-install", [ "bower-install-simple" ]);
-
-    // Build
-    grunt.registerTask('build', [
-        'bower-install',
-        'less',
-        'requirejs'
-    ]);
-
-    grunt.registerTask('default', [
-        'build'
-    ]);
-};

README.md

@@ -1,9 +1,18 @@
 GitBook
 =======
 
-[![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)
+[![Linux Build Status](https://travis-ci.org/GitbookIO/gitbook.png?branch=master)](https://travis-ci.org/GitbookIO/gitbook)
+[![Windows Build status](https://ci.appveyor.com/api/projects/status/63nlflxcwmb2pue6?svg=true)](https://ci.appveyor.com/project/GitBook/gitbook)
+[![Slack Status](https://slack.gitbook.com/badge.svg)](https://slack.gitbook.com)
 
-GitBook is a command line tool (and Node.js library) for building beautiful books and exercises using GitHub/Git and Markdown. Here is an example: [Learn Javascript](https://www.gitbook.io/book/GitBookIO/javascript). You can publish book easily online using [gitbook.io](https://www.gitbook.io) and an [editor](https://github.com/GitbookIO/editor) is available for Windows, Mac and Linux. You can follow [@GitBookIO](https://twitter.com/GitBookIO) on Twitter. Complete documentation is available at [help.gitbook.io](http://help.gitbook.io/).
+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 desktop editor is [also available](https://www.gitbook.com/editor).
+
+Check out the [GitBook Community Slack Channel](https://slack.gitbook.com), Stay updated by following [@GitBookIO](https://twitter.com/GitBookIO) on Twitter or [GitBook](https://www.facebook.com/gitbookcom) on Facebook.
+
+Complete documentation is available at [help.gitbook.com](http://help.gitbook.com/).
 
 ![Image](https://raw.github.com/GitbookIO/gitbook/master/preview.png)
 
@@ -12,132 +21,52 @@ GitBook is a command line tool (and Node.js library) for building beautiful book
 GitBook can be installed from **NPM** using:
 
 ```
-$ npm install gitbook -g
+$ npm install gitbook-cli -g
+```
+
+Create the directories and files for a book from its [SUMMARY.md](https://github.com/GitbookIO/gitbook#book-format) file (if existing) using
+
+```
+$ gitbook init
 ```
 
 You can serve a repository as a book using:
 
 ```
-$ gitbook serve ./repository
+$ gitbook serve
 ```
 
 Or simply build the static website using:
 
 ```
-$ gitbook build ./repository --output=./outputFolder
+$ gitbook build
 ```
 
-Options for commands `build` and `serve` are:
+## Features
 
-```
--o, --output <directory>  Path to output directory, defaults to ./_book
--f, --format <name>       Change generation format, defaults to site, availables are: site, page, ebook, json
---config <config file>    Configuration file to use, defaults to book.js or book.json
-```
-
-GitBook loads the default configuration from a `book.json` file in the repository if it exists.
-
-Here are the options that can be stored in this file:
-
-```js
-{
-    // Folders to use for output
-    // Caution: it overrides the value from the command line
-    // It's not advised this option in the book.json
-    "output": null,
-
-    // Generator to use for building
-    // Caution: it overrides the value from the command line
-    // It's not advised this option in the book.json
-    "generator": "site",
-
-    // Book title and description (defaults are extracted from the README)
-    "title": null,
-    "description": null,
-
-    // For ebook format, the extension to use for generation (default is detected from output extension)
-    // "epub", "pdf", "mobi"
-    // Caution: it overrides the value from the command line
-    // It's not advised this option in the book.json
-    "extension": null,
-
-    // GitHub information (defaults are extracted using git)
-    "github": null,
-    "githubHost": "https://github.com/",
-
-    // Plugins list, can contain "-name" for removing default plugins
-    "plugins": [],
-
-    // Global configuration for plugins
-    "pluginsConfig": {
-        "fontSettings": {
-            "theme": "sepia", "night" or "white",
-            "family": "serif" or "sans",
-            "size": 1 to 4
-        }
-    },
-
-    // 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": "./localtheme",
-
-    // Links in template (null: default, false: remove, string: new value)
-    "links": {
-        // Link to home in the top-left corner
-        "home": null,
-
-        // Links in top of sidebar
-        "about": null,
-        "issues": null,
-        "contribute": null,
-
-        // Sharing links
-        "sharing": {
-            "google": null,
-            "facebook": null,
-            "twitter": 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 fiel 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
-        }
-    }
-}
-```
-
-You can publish your books to our index by visiting [GitBook.io](http://www.gitbook.io)
+* [Output as a website or ebook (pdf, epub, mobi)](http://help.gitbook.com/format/output.html)
+* [Multi-Languages](http://help.gitbook.com/format/languages.html)
+* [Glossary](http://help.gitbook.com/format/glossary.html)
+* [Cover](http://help.gitbook.com/format/cover.html)
+* [AsciiDoc Support](http://help.gitbook.com/format/asciidoc.html)
+* [Variables and Templating](http://help.gitbook.com/format/templating.html)
+* [Content References](http://help.gitbook.com/format/conrefs.html)
+* [Plugins](http://help.gitbook.com/format/plugins.html)
+* 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.
-* **eBook**: A complete eBook with exercise solutions at the end of the book. Generate this format using: ```gitbook ebook ./myrepo```. You need to have [ebook-convert](http://manual.calibre-ebook.com/cli/ebook-convert.html) installed. The output format could be **PDF**, **ePub** or **MOBI**.
-* **Single Page**: The book will be stored in a single printable HTML page. This format is used for conversion to PDF or eBook. Generate this format using: ```gitbook build ./myrepo -f page```.
-* **JSON**: This format is used for debugging or extracting metadata from a book. Generate this format using: ```gitbook build ./myrepo -f json```.
+* **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
 
@@ -153,7 +82,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.
@@ -167,50 +96,11 @@ This is the summary of my book.
 
 Files that are not included in `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, who 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 which 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;
-    }
-    ```
-
-    ---
-
 #### 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/)
@@ -218,9 +108,83 @@ 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
 
@@ -229,36 +193,38 @@ The best resolution is **1800x2360**. The generation of the cover can be done au
 
 A small version of the cover can also be set by creating a file: **/cover_small.jpg**.
 
-#### Publish your book
+#### AsciiDoc
 
-The platform [GitBook.io](https://www.gitbook.io/) is like an "Heroku for books": you can create a book on it (public, paid, or private) and update it using **git push**.
+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`.
 
-#### Plugins
+## Publish your book
 
-Plugins can 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.
+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**.
 
-##### Default plugins:
+## Plugins
 
-* [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
+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.
 
-##### Other plugins:
+Plugins needed to build a book can be installed using: `gitbook install ./`. You can find plugins at [plugins.gitbook.com](http://plugins.gitbook.com).
 
-* [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
 
-#### Debugging
+## Debugging
 
-You can use the environment variable `DEBUG=true` to get better error messages (with stack trace). For example:
+You can use the options `--log=debug` and `--debug` to get better error messages (with stack trace). For example:
 
 ```
-$ export DEBUG=true
-$ gitbook build ./
+$ gitbook build ./ -- log=debug --debug
 ```
+
+#### How to use the latest commit from GitBook in gitbook-cli
+
+To use the latest commit from `GitBook/gitbook` with `gitbook-cli`:
+
+```
+$ git clone https://github.com/GitbookIO/gitbook.git ./gitbook
+$ gitbook versions:link ./gitbook
+```
+
+Now `gitbook-cli` will be using the `./gitbook` folder.
+
+You can uninstall it using: `gitbook versions:uninstall latest`.

appveyor.yml

@@ -0,0 +1,29 @@
+# Fix line endings in Windows. (runs before repo cloning)
+init:
+  - git config --global core.autocrlf input
+
+# Test against these versions of Node.js.
+environment:
+  matrix:
+    - nodejs_version: "0.10"
+    - nodejs_version: "0.11"
+
+# Install scripts. (runs after repo cloning)
+install:
+  # Get the latest stable version of Node.js or io.js
+  - ps: Install-Product node $env:nodejs_version
+  # install svgexport
+  - npm install svgexport -g
+  # install modules
+  - npm install
+
+# Post-install test scripts.
+test_script:
+  # Output useful info for debugging.
+  - node --version
+  - npm --version
+  # run tests
+  - npm test
+
+# Don't actually build.
+build: off

bin/build.js

@@ -1,63 +0,0 @@
-var path = require('path');
-var Q = require('q');
-var _ = require('lodash');
-var fs = require('fs');
-
-var utils = require('./utils');
-var generate = require("../lib/generate");
-var parse = require("../lib/parse");
-var generators = require("../lib/generate").generators;
-
-var buildCommand = function(command) {
-    return command
-    .option('-v, --verbose', 'Activate verbose mode, useful for debugging errors')
-    .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('--config <config file>', 'Configuration file to use, defaults to book.js or book.json');
-};
-
-
-var buildEbookCommand = function(command) {
-    return buildCommand(command)
-    .option('-c, --cover <path>', 'Cover image, default is cover.jpg if exists');
-};
-
-var makeBuildFunc = function(converter) {
-    return  function(dir, options) {
-        dir = dir || process.cwd();
-        outputDir = options.output;
-
-        // Set debugging
-        if(options.verbose) {
-            process.env.DEBUG = "true";
-        }
-
-        console.log('Starting build ...');
-        return converter(
-            _.extend({}, options || {}, {
-                input: dir,
-                output: outputDir,
-                generator: options.format,
-                configFile: options.config
-            })
-        )
-        .then(function(output) {
-            console.log("Successfully built!");
-            return output;
-        })
-        .fail(function(err) {
-            // Log error
-            utils.logError(err);
-
-            // Exit process with failure code
-            process.exit(-1);
-        });
-    };
-};
-
-module.exports = {
-    folder: makeBuildFunc(generate.folder),
-    file: makeBuildFunc(generate.file),
-    command: buildCommand,
-    commandEbook: buildEbookCommand
-};

bin/gitbook.js

@@ -1,121 +1,7 @@
 #! /usr/bin/env node
 
-var Q = require('q');
-var _ = require('lodash');
-var path = require('path');
-var prog = require('commander');
-var tinylr = require('tiny-lr-fork');
+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');
-var Server = require('./server');
-
-// General options
-prog
-.version(pkg.version);
-
-build.command(prog.command('build [source_dir]'))
-.description('Build a gitbook from a directory')
-.action(build.folder);
-
-build.command(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)
-.option('--no-watch', 'Disable restart with file watching')
-.action(function(dir, options) {
-    var server = new Server();
-
-    // init livereload server
-    var lrOptions = {port: 35729};
-    var lrServer = tinylr(lrOptions);
-    var lrPath = undefined;
-    lrServer.listen(lrOptions.port, function(err) {
-      if (err) { return console.log(err); }
-      console.log('Live reload server started on port: ' + lrOptions.port);
-    });
-
-    var generate = function() {
-        if (server.isRunning()) console.log("Stopping server");
-
-        server.stop()
-        .then(function() {
-            return build.folder(dir, _.extend(options || {}, {
-                cache: false,
-                defaultsPlugins: ["livereload"]
-            }));
-        })
-        .then(function(_options) {
-            console.log();
-            console.log('Starting server ...');
-            return server.start(_options.output, options.port)
-            .then(function() {
-                console.log('Serving book on http://localhost:'+options.port);
-
-                if (lrPath) {
-                  // trigger livereload
-                  lrServer.changed({body:{files:[lrPath]}})
-                }
-
-                if (!options.watch) return;
-                return utils.watch(_options.input)
-                .then(function(filepath) {
-                    // set livereload path
-                    lrPath = filepath;
-                    console.log("Restart after change in files");
-                    console.log('');
-                    return generate();
-                })
-            })
-        })
-        .fail(utils.logError);
-    };
-
-    console.log('Press CTRL+C to quit ...');
-    console.log('')
-    generate();
-});
-
-build.commandEbook(prog.command('pdf [source_dir]'))
-.description('Build a gitbook as a PDF')
-.action(function(dir, options) {
-    build.file(dir, _.extend(options, {
-        extension: "pdf",
-        format: "ebook"
-    }));
-});
-
-build.commandEbook(prog.command('epub [source_dir]'))
-.description('Build a gitbook as a ePub book')
-.action(function(dir, options) {
-    build.file(dir, _.extend(options, {
-        extension: "epub",
-        format: "ebook"
-    }));
-});
-
-build.commandEbook(prog.command('mobi [source_dir]'))
-.description('Build a gitbook as a Mobi book')
-.action(function(dir, options) {
-    build.file(dir, _.extend(options, {
-        extension: "mobi",
-        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 installed 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,44 +0,0 @@
-var Q = require('q');
-var _ = require('lodash');
-
-var http = require('http');
-var send = require('send');
-
-var path = require('path');
-var Gaze = require('gaze').Gaze;
-
-function watch(dir) {
-    var d = Q.defer();
-    dir = path.resolve(dir);
-
-    var gaze = new Gaze("**/*.md", {
-        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;
-}
-
-function logError(err) {
-    var message = err.message || err;
-    if (process.env.DEBUG != null) message = err.stack || message;
-    console.log(message);
-    return Q.reject(err);
-};
-
-
-// Exports
-module.exports = {
-    watch: watch,
-    logError: logError
-};

bower.json

@@ -1,13 +0,0 @@
-{
-    "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",
-        "ace-builds": "1.1.3"
-    }
-}

gulpfile.js

@@ -0,0 +1,47 @@
+var _ = require('lodash');
+var gulp = require('gulp');
+var gutil = require('gulp-util');
+var less = require('gulp-less');
+var rename = require('gulp-rename');
+var minifyCSS = require('gulp-minify-css');
+var browserify = require('browserify');
+var mergeStream = require('merge-stream');
+var source = require('vinyl-source-stream');
+
+gulp.task('css', function() {
+    var merged = mergeStream();
+
+    _.each({
+        'ebook.less': 'ebook/ebook.css',
+        'pdf.less': 'ebook/pdf.css',
+        'mobi.less': 'ebook/mobi.css',
+        'epub.less': 'ebook/epub.css',
+        'website.less': 'website/style.css'
+    }, function(out, input) {
+        gutil.log('compiling', input, 'into', out);
+        merged.add(gulp.src('theme/stylesheets/'+input)
+            .pipe(less())
+            .pipe(minifyCSS())
+            .pipe(rename(out))
+            .pipe(gulp.dest('theme/assets/')));
+    });
+
+    return merged;
+});
+
+gulp.task('js', function() {
+    return browserify('./theme/javascript/index.js')
+        .bundle()
+        .pipe(source('app.js'))
+        .pipe(gulp.dest('./theme/assets/website'));
+});
+
+gulp.task('assets', function() {
+    return gulp.src('./node_modules/font-awesome/fonts/*')
+    .pipe(gulp.dest('theme/assets/website/fonts/fontawesome/'));
+});
+
+gulp.task('default', ['css', 'js', 'assets'], function() {
+
+});
+

lib/blocks.js

@@ -0,0 +1,11 @@
+var _ = require('lodash');
+
+module.exports = {
+    // Return non-parsed html
+    // since blocks are by default non-parsable, a simple identity method works fine
+    html: _.identity,
+
+    // Highlight a code block
+    // This block can be extent by plugins
+    code: _.identity
+};

lib/book.js

@@ -0,0 +1,809 @@
+var Q = require('q');
+var _ = require('lodash');
+var path = require('path');
+var parsers = require('gitbook-parsers');
+
+var fs = require('./utils/fs');
+var parseNavigation = require('./utils/navigation');
+var parseProgress = require('./utils/progress');
+var pageUtil = require('./utils/page');
+var pathUtil = require('./utils/path');
+var links = require('./utils/links');
+var i18n = require('./utils/i18n');
+var logger = require('./utils/logger');
+
+var Configuration = require('./configuration');
+var TemplateEngine = require('./template');
+var PluginsList = require('./pluginslist');
+
+var generators = require('./generators');
+
+var Book = function(root, context, parent) {
+    this.context = _.defaults(context || {}, {
+        // Extend book configuration
+        config: {},
+
+        // Log function
+        log: function(msg) {
+            process.stdout.write(msg);
+        },
+
+        // Log level
+        logLevel: 'info'
+    });
+
+    // 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;
+
+    // Bind methods
+    _.bindAll(this);
+};
+
+// Return string representation
+Book.prototype.toString = function() {
+    return '[Book '+this.root+']';
+};
+
+// 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, 'languages');
+
+            // 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.lang),
+                            '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();
+    })
+
+    // Transform configuration
+    .then(function() {
+        return that.callHook('config', that.config.dump())
+        .then(function(newConfig) {
+            that.config.replace(newConfig);
+        });
+    })
+
+    // 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() {
+                var nFiles = (ops.content || []).length;
+                return _.reduce(ops.content || [], function(prev, file, i) {
+                    return prev.then(function() {
+                        var p = ((i*100)/nFiles).toFixed(0)+'%';
+                        that.log.debug.ln('processing', file, p);
+
+                        return Q(generator.convertFile(file))
+                        .fail(function(err) {
+                            // Transform error message to signal file
+                            throw that.normError(err, {
+                                fileName: file
+                            });
+                        });
+                    });
+                }, Q());
+            });
+        }
+    })
+
+    // Finish generation
+    .then(function() {
+        return that.callHook('finish:before');
+    })
+    .then(function() {
+        return generator.finish();
+    })
+    .then(function() {
+        return that.callHook('finish');
+    })
+    .then(function() {
+        that.log.info.ln('generation is finished');
+    });
+};
+
+// Generate the output for a multilingual book
+Book.prototype.generateMultiLingual = function() {
+    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());
+    });
+};
+
+// 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.setOutput(tmpDir);
+
+        return book.generate(options.ebookFormat)
+        .then(function() {
+            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.debug.ln('copy ebook to', _outputFile);
+                return fs.copy(
+                    path.join(_tmpDir, 'index.'+options.ebookFormat),
+                    _outputFile
+                );
+            };
+
+            // Multi-langs book
+            return Q()
+            .then(function() {
+                if (book.isMultilingual()) {
+                    return Q.all(
+                        _.map(book.langs, function(lang) {
+                            return copyFile(lang.lang);
+                        })
+                    )
+                    .thenResolve(book.langs.length);
+                } else {
+                    return copyFile().thenResolve(1);
+                }
+            })
+            .then(function(n) {
+                book.log.info.ok(n+' file(s) generated');
+
+                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;
+
+    // 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)
+            .fail(function(err) {
+                throw that.normError(err, {
+                    name: err.name || 'Readme Parse Error',
+                    fileName: that.readmeFile
+                });
+            });
+        });
+    })
+    .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)
+            .fail(function(err) {
+                throw that.normError(err, {
+                    name: err.name || 'Langs Parse Error',
+                    fileName: that.langsFile
+                });
+            });
+        });
+    })
+    .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,
+                entryPointTitle: that.i18n('SUMMARY_INTRODUCTION'),
+                files: that.files
+            })
+            .fail(function(err) {
+                throw that.normError(err, {
+                    name: err.name || 'Summary Parse Error',
+                    fileName: that.summaryFile
+                });
+            });
+        });
+    })
+    .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)
+            .fail(function(err) {
+                throw that.normError(err, {
+                    name: err.name || 'Glossary Parse Error',
+                    fileName: that.glossaryFile
+                });
+            });
+        });
+    })
+    .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 || 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);
+    })
+
+    // Prepare page markup
+    .then(function() {
+        return filetype.page.prepare(page.content)
+        .then(function(content) {
+            page.content = content;
+        });
+    })
+
+    // Generate template
+    .then(function() {
+        return that.template.renderPage(page);
+    })
+
+    // Prepare and Parse markup
+    .then(function(content) {
+        page.content = content;
+
+        that.log.debug.ln('use file parser', filetype.name, 'for', filename);
+        return filetype.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() {
+        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),
+                    path: filepath
+                };
+            });
+        });
+    }, Q(null));
+};
+
+// Format a string using a specific markup language
+Book.prototype.formatString = function(extension, content) {
+    return Q()
+    .then(function() {
+        var filetype = parsers.get(extension);
+        if (!filetype) throw new Error('Filetype doesn\'t exist: '+filetype);
+
+        return filetype.page(content);
+    })
+
+    // Merge sections
+    .then(function(page) {
+        return _.reduce(page.sections, function(content, section) {
+            return content + section.content;
+        }, '');
+    });
+};
+
+// Check if a file exists in the book
+Book.prototype.fileExists = function(filename) {
+    return fs.exists(
+        this.resolve(filename)
+    );
+};
+
+// Check if a file path is inside the book
+Book.prototype.fileIsInBook = function(filename) {
+    return pathUtil.isInRoot(this.root, filename);
+};
+
+// Read a file
+Book.prototype.readFile = function(filename) {
+    return fs.readFile(
+        this.resolve(filename),
+        { encoding: 'utf8' }
+    );
+};
+
+// Return stat for a file
+Book.prototype.statFile = function(filename) {
+    return fs.stat(this.resolve(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() {
+    return this.books.length > 0;
+};
+
+// Return root of the parent
+Book.prototype.parentRoot = function() {
+    if (this.parent) return this.parent.parentRoot();
+    return this.root;
+};
+
+// Return true if it's a sub-book
+Book.prototype.isSubBook = function() {
+    return !!this.parent;
+};
+
+// Test if the file is the entry point
+Book.prototype.isEntryPoint = function(fp) {
+    return fp == this.readmeFile;
+};
+
+// Alias to book.config.get
+Book.prototype.getConfig = function(key, def) {
+    return this.config.get(key, def);
+};
+
+// Resolve a path in the book source
+// Enforce that the output path in the root folder
+Book.prototype.resolve = function() {
+    return pathUtil.resolveInRoot.apply(null, [this.root].concat(_.toArray(arguments)));
+};
+
+// Convert an abslute path into a relative path to this
+Book.prototype.relative = function(p) {
+    return path.relative(this.root, p);
+};
+
+// Normalize a path to .html and convert README -> index
+Book.prototype.contentPath = function(link) {
+    if (
+        path.basename(link, path.extname(link)) == 'README' ||
+        link == this.readmeFile
+    ) {
+        link = path.join(path.dirname(link), 'index'+path.extname(link));
+    }
+
+    link = links.changeExtension(link, '.html');
+    return link;
+};
+
+// Normalize a link to .html and convert README -> index
+Book.prototype.contentLink = function(link) {
+    return links.normalize(this.contentPath(link));
+};
+
+// 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;
+};
+
+// Change output path
+Book.prototype.setOutput = function(p) {
+    var that = this;
+    this.options.output = path.resolve(p);
+
+    _.each(this.books, function(book) {
+        book.setOutput(path.join(that.options.output, book.options.language));
+    });
+};
+
+// Translate a strign according to the book language
+Book.prototype.i18n = function() {
+    var args = Array.prototype.slice.call(arguments);
+    return i18n.__.apply({}, [this.config.normalizeLanguage()].concat(args));
+};
+
+// Normalize error
+Book.prototype.normError = function(err, opts, defs) {
+    if (_.isString(err)) err = new Error(err);
+
+    // Extend err
+    _.extend(err, opts || {});
+    _.defaults(err, defs || {});
+
+    err.lineNumber = err.lineNumber || err.lineno;
+    err.columnNumber = err.columnNumber || err.colno;
+
+    err.toString = function() {
+        var attributes = [];
+
+        if (this.fileName) attributes.push('In file \''+this.fileName+'\'');
+        if (this.lineNumber) attributes.push('Line '+this.lineNumber);
+        if (this.columnNumber) attributes.push('Column '+this.columnNumber);
+        return (this.name || 'Error')+': '+this.message+((attributes.length > 0)? ' ('+attributes.join(', ')+')' : '');
+    };
+
+    return err;
+};
+
+// Call a hook in plugins
+Book.prototype.callHook = function(name, data) {
+    return this.plugins.hook(name, data);
+};
+
+module.exports= Book;

lib/config_default.js

@@ -0,0 +1,109 @@
+var path = require('path');
+
+module.exports = {
+    // Options that can't be extend
+    'configFile': 'book',
+    'generator': 'website',
+    'extension': null,
+
+    // Book metadats (somes are extracted from the README by default)
+    'title': null,
+    'description': null,
+    'isbn': null,
+    'language': 'en',
+    'direction': null,
+    'author': null,
+
+    // 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',
+        'print': 'styles/print.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': {},
+
+    // 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 for the file content
+        'fontSize': 12,
+        'fontFamily': 'Arial',
+
+        // 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',
+
+        // How to mark detected chapters.
+        // Choices are “pagebreak”, “rule”, 'both' or “none”.
+        'chapterMark' : 'pagebreak',
+
+        // An XPath expression. Page breaks are inserted before the specified elements.
+        // To disable use the expression: '/'
+        'pageBreaksBefore': '/',
+
+        // Margin (in pts)
+        // Note: 72 pts equals 1 inch
+        'margin': {
+            'right': 62,
+            'left': 62,
+            'top': 56,
+            'bottom': 56
+        },
+
+        // Header HTML template. Available variables: _PAGENUM_, _TITLE_, _AUTHOR_ and _SECTION_.
+        'headerTemplate': null,
+
+        // Footer HTML template. Available variables: _PAGENUM_, _TITLE_, _AUTHOR_ and _SECTION_.
+        'footerTemplate': null
+    }
+};

lib/configuration.js

@@ -0,0 +1,206 @@
+var _ = require('lodash');
+var Q = require('q');
+var path = require('path');
+var semver = require('semver');
+
+var pkg = require('../package.json');
+var i18n = require('./utils/i18n');
+var version = require('./version');
+
+var DEFAULT_CONFIG = require('./config_default');
+
+// Default plugins added to each books
+var DEFAULT_PLUGINS = ['highlight', 'search', 'sharing', 'fontsettings'];
+
+// Check if a plugin is a default plugin
+// Plugin should be in the list
+// And version from book.json specified for this plugin should be satisfied
+function isDefaultPlugin(name, version) {
+    if (!_.contains(DEFAULT_PLUGINS, name)) return false;
+
+    try {
+        var pluginPkg = require('gitbook-plugin-'+name+'/package.json');
+        return semver.satisfies(pluginPkg.version, version || '*');
+    } catch(e) {
+        return false;
+    }
+}
+
+// Normalize a list of plugins to use
+function normalizePluginsList(plugins, addDefaults) {
+    // 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('@');
+        var name = parts[0];
+        var version = parts[1];
+        return {
+            'name': name,
+            'version': version, // optional
+            'isDefault': isDefaultPlugin(name, version)
+        };
+    });
+
+    // 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
+    if (addDefaults !== false) {
+        _.each(DEFAULT_PLUGINS, function(plugin) {
+            if (_.find(plugins, { name: plugin })) {
+                return;
+            }
+
+            plugins.push({
+                'name': plugin,
+                'isDefault': true
+            });
+        });
+    }
+
+    // Remove plugin that start with '-'
+    plugins = _.filter(plugins, function(plugin) {
+        return !_.contains(toremove, plugin.name) && !(plugin.name.length > 0 && plugin.name[0] == '-');
+    });
+
+    // Remove duplicates
+    plugins = _.uniq(plugins, 'name');
+
+    return plugins;
+}
+
+var Configuration = function(book, options) {
+    this.book = book;
+    this.replace(options);
+};
+
+// Read and parse the configuration
+Configuration.prototype.load = function() {
+    var that = this;
+
+    return Q()
+    .then(function() {
+        var configPath, _config;
+
+        try {
+            configPath = require.resolve(
+                that.book.resolve(that.options.configFile)
+            );
+
+            // Invalidate node.js cache for livreloading
+            delete require.cache[configPath];
+
+            _config = require(configPath);
+            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() {
+        if (!that.book.isSubBook()) {
+            if (!version.satisfies(that.options.gitbook)) {
+                throw new Error('GitBook version doesn\'t satisfy version required by the book: '+that.options.gitbook);
+            }
+            if (that.options.gitbook != '*' && !semver.satisfies(semver.inc(pkg.version, 'patch'), that.options.gitbook)) {
+                that.book.log.warn.ln('gitbook version specified in your book.json might be too strict for future patches, \''+(_.first(pkg.version.split('.'))+'.x.x')+'\' is more adequate');
+            }
+        }
+
+        that.options.output = path.resolve(that.options.output || that.book.resolve('_book'));
+        that.options.plugins = normalizePluginsList(that.options.plugins);
+        that.options.defaultsPlugins = normalizePluginsList(that.options.defaultsPlugins || '', false);
+        that.options.plugins = _.union(that.options.plugins, that.options.defaultsPlugins);
+        that.options.plugins = _.uniq(that.options.plugins, 'name');
+
+        // Default value for text direction (from language)
+        if (!that.options.direction) {
+            var lang = i18n.getCatalog(that.options.language);
+            if (lang) that.options.direction = lang.direction;
+        }
+
+        that.options.gitbook = pkg.version;
+    });
+};
+
+// Extend the configuration
+Configuration.prototype.extend = function(options) {
+    _.extend(this.options, options);
+};
+
+// Replace the whole configuration
+Configuration.prototype.replace = function(options) {
+    var that = this;
+
+    this.options = _.cloneDeep(DEFAULT_CONFIG);
+    this.options = _.merge(this.options, options || {});
+
+    // options.input == book.root
+    Object.defineProperty(this.options, 'input', {
+        get: function () {
+            return that.book.root;
+        }
+    });
+
+    // options.originalInput == book.parent.root
+    Object.defineProperty(this.options, 'originalInput', {
+        get: function () {
+            return that.book.parent? that.book.parent.root : undefined;
+        }
+    });
+
+    // options.originalOutput == book.parent.options.output
+    Object.defineProperty(this.options, 'originalOutput', {
+        get: function () {
+            return that.book.parent? that.book.parent.options.output : undefined;
+        }
+    });
+};
+
+// Dump configuration as json object
+Configuration.prototype.dump = function() {
+    return _.cloneDeep(this.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 i18n.normalizeLanguage(this.options.language);
+};
+
+// Return a configuration
+Configuration.prototype.get = function(key, def) {
+    return _.get(this.options, key, def);
+};
+
+// Update a configuration
+Configuration.prototype.set = function(key, value) {
+    return _.set(this.options, key, value);
+};
+
+// Default configuration
+Configuration.DEFAULT = DEFAULT_CONFIG;
+
+module.exports= Configuration;

lib/conrefs_loader.js

@@ -0,0 +1,73 @@
+var _ = require('lodash');
+var path = require('path');
+var nunjucks = require('nunjucks');
+
+var git = require('./utils/git');
+var fs = require('./utils/fs');
+var pathUtil = require('./utils/path');
+
+// The loader should handle relative and git url
+var BookLoader = nunjucks.Loader.extend({
+    async: true,
+
+    init: function(book, opts) {
+        this.opts = _.defaults(opts || {}, {
+            interpolate: _.identity
+        });
+        this.book = book;
+    },
+
+    getSource: function(fileurl, callback) {
+        var that = this;
+
+        git.resolveFile(fileurl)
+        .then(function(filepath) {
+            // Is local file
+            if (!filepath) filepath = path.resolve(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 that.opts.interpolate(filepath, source.toString());
+            })
+            .then(function(source) {
+                return {
+                    src: source,
+                    path: filepath,
+
+                    // We disable cache sincde content is modified (shortcuts, ...)
+                    noCache: true
+                };
+            });
+        })
+        .nodeify(callback);
+    },
+
+    resolve: function(from, to) {
+        // If origin is in the book, we enforce result file to be in the book
+        if (this.book.fileIsInBook(from)) {
+            return this.book.resolve(
+                this.book.relative(path.dirname(from)),
+                to
+            );
+        }
+
+        // If origin is in a git repository, we resolve file in the git repository
+        var gitRoot = git.resolveRoot(from);
+        if (gitRoot) {
+            return pathUtil.resolveInRoot(gitRoot, to);
+        }
+
+        // If origin is not in the book (include from a git content ref)
+        return path.resolve(path.dirname(from), to);
+    },
+
+    // Handle all files as relative, so that nunjucks pass responsability to 'resolve'
+    // Only git urls are considered as absolute
+    isRelative: function(filename) {
+        return !git.checkUrl(filename);
+    }
+});
+
+module.exports = BookLoader;

lib/generate/ebook/index.js

@@ -1,93 +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");
-var stringUtils = require("../../utils/string");
-
-/*
- *  This generator inherits from the single page generator
- *  and convert the page output to ebook
- */
-var Generator = function() {
-    BaseGenerator.apply(this, arguments);
-};
-util.inherits(Generator, BaseGenerator);
-
-Generator.prototype.finish = function() {
-    var that = this;
-
-    return BaseGenerator.prototype.finish.apply(this)
-    .then(function() {
-        var d = Q.defer();
-        var format = that.options.extension || path.extname(that.options.output).replace("\.", "") || "pdf";
-
-        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,
-            "--authors": that.options.author,
-            "--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 ')]"
-        };
-
-        if (format == "pdf") {
-            var pdfOptions = _.defaults(that.options.pdf || {}, {
-                "fontSize": 12,
-                "toc": true,
-                "pageNumbers": false,
-                "paperSize": "a4",
-                "margin": {
-                    "right": 62,
-                    "left": 62,
-                    "top": 36,
-                    "bottom": 36
-                }
-            });
-
-            _.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-add-toc": Boolean(pdfOptions.toc),
-                "--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)
-            });
-        }
-
-        var command = [
-            "ebook-convert",
-            path.join(that.options.output, "index.html"),
-            path.join(that.options.output, "index."+format),
-            stringUtils.optionsToShellArgs(_options)
-        ].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,72 +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([
-        // Skip Git stuff
-        '.git/',
-        '.gitignore',
-
-        // Skip OS X meta data
-        '.DS_Store',
-
-        // Skip stuff installed by plugins
-        'node_modules',
-
-        // Skip book outputs
-        '*.pdf',
-        '*.epub',
-        '*.mobi',
-    ], '__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,79 +0,0 @@
-var _ = require("lodash");
-var path = require("path");
-var Q = require("q");
-var fs = require("./fs");
-
-var Plugin = require("./plugin");
-
-var BaseGenerator = function(options) {
-    this.options = options;
-
-    this.options.plugins = Plugin.normalizeNames(this.options.plugins);
-    this.options.plugins = _.union(this.options.plugins, this.options.defaultsPlugins);
-    this.plugins = [];
-};
-
-BaseGenerator.prototype.callHook = function(name, data) {
-    return this.plugins.hook(name, this, data);
-};
-
-BaseGenerator.prototype.loadPlugins = function() {
-    var that = this;
-
-    return Plugin.fromList(this.options.plugins, this.options.input)
-    .then(function(_plugins) {
-        that.plugins = _plugins;
-
-        return that.callHook("init");
-    });
-};
-
-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.copyCover = function() {
-    var that = this;
-
-    return Q.all([
-        fs.copy(path.join(this.options.input, "cover.jpg"), path.join(this.options.output, "cover.jpg")),
-        fs.copy(path.join(this.options.input, "cover_small.jpg"), path.join(this.options.output, "cover_small.jpg"))
-    ])
-    .fail(function() {
-        // If orignally from multi-lang, try copy from originalInput
-        if (!that.options.originalInput) return;
-
-        return Q.all([
-            fs.copy(path.join(that.options.originalInput, "cover.jpg"), path.join(that.options.output, "cover.jpg")),
-            fs.copy(path.join(that.options.originalInput, "cover_small.jpg"), path.join(that.options.output, "cover_small.jpg"))
-        ]);
-    })
-    .fail(function(err) {
-        return Q();
-    });
-};
-
-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,393 +0,0 @@
-var Q = require("q");
-var _ = require("lodash");
-var path = require("path");
-var tmp = require('tmp');
-
-var swig = require('./template');
-var fs = require("./fs");
-var parse = require("../parse");
-var Plugin = require("./plugin");
-
-var generators = {
-    "site": require("./site"),
-    "page": require("./page"),
-    "ebook": require("./ebook"),
-    "json": require("./json")
-};
-
-var defaultDescription = "Book generated using GitBook";
-
-
-var containsFiles = function(dir, files) {
-    return Q.all(_.map(files, function(file) {
-        return fs.exists(path.join(dir, file));
-    }))
-    .then(_.all);
-};
-
-// TEst if generator exists
-var checkGenerator = function(options) {
-    if (!generators[options.generator]) {
-        return Q.reject(new Error("Invalid generator (availables are: "+_.keys(generators).join(", ")+")"));
-    }
-    return Q();
-};
-
-// Create the generator and load plugins
-var loadGenerator = function(options) {
-    return checkGenerator(options)
-    .then(function() {
-        var generator = new generators[options.generator](options);
-
-        return generator.loadPlugins()
-        .then(_.constant(generator));
-    });
-};
-
-
-
-var generate = function(options) {
-    // Set defaults to options
-    options = _.defaults(options || {}, {
-        // Folders to use
-        "input": null,
-        "output": null,
-
-        // Config file (relative to input)
-        "configFile": "book",
-
-        // 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'),
-
-        // Plugins
-        "plugins": [],
-        "pluginsConfig": {},
-        "defaultsPlugins": [], // Default plugins that can't be set in book.json
-
-        // Links
-        "links": {
-            "about": null,
-            "issues": null,
-            "contribue": null,
-        }
-    });
-
-    // Validate options
-    if (!options.input) {
-        return Q.reject(new Error("Need option input (book input directory)"));
-    }
-
-    // Check files to get folder type (book, multilanguage book or neither)
-    return checkGenerator(options)
-
-    // Read config file
-    .then(function() {
-        try {
-            var _config = require(path.resolve(options.input, options.configFile));
-
-            _.extend(options, _.omit(_config, 'input', 'configFile', 'defaultsPlugins'));
-        }
-        catch(err) {
-            // No config file: not a big deal
-            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;
-        });
-    })
-
-    // Detect multi-languages book
-    .then(function() {
-        return containsFiles(options.input, ['LANGS.md'])
-    })
-
-    .then(function(isMultiLang) {
-        // Multi language book
-        if(isMultiLang) {
-            return generateMultiLang(options);
-        }
-
-        // Book
-        return generateBook(options);
-    });
-};
-
-
-var generateMultiLang = function(options) {
-    var langsSummary;
-    options.output = options.output || path.join(options.input, "_book");
-
-    return checkGenerator(options)
-
-    // Multi-languages book
-    .then(function() {
-        return fs.readFile(path.join(options.input, "LANGS.md"), "utf-8")
-    })
-
-    // Clean output folder
-    .then(function(_langsSummary) {
-        langsSummary = _langsSummary;
-        return fs.remove(options.output);
-    })
-    .then(function() {
-        return fs.mkdirp(options.output);
-    })
-
-    // Generate sub-books
-    .then(function() {
-        options.langsSummary = parse.langs(langsSummary);
-
-        // Generated a book for each valid entry
-        return _.reduce(options.langsSummary.list, function(prev, entry) {
-            return prev.then(function() {
-                return generate(_.extend({}, options, {
-                    input: path.join(options.input, entry.path),
-                    output: path.join(options.output, entry.path),
-                    originalInput: options.input,
-                    originalOutput: options.output
-                }));
-            })
-        }, Q());
-    })
-
-    .then(function() {
-        return loadGenerator(options);
-    })
-
-    // Generate languages index
-    .then(function(generator) {
-        return generator.langsIndex(options.langsSummary);
-    })
-
-    // Copy cover file
-    .then(function() {
-        return Q.all([
-            fs.copy(path.join(options.input, "cover.jpg"), path.join(options.output, "cover.jpg")),
-            fs.copy(path.join(options.input, "cover_small.jpg"), path.join(options.output, "cover_small.jpg"))
-        ])
-        .fail(function() {
-            return Q();
-        })
-    })
-
-    // Return options to caller
-    .then(_.constant(options));
-};
-
-/*
- *  Use a specific generator to convert a gitbook to a site/pdf/ebook/
- *  output is always a folder
- */
-var generateBook = function(options) {
-    var files;
-
-    options.output = options.output || path.join(options.input, "_book");
-
-    // Check if it's a book
-    return containsFiles(options.input, ['SUMMARY.md', 'README.md'])
-
-    // Fail if not a book
-    .then(function(isBook) {
-        if(!isBook) {
-            return Q.reject(new Error("Invalid gitbook repository, need SUMMARY.md and README.md"));
-        }
-    })
-
-    // Clean output folder
-    .then(function() {
-        return fs.remove(options.output);
-    })
-
-    // Get repo's URL
-    .then(function() {
-        // Git deactivated
-        if(options.github === false) {
-            options.github = null;
-            return null;
-        } else if(options.github) {
-            // Git already specified in options
-            options.github = (
-                // Support URLs in "github" entry of book.json
-                parse.git.githubID(options.github) ||
-
-                // Fallback
-                options.github
-            );
-            return;
-        }
-
-        // Try auto detecting
-        return parse.git.url(options.input)
-        .then(function(_url) {
-            // Get ID of repo
-            return parse.git.githubID(_url);
-        }, function(err) {
-            return null;
-        })
-        .then(function(repoId) {
-            options.github = repoId;
-        });
-    })
-
-    .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;
-        });
-    })
-
-    .then(function() {
-        return loadGenerator(options);
-    })
-
-    // Convert files
-    .then(function(generator) {
-        // Generate the book
-        return Q()
-
-        // 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 generation
-        .then(function() {
-            return generator.finish();
-        })
-        .then(function() {
-            return generator.callHook("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,
-    book: generateBook,
-    Plugin: Plugin,
-};

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,77 +0,0 @@
-var util = require("util");
-var path = require("path");
-var Q = require("q");
-var _ = require("lodash");
-
-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)
-        );
-    });
-};
-
-// Generate languages index
-// Contains the first languages readme and langs infos
-Generator.prototype.langsIndex = function(langs) {
-    var that = this;
-
-    if (langs.list.length == 0) return Q.reject("Need at least one language");
-
-    var mainLang = _.first(langs.list).lang;
-    console.log("Main language is", mainLang);
-
-    return Q()
-    .then(function() {
-        return fs.readFile(
-            path.join(that.options.output, mainLang, "README.json")
-        );
-    })
-    .then(function(content) {
-        var json = JSON.parse(content);
-        _.extend(json, {
-            langs: langs.list
-        });
-
-        return fs.writeFile(
-            path.join(that.options.output, "README.json"),
-            JSON.stringify(json, null, 4)
-        );
-    });
-};
-
-Generator.prototype.finish = function() {
-    // ignore
-};
-
-module.exports = Generator;

lib/generate/manifest.js

@@ -1,72 +0,0 @@
-var _ = require('lodash');
-var path = require('path');
-var Q = require('q');
-
-var fs = require("./fs");
-
-var extsToIgnore = [".gz"]
-
-var Manifest = function() {
-    this.revision = 0;
-    this.clear(Date.now());
-};
-
-// Regenerate manifest
-Manifest.prototype.clear = function(revision) {
-    if (revision) this.revision = revision;
-    this.sections = {
-        'CACHE': {},
-        'NETWORK': {},
-        'FALLBACK': {}
-    };
-    return Q(this);
-};
-
-// Add a resource
-Manifest.prototype.add = function(category, resource, value) {
-    if (_.isArray(resource)) {
-        _.each(resource, function(subres) {
-            this.add(category, subres, value);
-        }, this);
-        return;
-    }
-    this.sections[category][resource] = value;
-};
-
-// Add a directory in cache
-Manifest.prototype.addFolder = function(folder, root, except) {
-    var that = this;
-    root = root || "/";
-
-    return fs.list(folder)
-    .then(function(files) {
-        _.each(
-            // Ignore diretcories
-            _.filter(files, function(file) {
-                return file.substr(-1) != "/" && !_.contains(except, path.join(root, file)) && !_.contains(extsToIgnore, path.extname(file));
-            }),
-            function(file) {
-                that.add("CACHE", path.join(root, file));
-            }
-        );
-    })
-};
-
-// Get manifest content
-Manifest.prototype.dump = function() {
-    var lines = [
-        "CACHE MANIFEST",
-        "# Revision "+this.revision
-    ];
-
-    _.each(this.sections, function(content, section) {
-        if (_.size(content) == 0) return;
-        lines.push("");
-        lines.push(section+":");
-        lines = lines.concat(_.keys(content));
-    }, this);
-
-    return Q(lines.join("\n"));
-};
-
-module.exports = Manifest;

lib/generate/page/index.js

@@ -1,92 +0,0 @@
-var _ = require("lodash");
-var util = require("util");
-var path = require("path");
-var Q = require("q");
-var swig = require("../template");
-
-var fs = require("../fs");
-var parse = require("../../parse");
-var BaseGenerator = require("../site");
-
-
-/*
- *  This generator will generate a simple index.html which can be converted as a PDF
- */
-var Generator = function() {
-    BaseGenerator.apply(this, arguments);
-
-    // List of pages content
-    this.pages = {};
-};
-util.inherits(Generator, BaseGenerator);
-
-// Load all templates
-Generator.prototype.loadTemplates = function() {
-    this.template = swig.compileFile(
-        this.plugins.template("page") || path.resolve(this.options.theme, 'templates/page.html')
-    );
-};
-
-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: './',
-            singleFile: true
-        });
-    })
-    .then(function(sections) {
-        json.content = sections;
-    })
-    .then(function() {
-        that.pages[input] = json;
-    });
-};
-
-// Generate languages index
-Generator.prototype.langsIndex = function(langs) {
-    return Q();
-};
-
-Generator.prototype.finish = function() {
-    var that = this;
-    var basePath = ".";
-    var output = path.join(this.options.output, "index.html");
-
-    var progress = parse.progress(this.options.navigation, "README.md");
-
-    return Q()
-    // Generate html
-    .then(function(pages) {
-        return that._writeTemplate(that.template, {
-            pages: that.pages,
-            progress: progress,
-
-            basePath: basePath,
-            staticBase: path.join(basePath, "gitbook"),
-        }, output);
-    })
-
-    // Copy cover
-    .then(function() {
-        return that.copyCover();
-    })
-
-    // Copy assets
-    .then(function() {
-        return fs.copy(
-            path.join(that.options.theme, "assets"),
-            path.join(that.options.output, "gitbook")
-        );
-    });
-};
-
-module.exports = Generator;

lib/generate/plugin.js

@@ -1,207 +0,0 @@
-var _ = require("lodash");
-var Q = require("q");
-var semver = require("semver");
-var path = require("path");
-var url = require("url");
-var fs = require("./fs");
-var resolve = require('resolve');
-
-var pkg = require("../../package.json");
-
-var  RESOURCES = ["js", "css"];
-
-var Plugin = function(name, root) {
-    this.name = name;
-    this.root = root;
-    this.packageInfos = {};
-    this.infos = {};
-
-    _.each([
-        "gitbook-plugin-"+name,
-        "gitbook-theme-"+name,
-        "gitbook-"+name,
-        name,
-    ], function(_name) {
-        if (this.load(_name, __dirname)) return false;
-        if (this.load(_name, path.resolve(root))) return false;
-    }, this);
-};
-
-// 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) {
-        return false;
-    }
-};
-
-// Return resources
-Plugin.prototype.getResources = function(resource) {
-    if (!this.infos.book || !this.infos.book[resource]) {
-        return [];
-    }
-    return _.chain(this.infos.book[resource])
-    .map(function(resource) {
-        var parsed = url.parse(resource);
-        if (parsed.protocol) return {"url": resource}
-        else return { "path": this.name+"/"+resource };
-    }.bind(this))
-    .value();
-};
-
-// Test if it's a valid plugin
-Plugin.prototype.isValid = function() {
-    return (
-        this.packageInfos
-        && this.packageInfos.name
-        && this.packageInfos.engines
-        && this.packageInfos.engines.gitbook
-        && semver.satisfies(pkg.version, this.packageInfos.engines.gitbook)
-    );
-};
-
-// Resolve file path
-Plugin.prototype.resolveFile = function(filename) {
-    return path.resolve(this.baseDir, filename);
-};
-
-// Resolve file path
-Plugin.prototype.callHook = function(name, context, data) {
-    var hookFunc = this.infos.hooks? this.infos.hooks[name] : null;
-    data = data || {};
-
-    if (!hookFunc) return Q(data);
-
-    return Q()
-    .then(function() {
-        return hookFunc.apply(context, [data]);
-    });
-};
-
-// Has assets
-Plugin.prototype.hasAssets = function(out) {
-    return (this.infos.book && this.infos.book.assets);
-};
-
-// Copy plugin assets fodler
-Plugin.prototype.copyAssets = function(out) {
-    if (!this.hasAssets()) return Q();
-    return fs.copy(
-        this.resolveFile(this.infos.book.assets),
-        out
-    );
-};
-
-
-
-
-// Normalize a list of plugin name to use
-Plugin.normalizeNames = function(names) {
-    // Normalize list to an array
-    names = _.isString(names) ? names.split(",") : (names || []);
-
-    // List plugins to remove
-    var toremove = _.chain(names)
-    .filter(function(name) {
-        return name.length > 0 && name[0] == "-";
-    })
-    .map(function(name) {
-        return name.slice(1)
-    })
-    .value();
-
-    // Merge with defaults
-    names = _.chain(names)
-    .concat(Plugin.defaults)
-    .uniq()
-    .value();
-
-    // Remove plugins starting with
-    names = _.filter(names, function(name) {
-        return !_.contains(toremove, name) && !(name.length > 0 && name[0] == "-");
-    });
-
-    return names;
-};
-
-// Extract data from a list of plugin
-Plugin.fromList = function(names, root) {
-    var failed = [];
-
-    // Load plugins
-    var plugins = _.map(names, function(name) {
-        var plugin = new Plugin(name, root);
-        if (!plugin.isValid()) failed.push(name);
-        return plugin;
-    });
-
-    if (_.size(failed) > 0) return Q.reject(new Error("Error loading plugins: "+failed.join(",")));
-
-    // Get all resources
-    var resources = _.chain(RESOURCES)
-    .map(function(resource) {
-        return [
-            resource,
-            _.chain(plugins)
-            .map(function(plugin) {
-                return plugin.getResources(resource);
-            })
-            .flatten()
-            .value()
-        ];
-    })
-    .object()
-    .value();
-    resources.html = {}
-
-    _.each(plugins, function(plugin) {
-        if (!plugin.infos.book || !plugin.infos.book.html) return;
-        var html = plugin.infos.book.html || {};
-        _.each(html, function(code, key) {
-            if (!_.isFunction(code)) code = _.constant(code);
-            if (!resources.html[key]) resources.html[key] = [];
-            resources.html[key].push(code);
-        })
-    });
-
-    return Q({
-        'list': plugins,
-        'resources': resources,
-        'hook': function(name, context, data) {
-            return _.reduce(plugins, function(prev, plugin) {
-                return prev.then(function(ret) {
-                    return plugin.callHook(name, context, ret);
-                })
-            }, Q(data));
-        },
-        'template': function(name) {
-            var withTpl = _.find(plugins, function(plugin) {
-                return (plugin.infos.templates
-                    && plugin.infos.templates[name]);
-            });
-
-            if (!withTpl) return null;
-            return withTpl.resolveFile(withTpl.infos.templates[name]);
-        },
-        'html': function(tag, context, options) {
-            return _.map(resources.html[tag] || [], function(code) {
-                return code.call(context, options);
-            }).join("\n");
-        }
-    });
-};
-
-// Default plugins
-Plugin.defaults = [
-    "mathjax"
-];
-
-module.exports = Plugin;

lib/generate/site/index.js

@@ -1,241 +0,0 @@
-var util = require("util");
-var path = require("path");
-var Q = require("q");
-var _ = require("lodash");
-var swig = require("../template");
-
-var fs = require("../fs");
-var parse = require("../../parse");
-var BaseGenerator = require("../generator");
-var links = require("../../utils/links");
-var indexer = require('./search_indexer');
-var Manifest = require('../manifest');
-
-
-
-var Generator = function() {
-    BaseGenerator.apply(this, arguments);
-
-    // Attach methods to instance
-    _.bindAll(this);
-
-    this.revision = Date.now();
-    this.indexer = indexer();
-    this.manifest = new Manifest(Date.now());
-    this.manifest.add("NETWORK", [
-        '*'
-    ]);
-};
-util.inherits(Generator, BaseGenerator);
-
-// Load all templates
-Generator.prototype.loadTemplates = function() {
-    this.template = swig.compileFile(
-        this.plugins.template("site") || path.resolve(this.options.theme, 'templates/site.html')
-    );
-    this.langsTemplate = swig.compileFile(
-        this.plugins.template("langs") || path.resolve(this.options.theme, 'templates/langs.html')
-    );
-};
-
-// Load plugins
-Generator.prototype.loadPlugins = function() {
-    var that = this;
-
-    return BaseGenerator.prototype.loadPlugins.apply(this)
-    .then(function() {
-        return that.loadTemplates();
-    });
-};
-
-// Generate a template
-Generator.prototype._writeTemplate = function(tpl, options, output, interpolate) {
-    var that = this;
-
-    interpolate = interpolate || _.identity;
-    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,
-
-            plugins: that.plugins,
-            pluginsConfig: JSON.stringify(that.options.pluginsConfig),
-            htmlSnippet: _.partialRight(that.plugins.html, that, options),
-
-            options: that.options
-        }, options));
-    })
-    .then(interpolate)
-    .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;
-
-    _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) || ".";
-
-    var page = {
-        path: _input,
-        content: content,
-        progress: parse.progress(this.options.navigation, _input)
-    };
-
-    var _callHook = function(name) {
-        return that.callHook(name, page)
-        .then(function(_page) {
-            page = _page;
-            return page;
-        });
-    };
-
-    return Q()
-    .then(function() {
-        // Send content to plugins
-        return _callHook("page:before");
-    })
-    .then(function() {
-        // Lex page
-        return parse.lex(page.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) {
-        page.sections = sections;
-
-        // Use plugin hook
-        return _callHook("page");
-    })
-    .then(function() {
-        that.manifest.add("CACHE", _output);
-
-        return that._writeTemplate(that.template, {
-            progress: page.progress,
-
-            _input: _input,
-            content: page.sections,
-
-            basePath: basePath,
-            staticBase: links.join(basePath, "gitbook"),
-        }, output, function(html) {
-            page.content = html;
-
-            return _callHook("page:after").get("content")
-        });
-    });
-};
-
-// 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;
-
-    // Copy gitbook assets
-    return fs.copy(
-        path.join(that.options.theme, "assets"),
-        path.join(that.options.output, "gitbook")
-    )
-
-    // Add to cache manifest
-    .then(function() {
-        return that.manifest.addFolder(path.join(that.options.output, "gitbook"), "gitbook");
-    })
-
-    // Copy plugins assets
-    .then(function() {
-        return Q.all(
-            _.map(that.plugins.list, function(plugin) {
-                if (!plugin.hasAssets()) return Q();
-
-                var pluginAssets = path.join(that.options.output, "gitbook/plugins/", plugin.name);
-                return plugin.copyAssets(pluginAssets)
-                .then(function() {
-                    return that.manifest.addFolder(pluginAssets, "gitbook/plugins/"+plugin.name);
-                });
-            })
-        );
-    })
-};
-
-// Dump search index to disk
-Generator.prototype.writeSearchIndex = function() {
-    return fs.writeFile(
-        path.join(this.options.output, 'search_index.json'),
-        this.indexer.dump()
-    );
-};
-
-
-// Add cache manifest
-Generator.prototype.writeCacheManifest = function() {
-    return fs.writeFile(
-        path.join(this.options.output, 'manifest.appcache'),
-        this.manifest.dump()
-    );
-};
-
-Generator.prototype.finish = function() {
-    var deferred = this.copyAssets()
-    .then(this.copyCover)
-    .then(this.writeSearchIndex);
-
-    if (this.options.cache !== false) {
-        deferred = deferred.then(this.writeCacheManifest);
-    }
-
-    return deferred;
-};
-
-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/generate/template.js

@@ -1,52 +0,0 @@
-var path = require("path");
-var swig = require('swig');
-var hljs = require('highlight.js');
-
-var links = require('../utils/').links;
-var pkg = require('../../package.json');
-
-swig.setDefaults({
-    locals: {
-        gitbook: {
-            version: pkg.version
-        }
-    }
-});
-
-// 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;
-});
-
-// Swig filter: highlight coloration
-swig.setFilter('code', function(code, lang) {
-    try {
-        return hljs.highlight(lang, code).value;
-    } catch(e) {
-        return hljs.highlightAuto(code).value;
-    }
-});
-
-// Convert a level into a deep level
-swig.setFilter('lvl', function(lvl) {
-    return lvl.split(".").length;
-});
-
-// Join path
-swig.setFilter('pathJoin', function(base, _path) {
-    return path.join(base, _path);
-});
-
-// Is a link an absolute link
-swig.setFilter('isExternalLink', function(link) {
-    return links.isExternal(link);
-});
-
-module.exports = swig;

lib/generator.js

@@ -0,0 +1,76 @@
+var _ = require('lodash');
+var path = require('path');
+var Q = require('q');
+var fs = require('./utils/fs');
+
+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.callHook(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(
+        this.book.resolve(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(that.book.resolve('cover.jpg'), path.join(that.options.output, 'cover.jpg')),
+        fs.copy(that.book.resolve('cover_small.jpg'), path.join(that.options.output, 'cover_small.jpg'))
+    ])
+    .fail(function() {
+        // If orignaly from multi-lang, try copy from parent
+        if (!that.book.isSubBook()) 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() {
+        return Q();
+    });
+};
+
+// 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,172 @@
+var util = require('util');
+var path = require('path');
+var Q = require('q');
+var _ = require('lodash');
+var juice = require('juice');
+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(['print', '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'));
+};
+
+// Return template for footer/header with inlined css
+Generator.prototype.getPDFTemplate = function(id) {
+    var tpl = this.options.pdf[id+'Template'];
+    var defaultTpl = path.resolve(this.options.theme, 'templates/ebook/'+id+'.html');
+    var defaultCSS = path.resolve(this.options.theme, 'assets/ebook/pdf.css');
+
+    // Default template from theme
+    if (!tpl && fs.existsSync(defaultTpl)) {
+        tpl = fs.readFileSync(defaultTpl, { encoding: 'utf-8' });
+    }
+
+    // Inline CSS using juice
+    var stylesheets = [];
+
+    // From theme
+    if (fs.existsSync(defaultCSS)) {
+        stylesheets.push(fs.readFileSync(defaultCSS, { encoding: 'utf-8' }));
+    }
+
+    // Custom PDF style
+    if (this.styles.pdf) {
+        stylesheets.push(fs.readFileSync(this.book.resolve(this.styles.pdf), { encoding: 'utf-8' }));
+    }
+
+    tpl = juice(tpl, {
+        extraCss: stylesheets.concat('/n')
+    });
+
+    return tpl;
+};
+
+Generator.prototype.finish = function() {
+    var that = this;
+
+    return Q()
+    .then(this.copyAssets)
+    .then(this.copyCover)
+    .then(this.writeGlossary)
+    .then(this.writeSummary)
+    .then(function() {
+        if (!that.ebookFormat) return Q();
+
+        if (!that.options.cover && fs.existsSync(path.join(that.options.output, 'cover.jpg'))) {
+            that.options.cover = path.join(that.options.output, 'cover.jpg');
+        }
+
+        var d = Q.defer();
+
+        var _options = {
+            '--cover': that.options.cover,
+            '--title': that.options.title,
+            '--comments': that.options.description,
+            '--isbn': that.options.isbn,
+            '--authors': that.options.author,
+            '--language': that.options.language,
+            '--book-producer': 'GitBook',
+            '--publisher': 'GitBook',
+            '--chapter': 'descendant-or-self::*[contains(concat(\' \', normalize-space(@class), \' \'), \' book-chapter \')]',
+            '--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, {
+                '--chapter-mark': String(pdfOptions.chapterMark),
+                '--page-breaks-before': String(pdfOptions.pageBreaksBefore),
+                '--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': that.getPDFTemplate('header'),
+                '--pdf-footer-template': that.getPDFTemplate('footer'),
+                '--pdf-sans-family': String(pdfOptions.fontFamily)
+            });
+        } else if (that.ebookFormat == 'epub') {
+            _.extend(_options, {
+                '--dont-split-on-page-breaks': true
+            });
+        }
+
+        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) {
+            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,76 @@
+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() { };
+
+// 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)
+        );
+    });
+};
+
+// Finish generation
+Generator.prototype.finish = function() {
+    return this.writeReadme();
+};
+
+// Write README.json
+Generator.prototype.writeReadme = function() {
+    var that = this;
+    var mainLang, langs, readme;
+
+    return Q()
+    .then(function() {
+        langs = that.book.langs;
+        mainLang = langs.length > 0? _.first(langs).lang : null;
+
+        readme = links.changeExtension(that.book.readmeFile, ".json");
+
+        // Read readme from main language
+        return fs.readFile(
+            mainLang? path.join(that.options.output, mainLang, readme) : path.join(that.options.output, 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,262 @@
+var util = require('util');
+var path = require('path');
+var Q = require('q');
+var _ = require('lodash');
+
+var nunjucks = require('nunjucks');
+var AutoEscapeExtension = require('nunjucks-autoescape')(nunjucks);
+var FilterExtension = require('nunjucks-filter')(nunjucks);
+
+var fs = require('../utils/fs');
+var BaseGenerator = require('../generator');
+var links = require('../utils/links');
+var i18n = require('../utils/i18n');
+
+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 (stylePath && fs.existsSync(that.book.resolve(stylePath))) {
+                return [style, stylePath];
+            }
+            return null;
+        })
+        .compact()
+        .object()
+        .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 Q()
+    .then(function() {
+        var language = that.book.config.normalizeLanguage();
+
+        if (!i18n.hasLocale(language)) {
+            that.book.log.warn.ln('Language "'+language+'" is not available as a layout locales (en, '+i18n.getLocales().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));
+    });
+};
+
+// Finis generation
+Generator.prototype.finish = function() {
+    return this.copyAssets()
+    .then(this.copyCover)
+    .then(this.writeGlossary)
+    .then(this.writeLangsIndex);
+};
+
+// 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.contentPath(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.debug.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.writeLangsIndex = function() {
+    if (!this.book.langs.length) return Q();
+
+    return this._writeTemplate(this.templates.langs, {
+        langs: this.book.langs
+    }, path.join(this.options.output, 'index.html'));
+};
+
+// Write glossary
+Generator.prototype.writeGlossary = function() {
+    // No glossary
+    if (this.book.glossary.length === 0) return Q();
+
+    return this._writeTemplate(this.templates.glossary, {}, path.join(this.options.output, 'GLOSSARY.html'));
+};
+
+// 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() {
+        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'),
+
+                '__': that.book.i18n.bind(that.book)
+            }, 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/'+this.namespace),
+        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,215 @@
-module.exports = {
-    parse: require('./parse/'),
-    generate: require('./generate/')
+/*eslint no-console: 0*/
+
+var Q = require('q');
+var _ = require('lodash');
+var path = require('path');
+var tinylr = require('tiny-lr');
+var color = require('bash-color');
+
+var Book = require('./book');
+var initBook = require('./init');
+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'
+};
+
+// Export init to gitbook library
+Book.init = initBook;
+
+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;
+
+                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 file', filepath);
+                                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) {
+                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) {
+                return initBook(args[0] || process.cwd())
+                .then(function(){
+                    console.log('');
+                    console.log(color.green('Done, without error'));
+                });
+            }
+        }
+    ])
+};

lib/init.js

@@ -0,0 +1,83 @@
+var _ = require('lodash');
+var Q = require('q');
+var path = require('path');
+
+var Book = require('./book');
+var fs = require('./utils/fs');
+
+// Initialize folder structure for a book
+// Read SUMMARY to created the right chapter
+function initBook(root, opts) {
+    var book = new Book(root, opts);
+    var extensionToUse = '.md';
+
+    var chaptersPaths = function(chapters) {
+        return _.reduce(chapters || [], function(accu, chapter) {
+            var o = {
+                title: chapter.title
+            };
+            if (chapter.path) o.path = chapter.path;
+
+            return accu.concat(
+                [o].concat(chaptersPaths(chapter.articles))
+            );
+        }, []);
+    };
+
+    book.log.info.ln('init book at', root);
+    return fs.mkdirp(root)
+    .then(function() {
+        book.log.info.ln('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) {
+            if (!chapter.path) return Q();
+            var absolutePath = path.resolve(book.root, chapter.path);
+
+            return fs.exists(absolutePath)
+            .then(function(exists) {
+                if(exists) {
+                    book.log.info.ln('found', chapter.path);
+                    return;
+                } else {
+                    book.log.info.ln('create', chapter.path);
+                }
+
+                return fs.mkdirp(path.dirname(absolutePath))
+                .then(function() {
+                    return fs.writeFile(absolutePath, '# '+chapter.title+'\n');
+                });
+            });
+        }));
+    })
+    .then(function() {
+        book.log.info.ln('initialization is finished');
+    });
+}
+
+module.exports = initBook;

lib/parse/git.js

@@ -1,56 +0,0 @@
-var Q = require('q');
-var _ = require('lodash');
-var cp = require('child_process');
-var url = require('url');
-
-// 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 : undefined;
-
-    // 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();});
-}
-
-module.exports = {
-    url: gitURL,
-    githubID: githubID,
-    titleCase: titleCase
-};

lib/parse/index.js

@@ -1,10 +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'),
-    git: require('./git')
-};

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/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,45 +0,0 @@
-var _ = require('lodash');
-var marked = require('marked');
-var textRenderer = require('marked-text-renderer');
-
-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;
-    var renderer = textRenderer();
-
-    // Parse content
-    nodes = marked.lexer(src);
-
-    title = extractFirstNode(nodes, "heading") || '';
-    description = extractFirstNode(nodes, "paragraph") || '';
-
-    var convert = _.compose(
-        function(text) {
-            return _.unescape(text.replace(/(\r\n|\n|\r)/gm, ""));
-        },
-        function(text) {
-            return marked.parse(text, _.extend({}, marked.defaults, {
-                renderer: renderer
-            }));
-        }
-    );
-
-    return {
-        title: convert(title),
-        description: convert(description)
-    };
-}
-
-
-// Exports
-module.exports = parseReadme;

lib/parse/renderer.js

@@ -1,139 +0,0 @@
-var url = require('url');
-var inherits = require('util').inherits;
-var links = require('../utils').links;
-
-
-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++;
-    this.quizIndex = 0;
-}
-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) {
-    // Our "fixed" href
-    var _href = href;
-
-    // Don't build if it looks malicious
-    if (this.options.sanitize && this._unsanitized(href)) {
-        return text;
-    }
-
-    // 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(links.isRelative(_href)) {
-        if (path.extname(_href) == ".md") {
-            _href = links.toAbsolute(_href, o.dir || "./", o.outdir || "./");
-
-            if (o.singleFile) {
-                _href = "#"+_href;
-            } else {
-                _href = _href.replace(".md", ".html");
-            }
-        } else if (o && o.repo && o.dir) {
-            href = url.resolve('https://github.com/' + o.repo + '/blob/', [o.dir, _href].join("/"));
-            parsed = url.parse(href);
-            _href = parsed.href;
-        }
-    }
-
-    // Generate HTML for link
-    var out = '<a href="' + _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(links.isRelative(href) && o && o.dir && o.outdir) {
-        // o.dir: directory parent of the file currently in rendering process
-        // o.outdir: directory parent from the html output
-
-        _href = links.toAbsolute(_href, o.dir, o.outdir);
-    }
-
-    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 quizIdentifier = 'quiz-row-' + this.id + '-' + this.quizRowId + '-' + this.quizIndex++;
-    var field = "<input name='" + quizIdentifier + "' id='" + quizIdentifier + "' type='";
-    field += match[1] === '(' ? "radio" : "checkbox";
-    field += match[2] === 'x' ? "' checked/>" : "'/>";
-    var splittedText = text.split(fieldRegex);
-    var length = splittedText.length;
-    var label = '<label class="quiz-label" for="' + quizIdentifier + '">' + splittedText[length - 1] + '</label>';
-    return text.replace(fieldRegex, field).replace(splittedText[length - 1], label);
-}
-
-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,134 +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].replace(/\\/g, '/'),
-    };
-}
-
-function parseChapter(nodes, nums) {
-    return _.extend(parseTitle(_.first(nodes).text, nums), {
-        articles: _.map(listSplit(filterList(nodes), 'list_item_start', 'list_item_end'), function(nodes, i) {
-            return parseChapter(nodes, nums.concat(i + 1));
-        })
-    });
-}
-
-function defaultChapterList(chapterList) {
-    var first = _.first(chapterList);
-
-    var chapter = parseChapter(first, [0]);
-
-    // Already have README node, we're good to go
-    if(chapter.path === 'README.md') {
-        return chapterList;
-    }
-
-    return [
-        [ { type: 'text', text: '[Introduction](README.md)' } ]
-    ].concat(chapterList);
-}
-
-function parseSummary(src) {
-    var nodes = marked.lexer(src);
-
-    // Get out list of chapters
-    var chapterList = listSplit(
-        filterList(nodes),
-        'list_item_start', 'list_item_end'
-    );
-
-    // Split out chapter sections
-    var chapters = defaultChapterList(chapterList)
-    .map(function(nodes, i) {
-        return parseChapter(nodes, [i]);
-    });
-
-    return {
-        chapters: chapters
-    };
-}
-
-
-// Exports
-module.exports = parseSummary;

lib/plugin.js

@@ -0,0 +1,241 @@
+var _ = require('lodash');
+var Q = require('q');
+var path = require('path');
+var url = require('url');
+var fs = require('./utils/fs');
+var resolve = require('resolve');
+var mergeDefaults = require('merge-defaults');
+var jsonschema = require('jsonschema');
+var jsonSchemaDefaults = require('json-schema-defaults');
+
+var version = require('./version');
+
+var PLUGIN_PREFIX = 'gitbook-plugin-';
+
+// Return an absolute name for the plugin (the one on NPM)
+function absoluteName(name) {
+    if (name.indexOf(PLUGIN_PREFIX) === 0) return name;
+    return [PLUGIN_PREFIX, name].join('');
+}
+
+
+var Plugin = function(book, name) {
+    this.book = book;
+    this.name = absoluteName(name);
+    this.packageInfos = {};
+    this.infos = {};
+
+    // Bind methods
+    _.bindAll(this);
+
+    _.each([
+        absoluteName(name),
+        name
+    ], function(_name) {
+        // Load from the book
+        if (this.load(_name, book.root)) return false;
+
+        // Load from default plugins
+        if (this.load(_name, __dirname)) return false;
+    }, this);
+};
+
+// Type of plugins resources
+Plugin.RESOURCES = ['js', 'css'];
+Plugin.HOOKS = [
+    'init', 'finish', 'finish:before', 'config', 'page', 'page:before'
+];
+
+// Return the reduce name for the plugin
+// "gitbook-plugin-test" -> "test"
+// Return a relative name for the plugin (the one on GitBook)
+Plugin.prototype.reducedName = function() {
+    return this.name.replace(PLUGIN_PREFIX, '');
+};
+
+// 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 = this.packageInfos.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 &&
+        version.satisfies(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;
+};
+
+// Normalize, validate configuration for this plugin using its schema
+// Throw an error when shcema is not respected
+Plugin.prototype.validateConfig = function(config) {
+    var that = this;
+
+    return Q()
+    .then(function() {
+        var schema = that.packageInfos.gitbook || {};
+        if (!schema) return config;
+
+        // Normalize schema
+        schema.id = '/pluginsConfig.'+that.reducedName();
+        schema.type = 'object';
+
+        // Validate and throw if invalid
+        var v = new jsonschema.Validator();
+        var result = v.validate(config, schema, {
+            propertyName: 'pluginsConfig.'+that.reducedName()
+        });
+
+        // Throw error
+        if (result.errors.length > 0) {
+            throw new Error('Configuration Error: '+result.errors[0].stack);
+        }
+
+        // Insert default values
+        var defaults = jsonSchemaDefaults(schema);
+        return mergeDefaults(config, defaults);
+    });
+};
+
+// 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 removed 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));
+};
+
+// Get config from book
+Plugin.prototype.getConfig = function() {
+    return this.book.config.get('pluginsConfig.'+this.reducedName(), {});
+};
+
+// Set configuration for this plugin
+Plugin.prototype.setConfig = function(values) {
+    return this.book.config.set('pluginsConfig.'+this.reducedName(), values);
+};
+
+module.exports = Plugin;

lib/pluginslist.js

@@ -0,0 +1,230 @@
+var _ = require('lodash');
+var Q = require('q');
+var npmi = require('npmi');
+var npm = require('npm');
+var semver = require('semver');
+
+var Plugin = require('./plugin');
+var version = require('./version');
+
+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) {
+    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);
+    }
+
+    return Q()
+
+    // Validate and normalize configuration
+    .then(function() {
+        var config = plugin.getConfig();
+        return plugin.validateConfig(config);
+    })
+    .then(function(config) {
+        // Update configuration
+        plugin.setConfig(config);
+
+        // Extract filters
+        that.book.template.addFilters(plugin.getFilters());
+
+        // Extract blocks
+        that.book.template.addBlocks(plugin.getBlocks());
+
+        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;
+
+    // Remove defaults (no need to install)
+    var plugins = _.reject(that.book.options.plugins, {
+        isDefault: true
+    });
+
+    // 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 && version.satisfies(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,466 @@
+var _ = require('lodash');
+var Q = require('q');
+var path = require('path');
+var nunjucks = require('nunjucks');
+var parsers = require('gitbook-parsers');
+var escapeStringRegexp = require('escape-string-regexp');
+
+var batch = require('./utils/batch');
+var pkg = require('../package.json');
+var defaultBlocks = require('./blocks');
+var BookLoader = require('./conrefs_loader');
+
+// Normalize result from a block
+function normBlockResult(blk) {
+    if (_.isString(blk)) blk = { body: blk };
+    return blk;
+}
+
+
+var TemplateEngine = function(book) {
+    var that = this;
+
+    this.book = book;
+    this.log = this.book.log;
+
+    // Template loader
+    this.loader = new BookLoader(book, {
+        // Replace shortcuts in imported files
+        interpolate: function(filepath, source) {
+            var parser = parsers.get(path.extname(filepath));
+            var type = parser? parser.name : null;
+
+            return  that.applyShortcuts(type, source);
+        }
+    });
+
+    // Nunjucks env
+    this.env = new nunjucks.Environment(
+        this.loader,
+        {
+            // 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 bodies (that requires post-processing)
+    this.blockBodies = {};
+
+    // Map of added blocks
+    this.blocks = {};
+
+    // Bind methods
+    _.bindAll(this);
+
+    // Add default blocks
+    this.addBlocks(defaultBlocks);
+};
+
+// Process the result of block in a context
+TemplateEngine.prototype.processBlock = function(blk) {
+    blk = _.defaults(blk, {
+        parse: false,
+        post: undefined
+    });
+    blk.id = _.uniqueId('blk');
+
+    var toAdd = (!blk.parse) || (blk.post !== undefined);
+
+    // Add to global map
+    if (toAdd) this.blockBodies[blk.id] = blk;
+
+    // Parsable block, just return it
+    if (blk.parse) {
+        return blk.body;
+    }
+
+    // Return it as a position marker
+    return '@%@'+blk.id+'@%@';
+};
+
+// Replace position markers of blocks by body after processing
+// This is done to avoid that markdown/asciidoc 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.blockBodies[key];
+        if (!blk) return match;
+
+        var body = blk.body;
+
+        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) {
+        // Filter doesn't exist
+    }
+
+    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 multiple filters
+TemplateEngine.prototype.addFilters = function(filters) {
+    _.each(filters, function(filter, name) {
+        this.addFilter(name, filter);
+    }, this);
+};
+
+// Return nunjucks extension name of a block
+TemplateEngine.prototype.blockExtName = function(name) {
+    return 'Block'+name+'Extension';
+};
+
+// Test if a block is defined
+TemplateEngine.prototype.hasBlock = function(name) {
+    return this.env.hasExtension(this.blockExtName(name));
+};
+
+// Remove a block
+TemplateEngine.prototype.removeBlock = function(name) {
+    if (!this.hasBlock(name)) return;
+
+    // Remove nunjucks extension
+    this.env.removeExtension(this.blockExtName(name));
+
+    // Cleanup shortcuts
+    this.shortcuts = _.reject(this.shortcuts, {
+        block: name
+    });
+};
+
+// Add a block
+TemplateEngine.prototype.addBlock = function(name, block) {
+    var that = this, Ext, extName;
+
+    if (_.isFunction(block)) block = { process: block };
+
+    block = _.defaults(block || {}, {
+        shortcuts: [],
+        end: 'end'+name,
+        process: _.identity,
+        blocks: []
+    });
+
+    extName = this.blockExtName(name);
+
+    if (this.hasBlock(name) && !defaultBlocks[name]) {
+        this.log.warn.ln('conflict in blocks, \''+name+'\' is already defined');
+    }
+
+    // Cleanup previous block
+    this.removeBlock(name);
+
+    this.log.debug.ln('add block \''+name+'\'');
+    this.blocks[name] = block;
+
+    Ext = function () {
+        this.tags = [name];
+
+        this.parse = function(parser, nodes) {
+            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
+            var blocks = args
+                .concat([])
+                .slice(-block.blocks.length);
+
+            // Eliminate blocks from list
+            if (block.blocks.length > 0) args = args.slice(0, -block.blocks.length);
+
+            // Extract main body and kwargs
+            var body = args.pop();
+            var kwargs = _.isObject(_.last(args))? args.pop() : {};
+
+            // Extract blocks body
+            var _blocks =  _.map(block.blocks, function(blockName, i){
+                return {
+                    name: blockName,
+                    body: blocks[i]()
+                };
+            });
+
+            Q()
+            .then(function() {
+                return that.applyBlock(name, {
+                    body: body(),
+                    args: args,
+                    kwargs: kwargs,
+                    blocks: _blocks
+                }, context);
+            })
+
+            // 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({
+            block: name,
+            parsers: shortcut.parsers,
+            start: shortcut.start,
+            end: shortcut.end,
+            tag: {
+                start: name,
+                end: block.end
+            }
+        });
+    }, this);
+};
+
+// Add multiple blocks
+TemplateEngine.prototype.addBlocks = function(blocks) {
+    _.each(blocks, function(block, name) {
+        this.addBlock(name, block);
+    }, this);
+};
+
+// Apply a block to some content
+// This method result depends on the type of block (async or sync)
+TemplateEngine.prototype.applyBlock = function(name, blk, ctx) {
+    var func, block, r;
+
+    block = this.blocks[name];
+    if (!block) throw new Error('Block not found \''+name+'\'');
+    if (_.isString(blk)) {
+        blk = {
+            body: blk
+        };
+    }
+
+    blk = _.defaults(blk, {
+        args: [],
+        kwargs: {},
+        blocks: []
+    });
+
+    // Bind and call block processor
+    func = this.bindContext(block.process);
+    r = func.call(ctx || {}, blk);
+
+    if (Q.isPromise(r)) return r.then(normBlockResult);
+    else return normBlockResult(r);
+};
+
+// Apply a shortcut to a string
+TemplateEngine.prototype._applyShortcut = function(parser, content, shortcut) {
+    if (!_.contains(shortcut.parsers, parser)) return content;
+    var regex = new RegExp(
+        escapeStringRegexp(shortcut.start) + '([\\s\\S]*?[^\\$])' + escapeStringRegexp(shortcut.end),
+       'g'
+    );
+    return content.replace(regex, function(all, match) {
+        return '{% '+shortcut.tag.start+' %}'+ match + '{% '+shortcut.tag.end+' %}';
+    });
+};
+
+// Apply all shortcuts to some template string
+TemplateEngine.prototype.applyShortcuts = function(type, content) {
+    return _.reduce(this.shortcuts, _.partial(this._applyShortcut.bind(this), type), content);
+};
+
+// Render a string from the book
+TemplateEngine.prototype.renderString = function(content, context, options) {
+    context = _.extend({}, context, {
+        // Variables from book.json
+        book: this.book.options.variables,
+
+        // Complete book.json
+        config: this.book.options,
+
+        // infos about gitbook
+        gitbook: {
+            version: pkg.version,
+            generator: this.book.options.generator
+        }
+    });
+    options = _.defaults(options || {}, {
+        path: null,
+        type: null
+    });
+    if (options.path) options.path = this.book.resolve(options.path);
+    if (!options.type && options.path) {
+        var parser = parsers.get(path.extname(options.path));
+        options.type = parser? parser.name : null;
+    }
+
+    // Replace shortcuts
+    content = this.applyShortcuts(options.type, content);
+
+    return Q.nfcall(this.env.renderString.bind(this.env), content, context, options)
+    .fail(function(err) {
+        if (_.isString(err)) err = new Error(err);
+        err.message = err.message.replace(/^Error: /, '');
+
+        throw err;
+    });
+};
+
+// Render a file from the book
+TemplateEngine.prototype.renderFile = function(filename) {
+    var that = this;
+
+    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;
+
+    return that.book.statFile(page.path)
+    .then(function(stat) {
+        var 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) {
+    var that = this;
+
+    return Q(content)
+    .then(that.replaceBlocks)
+    .then(function(_content) {
+        return batch.execEach(that.blockBodies, {
+            max: 20,
+            fn: function(blk, blkId) {
+                return Q()
+                .then(function() {
+                    if (!blk.post) return Q();
+                    return blk.post();
+                })
+                .then(function() {
+                    delete that.blockBodies[blkId];
+                });
+            }
+        })
+        .thenResolve(_content);
+    });
+};
+
+module.exports = TemplateEngine;

lib/utils/batch.js

@@ -0,0 +1,52 @@
+var Q = require("q");
+var _ = require("lodash");
+
+// Execute a method for all element
+function execEach(items, options) {
+    if (_.size(items) === 0) return Q();
+    var concurrents = 0, d = Q.defer(), pending = [];
+
+    options = _.defaults(options || {}, {
+        max: 100,
+        fn: function() {}
+    });
+
+
+    function startItem(item, i) {
+        if (concurrents >= options.max) {
+            pending.push([item, i]);
+            return;
+        }
+
+        concurrents++;
+        Q()
+        .then(function() {
+            return options.fn(item, i);
+        })
+        .then(function() {
+            concurrents--;
+
+            // Next pending
+            var next = pending.shift();
+
+            if (concurrents === 0 && !next) {
+                d.resolve();
+            } else if (next) {
+                startItem.apply(null, next);
+            }
+        })
+        .fail(function(err) {
+            pending = [];
+            d.reject(err);
+        });
+    }
+
+    _.each(items, startItem);
+
+    return d.promise;
+}
+
+module.exports = {
+    execEach: execEach
+};
+

lib/utils/fs.js

@@ -0,0 +1,181 @@
+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.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 (fs.existsSync(filename)) {
+        _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,127 @@
+var  Q = require("q");
+var _ = require("lodash");
+var path = require("path");
+var crc = require("crc");
+var exec = Q.denodeify(require("child_process").exec);
+var URI = require("URIjs");
+var pathUtil = require("./path");
+
+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);
+    });
+}
+
+// Return root of git repo from a filepath
+function resolveGitRoot(filepath) {
+    var relativeToGit, repoId;
+
+    // No git repo cloned, or file is not in a git repository
+    if (!GIT_TMP || !pathUtil.isInRoot(GIT_TMP, filepath)) return null;
+
+    // Extract first directory (is the repo id)
+    relativeToGit = path.relative(GIT_TMP, filepath);
+    repoId = _.first(relativeToGit.split(path.sep));
+    if (!repoId) return;
+
+    // Return an absolute file
+    return path.resolve(GIT_TMP, repoId);
+}
+
+
+module.exports = {
+    checkUrl: checkGitUrl,
+    parseUrl: parseGitUrl,
+    resolveFile: resolveFileFromGit,
+    resolveRoot: resolveGitRoot
+};

lib/utils/i18n.js

@@ -0,0 +1,80 @@
+var _ = require("lodash");
+var path = require("path");
+var fs = require("fs");
+
+var i18n = require("i18n");
+
+var I18N_PATH = path.resolve(__dirname, "../../theme/i18n/");
+var DEFAULT_LANGUAGE = "en";
+var LOCALES = _.map(fs.readdirSync(I18N_PATH), function(lang) {
+    return path.basename(lang, ".json");
+});
+
+i18n.configure({
+    locales: LOCALES,
+    directory: I18N_PATH,
+    defaultLocale: DEFAULT_LANGUAGE,
+    updateFiles: false
+});
+
+function compareLocales(lang, locale) {
+    var langMain = _.first(lang.split("-"));
+    var langSecond = _.last(lang.split("-"));
+
+    var localeMain = _.first(locale.split("-"));
+    var localeSecond = _.last(locale.split("-"));
+
+    if (locale == lang) return 100;
+    if (localeMain == langMain) return 50;
+    if (localeSecond == langSecond) return 20;
+    return 0;
+}
+
+var normalizeLanguage = _.memoize(function(lang) {
+    var language = _.chain(LOCALES)
+        .values()
+        .map(function(locale) {
+            return {
+                locale: locale,
+                score: compareLocales(lang, locale)
+            };
+        })
+        .filter(function(lang) {
+            return lang.score > 0;
+        })
+        .sortBy("score")
+        .pluck("locale")
+        .last()
+        .value();
+    return language || lang;
+});
+
+function translate(locale, phrase) {
+    var args = Array.prototype.slice.call(arguments, 2);
+
+    return i18n.__.apply({}, [{
+        locale: locale,
+        phrase: phrase
+    }].concat(args));
+}
+
+function getCatalog(locale) {
+    locale = normalizeLanguage(locale);
+    return i18n.getCatalog(locale);
+}
+
+function getLocales() {
+    return LOCALES;
+}
+
+function hasLocale(locale) {
+    return _.contains(LOCALES, locale);
+}
+
+module.exports = {
+    __: translate,
+    normalizeLanguage: normalizeLanguage,
+    getCatalog: getCatalog,
+    getLocales: getLocales,
+    hasLocale: hasLocale
+};

lib/utils/images.js

@@ -0,0 +1,37 @@
+var _ = require("lodash");
+var Q = require("q");
+var fs = require("./fs");
+var spawn = require("spawn-cmd").spawn;
+
+// 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 = shellescape(["svgexport", source, dest]);
+    var child = spawn("svgexport", [source, dest]);
+
+    child.on("error", function(error) {
+        if (error.code == "ENOENT") error = new Error("Need to install \"svgexport\" using \"npm install svgexport -g\"");
+        return d.reject(error);
+    });
+
+    child.on("close", function(code) {
+        if (code === 0 && fs.existsSync(dest)) {
+            d.resolve();
+        } else {
+            d.reject(new Error("Error converting "+source+" into "+dest));
+        }
+    });
+
+    return d.promise;
+};
+
+module.exports = {
+    convertSVG: convertSVG,
+    INVALID: [".svg"]
+};

lib/utils/index.js

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

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

@@ -1,5 +1,5 @@
-var url = require('url');
-var path = require('path');
+var url = require("url");
+var path = require("path");
 
 // Is the link an external link
 var isExternal = function(href) {
@@ -15,46 +15,68 @@ var isRelative = function(href) {
     try {
         var parsed = url.parse(href);
 
-        return !parsed.protocol && parsed.path && parsed.path[0] != '/';
+        return !!(!parsed.protocol && parsed.path);
     } catch(err) {}
 
     return true;
 };
 
+// Return true if the link is an achor
+var isAnchor = function(href) {
+    try {
+        var parsed = url.parse(href);
+        return !!(!parsed.protocol && !parsed.path && parsed.hash);
+    } catch(err) {}
+
+    return false;
+};
+
+// Normalize a path to be a link
+var normalizeLink = function(s) {
+    return s.replace(/\\/g, "/");
+};
+
 // 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) {
-    // Absolute file in source
-    _href = path.join(dir, _href);
+    if (isExternal(_href)) return _href;
 
-    // make it relative to output
-    _href = path.relative(outdir, _href);
+    // Path "_href" inside the base folder
+    var hrefInRoot = path.normalize(path.join(dir, _href));
+    if (_href[0] == "/") hrefInRoot = path.normalize(_href.slice(1));
 
-    if (process.platform === 'win32') {
-        _href = _href.replace(/\\/g, '/');
-    }
+    // Make it relative to output
+    _href = path.relative(outdir, hrefInRoot);
+
+    // Normalize windows paths
+    _href = normalizeLink(_href);
 
     return _href;
 };
 
 // Join links
-
 var join = function() {
     var _href = path.join.apply(path, arguments);
 
-    if (process.platform === 'win32') {
-        _href = _href.replace(/\\/g, '/');
-    }
-
-    return _href;
+    return normalizeLink(_href);
 };
 
+// Change extension
+var changeExtension = function(filename, newext) {
+    return path.join(
+        path.dirname(filename),
+        path.basename(filename, path.extname(filename))+newext
+    );
+};
 
 module.exports = {
+    isAnchor: isAnchor,
     isRelative: isRelative,
     isExternal: isExternal,
     toAbsolute: toAbsolute,
-    join: join
+    join: join,
+    changeExtension: changeExtension,
+    normalize: normalizeLink
 };

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

@@ -1,9 +1,9 @@
-var _ = require('lodash');
+var _ = require("lodash");
 
 // Cleans up an article/chapter object
-// remove 'articles' attributes
+// remove "articles" attributes
 function clean(obj) {
-    return obj && _.omit(obj, ['articles']);
+    return obj && _.omit(obj, ["articles"]);
 }
 
 function flattenChapters(chapters) {
@@ -27,27 +27,42 @@ function navigation(summary, files) {
     files = _.isArray(files) ? files : (_.isString(files) ? [files] : null);
 
     // List of all navNodes
-    // Flatten chapters, then add in default README node if ndeeded etc ...
+    // Flatten chapters
     var navNodes = flattenChapters(summary.chapters);
-    var prevNodes = [null].concat(navNodes.slice(0, -1));
-    var nextNodes = navNodes.slice(1).concat([null]);
 
     // Mapping of prev/next for a give path
-    var mapping = _.chain(_.zip(navNodes, prevNodes, nextNodes))
-    .map(function(nodes) {
-        var current = nodes[0], prev = nodes[1], next = nodes[2];
+    var mapping = _.chain(navNodes)
+    .map(function(current, i) {
+        var prev = null, next = null;
 
         // Skip if no path
-        if(!current.path) return null;
+        if(!current.exists) 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, {
+            index: i,
             title: current.title,
+            introduction: current.introduction,
             prev: prev,
             next: next,
             level: current.level,
         }];
     })
-    .filter()
+    .compact()
     .object()
     .value();
 

lib/utils/page.js

@@ -0,0 +1,394 @@
+var Q = require('q');
+var _ = require('lodash');
+var url = require('url');
+var path = require('path');
+var cheerio = require('cheerio');
+var domSerializer = require('dom-serializer');
+var request = require('request');
+var crc = require('crc');
+var slug = require('github-slugid');
+
+var links = require('./links');
+var imgUtils = require('./images');
+var fs = require('./fs');
+var batch = require('./batch');
+
+var parsableExtensions = require('gitbook-parsers').extensions;
+
+// Map of images that have been converted
+var imgConversionCache = {};
+
+// Render a cheerio dom as html
+function renderDom($, dom, options) {
+    if (!dom && $._root && $._root.children) {
+        dom = $._root.children;
+    }
+
+    options = options|| dom.options || $._options;
+    return domSerializer(dom, options);
+}
+
+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.
+            while (node) {
+
+                // 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;
+                        }
+                    }
+                }
+
+                node = node.nextSibling;
+            }
+        }
+
+        // Time to remove those elements!
+        if (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, {
+        // We should parse html without trying to normalize too much
+        xmlMode: false,
+
+        // SVG need some attributes to use uppercases
+        lowerCaseAttributeNames: false,
+        lowerCaseTags: 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] = '<?xml version="1.0" encoding="UTF-8"?>'+content;
+            $(this).replaceWith($('<img>').attr('src', dest));
+        });
+    }
+
+    // Generate ID for headings
+    $('h1,h2,h3,h4,h5,h6').each(function() {
+        if ($(this).attr('id')) return;
+
+        $(this).attr('id', slug($(this).text()));
+    });
+
+    // Find images to normalize
+    $('img').each(function() {
+        var origin;
+        var src = $(this).attr('src');
+
+        if (!src) return;
+        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 = '/'+crc.crc32(origin).toString(16)+path.extname(url.parse(origin).pathname);
+                src = links.toAbsolute(src, options.base, options.output);
+                isExternal = false;
+            }
+
+            var ext = path.extname(src);
+            var srcAbs = links.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 = links.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 = links.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);
+    });
+
+    // Normalize links
+    $('a').each(function() {
+        var href = $(this).attr('href');
+        if (!href) return;
+
+        if (links.isAnchor(href)) {
+            // Keep it as it is
+        } else if (links.isRelative(href)) {
+            var parts = url.parse(href);
+            var absolutePath = links.join(options.base, parts.pathname);
+            var anchor = parts.hash || '';
+
+
+            // If is in navigation relative: transform as content
+            if (options.navigation[absolutePath]) {
+                absolutePath = options.book.contentLink(absolutePath);
+            }
+
+            // If md/adoc/rst files is not in summary
+            // or for ebook, signal all files that are outside the summary
+            else if (_.contains(parsableExtensions, path.extname(absolutePath)) ||
+            _.contains(['epub', 'pdf', 'mobi'], options.book.options.generator)) {
+                options.book.log.warn.ln('page', options.input, 'contains an hyperlink to resource outside spine \''+href+'\'');
+            }
+
+            // Transform as absolute
+            href = links.toAbsolute('/'+absolutePath, options.base, options.output)+anchor;
+        } else {
+            // External links
+            $(this).attr('target', '_blank');
+        }
+
+        // Transform extension
+        $(this).attr('href', href);
+    });
+
+    // Highlight code blocks
+    $('code').each(function() {
+        // Normalize language
+        var lang = _.chain(
+                ($(this).attr('class') || '').split(' ')
+            )
+            .map(function(cl) {
+                // Markdown
+                if (cl.search('lang-') === 0) return cl.slice('lang-'.length);
+
+                // Asciidoc
+                if (cl.search('language-') === 0) return cl.slice('language-'.length);
+
+                return null;
+            })
+            .compact()
+            .first()
+            .value();
+
+        var source = $(this).text();
+        var blk = options.book.template.applyBlock('code', {
+            body: source,
+            kwargs: {
+                language: lang
+            }
+        });
+
+        if (blk.html === false) $(this).text(blk.body);
+        else $(this).html(blk.body);
+    });
+
+    // Replace glossary terms
+    var glossary = _.sortBy(options.glossary, function(term) {
+        return -term.name.length;
+    });
+
+    _.each(glossary, function(term) {
+        var r =  new RegExp( '\\b(' + pregQuote(term.name.toLowerCase()) + ')\\b' , 'gi' );
+        var includedInFiles = false;
+
+        $('*').each(function() {
+            // Ignore codeblocks
+            if (_.contains(['code', 'pre', 'a'], this.name.toLowerCase())) return;
+
+            replaceText($, this, r, function(match) {
+                // Add to files index in glossary
+                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=\''+_.escape(term.description)+'\'>'+match+'</a>';
+            });
+        });
+    });
+
+    return {
+        html: renderDom($),
+        images: toConvert
+    };
+}
+
+// Convert svg images to png
+function convertImages(images, options) {
+    if (!options.convertImages) return Q();
+
+    var downloaded = [];
+    options.book.log.debug.ln('convert ', images.length, 'images to png');
+
+    return batch.execEach(images, {
+        max: 100,
+        fn: function(image) {
+            var imgin = path.resolve(options.book.options.output, image.source);
+
+            return Q()
+
+            // Write image if need to be download
+            .then(function() {
+                if (!image.origin && !_.contains(downloaded, image.origin)) return;
+                options.book.log.debug('download image', image.origin, '...');
+                downloaded.push(image.origin);
+                return options.book.log.debug.promise(fs.writeStream(imgin, request(image.origin)))
+                .fail(function(err) {
+                    if (!_.isError(err)) err = new Error(err);
+
+                    err.message = 'Fail downloading '+image.origin+': '+err.message;
+                    throw err;
+                });
+            })
+
+            // 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));
+            });
+        }
+    })
+    .then(function() {
+        options.book.log.debug.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);
+}
+
+
+module.exports = {
+    normalize: normalizePage
+};

lib/utils/path.js

@@ -0,0 +1,40 @@
+var _ = require("lodash");
+var path = require("path");
+
+// Return true if file path is inside a folder
+function isInRoot(root, filename) {
+    filename = path.normalize(filename);
+    return (filename.substr(0, root.length) === root);
+}
+
+// Resolve paths in a specific folder
+// Throw error if file is outside this folder
+function resolveInRoot(root) {
+    var input, result, err;
+
+    input = _.chain(arguments)
+        .toArray()
+        .slice(1)
+        .reduce(function(current, p) {
+            // Handle path relative to book root ("/README.md")
+            if (p[0] == "/" || p[0] == "\\") return p.slice(1);
+
+            return current? path.join(current, p) : path.normalize(p);
+        }, "")
+        .value();
+
+    result = path.resolve(root, input);
+
+    if (!isInRoot(root, result)) {
+        err = new Error("EACCESS: \"" + result + "\" not in \"" + root + "\"");
+        err.code = "EACCESS";
+        throw err;
+    }
+
+    return result;
+}
+
+module.exports = {
+    isInRoot: isInRoot,
+    resolveInRoot: resolveInRoot
+};

lib/utils/progress.js

@@ -1,19 +1,24 @@
 var _ = require("lodash");
 
 // Returns from a navigation and a current file, a snapshot of current detailed state
-var calculProgress = function(navigation, current) {
+function calculProgress(navigation, current) {
     var n = _.size(navigation);
     var percent = 0, prevPercent = 0, currentChapter = null;
     var done = true;
 
     var chapters = _.chain(navigation)
+
+    // Transform as array
     .map(function(nav, path) {
         nav.path = path;
         return nav;
     })
+
+    // Sort entries
     .sortBy(function(nav) {
-        return parseFloat(nav.level);
+        return nav.index;
     })
+
     .map(function(nav, i) {
         // Calcul percent
         nav.percent = (i * 100) / Math.max((n - 1), 1);
@@ -47,4 +52,4 @@ var calculProgress = function(navigation, current) {
     };
 }
 
-module.exports = calculProgress;
+module.exports = calculProgress;

lib/utils/server.js

@@ -1,11 +1,9 @@
-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 Q = require("q");
+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;
@@ -17,7 +15,7 @@ util.inherits(Server, events.EventEmitter);
 
 // Return true if the server is running
 Server.prototype.isRunning = function() {
-    return this.running != null;
+    return !!this.running;
 };
 
 // Stop the server
@@ -57,25 +55,25 @@ Server.prototype.start = function(dir, port) {
                 res.end(err.message);
             }
 
-            // Redirect to directory's index.html
+            // Redirect to directory"s index.html
             function redirect() {
                 res.statusCode = 301;
-                res.setHeader('Location', req.url + '/');
-                res.end('Redirecting to ' + req.url + '/');
+                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)
+            .on("error", error)
+            .on("directory", redirect)
             .pipe(res);
         });
 
-        that.running.on('connection', function (socket) {
+        that.running.on("connection", function (socket) {
             that.sockets.push(socket);
             socket.setTimeout(4000);
-            socket.on('close', function () {
+            socket.on("close", function () {
                 that.sockets.splice(that.sockets.indexOf(socket), 1);
             });
         });
@@ -91,6 +89,6 @@ Server.prototype.start = function(dir, port) {
 
         return d.promise;
     });
-}
+};
 
 module.exports = Server;

lib/utils/string.js

@@ -1,7 +1,7 @@
 var _ = require("lodash");
 
 function escapeShellArg(arg) {
-    var ret = '';
+    var ret = "";
 
     ret = arg.replace(/"/g, '\\"');
 
@@ -11,8 +11,8 @@ function escapeShellArg(arg) {
 function optionsToShellArgs(options) {
     return _.chain(options)
     .map(function(value, key) {
-        if (value == null || value == false) return null;
-        if (value == true) return key;
+        if (value === null || value === undefined || value === false) return null;
+        if (value === true) return key;
         return key+"="+escapeShellArg(value);
     })
     .compact()
@@ -22,5 +22,6 @@ function optionsToShellArgs(options) {
 
 module.exports = {
     escapeShellArg: escapeShellArg,
-    optionsToShellArgs: optionsToShellArgs
+    optionsToShellArgs: optionsToShellArgs,
+    toLowerCase: String.prototype.toLowerCase.call.bind(String.prototype.toLowerCase)
 };

lib/utils/watch.js

@@ -0,0 +1,40 @@
+var Q = require("q");
+var _ = require("lodash");
+var path = require("path");
+var chokidar = require("chokidar");
+
+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 watcher = chokidar.watch(toWatch, {
+        cwd: dir,
+        ignored: "_book/**",
+        ignoreInitial: true
+    });
+
+    watcher.once("all", function(e, filepath) {
+        watcher.close();
+
+        d.resolve(filepath);
+    });
+    watcher.once("error", function(err) {
+        watcher.close();
+
+        d.reject(err);
+    });
+
+    return d.promise;
+}
+
+module.exports = watch;

lib/version.js

@@ -0,0 +1,19 @@
+var semver = require('semver');
+var pkg = require('../package.json');
+
+var VERSION = pkg.version;
+var VERSION_STABLE = VERSION.replace(/\-(\S+)/g, '');
+
+// Test if current current gitbook version satisfies a condition
+// We can't directly use samver.satisfies since it will break all plugins when gitbook version is a prerelease (beta, alpha)
+function satisfies(condition) {
+    // Test with real version
+    if (semver.satisfies(VERSION, condition)) return true;
+
+    // Test with future stable release
+    return semver.satisfies(VERSION_STABLE, condition);
+}
+
+module.exports = {
+    satisfies: satisfies
+};

package.json

@@ -1,66 +1,93 @@
 {
     "name": "gitbook",
-    "version": "0.5.4",
-    "homepage": "http://www.gitbook.io/",
+    "version": "2.5.0",
+    "homepage": "https://www.gitbook.com",
     "description": "Library and cmd utility to generate GitBooks",
     "main": "lib/index.js",
     "dependencies": {
         "q": "1.0.1",
-        "lodash": "2.4.1",
-        "marked": "0.3.2",
-        "marked-text-renderer": "0.0.1",
-        "lunr": "0.5.2",
-        "swig": "1.3.2",
-        "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",
-        "semver": "2.2.1",
-        "gaze": "~0.5.1",
+        "lodash": "3.10.1",
+        "graceful-fs": "3.0.5",
         "resolve": "0.6.3",
-        "tiny-lr-fork": "0.0.5",
-        "gitbook-plugin": "0.0.2",
-        "gitbook-plugin-mathjax": "0.0.3",
-        "gitbook-plugin-livereload": "0.0.1"
+        "fs-extra": "0.16.5",
+        "fstream-ignore": "1.0.2",
+        "gitbook-parsers": "0.8.7",
+        "gitbook-plugin-highlight": "1.0.3",
+        "gitbook-plugin-sharing": "1.0.1",
+        "gitbook-plugin-search": "1.0.2",
+        "gitbook-plugin-fontsettings": "1.0.2",
+        "nunjucks": "2.1.0",
+        "nunjucks-autoescape": "1.0.0",
+        "nunjucks-filter": "1.0.0",
+        "i18n": "0.5.0",
+        "semver": "5.0.1",
+        "npmi": "0.1.1",
+        "cheerio": "0.19.0",
+        "gitbook-plugin-livereload": "0.0.1",
+        "chokidar": "~1.0.5",
+        "send": "0.2.0",
+        "tiny-lr": "0.1.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": "0.1.0",
+        "spawn-cmd": "0.0.2",
+        "escape-string-regexp": "1.0.3",
+        "juice": "1.5.0",
+        "jsonschema": "1.0.2",
+        "json-schema-defaults": "0.1.1",
+        "merge-defaults": "0.2.1",
+        "github-slugid": "1.0.0"
     },
     "devDependencies": {
-        "mocha": "1.18.2",
-        "grunt": "~0.4.2",
-        "grunt-cli": "0.1.11",
-        "grunt-contrib-less": "~0.5.0",
-        "grunt-contrib-requirejs": "0.4.1",
-        "grunt-bower-install-simple": "0.9.2"
+        "eslint": "1.5.0",
+        "mocha": "2.3.2",
+        "should": "7.1.0",
+        "should-promised": "0.3.1",
+        "gulp": "^3.8.11",
+        "gulp-rename": "^1.2.2",
+        "gulp-uglify": "1.1.0",
+        "gulp-less": "3.0.2",
+        "gulp-minify-css": "1.0.0",
+        "gulp-util": "3.0.6",
+        "browserify": "11.0.1",
+        "merge-stream": "0.1.7",
+        "vinyl-source-stream": "1.1.0",
+        "jquery": "2.1.4",
+        "mousetrap": "1.5.3",
+        "font-awesome": "4.1.0"
     },
     "scripts": {
-        "test": "export TESTING=true; mocha --reporter list"
-    },
-    "bin": {
-        "gitbook": "./bin/gitbook.js"
+        "test": "node_modules/.bin/mocha --reporter spec --timeout 15000"
     },
     "repository": {
         "type": "git",
         "url": "https://github.com/GitbookIO/gitbook.git"
     },
+    "bin": {
+        "gitbook": "./bin/gitbook.js"
+    },
     "keywords": [
         "git",
         "book",
         "gitbook"
     ],
-    "author": "FriendCode <contact@friendco.de>",
-    "license": "Apache 2",
+    "author": "FriendCode Inc. <contact@gitbook.com>",
+    "license": "Apache-2.0",
     "bugs": {
         "url": "https://github.com/GitbookIO/gitbook/issues"
     },
     "contributors": [
         {
             "name": "Aaron O'Mullan",
-            "email": "aaron.omullan@gmail.com"
+            "email": "aaron@gitbook.com"
         },
         {
             "name": "Samy Pessé",
-            "email": "samypesse@gmail.com"
+            "email": "samy@gitbook.com"
         }
     ]
 }

test/assertions.js

@@ -0,0 +1,69 @@
+var _ = require('lodash');
+var fs = require('fs');
+var path = require('path');
+var should = require('should');
+var cheerio = require('cheerio');
+
+require('should-promised');
+
+should.Assertion.add('file', function(file, description) {
+    this.params = { actual: this.obj.toString(), operator: 'have file ' + file, message: description };
+
+    this.obj.should.have.property('options').which.is.an.Object();
+    this.obj.options.should.have.property('output').which.is.a.String();
+    this.assert(fs.existsSync(path.resolve(this.obj.options.output, file)));
+});
+
+should.Assertion.add('jsonfile', function(file, description) {
+    this.params = { actual: this.obj.toString(), operator: 'have valid jsonfile ' + file, message: description };
+
+    this.obj.should.have.property('options').which.is.an.Object();
+    this.obj.options.should.have.property('output').which.is.a.String();
+    this.assert(JSON.parse(fs.readFileSync(path.resolve(this.obj.options.output, file), { encoding: 'utf-8' })));
+});
+
+should.Assertion.add('html', function(rules, description) {
+    this.params = { actual: 'HTML string', operator: 'valid html', message: description };
+    var $ = cheerio.load(this.obj);
+
+    _.each(rules, function(validations, query) {
+        validations = _.defaults(validations || {}, {
+            // Select a specific element in the list of matched elements
+            index: null,
+
+            // Check that there is the correct count of elements
+            count: 1,
+
+            // Check attribute values
+            attributes: {},
+
+            // Trim inner text
+            trim: false,
+
+            // Check inner text
+            text: undefined
+        });
+
+        var $el = $(query);
+
+        // Select correct element
+        if (_.isNumber(validations.index)) $el = $($el.get(validations.index));
+
+        // Test number of elements
+        $el.length.should.be.equal(validations.count);
+
+        // Test text
+        if (validations.text !== undefined) {
+            var text = $el.text();
+            if (validations.trim) text = text.trim();
+            text.should.be.equal(validations.text);
+        }
+
+        // Test attributes
+        _.each(validations.attributes, function(value, name) {
+            var attr = $el.attr(name);
+            should(attr).be.ok();
+            attr.should.be.equal(value);
+        });
+    });
+});

test/books/basic/README.md

@@ -0,0 +1,3 @@
+# Readme
+
+Default description for the book.

test/books/basic/SUMMARY.md

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

test/books/config-js/README.md

@@ -0,0 +1 @@
+# Readme

test/books/config-js/SUMMARY.md

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

test/books/config-js/book.js

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

test/books/config-json/README.md

@@ -0,0 +1 @@
+# Readme

test/books/config-json/SUMMARY.md

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

test/books/config-json/book.json

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

test/books/conrefs/README.md

@@ -0,0 +1,15 @@
+# Readme
+
+<p id="test-plugin-block-shortcuts-1">$$test_block1$$</p>
+<p id="test-plugin-block-shortcuts-2">{% include "./block.md" %}</p>
+
+### Relative
+
+<p id="t1">{% include "./hello.md" %}</p>
+<p id="t2">{% include "/hello.md" %}</p>
+
+### Git
+
+<p id="t3">{% include "git+https://gist.github.com/69ea4542e4c8967d2fa7.git/test.md" %}</p>
+<p id="t4">{% include "git+https://gist.github.com/69ea4542e4c8967d2fa7.git/test2.md" %}</p>
+<p id="t5">{% include "git+https://gist.github.com/69ea4542e4c8967d2fa7.git/test3.md" %}</p>

test/books/conrefs/SUMMARY.md

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

test/books/conrefs/block.md

@@ -0,0 +1 @@
+$$test_block2$$

test/books/conrefs/hello.md

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

test/books/glossary/GLOSSARY.md

@@ -0,0 +1,13 @@
+# Glossary
+
+## test
+
+Just a simple and easy to understand test.
+
+## hakunamatata
+
+This word is not present in the content.
+
+## test long
+
+This is a test with a longer text that the first entry to test order.

test/books/glossary/README.md

@@ -0,0 +1,10 @@
+# Readme
+
+The word test should be replaced by a glossary link.
+
+```
+But the word test should not be replaced in code blocks
+```
+
+The two words test long should be replaced by the correct glossary links.
+

test/books/glossary/SUMMARY.md

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

test/books/glossary/folder/PAGE.md

@@ -0,0 +1,3 @@
+# Page
+
+Just a page in a sub-directory to test relative link to glossary.

test/books/headings/README.md

@@ -0,0 +1,3 @@
+# Hello World
+
+## Hello {#hello-custom}

test/books/highlight/README.md

@@ -0,0 +1,16 @@
+# Readme
+
+Block without language
+
+```
+test 1
+```
+
+Block with a language
+
+```lang
+test 2
+```
+
+Inline code: `test 3`
+Inline code with html: `<test>`

test/books/highlight/SUMMARY.md

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

test/books/images/README.md

@@ -0,0 +1,18 @@
+# Tests for Images
+
+# SVG relative image
+
+
+### Convert SVG to PNG
+![test.svg](test.svg)
+
+### Should only convert it once
+![test.svg](test.svg)
+
+### Download remote images
+![remote image](http://upload.wikimedia.org/wikipedia/commons/b/b0/NewTux.svg)
+
+### Remote images with same filename
+![youtube1](http://img.youtube.com/vi/9bZkp7q19f0/0.jpg)
+![youtube2](http://img.youtube.com/vi/IkV2HQLAKHY/0.jpg)
+

test/books/images/SUMMARY.md

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

test/books/images/folder/PAGE.md

@@ -0,0 +1,3 @@
+### Images from other folder
+![test.svg](../test.svg)
+

test/books/images/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/books/init/.gitignore

@@ -0,0 +1,3 @@
+*
+!SUMMARY.md
+!.gitignore

test/books/init/SUMMARY.md

@@ -0,0 +1,9 @@
+# Summary
+
+* [Hello](hello.md)
+* [Hello 2](hello2.md)
+* Hello 3
+    * [Hello 4](hello3/hello4.md)
+    * Hello 5
+        * [Hello 6](hello3/hello5/hello6.md)
+

test/books/languages/LANGS.md

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

test/books/languages/README.md

@@ -0,0 +1 @@
+# Readme

test/books/languages/en/README.md

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

test/books/languages/en/SUMMARY.md

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