1. module gitbook
   1. function gitbook.Book (values)
   2. function gitbook.Config (values)
   3. function gitbook.FS (values)
   4. function gitbook.File (values)
   5. function gitbook.Glossary (values)
   6. function gitbook.Page (values)
   7. function gitbook.PluginDependency (values)
   8. function gitbook.Summary (values)
   9. function gitbook.conrefsLoader ()
   10. function gitbook.createNodeFS (root)
   11. function gitbook.glossaryEntry (values)
   12. function gitbook.ignore (values)
   13. function gitbook.initBook (rootFolder)
   14. function gitbook.language (values)
   15. function gitbook.languages (values)
   16. function gitbook.logger (write, logLevel)
   17. function gitbook.output (values)
   18. function gitbook.parser (values)
   19. function gitbook.plugin (values)
   20. function gitbook.promise (value)
   21. function gitbook.readme (values)
   22. function gitbook.server ()
   23. function gitbook.state (values)
   24. function gitbook.summaryArticle (values)
   25. function gitbook.summaryPart (values)
   26. function gitbook.templateBlock (values)
   27. function gitbook.templateEngine (values)
   28. function gitbook.templateOutput (values)
   29. function gitbook.templateShortcut (values)
   30. function gitbook.themesLoader ()
   31. object gitbook.Book.prototype
   32. object gitbook.CONFIG_FILES
   33. object gitbook.Config.prototype
   34. object gitbook.ConfigModifier
   35. object gitbook.DEFAULT_PLUGINS
   36. object gitbook.EXTENSIONS_ASCIIDOC
   37. object gitbook.EXTENSIONS_MARKDOWN
   38. object gitbook.FS.prototype
   39. object gitbook.FS.prototype._defaultValues
   40. object gitbook.File.prototype
   41. object gitbook.Glossary.prototype
   42. object gitbook.IGNORE_FILES
   43. object gitbook.Output
   44. object gitbook.Page.prototype
   45. object gitbook.Parse
   46. object gitbook.PluginDependency.prototype
   47. object gitbook.Summary.prototype
   48. object gitbook.SummaryModifier
   49. object gitbook.browser
   50. object gitbook.command
   51. object gitbook.commands
   52. object gitbook.conrefsLoader.prototype
   53. object gitbook.deprecate
   54. object gitbook.error
   55. object gitbook.fs
   56. object gitbook.glossaryEntry.prototype
   57. object gitbook.ignore.prototype
   58. object gitbook.images
   59. object gitbook.index
   60. object gitbook.install
   61. object gitbook.language.prototype
   62. object gitbook.languages.prototype
   63. object gitbook.location
   64. object gitbook.logger.prototype
   65. object gitbook.output.prototype
   66. object gitbook.parse
   67. object gitbook.parser.prototype
   68. object gitbook.parsers
   69. object gitbook.path
   70. object gitbook.plugin.prototype
   71. object gitbook.readme.prototype
   72. object gitbook.serve
   73. object gitbook.server.prototype
   74. object gitbook.state.prototype
   75. object gitbook.summaryArticle.prototype
   76. object gitbook.summaryPart.prototype
   77. object gitbook.templateBlock.prototype
   78. object gitbook.templateEngine.prototype
   79. object gitbook.templateOutput.prototype
   80. object gitbook.templateShortcut.prototype
   81. object gitbook.themesLoader.prototype
   82. object gitbook.timing
2. module gitbook.Book
   1. function gitbook.Book (values)
   2. function gitbook.Book.createForFS (fs)
   3. function gitbook.Book.createFromParent (parent, language)
3. module gitbook.Book.prototype
   1. function gitbook.Book.prototype.addLanguageBook (language, book)
   2. function gitbook.Book.prototype.constructor (values)
   3. function gitbook.Book.prototype.getBooks ()
   4. function gitbook.Book.prototype.getConfig ()
   5. function gitbook.Book.prototype.getContentFS ()
   6. function gitbook.Book.prototype.getContentRoot ()
   7. function gitbook.Book.prototype.getDefaultExt ()
   8. function gitbook.Book.prototype.getDefaultGlossaryPath (absolute)
   9. function gitbook.Book.prototype.getDefaultReadmePath (absolute)
   10. function gitbook.Book.prototype.getDefaultSummaryPath (absolute)
   11. function gitbook.Book.prototype.getFS ()
   12. function gitbook.Book.prototype.getGlossary ()
   13. function gitbook.Book.prototype.getIgnore ()
   14. function gitbook.Book.prototype.getLanguage ()
   15. function gitbook.Book.prototype.getLanguageBook (language)
   16. function gitbook.Book.prototype.getLanguages ()
   17. function gitbook.Book.prototype.getLogger ()
   18. function gitbook.Book.prototype.getPage (ref)
   19. function gitbook.Book.prototype.getReadme ()
   20. function gitbook.Book.prototype.getRoot ()
   21. function gitbook.Book.prototype.getSummary ()
   22. function gitbook.Book.prototype.isContentFileIgnored (filename)
   23. function gitbook.Book.prototype.isFileIgnored (filename)
   24. function gitbook.Book.prototype.isLanguageBook ()
   25. function gitbook.Book.prototype.isMultilingual ()
   26. function gitbook.Book.prototype.setConfig (config)
   27. function gitbook.Book.prototype.setIgnore (ignore)
   28. function gitbook.Book.prototype.setLogLevel (level)
   29. function gitbook.Book.prototype.setReadme (readme)
   30. function gitbook.Book.prototype.setSummary (summary)
   31. number gitbook.Book.prototype.size
   32. object gitbook.Book.prototype._defaultValues
   33. object gitbook.Book.prototype._keys
4. module gitbook.Config
   1. function gitbook.Config (values)
   2. function gitbook.Config.create (file, values)
   3. function gitbook.Config.createWithValues (values)
   4. function gitbook.Config.keyToKeyPath (keyPath)
5. module gitbook.Config.prototype
   1. function gitbook.Config.prototype.constructor (values)
   2. function gitbook.Config.prototype.getFile ()
   3. function gitbook.Config.prototype.getPluginDependencies ()
   4. function gitbook.Config.prototype.getPluginDependency (name)
   5. function gitbook.Config.prototype.getValue (keyPath, def)
   6. function gitbook.Config.prototype.getValues ()
   7. function gitbook.Config.prototype.mergeValues (values)
   8. function gitbook.Config.prototype.setFile (file)
   9. function gitbook.Config.prototype.setPluginDependencies (deps)
   10. function gitbook.Config.prototype.setValue (keyPath, value)
   11. function gitbook.Config.prototype.toReducedVersion ()
   12. function gitbook.Config.prototype.toText ()
   13. function gitbook.Config.prototype.updateValues (values)
   14. number gitbook.Config.prototype.size
   15. object gitbook.Config.prototype._defaultValues
   16. object gitbook.Config.prototype._keys
   17. string gitbook.Config.prototype._name
6. module gitbook.ConfigModifier
   1. function gitbook.ConfigModifier.addPlugin (config, pluginName, version)
   2. function gitbook.ConfigModifier.editPlugin (config, pluginName, pluginConfig)
   3. function gitbook.ConfigModifier.getPluginConfig (config, pluginName)
   4. function gitbook.ConfigModifier.hasPlugin (deps, pluginName, version)
   5. function gitbook.ConfigModifier.isDefaultPlugin (pluginName, version)
   6. function gitbook.ConfigModifier.removePlugin (config, pluginName)
   7. function gitbook.ConfigModifier.togglePlugin (config, pluginName, state)
7. module gitbook.FS
   1. function gitbook.FS (values)
   2. function gitbook.FS.create (def)
   3. function gitbook.FS.reduceScope (fs, scope)
8. module gitbook.FS.prototype
   1. function gitbook.FS.prototype.constructor (values)
   2. function gitbook.FS.prototype.exists (filename)
   3. function gitbook.FS.prototype.findFile (dirname, filename)
   4. function gitbook.FS.prototype.getRoot ()
   5. function gitbook.FS.prototype.isInScope (filename)
   6. function gitbook.FS.prototype.listAllFiles (dirName, filterFn)
   7. function gitbook.FS.prototype.listFiles (dirname)
   8. function gitbook.FS.prototype.loadAsObject (filename)
   9. function gitbook.FS.prototype.read (filename)
   10. function gitbook.FS.prototype.readAsStream (filename)
   11. function gitbook.FS.prototype.readAsString (filename, encoding)
   12. function gitbook.FS.prototype.readDir (dirname)
   13. function gitbook.FS.prototype.resolve ()
   14. function gitbook.FS.prototype.statFile (filename)
   15. number gitbook.FS.prototype.size
   16. object gitbook.FS.prototype._defaultValues
   17. object gitbook.FS.prototype._keys
9. module gitbook.FS.prototype._defaultValues
   1. function gitbook.FS.prototype._defaultValues.fsExists ()
   2. function gitbook.FS.prototype._defaultValues.fsReadDir ()
   3. function gitbook.FS.prototype._defaultValues.fsReadFile ()
   4. function gitbook.FS.prototype._defaultValues.fsStatFile ()
   5. object gitbook.FS.prototype._defaultValues.fsLoadObject
   6. object gitbook.FS.prototype._defaultValues.fsReadAsStream
   7. string gitbook.FS.prototype._defaultValues.root
10. module gitbook.File
    1. function gitbook.File (values)
    2. function gitbook.File.createFromStat (filepath, stat)
    3. function gitbook.File.createWithFilepath (filepath)
11. module gitbook.File.prototype
    1. function gitbook.File.prototype.constructor (values)
    2. function gitbook.File.prototype.exists ()
    3. function gitbook.File.prototype.getExtension ()
    4. function gitbook.File.prototype.getMTime ()
    5. function gitbook.File.prototype.getParser ()
    6. function gitbook.File.prototype.getPath ()
    7. function gitbook.File.prototype.getType ()
    8. number gitbook.File.prototype.size
    9. object gitbook.File.prototype._defaultValues
    10. object gitbook.File.prototype._keys
12. module gitbook.Glossary
    1. function gitbook.Glossary (values)
    2. function gitbook.Glossary.addEntry (glossary, entry)
    3. function gitbook.Glossary.addEntryByName (glossary, name, description)
    4. function gitbook.Glossary.createFromEntries (file, entries)
13. module gitbook.Glossary.prototype
    1. function gitbook.Glossary.prototype.constructor (values)
    2. function gitbook.Glossary.prototype.getEntries ()
    3. function gitbook.Glossary.prototype.getEntry (name)
    4. function gitbook.Glossary.prototype.getFile ()
    5. function gitbook.Glossary.prototype.toText (parser)
    6. number gitbook.Glossary.prototype.size
    7. object gitbook.Glossary.prototype._defaultValues
    8. object gitbook.Glossary.prototype._keys
14. module gitbook.Output
    1. function gitbook.Output.generate (generator, book, options)
    2. function gitbook.Output.getGenerator (name)
15. module gitbook.Page
    1. function gitbook.Page (values)
    2. function gitbook.Page.createForFile (file)
16. module gitbook.Page.prototype
    1. function gitbook.Page.prototype.constructor (values)
    2. function gitbook.Page.prototype.getAttributes ()
    3. function gitbook.Page.prototype.getContent ()
    4. function gitbook.Page.prototype.getDir ()
    5. function gitbook.Page.prototype.getFile ()
    6. function gitbook.Page.prototype.getPath ()
    7. function gitbook.Page.prototype.toText ()
17. module gitbook.Parse
    1. function gitbook.Parse.listAssets (book, pages)
    2. function gitbook.Parse.lookupStructureFile (book, type)
    3. function gitbook.Parse.parseBook (book)
    4. function gitbook.Parse.parseConfig (book)
    5. function gitbook.Parse.parseGlossary (book)
    6. function gitbook.Parse.parseIgnore (book)
    7. function gitbook.Parse.parseLanguages (book)
    8. function gitbook.Parse.parsePage (book, page)
    9. function gitbook.Parse.parsePageFromString (page, content)
    10. function gitbook.Parse.parsePagesList (book)
    11. function gitbook.Parse.parseReadme (book)
    12. function gitbook.Parse.parseSummary (book)
18. module gitbook.PluginDependency
    1. function gitbook.PluginDependency (values)
    2. function gitbook.PluginDependency.create (name, version, enabled)
    3. function gitbook.PluginDependency.createFromString (s)
    4. function gitbook.PluginDependency.listFromArray (arr)
    5. function gitbook.PluginDependency.listFromString (s)
    6. function gitbook.PluginDependency.listToArray (list)
    7. function gitbook.PluginDependency.nameToNpmID (s)
19. module gitbook.PluginDependency.prototype
    1. function gitbook.PluginDependency.prototype.constructor (values)
    2. function gitbook.PluginDependency.prototype.getName ()
    3. function gitbook.PluginDependency.prototype.getNpmID ()
    4. function gitbook.PluginDependency.prototype.getVersion ()
    5. function gitbook.PluginDependency.prototype.isEnabled ()
    6. function gitbook.PluginDependency.prototype.isGitDependency ()
    7. function gitbook.PluginDependency.prototype.toggle (state)
    8. number gitbook.PluginDependency.prototype.size
    9. object gitbook.PluginDependency.prototype._defaultValues
    10. object gitbook.PluginDependency.prototype._keys
    11. string gitbook.PluginDependency.prototype._name
20. module gitbook.Summary
    1. function gitbook.Summary (values)
    2. function gitbook.Summary.createFromParts (file, parts)
21. module gitbook.Summary.prototype
    1. function gitbook.Summary.prototype.constructor (values)
    2. function gitbook.Summary.prototype.getArticle (iter, partIter)
    3. function gitbook.Summary.prototype.getArticlesAsList ()
    4. function gitbook.Summary.prototype.getByLevel (level)
    5. function gitbook.Summary.prototype.getByPath (filePath)
    6. function gitbook.Summary.prototype.getFile ()
    7. function gitbook.Summary.prototype.getFirstArticle ()
    8. function gitbook.Summary.prototype.getNextArticle (current)
    9. function gitbook.Summary.prototype.getParent (level)
    10. function gitbook.Summary.prototype.getPart (i)
    11. function gitbook.Summary.prototype.getParts ()
    12. function gitbook.Summary.prototype.getPrevArticle (current)
    13. function gitbook.Summary.prototype.toText (parseExt)
    14. number gitbook.Summary.prototype.size
    15. object gitbook.Summary.prototype._defaultValues
    16. object gitbook.Summary.prototype._keys
    17. string gitbook.Summary.prototype._name
22. module gitbook.SummaryModifier
    1. function gitbook.SummaryModifier.editArticleRef (summary, level, newRef)
    2. function gitbook.SummaryModifier.editArticleTitle (summary, level, newTitle)
    3. function gitbook.SummaryModifier.editPartTitle (summary, index, newTitle)
    4. function gitbook.SummaryModifier.insertArticle (summary, article, level)
    5. function gitbook.SummaryModifier.insertPart (summary, part, index)
    6. function gitbook.SummaryModifier.moveArticle (summary, origin, target)
    7. function gitbook.SummaryModifier.moveArticleAfter (summary, origin, afterTarget)
    8. function gitbook.SummaryModifier.removeArticle (summary, level)
    9. function gitbook.SummaryModifier.removePart (summary, index)
    10. function gitbook.SummaryModifier.unshiftArticle (summary, article)
23. module gitbook.browser
    1. function gitbook.browser.Book (values)
    2. function gitbook.browser.Config (values)
    3. function gitbook.browser.FS (values)
    4. function gitbook.browser.File (values)
    5. function gitbook.browser.Glossary (values)
    6. function gitbook.browser.Page (values)
    7. function gitbook.browser.PluginDependency (values)
    8. function gitbook.browser.Summary (values)
    9. object gitbook.browser.CONFIG_FILES
    10. object gitbook.browser.ConfigModifier
    11. object gitbook.browser.DEFAULT_PLUGINS
    12. object gitbook.browser.EXTENSIONS_ASCIIDOC
    13. object gitbook.browser.EXTENSIONS_MARKDOWN
    14. object gitbook.browser.IGNORE_FILES
    15. object gitbook.browser.Parse
    16. object gitbook.browser.SummaryModifier
24. module gitbook.command
    1. function gitbook.command.exec (command, options)
    2. function gitbook.command.optionsToShellArgs (options)
    3. function gitbook.command.spawn (command, args, options)
25. module gitbook.conrefsLoader
    1. function gitbook.conrefsLoader ()
    2. function gitbook.conrefsLoader.extend (name, props)
26. module gitbook.conrefsLoader.prototype
    1. boolean gitbook.conrefsLoader.prototype.async
    2. function gitbook.conrefsLoader.prototype.constructor ()
    3. function gitbook.conrefsLoader.prototype.getSource (sourceURL, callback)
    4. function gitbook.conrefsLoader.prototype.init (rootFolder, transformFn, logger)
    5. function gitbook.conrefsLoader.prototype.isRelative (filename)
    6. function gitbook.conrefsLoader.prototype.resolve (from, to)
    7. string gitbook.conrefsLoader.prototype.typename
27. module gitbook.deprecate
    1. function gitbook.deprecate.disable (key)
    2. function gitbook.deprecate.enable (key)
    3. function gitbook.deprecate.field (book, key, instance, property, value, msg)
    4. function gitbook.deprecate.method (book, key, fn, msg)
    5. function gitbook.deprecate.renamedMethod (book, key, instance, oldName, newName, msg)
28. module gitbook.error
    1. function gitbook.error.ConfigurationError (cause, opts)
    2. function gitbook.error.EbookError (cause, opts)
    3. function gitbook.error.FileNotFoundError (opts)
    4. function gitbook.error.FileNotParsableError (opts)
    5. function gitbook.error.FileOutOfScopeError (opts)
    6. function gitbook.error.OutputError (cause, opts)
    7. function gitbook.error.ParsingError (cause, opts)
    8. function gitbook.error.PluginError (cause, opts)
    9. function gitbook.error.RequireInstallError (opts)
    10. function gitbook.error.TemplateError (cause, opts)
    11. function gitbook.error.enforce (err)
29. module gitbook.fs
    1. function gitbook.fs.assertFile (filePath, generator)
    2. function gitbook.fs.copy ()
    3. function gitbook.fs.copyDir ()
    4. function gitbook.fs.download (uri, dest)
    5. function gitbook.fs.ensureFile (filename)
    6. function gitbook.fs.ensureFolder (rootFolder)
    7. function gitbook.fs.exists (filename)
    8. function gitbook.fs.existsSync (path)
    9. function gitbook.fs.mkdirp ()
    10. function gitbook.fs.pickFile (rootFolder, fileName)
    11. function gitbook.fs.readFile ()
    12. function gitbook.fs.readStream (path, options)
    13. function gitbook.fs.readdir ()
    14. function gitbook.fs.rmDir (base)
    15. function gitbook.fs.stat ()
    16. function gitbook.fs.statSync (path)
    17. function gitbook.fs.tmpDir (opts)
    18. function gitbook.fs.tmpFile (opts)
    19. function gitbook.fs.uniqueFilename (base, filename)
    20. function gitbook.fs.writeFile ()
    21. function gitbook.fs.writeStream (filename, st)
30. module gitbook.glossaryEntry
    1. function gitbook.glossaryEntry (values)
    2. function gitbook.glossaryEntry.nameToID (name)
31. module gitbook.glossaryEntry.prototype
    1. function gitbook.glossaryEntry.prototype.constructor (values)
    2. function gitbook.glossaryEntry.prototype.getDescription ()
    3. function gitbook.glossaryEntry.prototype.getID ()
    4. function gitbook.glossaryEntry.prototype.getName ()
32. module gitbook.ignore
    1. function gitbook.ignore (values)
33. module gitbook.ignore.prototype
    1. function gitbook.ignore.prototype.add (rule)
    2. function gitbook.ignore.prototype.constructor (values)
    3. function gitbook.ignore.prototype.getIgnore ()
    4. function gitbook.ignore.prototype.isFileIgnored (filename)
    5. number gitbook.ignore.prototype.size
    6. object gitbook.ignore.prototype._defaultValues
    7. object gitbook.ignore.prototype._keys
    8. string gitbook.ignore.prototype._name
34. module gitbook.images
    1. function gitbook.images.convertInlinePNG (source, dest)
    2. function gitbook.images.convertSVGBufferToPNG (buf, dest)
    3. function gitbook.images.convertSVGToPNG (source, dest, options)
35. module gitbook.index
    1. function gitbook.index.decodeGlobal (output, result)
    2. function gitbook.index.decodePage (output, page, result)
    3. function gitbook.index.encodeGlobal (output)
    4. function gitbook.index.encodePage (output, page)
36. module gitbook.install
    1. function gitbook.install.exec (args, kwargs)
    2. object gitbook.install.options
    3. string gitbook.install.description
    4. string gitbook.install.name
37. module gitbook.language
    1. function gitbook.language (values)
38. module gitbook.language.prototype
    1. function gitbook.language.prototype.constructor (values)
    2. function gitbook.language.prototype.getID ()
    3. function gitbook.language.prototype.getPath ()
    4. function gitbook.language.prototype.getTitle ()
39. module gitbook.languages
    1. function gitbook.languages (values)
    2. function gitbook.languages.createFromList (file, langs)
40. module gitbook.languages.prototype
    1. function gitbook.languages.prototype.constructor (values)
    2. function gitbook.languages.prototype.getCount ()
    3. function gitbook.languages.prototype.getDefaultLanguage ()
    4. function gitbook.languages.prototype.getFile ()
    5. function gitbook.languages.prototype.getLanguage (lang)
    6. function gitbook.languages.prototype.getList ()
    7. number gitbook.languages.prototype.size
    8. object gitbook.languages.prototype._defaultValues
    9. object gitbook.languages.prototype._keys
41. module gitbook.location
    1. function gitbook.location.areIdenticalPaths (p1, p2)
    2. function gitbook.location.flatten (href)
    3. function gitbook.location.isAnchor (href)
    4. function gitbook.location.isDataURI (href)
    5. function gitbook.location.isExternal (href)
    6. function gitbook.location.isRelative (href)
    7. function gitbook.location.normalize (s)
    8. function gitbook.location.relative (dir, file)
    9. function gitbook.location.relativeForFile (baseFile, file)
    10. function gitbook.location.toAbsolute (_href, dir, outdir)
42. module gitbook.logger
    1. function gitbook.logger (write, logLevel)
    2. object gitbook.logger.LEVELS
43. module gitbook.logger.prototype
    1. function gitbook.logger.prototype.fail (level)
    2. function gitbook.logger.prototype.format ()
    3. function gitbook.logger.prototype.getLevel (logLevel)
    4. function gitbook.logger.prototype.log (level)
    5. function gitbook.logger.prototype.logLn ()
    6. function gitbook.logger.prototype.ok (level)
    7. function gitbook.logger.prototype.promise (level, p)
    8. function gitbook.logger.prototype.setLevel (logLevel)
    9. function gitbook.logger.prototype.write (msg)
    10. function gitbook.logger.prototype.writeLn (msg)
44. module gitbook.output
    1. function gitbook.output (values)
45. module gitbook.output.prototype
    1. function gitbook.output.prototype.constructor (values)
    2. function gitbook.output.prototype.getAssets ()
    3. function gitbook.output.prototype.getBook ()
    4. function gitbook.output.prototype.getGenerator ()
    5. function gitbook.output.prototype.getLogger ()
    6. function gitbook.output.prototype.getOptions ()
    7. function gitbook.output.prototype.getPage (filePath)
    8. function gitbook.output.prototype.getPages ()
    9. function gitbook.output.prototype.getPlugins ()
    10. function gitbook.output.prototype.getRoot ()
    11. function gitbook.output.prototype.getState ()
    12. function gitbook.output.prototype.setOptions (newOptions)
    13. function gitbook.output.prototype.setState (newState)
46. module gitbook.parse
    1. function gitbook.parse.exec (args, kwargs)
    2. object gitbook.parse.options
    3. string gitbook.parse.description
    4. string gitbook.parse.name
47. module gitbook.parser
    1. function gitbook.parser (values)
    2. function gitbook.parser.create (name, extensions, module)
48. module gitbook.parser.prototype
    1. function gitbook.parser.prototype.constructor (values)
    2. function gitbook.parser.prototype.getExtensions ()
    3. function gitbook.parser.prototype.getName ()
    4. function gitbook.parser.prototype.matchExtension (ext)
    5. function gitbook.parser.prototype.parseGlossary (content)
    6. function gitbook.parser.prototype.parseInline (content)
    7. function gitbook.parser.prototype.parseLanguages (content)
    8. function gitbook.parser.prototype.parsePage (content)
    9. function gitbook.parser.prototype.parseReadme (content)
    10. function gitbook.parser.prototype.parseSummary (content)
    11. function gitbook.parser.prototype.preparePage (content)
    12. function gitbook.parser.prototype.renderGlossary (content)
    13. function gitbook.parser.prototype.renderLanguages (content)
    14. function gitbook.parser.prototype.renderSummary (content)
    15. number gitbook.parser.prototype.size
    16. object gitbook.parser.prototype._defaultValues
    17. object gitbook.parser.prototype._keys
49. module gitbook.parsers
    1. function gitbook.parsers.get (name)
    2. function gitbook.parsers.getByExt (ext)
    3. function gitbook.parsers.getForFile (filename)
    4. object gitbook.parsers.extensions
50. module gitbook.path
    1. function gitbook.path.isInRoot (root, filename)
    2. function gitbook.path.isPureRelative (filename)
    3. function gitbook.path.normalize (filename)
    4. function gitbook.path.resolveInRoot (root)
    5. function gitbook.path.setExtension (filename, ext)
51. module gitbook.plugin
    1. function gitbook.plugin (values)
    2. function gitbook.plugin.createFromDep (dep)
    3. function gitbook.plugin.createFromString (s)
    4. function gitbook.plugin.nameToNpmID (s)
52. module gitbook.plugin.prototype
    1. function gitbook.plugin.prototype.constructor (values)
    2. function gitbook.plugin.prototype.getBlocks ()
    3. function gitbook.plugin.prototype.getContent ()
    4. function gitbook.plugin.prototype.getDepth ()
    5. function gitbook.plugin.prototype.getFilters ()
    6. function gitbook.plugin.prototype.getHook (name)
    7. function gitbook.plugin.prototype.getHooks ()
    8. function gitbook.plugin.prototype.getName ()
    9. function gitbook.plugin.prototype.getNpmID ()
    10. function gitbook.plugin.prototype.getPackage ()
    11. function gitbook.plugin.prototype.getParent ()
    12. function gitbook.plugin.prototype.getPath ()
    13. function gitbook.plugin.prototype.getResources (type)
    14. function gitbook.plugin.prototype.getVersion ()
    15. function gitbook.plugin.prototype.isLoaded ()
    16. function gitbook.plugin.prototype.isTheme ()
53. module gitbook.promise
    1. boolean gitbook.promise.longStackSupport
    2. function gitbook.promise (resolver)
    3. function gitbook.promise.Promise (resolver)
    4. function gitbook.promise.all (promises)
    5. function gitbook.promise.allResolved ()
    6. function gitbook.promise.allSettled (promises)
    7. function gitbook.promise.any (promises)
    8. function gitbook.promise.async (makeGenerator)
    9. function gitbook.promise.catch (object, rejected)
    10. function gitbook.promise.defer ()
    11. function gitbook.promise.del (object, key)
    12. function gitbook.promise.delay (object, timeout)
    13. function gitbook.promise.delete (object, key)
    14. function gitbook.promise.denodeify (callback)
    15. function gitbook.promise.dispatch (object, op, args)
    16. function gitbook.promise.done (object, fulfilled, rejected, progress)
    17. function gitbook.promise.fail (object, rejected)
    18. function gitbook.promise.fapply (object, args)
    19. function gitbook.promise.fbind (object)
    20. function gitbook.promise.fcall (object)
    21. function gitbook.promise.fin (object, callback)
    22. function gitbook.promise.finally (object, callback)
    23. function gitbook.promise.forEach (arr, iter)
    24. function gitbook.promise.fulfill (value)
    25. function gitbook.promise.get (object, key)
    26. function gitbook.promise.getUnhandledReasons ()
    27. function gitbook.promise.invoke (object, name)
    28. function gitbook.promise.isFulfilled (object)
    29. function gitbook.promise.isPending (object)
    30. function gitbook.promise.isPromise (object)
    31. function gitbook.promise.isPromiseAlike (object)
    32. function gitbook.promise.isRejected (object)
    33. function gitbook.promise.join (x, y)
    34. function gitbook.promise.keys (object)
    35. function gitbook.promise.makePromise (descriptor, fallback, inspect)
    36. function gitbook.promise.map (arr, iter)
    37. function gitbook.promise.mapply (object, name, args)
    38. function gitbook.promise.master (object)
    39. function gitbook.promise.mcall (object, name)
    40. function gitbook.promise.nbind (callback, thisp)
    41. function gitbook.promise.nearer (value)
    42. function gitbook.promise.nextTick (task)
    43. function gitbook.promise.nfapply (callback, args)
    44. function gitbook.promise.nfbind (callback)
    45. function gitbook.promise.nfcall (callback)
    46. function gitbook.promise.ninvoke (object, name)
    47. function gitbook.promise.nmapply (object, name, args)
    48. function gitbook.promise.nmcall (object, name)
    49. function gitbook.promise.noConflict ()
    50. function gitbook.promise.nodeify (object, nodeback)
    51. function gitbook.promise.npost (object, name, args)
    52. function gitbook.promise.nsend (object, name)
    53. function gitbook.promise.passByCopy (object)
    54. function gitbook.promise.post (object, name, args)
    55. function gitbook.promise.progress (object, progressed)
    56. function gitbook.promise.promised (callback)
    57. function gitbook.promise.race (answerPs)
    58. function gitbook.promise.reduce (arr, iter, base)
    59. function gitbook.promise.reject (reason)
    60. function gitbook.promise.resetUnhandledRejections ()
    61. function gitbook.promise.resolve (value)
    62. function gitbook.promise.return (value)
    63. function gitbook.promise.send (object, name)
    64. function gitbook.promise.serie (arr, iter, base)
    65. function gitbook.promise.set (object, key, value)
    66. function gitbook.promise.some (arr, iter)
    67. function gitbook.promise.spawn (makeGenerator)
    68. function gitbook.promise.spread (value, fulfilled, rejected)
    69. function gitbook.promise.stopUnhandledRejectionTracking ()
    70. function gitbook.promise.tap (promise, callback)
    71. function gitbook.promise.thenReject (promise, reason)
    72. function gitbook.promise.thenResolve (promise, value)
    73. function gitbook.promise.timeout (object, ms, error)
    74. function gitbook.promise.try (object)
    75. function gitbook.promise.when (value, fulfilled, rejected, progressed)
    76. function gitbook.promise.wrapfn (func)
54. module gitbook.readme
    1. function gitbook.readme (values)
    2. function gitbook.readme.create (file, def)
55. module gitbook.readme.prototype
    1. function gitbook.readme.prototype.constructor (values)
    2. function gitbook.readme.prototype.getDescription ()
    3. function gitbook.readme.prototype.getFile ()
    4. function gitbook.readme.prototype.getTitle ()
    5. number gitbook.readme.prototype.size
    6. object gitbook.readme.prototype._defaultValues
    7. object gitbook.readme.prototype._keys
56. module gitbook.serve
    1. function gitbook.serve.exec (args, kwargs)
    2. object gitbook.serve.options
    3. string gitbook.serve.description
    4. string gitbook.serve.name
57. module gitbook.server
    1. function gitbook.server ()
    2. function gitbook.server.super_ ()
58. module gitbook.server.prototype
    1. function gitbook.server.prototype.isRunning ()
    2. function gitbook.server.prototype.start (dir, port)
    3. function gitbook.server.prototype.stop ()
59. module gitbook.state
    1. function gitbook.state (values)
60. module gitbook.state.prototype
    1. function gitbook.state.prototype.constructor (values)
    2. function gitbook.state.prototype.getI18n ()
    3. function gitbook.state.prototype.getResources ()
61. module gitbook.summaryArticle
    1. function gitbook.summaryArticle (values)
    2. function gitbook.summaryArticle.create (def, level)
    3. function gitbook.summaryArticle.findArticle (base, iter)
62. module gitbook.summaryArticle.prototype
    1. function gitbook.summaryArticle.prototype.constructor (values)
    2. function gitbook.summaryArticle.prototype.createChildLevel ()
    3. function gitbook.summaryArticle.prototype.getAnchor ()
    4. function gitbook.summaryArticle.prototype.getArticles ()
    5. function gitbook.summaryArticle.prototype.getDepth ()
    6. function gitbook.summaryArticle.prototype.getLevel ()
    7. function gitbook.summaryArticle.prototype.getPath ()
    8. function gitbook.summaryArticle.prototype.getRef ()
    9. function gitbook.summaryArticle.prototype.getTitle ()
    10. function gitbook.summaryArticle.prototype.getUrl ()
    11. function gitbook.summaryArticle.prototype.isExternal ()
    12. function gitbook.summaryArticle.prototype.isFile (file)
    13. function gitbook.summaryArticle.prototype.isPage ()
    14. function gitbook.summaryArticle.prototype.isReadme (book)
63. module gitbook.summaryPart
    1. function gitbook.summaryPart (values)
    2. function gitbook.summaryPart.create (def, level)
64. module gitbook.summaryPart.prototype
    1. function gitbook.summaryPart.prototype.constructor (values)
    2. function gitbook.summaryPart.prototype.createChildLevel ()
    3. function gitbook.summaryPart.prototype.getArticles ()
    4. function gitbook.summaryPart.prototype.getLevel ()
    5. function gitbook.summaryPart.prototype.getTitle ()
65. module gitbook.templateBlock
    1. function gitbook.templateBlock (values)
    2. function gitbook.templateBlock.create (blockName, block)
66. module gitbook.templateBlock.prototype
    1. function gitbook.templateBlock.prototype.applyBlock (inner, context)
    2. function gitbook.templateBlock.prototype.blockResultToHtml (result, blocksOutput)
    3. function gitbook.templateBlock.prototype.constructor (values)
    4. function gitbook.templateBlock.prototype.getBlocks ()
    5. function gitbook.templateBlock.prototype.getEndTag ()
    6. function gitbook.templateBlock.prototype.getExtensionName ()
    7. function gitbook.templateBlock.prototype.getName ()
    8. function gitbook.templateBlock.prototype.getProcess ()
    9. function gitbook.templateBlock.prototype.getShortcuts ()
    10. function gitbook.templateBlock.prototype.normalizeBlockResult (result)
    11. function gitbook.templateBlock.prototype.toNunjucksExt (mainContext, blocksOutput)
    12. number gitbook.templateBlock.prototype.size
    13. object gitbook.templateBlock.prototype._defaultValues
    14. object gitbook.templateBlock.prototype._keys
    15. string gitbook.templateBlock.prototype._name
67. module gitbook.templateEngine
    1. function gitbook.templateEngine (values)
    2. function gitbook.templateEngine.create (def)
68. module gitbook.templateEngine.prototype
    1. function gitbook.templateEngine.prototype.constructor (values)
    2. function gitbook.templateEngine.prototype.getBlock (name)
    3. function gitbook.templateEngine.prototype.getBlocks ()
    4. function gitbook.templateEngine.prototype.getContext ()
    5. function gitbook.templateEngine.prototype.getExtensions ()
    6. function gitbook.templateEngine.prototype.getFilters ()
    7. function gitbook.templateEngine.prototype.getGlobals ()
    8. function gitbook.templateEngine.prototype.getLoader ()
    9. function gitbook.templateEngine.prototype.getShortcuts ()
    10. function gitbook.templateEngine.prototype.toNunjucks (blocksOutput)
69. module gitbook.templateOutput
    1. function gitbook.templateOutput (values)
    2. function gitbook.templateOutput.create (content, blocks)
70. module gitbook.templateOutput.prototype
    1. function gitbook.templateOutput.prototype.constructor (values)
    2. function gitbook.templateOutput.prototype.getBlocks ()
    3. function gitbook.templateOutput.prototype.getContent ()
    4. function gitbook.templateOutput.prototype.setContent (content)
71. module gitbook.templateShortcut
    1. function gitbook.templateShortcut (values)
    2. function gitbook.templateShortcut.createForBlock (block, details)
72. module gitbook.templateShortcut.prototype
    1. function gitbook.templateShortcut.prototype.acceptParser (parser)
    2. function gitbook.templateShortcut.prototype.constructor (values)
    3. function gitbook.templateShortcut.prototype.getEnd ()
    4. function gitbook.templateShortcut.prototype.getEndTag ()
    5. function gitbook.templateShortcut.prototype.getParsers ()
    6. function gitbook.templateShortcut.prototype.getStart ()
    7. function gitbook.templateShortcut.prototype.getStartTag ()
73. module gitbook.themesLoader
    1. function gitbook.themesLoader ()
    2. function gitbook.themesLoader.extend (name, props)
74. module gitbook.themesLoader.prototype
    1. function gitbook.themesLoader.prototype.constructor ()
    2. function gitbook.themesLoader.prototype.getSearchPath (filepath)
    3. function gitbook.themesLoader.prototype.getSource (fullpath)
    4. function gitbook.themesLoader.prototype.getTemplateName (filepath)
    5. function gitbook.themesLoader.prototype.init (searchPaths)
    6. function gitbook.themesLoader.prototype.isRelative ()
    7. function gitbook.themesLoader.prototype.resolve (from, to)
    8. string gitbook.themesLoader.prototype.typename
75. module gitbook.timing
    1. function gitbook.timing.dump (logger)
    2. function gitbook.timing.measure (type, p)

module gitbook

function gitbook.Book (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.Config (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.FS (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.File (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.Glossary (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.Page (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.PluginDependency (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.Summary (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.conrefsLoader ()

• description and source-code

  conrefsLoader = function () {
      if(prototype.init) {
          prototype.init.apply(this, arguments);
      }
  }

• example usage

  n/a

function gitbook.createNodeFS (root)

• description and source-code

  function createNodeFS(root) {
      return FS.create({
          root: root,
  
          fsExists: fs.exists,
          fsReadFile: fs.readFile,
          fsStatFile: fs.stat,
          fsReadDir: fsReadDir,
          fsLoadObject: fsLoadObject,
          fsReadAsStream: fs.readStream
      });
  }

• example usage

  n/a

function gitbook.glossaryEntry (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.ignore (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.initBook (rootFolder)

• description and source-code

  function initBook(rootFolder) {
      var extension = '.md';
  
      return fs.mkdirp(rootFolder)
  
      // Parse the summary and readme
      .then(function() {
          var fs = createNodeFS(rootFolder);
          var book = Book.createForFS(fs);
  
          return Parse.parseReadme(book)
  
          // Setup default readme if doesn't found one
          .fail(function() {
              var readmeFile = File.createWithFilepath('README' + extension);
              var readme = Readme.create(readmeFile);
              return book.setReadme(readme);
          });
      })
      .then(Parse.parseSummary)
  
      .then(function(book) {
          var logger = book.getLogger();
          var summary = book.getSummary();
          var summaryFile = summary.getFile();
          var summaryFilename = summaryFile.getPath() || ('SUMMARY' + extension);
  
          var articles = summary.getArticlesAsList();
  
          // Write pages
          return Promise.forEach(articles, function(article) {
              var articlePath = article.getPath();
              var filePath = articlePath? path.join(rootFolder, articlePath) : null;
              if (!filePath) {
                  return;
              }
  
              return fs.assertFile(filePath, function() {
                  return fs.ensureFile(filePath)
                  .then(function() {
                      logger.info.ln('create', article.getPath());
                      return fs.writeFile(filePath, '# ' + article.getTitle() + '\n\n');
                  });
              });
          })
  
          // Write summary
          .then(function() {
              var filePath = path.join(rootFolder, summaryFilename);
  
              return fs.ensureFile(filePath)
              .then(function() {
                  logger.info.ln('create ' + path.basename(filePath));
                  return fs.writeFile(filePath, summary.toText(extension));
              });
          })
  
          // Log end
          .then(function() {
              logger.info.ln('initialization is finished');
          });
      });
  }

• example usage

  n/a

function gitbook.language (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.languages (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.logger (write, logLevel)

• description and source-code

  function Logger(write, logLevel) {
      if (!(this instanceof Logger)) return new Logger(write, logLevel);
  
      this._write = write || function(msg) {
          if(process.stdout) {
              process.stdout.write(msg);
          }
      };
      this.lastChar = '\n';
  
      this.setLevel(logLevel || 'info');
  
      // Create easy-to-use method like "logger.debug.ln('....')"
      LEVELS.forEach(function(level, levelKey) {
          if (levelKey === 'DISABLED') {
              return;
          }
          levelKey = levelKey.toLowerCase();
  
          this[levelKey] =            this.log.bind(this, level);
          this[levelKey].ln =         this.logLn.bind(this, level);
          this[levelKey].ok =         this.ok.bind(this, level);
          this[levelKey].fail =       this.fail.bind(this, level);
          this[levelKey].promise =    this.promise.bind(this, level);
      }, this);
  }

• example usage

  n/a

function gitbook.output (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.parser (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.plugin (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.promise (value)

• description and source-code

  function Q(value) {
      // If the object is already a Promise, return it directly.  This enables
      // the resolve function to both be used to created references from objects,
      // but to tolerably coerce non-promises to promises.
      if (value instanceof Promise) {
          return value;
      }
  
      // assimilate thenables
      if (isPromiseAlike(value)) {
          return coerce(value);
      } else {
          return fulfill(value);
      }
  }

• example usage

  ...
              })
  
              // Log end
              .then(function(count) {
                  logger.info.ok(count + ' file(s) generated');
  
                  logger.debug('cleaning up... ');
                  return logger.debug.promise(fs.rmDir(outputFolder));
              });
          }
      };
  };
  ...

function gitbook.readme (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.server ()

• description and source-code

  function Server() {
      this.running = null;
      this.dir = null;
      this.port = 0;
      this.sockets = [];
  }

• example usage

  n/a

function gitbook.state (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.summaryArticle (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.summaryPart (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.templateBlock (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.templateEngine (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.templateOutput (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.templateShortcut (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.themesLoader ()

• description and source-code

  themesLoader = function () {
      if(prototype.init) {
          prototype.init.apply(this, arguments);
      }
  }

• example usage

  n/a

module gitbook.Book

function gitbook.Book (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.Book.createForFS (fs)

• description and source-code

  function createForFS(fs) {
      return new Book({
          fs: fs
      });
  }

• example usage

  ...
      var extension = '.md';
  
      return fs.mkdirp(rootFolder)
  
      // Parse the summary and readme
      .then(function() {
  var fs = createNodeFS(rootFolder);
  var book = Book.createForFS(fs);
  
  return Parse.parseReadme(book)
  
  // Setup default readme if doesn't found one
  .fail(function() {
      var readmeFile = File.createWithFilepath('README' + extension);
      var readme = Readme.create(readmeFile);
  ...

function gitbook.Book.createFromParent (parent, language)

• description and source-code

  function createFromParent(parent, language) {
      var ignore = parent.getIgnore();
      var config = parent.getConfig();
  
      // Set language in configuration
      config = config.setValue('language', language);
  
      return new Book({
          // Inherits config. logegr and list of ignored files
          logger: parent.getLogger(),
          config: config,
          ignore: ignore,
  
          language: language,
          fs: FS.reduceScope(parent.getContentFS(), language)
      });
  }

• example usage

  ...
  */
  function parseMultilingualBook(book) {
      var languages = book.getLanguages();
      var langList = languages.getList();
  
      return Promise.reduce(langList, function(currentBook, lang) {
  var langID = lang.getID();
  var child = Book.createFromParent(currentBook, langID);
  var ignore = currentBook.getIgnore();
  
  return Promise(child)
  .then(parseConfig)
  .then(parseBookContent)
  .then(function(result) {
      // Ignore content of this book when generating parent book
  ...

module gitbook.Book.prototype

function gitbook.Book.prototype.addLanguageBook (language, book)

• description and source-code

  addLanguageBook = function (language, book) {
      var books = this.getBooks();
      books = books.set(language, book);
  
      return this.set('books', books);
  }

• example usage

  ...
      .then(parseConfig)
      .then(parseBookContent)
      .then(function(result) {
          // Ignore content of this book when generating parent book
          ignore = ignore.add(langID + '/**');
          currentBook = currentBook.set('ignore', ignore);
  
          return currentBook.addLanguageBook(langID, result);
      });
  }, book);
  }
  
  
  /**
  Parse a whole book from a filesystem
  ...

function gitbook.Book.prototype.constructor (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.Book.prototype.getBooks ()

• description and source-code

  getBooks = function () {
      return this.get('books');
  }

• example usage

  ...
      logger.info.ln('Table of Contents file is', summaryFile.getPath());
  }
  }
  
  function printMultingualBook(book) {
  var logger = book.getLogger();
  var languages = book.getLanguages();
  var books = book.getBooks();
  
  logger.info.ln(languages.size + ' languages');
  
  languages.forEach(function(lang) {
      logger.info.ln('Language:', lang.getTitle());
      printBook(books.get(lang.getID()));
      logger.info.ln('');
  ...

function gitbook.Book.prototype.getConfig ()

• description and source-code

  getConfig = function () {
      return this.get('config');
  }

• example usage

  ...
  
      @param {Output} output
      @param {Object} result: result from API
      @return {Output}
  */
  function decodeGlobal(output, result) {
      var book = output.getBook();
      var config = book.getConfig();
  
      // Update config
      config = decodeConfig(config, result.config);
      book = book.set('config', config);
  
      return output.set('book', book);
  }
  ...

function gitbook.Book.prototype.getContentFS ()

• description and source-code

  getContentFS = function () {
      var fs = this.getFS();
      var config = this.getConfig();
      var rootFolder = config.getValue('root');
  
      if (rootFolder) {
          return FS.reduceScope(fs, rootFolder);
      }
  
      return fs;
  }

• example usage

  ...
  It's the context for page's hook, etc
  
  @param {Output} output
  @return {Object}
  */
  function encodeGlobal(output) {
  var book = output.getBook();
  var bookFS = book.getContentFS();
  var logger = output.getLogger();
  var outputFolder = output.getRoot();
  var plugins = output.getPlugins();
  var blocks = Plugins.listBlocks(plugins);
  
  var result = {
      log: logger,
  ...

function gitbook.Book.prototype.getContentRoot ()

• description and source-code

  getContentRoot = function () {
      var fs = this.getContentFS();
      return fs.getRoot();
  }

• example usage

  ...
          /**
  Resolve a file from the book root
  
  @param {String} fileName
  @return {String}
          */
          resolve: function(fileName) {
  return path.resolve(book.getContentRoot(), fileName);
          },
  
          /**
  Resolve a page by it path
  
  @param {String} filePath
  @return {String}
  ...

function gitbook.Book.prototype.getDefaultExt ()

• description and source-code

  getDefaultExt = function () {
      // Inferring sources
      var clues = [
          this.getReadme(),
          this.getSummary(),
          this.getGlossary()
      ];
  
      // List their extensions
      var exts = clues.map(function (clue) {
          var file = clue.getFile();
          if (file.exists()) {
              return file.getParser().getExtensions().first();
          } else {
              return null;
          }
      });
      // Adds the general default extension
      exts.push('.md');
  
      // Choose the first non null
      return exts.find(function (e) { return e !== null; });
  }

• example usage

  ...
  /**
      Infer the default path for a Readme.
      @param {Boolean} [absolute=false] False for a path relative to
          this book's content root
      @return {String}
  */
  Book.prototype.getDefaultReadmePath = function(absolute) {
      var defaultPath = 'README'+this.getDefaultExt();
      if (absolute) {
          return path.join(this.getContentRoot(), defaultPath);
      } else {
          return defaultPath;
      }
  };
  ...

function gitbook.Book.prototype.getDefaultGlossaryPath (absolute)

• description and source-code

  getDefaultGlossaryPath = function (absolute) {
      var defaultPath = 'GLOSSARY'+this.getDefaultExt();
      if (absolute) {
          return path.join(this.getContentRoot(), defaultPath);
      } else {
          return defaultPath;
      }
  }

• example usage

  n/a

function gitbook.Book.prototype.getDefaultReadmePath (absolute)

• description and source-code

  getDefaultReadmePath = function (absolute) {
      var defaultPath = 'README'+this.getDefaultExt();
      if (absolute) {
          return path.join(this.getContentRoot(), defaultPath);
      } else {
          return defaultPath;
      }
  }

• example usage

  n/a

function gitbook.Book.prototype.getDefaultSummaryPath (absolute)

• description and source-code

  getDefaultSummaryPath = function (absolute) {
      var defaultPath = 'SUMMARY'+this.getDefaultExt();
      if (absolute) {
          return path.join(this.getContentRoot(), defaultPath);
      } else {
          return defaultPath;
      }
  }

• example usage

  n/a

function gitbook.Book.prototype.getFS ()

• description and source-code

  getFS = function () {
      return this.get('fs');
  }

• example usage

  ...
  
  /**
  Return FS instance to access the content
  
  @return {FS}
  */
  Book.prototype.getContentFS = function() {
  var fs = this.getFS();
  var config = this.getConfig();
  var rootFolder = config.getValue('root');
  
  if (rootFolder) {
      return FS.reduceScope(fs, rootFolder);
  }
  ...

function gitbook.Book.prototype.getGlossary ()

• description and source-code

  getGlossary = function () {
      return this.get('glossary');
  }

• example usage

  ...
  
  var summary = book.getSummary();
  var summaryFile = summary.getFile();
  
  var readme = book.getReadme();
  var readmeFile = readme.getFile();
  
  var glossary = book.getGlossary();
  var glossaryFile = glossary.getFile();
  
  if (configFile.exists()) {
      logger.info.ln('Configuration file is', configFile.getPath());
  }
  
  if (readmeFile.exists()) {
  ...

function gitbook.Book.prototype.getIgnore ()

• description and source-code

  getIgnore = function () {
      return this.get('ignore');
  }

• example usage

  ...
  /**
  Check if a file is ignore (should not being parsed, etc)
  
  @param {String} ref
  @return {Page|undefined}
  */
  Book.prototype.isFileIgnored = function(filename) {
  var ignore = this.getIgnore();
  var language = this.getLanguage();
  
  // Ignore is always relative to the root of the main book
  if (language) {
      filename = path.join(language, filename);
  }
  ...

function gitbook.Book.prototype.getLanguage ()

• description and source-code

  getLanguage = function () {
      return this.get('language');
  }

• example usage

  ...
  Encode a book to JSON
  
  @param {Book}
  @return {Object}
  */
  function encodeBookToJson(book) {
  var config = book.getConfig();
  var language = book.getLanguage();
  
  var variables = config.getValue('variables', {});
  
  return {
      summary: encodeSummary(book.getSummary()),
      glossary: encodeGlossary(book.getGlossary()),
      readme: encodeReadme(book.getReadme()),
  ...

function gitbook.Book.prototype.getLanguageBook (language)

• description and source-code

  getLanguageBook = function (language) {
      var books = this.getBooks();
      return books.get(language);
  }

• example usage

  n/a

function gitbook.Book.prototype.getLanguages ()

• description and source-code

  getLanguages = function () {
      return this.get('languages');
  }

• example usage

  ...
                      format: format
                  });
              })
  
              // Extract ebook file
              .then(function(output) {
                  var book = output.getBook();
                  var languages = book.getLanguages();
  
                  if (book.isMultilingual()) {
                      return Promise.forEach(languages.getList(), function(lang) {
  var langID = lang.getID();
  
  var langOutputFile = path.join(
      path.dirname(outputFile),
  ...

function gitbook.Book.prototype.getLogger ()

• description and source-code

  getLogger = function () {
      return this.get('logger');
  }

• example usage

  ...
      var readme = Readme.create(readmeFile);
      return book.setReadme(readme);
  });
      })
      .then(Parse.parseSummary)
  
      .then(function(book) {
  var logger = book.getLogger();
  var summary = book.getSummary();
  var summaryFile = summary.getFile();
  var summaryFilename = summaryFile.getPath() || ('SUMMARY' + extension);
  
  var articles = summary.getArticlesAsList();
  
  // Write pages
  ...

function gitbook.Book.prototype.getPage (ref)

• description and source-code

  getPage = function (ref) {
      return this.getPages().get(ref);
  }

• example usage

  ...
  /**
      Resolve a page by it path
  
      @param {String} filePath
      @return {String}
  */
  getPageByPath: function(filePath) {
      var page = output.getPage(filePath);
      if (!page) return undefined;
  
      return encodePage(output, page);
  },
  
  /**
      Render a block of text (markdown/asciidoc)
  ...

function gitbook.Book.prototype.getReadme ()

• description and source-code

  getReadme = function () {
      return this.get('readme');
  }

• example usage

  ...
  
  var config = book.getConfig();
  var configFile = config.getFile();
  
  var summary = book.getSummary();
  var summaryFile = summary.getFile();
  
  var readme = book.getReadme();
  var readmeFile = readme.getFile();
  
  var glossary = book.getGlossary();
  var glossaryFile = glossary.getFile();
  
  if (configFile.exists()) {
      logger.info.ln('Configuration file is', configFile.getPath());
  ...

function gitbook.Book.prototype.getRoot ()

• description and source-code

  getRoot = function () {
      var fs = this.getFS();
      return fs.getRoot();
  }

• example usage

  ...
      deprecate.field(output, 'config.options', result, 'options',
          result.values, '"config.options" property is deprecated, use "config.get(key)" instead');
  
      deprecate.field(output, 'config.options.generator', result.values, 'generator',
          output.getGenerator(), '"options.generator" property is deprecated, use "output.name" instead&#
  x27;);
  
      deprecate.field(output, 'config.options.generator', result.values, 'output',
          output.getRoot(), '"options.output" property is deprecated, use
   "output.root()" instead');
  
      return result;
  }
  
  module.exports = encodeConfig;
  ...

function gitbook.Book.prototype.getSummary ()

• description and source-code

  getSummary = function () {
      return this.get('summary');
  }

• example usage

  ...
      return book.setReadme(readme);
  });
      })
      .then(Parse.parseSummary)
  
      .then(function(book) {
  var logger = book.getLogger();
  var summary = book.getSummary();
  var summaryFile = summary.getFile();
  var summaryFilename = summaryFile.getPath() || ('SUMMARY' + extension);
  
  var articles = summary.getArticlesAsList();
  
  // Write pages
  return Promise.forEach(articles, function(article) {
  ...

function gitbook.Book.prototype.isContentFileIgnored (filename)

• description and source-code

  isContentFileIgnored = function (filename) {
      var config = this.getConfig();
      var rootFolder = config.getValue('root');
  
      if (rootFolder) {
          filename = path.join(rootFolder, filename);
      }
  
      return this.isFileIgnored(filename);
  }

• example usage

  ...
      var exts = parsers.extensions;
  
      return Promise.some(exts, function(ext) {
          var filepath = basename + ext;
  
          return fs.findFile(basedir, filepath)
          .then(function(found) {
              if (!found || book.isContentFileIgnored(found)) {
                  return undefined;
              }
  
              return fs.statFile(found);
          });
      });
  }
  ...

function gitbook.Book.prototype.isFileIgnored (filename)

• description and source-code

  isFileIgnored = function (filename) {
      var ignore = this.getIgnore();
      var language = this.getLanguage();
  
      // Ignore is always relative to the root of the main book
      if (language) {
          filename = path.join(language, filename);
      }
  
      return ignore.isFileIgnored(filename);
  }

• example usage

  ...
  var language = this.getLanguage();
  
  // Ignore is always relative to the root of the main book
  if (language) {
      filename = path.join(language, filename);
  }
  
  return ignore.isFileIgnored(filename);
  };
  
  /**
  Check if a content file is ignore (should not being parsed, etc)
  
  @param {String} ref
  @return {Page|undefined}
  ...

function gitbook.Book.prototype.isLanguageBook ()

• description and source-code

  isLanguageBook = function () {
      return Boolean(this.getLanguage());
  }

• example usage

  ...
  
          /**
  Check if the book is a language book for a multilingual book
  
  @return {Boolean}
          */
          isLanguageBook: function() {
  return book.isLanguageBook();
          },
  
          /**
  Read a file from the book
  
  @param {String} fileName
  @return {Promise<Buffer>}
  ...

function gitbook.Book.prototype.isMultilingual ()

• description and source-code

  isMultilingual = function () {
      return (this.getLanguages().getCount() > 0);
  }

• example usage

  ...
  
  /**
      Check if the book is a multilingual book
  
      @return {Boolean}
  */
  isMultilingual: function() {
      return book.isMultilingual();
  },
  
  /**
      Check if the book is a language book for a multilingual book
  
      @return {Boolean}
  */
  ...

function gitbook.Book.prototype.setConfig (config)

• description and source-code

  setConfig = function (config) {
      return this.set('config', config);
  }

• example usage

  ...
          if (result.file) {
              config = config.setFile(result.file);
          }
  
          // Merge with old values
          config = config.mergeValues(values);
  
          return book.setConfig(config);
      });
  }
  
  module.exports = parseConfig;
  ...

function gitbook.Book.prototype.setIgnore (ignore)

• description and source-code

  setIgnore = function (ignore) {
      return this.set('ignore', ignore);
  }

• example usage

  ...
              ignore = ignore.add(content.toString().split(/\r?\n/));
          }, function(err) {
              return Promise();
          });
      })
  
      .then(function() {
          return book.setIgnore(ignore);
      });
  }
  
  module.exports = parseIgnore;
  ...

function gitbook.Book.prototype.setLogLevel (level)

• description and source-code

  setLogLevel = function (level) {
      this.getLogger().setLevel(level);
      return this;
  }

• example usage

  ...
  function getBook(args, kwargs) {
      var input = path.resolve(args[0] || process.cwd());
      var logLevel = kwargs.log;
  
      var fs = createNodeFS(input);
      var book = Book.createForFS(fs);
  
      return book.setLogLevel(logLevel);
  }
  
  module.exports = getBook;
  ...

function gitbook.Book.prototype.setReadme (readme)

• description and source-code

  setReadme = function (readme) {
      return this.set('readme', readme);
  }

• example usage

  ...
  
      return Parse.parseReadme(book)
  
      // Setup default readme if doesn't found one
      .fail(function() {
          var readmeFile = File.createWithFilepath('README' + extension);
          var readme = Readme.create(readmeFile);
          return book.setReadme(readme);
      });
  })
  .then(Parse.parseSummary)
  
  .then(function(book) {
      var logger = book.getLogger();
      var summary = book.getSummary();
  ...

function gitbook.Book.prototype.setSummary (summary)

• description and source-code

  setSummary = function (summary) {
      return this.set('summary', summary);
  }

• example usage

  ...
              summary = SummaryModifier.unshiftArticle(summary, {
                  title: 'Introduction',
                  ref: readmeFile.getPath()
              });
          }
  
          // Set new summary
          return book.setSummary(summary);
      });
  }
  
  module.exports = parseSummary;
  ...

module gitbook.Config

function gitbook.Config (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.Config.create (file, values)

• description and source-code

  create = function (file, values) {
      return new Config({
          file: file,
          values: Immutable.fromJS(values)
      });
  }

• example usage

  ...
      var book = Book.createForFS(fs);
  
      return Parse.parseReadme(book)
  
      // Setup default readme if doesn't found one
      .fail(function() {
          var readmeFile = File.createWithFilepath('README' + extension);
          var readme = Readme.create(readmeFile);
          return book.setReadme(readme);
      });
  })
  .then(Parse.parseSummary)
  
  .then(function(book) {
      var logger = book.getLogger();
  ...

function gitbook.Config.createWithValues (values)

• description and source-code

  createWithValues = function (values) {
      return new Config({
          values: Immutable.fromJS(values)
      });
  }

• example usage

  ...
  
  
  
  var Immutable = require('immutable');
  var Config = require('../config');
  
  describe('Config', function() {
  var config = Config.createWithValues({
      hello: {
          world: 1,
          test: 'Hello',
          isFalse: false
      }
  });
  ...

function gitbook.Config.keyToKeyPath (keyPath)

• description and source-code

  keyToKeyPath = function (keyPath) {
      if (is.string(keyPath)) keyPath = keyPath.split('.');
      return keyPath;
  }

• example usage

  ...
  /**
   * Return a configuration value by its key path
   * @param {String} key
   * @return {Mixed}
   */
  Config.prototype.getValue = function(keyPath, def) {
      var values = this.getValues();
      keyPath = Config.keyToKeyPath(keyPath);
  
      if (!values.hasIn(keyPath)) {
          return Immutable.fromJS(def);
      }
  
      return values.getIn(keyPath);
  };
  ...

module gitbook.Config.prototype

function gitbook.Config.prototype.constructor (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.Config.prototype.getFile ()

• description and source-code

  getFile = function () {
      return this.get('file');
  }

• example usage

  ...
  });
      })
      .then(Parse.parseSummary)
  
      .then(function(book) {
  var logger = book.getLogger();
  var summary = book.getSummary();
  var summaryFile = summary.getFile();
  var summaryFilename = summaryFile.getPath() || ('SUMMARY' + extension);
  
  var articles = summary.getArticlesAsList();
  
  // Write pages
  return Promise.forEach(articles, function(article) {
      var articlePath = article.getPath();
  ...

function gitbook.Config.prototype.getPluginDependencies ()

• description and source-code

  getPluginDependencies = function () {
      var plugins = this.getValue('plugins');
  
      if (is.string(plugins)) {
          return PluginDependency.listFromString(plugins);
      } else {
          return PluginDependency.listFromArray(plugins);
      }
  }

• example usage

  ...
  
  /**
   * Return a plugin dependency by its name
   * @param {String} name
   * @return {PluginDependency}
   */
  Config.prototype.getPluginDependency = function(name) {
      var plugins = this.getPluginDependencies();
  
      return plugins.find(function(dep) {
          return dep.getName() === name;
      });
  };
  
  /**
  ...

function gitbook.Config.prototype.getPluginDependency (name)

• description and source-code

  getPluginDependency = function (name) {
      var plugins = this.getPluginDependencies();
  
      return plugins.find(function(dep) {
          return dep.getName() === name;
      });
  }

• example usage

  n/a

function gitbook.Config.prototype.getValue (keyPath, def)

• description and source-code

  getValue = function (keyPath, def) {
      var values = this.getValues();
      keyPath = Config.keyToKeyPath(keyPath);
  
      if (!values.hasIn(keyPath)) {
          return Immutable.fromJS(def);
      }
  
      return values.getIn(keyPath);
  }

• example usage

  ...
  @param {Book}
  @return {Object}
  */
  function encodeBookToJson(book) {
  var config = book.getConfig();
  var language = book.getLanguage();
  
  var variables = config.getValue('variables', {});
  
  return {
      summary: encodeSummary(book.getSummary()),
      glossary: encodeGlossary(book.getGlossary()),
      readme: encodeReadme(book.getReadme()),
      config: book.getConfig().getValues().toJS(),
  ...

function gitbook.Config.prototype.getValues ()

• description and source-code

  getValues = function () {
      return this.get('values');
  }

• example usage

  ...
  
      @param {Output} output
      @param {Config} config
      @return {Object}
  */
  function encodeConfig(output, config) {
      var result = {
  values: config.getValues().toJS(),
  
  get: function(key, defaultValue) {
      return objectPath.get(result.values, key, defaultValue);
  },
  
  set: function(key, value) {
      return objectPath.set(result.values, key, value);
  ...

function gitbook.Config.prototype.mergeValues (values)

• description and source-code

  mergeValues = function (values) {
      var currentValues = this.getValues();
      values = Immutable.fromJS(values);
  
      currentValues = currentValues.mergeDeep(values);
  
      return this.set('values', currentValues);
  }

• example usage

  ...
  
          // Set the file
          if (result.file) {
              config = config.setFile(result.file);
          }
  
          // Merge with old values
          config = config.mergeValues(values);
  
          return book.setConfig(config);
      });
  }
  
  module.exports = parseConfig;
  ...

function gitbook.Config.prototype.setFile (file)

• description and source-code

  setFile = function (file) {
      return this.set('file', file);
  }

• example usage

  ...
  
  .then(function(result) {
      var values = result? result.values : {};
      values = validateConfig(values);
  
      // Set the file
      if (result.file) {
          config = config.setFile(result.file);
      }
  
      // Merge with old values
      config = config.mergeValues(values);
  
      return book.setConfig(config);
  });
  ...

function gitbook.Config.prototype.setPluginDependencies (deps)

• description and source-code

  setPluginDependencies = function (deps) {
      var plugins = PluginDependency.listToArray(deps);
  
      return this.setValue('plugins', plugins);
  }

• example usage

  ...
          return togglePlugin(config, pluginName, true);
      }
  
      var deps = config.getPluginDependencies();
      var dep = PluginDependency.create(pluginName, version);
  
      deps = deps.push(dep);
      return config.setPluginDependencies(deps);
  }
  
  module.exports = addPlugin;
  ...

function gitbook.Config.prototype.setValue (keyPath, value)

• description and source-code

  setValue = function (keyPath, value) {
      keyPath = Config.keyToKeyPath(keyPath);
  
      value = Immutable.fromJS(value);
  
      var values = this.getValues();
      values = values.setIn(keyPath, value);
  
      return this.set('values', values);
  }

• example usage

  ...
  @return {Book}
  */
  Book.createFromParent = function createFromParent(parent, language) {
  var ignore = parent.getIgnore();
  var config = parent.getConfig();
  
  // Set language in configuration
  config = config.setValue('language', language);
  
  return new Book({
      // Inherits config. logegr and list of ignored files
      logger: parent.getLogger(),
      config: config,
      ignore: ignore,
  ...

function gitbook.Config.prototype.toReducedVersion ()

• description and source-code

  toReducedVersion = function () {
      return reducedObject(configDefault, this.getValues());
  }

• example usage

  ...
  };
  
  /**
  * Render config as text
  * @return {Promise<String>}
  */
  Config.prototype.toText = function() {
     return JSON.stringify(this.toReducedVersion().toJS(), null, 4);
  };
  
  /**
  * Change the file for the configuration
  * @param {File} file
  * @return {Config}
  */
  ...

function gitbook.Config.prototype.toText ()

• description and source-code

  toText = function () {
      return JSON.stringify(this.toReducedVersion().toJS(), null, 4);
  }

• example usage

  ...
  // Write summary
  .then(function() {
      var filePath = path.join(rootFolder, summaryFilename);
  
      return fs.ensureFile(filePath)
      .then(function() {
          logger.info.ln('create ' + path.basename(filePath));
          return fs.writeFile(filePath, summary.toText(extension));
      });
  })
  
  // Log end
  .then(function() {
      logger.info.ln('initialization is finished');
  });
  ...

function gitbook.Config.prototype.updateValues (values)

• description and source-code

  updateValues = function (values) {
      values = Immutable.fromJS(values);
  
      return this.set('values', values);
  }

• example usage

  ...
  */
  function decodeGlobal(config, result) {
      var values = result.values;
  
      delete values.generator;
      delete values.output;
  
      return config.updateValues(values);
  }
  
  module.exports = decodeGlobal;
  ...

module gitbook.ConfigModifier

function gitbook.ConfigModifier.addPlugin (config, pluginName, version)

• description and source-code

  function addPlugin(config, pluginName, version) {
      // For default plugin, we only ensure it is enabled
      if (isDefaultPlugin(pluginName, version)) {
          return togglePlugin(config, pluginName, true);
      }
  
      var deps = config.getPluginDependencies();
      var dep = PluginDependency.create(pluginName, version);
  
      deps = deps.push(dep);
      return config.setPluginDependencies(deps);
  }

• example usage

  ...
      return server.stop()
      .then(function() {
  return Parse.parseBook(book)
  .then(function(resultBook) {
      if (hasLiveReloading) {
          // Enable livereload plugin
          var config = resultBook.getConfig();
          config = ConfigModifier.addPlugin(config, 'livereload');
          resultBook = resultBook.set('config', config);
      }
  
      return Output.generate(Generator, resultBook, {
          root: outputFolder
      });
  });
  ...

function gitbook.ConfigModifier.editPlugin (config, pluginName, pluginConfig)

• description and source-code

  function editPlugin(config, pluginName, pluginConfig) {
      return config.setValue('pluginsConfig.'+pluginName, pluginConfig);
  }

• example usage

  n/a

function gitbook.ConfigModifier.getPluginConfig (config, pluginName)

• description and source-code

  function getPluginConfig(config, pluginName) {
      var pluginsConfig = config.getValues().get('pluginsConfig');
      if (pluginsConfig === undefined) {
          return {};
      }
      var pluginConf = pluginsConfig.get(pluginName);
      if (pluginConf === undefined) {
          return {};
      } else {
          return pluginConf.toJS();
      }
  }

• example usage

  n/a

function gitbook.ConfigModifier.hasPlugin (deps, pluginName, version)

• description and source-code

  function hasPlugin(deps, pluginName, version) {
      return !!deps.find(function(dep) {
          return dep.getName() === pluginName && (!version || dep.getVersion() === version);
      });
  }

• example usage

  n/a

function gitbook.ConfigModifier.isDefaultPlugin (pluginName, version)

• description and source-code

  function isDefaultPlugin(pluginName, version) {
      return hasPlugin(DEFAULT_PLUGINS, pluginName, version);
  }

• example usage

  n/a

function gitbook.ConfigModifier.removePlugin (config, pluginName)

• description and source-code

  function removePlugin(config, pluginName) {
      var deps = config.getPluginDependencies();
  
      // For default plugin, we have to disable it instead of removing from the list
      if (isDefaultPlugin(pluginName)) {
          return togglePlugin(config, pluginName, false);
      }
  
      // Remove the dependency from the list
      deps = deps.filterNot(function(dep) {
          return dep.getName() === pluginName;
      });
      return config.setPluginDependencies(deps);
  }

• example usage

  n/a

function gitbook.ConfigModifier.togglePlugin (config, pluginName, state)

• description and source-code

  function togglePlugin(config, pluginName, state) {
      var deps = config.getPluginDependencies();
  
      // For default plugin, we should ensure it's listed first
      if (isDefaultPlugin(pluginName) && !hasPlugin(deps, pluginName)) {
          deps = deps.push(PluginDependency.create(pluginName));
      }
  
      deps = deps.map(function(dep) {
          if (dep.getName() === pluginName) {
              return dep.toggle(state);
          }
  
          return dep;
      });
  
      return config.setPluginDependencies(deps);
  }

• example usage

  n/a

module gitbook.FS

function gitbook.FS (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.FS.create (def)

• description and source-code

  function create(def) {
      return new FS(def);
  }

• example usage

  ...
      var book = Book.createForFS(fs);
  
      return Parse.parseReadme(book)
  
      // Setup default readme if doesn't found one
      .fail(function() {
          var readmeFile = File.createWithFilepath('README' + extension);
          var readme = Readme.create(readmeFile);
          return book.setReadme(readme);
      });
  })
  .then(Parse.parseSummary)
  
  .then(function(book) {
      var logger = book.getLogger();
  ...

function gitbook.FS.reduceScope (fs, scope)

• description and source-code

  function reduceScope(fs, scope) {
      return fs.set('root', path.join(fs.getRoot(), scope));
  }

• example usage

  ...
  */
  Book.prototype.getContentFS = function() {
  var fs = this.getFS();
  var config = this.getConfig();
  var rootFolder = config.getValue('root');
  
  if (rootFolder) {
      return FS.reduceScope(fs, rootFolder);
  }
  
  return fs;
  };
  
  /**
  Return root of the book
  ...

module gitbook.FS.prototype

function gitbook.FS.prototype.constructor (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.FS.prototype.exists (filename)

• description and source-code

  exists = function (filename) {
      var that = this;
  
      return Promise()
      .then(function() {
          filename = that.resolve(filename);
          var exists = that.get('fsExists');
  
          return exists(filename);
      });
  }

• example usage

  ...
      @return {Promise}
  */
  hasFile: function(fileName, content) {
      return Promise()
      .then(function() {
          var filePath = PathUtils.resolveInRoot(outputFolder, fileName);
  
          return fs.exists(filePath);
      });
  },
  
  /**
      Write a file to the output folder,
      It creates the required folder
  ...

function gitbook.FS.prototype.findFile (dirname, filename)

• description and source-code

  findFile = function (dirname, filename) {
      return this.listFiles(dirname)
      .then(function(files) {
          return files.find(function(file) {
              return (file.toLowerCase() == filename.toLowerCase());
          });
      });
  }

• example usage

  ...
  
      // Ordered list of extensions to test
      var exts = parsers.extensions;
  
      return Promise.some(exts, function(ext) {
  var filepath = basename + ext;
  
  return fs.findFile(basedir, filepath)
  .then(function(found) {
      if (!found || book.isContentFileIgnored(found)) {
          return undefined;
      }
  
      return fs.statFile(found);
  });
  ...

function gitbook.FS.prototype.getRoot ()

• description and source-code

  getRoot = function () {
      return this.get('root');
  }

• example usage

  ...
      deprecate.field(output, 'config.options', result, 'options',
          result.values, '"config.options" property is deprecated, use "config.get(key)" instead');
  
      deprecate.field(output, 'config.options.generator', result.values, 'generator',
          output.getGenerator(), '"options.generator" property is deprecated, use "output.name" instead&#
  x27;);
  
      deprecate.field(output, 'config.options.generator', result.values, 'output',
          output.getRoot(), '"options.output" property is deprecated, use
   "output.root()" instead');
  
      return result;
  }
  
  module.exports = encodeConfig;
  ...

function gitbook.FS.prototype.isInScope (filename)

• description and source-code

  isInScope = function (filename) {
      var rootPath = this.getRoot();
      filename = path.join(rootPath, filename);
  
      return PathUtil.isInRoot(rootPath, filename);
  }

• example usage

  ...
  */
  FS.prototype.resolve = function() {
  var rootPath = this.getRoot();
  var args = Array.prototype.slice.call(arguments);
  var filename = path.join.apply(path, [rootPath].concat(args));
  filename = path.normalize(filename);
  
  if (!this.isInScope(filename)) {
      throw error.FileOutOfScopeError({
          filename: filename,
          root: this.root
      });
  }
  
  return filename;
  ...

function gitbook.FS.prototype.listAllFiles (dirName, filterFn)

• description and source-code

  listAllFiles = function (dirName, filterFn) {
      var that = this;
      dirName = dirName || '.';
  
      return this.readDir(dirName)
      .then(function(files) {
          return Promise.reduce(files, function(out, file) {
              var isDirectory = pathIsFolder(file);
              var newDirName = path.join(dirName, file);
  
              if (filterFn && filterFn(newDirName) === false) {
                  return out;
              }
  
              if (!isDirectory) {
                  return out.push(newDirName);
              }
  
              return that.listAllFiles(newDirName, filterFn)
              .then(function(inner) {
                  return out.concat(inner);
              });
          }, Immutable.List());
      });
  }

• example usage

  ...
                  return out;
              }
  
              if (!isDirectory) {
                  return out.push(newDirName);
              }
  
              return that.listAllFiles(newDirName, filterFn)
              .then(function(inner) {
                  return out.concat(inner);
              });
          }, Immutable.List());
      });
  };
  ...

function gitbook.FS.prototype.listFiles (dirname)

• description and source-code

  listFiles = function (dirname) {
      return this.readDir(dirname)
      .then(function(files) {
          return files.filterNot(pathIsFolder);
      });
  }

• example usage

  ...
      Return the found filename
  
      @param {String} dirname
      @param {String} filename
      @return {Promise<String>}
  */
  FS.prototype.findFile = function(dirname, filename) {
      return this.listFiles(dirname)
      .then(function(files) {
          return files.find(function(file) {
              return (file.toLowerCase() == filename.toLowerCase());
          });
      });
  };
  ...

function gitbook.FS.prototype.loadAsObject (filename)

• description and source-code

  loadAsObject = function (filename) {
      var that = this;
      var fsLoadObject = this.get('fsLoadObject');
  
      return this.exists(filename)
      .then(function(exists) {
          if (!exists) {
              var err = new Error('Module doesn\'t exist');
              err.code = 'MODULE_NOT_FOUND';
  
              throw err;
          }
  
          if (fsLoadObject) {
              return fsLoadObject(that.resolve(filename));
          } else {
              return that.readAsString(filename)
              .then(function(str) {
                  return JSON.parse(str);
              });
          }
      });
  }

• example usage

  ...
      return Promise.some(CONFIG_FILES, function(filename) {
  // Is this file ignored?
  if (book.isFileIgnored(filename)) {
      return;
  }
  
  // Try loading it
  return fs.loadAsObject(filename)
  .then(function(cfg) {
      return fs.statFile(filename)
      .then(function(file) {
          return {
              file: file,
              values: cfg
          };
  ...

function gitbook.FS.prototype.read (filename)

• description and source-code

  read = function (filename) {
      var that = this;
  
      return Promise()
      .then(function() {
          filename = that.resolve(filename);
          var read = that.get('fsReadFile');
  
          return read(filename);
      });
  }

• example usage

  ...
          /**
  Read a file from the book
  
  @param {String} fileName
  @return {Promise<Buffer>}
          */
          readFile: function(fileName) {
  return bookFS.read(fileName);
          },
  
          /**
  Read a file from the book as a string
  
  @param {String} fileName
  @return {Promise<String>}
  ...

function gitbook.FS.prototype.readAsStream (filename)

• description and source-code

  readAsStream = function (filename) {
      var that = this;
      var filepath = that.resolve(filename);
      var fsReadAsStream = this.get('fsReadAsStream');
  
      if (fsReadAsStream) {
          return Promise(fsReadAsStream(filepath));
      }
  
      return this.read(filename)
      .then(function(buf) {
          var bufferStream = new stream.PassThrough();
          bufferStream.end(buf);
  
          return bufferStream;
      });
  }

• example usage

  n/a

function gitbook.FS.prototype.readAsString (filename, encoding)

• description and source-code

  readAsString = function (filename, encoding) {
      encoding = encoding || 'utf8';
  
      return this.read(filename)
      .then(function(buf) {
          return buf.toString(encoding);
      });
  }

• example usage

  ...
          /**
  Read a file from the book as a string
  
  @param {String} fileName
  @return {Promise<String>}
          */
          readFileAsString: function(fileName) {
  return bookFS.readAsString(fileName);
          },
  
          /**
  Resolve a file from the book root
  
  @param {String} fileName
  @return {String}
  ...

function gitbook.FS.prototype.readDir (dirname)

• description and source-code

  readDir = function (dirname) {
      var that = this;
  
      return Promise()
      .then(function() {
          var dirpath = that.resolve(dirname);
          var readDir = that.get('fsReadDir');
  
          return readDir(dirpath);
      })
      .then(function(files) {
          return Immutable.List(files);
      });
  }

• example usage

  ...
  List only files in a diretcory
  Directories ends with '/'
  
  @param {String} dirname
  @return {Promise<List<String>>}
  */
  FS.prototype.listFiles = function(dirname) {
  return this.readDir(dirname)
  .then(function(files) {
      return files.filterNot(pathIsFolder);
  });
  };
  
  /**
  List all files in a directory
  ...

function gitbook.FS.prototype.resolve ()

• description and source-code

  resolve = function () {
      var rootPath = this.getRoot();
      var args = Array.prototype.slice.call(arguments);
      var filename = path.join.apply(path, [rootPath].concat(args));
      filename = path.normalize(filename);
  
      if (!this.isInScope(filename)) {
          throw error.FileOutOfScopeError({
              filename: filename,
              root: this.root
          });
      }
  
      return filename;
  }

• example usage

  ...
  The `Book` class is the central point of GitBook, it centralize all access read methods. This class is defined in [book.js](https
  ://github.com/GitbookIO/gitbook/blob/master/lib/book.js).
  
  ```js
  // Read configuration from book.json
  var value = book.config.get('title', 'Default Value');
  
  // Resolve a filename to an absolute path
  var filepath = book.resolve('README.md');
  
  // Render an inline markup string
  book.renderInline('markdown', 'This is **Markdown**')
      .then(function(str) { ... })
  
  // Render a markup string (block mode)
  book.renderBlock('markdown', '* This is **Markdown**')
  ...

function gitbook.FS.prototype.statFile (filename)

• description and source-code

  statFile = function (filename) {
      var that = this;
  
      return Promise()
      .then(function() {
          var filepath = that.resolve(filename);
          var stat = that.get('fsStatFile');
  
          return stat(filepath);
      })
      .then(function(stat) {
          return File.createFromStat(filename, stat);
      });
  }

• example usage

  ...
  
          return fs.findFile(basedir, filepath)
          .then(function(found) {
              if (!found || book.isContentFileIgnored(found)) {
                  return undefined;
              }
  
              return fs.statFile(found);
          });
      });
  }
  
  module.exports = findParsableFile;
  ...

module gitbook.FS.prototype._defaultValues

function gitbook.FS.prototype._defaultValues.fsExists ()

• description and source-code

  function anonymous() {
  
  }

• example usage

  n/a

function gitbook.FS.prototype._defaultValues.fsReadDir ()

• description and source-code

  function anonymous() {
  
  }

• example usage

  n/a

function gitbook.FS.prototype._defaultValues.fsReadFile ()

• description and source-code

  function anonymous() {
  
  }

• example usage

  n/a

function gitbook.FS.prototype._defaultValues.fsStatFile ()

• description and source-code

  function anonymous() {
  
  }

• example usage

  n/a

module gitbook.File

function gitbook.File (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.File.createFromStat (filepath, stat)

• description and source-code

  function createFromStat(filepath, stat) {
      return new File({
          path: filepath,
          mtime: stat.mtime
      });
  }

• example usage

  ...
  .then(function() {
      var filepath = that.resolve(filename);
      var stat = that.get('fsStatFile');
  
      return stat(filepath);
  })
  .then(function(stat) {
      return File.createFromStat(filename, stat);
  });
  };
  
  /**
  List files/directories in a directory.
  Directories ends with '/'
  ...

function gitbook.File.createWithFilepath (filepath)

• description and source-code

  function createWithFilepath(filepath) {
      return new File({
          path: filepath
      });
  }

• example usage

  ...
      var fs = createNodeFS(rootFolder);
      var book = Book.createForFS(fs);
  
      return Parse.parseReadme(book)
  
      // Setup default readme if doesn't found one
      .fail(function() {
          var readmeFile = File.createWithFilepath('README' + extension);
          var readme = Readme.create(readmeFile);
          return book.setReadme(readme);
      });
  })
  .then(Parse.parseSummary)
  
  .then(function(book) {
  ...

module gitbook.File.prototype

function gitbook.File.prototype.constructor (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.File.prototype.exists ()

• description and source-code

  exists = function () {
      return Boolean(this.getPath());
  }

• example usage

  ...
      @return {Promise}
  */
  hasFile: function(fileName, content) {
      return Promise()
      .then(function() {
          var filePath = PathUtils.resolveInRoot(outputFolder, fileName);
  
          return fs.exists(filePath);
      });
  },
  
  /**
      Write a file to the output folder,
      It creates the required folder
  ...

function gitbook.File.prototype.getExtension ()

• description and source-code

  getExtension = function () {
      return path.extname(this.getPath()).toLowerCase();
  }

• example usage

  ...
  
  /**
  Return parser for this file
  
  @return {Parser}
  */
  File.prototype.getParser = function() {
  return parsers.getByExt(this.getExtension());
  };
  
  /**
  Create a file from stats informations
  
  @param {String} filepath
  @param {Object|fs.Stats} stat
  ...

function gitbook.File.prototype.getMTime ()

• description and source-code

  getMTime = function () {
      return this.get('mtime');
  }

• example usage

  ...
      var filePath = file.getPath();
      if (!filePath) {
          return undefined;
      }
  
      return {
          path: filePath,
          mtime: file.getMTime(),
          type: file.getType()
      };
  }
  
  module.exports = encodeFileToJson;
  ...

function gitbook.File.prototype.getParser ()

• description and source-code

  getParser = function () {
      return parsers.getByExt(this.getExtension());
  }

• example usage

  ...
      this.getGlossary()
  ];
  
  // List their extensions
  var exts = clues.map(function (clue) {
      var file = clue.getFile();
      if (file.exists()) {
          return file.getParser().getExtensions().first();
      } else {
          return null;
      }
  });
  // Adds the general default extension
  exts.push('.md');
  ...

function gitbook.File.prototype.getPath ()

• description and source-code

  getPath = function () {
      return this.get('path');
  }

• example usage

  ...
      })
      .then(Parse.parseSummary)
  
      .then(function(book) {
  var logger = book.getLogger();
  var summary = book.getSummary();
  var summaryFile = summary.getFile();
  var summaryFilename = summaryFile.getPath() || ('SUMMARY' + extension);
  
  var articles = summary.getArticlesAsList();
  
  // Write pages
  return Promise.forEach(articles, function(article) {
      var articlePath = article.getPath();
      var filePath = articlePath? path.join(rootFolder, articlePath) : null;
  ...

function gitbook.File.prototype.getType ()

• description and source-code

  getType = function () {
      var parser = this.getParser();
      if (parser) {
          return parser.getName();
      } else {
          return undefined;
      }
  }

• example usage

  ...
  var summary = book.getSummary();
  var fs = book.getContentFS();
  var file = page.getFile();
  
  // JS Page is based on the JSON output
  var result = JSONUtils.encodePage(page, summary);
  
  result.type = file.getType();
  result.path = file.getPath();
  result.rawPath = fs.resolve(result.path);
  
  deprecate.field(output, 'page.progress', result, 'progress', function() {
      return encodeProgress(output, page);
  }, '"page.progress" property is deprecated');
  ...

module gitbook.Glossary

function gitbook.Glossary (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.Glossary.addEntry (glossary, entry)

• description and source-code

  function addEntry(glossary, entry) {
      var id = entry.getID();
      var entries = glossary.getEntries();
  
      entries = entries.set(id, entry);
      return glossary.set('entries', entries);
  }

• example usage

  ...
  */
  Glossary.addEntryByName = function addEntryByName(glossary, name, description) {
  var entry = new GlossaryEntry({
      name: name,
      description: description
  });
  
  return Glossary.addEntry(glossary, entry);
  };
  
  /**
  Create a glossary from a list of entries
  
  @param {String} filename
  @param {Array|List} entries
  ...

function gitbook.Glossary.addEntryByName (glossary, name, description)

• description and source-code

  function addEntryByName(glossary, name, description) {
      var entry = new GlossaryEntry({
          name: name,
          description: description
      });
  
      return Glossary.addEntry(glossary, entry);
  }

• example usage

  n/a

function gitbook.Glossary.createFromEntries (file, entries)

• description and source-code

  function createFromEntries(file, entries) {
      entries = entries.map(function(entry) {
          if (!(entry instanceof GlossaryEntry)) {
              entry = new GlossaryEntry(entry);
          }
  
          return [entry.getID(), entry];
      });
  
      return new Glossary({
          file: file,
          entries: Immutable.OrderedMap(entries)
      });
  }

• example usage

  ...
      .spread(function(file, entries) {
          if (!file) {
              return book;
          }
  
          logger.debug.ln('glossary index file found at', file.getPath());
  
          var glossary = Glossary.createFromEntries(file, entries);
          return book.set('glossary', glossary);
      });
  }
  
  module.exports = parseGlossary;
  ...

module gitbook.Glossary.prototype

function gitbook.Glossary.prototype.constructor (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.Glossary.prototype.getEntries ()

• description and source-code

  getEntries = function () {
      return this.get('entries');
  }

• example usage

  ...
      Encode a glossary to JSON
  
      @param {Glossary}
      @return {Object}
  */
  function encodeGlossary(glossary) {
      var file = glossary.getFile();
      var entries = glossary.getEntries();
  
      return {
          file: encodeFile(file),
          entries: entries
              .map(encodeGlossaryEntry).toJS()
      };
  }
  ...

function gitbook.Glossary.prototype.getEntry (name)

• description and source-code

  getEntry = function (name) {
      var entries = this.getEntries();
      var id = GlossaryEntry.nameToID(name);
  
      return entries.get(id);
  }

• example usage

  n/a

function gitbook.Glossary.prototype.getFile ()

• description and source-code

  getFile = function () {
      return this.get('file');
  }

• example usage

  ...
  });
      })
      .then(Parse.parseSummary)
  
      .then(function(book) {
  var logger = book.getLogger();
  var summary = book.getSummary();
  var summaryFile = summary.getFile();
  var summaryFilename = summaryFile.getPath() || ('SUMMARY' + extension);
  
  var articles = summary.getArticlesAsList();
  
  // Write pages
  return Promise.forEach(articles, function(article) {
      var articlePath = article.getPath();
  ...

function gitbook.Glossary.prototype.toText (parser)

• description and source-code

  toText = function (parser) {
      var file = this.getFile();
      var entries = this.getEntries();
  
      parser = parser? parsers.getByExt(parser) : file.getParser();
  
      if (!parser) {
          throw error.FileNotParsableError({
              filename: file.getPath()
          });
      }
  
      return parser.renderGlossary(entries.toJS());
  }

• example usage

  ...
  // Write summary
  .then(function() {
      var filePath = path.join(rootFolder, summaryFilename);
  
      return fs.ensureFile(filePath)
      .then(function() {
          logger.info.ln('create ' + path.basename(filePath));
          return fs.writeFile(filePath, summary.toText(extension));
      });
  })
  
  // Log end
  .then(function() {
      logger.info.ln('initialization is finished');
  });
  ...

module gitbook.Output

function gitbook.Output.generate (generator, book, options)

• description and source-code

  function generateBook(generator, book, options) {
      options = generator.Options(options);
      var state = generator.State? generator.State({}) : Immutable.Map();
      var start = Date.now();
  
      return Promise(
          new Output({
              book: book,
              options: options,
              state: state,
              generator: generator.name
          })
      )
  
      // Cleanup output folder
      .then(function(output) {
          var logger = output.getLogger();
          var rootFolder = output.getRoot();
  
          logger.debug.ln('cleanup folder "' + rootFolder + '"');
          return fs.ensureFolder(rootFolder)
              .thenResolve(output);
      })
  
      .then(processOutput.bind(null, generator))
  
      // Log duration and end message
      .then(function(output) {
          var logger = output.getLogger();
          var end = Date.now();
          var duration = (end - start)/1000;
  
          logger.info.ok('generation finished with success in ' + duration.toFixed(1) + 's !');
  
          return output;
      });
  }

• example usage

  ...
  
  var book = getBook(args, kwargs);
  var logger = book.getLogger();
  var Generator = Output.getGenerator('ebook');
  
  return Parse.parseBook(book)
  .then(function(resultBook) {
      return Output.generate(Generator, resultBook, {
          root: outputFolder,
          format: format
      });
  })
  
  // Extract ebook file
  .then(function(output) {
  ...

function gitbook.Output.getGenerator (name)

• description and source-code

  function getGenerator(name) {
      return generators.find(function(generator) {
          return generator.name == name;
      });
  }

• example usage

  ...
          }
      };
  
      deprecate.field(output, 'config.options', result, 'options',
          result.values, '"config.options" property is deprecated, use "config.get(key)" instead');
  
      deprecate.field(output, 'config.options.generator', result.values, 'generator',
          output.getGenerator(), '"options.generator" property is deprecated
  , use "output.name" instead');
  
      deprecate.field(output, 'config.options.generator', result.values, 'output',
          output.getRoot(), '"options.output" property is deprecated, use "output.root()" instead');
  
      return result;
  }
  ...

module gitbook.Page

function gitbook.Page (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.Page.createForFile (file)

• description and source-code

  createForFile = function (file) {
      return new Page({
          file: file
      });
  }

• example usage

  ...
  */
  function parseFilePage(book, filePath) {
  var fs = book.getContentFS();
  
  return fs.statFile(filePath)
  .then(
      function(file) {
          var page = Page.createForFile(file);
          return parsePage(book, page);
      },
      function(err) {
          // file doesn't exist
          return null;
      }
  )
  ...

module gitbook.Page.prototype

function gitbook.Page.prototype.constructor (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.Page.prototype.getAttributes ()

• description and source-code

  getAttributes = function () {
      return this.get('attributes');
  }

• example usage

  ...
  
  @param {Page} page
  @param {Summary} summary
  @return {Object}
  */
  function encodePage(page, summary) {
  var file = page.getFile();
  var attributes = page.getAttributes();
  var article = summary.getByPath(file.getPath());
  
  var result = attributes.toJS();
  
  if (article) {
      result.title = article.getTitle();
      result.level = article.getLevel();
  ...

function gitbook.Page.prototype.getContent ()

• description and source-code

  getContent = function () {
      return this.get('content');
  }

• example usage

  ...
  
  @param {Output} output
  @param {Page} page: page instance to edit
  @param {Object} result: result from API
  @return {Page}
  */
  function decodePage(output, page, result) {
  var originalContent = page.getContent();
  
  // No returned value
  // Existing content will be used
  if (!result) {
      return page;
  }
  ...

function gitbook.Page.prototype.getDir ()

• description and source-code

  getDir = function () {
      return this.get('dir');
  }

• example usage

  ...
          var prevArticle = summary.getPrevArticle(article);
          if (prevArticle) {
              result.previous = encodeSummaryArticle(prevArticle);
          }
      }
  
      result.content = page.getContent();
      result.dir = page.getDir();
  
      return result;
  }
  
  module.exports = encodePage;
  ...

function gitbook.Page.prototype.getFile ()

• description and source-code

  getFile = function () {
      return this.get('file');
  }

• example usage

  ...
  });
      })
      .then(Parse.parseSummary)
  
      .then(function(book) {
  var logger = book.getLogger();
  var summary = book.getSummary();
  var summaryFile = summary.getFile();
  var summaryFilename = summaryFile.getPath() || ('SUMMARY' + extension);
  
  var articles = summary.getArticlesAsList();
  
  // Write pages
  return Promise.forEach(articles, function(article) {
      var articlePath = article.getPath();
  ...

function gitbook.Page.prototype.getPath ()

• description and source-code

  getPath = function () {
      return this.getFile().getPath();
  }

• example usage

  ...
      })
      .then(Parse.parseSummary)
  
      .then(function(book) {
  var logger = book.getLogger();
  var summary = book.getSummary();
  var summaryFile = summary.getFile();
  var summaryFilename = summaryFile.getPath() || ('SUMMARY' + extension);
  
  var articles = summary.getArticlesAsList();
  
  // Write pages
  return Promise.forEach(articles, function(article) {
      var articlePath = article.getPath();
      var filePath = articlePath? path.join(rootFolder, articlePath) : null;
  ...

function gitbook.Page.prototype.toText ()

• description and source-code

  toText = function () {
      var attrs = this.getAttributes();
      var content = this.getContent();
  
      if (attrs.size === 0) {
          return content;
      }
  
      var frontMatter = '---\n' + yaml.safeDump(attrs.toJS(), { skipInvalid: true }) + '---\n\n';
      return (frontMatter + content);
  }

• example usage

  ...
  // Write summary
  .then(function() {
      var filePath = path.join(rootFolder, summaryFilename);
  
      return fs.ensureFile(filePath)
      .then(function() {
          logger.info.ln('create ' + path.basename(filePath));
          return fs.writeFile(filePath, summary.toText(extension));
      });
  })
  
  // Log end
  .then(function() {
      logger.info.ln('initialization is finished');
  });
  ...

module gitbook.Parse

function gitbook.Parse.listAssets (book, pages)

• description and source-code

  function listAssets(book, pages) {
      var fs = book.getContentFS();
  
      var summary = book.getSummary();
      var summaryFile = summary.getFile().getPath();
  
      var glossary = book.getGlossary();
      var glossaryFile = glossary.getFile().getPath();
  
      var langs = book.getLanguages();
      var langsFile = langs.getFile().getPath();
  
      var config = book.getConfig();
      var configFile = config.getFile().getPath();
  
      function filterFile(file) {
          return !(
              file === summaryFile ||
              file === glossaryFile ||
              file === langsFile ||
              file === configFile ||
              book.isContentFileIgnored(file) ||
              pages.has(file)
          );
      }
  
      return timing.measure(
          'parse.listAssets',
          fs.listAllFiles('.', filterFile)
      );
  }

• example usage

  ...
      @return {Promise<Output>}
  */
  function prepareAssets(output) {
      var book = output.getBook();
      var pages = output.getPages();
      var logger = output.getLogger();
  
      return Parse.listAssets(book, pages)
      .then(function(assets) {
          logger.info.ln('found', assets.size, 'asset files');
  
          return output.set('assets', assets);
      });
  }
  ...

function gitbook.Parse.lookupStructureFile (book, type)

• description and source-code

  function lookupStructureFile(book, type) {
      var config = book.getConfig();
  
      var fileToSearch = config.getValue(['structure', type]);
  
      return findParsableFile(book, fileToSearch);
  }

• example usage

  n/a

function gitbook.Parse.parseBook (book)

• description and source-code

  function parseBook(book) {
      return timing.measure(
          'parse.book',
          Promise(book)
          .then(parseIgnore)
          .then(parseConfig)
          .then(parseLanguages)
          .then(function(resultBook) {
              if (resultBook.isMultilingual()) {
                  return parseMultilingualBook(resultBook);
              } else {
                  return parseBookContent(resultBook);
              }
          })
      );
  }

• example usage

  ...
  // Create temporary directory
  var outputFolder = tmp.dirSync().name;
  
  var book = getBook(args, kwargs);
  var logger = book.getLogger();
  var Generator = Output.getGenerator('ebook');
  
  return Parse.parseBook(book)
  .then(function(resultBook) {
      return Output.generate(Generator, resultBook, {
          root: outputFolder,
          format: format
      });
  })
  ...

function gitbook.Parse.parseConfig (book)

• description and source-code

  function parseConfig(book) {
      var fs = book.getFS();
      var config = book.getConfig();
  
      return Promise.some(CONFIG_FILES, function(filename) {
          // Is this file ignored?
          if (book.isFileIgnored(filename)) {
              return;
          }
  
          // Try loading it
          return fs.loadAsObject(filename)
          .then(function(cfg) {
              return fs.statFile(filename)
              .then(function(file) {
                  return {
                      file: file,
                      values: cfg
                  };
              });
          })
          .fail(function(err) {
              if (err.code != 'MODULE_NOT_FOUND') throw(err);
              else return Promise(false);
          });
      })
  
      .then(function(result) {
          var values = result? result.values : {};
          values = validateConfig(values);
  
          // Set the file
          if (result.file) {
              config = config.setFile(result.file);
          }
  
          // Merge with old values
          config = config.mergeValues(values);
  
          return book.setConfig(config);
      });
  }

• example usage

  ...
      description: 'install all plugins dependencies',
      options: [
          options.log
      ],
      exec: function(args, kwargs) {
          var book = getBook(args, kwargs);
  
          return Parse.parseConfig(book)
          .then(function(resultBook) {
              return Plugins.installPlugins(resultBook);
          });
      }
  };
  ...

function gitbook.Parse.parseGlossary (book)

• description and source-code

  function parseGlossary(book) {
      var logger = book.getLogger();
  
      return parseStructureFile(book, 'glossary')
      .spread(function(file, entries) {
          if (!file) {
              return book;
          }
  
          logger.debug.ln('glossary index file found at', file.getPath());
  
          var glossary = Glossary.createFromEntries(file, entries);
          return book.set('glossary', glossary);
      });
  }

• example usage

  ...
  }
  
  return fs.readAsString(filepath)
  .then(function(content) {
      if (type === 'readme') {
          return parser.parseReadme(content);
      } else if (type === 'glossary') {
          return parser.parseGlossary(content);
      } else if (type === 'summary') {
          return parser.parseSummary(content);
      } else if (type === 'langs') {
          return parser.parseLanguages(content);
      } else {
          throw new Error('Parsing invalid type "' + type + '"');
      }
  ...

function gitbook.Parse.parseIgnore (book)

• description and source-code

  function parseIgnore(book) {
      if (book.isLanguageBook()) {
          return Promise.reject(new Error('Ignore files could be parsed for language books'));
      }
  
      var fs = book.getFS();
      var ignore = book.getIgnore();
  
      ignore = ignore.add(DEFAULT_IGNORES);
  
      return Promise.serie(IGNORE_FILES, function(filename) {
          return fs.readAsString(filename)
          .then(function(content) {
              ignore = ignore.add(content.toString().split(/\r?\n/));
          }, function(err) {
              return Promise();
          });
      })
  
      .then(function() {
          return book.setIgnore(ignore);
      });
  }

• example usage

  n/a

function gitbook.Parse.parseLanguages (book)

• description and source-code

  function parseLanguages(book) {
      var logger = book.getLogger();
  
      return parseStructureFile(book, 'langs')
      .spread(function(file, result) {
          if (!file) {
              return book;
          }
  
          var languages = Languages.createFromList(file, result);
  
          logger.debug.ln('languages index file found at', file.getPath());
          logger.info.ln('parsing multilingual book, with', languages.getList().size, 'languages');
  
          return book.set('languages', languages);
      });
  }

• example usage

  ...
      if (type === 'readme') {
          return parser.parseReadme(content);
      } else if (type === 'glossary') {
          return parser.parseGlossary(content);
      } else if (type === 'summary') {
          return parser.parseSummary(content);
      } else if (type === 'langs') {
          return parser.parseLanguages(content);
      } else {
          throw new Error('Parsing invalid type "' + type + '"');
      }
  })
  .then(function(result) {
      return [
          file,
  ...

function gitbook.Parse.parsePage (book, page)

• description and source-code

  function parsePage(book, page) {
      var fs = book.getContentFS();
      var file = page.getFile();
  
      return fs.readAsString(file.getPath())
      .then(function(content) {
          return parsePageFromString(page, content);
      });
  }

• example usage

  ...
  @param {String} type
  @param {String} text
  @return {Promise<String>}
          */
          renderBlock: function(type, text) {
  var parser = parsers.get(type);
  
  return parser.parsePage(text)
      .get('content');
          },
  
          /**
  Render an inline text (markdown/asciidoc)
  
  @param {String} type
  ...

function gitbook.Parse.parsePageFromString (page, content)

• description and source-code

  function parsePageFromString(page, content) {
      // Parse page YAML
      var parsed = fm(content);
  
      return page.merge({
          content:    parsed.body,
          attributes: Immutable.fromJS(parsed.attributes),
          dir:        direction(parsed.body)
      });
  }

• example usage

  n/a

function gitbook.Parse.parsePagesList (book)

• description and source-code

  function parsePagesList(book) {
      var summary = book.getSummary();
      var glossary = book.getGlossary();
      var map = Immutable.OrderedMap();
  
      // Parse pages from summary
      return timing.measure(
          'parse.listPages',
          walkSummary(summary, function(article) {
              if (!article.isPage()) return;
  
              var filepath = article.getPath();
  
              // Is the page ignored?
              if (book.isContentFileIgnored(filepath)) return;
  
              return parseFilePage(book, filepath)
              .then(function(page) {
                  // file doesn't exist
                  if (!page) {
                      return;
                  }
  
                  map = map.set(filepath, page);
              });
          })
      )
  
      // Parse glossary
      .then(function() {
          var file = glossary.getFile();
  
          if (!file.exists()) {
              return;
          }
  
          return parseFilePage(book, file.getPath())
          .then(function(page) {
              // file doesn't exist
              if (!page) {
                  return;
              }
  
              map = map.set(file.getPath(), page);
          });
      })
  
      .then(function() {
          return map;
      });
  }

• example usage

  ...
      var book = output.getBook();
      var logger = book.getLogger();
  
      if (book.isMultilingual()) {
          return Promise(output);
      }
  
      return Parse.parsePagesList(book)
      .then(function(pages) {
          logger.info.ln('found', pages.size, 'pages');
  
          return output.set('pages', pages);
      });
  }
  ...

function gitbook.Parse.parseReadme (book)

• description and source-code

  function parseReadme(book) {
      var logger = book.getLogger();
  
      return parseStructureFile(book, 'readme')
      .spread(function(file, result) {
          if (!file) {
              throw new error.FileNotFoundError({ filename: 'README' });
          }
  
          logger.debug.ln('readme found at', file.getPath());
  
          var readme = Readme.create(file, result);
          return book.set('readme', readme);
      });
  }

• example usage

  ...
      return fs.mkdirp(rootFolder)
  
      // Parse the summary and readme
      .then(function() {
  var fs = createNodeFS(rootFolder);
  var book = Book.createForFS(fs);
  
  return Parse.parseReadme(book)
  
  // Setup default readme if doesn't found one
  .fail(function() {
      var readmeFile = File.createWithFilepath('README' + extension);
      var readme = Readme.create(readmeFile);
      return book.setReadme(readme);
  });
  ...

function gitbook.Parse.parseSummary (book)

• description and source-code

  function parseSummary(book) {
      var readme = book.getReadme();
      var logger = book.getLogger();
      var readmeFile = readme.getFile();
  
      return parseStructureFile(book, 'summary')
      .spread(function(file, result) {
          var summary;
  
          if (!file) {
              logger.warn.ln('no summary file in this book');
              summary = Summary();
          } else {
              logger.debug.ln('summary file found at', file.getPath());
              summary = Summary.createFromParts(file, result.parts);
          }
  
          // Insert readme as first entry if not in SUMMARY.md
          var readmeArticle = summary.getByPath(readmeFile.getPath());
  
          if (readmeFile.exists() && !readmeArticle) {
              summary = SummaryModifier.unshiftArticle(summary, {
                  title: 'Introduction',
                  ref: readmeFile.getPath()
              });
          }
  
          // Set new summary
          return book.setSummary(summary);
      });
  }

• example usage

  ...
  return fs.readAsString(filepath)
  .then(function(content) {
      if (type === 'readme') {
          return parser.parseReadme(content);
      } else if (type === 'glossary') {
          return parser.parseGlossary(content);
      } else if (type === 'summary') {
          return parser.parseSummary(content);
      } else if (type === 'langs') {
          return parser.parseLanguages(content);
      } else {
          throw new Error('Parsing invalid type "' + type + '"');
      }
  })
  .then(function(result) {
  ...

module gitbook.PluginDependency

function gitbook.PluginDependency (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.PluginDependency.create (name, version, enabled)

• description and source-code

  create = function (name, version, enabled) {
      if (is.undefined(enabled)) {
          enabled = true;
      }
  
      return new PluginDependency({
          name: name,
          version: version || DEFAULT_VERSION,
          enabled: Boolean(enabled)
      });
  }

• example usage

  ...
      var book = Book.createForFS(fs);
  
      return Parse.parseReadme(book)
  
      // Setup default readme if doesn't found one
      .fail(function() {
          var readmeFile = File.createWithFilepath('README' + extension);
          var readme = Readme.create(readmeFile);
          return book.setReadme(readme);
      });
  })
  .then(Parse.parseSummary)
  
  .then(function(book) {
      var logger = book.getLogger();
  ...

function gitbook.PluginDependency.createFromString (s)

• description and source-code

  createFromString = function (s) {
      var parts = s.split('@');
      var name = parts[0];
      var version = parts.slice(1).join('@');
      var enabled = true;
  
      if (name[0] === '-') {
          enabled = false;
          name = name.slice(1);
      }
  
      return new PluginDependency({
          name: name,
          version: version || DEFAULT_VERSION,
          enabled: enabled
      });
  }

• example usage

  ...
   * @param {Array}
   * @return {List<PluginDependency>}
   */
  PluginDependency.listFromArray = function(arr) {
  return Immutable.List(arr)
      .map(function(entry) {
          if (is.string(entry)) {
              return PluginDependency.createFromString(entry);
          } else {
              return PluginDependency({
                  name: entry.get('name'),
                  version: entry.get('version')
              });
          }
      })
  ...

function gitbook.PluginDependency.listFromArray (arr)

• description and source-code

  listFromArray = function (arr) {
      return Immutable.List(arr)
          .map(function(entry) {
              if (is.string(entry)) {
                  return PluginDependency.createFromString(entry);
              } else {
                  return PluginDependency({
                      name: entry.get('name'),
                      version: entry.get('version')
                  });
              }
          })
          .filter(function(dep) {
              return Boolean(dep.getName());
          });
  }

• example usage

  ...
  */
  Config.prototype.getPluginDependencies = function() {
     var plugins = this.getValue('plugins');
  
     if (is.string(plugins)) {
         return PluginDependency.listFromString(plugins);
     } else {
         return PluginDependency.listFromArray(plugins);
     }
  };
  
  /**
  * Return a plugin dependency by its name
  * @param {String} name
  * @return {PluginDependency}
  ...

function gitbook.PluginDependency.listFromString (s)

• description and source-code

  listFromString = function (s) {
      var parts = s.split(',');
      return PluginDependency.listFromArray(parts);
  }

• example usage

  ...
  * Return a list of plugin dependencies
  * @return {List<PluginDependency>}
  */
  Config.prototype.getPluginDependencies = function() {
     var plugins = this.getValue('plugins');
  
     if (is.string(plugins)) {
         return PluginDependency.listFromString(plugins);
     } else {
         return PluginDependency.listFromArray(plugins);
     }
  };
  
  /**
  * Return a plugin dependency by its name
  ...

function gitbook.PluginDependency.listToArray (list)

• description and source-code

  listToArray = function (list) {
      return list
          .map(function(dep) {
              var result = '';
  
              if (!dep.isEnabled()) {
                  result += '-';
              }
  
              result += dep.getName();
              if (dep.getVersion() !== DEFAULT_VERSION) {
                  result += '@' + dep.getVersion();
              }
  
              return result;
          })
          .toJS();
  }

• example usage

  ...
  
  /**
  * Update the list of plugins dependencies
  * @param {List<PluginDependency>}
  * @return {Config}
  */
  Config.prototype.setPluginDependencies = function(deps) {
     var plugins = PluginDependency.listToArray(deps);
  
     return this.setValue('plugins', plugins);
  };
  
  
  /**
  * Update values for an existing configuration
  ...

function gitbook.PluginDependency.nameToNpmID (s)

• description and source-code

  nameToNpmID = function (s) {
      return PREFIX + s;
  }

• example usage

  ...
  
  /**
  * Create a PluginDependency from a dependency of gitbook
  * @param {String} pluginName
  * @return {PluginDependency}
  */
  function createFromDependency(pluginName) {
     var npmID = PluginDependency.nameToNpmID(pluginName);
     var version = pkg.dependencies[npmID];
  
     return PluginDependency.create(pluginName, version);
  }
  
  /*
  * List of default plugins for all books,
  ...

module gitbook.PluginDependency.prototype

function gitbook.PluginDependency.prototype.constructor (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.PluginDependency.prototype.getName ()

• description and source-code

  getName = function () {
      return this.get('name');
  }

• example usage

  ...
  * Return a specific parser by its name
  *
  * @param {String} name
  * @return {Parser|undefined}
  */
  function getParser(name) {
     return parsers.find(function(parser) {
         return parser.getName() === name;
     });
  }
  
  /**
  * Return a specific parser according to an extension
  *
  * @param {String} ext
  ...

function gitbook.PluginDependency.prototype.getNpmID ()

• description and source-code

  getNpmID = function () {
      return PluginDependency.nameToNpmID(this.getName());
  }

• example usage

  ...
      .then(function(version) {
  if (!version) {
      throw new Error('Found no satisfactory version for plugin "' + name + '" with requirement "'
  ; + requirement + '"');
  }
  
  logger.info.ln('install plugin "' + name +'" (' + requirement + ') from NPM with version'
  ;, version);
  return Promise.nfcall(npmi, {
      'name': plugin.getNpmID(),
      'version': version,
      'path': installFolder,
      'npmLoad': {
          'loglevel': 'silent',
          'loaded': true,
          'prefix': installFolder
      }
  ...

function gitbook.PluginDependency.prototype.getVersion ()

• description and source-code

  getVersion = function () {
      return this.get('version');
  }

• example usage

  ...
  };
  
  /**
  * Is the plugin using a git dependency
  * @return {Boolean}
  */
  PluginDependency.prototype.isGitDependency = function() {
     return !semver.validRange(this.getVersion());
  };
  
  /**
  * Create a plugin with a name and a plugin
  * @param {String}
  * @return {Plugin|undefined}
  */
  ...

function gitbook.PluginDependency.prototype.isEnabled ()

• description and source-code

  isEnabled = function () {
      return this.get('enabled');
  }

• example usage

  ...
  /**
  * Toggle this plugin state
  * @param  {Boolean}
  * @return {PluginDependency}
  */
  PluginDependency.prototype.toggle = function(state) {
     if (is.undef(state)) {
         state = !this.isEnabled();
     }
  
     return this.set('enabled', state);
  };
  
  /**
  * Return NPM ID for the dependency
  ...

function gitbook.PluginDependency.prototype.isGitDependency ()

• description and source-code

  isGitDependency = function () {
      return !semver.validRange(this.getVersion());
  }

• example usage

  ...
  @param {PluginDependency} plugin
  @return {Promise<String>}
  */
  function resolveVersion(plugin) {
  var npmId = Plugin.nameToNpmID(plugin.getName());
  var requiredVersion = plugin.getVersion();
  
  if (plugin.isGitDependency()) {
      return Promise.resolve(requiredVersion);
  }
  
  return initNPM()
  .then(function() {
      return Promise.nfcall(npm.commands.view, [npmId + '@' + requiredVersion, 'engines'], true);
  })
  ...

function gitbook.PluginDependency.prototype.toggle (state)

• description and source-code

  toggle = function (state) {
      if (is.undef(state)) {
          state = !this.isEnabled();
      }
  
      return this.set('enabled', state);
  }

• example usage

  ...
      // For default plugin, we should ensure it's listed first
      if (isDefaultPlugin(pluginName) && !hasPlugin(deps, pluginName)) {
          deps = deps.push(PluginDependency.create(pluginName));
      }
  
      deps = deps.map(function(dep) {
          if (dep.getName() === pluginName) {
              return dep.toggle(state);
          }
  
          return dep;
      });
  
      return config.setPluginDependencies(deps);
  }
  ...

module gitbook.Summary

function gitbook.Summary (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.Summary.createFromParts (file, parts)

• description and source-code

  function createFromParts(file, parts) {
      parts = parts.map(function(part, i) {
          if (part instanceof SummaryPart) {
              return part;
          }
  
          return SummaryPart.create(part, i + 1);
      });
  
      return new Summary({
          file: file,
          parts: new Immutable.List(parts)
      });
  }

• example usage

  ...
  var summary;
  
  if (!file) {
      logger.warn.ln('no summary file in this book');
      summary = Summary();
  } else {
      logger.debug.ln('summary file found at', file.getPath());
      summary = Summary.createFromParts(file, result.parts);
  }
  
  // Insert readme as first entry if not in SUMMARY.md
  var readmeArticle = summary.getByPath(readmeFile.getPath());
  
  if (readmeFile.exists() && !readmeArticle) {
      summary = SummaryModifier.unshiftArticle(summary, {
  ...

module gitbook.Summary.prototype

function gitbook.Summary.prototype.constructor (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.Summary.prototype.getArticle (iter, partIter)

• description and source-code

  getArticle = function (iter, partIter) {
      var parts = this.getParts();
  
      return parts.reduce(function(result, part) {
          if (result) return result;
  
          if (partIter && partIter(part)) return part;
          return SummaryArticle.findArticle(part, iter);
      }, null);
  }

• example usage

  ...
      var result = {
  /**
      Iterate over the summary, it stops when the "iter" returns false
  
      @param {Function} iter
  */
  walk: function (iter) {
      summary.getArticle(function(article) {
          var jsonArticle = encodeSummaryArticle(article, false);
  
          return iter(jsonArticle);
      });
  },
  
  /**
  ...

function gitbook.Summary.prototype.getArticlesAsList ()

• description and source-code

  getArticlesAsList = function () {
      var accu = [];
  
      this.getArticle(function(article) {
          accu.push(article);
      });
  
      return Immutable.List(accu);
  }

• example usage

  ...
  
      .then(function(book) {
  var logger = book.getLogger();
  var summary = book.getSummary();
  var summaryFile = summary.getFile();
  var summaryFilename = summaryFile.getPath() || ('SUMMARY' + extension);
  
  var articles = summary.getArticlesAsList();
  
  // Write pages
  return Promise.forEach(articles, function(article) {
      var articlePath = article.getPath();
      var filePath = articlePath? path.join(rootFolder, articlePath) : null;
      if (!filePath) {
          return;
  ...

function gitbook.Summary.prototype.getByLevel (level)

• description and source-code

  getByLevel = function (level) {
      function iterByLevel(article) {
          return (article.getLevel() === level);
      }
  
      return this.getArticle(iterByLevel, iterByLevel);
  }

• example usage

  ...
          /**
  Get an article by its level
  
  @param {String} level
  @return {Object}
          */
          getArticleByLevel: function(level) {
  var article = summary.getByLevel(level);
  return (article? encodeSummaryArticle(article) : undefined);
          },
  
          /**
  Get an article by its path
  
  @param {String} level
  ...

function gitbook.Summary.prototype.getByPath (filePath)

• description and source-code

  getByPath = function (filePath) {
      return this.getArticle(function(article) {
          var articlePath = article.getPath();
  
          return (
              articlePath &&
              LocationUtils.areIdenticalPaths(articlePath, filePath)
          );
      });
  }

• example usage

  ...
          /**
              Get an article by its path
  
              @param {String} level
              @return {Object}
          */
          getArticleByPath: function(level) {
              var article = summary.getByPath(level);
              return (article? encodeSummaryArticle(article) : undefined);
          }
      };
  
      return result;
  }
  ...

function gitbook.Summary.prototype.getFile ()

• description and source-code

  getFile = function () {
      return this.get('file');
  }

• example usage

  ...
  });
      })
      .then(Parse.parseSummary)
  
      .then(function(book) {
  var logger = book.getLogger();
  var summary = book.getSummary();
  var summaryFile = summary.getFile();
  var summaryFilename = summaryFile.getPath() || ('SUMMARY' + extension);
  
  var articles = summary.getArticlesAsList();
  
  // Write pages
  return Promise.forEach(articles, function(article) {
      var articlePath = article.getPath();
  ...

function gitbook.Summary.prototype.getFirstArticle ()

• description and source-code

  getFirstArticle = function () {
      return this.getArticle(function(article) {
          return true;
      });
  }

• example usage

  n/a

function gitbook.Summary.prototype.getNextArticle (current)

• description and source-code

  getNextArticle = function (current) {
      var level = is.string(current)? current : current.getLevel();
      var wasPrev = false;
  
      return this.getArticle(function(article) {
          if (wasPrev) return true;
  
          wasPrev = article.getLevel() == level;
          return false;
      });
  }

• example usage

  ...
      var result = attributes.toJS();
  
      if (article) {
  result.title = article.getTitle();
  result.level = article.getLevel();
  result.depth = article.getDepth();
  
  var nextArticle = summary.getNextArticle(article);
  if (nextArticle) {
      result.next = encodeSummaryArticle(nextArticle);
  }
  
  var prevArticle = summary.getPrevArticle(article);
  if (prevArticle) {
      result.previous = encodeSummaryArticle(prevArticle);
  ...

function gitbook.Summary.prototype.getParent (level)

• description and source-code

  getParent = function (level) {
      // Coerce to level
      level = is.string(level)? level : level.getLevel();
  
      // Get parent level
      var parentLevel = getParentLevel(level);
      if (!parentLevel) {
          return null;
      }
  
      // Get parent of the position
      var parentArticle = this.getByLevel(parentLevel);
      return parentArticle || null;
  }

• example usage

  ...
          var plugins = requirements.reduce(function(result, dep) {
  var name = dep.getName();
  var installed = installedMap.get(name);
  
  if (installed) {
      var deps = installedMap
          .filter(function(plugin) {
              return plugin.getParent() === name;
          })
          .toArray();
  
      result = result.concat(deps);
      result.push(installed);
  } else {
      missing.push(name);
  ...

function gitbook.Summary.prototype.getPart (i)

• description and source-code

  getPart = function (i) {
      var parts = this.getParts();
      return parts.get(i);
  }

• example usage

  n/a

function gitbook.Summary.prototype.getParts ()

• description and source-code

  getParts = function () {
      return this.get('parts');
  }

• example usage

  ...
      Encode a summary to JSON
  
      @param {Summary}
      @return {Object}
  */
  function encodeSummary(summary) {
      var file = summary.getFile();
      var parts = summary.getParts();
  
      return {
          file: encodeFile(file),
          parts: parts.map(encodeSummaryPart).toJS()
      };
  }
  ...

function gitbook.Summary.prototype.getPrevArticle (current)

• description and source-code

  getPrevArticle = function (current) {
      var level = is.string(current)? current : current.getLevel();
      var prev = undefined;
  
      this.getArticle(function(article) {
          if (article.getLevel() == level) {
              return true;
          }
  
          prev = article;
          return false;
      });
  
      return prev;
  }

• example usage

  ...
      result.depth = article.getDepth();
  
      var nextArticle = summary.getNextArticle(article);
      if (nextArticle) {
          result.next = encodeSummaryArticle(nextArticle);
      }
  
      var prevArticle = summary.getPrevArticle(article);
      if (prevArticle) {
          result.previous = encodeSummaryArticle(prevArticle);
      }
  }
  
  result.content = page.getContent();
  result.dir = page.getDir();
  ...

function gitbook.Summary.prototype.toText (parseExt)

• description and source-code

  toText = function (parseExt) {
      var file = this.getFile();
      var parts = this.getParts();
  
      var parser = parseExt? parsers.getByExt(parseExt) : file.getParser();
  
      if (!parser) {
          throw error.FileNotParsableError({
              filename: file.getPath()
          });
      }
  
      return parser.renderSummary({
          parts: parts.toJS()
      });
  }

• example usage

  ...
  // Write summary
  .then(function() {
      var filePath = path.join(rootFolder, summaryFilename);
  
      return fs.ensureFile(filePath)
      .then(function() {
          logger.info.ln('create ' + path.basename(filePath));
          return fs.writeFile(filePath, summary.toText(extension));
      });
  })
  
  // Log end
  .then(function() {
      logger.info.ln('initialization is finished');
  });
  ...

module gitbook.SummaryModifier

function gitbook.SummaryModifier.editArticleRef (summary, level, newRef)

• description and source-code

  function editArticleRef(summary, level, newRef) {
      return mergeAtLevel(summary, level, {
          ref: newRef
      });
  }

• example usage

  n/a

function gitbook.SummaryModifier.editArticleTitle (summary, level, newTitle)

• description and source-code

  function editArticleTitle(summary, level, newTitle) {
      return mergeAtLevel(summary, level, {
          title: newTitle
      });
  }

• example usage

  n/a

function gitbook.SummaryModifier.editPartTitle (summary, index, newTitle)

• description and source-code

  function editPartTitle(summary, index, newTitle) {
      var parts = summary.getParts();
  
      var part = parts.get(index);
      if (!part) {
          return summary;
      }
  
      part = part.set('title', newTitle);
      parts = parts.set(index, part);
  
      return summary.set('parts', parts);
  }

• example usage

  n/a

function gitbook.SummaryModifier.insertArticle (summary, article, level)

• description and source-code

  function insertArticle(summary, article, level) {
      article = SummaryArticle(article);
      level = is.string(level)? level : level.getLevel();
  
      var parent = summary.getParent(level);
      if (!parent) {
          return summary;
      }
  
      // Find the index to insert at
      var articles = parent.getArticles();
      var index = getLeafIndex(level);
  
      // Insert the article at the right index
      articles = articles.insert(index, article);
  
      // Reindex the level from here
      parent = parent.set('articles', articles);
      parent = indexArticleLevels(parent);
  
      return mergeAtLevel(summary, parent.getLevel(), parent);
  }

• example usage

  n/a

function gitbook.SummaryModifier.insertPart (summary, part, index)

• description and source-code

  function insertPart(summary, part, index) {
      part = SummaryPart(part);
  
      var parts = summary.getParts().insert(index, part);
      return indexLevels(summary.set('parts', parts));
  }

• example usage

  n/a

function gitbook.SummaryModifier.moveArticle (summary, origin, target)

• description and source-code

  function moveArticle(summary, origin, target) {
      // Coerce to level
      var originLevel = is.string(origin)? origin : origin.getLevel();
      var targetLevel = is.string(target)? target : target.getLevel();
      var article = summary.getByLevel(originLevel);
  
      // Remove first
      var removed = removeArticle(summary, originLevel);
      return insertArticle(removed, article, targetLevel);
  }

• example usage

  n/a

function gitbook.SummaryModifier.moveArticleAfter (summary, origin, afterTarget)

• description and source-code

  function moveArticleAfter(summary, origin, afterTarget) {
      // Coerce to level
      var originLevel = is.string(origin)? origin : origin.getLevel();
      var afterTargetLevel = is.string(afterTarget)? afterTarget : afterTarget.getLevel();
      var article = summary.getByLevel(originLevel);
  
      var targetLevel = increment(afterTargetLevel);
  
      if (targetLevel < origin) {
          // Remove first
          var removed = removeArticle(summary, originLevel);
          // Insert then
          return insertArticle(removed, article, targetLevel);
      } else {
          // Insert right after first
          var inserted = insertArticle(summary, article, targetLevel);
          // Remove old one
          return removeArticle(inserted, originLevel);
      }
  }

• example usage

  n/a

function gitbook.SummaryModifier.removeArticle (summary, level)

• description and source-code

  function removeArticle(summary, level) {
      // Coerce to level
      level = is.string(level)? level : level.getLevel();
  
      var parent = summary.getParent(level);
  
      var articles = parent.getArticles();
      // Find the index to remove
      var index = articles.findIndex(function(art) {
          return art.getLevel() === level;
      });
      if (index === -1) {
          return summary;
      }
  
      // Remove from children
      articles = articles.remove(index);
      parent = parent.set('articles', articles);
  
      // Reindex the level from here
      parent = indexArticleLevels(parent);
  
      return mergeAtLevel(summary, parent.getLevel(), parent);
  }

• example usage

  n/a

function gitbook.SummaryModifier.removePart (summary, index)

• description and source-code

  function removePart(summary, index) {
      var parts = summary.getParts().remove(index);
      return indexLevels(summary.set('parts', parts));
  }

• example usage

  n/a

function gitbook.SummaryModifier.unshiftArticle (summary, article)

• description and source-code

  function unshiftArticle(summary, article) {
      article = SummaryArticle(article);
  
      var parts = summary.getParts();
      var part = parts.get(0) || SummaryPart();
  
      var articles = part.getArticles();
      articles = articles.unshift(article);
      part = part.set('articles', articles);
  
      parts = parts.set(0, part);
      summary = summary.set('parts', parts);
  
      return indexLevels(summary);
  }

• example usage

  ...
      summary = Summary.createFromParts(file, result.parts);
  }
  
  // Insert readme as first entry if not in SUMMARY.md
  var readmeArticle = summary.getByPath(readmeFile.getPath());
  
  if (readmeFile.exists() && !readmeArticle) {
      summary = SummaryModifier.unshiftArticle(summary, {
          title: 'Introduction',
          ref: readmeFile.getPath()
      });
  }
  
  // Set new summary
  return book.setSummary(summary);
  ...

module gitbook.browser

function gitbook.browser.Book (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.browser.Config (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.browser.FS (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.browser.File (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.browser.Glossary (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.browser.Page (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.browser.PluginDependency (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.browser.Summary (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

module gitbook.command

function gitbook.command.exec (command, options)

• description and source-code

  function exec(command, options) {
      var d = Promise.defer();
  
      var child = childProcess.exec(command, options, function(err, stdout, stderr) {
          if (!err) {
              return d.resolve();
          }
  
          err.message = stdout.toString('utf8') + stderr.toString('utf8');
          d.reject(err);
      });
  
      child.stdout.on('data', function (data) {
          d.notify(data);
      });
  
      child.stderr.on('data', function (data) {
          d.notify(data);
      });
  
      return d.promise;
  }

• example usage

  ...
  @param {String} command
  @param {Object} options
  @return {Promise}
  */
  function exec(command, options) {
  var d = Promise.defer();
  
  var child = childProcess.exec(command, options, function(err, stdout, stderr) {
      if (!err) {
          return d.resolve();
      }
  
      err.message = stdout.toString('utf8') + stderr.toString('utf8');
      d.reject(err);
  });
  ...

function gitbook.command.optionsToShellArgs (options)

• description and source-code

  function optionsToShellArgs(options) {
      var result = [];
  
      for (var key in options) {
          var value = options[key];
  
          if (value === null || value === undefined || value === false) {
              continue;
          }
  
          if (is.bool(value)) {
              result.push(key);
          } else {
              result.push(key + '=' + escapeShellArg(value));
          }
      }
  
      return result.join(' ');
  }

• example usage

  ...
  
      return getConvertOptions(output)
      .then(function(options) {
  var cmd = [
      'ebook-convert',
      path.resolve(outputFolder, SUMMARY_FILE),
      path.resolve(outputFolder, 'index.' + format),
      command.optionsToShellArgs(options)
  ].join(' ');
  
  return command.exec(cmd)
  .progress(function(data) {
      logger.debug(data);
  })
  .fail(function(err) {
  ...

function gitbook.command.spawn (command, args, options)

• description and source-code

  function spawnCmd(command, args, options) {
      var d = Promise.defer();
      var child = spawn(command, args, options);
  
      child.on('error', function(error) {
          return d.reject(error);
      });
  
      child.stdout.on('data', function (data) {
          d.notify(data);
      });
  
      child.stderr.on('data', function (data) {
          d.notify(data);
      });
  
      child.on('close', function(code) {
          if (code === 0) {
              d.resolve();
          } else {
              d.reject(new Error('Error with command "'+command+'"'));
          }
      });
  
      return d.promise;
  }

• example usage

  ...
  var fs = require('./fs');
  var error = require('./error');
  
  // Convert a svg file to a pmg
  function convertSVGToPNG(source, dest, options) {
  if (!fs.existsSync(source)) return Promise.reject(new error.FileNotFoundError({ filename: source }));
  
  return command.spawn('svgexport', [source, dest])
  .fail(function(err) {
      if (err.code == 'ENOENT') {
          err = error.RequireInstallError({
              cmd: 'svgexport',
              install: 'Install it using: "npm install svgexport -g"'
          });
      }
  ...

module gitbook.conrefsLoader

function gitbook.conrefsLoader ()

• description and source-code

  conrefsLoader = function () {
      if(prototype.init) {
          prototype.init.apply(this, arguments);
      }
  }

• example usage

  n/a

function gitbook.conrefsLoader.extend (name, props)

• description and source-code

  extend = function (name, props) {
      if(typeof name === 'object') {
          props = name;
          name = 'anonymous';
      }
      return extend(new_cls, name, props);
  }

• example usage

  ...
  
  var is = require('is');
  var path = require('path');
  var fs = require('fs');
  var expect = require('expect');
  var cheerio = require('cheerio');
  
  expect.extend({
  /**
   * Check that a file is created in a directory:
   * expect('myFolder').toHaveFile('hello.md');
   */
  toHaveFile: function(fileName) {
      var filePath = path.join(this.actual, fileName);
      var exists = fs.existsSync(filePath);
  ...

module gitbook.conrefsLoader.prototype

function gitbook.conrefsLoader.prototype.constructor ()

• description and source-code

  constructor = function () {
      if(prototype.init) {
          prototype.init.apply(this, arguments);
      }
  }

• example usage

  n/a

function gitbook.conrefsLoader.prototype.getSource (sourceURL, callback)

• description and source-code

  getSource = function (sourceURL, callback) {
      var that = this;
  
      this.git.resolve(sourceURL)
      .then(function(filepath) {
          // Is local file
          if (!filepath) {
              filepath = path.resolve(sourceURL);
          } else {
              if (that.logger) that.logger.debug.ln('resolve from git', sourceURL, 'to', filepath);
          }
  
          // Read file from absolute path
          return fs.readFile(filepath)
          .then(function(source) {
              source = source.toString('utf8');
  
              if (that.transformFn) {
                  return that.transformFn(filepath, source);
              }
  
              return source;
          })
          .then(function(source) {
              return {
                  src: source,
                  path: filepath
              };
          });
      })
      .nodeify(callback);
  }

• example usage

  ...
  
  // Resolve the filePath
  var resolvedFilePath = loader.resolve(null, filePath);
  
  return Promise()
  .then(function() {
      if (!loader.async) {
          return loader.getSource(resolvedFilePath);
      }
  
      var deferred = Promise.defer();
      loader.getSource(resolvedFilePath, deferred.makeNodeResolver());
      return deferred.promise;
  })
  .then(function(result) {
  ...

function gitbook.conrefsLoader.prototype.init (rootFolder, transformFn, logger)

• description and source-code

  init = function (rootFolder, transformFn, logger) {
      this.rootFolder = rootFolder;
      this.transformFn = transformFn;
      this.logger = logger;
      this.git = new Git();
  }

• example usage

  n/a

function gitbook.conrefsLoader.prototype.isRelative (filename)

• description and source-code

  isRelative = function (filename) {
      return LocationUtils.isRelative(filename);
  }

• example usage

  ...
  
          // 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'
      isRelative: function(filename) {
          return LocationUtils.isRelative(filename);
      }
  });
  
  module.exports = ConrefsLoader;
  ...

function gitbook.conrefsLoader.prototype.resolve (from, to)

• description and source-code

  resolve = function (from, to) {
      // If origin is in the book, we enforce result file to be in the book
      if (PathUtils.isInRoot(this.rootFolder, from)) {
  
          // Path of current template in the rootFolder (not absolute to fs)
          var fromRelative = path.relative(this.rootFolder, from);
  
          // Resolve "to" to a filepath relative to rootFolder
          var href = LocationUtils.toAbsolute(to, path.dirname(fromRelative), '');
  
          // Return absolute path
          return PathUtils.resolveInRoot(this.rootFolder, href);
      }
  
      // If origin is in a git repository, we resolve file in the git repository
      var gitRoot = this.git.resolveRoot(from);
      if (gitRoot) {
          return PathUtils.resolveInRoot(gitRoot, to);
      }
  
      // If origin is not in the book (include from a git content ref)
      return path.resolve(path.dirname(from), to);
  }

• example usage

  ...
  The `Book` class is the central point of GitBook, it centralize all access read methods. This class is defined in [book.js](https
  ://github.com/GitbookIO/gitbook/blob/master/lib/book.js).
  
  ```js
  // Read configuration from book.json
  var value = book.config.get('title', 'Default Value');
  
  // Resolve a filename to an absolute path
  var filepath = book.resolve('README.md');
  
  // Render an inline markup string
  book.renderInline('markdown', 'This is **Markdown**')
      .then(function(str) { ... })
  
  // Render a markup string (block mode)
  book.renderBlock('markdown', '* This is **Markdown**')
  ...

module gitbook.deprecate

function gitbook.deprecate.disable (key)

• description and source-code

  function disableDeprecation(key) {
      disabled[key] = true;
  }

• example usage

  ...
  
  // No returned value
  // Existing content will be used
  if (!result) {
      return page;
  }
  
  deprecate.disable('page.sections');
  
  // GitBook 3
  // Use returned page.content if different from original content
  if (result.content != originalContent) {
      page = page.set('content', result.content);
  }
  ...

function gitbook.deprecate.enable (key)

• description and source-code

  function enableDeprecation(key) {
      disabled[key] = false;
  }

• example usage

  ...
          page = page.set('content',
              result.sections.map(function(section) {
                  return section.content;
              }).join('\n')
          );
      }
  
      deprecate.enable('page.sections');
  
      return page;
  }
  
  module.exports = decodePage;
  ...

function gitbook.deprecate.field (book, key, instance, property, value, msg)

• description and source-code

  function deprecateField(book, key, instance, property, value, msg) {
      var store = undefined;
  
      var prepare = function() {
          if (!is.undefined(store)) return;
  
          if (is.fn(value)) store = value();
          else store = value;
      };
  
      var getter = function(){
          prepare();
  
          logNotice(book, key, msg);
          return store;
      };
      var setter = function(v) {
          prepare();
  
          logNotice(book, key, msg);
          store = v;
          return store;
      };
  
      Object.defineProperty(instance, property, {
          get: getter,
          set: setter,
          enumerable: true,
          configurable: true
      });
  }

• example usage

  ...
      },
  
      set: function(key, value) {
          return objectPath.set(result.values, key, value);
      }
  };
  
  deprecate.field(output, 'config.options', result, 'options',
      result.values, '"config.options" property is deprecated, use "config.get(key)" instead');
  
  deprecate.field(output, 'config.options.generator', result.values, 'generator',
      output.getGenerator(), '"options.generator" property is deprecated, use "output.name" instead');
  
  deprecate.field(output, 'config.options.generator', result.values, 'output',
      output.getRoot(), '"options.output" property is deprecated, use "output.root()" instead');
  ...

function gitbook.deprecate.method (book, key, fn, msg)

• description and source-code

  function deprecateMethod(book, key, fn, msg) {
      return function() {
          logNotice(book, key, msg);
  
          return fn.apply(this, arguments);
      };
  }

• example usage

  n/a

function gitbook.deprecate.renamedMethod (book, key, instance, oldName, newName, msg)

• description and source-code

  function deprecateRenamedMethod(book, key, instance, oldName, newName, msg) {
      msg = msg || ('"' + oldName + '" is deprecated, use "' + newName + '()" instead');
      var fn = objectPath.get(instance, newName);
  
      instance[oldName] = deprecateMethod(book, key, fn, msg);
  }

• example usage

  ...
      gitbook: {
          version: gitbook.version
      }
  };
  
  // Deprecated properties
  
  deprecate.renamedMethod(output, 'this.isSubBook', result, 'isSubBook&#
  x27;, 'isLanguageBook');
  deprecate.renamedMethod(output, 'this.contentLink', result, 'contentLink', 'output.toURL');
  
  deprecate.field(output, 'this.generator', result, 'generator',
      output.getGenerator(), '"this.generator" property is deprecated, use "this.output.name" instead'
  ;);
  
  deprecate.field(output, 'this.navigation', result, 'navigation', function() {
      return encodeNavigation(output);
  ...

module gitbook.error

function gitbook.error.ConfigurationError (cause, opts)

• description and source-code

  function createError(cause, opts) {
      /*eslint max-statements: [2, 25]*/
      assert(cause, 'an error is required');
      assert(isError(cause),
          'WrappedError: first argument must be an error');
  
      var causeMessage = cause.message;
      if (causeMessage.indexOf('{causeMessage}') >= 0) {
          // recover
          causeMessage = causeMessage.replace(
              causeMessageRegex,
              '$INVALID_CAUSE_MESSAGE_LITERAL'
          );
      }
      if (causeMessage.indexOf('{origMessage}') >= 0) {
          causeMessage = causeMessage.replace(
              origMessageRegex,
              '$INVALID_ORIG_MESSAGE_LITERAL'
          );
      }
  
      var nodeCause = false;
      var errOptions = extend({}, opts, {
          causeMessage: causeMessage,
          origMessage: causeMessage
      });
  
      if (has(cause, 'code') && !has(errOptions, 'code')) {
          errOptions.code = cause.code;
      }
  
      if (has(cause, 'errno') && !has(errOptions, 'errno')) {
          errOptions.errno = cause.errno;
          nodeCause = true;
      }
  
      if (has(cause, 'syscall') && !has(errOptions, 'syscall')) {
          errOptions.syscall = cause.syscall;
          nodeCause = true;
      }
  
      var causeType = cause.type;
      if (!causeType && nodeCause) {
          causeType = 'error.wrapped-io.' +
              (cause.syscall || 'unknown') + '.' +
              (cause.errno || 'unknown');
      } else {
          causeType = 'error.wrapped-unknown';
      }
  
      errOptions.fullType = options.type + '~!~' +
          (cause.fullType || cause.type || causeType);
  
      var err = createTypedError(errOptions);
  
      Object.defineProperty(err, 'cause', {
          value: cause,
          configurable: true,
          enumerable: false
      });
      return err;
  }

• example usage

  ...
      var v = new jsonschema.Validator();
      var result = v.validate(bookJson, schema, {
          propertyName: 'config'
      });
  
      // Throw error
      if (result.errors.length > 0) {
          throw new error.ConfigurationError(new Error(result.errors[0].stack));
      }
  
      // Insert default values
      var defaults = jsonSchemaDefaults(schema);
      return mergeDefaults(bookJson, defaults);
  }
  ...

function gitbook.error.EbookError (cause, opts)

• description and source-code

  function createError(cause, opts) {
      /*eslint max-statements: [2, 25]*/
      assert(cause, 'an error is required');
      assert(isError(cause),
          'WrappedError: first argument must be an error');
  
      var causeMessage = cause.message;
      if (causeMessage.indexOf('{causeMessage}') >= 0) {
          // recover
          causeMessage = causeMessage.replace(
              causeMessageRegex,
              '$INVALID_CAUSE_MESSAGE_LITERAL'
          );
      }
      if (causeMessage.indexOf('{origMessage}') >= 0) {
          causeMessage = causeMessage.replace(
              origMessageRegex,
              '$INVALID_ORIG_MESSAGE_LITERAL'
          );
      }
  
      var nodeCause = false;
      var errOptions = extend({}, opts, {
          causeMessage: causeMessage,
          origMessage: causeMessage
      });
  
      if (has(cause, 'code') && !has(errOptions, 'code')) {
          errOptions.code = cause.code;
      }
  
      if (has(cause, 'errno') && !has(errOptions, 'errno')) {
          errOptions.errno = cause.errno;
          nodeCause = true;
      }
  
      if (has(cause, 'syscall') && !has(errOptions, 'syscall')) {
          errOptions.syscall = cause.syscall;
          nodeCause = true;
      }
  
      var causeType = cause.type;
      if (!causeType && nodeCause) {
          causeType = 'error.wrapped-io.' +
              (cause.syscall || 'unknown') + '.' +
              (cause.errno || 'unknown');
      } else {
          causeType = 'error.wrapped-unknown';
      }
  
      errOptions.fullType = options.type + '~!~' +
          (cause.fullType || cause.type || causeType);
  
      var err = createTypedError(errOptions);
  
      Object.defineProperty(err, 'cause', {
          value: cause,
          configurable: true,
          enumerable: false
      });
      return err;
  }

• example usage

  ...
          if (err.code == 127) {
              throw error.RequireInstallError({
                  cmd: 'ebook-convert',
                  install: 'Install it from Calibre: https://calibre-ebook.com'
              });
          }
  
          throw error.EbookError(err);
      });
  })
  .thenResolve(output);
  }
  
  /**
  Finish the generation, generates the SUMMARY.html
  ...

function gitbook.error.FileNotFoundError (opts)

• description and source-code

  function createError(opts) {
      var result = new Error();
  
      Object.defineProperty(result, 'type', {
          value: result.type,
          enumerable: true,
          writable: true,
          configurable: true
      });
  
      var options = extend({}, args, opts);
      if (!options.fullType) {
          options.fullType = options.type;
      }
  
      extend(result, options);
      if (opts && opts.message) {
          result.message = template(opts.message, options);
      } else if (message) {
          result.message = template(message, options);
      }
  
      return result;
  }

• example usage

  ...
  function fsExists(filePath) {
      return Boolean(getFile(filePath) !== null);
  }
  
  function fsReadFile(filePath) {
      var file = getFile(filePath);
      if (!is.string(file)) {
          throw error.FileNotFoundError({
              filename: filePath
          });
      }
  
      return new Buffer(file, 'utf8');
  }
  ...

function gitbook.error.FileNotParsableError (opts)

• description and source-code

  function createError(opts) {
      var result = new Error();
  
      Object.defineProperty(result, 'type', {
          value: result.type,
          enumerable: true,
          writable: true,
          configurable: true
      });
  
      var options = extend({}, args, opts);
      if (!options.fullType) {
          options.fullType = options.type;
      }
  
      extend(result, options);
      if (opts && opts.message) {
          result.message = template(opts.message, options);
      } else if (message) {
          result.message = template(message, options);
      }
  
      return result;
  }

• example usage

  ...
  Glossary.prototype.toText = function(parser) {
      var file = this.getFile();
      var entries = this.getEntries();
  
      parser = parser? parsers.getByExt(parser) : file.getParser();
  
      if (!parser) {
          throw error.FileNotParsableError({
              filename: file.getPath()
          });
      }
  
      return parser.renderGlossary(entries.toJS());
  };
  ...

function gitbook.error.FileOutOfScopeError (opts)

• description and source-code

  function createError(opts) {
      var result = new Error();
  
      Object.defineProperty(result, 'type', {
          value: result.type,
          enumerable: true,
          writable: true,
          configurable: true
      });
  
      var options = extend({}, args, opts);
      if (!options.fullType) {
          options.fullType = options.type;
      }
  
      extend(result, options);
      if (opts && opts.message) {
          result.message = template(opts.message, options);
      } else if (message) {
          result.message = template(message, options);
      }
  
      return result;
  }

• example usage

  ...
  FS.prototype.resolve = function() {
      var rootPath = this.getRoot();
      var args = Array.prototype.slice.call(arguments);
      var filename = path.join.apply(path, [rootPath].concat(args));
      filename = path.normalize(filename);
  
      if (!this.isInScope(filename)) {
          throw error.FileOutOfScopeError({
              filename: filename,
              root: this.root
          });
      }
  
      return filename;
  };
  ...

function gitbook.error.OutputError (cause, opts)

• description and source-code

  function createError(cause, opts) {
      /*eslint max-statements: [2, 25]*/
      assert(cause, 'an error is required');
      assert(isError(cause),
          'WrappedError: first argument must be an error');
  
      var causeMessage = cause.message;
      if (causeMessage.indexOf('{causeMessage}') >= 0) {
          // recover
          causeMessage = causeMessage.replace(
              causeMessageRegex,
              '$INVALID_CAUSE_MESSAGE_LITERAL'
          );
      }
      if (causeMessage.indexOf('{origMessage}') >= 0) {
          causeMessage = causeMessage.replace(
              origMessageRegex,
              '$INVALID_ORIG_MESSAGE_LITERAL'
          );
      }
  
      var nodeCause = false;
      var errOptions = extend({}, opts, {
          causeMessage: causeMessage,
          origMessage: causeMessage
      });
  
      if (has(cause, 'code') && !has(errOptions, 'code')) {
          errOptions.code = cause.code;
      }
  
      if (has(cause, 'errno') && !has(errOptions, 'errno')) {
          errOptions.errno = cause.errno;
          nodeCause = true;
      }
  
      if (has(cause, 'syscall') && !has(errOptions, 'syscall')) {
          errOptions.syscall = cause.syscall;
          nodeCause = true;
      }
  
      var causeType = cause.type;
      if (!causeType && nodeCause) {
          causeType = 'error.wrapped-io.' +
              (cause.syscall || 'unknown') + '.' +
              (cause.errno || 'unknown');
      } else {
          causeType = 'error.wrapped-unknown';
      }
  
      errOptions.fullType = options.type + '~!~' +
          (cause.fullType || cause.type || causeType);
  
      var err = createTypedError(errOptions);
  
      Object.defineProperty(err, 'cause', {
          value: cause,
          configurable: true,
          enumerable: false
      });
      return err;
  }

• example usage

  n/a

function gitbook.error.ParsingError (cause, opts)

• description and source-code

  function createError(cause, opts) {
      /*eslint max-statements: [2, 25]*/
      assert(cause, 'an error is required');
      assert(isError(cause),
          'WrappedError: first argument must be an error');
  
      var causeMessage = cause.message;
      if (causeMessage.indexOf('{causeMessage}') >= 0) {
          // recover
          causeMessage = causeMessage.replace(
              causeMessageRegex,
              '$INVALID_CAUSE_MESSAGE_LITERAL'
          );
      }
      if (causeMessage.indexOf('{origMessage}') >= 0) {
          causeMessage = causeMessage.replace(
              origMessageRegex,
              '$INVALID_ORIG_MESSAGE_LITERAL'
          );
      }
  
      var nodeCause = false;
      var errOptions = extend({}, opts, {
          causeMessage: causeMessage,
          origMessage: causeMessage
      });
  
      if (has(cause, 'code') && !has(errOptions, 'code')) {
          errOptions.code = cause.code;
      }
  
      if (has(cause, 'errno') && !has(errOptions, 'errno')) {
          errOptions.errno = cause.errno;
          nodeCause = true;
      }
  
      if (has(cause, 'syscall') && !has(errOptions, 'syscall')) {
          errOptions.syscall = cause.syscall;
          nodeCause = true;
      }
  
      var causeType = cause.type;
      if (!causeType && nodeCause) {
          causeType = 'error.wrapped-io.' +
              (cause.syscall || 'unknown') + '.' +
              (cause.errno || 'unknown');
      } else {
          causeType = 'error.wrapped-unknown';
      }
  
      errOptions.fullType = options.type + '~!~' +
          (cause.fullType || cause.type || causeType);
  
      var err = createTypedError(errOptions);
  
      Object.defineProperty(err, 'cause', {
          value: cause,
          configurable: true,
          enumerable: false
      });
      return err;
  }

• example usage

  n/a

function gitbook.error.PluginError (cause, opts)

• description and source-code

  function createError(cause, opts) {
      /*eslint max-statements: [2, 25]*/
      assert(cause, 'an error is required');
      assert(isError(cause),
          'WrappedError: first argument must be an error');
  
      var causeMessage = cause.message;
      if (causeMessage.indexOf('{causeMessage}') >= 0) {
          // recover
          causeMessage = causeMessage.replace(
              causeMessageRegex,
              '$INVALID_CAUSE_MESSAGE_LITERAL'
          );
      }
      if (causeMessage.indexOf('{origMessage}') >= 0) {
          causeMessage = causeMessage.replace(
              origMessageRegex,
              '$INVALID_ORIG_MESSAGE_LITERAL'
          );
      }
  
      var nodeCause = false;
      var errOptions = extend({}, opts, {
          causeMessage: causeMessage,
          origMessage: causeMessage
      });
  
      if (has(cause, 'code') && !has(errOptions, 'code')) {
          errOptions.code = cause.code;
      }
  
      if (has(cause, 'errno') && !has(errOptions, 'errno')) {
          errOptions.errno = cause.errno;
          nodeCause = true;
      }
  
      if (has(cause, 'syscall') && !has(errOptions, 'syscall')) {
          errOptions.syscall = cause.syscall;
          nodeCause = true;
      }
  
      var causeType = cause.type;
      if (!causeType && nodeCause) {
          causeType = 'error.wrapped-io.' +
              (cause.syscall || 'unknown') + '.' +
              (cause.errno || 'unknown');
      } else {
          causeType = 'error.wrapped-unknown';
      }
  
      errOptions.fullType = options.type + '~!~' +
          (cause.fullType || cause.type || causeType);
  
      var err = createTypedError(errOptions);
  
      Object.defineProperty(err, 'cause', {
          value: cause,
          configurable: true,
          enumerable: false
      });
      return err;
  }

• example usage

  ...
  }
  
  // Load plugin JS content
  if (packageMain) {
      try {
          content = require(packageMain);
      } catch(err) {
          throw new error.PluginError(err, {
              plugin: name
          });
      }
  }
  
  // Update plugin
  return plugin.merge({
  ...

function gitbook.error.RequireInstallError (opts)

• description and source-code

  function createError(opts) {
      var result = new Error();
  
      Object.defineProperty(result, 'type', {
          value: result.type,
          enumerable: true,
          writable: true,
          configurable: true
      });
  
      var options = extend({}, args, opts);
      if (!options.fullType) {
          options.fullType = options.type;
      }
  
      extend(result, options);
      if (opts && opts.message) {
          result.message = template(opts.message, options);
      } else if (message) {
          result.message = template(message, options);
      }
  
      return result;
  }

• example usage

  ...
  // Convert a svg file to a pmg
  function convertSVGToPNG(source, dest, options) {
  if (!fs.existsSync(source)) return Promise.reject(new error.FileNotFoundError({ filename: source }));
  
  return command.spawn('svgexport', [source, dest])
  .fail(function(err) {
      if (err.code == 'ENOENT') {
          err = error.RequireInstallError({
              cmd: 'svgexport',
              install: 'Install it using: "npm install svgexport -g"'
          });
      }
      throw err;
  })
  .then(function() {
  ...

function gitbook.error.TemplateError (cause, opts)

• description and source-code

  function createError(cause, opts) {
      /*eslint max-statements: [2, 25]*/
      assert(cause, 'an error is required');
      assert(isError(cause),
          'WrappedError: first argument must be an error');
  
      var causeMessage = cause.message;
      if (causeMessage.indexOf('{causeMessage}') >= 0) {
          // recover
          causeMessage = causeMessage.replace(
              causeMessageRegex,
              '$INVALID_CAUSE_MESSAGE_LITERAL'
          );
      }
      if (causeMessage.indexOf('{origMessage}') >= 0) {
          causeMessage = causeMessage.replace(
              origMessageRegex,
              '$INVALID_ORIG_MESSAGE_LITERAL'
          );
      }
  
      var nodeCause = false;
      var errOptions = extend({}, opts, {
          causeMessage: causeMessage,
          origMessage: causeMessage
      });
  
      if (has(cause, 'code') && !has(errOptions, 'code')) {
          errOptions.code = cause.code;
      }
  
      if (has(cause, 'errno') && !has(errOptions, 'errno')) {
          errOptions.errno = cause.errno;
          nodeCause = true;
      }
  
      if (has(cause, 'syscall') && !has(errOptions, 'syscall')) {
          errOptions.syscall = cause.syscall;
          nodeCause = true;
      }
  
      var causeType = cause.type;
      if (!causeType && nodeCause) {
          causeType = 'error.wrapped-io.' +
              (cause.syscall || 'unknown') + '.' +
              (cause.errno || 'unknown');
      } else {
          causeType = 'error.wrapped-unknown';
      }
  
      errOptions.fullType = options.type + '~!~' +
          (cause.fullType || cause.type || causeType);
  
      var err = createTypedError(errOptions);
  
      Object.defineProperty(err, 'cause', {
          value: cause,
          configurable: true,
          enumerable: false
      });
      return err;
  }

• example usage

  ...
  
      var deferred = Promise.defer();
      loader.getSource(resolvedFilePath, deferred.makeNodeResolver());
      return deferred.promise;
  })
  .then(function(result) {
      if (!result) {
          throw error.TemplateError(new Error('Not found'), {
              filename: filePath
          });
      }
  
      return render(engine, result.path, result.src, context);
  });
  ...

function gitbook.error.enforce (err)

• description and source-code

  function enforce(err) {
      if (is.string(err)) err = new Error(err);
      err.message = err.message.replace(/^Error: /, '');
  
      return err;
  }

• example usage

  n/a

module gitbook.fs

function gitbook.fs.assertFile (filePath, generator)

• description and source-code

  function assertFile(filePath, generator) {
      return fileExists(filePath)
      .then(function(exists) {
          if (exists) return;
  
          return generator();
      });
  }

• example usage

  ...
  return Promise.forEach(articles, function(article) {
      var articlePath = article.getPath();
      var filePath = articlePath? path.join(rootFolder, articlePath) : null;
      if (!filePath) {
          return;
      }
  
      return fs.assertFile(filePath, function() {
          return fs.ensureFile(filePath)
          .then(function() {
              logger.info.ln('create', article.getPath());
              return fs.writeFile(filePath, '# ' + article.getTitle() + '\n\n');
          });
      });
  })
  ...

function gitbook.fs.copy ()

• description and source-code

  copy = function () {
      var nodeArgs = baseArgs.concat(array_slice(arguments));
      var deferred = defer();
      nodeArgs.push(deferred.makeNodeResolver());
      Q(callback).fapply(nodeArgs).fail(deferred.reject);
      return deferred.promise;
  }

• example usage

  ...
      copyFile: function(inputFile, outputFile, content) {
          return Promise()
          .then(function() {
              var outputFilePath = PathUtils.resolveInRoot(outputFolder, outputFile);
  
              return fs.ensureFile(outputFilePath)
              .then(function() {
                  return fs.copy(inputFile, outputFilePath);
              });
          });
      }
  },
  
  gitbook: {
      version: gitbook.version
  ...

function gitbook.fs.copyDir ()

• description and source-code

  copyDir = function () {
      var nodeArgs = baseArgs.concat(array_slice(arguments));
      var deferred = defer();
      nodeArgs.push(deferred.makeNodeResolver());
      Q(callback).fapply(nodeArgs).fail(deferred.reject);
      return deferred.promise;
  }

• example usage

  n/a

function gitbook.fs.download (uri, dest)

• description and source-code

  function download(uri, dest) {
      return writeStream(dest, request(uri));
  }

• example usage

  ...
  
  // We avoid generating twice the same PNG
  var hash = crc.crc32(src).toString(16);
  var fileName = hash + extension;
  var filePath = path.join(rootFolder, fileName);
  
  return fs.assertFile(filePath, function() {
      return fs.download(src, filePath);
  })
  .then(function() {
      // Convert to relative
      src = LocationUtils.relative(currentDirectory, fileName);
  
      $img.replaceWith('<img src="' + src + '" />');
  });
  ...

function gitbook.fs.ensureFile (filename)

• description and source-code

  function ensureFile(filename) {
      var base = path.dirname(filename);
      return Promise.nfcall(mkdirp, base);
  }

• example usage

  ...
      var articlePath = article.getPath();
      var filePath = articlePath? path.join(rootFolder, articlePath) : null;
      if (!filePath) {
          return;
      }
  
      return fs.assertFile(filePath, function() {
          return fs.ensureFile(filePath)
          .then(function() {
              logger.info.ln('create', article.getPath());
              return fs.writeFile(filePath, '# ' + article.getTitle() + '\n\n');
          });
      });
  })
  ...

function gitbook.fs.ensureFolder (rootFolder)

• description and source-code

  function ensureFolder(rootFolder) {
      return rmDir(rootFolder)
      .fail(function() {
          return Promise();
      })
      .then(function() {
          return Promise.nfcall(mkdirp, rootFolder);
      });
  }

• example usage

  ...
  
  // Cleanup output folder
  .then(function(output) {
      var logger = output.getLogger();
      var rootFolder = output.getRoot();
  
      logger.debug.ln('cleanup folder "' + rootFolder + '"');
      return fs.ensureFolder(rootFolder)
          .thenResolve(output);
  })
  
  .then(processOutput.bind(null, generator))
  
  // Log duration and end message
  .then(function(output) {
  ...

function gitbook.fs.exists (filename)

• description and source-code

  function fileExists(filename) {
      var d = Promise.defer();
  
      fs.exists(filename, function(exists) {
          d.resolve(exists);
      });
  
      return d.promise;
  }

• example usage

  ...
      @return {Promise}
  */
  hasFile: function(fileName, content) {
      return Promise()
      .then(function() {
          var filePath = PathUtils.resolveInRoot(outputFolder, fileName);
  
          return fs.exists(filePath);
      });
  },
  
  /**
      Write a file to the output folder,
      It creates the required folder
  ...

function gitbook.fs.existsSync (path)

• description and source-code

  existsSync = function (path) {
    try {
      nullCheck(path);
      binding.stat(pathModule._makeLong(path), statValues);
      return true;
    } catch (e) {
      return false;
    }
  }

• example usage

  ...
  expect.extend({
      /**
       * Check that a file is created in a directory:
       * expect('myFolder').toHaveFile('hello.md');
       */
      toHaveFile: function(fileName) {
  var filePath = path.join(this.actual, fileName);
  var exists = fs.existsSync(filePath);
  
  expect.assert(
      exists,
      'expected %s to have file %s',
      this.actual,
      fileName
  );
  ...

function gitbook.fs.mkdirp ()

• description and source-code

  mkdirp = function () {
      var nodeArgs = baseArgs.concat(array_slice(arguments));
      var deferred = defer();
      nodeArgs.push(deferred.makeNodeResolver());
      Q(callback).fapply(nodeArgs).fail(deferred.reject);
      return deferred.promise;
  }

• example usage

  ...
      @param {Book}
      @param {String}
      @return {Promise}
  */
  function initBook(rootFolder) {
      var extension = '.md';
  
      return fs.mkdirp(rootFolder)
  
      // Parse the summary and readme
      .then(function() {
  var fs = createNodeFS(rootFolder);
  var book = Book.createForFS(fs);
  
  return Parse.parseReadme(book)
  ...

function gitbook.fs.pickFile (rootFolder, fileName)

• description and source-code

  function pickFile(rootFolder, fileName) {
      var result = path.join(rootFolder, fileName);
      if (fs.existsSync(result)) {
          return result;
      }
  
      return undefined;
  }

• example usage

  ...
  function getCoverPath(output) {
  var outputRoot = output.getRoot();
  var book = output.getBook();
  var config = book.getConfig();
  var coverName = config.getValue('cover', 'cover.jpg');
  
  // Resolve to absolute
  var cover = fs.pickFile(outputRoot, coverName);
  if (cover) {
      return cover;
  }
  
  // Multilingual? try parent folder
  if (book.isLanguageBook()) {
      cover = fs.pickFile(path.join(outputRoot, '..'), coverName);
  ...

function gitbook.fs.readFile ()

• description and source-code

  readFile = function () {
      var nodeArgs = baseArgs.concat(array_slice(arguments));
      var deferred = defer();
      nodeArgs.push(deferred.makeNodeResolver());
      Q(callback).fapply(nodeArgs).fail(deferred.reject);
      return deferred.promise;
  }

• example usage

  ...
              if (!filepath) {
  filepath = path.resolve(sourceURL);
              } else {
  if (that.logger) that.logger.debug.ln('resolve from git', sourceURL, 'to', filepath);
              }
  
              // Read file from absolute path
              return fs.readFile(filepath)
              .then(function(source) {
  source = source.toString('utf8');
  
  if (that.transformFn) {
      return that.transformFn(filepath, source);
  }
  ...

function gitbook.fs.readStream (path, options)

• description and source-code

  function createReadStream(path, options) {
    return new ReadStream(path, options)
  }

• example usage

  n/a

function gitbook.fs.readdir ()

• description and source-code

  readdir = function () {
      var nodeArgs = baseArgs.concat(array_slice(arguments));
      var deferred = defer();
      nodeArgs.push(deferred.makeNodeResolver());
      Q(callback).fapply(nodeArgs).fail(deferred.reject);
      return deferred.promise;
  }

• example usage

  ...
  var Immutable = require('immutable');
  var fresh = require('fresh-require');
  
  var fs = require('../utils/fs');
  var FS = require('../models/fs');
  
  function fsReadDir(folder) {
      return fs.readdir(folder)
      .then(function(files) {
  files = Immutable.List(files);
  
  return files
      .map(function(file) {
          if (file == '.' || file == '..') return;
  ...

function gitbook.fs.rmDir (base)

• description and source-code

  function rmDir(base) {
      return Promise.nfcall(rmdir, base, {
          fs: fs
      });
  }

• example usage

  ...
              })
  
              // Log end
              .then(function(count) {
                  logger.info.ok(count + ' file(s) generated');
  
                  logger.debug('cleaning up... ');
                  return logger.debug.promise(fs.rmDir(outputFolder));
              });
          }
      };
  };
  ...

function gitbook.fs.stat ()

• description and source-code

  stat = function () {
      var nodeArgs = baseArgs.concat(array_slice(arguments));
      var deferred = defer();
      nodeArgs.push(deferred.makeNodeResolver());
      Q(callback).fapply(nodeArgs).fail(deferred.reject);
      return deferred.promise;
  }

• example usage

  n/a

function gitbook.fs.statSync (path)

• description and source-code

  statSync = function (path) {
    nullCheck(path);
    binding.stat(pathModule._makeLong(path), statValues);
    return statsFromValues();
  }

• example usage

  ...
  .then(function(files) {
      files = Immutable.List(files);
  
      return files
          .map(function(file) {
              if (file == '.' || file == '..') return;
  
              var stat = fs.statSync(path.join(folder, file));
              if (stat.isDirectory()) file = file + path.sep;
              return file;
          })
          .filter(function(file) {
              return Boolean(file);
          });
  });
  ...

function gitbook.fs.tmpDir (opts)

• description and source-code

  function genTmpDir(opts) {
      return Promise.nfcall(tmp.dir, opts)
          .get(0);
  }

• example usage

  n/a

function gitbook.fs.tmpFile (opts)

• description and source-code

  function genTmpFile(opts) {
      return Promise.nfcall(tmp.file, opts)
          .get(0);
  }

• example usage

  ...
      throw new Error('Error converting '+source+' into '+dest);
  });
  }
  
  // Convert a svg buffer to a png file
  function convertSVGBufferToPNG(buf, dest) {
  // Create a temporary SVG file to convert
  return fs.tmpFile({
      postfix: '.svg'
  })
  .then(function(tmpSvg) {
      return fs.writeFile(tmpSvg, buf)
      .then(function() {
          return convertSVGToPNG(tmpSvg, dest);
      });
  ...

function gitbook.fs.uniqueFilename (base, filename)

• description and source-code

  function uniqueFilename(base, filename) {
      var ext = path.extname(filename);
      filename = path.resolve(base, 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 Promise(path.relative(base, _filename));
  }

• example usage

  n/a

function gitbook.fs.writeFile ()

• description and source-code

  writeFile = function () {
      var nodeArgs = baseArgs.concat(array_slice(arguments));
      var deferred = defer();
      nodeArgs.push(deferred.makeNodeResolver());
      Q(callback).fapply(nodeArgs).fail(deferred.reject);
      return deferred.promise;
  }

• example usage

  ...
          return;
      }
  
      return fs.assertFile(filePath, function() {
          return fs.ensureFile(filePath)
          .then(function() {
              logger.info.ln('create', article.getPath());
              return fs.writeFile(filePath, '# ' + article.getTitle() + '
  ;\n\n');
          });
      });
  })
  
  // Write summary
  .then(function() {
      var filePath = path.join(rootFolder, summaryFilename);
  ...

function gitbook.fs.writeStream (filename, st)

• description and source-code

  function writeStream(filename, st) {
      var d = Promise.defer();
  
      var wstream = fs.createWriteStream(filename);
      var cleanup = function() {
          destroy(wstream);
          wstream.removeAllListeners();
      };
  
      wstream.on('finish', function () {
          cleanup();
          d.resolve();
      });
      wstream.on('error', function (err) {
          cleanup();
          d.reject(err);
      });
  
      st.on('error', function(err) {
          cleanup();
          d.reject(err);
      });
  
      st.pipe(wstream);
  
      return d.promise;
  }

• example usage

  n/a

module gitbook.glossaryEntry

function gitbook.glossaryEntry (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.glossaryEntry.nameToID (name)

• description and source-code

  function nameToID(name) {
      return slug(name);
  }

• example usage

  ...
  
  /**
  Get identifier for this entry
  
  @retrun {Boolean}
  */
  GlossaryEntry.prototype.getID = function() {
  return GlossaryEntry.nameToID(this.getName());
  };
  
  
  /**
  Normalize a glossary entry name into a unique id
  
  @param {String}
  ...

module gitbook.glossaryEntry.prototype

function gitbook.glossaryEntry.prototype.constructor (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.glossaryEntry.prototype.getDescription ()

• description and source-code

  getDescription = function () {
      return this.get('description');
  }

• example usage

  ...
      @param {GlossaryEntry}
      @return {Object}
  */
  function encodeGlossaryEntry(entry) {
      return {
          id: entry.getID(),
          name: entry.getName(),
          description: entry.getDescription()
      };
  }
  
  module.exports = encodeGlossaryEntry;
  ...

function gitbook.glossaryEntry.prototype.getID ()

• description and source-code

  getID = function () {
      return GlossaryEntry.nameToID(this.getName());
  }

• example usage

  ...
              // Extract ebook file
              .then(function(output) {
                  var book = output.getBook();
                  var languages = book.getLanguages();
  
                  if (book.isMultilingual()) {
                      return Promise.forEach(languages.getList(), function(lang) {
  var langID = lang.getID();
  
  var langOutputFile = path.join(
      path.dirname(outputFile),
      path.basename(outputFile, extension) + '_' + langID + extension
  );
  
  return fs.copy(
  ...

function gitbook.glossaryEntry.prototype.getName ()

• description and source-code

  getName = function () {
      return this.get('name');
  }

• example usage

  ...
  * Return a specific parser by its name
  *
  * @param {String} name
  * @return {Parser|undefined}
  */
  function getParser(name) {
     return parsers.find(function(parser) {
         return parser.getName() === name;
     });
  }
  
  /**
  * Return a specific parser according to an extension
  *
  * @param {String} ext
  ...

module gitbook.ignore

function gitbook.ignore (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

module gitbook.ignore.prototype

function gitbook.ignore.prototype.add (rule)

• description and source-code

  add = function (rule) {
      var ignore = this.getIgnore();
      var newIgnore = new IgnoreMutable();
  
      newIgnore.add(ignore);
      newIgnore.add(rule);
  
      return this.set('ignore', newIgnore);
  }

• example usage

  ...
      @param {String}
      @return {Ignore}
  */
  Ignore.prototype.add = function(rule) {
      var ignore = this.getIgnore();
      var newIgnore = new IgnoreMutable();
  
      newIgnore.add(ignore);
      newIgnore.add(rule);
  
      return this.set('ignore', newIgnore);
  };
  
  module.exports = Ignore;
  ...

function gitbook.ignore.prototype.constructor (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.ignore.prototype.getIgnore ()

• description and source-code

  getIgnore = function () {
      return this.get('ignore');
  }

• example usage

  ...
  /**
  Check if a file is ignore (should not being parsed, etc)
  
  @param {String} ref
  @return {Page|undefined}
  */
  Book.prototype.isFileIgnored = function(filename) {
  var ignore = this.getIgnore();
  var language = this.getLanguage();
  
  // Ignore is always relative to the root of the main book
  if (language) {
      filename = path.join(language, filename);
  }
  ...

function gitbook.ignore.prototype.isFileIgnored (filename)

• description and source-code

  isFileIgnored = function (filename) {
      var ignore = this.getIgnore();
      return ignore.filter([filename]).length == 0;
  }

• example usage

  ...
  var language = this.getLanguage();
  
  // Ignore is always relative to the root of the main book
  if (language) {
      filename = path.join(language, filename);
  }
  
  return ignore.isFileIgnored(filename);
  };
  
  /**
  Check if a content file is ignore (should not being parsed, etc)
  
  @param {String} ref
  @return {Page|undefined}
  ...

module gitbook.images

function gitbook.images.convertInlinePNG (source, dest)

• description and source-code

  function convertInlinePNG(source, dest) {
      if (!/^data\:image\/png/.test(source)) return Promise.reject(new Error('Source is not a PNG data-uri'));
  
      var base64data = source.split('data:image/png;base64,')[1];
      var buf = new Buffer(base64data, 'base64');
  
      return fs.writeFile(dest, buf)
      .then(function() {
          if (fs.existsSync(dest)) return;
  
          throw new Error('Error converting '+source+' into '+dest);
      });
  }

• example usage

  ...
          var hash = crc.crc32(src).toString(16);
          var fileName = hash + '.png';
  
          // Result file path
          var filePath = path.join(rootFolder, fileName);
  
          return fs.assertFile(filePath, function() {
  return imagesUtil.convertInlinePNG(src, filePath);
          })
          .then(function() {
  // Convert filename to a relative filename
  fileName = LocationUtils.relative(currentDirectory, fileName);
  
  // Replace src
  $img.attr('src', fileName);
  ...

function gitbook.images.convertSVGBufferToPNG (buf, dest)

• description and source-code

  function convertSVGBufferToPNG(buf, dest) {
      // Create a temporary SVG file to convert
      return fs.tmpFile({
          postfix: '.svg'
      })
      .then(function(tmpSvg) {
          return fs.writeFile(tmpSvg, buf)
          .then(function() {
              return convertSVGToPNG(tmpSvg, dest);
          });
      });
  }

• example usage

  n/a

function gitbook.images.convertSVGToPNG (source, dest, options)

• description and source-code

  function convertSVGToPNG(source, dest, options) {
      if (!fs.existsSync(source)) return Promise.reject(new error.FileNotFoundError({ filename: source }));
  
      return command.spawn('svgexport', [source, dest])
      .fail(function(err) {
          if (err.code == 'ENOENT') {
              err = error.RequireInstallError({
                  cmd: 'svgexport',
                  install: 'Install it using: "npm install svgexport -g"'
              });
          }
          throw err;
      })
      .then(function() {
          if (fs.existsSync(dest)) return;
  
          throw new Error('Error converting '+source+' into '+dest);
      });
  }

• example usage

  n/a

module gitbook.index

function gitbook.index.decodeGlobal (output, result)

• description and source-code

  function decodeGlobal(output, result) {
      var book = output.getBook();
      var config = book.getConfig();
  
      // Update config
      config = decodeConfig(config, result.config);
      book = book.set('config', config);
  
      return output.set('book', book);
  }

• example usage

  ...
  
                  return hook.call(context, prev);
              }, arg);
          })
  
          // Handle final result
          .then(function(result) {
              output = Api.decodeGlobal(output, context);
              return handleResult(output, result);
          })
      );
  }
  
  module.exports = callHook;
  ...

function gitbook.index.decodePage (output, page, result)

• description and source-code

  function decodePage(output, page, result) {
      var originalContent = page.getContent();
  
      // No returned value
      // Existing content will be used
      if (!result) {
          return page;
      }
  
      deprecate.disable('page.sections');
  
      // GitBook 3
      // Use returned page.content if different from original content
      if (result.content != originalContent) {
          page = page.set('content', result.content);
      }
  
      // GitBook 2 compatibility
      // Finally, use page.sections
      else if (result.sections) {
          page = page.set('content',
              result.sections.map(function(section) {
                  return section.content;
              }).join('\n')
          );
      }
  
      deprecate.enable('page.sections');
  
      return page;
  }

• example usage

  ...
          name,
  
          function(out) {
              return Api.encodePage(out, page);
          },
  
          function(out, result) {
              return Api.decodePage(out, page, result);
          },
  
          output
      );
  }
  
  module.exports = callPageHook;
  ...

function gitbook.index.encodeGlobal (output)

• description and source-code

  function encodeGlobal(output) {
      var book = output.getBook();
      var bookFS = book.getContentFS();
      var logger = output.getLogger();
      var outputFolder = output.getRoot();
      var plugins = output.getPlugins();
      var blocks = Plugins.listBlocks(plugins);
  
      var result = {
          log: logger,
          config: encodeConfig(output, book.getConfig()),
          summary: encodeSummary(output, book.getSummary()),
  
          /**
              Check if the book is a multilingual book
  
              @return {Boolean}
          */
          isMultilingual: function() {
              return book.isMultilingual();
          },
  
          /**
              Check if the book is a language book for a multilingual book
  
              @return {Boolean}
          */
          isLanguageBook: function() {
              return book.isLanguageBook();
          },
  
          /**
              Read a file from the book
  
              @param {String} fileName
              @return {Promise<Buffer>}
          */
          readFile: function(fileName) {
              return bookFS.read(fileName);
          },
  
          /**
              Read a file from the book as a string
  
              @param {String} fileName
              @return {Promise<String>}
          */
          readFileAsString: function(fileName) {
              return bookFS.readAsString(fileName);
          },
  
          /**
              Resolve a file from the book root
  
              @param {String} fileName
              @return {String}
          */
          resolve: function(fileName) {
              return path.resolve(book.getContentRoot(), fileName);
          },
  
          /**
              Resolve a page by it path
  
              @param {String} filePath
              @return {String}
          */
          getPageByPath: function(filePath) {
              var page = output.getPage(filePath);
              if (!page) return undefined;
  
              return encodePage(output, page);
          },
  
          /**
              Render a block of text (markdown/asciidoc)
  
              @param {String} type
              @param {String} text
              @return {Promise<String>}
          */
          renderBlock: function(type, text) {
              var parser = parsers.get(type);
  
              return parser.parsePage(text)
                  .get('content');
          },
  
          /**
              Render an inline text (markdown/asciidoc)
  
              @param {String} type
              @param {String} text
              @return {Promise<String>}
          */
          renderInline: function(type, text) {
              var parser = parsers.get(type);
  
              return parser.parseInline(text)
                  .get('content');
          },
  
          template: {
              /**
                  Apply a templating block and returns its result
  
                  @param {String} name
                  @param {Object} blockData
                  @return {Promise|Object}
              */
              applyBlock: function(name, blockData) {
                  var block = blocks.get(name) || defaultBlocks.get(name);
                  return Promise(block.applyBlock(blockData, result));
              }
          },
  
          output: {
              /**
                  Name of the generator being used
                  {String}
              */
              name: output.getGenerator(),
  
              /**
                  Return absolute path to the root folder of output
                  @return {String}
              */
              root: function() {
                  return outputFolder;
              },
  
              /**
                  Resolve a file from the output root
  
                  @param {String} fileName
                  @return {String}
              */
              resolve: function(fileName) {
                  return path.resolve(outputFolder, fileName);
              },
  
              /**
                  Convert a filepath into an url
                  @return {String}
              */
              toURL: function(filePath) {
                  return fileToURL(output, filePath);
              },
  
              /**
                  Check that a file exists.
  
                  @param {String} fileName
                  @return {Promise} ...

• example usage

  ...
  
      var logger = output.getLogger();
      var plugins = output.getPlugins();
  
      logger.debug.ln('calling hook "' + name + '"');
  
      // Create the JS context for plugins
      var context = Api.encodeGlobal(output);
  
      return timing.measure(
  'call.hook.' + name,
  
  // Get the arguments
  Promise(getArgument(output))
  ...

function gitbook.index.encodePage (output, page)

• description and source-code

  function encodePage(output, page) {
      var book = output.getBook();
      var summary = book.getSummary();
      var fs = book.getContentFS();
      var file = page.getFile();
  
      // JS Page is based on the JSON output
      var result = JSONUtils.encodePage(page, summary);
  
      result.type = file.getType();
      result.path = file.getPath();
      result.rawPath = fs.resolve(result.path);
  
      deprecate.field(output, 'page.progress', result, 'progress', function() {
          return encodeProgress(output, page);
      }, '"page.progress" property is deprecated');
  
      deprecate.field(output, 'page.sections', result, 'sections', [
          {
              content: result.content,
              type: 'normal'
          }
      ], '"sections" property is deprecated, use page.content instead');
  
      return result;
  }

• example usage

  ...
  function encodePage(output, page) {
  var book = output.getBook();
  var summary = book.getSummary();
  var fs = book.getContentFS();
  var file = page.getFile();
  
  // JS Page is based on the JSON output
  var result = JSONUtils.encodePage(page, summary);
  
  result.type = file.getType();
  result.path = file.getPath();
  result.rawPath = fs.resolve(result.path);
  
  deprecate.field(output, 'page.progress', result, 'progress', function() {
      return encodeProgress(output, page);
  ...

module gitbook.install

function gitbook.install.exec (args, kwargs)

• description and source-code

  exec = function (args, kwargs) {
      var book = getBook(args, kwargs);
  
      return Parse.parseConfig(book)
      .then(function(resultBook) {
          return Plugins.installPlugins(resultBook);
      });
  }

• example usage

  ...
  @param {String} command
  @param {Object} options
  @return {Promise}
  */
  function exec(command, options) {
  var d = Promise.defer();
  
  var child = childProcess.exec(command, options, function(err, stdout, stderr) {
      if (!err) {
          return d.resolve();
      }
  
      err.message = stdout.toString('utf8') + stderr.toString('utf8');
      d.reject(err);
  });
  ...

module gitbook.language

function gitbook.language (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

module gitbook.language.prototype

function gitbook.language.prototype.constructor (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.language.prototype.getID ()

• description and source-code

  getID = function () {
      return path.basename(this.getPath());
  }

• example usage

  ...
              // Extract ebook file
              .then(function(output) {
                  var book = output.getBook();
                  var languages = book.getLanguages();
  
                  if (book.isMultilingual()) {
                      return Promise.forEach(languages.getList(), function(lang) {
  var langID = lang.getID();
  
  var langOutputFile = path.join(
      path.dirname(outputFile),
      path.basename(outputFile, extension) + '_' + langID + extension
  );
  
  return fs.copy(
  ...

function gitbook.language.prototype.getPath ()

• description and source-code

  getPath = function () {
      return this.get('path');
  }

• example usage

  ...
      })
      .then(Parse.parseSummary)
  
      .then(function(book) {
  var logger = book.getLogger();
  var summary = book.getSummary();
  var summaryFile = summary.getFile();
  var summaryFilename = summaryFile.getPath() || ('SUMMARY' + extension);
  
  var articles = summary.getArticlesAsList();
  
  // Write pages
  return Promise.forEach(articles, function(article) {
      var articlePath = article.getPath();
      var filePath = articlePath? path.join(rootFolder, articlePath) : null;
  ...

function gitbook.language.prototype.getTitle ()

• description and source-code

  getTitle = function () {
      return this.get('title');
  }

• example usage

  ...
          return;
      }
  
      return fs.assertFile(filePath, function() {
          return fs.ensureFile(filePath)
          .then(function() {
              logger.info.ln('create', article.getPath());
              return fs.writeFile(filePath, '# ' + article.getTitle() + '
  ;\n\n');
          });
      });
  })
  
  // Write summary
  .then(function() {
      var filePath = path.join(rootFolder, summaryFilename);
  ...

module gitbook.languages

function gitbook.languages (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.languages.createFromList (file, langs)

• description and source-code

  createFromList = function (file, langs) {
      var list = Immutable.OrderedMap();
  
      langs.forEach(function(lang) {
          lang = Language({
              title: lang.title,
              path: lang.ref
          });
          list = list.set(lang.getID(), lang);
      });
  
      return Languages({
          file: file,
          list: list
      });
  }

• example usage

  ...
  
      return parseStructureFile(book, 'langs')
      .spread(function(file, result) {
          if (!file) {
              return book;
          }
  
          var languages = Languages.createFromList(file, result);
  
          logger.debug.ln('languages index file found at', file.getPath());
          logger.info.ln('parsing multilingual book, with', languages.getList().size, 'languages');
  
          return book.set('languages', languages);
      });
  }
  ...

module gitbook.languages.prototype

function gitbook.languages.prototype.constructor (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.languages.prototype.getCount ()

• description and source-code

  getCount = function () {
      return this.getList().size;
  }

• example usage

  ...
              );
  
              return fs.copy(
                  path.resolve(outputFolder, langID, 'index' + extension),
                  langOutputFile
              );
          })
          .thenResolve(languages.getCount());
      } else {
          return fs.copy(
              path.resolve(outputFolder, 'index' + extension),
              outputFile
          ).thenResolve(1);
      }
  })
  ...

function gitbook.languages.prototype.getDefaultLanguage ()

• description and source-code

  getDefaultLanguage = function () {
      return this.getList().first();
  }

• example usage

  ...
  
  if (!book.isMultilingual()) {
      return Promise(output);
  }
  
  // Get main language
  var languages = book.getLanguages();
  var mainLanguage = languages.getDefaultLanguage();
  
  // Read the main JSON
  return fs.readFile(path.resolve(outputRoot, mainLanguage.getID(), 'README.json'), 'utf8')
  
  // Extend the JSON
  .then(function(content) {
      var json = JSON.parse(content);
  ...

function gitbook.languages.prototype.getFile ()

• description and source-code

  getFile = function () {
      return this.get('file');
  }

• example usage

  ...
  });
      })
      .then(Parse.parseSummary)
  
      .then(function(book) {
  var logger = book.getLogger();
  var summary = book.getSummary();
  var summaryFile = summary.getFile();
  var summaryFilename = summaryFile.getPath() || ('SUMMARY' + extension);
  
  var articles = summary.getArticlesAsList();
  
  // Write pages
  return Promise.forEach(articles, function(article) {
      var articlePath = article.getPath();
  ...

function gitbook.languages.prototype.getLanguage (lang)

• description and source-code

  getLanguage = function (lang) {
      return this.getList().get(lang);
  }

• example usage

  ...
  Encode a book to JSON
  
  @param {Book}
  @return {Object}
  */
  function encodeBookToJson(book) {
  var config = book.getConfig();
  var language = book.getLanguage();
  
  var variables = config.getValue('variables', {});
  
  return {
      summary: encodeSummary(book.getSummary()),
      glossary: encodeGlossary(book.getGlossary()),
      readme: encodeReadme(book.getReadme()),
  ...

function gitbook.languages.prototype.getList ()

• description and source-code

  getList = function () {
      return this.get('list');
  }

• example usage

  ...
  
              // Extract ebook file
              .then(function(output) {
                  var book = output.getBook();
                  var languages = book.getLanguages();
  
                  if (book.isMultilingual()) {
                      return Promise.forEach(languages.getList(), function(lang) {
  var langID = lang.getID();
  
  var langOutputFile = path.join(
      path.dirname(outputFile),
      path.basename(outputFile, extension) + '_' + langID + extension
  );
  ...

module gitbook.location

function gitbook.location.areIdenticalPaths (p1, p2)

• description and source-code

  function areIdenticalPaths(p1, p2) {
      return normalize(p1) === normalize(p2);
  }

• example usage

  ...
  */
  Summary.prototype.getByPath = function(filePath) {
  return this.getArticle(function(article) {
      var articlePath = article.getPath();
  
      return (
          articlePath &&
          LocationUtils.areIdenticalPaths(articlePath, filePath)
      );
  });
  };
  
  /**
  Return the first article
  ...

function gitbook.location.flatten (href)

• description and source-code

  function flatten(href) {
      href = normalize(href);
      if (href[0] == '/') {
          href = normalize(href.slice(1));
      }
  
      return href;
  }

• example usage

  ...
  }
  
  // List all parsable extensions
  var extensions = parsers
      .map(function(parser) {
          return parser.getExtensions();
      })
      .flatten();
  
  module.exports = {
      extensions: extensions,
      get: getParser,
      getByExt: getParserByExt,
      getForFile: getParserForFile
  };
  ...

function gitbook.location.isAnchor (href)

• description and source-code

  function isAnchor(href) {
      try {
          var parsed = url.parse(href);
          return !!(!parsed.protocol && !parsed.path && parsed.hash);
      } catch(err) {
          return false;
      }
  }

• example usage

  n/a

function gitbook.location.isDataURI (href)

• description and source-code

  function isDataURI(href) {
      try {
          return Boolean(url.parse(href).protocol) && (url.parse(href).protocol === 'data:');
      } catch(err) {
          return false;
      }
  }

• example usage

  ...
      @return {Promise}
  */
  function inlinePng(rootFolder, currentFile, $) {
      var currentDirectory = path.dirname(currentFile);
  
      return editHTMLElement($, 'img', function($img) {
  var src = $img.attr('src');
  if (!LocationUtils.isDataURI(src)) {
      return;
  }
  
  // We avoid generating twice the same PNG
  var hash = crc.crc32(src).toString(16);
  var fileName = hash + '.png';
  ...

function gitbook.location.isExternal (href)

• description and source-code

  function isExternal(href) {
      try {
          return Boolean(url.parse(href).protocol) && !isDataURI(href);
      } catch(err) {
          return false;
      }
  }

• example usage

  ...
  var articlePath = article.getPath();
  
  return {
      path: articlePath,
      title: article.getTitle(),
      level: article.getLevel(),
      exists: (articlePath && pages.has(articlePath)),
      external: article.isExternal()
  };
  }
  
  /**
  this.navigation is a deprecated property from GitBook v2
  
  @param {Output}
  ...

function gitbook.location.isRelative (href)

• description and source-code

  function isRelative(href) {
      return !isExternal(href);
  }

• example usage

  ...
  
          // 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'
      isRelative: function(filename) {
          return LocationUtils.isRelative(filename);
      }
  });
  
  module.exports = ConrefsLoader;
  ...

function gitbook.location.normalize (s)

• description and source-code

  function normalize(s) {
      return path.normalize(s).replace(/\\/g, '/');
  }

• example usage

  ...
      @param {Map<String:String|Map>}
  */
  function createMockFS(files) {
      files = Immutable.fromJS(files);
      var mtime = new Date();
  
      function getFile(filePath) {
          var parts = path.normalize(filePath).split(path.sep);
          return parts.reduce(function(list, part, i) {
  if (!list) return null;
  
  var file;
  
  if (!part || part === '.') file = list;
  else file = list.get(part);
  ...

function gitbook.location.relative (dir, file)

• description and source-code

  function relative(dir, file) {
      var isDirectory = file.slice(-1) === '/';
      return normalize(path.relative(dir, file)) + (isDirectory? '/': '');
  }

• example usage

  ...
      },
  
      resolve: function(from, to) {
  // If origin is in the book, we enforce result file to be in the book
  if (PathUtils.isInRoot(this.rootFolder, from)) {
  
      // Path of current template in the rootFolder (not absolute to fs)
      var fromRelative = path.relative(this.rootFolder, from);
  
      // Resolve "to" to a filepath relative to rootFolder
      var href = LocationUtils.toAbsolute(to, path.dirname(fromRelative), '');
  
      // Return absolute path
      return PathUtils.resolveInRoot(this.rootFolder, href);
  }
  ...

function gitbook.location.relativeForFile (baseFile, file)

• description and source-code

  function relativeForFile(baseFile, file) {
      return relative(path.dirname(baseFile), file);
  }

• example usage

  n/a

function gitbook.location.toAbsolute (_href, dir, outdir)

• description and source-code

  function toAbsolute(_href, dir, outdir) {
      if (isExternal(_href) || isDataURI(_href)) {
          return _href;
      }
  
      outdir = outdir == undefined? dir : outdir;
  
      _href = normalize(_href);
      dir = normalize(dir);
      outdir = normalize(outdir);
  
      // Path "_href" inside the base folder
      var hrefInRoot = normalize(path.join(dir, _href));
      if (_href[0] == '/') {
          hrefInRoot = normalize(_href.slice(1));
      }
  
      // Make it relative to output
      _href = path.relative(outdir, hrefInRoot);
  
      // Normalize windows paths
      _href = normalize(_href);
  
      return _href;
  }

• example usage

  ...
  // If origin is in the book, we enforce result file to be in the book
  if (PathUtils.isInRoot(this.rootFolder, from)) {
  
      // Path of current template in the rootFolder (not absolute to fs)
      var fromRelative = path.relative(this.rootFolder, from);
  
      // Resolve "to" to a filepath relative to rootFolder
      var href = LocationUtils.toAbsolute(to, path.dirname(fromRelative), '');
  
      // Return absolute path
      return PathUtils.resolveInRoot(this.rootFolder, href);
  }
  
  // If origin is in a git repository, we resolve file in the git repository
  var gitRoot = this.git.resolveRoot(from);
  ...

module gitbook.logger

function gitbook.logger (write, logLevel)

• description and source-code

  function Logger(write, logLevel) {
      if (!(this instanceof Logger)) return new Logger(write, logLevel);
  
      this._write = write || function(msg) {
          if(process.stdout) {
              process.stdout.write(msg);
          }
      };
      this.lastChar = '\n';
  
      this.setLevel(logLevel || 'info');
  
      // Create easy-to-use method like "logger.debug.ln('....')"
      LEVELS.forEach(function(level, levelKey) {
          if (levelKey === 'DISABLED') {
              return;
          }
          levelKey = levelKey.toLowerCase();
  
          this[levelKey] =            this.log.bind(this, level);
          this[levelKey].ln =         this.logLn.bind(this, level);
          this[levelKey].ok =         this.ok.bind(this, level);
          this[levelKey].fail =       this.fail.bind(this, level);
          this[levelKey].promise =    this.promise.bind(this, level);
      }, this);
  }

• example usage

  n/a

module gitbook.logger.prototype

function gitbook.logger.prototype.fail (level)

• description and source-code

  fail = function (level) {
      return this.log(level, color.red('ERROR') + '\n');
  }

• example usage

  ...
  .then(function() {
      var fs = createNodeFS(rootFolder);
      var book = Book.createForFS(fs);
  
      return Parse.parseReadme(book)
  
      // Setup default readme if doesn't found one
      .fail(function() {
          var readmeFile = File.createWithFilepath('README' + extension);
          var readme = Readme.create(readmeFile);
          return book.setReadme(readme);
      });
  })
  .then(Parse.parseSummary)
  ...

function gitbook.logger.prototype.format ()

• description and source-code

  format = function () {
      return util.format.apply(util, arguments);
  }

• example usage

  ...
      a url string in it's parsed form and returns the new url as a string
  
      @param {String} uri
      @param {Function} fn
      @return {String}
  */
  function urlTransform(uri, fn) {
      return url.format(fn(url.parse(uri)));
  }
  
  module.exports = Server;
  ...

function gitbook.logger.prototype.getLevel (logLevel)

• description and source-code

  getLevel = function (logLevel) {
      return this.logLevel;
  }

• example usage

  ...
  */
  function encodeArticle(pages, article) {
  var articlePath = article.getPath();
  
  return {
      path: articlePath,
      title: article.getTitle(),
      level: article.getLevel(),
      exists: (articlePath && pages.has(articlePath)),
      external: article.isExternal()
  };
  }
  
  /**
  this.navigation is a deprecated property from GitBook v2
  ...

function gitbook.logger.prototype.log (level)

• description and source-code

  log = function (level) {
      if (level < this.logLevel) return;
  
      var levelKey = LEVELS.findKey(function(v) {
          return v === level;
      });
      var args = Array.prototype.slice.apply(arguments, [1]);
      var msg = this.format.apply(this, args);
  
      if (this.lastChar == '\n') {
          msg = COLORS.get(levelKey)(levelKey.toLowerCase()+':')+' '+msg;
      }
  
      return this.write(msg);
  }

• example usage

  ...
  
  
  #! /usr/bin/env node
  /* eslint-disable no-console */
  
  var color = require('bash-color');
  
  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"'
  ;));
  ...

function gitbook.logger.prototype.logLn ()

• description and source-code

  logLn = function () {
      if (this.lastChar != '\n') this.write('\n');
  
      var args = Array.prototype.slice.apply(arguments);
      args.push('\n');
      return this.log.apply(this, args);
  }

• example usage

  ...
  /**
  Log a confirmation [OK]
  */
  Logger.prototype.ok = function(level) {
  var args = Array.prototype.slice.apply(arguments, [1]);
  var msg = this.format.apply(this, args);
  if (arguments.length > 1) {
      this.logLn(level, color.green('>> ') + msg.trim().replace(/\n
  /g, color.green('\n>> ')));
  } else {
      this.log(level, color.green('OK'), '\n');
  }
  };
  
  /**
  Log a "FAIL"
  ...

function gitbook.logger.prototype.ok (level)

• description and source-code

  ok = function (level) {
      var args = Array.prototype.slice.apply(arguments, [1]);
      var msg = this.format.apply(this, args);
      if (arguments.length > 1) {
          this.logLn(level, color.green('>> ') + msg.trim().replace(/\n/g, color.green('\n>> ')));
      } else {
          this.log(level, color.green('OK'), '\n');
      }
  }

• example usage

  ...
                          outputFile
                      ).thenResolve(1);
                  }
              })
  
              // Log end
              .then(function(count) {
                  logger.info.ok(count + ' file(s) generated');
  
                  logger.debug('cleaning up... ');
                  return logger.debug.promise(fs.rmDir(outputFolder));
              });
          }
      };
  };
  ...

function gitbook.logger.prototype.promise (level, p)

• description and source-code

  promise = function (level, p) {
      var that = this;
  
      return p.
      then(function(st) {
          that.ok(level);
          return st;
      }, function(err) {
          that.fail(level);
          throw err;
      });
  }

• example usage

  ...
              })
  
              // Log end
              .then(function(count) {
                  logger.info.ok(count + ' file(s) generated');
  
                  logger.debug('cleaning up... ');
                  return logger.debug.promise(fs.rmDir(outputFolder));
              });
          }
      };
  };
  ...

function gitbook.logger.prototype.setLevel (logLevel)

• description and source-code

  setLevel = function (logLevel) {
      if (is.string(logLevel)) {
          logLevel = logLevel.toUpperCase();
          logLevel = LEVELS.get(logLevel);
      }
  
      this.logLevel = logLevel;
  }

• example usage

  ...
  /**
  Change log level
  
  @param {String} level
  @return {Book}
  */
  Book.prototype.setLogLevel = function(level) {
  this.getLogger().setLevel(level);
  return this;
  };
  
  /**
  Create a book using a filesystem
  
  @param {FS} fs
  ...

function gitbook.logger.prototype.write (msg)

• description and source-code

  write = function (msg) {
      msg = msg.toString();
      this.lastChar = msg[msg.length - 1];
      return this._write(msg);
  }

• example usage

  ...
  });
  
  function Logger(write, logLevel) {
  if (!(this instanceof Logger)) return new Logger(write, logLevel);
  
  this._write = write || function(msg) {
      if(process.stdout) {
          process.stdout.write(msg);
      }
  };
  this.lastChar = '\n';
  
  this.setLevel(logLevel || 'info');
  
  // Create easy-to-use method like "logger.debug.ln('....')"
  ...

function gitbook.logger.prototype.writeLn (msg)

• description and source-code

  writeLn = function (msg) {
      return this.write((msg || '')+'\n');
  }

• example usage

  n/a

module gitbook.output

function gitbook.output (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

module gitbook.output.prototype

function gitbook.output.prototype.constructor (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.output.prototype.getAssets ()

• description and source-code

  getAssets = function () {
      return this.get('assets');
  }

• example usage

  ...
  Output all assets using a generator
  
  @param {Generator} generator
  @param {Output} output
  @return {Promise<Output>}
  */
  function generateAssets(generator, output) {
  var assets = output.getAssets();
  var logger = output.getLogger();
  
  // Is generator ignoring assets?
  if (!generator.onAsset) {
      return Promise(output);
  }
  ...

function gitbook.output.prototype.getBook ()

• description and source-code

  getBook = function () {
      return this.get('book');
  }

• example usage

  ...
  Only the configuration can be edited by plugin's hooks
  
  @param {Output} output
  @param {Object} result: result from API
  @return {Output}
  */
  function decodeGlobal(output, result) {
  var book = output.getBook();
  var config = book.getConfig();
  
  // Update config
  config = decodeConfig(config, result.config);
  book = book.set('config', config);
  
  return output.set('book', book);
  ...

function gitbook.output.prototype.getGenerator ()

• description and source-code

  getGenerator = function () {
      return this.get('generator');
  }

• example usage

  ...
          }
      };
  
      deprecate.field(output, 'config.options', result, 'options',
          result.values, '"config.options" property is deprecated, use "config.get(key)" instead');
  
      deprecate.field(output, 'config.options.generator', result.values, 'generator',
          output.getGenerator(), '"options.generator" property is deprecated
  , use "output.name" instead');
  
      deprecate.field(output, 'config.options.generator', result.values, 'output',
          output.getRoot(), '"options.output" property is deprecated, use "output.root()" instead');
  
      return result;
  }
  ...

function gitbook.output.prototype.getLogger ()

• description and source-code

  getLogger = function () {
      return this.getBook().getLogger();
  }

• example usage

  ...
      var readme = Readme.create(readmeFile);
      return book.setReadme(readme);
  });
      })
      .then(Parse.parseSummary)
  
      .then(function(book) {
  var logger = book.getLogger();
  var summary = book.getSummary();
  var summaryFile = summary.getFile();
  var summaryFilename = summaryFile.getPath() || ('SUMMARY' + extension);
  
  var articles = summary.getArticlesAsList();
  
  // Write pages
  ...

function gitbook.output.prototype.getOptions ()

• description and source-code

  getOptions = function () {
      return this.get('options');
  }

• example usage

  ...
   *
   * @param {Output}
   * @return {Object}
   */
  function encodeOutputToJson(output) {
  var book = output.getBook();
  var generator = output.getGenerator();
  var options = output.getOptions();
  
  var result = encodeBook(book);
  
  result.output = {
      name: generator
  };
  ...

function gitbook.output.prototype.getPage (filePath)

• description and source-code

  getPage = function (filePath) {
      filePath = LocationUtils.normalize(filePath);
  
      var pages = this.getPages();
      return pages.get(filePath);
  }

• example usage

  ...
  /**
      Resolve a page by it path
  
      @param {String} filePath
      @return {String}
  */
  getPageByPath: function(filePath) {
      var page = output.getPage(filePath);
      if (!page) return undefined;
  
      return encodePage(output, page);
  },
  
  /**
      Render a block of text (markdown/asciidoc)
  ...

function gitbook.output.prototype.getPages ()

• description and source-code

  getPages = function () {
      return this.get('pages');
  }

• example usage

  ...
  this.navigation is a deprecated property from GitBook v2
  
  @param {Output}
  @return {Object}
  */
  function encodeNavigation(output) {
  var book = output.getBook();
  var pages = output.getPages();
  var summary = book.getSummary();
  var articles = summary.getArticlesAsList();
  
  
  var navigation = articles
      .map(function(article, i) {
          var ref = article.getRef();
  ...

function gitbook.output.prototype.getPlugins ()

• description and source-code

  getPlugins = function () {
      return this.get('plugins');
  }

• example usage

  ...
  @return {Object}
  */
  function encodeGlobal(output) {
  var book = output.getBook();
  var bookFS = book.getContentFS();
  var logger = output.getLogger();
  var outputFolder = output.getRoot();
  var plugins = output.getPlugins();
  var blocks = Plugins.listBlocks(plugins);
  
  var result = {
      log: logger,
      config: encodeConfig(output, book.getConfig()),
      summary: encodeSummary(output, book.getSummary()),
  ...

function gitbook.output.prototype.getRoot ()

• description and source-code

  getRoot = function () {
      return this.getOptions().get('root');
  }

• example usage

  ...
      deprecate.field(output, 'config.options', result, 'options',
          result.values, '"config.options" property is deprecated, use "config.get(key)" instead');
  
      deprecate.field(output, 'config.options.generator', result.values, 'generator',
          output.getGenerator(), '"options.generator" property is deprecated, use "output.name" instead&#
  x27;);
  
      deprecate.field(output, 'config.options.generator', result.values, 'output',
          output.getRoot(), '"options.output" property is deprecated, use
   "output.root()" instead');
  
      return result;
  }
  
  module.exports = encodeConfig;
  ...

function gitbook.output.prototype.getState ()

• description and source-code

  getState = function () {
      return this.get('state');
  }

• example usage

  ...
      return;
  }
  
  var logger = book.getLogger();
  var books = book.getBooks();
  var outputRoot = output.getRoot();
  var plugins = output.getPlugins();
  var state = output.getState();
  var options = output.getOptions();
  
  return Promise.forEach(books, function(langBook) {
      // Inherits plugins list, options and state
      var langOptions = options.set('root', path.join(outputRoot, langBook.getLanguage()));
      var langOutput = new Output({
          book:       langBook,
  ...

function gitbook.output.prototype.setOptions (newOptions)

• description and source-code

  setOptions = function (newOptions) {
      return this.set('options', newOptions);
  }

• example usage

  n/a

function gitbook.output.prototype.setState (newState)

• description and source-code

  setState = function (newState) {
      return this.set('state', newState);
  }

• example usage

  n/a

module gitbook.parse

function gitbook.parse.exec (args, kwargs)

• description and source-code

  exec = function (args, kwargs) {
      var book = getBook(args, kwargs);
      var logger = book.getLogger();
  
      return Parse.parseBook(book)
      .then(function(resultBook) {
          var rootFolder = book.getRoot();
          var contentFolder = book.getContentRoot();
  
          logger.info.ln('Book located in:', rootFolder);
          if (contentFolder != rootFolder) {
              logger.info.ln('Content located in:', contentFolder);
          }
  
          if (resultBook.isMultilingual()) {
              printMultingualBook(resultBook);
          } else {
              printBook(resultBook);
          }
      });
  }

• example usage

  ...
  @param {String} command
  @param {Object} options
  @return {Promise}
  */
  function exec(command, options) {
  var d = Promise.defer();
  
  var child = childProcess.exec(command, options, function(err, stdout, stderr) {
      if (!err) {
          return d.resolve();
      }
  
      err.message = stdout.toString('utf8') + stderr.toString('utf8');
      d.reject(err);
  });
  ...

module gitbook.parser

function gitbook.parser (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.parser.create (name, extensions, module)

• description and source-code

  create = function (name, extensions, module) {
      return new Parser({
          name: name,
          extensions: Immutable.List(extensions),
          readme:         module.readme,
          langs:          module.langs,
          summary:        module.summary,
          glossary:       module.glossary,
          page:           module.page,
          inline:         module.inline
      });
  }

• example usage

  ...
      var book = Book.createForFS(fs);
  
      return Parse.parseReadme(book)
  
      // Setup default readme if doesn't found one
      .fail(function() {
          var readmeFile = File.createWithFilepath('README' + extension);
          var readme = Readme.create(readmeFile);
          return book.setReadme(readme);
      });
  })
  .then(Parse.parseSummary)
  
  .then(function(book) {
      var logger = book.getLogger();
  ...

module gitbook.parser.prototype

function gitbook.parser.prototype.constructor (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.parser.prototype.getExtensions ()

• description and source-code

  getExtensions = function () {
      return this.get('extensions');
  }

• example usage

  ...
  function getParserForFile(filename) {
  return getParserByExt(path.extname(filename));
  }
  
  // List all parsable extensions
  var extensions = parsers
  .map(function(parser) {
      return parser.getExtensions();
  })
  .flatten();
  
  module.exports = {
  extensions: extensions,
  get: getParser,
  getByExt: getParserByExt,
  ...

function gitbook.parser.prototype.getName ()

• description and source-code

  getName = function () {
      return this.get('name');
  }

• example usage

  ...
  * Return a specific parser by its name
  *
  * @param {String} name
  * @return {Parser|undefined}
  */
  function getParser(name) {
     return parsers.find(function(parser) {
         return parser.getName() === name;
     });
  }
  
  /**
  * Return a specific parser according to an extension
  *
  * @param {String} ext
  ...

function gitbook.parser.prototype.matchExtension (ext)

• description and source-code

  matchExtension = function (ext) {
      var exts = this.getExtensions();
      return exts.includes(ext.toLowerCase());
  }

• example usage

  ...
  * Return a specific parser according to an extension
  *
  * @param {String} ext
  * @return {Parser|undefined}
  */
  function getParserByExt(ext) {
     return parsers.find(function(parser) {
         return parser.matchExtension(ext);
     });
  }
  
  /**
  * Return parser for a file
  *
  * @param {String} ext
  ...

function gitbook.parser.prototype.parseGlossary (content)

• description and source-code

  parseGlossary = function (content) {
      var glossary = this.get('glossary');
      return Promise(glossary(content));
  }

• example usage

  ...
  }
  
  return fs.readAsString(filepath)
  .then(function(content) {
      if (type === 'readme') {
          return parser.parseReadme(content);
      } else if (type === 'glossary') {
          return parser.parseGlossary(content);
      } else if (type === 'summary') {
          return parser.parseSummary(content);
      } else if (type === 'langs') {
          return parser.parseLanguages(content);
      } else {
          throw new Error('Parsing invalid type "' + type + '"');
      }
  ...

function gitbook.parser.prototype.parseInline (content)

• description and source-code

  parseInline = function (content) {
      var inline = this.get('inline');
      return Promise(inline(content));
  }

• example usage

  ...
      @param {String} type
      @param {String} text
      @return {Promise<String>}
  */
  renderInline: function(type, text) {
      var parser = parsers.get(type);
  
      return parser.parseInline(text)
          .get('content');
  },
  
  template: {
      /**
          Apply a templating block and returns its result
  ...

function gitbook.parser.prototype.parseLanguages (content)

• description and source-code

  parseLanguages = function (content) {
      var langs = this.get('langs');
      return Promise(langs(content));
  }

• example usage

  ...
      if (type === 'readme') {
          return parser.parseReadme(content);
      } else if (type === 'glossary') {
          return parser.parseGlossary(content);
      } else if (type === 'summary') {
          return parser.parseSummary(content);
      } else if (type === 'langs') {
          return parser.parseLanguages(content);
      } else {
          throw new Error('Parsing invalid type "' + type + '"');
      }
  })
  .then(function(result) {
      return [
          file,
  ...

function gitbook.parser.prototype.parsePage (content)

• description and source-code

  parsePage = function (content) {
      var page = this.get('page');
      return Promise(page(content));
  }

• example usage

  ...
  @param {String} type
  @param {String} text
  @return {Promise<String>}
          */
          renderBlock: function(type, text) {
  var parser = parsers.get(type);
  
  return parser.parsePage(text)
      .get('content');
          },
  
          /**
  Render an inline text (markdown/asciidoc)
  
  @param {String} type
  ...

function gitbook.parser.prototype.parseReadme (content)

• description and source-code

  parseReadme = function (content) {
      var readme = this.get('readme');
      return Promise(readme(content));
  }

• example usage

  ...
      return fs.mkdirp(rootFolder)
  
      // Parse the summary and readme
      .then(function() {
  var fs = createNodeFS(rootFolder);
  var book = Book.createForFS(fs);
  
  return Parse.parseReadme(book)
  
  // Setup default readme if doesn't found one
  .fail(function() {
      var readmeFile = File.createWithFilepath('README' + extension);
      var readme = Readme.create(readmeFile);
      return book.setReadme(readme);
  });
  ...

function gitbook.parser.prototype.parseSummary (content)

• description and source-code

  parseSummary = function (content) {
      var summary = this.get('summary');
      return Promise(summary(content));
  }

• example usage

  ...
  return fs.readAsString(filepath)
  .then(function(content) {
      if (type === 'readme') {
          return parser.parseReadme(content);
      } else if (type === 'glossary') {
          return parser.parseGlossary(content);
      } else if (type === 'summary') {
          return parser.parseSummary(content);
      } else if (type === 'langs') {
          return parser.parseLanguages(content);
      } else {
          throw new Error('Parsing invalid type "' + type + '"');
      }
  })
  .then(function(result) {
  ...

function gitbook.parser.prototype.preparePage (content)

• description and source-code

  preparePage = function (content) {
      var page = this.get('page');
      if (!page.prepare) {
          return Promise(content);
      }
  
      return Promise(page.prepare(content));
  }

• example usage

  ...
  }
  
  // Call hook "page:before"
  return callPageHook('page:before', output, resultPage)
  
  // Escape code blocks with raw tags
  .then(function(currentPage) {
      return parser.preparePage(currentPage.getContent());
  })
  
  // Render templating syntax
  .then(function(content) {
      var absoluteFilePath = path.join(book.getContentRoot(), filePath);
      return Templating.render(engine, absoluteFilePath, content, context);
  })
  ...

function gitbook.parser.prototype.renderGlossary (content)

• description and source-code

  renderGlossary = function (content) {
      var glossary = this.get('glossary');
      return Promise(glossary.toText(content));
  }

• example usage

  ...
  
  if (!parser) {
      throw error.FileNotParsableError({
          filename: file.getPath()
      });
  }
  
  return parser.renderGlossary(entries.toJS());
  };
  
  
  /**
  Add/Replace an entry to a glossary
  
  @param {Glossary} glossary
  ...

function gitbook.parser.prototype.renderLanguages (content)

• description and source-code

  renderLanguages = function (content) {
      var langs = this.get('langs');
      return Promise(langs.toText(content));
  }

• example usage

  n/a

function gitbook.parser.prototype.renderSummary (content)

• description and source-code

  renderSummary = function (content) {
      var summary = this.get('summary');
      return Promise(summary.toText(content));
  }

• example usage

  ...
  
  if (!parser) {
      throw error.FileNotParsableError({
          filename: file.getPath()
      });
  }
  
  return parser.renderSummary({
      parts: parts.toJS()
  });
  };
  
  /**
  Return all articles as a list
  ...

module gitbook.parsers

function gitbook.parsers.get (name)

• description and source-code

  function getParser(name) {
      return parsers.find(function(parser) {
          return parser.getName() === name;
      });
  }

• example usage

  ...
  
  #### Book instance
  
  The `Book` class is the central point of GitBook, it centralize all access read methods. This class is defined in [book.js](https
  ://github.com/GitbookIO/gitbook/blob/master/lib/book.js).
  
  ```js
  // Read configuration from book.json
  var value = book.config.get('title', 'Default Value');
  
  // Resolve a filename to an absolute path
  var filepath = book.resolve('README.md');
  
  // Render an inline markup string
  book.renderInline('markdown', 'This is **Markdown**')
  .then(function(str) { ... })
  ...

function gitbook.parsers.getByExt (ext)

• description and source-code

  function getParserByExt(ext) {
      return parsers.find(function(parser) {
          return parser.matchExtension(ext);
      });
  }

• example usage

  ...
  
  /**
  Return parser for this file
  
  @return {Parser}
  */
  File.prototype.getParser = function() {
  return parsers.getByExt(this.getExtension());
  };
  
  /**
  Create a file from stats informations
  
  @param {String} filepath
  @param {Object|fs.Stats} stat
  ...

function gitbook.parsers.getForFile (filename)

• description and source-code

  function getParserForFile(filename) {
      return getParserByExt(path.extname(filename));
  }

• example usage

  ...
   * to a file for a TemplatEngine
   *
   * @param {List<TemplateBlock>} engine
   * @param {String} filePath
   * @return {List<TemplateShortcut>}
   */
  function listShortcuts(blocks, filePath) {
  var parser = parsers.getForFile(filePath);
  
  if (!parser) {
      return Immutable.List();
  }
  
  return blocks
      .map(function(block) {
  ...

module gitbook.path

function gitbook.path.isInRoot (root, filename)

• description and source-code

  function isInRoot(root, filename) {
      root = path.normalize(root);
      filename = path.normalize(filename);
  
      if (root === '.') {
          return true;
      }
      if (root[root.length - 1] != path.sep) {
          root = root + path.sep;
      }
  
      return (filename.substr(0, root.length) === root);
  }

• example usage

  ...
  @param {String} filename
  @return {Boolean}
  */
  FS.prototype.isInScope = function(filename) {
  var rootPath = this.getRoot();
  filename = path.join(rootPath, filename);
  
  return PathUtil.isInRoot(rootPath, filename);
  };
  
  /**
  Resolve a file in this FS
  
  @param {String}
  @return {String}
  ...

function gitbook.path.isPureRelative (filename)

• description and source-code

  function isPureRelative(filename) {
      return (filename.indexOf('./') === 0 || filename.indexOf('../') === 0);
  }

• example usage

  ...
       * @param {String} to
       * @return {String|null}
       */
      resolve: function(from, to) {
  var searchPaths = this.searchPaths;
  
  // Relative template like "./test.html"
  if (PathUtils.isPureRelative(to) && from) {
      return path.resolve(path.dirname(from), to);
  }
  
  // Determine in which search folder we currently are
  var originalSearchPath = this.getSearchPath(from);
  var originalFilename = this.getTemplateName(from);
  ...

function gitbook.path.normalize (filename)

• description and source-code

  function normalizePath(filename) {
      return path.normalize(filename);
  }

• example usage

  ...
      @param {Map<String:String|Map>}
  */
  function createMockFS(files) {
      files = Immutable.fromJS(files);
      var mtime = new Date();
  
      function getFile(filePath) {
          var parts = path.normalize(filePath).split(path.sep);
          return parts.reduce(function(list, part, i) {
  if (!list) return null;
  
  var file;
  
  if (!part || part === '.') file = list;
  else file = list.get(part);
  ...

function gitbook.path.resolveInRoot (root)

• description and source-code

  function resolveInRoot(root) {
      var input, result;
      var args = Array.prototype.slice.call(arguments, 1);
  
      input = args
          .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);
          }, '');
  
      result = path.resolve(root, input);
  
      if (!isInRoot(root, result)) {
          throw new error.FileOutOfScopeError({
              filename: result,
              root: root
          });
      }
  
      return result;
  }

• example usage

  ...
  
      @param {String} fileName
      @return {Promise}
  */
  hasFile: function(fileName, content) {
      return Promise()
      .then(function() {
          var filePath = PathUtils.resolveInRoot(outputFolder, fileName);
  
          return fs.exists(filePath);
      });
  },
  
  /**
      Write a file to the output folder,
  ...

function gitbook.path.setExtension (filename, ext)

• description and source-code

  function setExtension(filename, ext) {
      return path.join(
          path.dirname(filename),
          path.basename(filename, path.extname(filename)) + ext
      );
  }

• example usage

  ...
  
      if (
          path.basename(filePath, path.extname(filePath)) == 'README' ||
          (fileReadme.exists() && filePath == fileReadme.getPath())
      ) {
          filePath = path.join(path.dirname(filePath), 'index' + OUTPUT_EXTENSION);
      } else {
          filePath = PathUtils.setExtension(filePath, OUTPUT_EXTENSION);
      }
  
      return LocationUtils.normalize(filePath);
  }
  
  module.exports = fileToOutput;
  ...

module gitbook.plugin

function gitbook.plugin (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.plugin.createFromDep (dep)

• description and source-code

  createFromDep = function (dep) {
      return new Plugin({
          name: dep.getName(),
          version: dep.getVersion()
      });
  }

• example usage

  n/a

function gitbook.plugin.createFromString (s)

• description and source-code

  createFromString = function (s) {
      var parts = s.split('@');
      var name = parts[0];
      var version = parts.slice(1).join('@');
  
      return new Plugin({
          name: name,
          version: version || DEFAULT_VERSION
      });
  }

• example usage

  ...
   * @param {Array}
   * @return {List<PluginDependency>}
   */
  PluginDependency.listFromArray = function(arr) {
  return Immutable.List(arr)
      .map(function(entry) {
          if (is.string(entry)) {
              return PluginDependency.createFromString(entry);
          } else {
              return PluginDependency({
                  name: entry.get('name'),
                  version: entry.get('version')
              });
          }
      })
  ...

function gitbook.plugin.nameToNpmID (s)

• description and source-code

  nameToNpmID = function (s) {
      return PREFIX + s;
  }

• example usage

  ...
  
  /**
  * Create a PluginDependency from a dependency of gitbook
  * @param {String} pluginName
  * @return {PluginDependency}
  */
  function createFromDependency(pluginName) {
     var npmID = PluginDependency.nameToNpmID(pluginName);
     var version = pkg.dependencies[npmID];
  
     return PluginDependency.create(pluginName, version);
  }
  
  /*
  * List of default plugins for all books,
  ...

module gitbook.plugin.prototype

function gitbook.plugin.prototype.constructor (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.plugin.prototype.getBlocks ()

• description and source-code

  getBlocks = function () {
      var blocks = this.getContent().get('blocks');
      blocks = blocks || Immutable.Map();
  
      return blocks
          .map(function(block, blockName) {
              return TemplateBlock.create(blockName, block);
          });
  }

• example usage

  ...
   */
  TemplateBlock.prototype.toNunjucksExt = function(mainContext, blocksOutput) {
      blocksOutput = blocksOutput || {};
  
      var that = this;
      var name = this.getName();
      var endTag = this.getEndTag();
      var blocks = this.getBlocks().toJS();
  
      function Ext() {
  this.tags = [name];
  
  this.parse = function(parser, nodes) {
      var lastBlockName = null;
      var lastBlockArgs = null;
  ...

function gitbook.plugin.prototype.getContent ()

• description and source-code

  getContent = function () {
      return this.get('content');
  }

• example usage

  ...
  
  @param {Output} output
  @param {Page} page: page instance to edit
  @param {Object} result: result from API
  @return {Page}
  */
  function decodePage(output, page, result) {
  var originalContent = page.getContent();
  
  // No returned value
  // Existing content will be used
  if (!result) {
      return page;
  }
  ...

function gitbook.plugin.prototype.getDepth ()

• description and source-code

  getDepth = function () {
      return this.get('depth');
  }

• example usage

  ...
      var article = summary.getByPath(file.getPath());
  
      var result = attributes.toJS();
  
      if (article) {
  result.title = article.getTitle();
  result.level = article.getLevel();
  result.depth = article.getDepth();
  
  var nextArticle = summary.getNextArticle(article);
  if (nextArticle) {
      result.next = encodeSummaryArticle(nextArticle);
  }
  
  var prevArticle = summary.getPrevArticle(article);
  ...

function gitbook.plugin.prototype.getFilters ()

• description and source-code

  getFilters = function () {
      return this.getContent().get('filters');
  }

• example usage

  ...
  Return a nunjucks environment from this configuration
  
  @return {Nunjucks.Environment}
  */
  TemplateEngine.prototype.toNunjucks = function(blocksOutput) {
  var loader = this.getLoader();
  var blocks = this.getBlocks();
  var filters = this.getFilters();
  var globals = this.getGlobals();
  var extensions = this.getExtensions();
  var context = this.getContext();
  
  var env = new nunjucks.Environment(
      loader,
      {
  ...

function gitbook.plugin.prototype.getHook (name)

• description and source-code

  getHook = function (name) {
      return this.getHooks().get(name);
  }

• example usage

  ...
  
  // Get the arguments
  Promise(getArgument(output))
  
  // Call the hooks in serie
  .then(function(arg) {
      return Promise.reduce(plugins, function(prev, plugin) {
          var hook = plugin.getHook(name);
          if (!hook) {
              return prev;
          }
  
          return hook.call(context, prev);
      }, arg);
  })
  ...

function gitbook.plugin.prototype.getHooks ()

• description and source-code

  getHooks = function () {
      return this.getContent().get('hooks') || Immutable.Map();
  }

• example usage

  ...
  
  /**
  * Return a specific hook
  * @param {String} name
  * @return {Function|undefined}
  */
  Plugin.prototype.getHook = function(name) {
     return this.getHooks().get(name);
  };
  
  /**
  * Create a plugin from a string
  * @param {String}
  * @return {Plugin}
  */
  ...

function gitbook.plugin.prototype.getName ()

• description and source-code

  getName = function () {
      return this.get('name');
  }

• example usage

  ...
  * Return a specific parser by its name
  *
  * @param {String} name
  * @return {Parser|undefined}
  */
  function getParser(name) {
     return parsers.find(function(parser) {
         return parser.getName() === name;
     });
  }
  
  /**
  * Return a specific parser according to an extension
  *
  * @param {String} ext
  ...

function gitbook.plugin.prototype.getNpmID ()

• description and source-code

  getNpmID = function () {
      return PluginDependency.nameToNpmID(this.getName());
  }

• example usage

  ...
      .then(function(version) {
  if (!version) {
      throw new Error('Found no satisfactory version for plugin "' + name + '" with requirement "'
  ; + requirement + '"');
  }
  
  logger.info.ln('install plugin "' + name +'" (' + requirement + ') from NPM with version'
  ;, version);
  return Promise.nfcall(npmi, {
      'name': plugin.getNpmID(),
      'version': version,
      'path': installFolder,
      'npmLoad': {
          'loglevel': 'silent',
          'loaded': true,
          'prefix': installFolder
      }
  ...

function gitbook.plugin.prototype.getPackage ()

• description and source-code

  getPackage = function () {
      return this.get('package');
  }

• example usage

  ...
  };
  
  /**
   * Check if a plugin is loaded
   * @return {Boolean}
   */
  Plugin.prototype.isLoaded = function() {
      return Boolean(this.getPackage().size > 0);
  };
  
  /**
   * Check if a plugin is a theme given its name
   * @return {Boolean}
   */
  Plugin.prototype.isTheme = function() {
  ...

function gitbook.plugin.prototype.getParent ()

• description and source-code

  getParent = function () {
      return this.get('parent');
  }

• example usage

  ...
          var plugins = requirements.reduce(function(result, dep) {
  var name = dep.getName();
  var installed = installedMap.get(name);
  
  if (installed) {
      var deps = installedMap
          .filter(function(plugin) {
              return plugin.getParent() === name;
          })
          .toArray();
  
      result = result.concat(deps);
      result.push(installed);
  } else {
      missing.push(name);
  ...

function gitbook.plugin.prototype.getPath ()

• description and source-code

  getPath = function () {
      return this.get('path');
  }

• example usage

  ...
      })
      .then(Parse.parseSummary)
  
      .then(function(book) {
  var logger = book.getLogger();
  var summary = book.getSummary();
  var summaryFile = summary.getFile();
  var summaryFilename = summaryFile.getPath() || ('SUMMARY' + extension);
  
  var articles = summary.getArticlesAsList();
  
  // Write pages
  return Promise.forEach(articles, function(article) {
      var articlePath = article.getPath();
      var filePath = articlePath? path.join(rootFolder, articlePath) : null;
  ...

function gitbook.plugin.prototype.getResources (type)

• description and source-code

  getResources = function (type) {
      if (type != 'website' && type != 'ebook') {
          throw new Error('Invalid assets type ' + type);
      }
  
      var content = this.getContent();
      return (content.get(type)
          || (type == 'website'? content.get('book') : null)
          || Immutable.Map());
  }

• example usage

  n/a

function gitbook.plugin.prototype.getVersion ()

• description and source-code

  getVersion = function () {
      return this.get('version');
  }

• example usage

  ...
  };
  
  /**
  * Is the plugin using a git dependency
  * @return {Boolean}
  */
  PluginDependency.prototype.isGitDependency = function() {
     return !semver.validRange(this.getVersion());
  };
  
  /**
  * Create a plugin with a name and a plugin
  * @param {String}
  * @return {Plugin|undefined}
  */
  ...

function gitbook.plugin.prototype.isLoaded ()

• description and source-code

  isLoaded = function () {
      return Boolean(this.getPackage().size > 0);
  }

• example usage

  ...
  @param {Plugin}
  @return {Promise<Plugin>}
  */
  function validatePlugin(plugin) {
  var packageInfos = plugin.getPackage();
  
  var isValid = (
      plugin.isLoaded() &&
      packageInfos &&
      packageInfos.get('name') &&
      packageInfos.get('engines') &&
      packageInfos.get('engines').get('gitbook')
  );
  
  if (!isValid) {
  ...

function gitbook.plugin.prototype.isTheme ()

• description and source-code

  isTheme = function () {
      var name = this.getName();
      return (name && name.indexOf(THEME_PREFIX) === 0);
  }

• example usage

  n/a

module gitbook.promise

function gitbook.promise (resolver)

• description and source-code

  function promise(resolver) {
      if (typeof resolver !== "function") {
          throw new TypeError("resolver must be a function.");
      }
      var deferred = defer();
      try {
          resolver(deferred.resolve, deferred.reject, deferred.notify);
      } catch (reason) {
          deferred.reject(reason);
      }
      return deferred.promise;
  }

• example usage

  ...
              })
  
              // Log end
              .then(function(count) {
                  logger.info.ok(count + ' file(s) generated');
  
                  logger.debug('cleaning up... ');
                  return logger.debug.promise(fs.rmDir(outputFolder));
              });
          }
      };
  };
  ...

function gitbook.promise.Promise (resolver)

• description and source-code

  function promise(resolver) {
      if (typeof resolver !== "function") {
          throw new TypeError("resolver must be a function.");
      }
      var deferred = defer();
      try {
          resolver(deferred.resolve, deferred.reject, deferred.notify);
      } catch (reason) {
          deferred.reject(reason);
      }
      return deferred.promise;
  }

• example usage

  n/a

function gitbook.promise.all (promises)

• description and source-code

  function all(promises) {
      return when(promises, function (promises) {
          var pendingCount = 0;
          var deferred = defer();
          array_reduce(promises, function (undefined, promise, index) {
              var snapshot;
              if (
                  isPromise(promise) &&
                  (snapshot = promise.inspect()).state === "fulfilled"
              ) {
                  promises[index] = snapshot.value;
              } else {
                  ++pendingCount;
                  when(
                      promise,
                      function (value) {
                          promises[index] = value;
                          if (--pendingCount === 0) {
                              deferred.resolve(promises);
                          }
                      },
                      deferred.reject,
                      function (progress) {
                          deferred.notify({ index: index, value: progress });
                      }
                  );
              }
          }, void 0);
          if (pendingCount === 0) {
              deferred.resolve(promises);
          }
          return deferred.promise;
      });
  }

• example usage

  ...
   * @param {Book}
   * @return {Promise<OrderedMap<String:Plugin>>}
   */
  function findForBook(book) {
      return timing.measure(
  'plugins.findForBook',
  
  Promise.all([
      findInstalled(locateRootFolder()),
      findInstalled(book.getRoot())
  ])
  
  // Merge all plugins
  .then(function(results) {
      return Immutable.List(results)
  ...

function gitbook.promise.allResolved ()

• description and source-code

  allResolved = function () {
      if (typeof console !== "undefined" &&
          typeof console.warn === "function") {
          console.warn(name + " is deprecated, use " + alternative +
                       " instead.", new Error("").stack);
      }
      return callback.apply(callback, arguments);
  }

• example usage

  n/a

function gitbook.promise.allSettled (promises)

• description and source-code

  function allSettled(promises) {
      return Q(promises).allSettled();
  }

• example usage

  n/a

function gitbook.promise.any (promises)

• description and source-code

  function any(promises) {
      if (promises.length === 0) {
          return Q.resolve();
      }
  
      var deferred = Q.defer();
      var pendingCount = 0;
      array_reduce(promises, function (prev, current, index) {
          var promise = promises[index];
  
          pendingCount++;
  
          when(promise, onFulfilled, onRejected, onProgress);
          function onFulfilled(result) {
              deferred.resolve(result);
          }
          function onRejected() {
              pendingCount--;
              if (pendingCount === 0) {
                  deferred.reject(new Error(
                      "Can't get fulfillment value from any promise, all " +
                      "promises were rejected."
                  ));
              }
          }
          function onProgress(progress) {
              deferred.notify({
                  index: index,
                  value: progress
              });
          }
      }, undefined);
  
      return deferred.promise;
  }

• example usage

  n/a

function gitbook.promise.async (makeGenerator)

• description and source-code

  function async(makeGenerator) {
      return function () {
          // when verb is "send", arg is a value
          // when verb is "throw", arg is an exception
          function continuer(verb, arg) {
              var result;
  
              // Until V8 3.19 / Chromium 29 is released, SpiderMonkey is the only
              // engine that has a deployed base of browsers that support generators.
              // However, SM's generators use the Python-inspired semantics of
              // outdated ES6 drafts.  We would like to support ES6, but we'd also
              // like to make it possible to use generators in deployed browsers, so
              // we also support Python-style generators.  At some point we can remove
              // this block.
  
              if (typeof StopIteration === "undefined") {
                  // ES6 Generators
                  try {
                      result = generator[verb](arg);
                  } catch (exception) {
                      return reject(exception);
                  }
                  if (result.done) {
                      return Q(result.value);
                  } else {
                      return when(result.value, callback, errback);
                  }
              } else {
                  // SpiderMonkey Generators
                  // FIXME: Remove this case when SM does ES6 generators.
                  try {
                      result = generator[verb](arg);
                  } catch (exception) {
                      if (isStopIteration(exception)) {
                          return Q(exception.value);
                      } else {
                          return reject(exception);
                      }
                  }
                  return when(result, callback, errback);
              }
          }
          var generator = makeGenerator.apply(this, arguments);
          var callback = continuer.bind(continuer, "next");
          var errback = continuer.bind(continuer, "throw");
          return callback();
      };
  }

• example usage

  n/a

function gitbook.promise.catch (object, rejected)

• description and source-code

  catch = function (object, rejected) {
      return Q(object).then(void 0, rejected);
  }

• example usage

  n/a

function gitbook.promise.defer ()

• description and source-code

  function defer() {
      // if "messages" is an "Array", that indicates that the promise has not yet
      // been resolved.  If it is "undefined", it has been resolved.  Each
      // element of the messages array is itself an array of complete arguments to
      // forward to the resolved promise.  We coerce the resolution value to a
      // promise using the `resolve` function because it handles both fully
      // non-thenable values and other thenables gracefully.
      var messages = [], progressListeners = [], resolvedPromise;
  
      var deferred = object_create(defer.prototype);
      var promise = object_create(Promise.prototype);
  
      promise.promiseDispatch = function (resolve, op, operands) {
          var args = array_slice(arguments);
          if (messages) {
              messages.push(args);
              if (op === "when" && operands[1]) { // progress operand
                  progressListeners.push(operands[1]);
              }
          } else {
              Q.nextTick(function () {
                  resolvedPromise.promiseDispatch.apply(resolvedPromise, args);
              });
          }
      };
  
      // XXX deprecated
      promise.valueOf = function () {
          if (messages) {
              return promise;
          }
          var nearerValue = nearer(resolvedPromise);
          if (isPromise(nearerValue)) {
              resolvedPromise = nearerValue; // shorten chain
          }
          return nearerValue;
      };
  
      promise.inspect = function () {
          if (!resolvedPromise) {
              return { state: "pending" };
          }
          return resolvedPromise.inspect();
      };
  
      if (Q.longStackSupport && hasStacks) {
          try {
              throw new Error();
          } catch (e) {
              // NOTE: don't try to use `Error.captureStackTrace` or transfer the
              // accessor around; that causes memory leaks as per GH-111. Just
              // reify the stack trace as a string ASAP.
              //
              // At the same time, cut off the first line; it's always just
              // "[object Promise]\n", as per the `toString`.
              promise.stack = e.stack.substring(e.stack.indexOf("\n") + 1);
          }
      }
  
      // NOTE: we do the checks for `resolvedPromise` in each method, instead of
      // consolidating them into `become`, since otherwise we'd create new
      // promises with the lines `become(whatever(value))`. See e.g. GH-252.
  
      function become(newPromise) {
          resolvedPromise = newPromise;
          promise.source = newPromise;
  
          array_reduce(messages, function (undefined, message) {
              Q.nextTick(function () {
                  newPromise.promiseDispatch.apply(newPromise, message);
              });
          }, void 0);
  
          messages = void 0;
          progressListeners = void 0;
      }
  
      deferred.promise = promise;
      deferred.resolve = function (value) {
          if (resolvedPromise) {
              return;
          }
  
          become(Q(value));
      };
  
      deferred.fulfill = function (value) {
          if (resolvedPromise) {
              return;
          }
  
          become(fulfill(value));
      };
      deferred.reject = function (reason) {
          if (resolvedPromise) {
              return;
          }
  
          become(reject(reason));
      };
      deferred.notify = function (progress) {
          if (resolvedPromise) {
              return;
          }
  
          array_reduce(progressListeners, function (undefined, progressListener) {
              Q.nextTick(function () {
                  progressListener(progress);
              });
          }, void 0);
      };
  
      return deferred;
  }

• example usage

  ...
  var getOutputFolder = require('./getOutputFolder');
  var Server = require('./server');
  var watch = require('./watch');
  
  var server, lrServer, lrPath;
  
  function waitForCtrlC() {
      var d = Promise.defer();
  
      process.on('SIGINT', function() {
          d.resolve();
      });
  
      return d.promise;
  }
  ...

function gitbook.promise.del (object, key)

• description and source-code

  del = function (object, key) {
      return Q(object).dispatch("delete", [key]);
  }

• example usage

  n/a

function gitbook.promise.delay (object, timeout)

• description and source-code

  delay = function (object, timeout) {
      if (timeout === void 0) {
          timeout = object;
          object = void 0;
      }
      return Q(object).delay(timeout);
  }

• example usage

  n/a

function gitbook.promise.delete (object, key)

• description and source-code

  delete = function (object, key) {
      return Q(object).dispatch("delete", [key]);
  }

• example usage

  n/a

function gitbook.promise.denodeify (callback)

• description and source-code

  denodeify = function (callback) {
      var baseArgs = array_slice(arguments, 1);
      return function () {
          var nodeArgs = baseArgs.concat(array_slice(arguments));
          var deferred = defer();
          nodeArgs.push(deferred.makeNodeResolver());
          Q(callback).fapply(nodeArgs).fail(deferred.reject);
          return deferred.promise;
      };
  }

• example usage

  n/a

function gitbook.promise.dispatch (object, op, args)

• description and source-code

  function dispatch(object, op, args) {
      return Q(object).dispatch(op, args);
  }

• example usage

  n/a

function gitbook.promise.done (object, fulfilled, rejected, progress)

• description and source-code

  done = function (object, fulfilled, rejected, progress) {
      return Q(object).done(fulfilled, rejected, progress);
  }

• example usage

  n/a

function gitbook.promise.fail (object, rejected)

• description and source-code

  fail = function (object, rejected) {
      return Q(object).then(void 0, rejected);
  }

• example usage

  ...
  .then(function() {
      var fs = createNodeFS(rootFolder);
      var book = Book.createForFS(fs);
  
      return Parse.parseReadme(book)
  
      // Setup default readme if doesn't found one
      .fail(function() {
          var readmeFile = File.createWithFilepath('README' + extension);
          var readme = Readme.create(readmeFile);
          return book.setReadme(readme);
      });
  })
  .then(Parse.parseSummary)
  ...

function gitbook.promise.fapply (object, args)

• description and source-code

  fapply = function (object, args) {
      return Q(object).dispatch("apply", [void 0, args]);
  }

• example usage

  n/a

function gitbook.promise.fbind (object)

• description and source-code

  fbind = function (object) {
      var promise = Q(object);
      var args = array_slice(arguments, 1);
      return function fbound() {
          return promise.dispatch("apply", [
              this,
              args.concat(array_slice(arguments))
          ]);
      };
  }

• example usage

  n/a

function gitbook.promise.fcall (object)

• description and source-code

  fcall = function (object) {
      return Q(object).dispatch("apply", [void 0, array_slice(arguments, 1)]);
  }

• example usage

  n/a

function gitbook.promise.fin (object, callback)

• description and source-code

  fin = function (object, callback) {
      return Q(object)["finally"](callback);
  }

• example usage

  ...
  
          return Parse.parseBook(book)
          .then(function(resultBook) {
              return Output.generate(Generator, resultBook, {
                  root: outputFolder
              });
          })
          .fin(function() {
              if (kwargs.timing) timing.dump(book.getLogger());
          });
      }
  };
  ...

function gitbook.promise.finally (object, callback)

• description and source-code

  finally = function (object, callback) {
      return Q(object)["finally"](callback);
  }

• example usage

  n/a

function gitbook.promise.forEach (arr, iter)

• description and source-code

  function forEach(arr, iter) {
      return reduce(arr, function(val, el, key) {
          return iter(el, key);
      });
  }

• example usage

  ...
          var summary = book.getSummary();
          var summaryFile = summary.getFile();
          var summaryFilename = summaryFile.getPath() || ('SUMMARY' + extension);
  
          var articles = summary.getArticlesAsList();
  
          // Write pages
          return Promise.forEach(articles, function(article) {
  var articlePath = article.getPath();
  var filePath = articlePath? path.join(rootFolder, articlePath) : null;
  if (!filePath) {
      return;
  }
  
  return fs.assertFile(filePath, function() {
  ...

function gitbook.promise.fulfill (value)

• description and source-code

  function fulfill(value) {
      return Promise({
          "when": function () {
              return value;
          },
          "get": function (name) {
              return value[name];
          },
          "set": function (name, rhs) {
              value[name] = rhs;
          },
          "delete": function (name) {
              delete value[name];
          },
          "post": function (name, args) {
              // Mark Miller proposes that post with no name should apply a
              // promised function.
              if (name === null || name === void 0) {
                  return value.apply(void 0, args);
              } else {
                  return value[name].apply(value, args);
              }
          },
          "apply": function (thisp, args) {
              return value.apply(thisp, args);
          },
          "keys": function () {
              return object_keys(value);
          }
      }, void 0, function inspect() {
          return { state: "fulfilled", value: value };
      });
  }

• example usage

  n/a

function gitbook.promise.get (object, key)

• description and source-code

  get = function (object, key) {
      return Q(object).dispatch("get", [key]);
  }

• example usage

  ...
  
  #### Book instance
  
  The `Book` class is the central point of GitBook, it centralize all access read methods. This class is defined in [book.js](https
  ://github.com/GitbookIO/gitbook/blob/master/lib/book.js).
  
  ```js
  // Read configuration from book.json
  var value = book.config.get('title', 'Default Value');
  
  // Resolve a filename to an absolute path
  var filepath = book.resolve('README.md');
  
  // Render an inline markup string
  book.renderInline('markdown', 'This is **Markdown**')
  .then(function(str) { ... })
  ...

function gitbook.promise.getUnhandledReasons ()

• description and source-code

  getUnhandledReasons = function () {
      // Make a copy so that consumers can't interfere with our internal state.
      return unhandledReasons.slice();
  }

• example usage

  n/a

function gitbook.promise.invoke (object, name)

• description and source-code

  invoke = function (object, name) {
      return Q(object).dispatch("post", [name, array_slice(arguments, 2)]);
  }

• example usage

  n/a

function gitbook.promise.isFulfilled (object)

• description and source-code

  function isFulfilled(object) {
      return !isPromise(object) || object.inspect().state === "fulfilled";
  }

• example usage

  n/a

function gitbook.promise.isPending (object)

• description and source-code

  function isPending(object) {
      return isPromise(object) && object.inspect().state === "pending";
  }

• example usage

  n/a

function gitbook.promise.isPromise (object)

• description and source-code

  function isPromise(object) {
      return object instanceof Promise;
  }

• example usage

  n/a

function gitbook.promise.isPromiseAlike (object)

• description and source-code

  function isPromiseAlike(object) {
      return isObject(object) && typeof object.then === "function";
  }

• example usage

  ...
      inner = inner || {};
      inner.args = inner.args || [];
      inner.kwargs = inner.kwargs || {};
      inner.blocks = inner.blocks || [];
  
      var r = processFn.call(context, inner);
  
      if (Promise.isPromiseAlike(r)) {
          return r.then(this.normalizeBlockResult.bind(this));
      } else {
          return this.normalizeBlockResult(r);
      }
  };
  
  /**
  ...

function gitbook.promise.isRejected (object)

• description and source-code

  function isRejected(object) {
      return isPromise(object) && object.inspect().state === "rejected";
  }

• example usage

  n/a

function gitbook.promise.join (x, y)

• description and source-code

  join = function (x, y) {
      return Q(x).join(y);
  }

• example usage

  ...
          var summaryFilename = summaryFile.getPath() || ('SUMMARY' + extension);
  
          var articles = summary.getArticlesAsList();
  
          // Write pages
          return Promise.forEach(articles, function(article) {
  var articlePath = article.getPath();
  var filePath = articlePath? path.join(rootFolder, articlePath) : null;
  if (!filePath) {
      return;
  }
  
  return fs.assertFile(filePath, function() {
      return fs.ensureFile(filePath)
      .then(function() {
  ...

function gitbook.promise.keys (object)

• description and source-code

  keys = function (object) {
      return Q(object).dispatch("keys", []);
  }

• example usage

  n/a

function gitbook.promise.makePromise (descriptor, fallback, inspect)

• description and source-code

  function Promise(descriptor, fallback, inspect) {
      if (fallback === void 0) {
          fallback = function (op) {
              return reject(new Error(
                  "Promise does not support operation: " + op
              ));
          };
      }
      if (inspect === void 0) {
          inspect = function () {
              return {state: "unknown"};
          };
      }
  
      var promise = object_create(Promise.prototype);
  
      promise.promiseDispatch = function (resolve, op, args) {
          var result;
          try {
              if (descriptor[op]) {
                  result = descriptor[op].apply(promise, args);
              } else {
                  result = fallback.call(promise, op, args);
              }
          } catch (exception) {
              result = reject(exception);
          }
          if (resolve) {
              resolve(result);
          }
      };
  
      promise.inspect = inspect;
  
      // XXX deprecated `valueOf` and `exception` support
      if (inspect) {
          var inspected = inspect();
          if (inspected.state === "rejected") {
              promise.exception = inspected.reason;
          }
  
          promise.valueOf = function () {
              var inspected = inspect();
              if (inspected.state === "pending" ||
                  inspected.state === "rejected") {
                  return promise;
              }
              return inspected.value;
          };
      }
  
      return promise;
  }

• example usage

  n/a

function gitbook.promise.map (arr, iter)

• description and source-code

  function map(arr, iter) {
      if (Immutable.Map.isMap(arr)) {
          var type = 'Map';
          if (Immutable.OrderedMap.isOrderedMap(arr)) {
              type = 'OrderedMap';
          }
  
          return mapAsList(arr, function(value, key) {
              return Q(iter(value, key))
              .then(function(result) {
                  return [key, result];
              });
          })
          .then(function(result) {
              return Immutable[type](result);
          });
      } else {
          return mapAsList(arr, iter)
          .then(function(result) {
              return Immutable.List(result);
          });
      }
  }

• example usage

  ...
   */
  function getParserForFile(filename) {
  return getParserByExt(path.extname(filename));
  }
  
  // List all parsable extensions
  var extensions = parsers
  .map(function(parser) {
      return parser.getExtensions();
  })
  .flatten();
  
  module.exports = {
  extensions: extensions,
  get: getParser,
  ...

function gitbook.promise.mapply (object, name, args)

• description and source-code

  mapply = function (object, name, args) {
      return Q(object).dispatch("post", [name, args]);
  }

• example usage

  n/a

function gitbook.promise.master (object)

• description and source-code

  function master(object) {
      return Promise({
          "isDef": function () {}
      }, function fallback(op, args) {
          return dispatch(object, op, args);
      }, function () {
          return Q(object).inspect();
      });
  }

• example usage

  n/a

function gitbook.promise.mcall (object, name)

• description and source-code

  mcall = function (object, name) {
      return Q(object).dispatch("post", [name, array_slice(arguments, 2)]);
  }

• example usage

  n/a

function gitbook.promise.nbind (callback, thisp)

• description and source-code

  nbind = function (callback, thisp) {
      var baseArgs = array_slice(arguments, 2);
      return function () {
          var nodeArgs = baseArgs.concat(array_slice(arguments));
          var deferred = defer();
          nodeArgs.push(deferred.makeNodeResolver());
          function bound() {
              return callback.apply(thisp, arguments);
          }
          Q(bound).fapply(nodeArgs).fail(deferred.reject);
          return deferred.promise;
      };
  }

• example usage

  n/a

function gitbook.promise.nearer (value)

• description and source-code

  function nearer(value) {
      if (isPromise(value)) {
          var inspected = value.inspect();
          if (inspected.state === "fulfilled") {
              return inspected.value;
          }
      }
      return value;
  }

• example usage

  n/a

function gitbook.promise.nextTick (task)

• description and source-code

  nextTick = function (task) {
      tail = tail.next = {
          task: task,
          domain: isNodeJS && process.domain,
          next: null
      };
  
      if (!flushing) {
          flushing = true;
          requestTick();
      }
  }

• example usage

  n/a

function gitbook.promise.nfapply (callback, args)

• description and source-code

  nfapply = function (callback, args) {
      return Q(callback).nfapply(args);
  }

• example usage

  n/a

function gitbook.promise.nfbind (callback)

• description and source-code

  nfbind = function (callback) {
      var baseArgs = array_slice(arguments, 1);
      return function () {
          var nodeArgs = baseArgs.concat(array_slice(arguments));
          var deferred = defer();
          nodeArgs.push(deferred.makeNodeResolver());
          Q(callback).fapply(nodeArgs).fail(deferred.reject);
          return deferred.promise;
      };
  }

• example usage

  ...
      return Promise.nfcall(mkdirp, rootFolder);
  });
  }
  
  module.exports = {
  exists: fileExists,
  existsSync: fs.existsSync,
  mkdirp: Promise.nfbind(mkdirp),
  readFile: Promise.nfbind(fs.readFile),
  writeFile: Promise.nfbind(fs.writeFile),
  assertFile: assertFile,
  pickFile: pickFile,
  stat: Promise.nfbind(fs.stat),
  statSync: fs.statSync,
  readdir: Promise.nfbind(fs.readdir),
  ...

function gitbook.promise.nfcall (callback)

• description and source-code

  nfcall = function (callback) {
      var args = array_slice(arguments, 1);
      return Q(callback).nfapply(args);
  }

• example usage

  ...
  return Promise()
  .then(function() {
      if (!hasWatch || !hasLiveReloading) {
          return;
      }
  
      lrServer = tinylr({});
      return Promise.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('');
  
      });
  })
  ...

function gitbook.promise.ninvoke (object, name)

• description and source-code

  ninvoke = function (object, name) {
      var nodeArgs = array_slice(arguments, 2);
      var deferred = defer();
      nodeArgs.push(deferred.makeNodeResolver());
      Q(object).dispatch("post", [name, nodeArgs]).fail(deferred.reject);
      return deferred.promise;
  }

• example usage

  n/a

function gitbook.promise.nmapply (object, name, args)

• description and source-code

  nmapply = function (object, name, args) {
      return Q(object).npost(name, args);
  }

• example usage

  n/a

function gitbook.promise.nmcall (object, name)

• description and source-code

  nmcall = function (object, name) {
      var nodeArgs = array_slice(arguments, 2);
      var deferred = defer();
      nodeArgs.push(deferred.makeNodeResolver());
      Q(object).dispatch("post", [name, nodeArgs]).fail(deferred.reject);
      return deferred.promise;
  }

• example usage

  n/a

function gitbook.promise.noConflict ()

• description and source-code

  noConflict = function () {
      throw new Error("Q.noConflict only works when Q is used as a global");
  }

• example usage

  n/a

function gitbook.promise.nodeify (object, nodeback)

• description and source-code

  function nodeify(object, nodeback) {
      return Q(object).nodeify(nodeback);
  }

• example usage

  ...
                  }, mainContext || {});
  
                  return that.applyBlock(mainBlock, ctx);
              })
              .then(function(result) {
                  return that.blockResultToHtml(result, blocksOutput);
              })
              .nodeify(callback);
          };
      }
  
      return Ext;
  };
  
  /**
  ...

function gitbook.promise.npost (object, name, args)

• description and source-code

  npost = function (object, name, args) {
      return Q(object).npost(name, args);
  }

• example usage

  n/a

function gitbook.promise.nsend (object, name)

• description and source-code

  nsend = function (object, name) {
      var nodeArgs = array_slice(arguments, 2);
      var deferred = defer();
      nodeArgs.push(deferred.makeNodeResolver());
      Q(object).dispatch("post", [name, nodeArgs]).fail(deferred.reject);
      return deferred.promise;
  }

• example usage

  n/a

function gitbook.promise.passByCopy (object)

• description and source-code

  passByCopy = function (object) {
      //freeze(object);
      //passByCopies.set(object, true);
      return object;
  }

• example usage

  n/a

function gitbook.promise.post (object, name, args)

• description and source-code

  post = function (object, name, args) {
      return Q(object).dispatch("post", [name, args]);
  }

• example usage

  n/a

function gitbook.promise.progress (object, progressed)

• description and source-code

  function progress(object, progressed) {
      return Q(object).then(void 0, void 0, progressed);
  }

• example usage

  ...
      'ebook-convert',
      path.resolve(outputFolder, SUMMARY_FILE),
      path.resolve(outputFolder, 'index.' + format),
      command.optionsToShellArgs(options)
  ].join(' ');
  
  return command.exec(cmd)
  .progress(function(data) {
      logger.debug(data);
  })
  .fail(function(err) {
      if (err.code == 127) {
          throw error.RequireInstallError({
              cmd: 'ebook-convert',
              install: 'Install it from Calibre: https://calibre-ebook.com'
  ...

function gitbook.promise.promised (callback)

• description and source-code

  function promised(callback) {
      return function () {
          return spread([this, all(arguments)], function (self, args) {
              return callback.apply(self, args);
          });
      };
  }

• example usage

  n/a

function gitbook.promise.race (answerPs)

• description and source-code

  function race(answerPs) {
      return promise(function (resolve, reject) {
          // Switch to this once we can assume at least ES5
          // answerPs.forEach(function (answerP) {
          //     Q(answerP).then(resolve, reject);
          // });
          // Use this in the meantime
          for (var i = 0, len = answerPs.length; i < len; i++) {
              Q(answerPs[i]).then(resolve, reject);
          }
      });
  }

• example usage

  n/a

function gitbook.promise.reduce (arr, iter, base)

• description and source-code

  function reduce(arr, iter, base) {
      arr = Immutable.Iterable.isIterable(arr)? arr : Immutable.List(arr);
  
      return arr.reduce(function(prev, elem, key) {
          return prev
          .then(function(val) {
              return iter(val, elem, key);
          });
      }, Q(base));
  }

• example usage

  ...
  */
  function createMockFS(files) {
      files = Immutable.fromJS(files);
      var mtime = new Date();
  
      function getFile(filePath) {
          var parts = path.normalize(filePath).split(path.sep);
          return parts.reduce(function(list, part, i) {
  if (!list) return null;
  
  var file;
  
  if (!part || part === '.') file = list;
  else file = list.get(part);
  ...

function gitbook.promise.reject (reason)

• description and source-code

  function reject(reason) {
      var rejection = Promise({
          "when": function (rejected) {
              // note that the error has been handled
              if (rejected) {
                  untrackRejection(this);
              }
              return rejected ? rejected(reason) : this;
          }
      }, function fallback() {
          return this;
      }, function inspect() {
          return { state: "rejected", reason: reason };
      });
  
      // Note that the reason has not been handled.
      trackRejection(rejection, reason);
  
      return rejection;
  }

• example usage

  ...
  if (!this.isRunning()) return Promise();
  
  var d = Promise.defer();
  this.running.close(function(err) {
      that.running = null;
      that.emit('state', false);
  
      if (err) d.reject(err);
      else d.resolve();
  });
  
  for (var i = 0; i < this.sockets.length; i++) {
      this.sockets[i].destroy();
  }
  ...

function gitbook.promise.resetUnhandledRejections ()

• description and source-code

  function resetUnhandledRejections() {
      unhandledReasons.length = 0;
      unhandledRejections.length = 0;
  
      if (!trackUnhandledRejections) {
          trackUnhandledRejections = true;
      }
  }

• example usage

  n/a

function gitbook.promise.resolve (value)

• description and source-code

  function Q(value) {
      // If the object is already a Promise, return it directly.  This enables
      // the resolve function to both be used to created references from objects,
      // but to tolerably coerce non-promises to promises.
      if (value instanceof Promise) {
          return value;
      }
  
      // assimilate thenables
      if (isPromiseAlike(value)) {
          return coerce(value);
      } else {
          return fulfill(value);
      }
  }

• example usage

  ...
  The `Book` class is the central point of GitBook, it centralize all access read methods. This class is defined in [book.js](https
  ://github.com/GitbookIO/gitbook/blob/master/lib/book.js).
  
  ```js
  // Read configuration from book.json
  var value = book.config.get('title', 'Default Value');
  
  // Resolve a filename to an absolute path
  var filepath = book.resolve('README.md');
  
  // Render an inline markup string
  book.renderInline('markdown', 'This is **Markdown**')
      .then(function(str) { ... })
  
  // Render a markup string (block mode)
  book.renderBlock('markdown', '* This is **Markdown**')
  ...

function gitbook.promise.return (value)

• description and source-code

  function _return(value) {
      throw new QReturnValue(value);
  }

• example usage

  n/a

function gitbook.promise.send (object, name)

• description and source-code

  send = function (object, name) {
      return Q(object).dispatch("post", [name, array_slice(arguments, 2)]);
  }

• example usage

  n/a

function gitbook.promise.serie (arr, iter, base)

• description and source-code

  function serie(arr, iter, base) {
      return reduce(arr, function(before, item, key) {
          return Q(iter(item, key))
          .then(function(r) {
              before.push(r);
              return before;
          });
      }, []);
  }

• example usage

  ...
  }
  
  var fs = book.getFS();
  var ignore = book.getIgnore();
  
  ignore = ignore.add(DEFAULT_IGNORES);
  
  return Promise.serie(IGNORE_FILES, function(filename) {
      return fs.readAsString(filename)
      .then(function(content) {
          ignore = ignore.add(content.toString().split(/\r?\n/));
      }, function(err) {
          return Promise();
      });
  })
  ...

function gitbook.promise.set (object, key, value)

• description and source-code

  set = function (object, key, value) {
      return Q(object).dispatch("set", [key, value]);
  }

• example usage

  ...
  */
  function decodeGlobal(output, result) {
      var book = output.getBook();
      var config = book.getConfig();
  
      // Update config
      config = decodeConfig(config, result.config);
      book = book.set('config', config);
  
      return output.set('book', book);
  }
  
  module.exports = decodeGlobal;
  ...

function gitbook.promise.some (arr, iter)

• description and source-code

  function some(arr, iter) {
      arr = Immutable.List(arr);
  
      return arr.reduce(function(prev, elem, i) {
          return prev.then(function(val) {
              if (val) return val;
  
              return iter(elem, i);
          });
      }, Q());
  }

• example usage

  ...
      var ext = path.extname(filename);
      var basename = path.basename(filename, ext);
      var basedir = path.dirname(filename);
  
      // Ordered list of extensions to test
      var exts = parsers.extensions;
  
      return Promise.some(exts, function(ext) {
  var filepath = basename + ext;
  
  return fs.findFile(basedir, filepath)
  .then(function(found) {
      if (!found || book.isContentFileIgnored(found)) {
          return undefined;
      }
  ...

function gitbook.promise.spawn (makeGenerator)

• description and source-code

  function spawn(makeGenerator) {
      Q.done(Q.async(makeGenerator)());
  }

• example usage

  ...
  var fs = require('./fs');
  var error = require('./error');
  
  // Convert a svg file to a pmg
  function convertSVGToPNG(source, dest, options) {
  if (!fs.existsSync(source)) return Promise.reject(new error.FileNotFoundError({ filename: source }));
  
  return command.spawn('svgexport', [source, dest])
  .fail(function(err) {
      if (err.code == 'ENOENT') {
          err = error.RequireInstallError({
              cmd: 'svgexport',
              install: 'Install it using: "npm install svgexport -g"'
          });
      }
  ...

function gitbook.promise.spread (value, fulfilled, rejected)

• description and source-code

  function spread(value, fulfilled, rejected) {
      return Q(value).spread(fulfilled, rejected);
  }

• example usage

  ...
      @param {Book} book
      @return {Promise<Book>}
  */
  function parseGlossary(book) {
      var logger = book.getLogger();
  
      return parseStructureFile(book, 'glossary')
      .spread(function(file, entries) {
  if (!file) {
      return book;
  }
  
  logger.debug.ln('glossary index file found at', file.getPath());
  
  var glossary = Glossary.createFromEntries(file, entries);
  ...

function gitbook.promise.stopUnhandledRejectionTracking ()

• description and source-code

  stopUnhandledRejectionTracking = function () {
      resetUnhandledRejections();
      trackUnhandledRejections = false;
  }

• example usage

  n/a

function gitbook.promise.tap (promise, callback)

• description and source-code

  tap = function (promise, callback) {
      return Q(promise).tap(callback);
  }

• example usage

  ...
  
  return generator.onInit(output);
      })
  
      .then(generateAssets.bind(null, generator))
      .then(generatePages.bind(null, generator))
  
      .tap(function(output) {
  var book = output.getBook();
  
  if (!book.isMultilingual()) {
      return;
  }
  
  var logger = book.getLogger();
  ...

function gitbook.promise.thenReject (promise, reason)

• description and source-code

  thenReject = function (promise, reason) {
      return Q(promise).thenReject(reason);
  }

• example usage

  n/a

function gitbook.promise.thenResolve (promise, value)

• description and source-code

  thenResolve = function (promise, value) {
      return Q(promise).thenResolve(value);
  }

• example usage

  ...
              );
  
              return fs.copy(
                  path.resolve(outputFolder, langID, 'index' + extension),
                  langOutputFile
              );
          })
          .thenResolve(languages.getCount());
      } else {
          return fs.copy(
              path.resolve(outputFolder, 'index' + extension),
              outputFile
          ).thenResolve(1);
      }
  })
  ...

function gitbook.promise.timeout (object, ms, error)

• description and source-code

  timeout = function (object, ms, error) {
      return Q(object).timeout(ms, error);
  }

• example usage

  n/a

function gitbook.promise.try (object)

• description and source-code

  try = function (object) {
      return Q(object).dispatch("apply", [void 0, array_slice(arguments, 1)]);
  }

• example usage

  n/a

function gitbook.promise.when (value, fulfilled, rejected, progressed)

• description and source-code

  function when(value, fulfilled, rejected, progressed) {
      return Q(value).then(fulfilled, rejected, progressed);
  }

• example usage

  n/a

function gitbook.promise.wrapfn (func)

• description and source-code

  function wrap(func) {
      return function() {
          var args = Array.prototype.slice.call(arguments, 0);
  
          return Q()
          .then(function() {
              return func.apply(null, args);
          });
      };
  }

• example usage

  n/a

module gitbook.readme

function gitbook.readme (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.readme.create (file, def)

• description and source-code

  create = function (file, def) {
      def = def || {};
  
      return new Readme({
          file: file,
          title: def.title || '',
          description: def.description || ''
      });
  }

• example usage

  ...
      var book = Book.createForFS(fs);
  
      return Parse.parseReadme(book)
  
      // Setup default readme if doesn't found one
      .fail(function() {
          var readmeFile = File.createWithFilepath('README' + extension);
          var readme = Readme.create(readmeFile);
          return book.setReadme(readme);
      });
  })
  .then(Parse.parseSummary)
  
  .then(function(book) {
      var logger = book.getLogger();
  ...

module gitbook.readme.prototype

function gitbook.readme.prototype.constructor (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.readme.prototype.getDescription ()

• description and source-code

  getDescription = function () {
      return this.get('description');
  }

• example usage

  ...
      @param {GlossaryEntry}
      @return {Object}
  */
  function encodeGlossaryEntry(entry) {
      return {
          id: entry.getID(),
          name: entry.getName(),
          description: entry.getDescription()
      };
  }
  
  module.exports = encodeGlossaryEntry;
  ...

function gitbook.readme.prototype.getFile ()

• description and source-code

  getFile = function () {
      return this.get('file');
  }

• example usage

  ...
  });
      })
      .then(Parse.parseSummary)
  
      .then(function(book) {
  var logger = book.getLogger();
  var summary = book.getSummary();
  var summaryFile = summary.getFile();
  var summaryFilename = summaryFile.getPath() || ('SUMMARY' + extension);
  
  var articles = summary.getArticlesAsList();
  
  // Write pages
  return Promise.forEach(articles, function(article) {
      var articlePath = article.getPath();
  ...

function gitbook.readme.prototype.getTitle ()

• description and source-code

  getTitle = function () {
      return this.get('title');
  }

• example usage

  ...
          return;
      }
  
      return fs.assertFile(filePath, function() {
          return fs.ensureFile(filePath)
          .then(function() {
              logger.info.ln('create', article.getPath());
              return fs.writeFile(filePath, '# ' + article.getTitle() + '
  ;\n\n');
          });
      });
  })
  
  // Write summary
  .then(function() {
      var filePath = path.join(rootFolder, summaryFilename);
  ...

module gitbook.serve

function gitbook.serve.exec (args, kwargs)

• description and source-code

  exec = function (args, kwargs) {
      server = new Server();
      var hasWatch = kwargs['watch'];
      var hasLiveReloading = kwargs['live'];
  
      return Promise()
      .then(function() {
          if (!hasWatch || !hasLiveReloading) {
              return;
          }
  
          lrServer = tinylr({});
          return Promise.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('');
  
          });
      })
      .then(function() {
          return generateBook(args, kwargs);
      });
  }

• example usage

  ...
  @param {String} command
  @param {Object} options
  @return {Promise}
  */
  function exec(command, options) {
  var d = Promise.defer();
  
  var child = childProcess.exec(command, options, function(err, stdout, stderr) {
      if (!err) {
          return d.resolve();
      }
  
      err.message = stdout.toString('utf8') + stderr.toString('utf8');
      d.reject(err);
  });
  ...

module gitbook.server

function gitbook.server ()

• description and source-code

  function Server() {
      this.running = null;
      this.dir = null;
      this.port = 0;
      this.sockets = [];
  }

• example usage

  n/a

function gitbook.server.super_ ()

• description and source-code

  function EventEmitter() {
    EventEmitter.init.call(this);
  }

• example usage

  n/a

module gitbook.server.prototype

function gitbook.server.prototype.isRunning ()

• description and source-code

  isRunning = function () {
      return !!this.running;
  }

• example usage

  ...
  var browser = kwargs['browser'];
  
  var hasWatch = kwargs['watch'];
  var hasLiveReloading = kwargs['live'];
  var hasOpen = kwargs['open'];
  
  // Stop server if running
  if (server.isRunning()) console.log('Stopping server');
  
  return server.stop()
  .then(function() {
      return Parse.parseBook(book)
      .then(function(resultBook) {
          if (hasLiveReloading) {
              // Enable livereload plugin
  ...

function gitbook.server.prototype.start (dir, port)

• description and source-code

  start = function (dir, port) {
      var that = this, pre = Promise();
      port = port || 8004;
  
      if (that.isRunning()) pre = this.stop();
      return pre
      .then(function() {
          var d = Promise.defer();
  
          that.running = http.createServer(function(req, res){
              // Render error
              function error(err) {
                  res.statusCode = err.status || 500;
                  res.end(err.message);
              }
  
              // Redirect to directory's index.html
              function redirect() {
                  var resultURL = urlTransform(req.url, function(parsed) {
                      parsed.pathname += '/';
                      return parsed;
                  });
  
                  res.statusCode = 301;
                  res.setHeader('Location', resultURL);
                  res.end('Redirecting to ' + resultURL);
              }
  
              res.setHeader('X-Current-Location', req.url);
  
              // Send file
              send(req, url.parse(req.url).pathname, {
                  root: dir
              })
              .on('error', error)
              .on('directory', redirect)
              .pipe(res);
          });
  
          that.running.on('connection', function (socket) {
              that.sockets.push(socket);
              socket.setTimeout(4000);
              socket.on('close', function () {
                  that.sockets.splice(that.sockets.indexOf(socket), 1);
              });
          });
  
          that.running.listen(port, function(err) {
              if (err) return d.reject(err);
  
              that.port = port;
              that.dir = dir;
              that.emit('state', true);
              d.resolve();
          });
  
          return d.promise;
      });
  }

• example usage

  ...
          root: outputFolder
      });
  });
      })
      .then(function() {
  console.log();
  console.log('Starting server ...');
  return server.start(outputFolder, port);
      })
      .then(function() {
  console.log('Serving book on http://localhost:'+port);
  
  if (lrPath && hasLiveReloading) {
      // trigger livereload
      lrServer.changed({
  ...

function gitbook.server.prototype.stop ()

• description and source-code

  stop = function () {
      var that = this;
      if (!this.isRunning()) return Promise();
  
      var d = Promise.defer();
      this.running.close(function(err) {
          that.running = null;
          that.emit('state', false);
  
          if (err) d.reject(err);
          else d.resolve();
      });
  
      for (var i = 0; i < this.sockets.length; i++) {
          this.sockets[i].destroy();
      }
  
      return d.promise;
  }

• example usage

  ...
  var hasWatch = kwargs['watch'];
  var hasLiveReloading = kwargs['live'];
  var hasOpen = kwargs['open'];
  
  // Stop server if running
  if (server.isRunning()) console.log('Stopping server');
  
  return server.stop()
  .then(function() {
      return Parse.parseBook(book)
      .then(function(resultBook) {
          if (hasLiveReloading) {
              // Enable livereload plugin
              var config = resultBook.getConfig();
              config = ConfigModifier.addPlugin(config, 'livereload');
  ...

module gitbook.state

function gitbook.state (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

module gitbook.state.prototype

function gitbook.state.prototype.constructor (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.state.prototype.getI18n ()

• description and source-code

  getI18n = function () {
      return this.get('i18n');
  }

• example usage

  n/a

function gitbook.state.prototype.getResources ()

• description and source-code

  getResources = function () {
      return this.get('resources');
  }

• example usage

  n/a

module gitbook.summaryArticle

function gitbook.summaryArticle (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.summaryArticle.create (def, level)

• description and source-code

  create = function (def, level) {
      var articles = (def.articles || []).map(function(article, i) {
          if (article instanceof SummaryArticle) {
              return article;
          }
          return SummaryArticle.create(article, [level, i + 1].join('.'));
      });
  
      return new SummaryArticle({
          level: level,
          title: def.title,
          ref: def.ref || def.path || '',
          articles: Immutable.List(articles)
      });
  }

• example usage

  ...
      var book = Book.createForFS(fs);
  
      return Parse.parseReadme(book)
  
      // Setup default readme if doesn't found one
      .fail(function() {
          var readmeFile = File.createWithFilepath('README' + extension);
          var readme = Readme.create(readmeFile);
          return book.setReadme(readme);
      });
  })
  .then(Parse.parseSummary)
  
  .then(function(book) {
      var logger = book.getLogger();
  ...

function gitbook.summaryArticle.findArticle (base, iter)

• description and source-code

  findArticle = function (base, iter) {
      var articles = base.getArticles();
  
      return articles.reduce(function(result, article) {
          if (result) return result;
  
          if (iter(article)) {
              return article;
          }
  
          return SummaryArticle.findArticle(article, iter);
      }, null);
  }

• example usage

  ...
      return articles.reduce(function(result, article) {
          if (result) return result;
  
          if (iter(article)) {
              return article;
          }
  
          return SummaryArticle.findArticle(article, iter);
      }, null);
  };
  
  
  module.exports = SummaryArticle;
  ...

module gitbook.summaryArticle.prototype

function gitbook.summaryArticle.prototype.constructor (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.summaryArticle.prototype.createChildLevel ()

• description and source-code

  createChildLevel = function () {
      var level       = this.getLevel();
      var subArticles = this.getArticles();
      var childLevel  = level + '.' + (subArticles.size + 1);
  
      return childLevel;
  }

• example usage

  ...
  var SummaryArticle = require('../summaryArticle');
  var File = require('../file');
  
  describe('SummaryArticle', function() {
      describe('createChildLevel', function() {
  it('must create the right level', function() {
      var article = SummaryArticle.create({}, '1.1');
      expect(article.createChildLevel()).toBe('1.1.1');
  });
  
  it('must create the right level when has articles', function() {
      var article = SummaryArticle.create({
          articles: [
              {
                  title: 'Test'
  ...

function gitbook.summaryArticle.prototype.getAnchor ()

• description and source-code

  getAnchor = function () {
      var ref = this.getRef();
      var parts = ref.split('#');
  
      var anchor = (parts.length > 1? '#' + parts[parts.length - 1] : undefined);
      return anchor;
  }

• example usage

  ...
              .toJS();
      }
  
      return {
          title: article.getTitle(),
          level: article.getLevel(),
          depth: article.getDepth(),
          anchor: article.getAnchor(),
          url: article.getUrl(),
          path: article.getPath(),
          ref: article.getRef(),
          articles: articles
      };
  }
  ...

function gitbook.summaryArticle.prototype.getArticles ()

• description and source-code

  getArticles = function () {
      return this.get('articles');
  }

• example usage

  ...
  
  @param {SummaryArticle}
  @return {Object}
  */
  function encodeSummaryArticle(article, recursive) {
  var articles = undefined;
  if (recursive !== false) {
      articles = article.getArticles()
          .map(encodeSummaryArticle)
          .toJS();
  }
  
  return {
      title: article.getTitle(),
      level: article.getLevel(),
  ...

function gitbook.summaryArticle.prototype.getDepth ()

• description and source-code

  getDepth = function () {
      return (this.getLevel().split('.').length - 1);
  }

• example usage

  ...
      var article = summary.getByPath(file.getPath());
  
      var result = attributes.toJS();
  
      if (article) {
  result.title = article.getTitle();
  result.level = article.getLevel();
  result.depth = article.getDepth();
  
  var nextArticle = summary.getNextArticle(article);
  if (nextArticle) {
      result.next = encodeSummaryArticle(nextArticle);
  }
  
  var prevArticle = summary.getPrevArticle(article);
  ...

function gitbook.summaryArticle.prototype.getLevel ()

• description and source-code

  getLevel = function () {
      return this.get('level');
  }

• example usage

  ...
  */
  function encodeArticle(pages, article) {
  var articlePath = article.getPath();
  
  return {
      path: articlePath,
      title: article.getTitle(),
      level: article.getLevel(),
      exists: (articlePath && pages.has(articlePath)),
      external: article.isExternal()
  };
  }
  
  /**
  this.navigation is a deprecated property from GitBook v2
  ...

function gitbook.summaryArticle.prototype.getPath ()

• description and source-code

  getPath = function () {
      if (this.isExternal()) {
          return undefined;
      }
  
      var ref = this.getRef();
      if (!ref) {
          return undefined;
      }
  
      var parts = ref.split('#');
  
      var pathname = (parts.length > 1? parts.slice(0, -1).join('#') : ref);
  
      // Normalize path to remove ('./', '/...', etc)
      return location.flatten(pathname);
  }

• example usage

  ...
      })
      .then(Parse.parseSummary)
  
      .then(function(book) {
  var logger = book.getLogger();
  var summary = book.getSummary();
  var summaryFile = summary.getFile();
  var summaryFilename = summaryFile.getPath() || ('SUMMARY' + extension);
  
  var articles = summary.getArticlesAsList();
  
  // Write pages
  return Promise.forEach(articles, function(article) {
      var articlePath = article.getPath();
      var filePath = articlePath? path.join(rootFolder, articlePath) : null;
  ...

function gitbook.summaryArticle.prototype.getRef ()

• description and source-code

  getRef = function () {
      return this.get('ref');
  }

• example usage

  ...
      var pages = output.getPages();
      var summary = book.getSummary();
      var articles = summary.getArticlesAsList();
  
  
      var navigation = articles
          .map(function(article, i) {
  var ref = article.getRef();
  if (!ref) {
      return undefined;
  }
  
  var prev = articles.get(i - 1);
  var next = articles.get(i + 1);
  ...

function gitbook.summaryArticle.prototype.getTitle ()

• description and source-code

  getTitle = function () {
      return this.get('title');
  }

• example usage

  ...
          return;
      }
  
      return fs.assertFile(filePath, function() {
          return fs.ensureFile(filePath)
          .then(function() {
              logger.info.ln('create', article.getPath());
              return fs.writeFile(filePath, '# ' + article.getTitle() + '
  ;\n\n');
          });
      });
  })
  
  // Write summary
  .then(function() {
      var filePath = path.join(rootFolder, summaryFilename);
  ...

function gitbook.summaryArticle.prototype.getUrl ()

• description and source-code

  getUrl = function () {
      return this.isExternal()? this.getRef() : undefined;
  }

• example usage

  ...
      }
  
      return {
          title: article.getTitle(),
          level: article.getLevel(),
          depth: article.getDepth(),
          anchor: article.getAnchor(),
          url: article.getUrl(),
          path: article.getPath(),
          ref: article.getRef(),
          articles: articles
      };
  }
  
  module.exports = encodeSummaryArticle;
  ...

function gitbook.summaryArticle.prototype.isExternal ()

• description and source-code

  isExternal = function () {
      return location.isExternal(this.getRef());
  }

• example usage

  ...
  var articlePath = article.getPath();
  
  return {
      path: articlePath,
      title: article.getTitle(),
      level: article.getLevel(),
      exists: (articlePath && pages.has(articlePath)),
      external: article.isExternal()
  };
  }
  
  /**
  this.navigation is a deprecated property from GitBook v2
  
  @param {Output}
  ...

function gitbook.summaryArticle.prototype.isFile (file)

• description and source-code

  isFile = function (file) {
      return (
          file.getPath() === this.getPath()
          && this.getAnchor() === undefined
      );
  }

• example usage

  ...
  * @param {Book|Readme} book
  * @return {Boolean}
  */
  SummaryArticle.prototype.isReadme = function(book) {
     var readme = book.getFile? book : book.getReadme();
     var file = readme.getFile();
  
     return this.isFile(file);
  };
  
  /**
  * Is article pointing to aan absolute url
  *
  * @return {Boolean}
  */
  ...

function gitbook.summaryArticle.prototype.isPage ()

• description and source-code

  isPage = function () {
      return !this.isExternal() && this.getRef();
  }

• example usage

  ...
      var glossary = book.getGlossary();
      var map = Immutable.OrderedMap();
  
      // Parse pages from summary
      return timing.measure(
          'parse.listPages',
          walkSummary(summary, function(article) {
  if (!article.isPage()) return;
  
  var filepath = article.getPath();
  
  // Is the page ignored?
  if (book.isContentFileIgnored(filepath)) return;
  
  return parseFilePage(book, filepath)
  ...

function gitbook.summaryArticle.prototype.isReadme (book)

• description and source-code

  isReadme = function (book) {
      var readme = book.getFile? book : book.getReadme();
      var file = readme.getFile();
  
      return this.isFile(file);
  }

• example usage

  n/a

module gitbook.summaryPart

function gitbook.summaryPart (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.summaryPart.create (def, level)

• description and source-code

  create = function (def, level) {
      var articles = (def.articles || []).map(function(article, i) {
          if (article instanceof SummaryArticle) {
              return article;
          }
          return SummaryArticle.create(article, [level, i + 1].join('.'));
      });
  
      return new SummaryPart({
          level: String(level),
          title: def.title,
          articles: Immutable.List(articles)
      });
  }

• example usage

  ...
      var book = Book.createForFS(fs);
  
      return Parse.parseReadme(book)
  
      // Setup default readme if doesn't found one
      .fail(function() {
          var readmeFile = File.createWithFilepath('README' + extension);
          var readme = Readme.create(readmeFile);
          return book.setReadme(readme);
      });
  })
  .then(Parse.parseSummary)
  
  .then(function(book) {
      var logger = book.getLogger();
  ...

module gitbook.summaryPart.prototype

function gitbook.summaryPart.prototype.constructor (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.summaryPart.prototype.createChildLevel ()

• description and source-code

  createChildLevel = function () {
      var level       = this.getLevel();
      var subArticles = this.getArticles();
      var childLevel  = level + '.' + (subArticles.size + 1);
  
      return childLevel;
  }

• example usage

  ...
  var SummaryArticle = require('../summaryArticle');
  var File = require('../file');
  
  describe('SummaryArticle', function() {
      describe('createChildLevel', function() {
  it('must create the right level', function() {
      var article = SummaryArticle.create({}, '1.1');
      expect(article.createChildLevel()).toBe('1.1.1');
  });
  
  it('must create the right level when has articles', function() {
      var article = SummaryArticle.create({
          articles: [
              {
                  title: 'Test'
  ...

function gitbook.summaryPart.prototype.getArticles ()

• description and source-code

  getArticles = function () {
      return this.get('articles');
  }

• example usage

  ...
  
  @param {SummaryArticle}
  @return {Object}
  */
  function encodeSummaryArticle(article, recursive) {
  var articles = undefined;
  if (recursive !== false) {
      articles = article.getArticles()
          .map(encodeSummaryArticle)
          .toJS();
  }
  
  return {
      title: article.getTitle(),
      level: article.getLevel(),
  ...

function gitbook.summaryPart.prototype.getLevel ()

• description and source-code

  getLevel = function () {
      return this.get('level');
  }

• example usage

  ...
  */
  function encodeArticle(pages, article) {
  var articlePath = article.getPath();
  
  return {
      path: articlePath,
      title: article.getTitle(),
      level: article.getLevel(),
      exists: (articlePath && pages.has(articlePath)),
      external: article.isExternal()
  };
  }
  
  /**
  this.navigation is a deprecated property from GitBook v2
  ...

function gitbook.summaryPart.prototype.getTitle ()

• description and source-code

  getTitle = function () {
      return this.get('title');
  }

• example usage

  ...
          return;
      }
  
      return fs.assertFile(filePath, function() {
          return fs.ensureFile(filePath)
          .then(function() {
              logger.info.ln('create', article.getPath());
              return fs.writeFile(filePath, '# ' + article.getTitle() + '
  ;\n\n');
          });
      });
  })
  
  // Write summary
  .then(function() {
      var filePath = path.join(rootFolder, summaryFilename);
  ...

module gitbook.templateBlock

function gitbook.templateBlock (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.templateBlock.create (blockName, block)

• description and source-code

  create = function (blockName, block) {
      if (is.fn(block)) {
          block = new Immutable.Map({
              process: block
          });
      }
  
      block = new TemplateBlock(block);
      block = block.set('name', blockName);
      return block;
  }

• example usage

  ...
      var book = Book.createForFS(fs);
  
      return Parse.parseReadme(book)
  
      // Setup default readme if doesn't found one
      .fail(function() {
          var readmeFile = File.createWithFilepath('README' + extension);
          var readme = Readme.create(readmeFile);
          return book.setReadme(readme);
      });
  })
  .then(Parse.parseSummary)
  
  .then(function(book) {
      var logger = book.getLogger();
  ...

module gitbook.templateBlock.prototype

function gitbook.templateBlock.prototype.applyBlock (inner, context)

• description and source-code

  applyBlock = function (inner, context) {
      var processFn = this.getProcess();
  
      inner = inner || {};
      inner.args = inner.args || [];
      inner.kwargs = inner.kwargs || {};
      inner.blocks = inner.blocks || [];
  
      var r = processFn.call(context, inner);
  
      if (Promise.isPromiseAlike(r)) {
          return r.then(this.normalizeBlockResult.bind(this));
      } else {
          return this.normalizeBlockResult(r);
      }
  }

• example usage

  ...
  
          @param {String} name
          @param {Object} blockData
          @return {Promise|Object}
      */
      applyBlock: function(name, blockData) {
          var block = blocks.get(name) || defaultBlocks.get(name);
          return Promise(block.applyBlock(blockData, result));
      }
  },
  
  output: {
      /**
          Name of the generator being used
          {String}
  ...

function gitbook.templateBlock.prototype.blockResultToHtml (result, blocksOutput)

• description and source-code

  blockResultToHtml = function (result, blocksOutput) {
      var indexedKey;
      var toIndex = (!result.parse) || (result.post !== undefined);
  
      if (toIndex) {
          indexedKey = genKey();
          blocksOutput[indexedKey] = result;
      }
  
      // Parsable block, just return it
      if (result.parse) {
          return result.body;
      }
  
      // Return it as a position marker
      return '{{-%' + indexedKey + '%-}}';
  
  }

• example usage

  ...
                  var ctx = extend({
                      ctx: context
                  }, mainContext || {});
  
                  return that.applyBlock(mainBlock, ctx);
              })
              .then(function(result) {
                  return that.blockResultToHtml(result, blocksOutput);
              })
              .nodeify(callback);
          };
      }
  
      return Ext;
  };
  ...

function gitbook.templateBlock.prototype.constructor (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.templateBlock.prototype.getBlocks ()

• description and source-code

  getBlocks = function () {
      return this.get('blocks');
  }

• example usage

  ...
   */
  TemplateBlock.prototype.toNunjucksExt = function(mainContext, blocksOutput) {
      blocksOutput = blocksOutput || {};
  
      var that = this;
      var name = this.getName();
      var endTag = this.getEndTag();
      var blocks = this.getBlocks().toJS();
  
      function Ext() {
  this.tags = [name];
  
  this.parse = function(parser, nodes) {
      var lastBlockName = null;
      var lastBlockArgs = null;
  ...

function gitbook.templateBlock.prototype.getEndTag ()

• description and source-code

  getEndTag = function () {
      return this.get('end') || ('end' + this.getName());
  }

• example usage

  ...
   * @return {Nunjucks.Extension}
   */
  TemplateBlock.prototype.toNunjucksExt = function(mainContext, blocksOutput) {
      blocksOutput = blocksOutput || {};
  
      var that = this;
      var name = this.getName();
      var endTag = this.getEndTag();
      var blocks = this.getBlocks().toJS();
  
      function Ext() {
  this.tags = [name];
  
  this.parse = function(parser, nodes) {
      var lastBlockName = null;
  ...

function gitbook.templateBlock.prototype.getExtensionName ()

• description and source-code

  getExtensionName = function () {
      return 'Block' + this.getName() + 'Extension';
  }

• example usage

  ...
  // Add filters
  filters.forEach(function(filterFn, filterName) {
      env.addFilter(filterName, filterFn.bind(context));
  });
  
  // Add blocks
  blocks.forEach(function(block) {
      var extName = block.getExtensionName();
      var Ext = block.toNunjucksExt(context, blocksOutput);
  
      env.addExtension(extName, new Ext());
  });
  
  // Add globals
  globals.forEach(function(globalValue, globalName) {
  ...

function gitbook.templateBlock.prototype.getName ()

• description and source-code

  getName = function () {
      return this.get('name');
  }

• example usage

  ...
  * Return a specific parser by its name
  *
  * @param {String} name
  * @return {Parser|undefined}
  */
  function getParser(name) {
     return parsers.find(function(parser) {
         return parser.getName() === name;
     });
  }
  
  /**
  * Return a specific parser according to an extension
  *
  * @param {String} ext
  ...

function gitbook.templateBlock.prototype.getProcess ()

• description and source-code

  getProcess = function () {
      return this.get('process');
  }

• example usage

  ...
  /**
   * Apply a block to a content
   * @param {Object} inner
   * @param {Object} context
   * @return {Promise<String>|String}
   */
  TemplateBlock.prototype.applyBlock = function(inner, context) {
  var processFn = this.getProcess();
  
  inner = inner || {};
  inner.args = inner.args || [];
  inner.kwargs = inner.kwargs || {};
  inner.blocks = inner.blocks || [];
  
  var r = processFn.call(context, inner);
  ...

function gitbook.templateBlock.prototype.getShortcuts ()

• description and source-code

  getShortcuts = function () {
      var shortcuts = this.get('shortcuts');
      if (shortcuts.size === 0) {
          return undefined;
      }
  
      return TemplateShortcut.createForBlock(this, shortcuts);
  }

• example usage

  ...
  
  if (!parser) {
      return Immutable.List();
  }
  
  return blocks
      .map(function(block) {
          return block.getShortcuts();
      })
      .filter(function(shortcuts) {
          return (
              shortcuts &&
              shortcuts.acceptParser(parser.getName())
          );
      });
  ...

function gitbook.templateBlock.prototype.normalizeBlockResult (result)

• description and source-code

  normalizeBlockResult = function (result) {
      if (is.string(result)) {
          result = { body: result };
      }
      result.name = this.getName();
  
      return result;
  }

• example usage

  ...
     inner.blocks = inner.blocks || [];
  
     var r = processFn.call(context, inner);
  
     if (Promise.isPromiseAlike(r)) {
         return r.then(this.normalizeBlockResult.bind(this));
     } else {
         return this.normalizeBlockResult(r);
     }
  };
  
  /**
  * Normalize result from a block process function
  * @param {Object|String} result
  * @return {Object}
  ...

function gitbook.templateBlock.prototype.toNunjucksExt (mainContext, blocksOutput)

• description and source-code

  toNunjucksExt = function (mainContext, blocksOutput) {
      blocksOutput = blocksOutput || {};
  
      var that = this;
      var name = this.getName();
      var endTag = this.getEndTag();
      var blocks = this.getBlocks().toJS();
  
      function Ext() {
          this.tags = [name];
  
          this.parse = function(parser, nodes) {
              var lastBlockName = null;
              var lastBlockArgs = null;
              var allBlocks = blocks.concat([endTag]);
  
              // Parse first block
              var tok = parser.nextToken();
              lastBlockArgs = parser.parseSignature(null, true);
              parser.advanceAfterBlockEnd(tok.value);
  
              var args = new nodes.NodeList();
              var bodies = [];
              var blockNamesNode = new nodes.Array(tok.lineno, tok.colno);
              var blockArgCounts = new nodes.Array(tok.lineno, tok.colno);
  
              // Parse while we found "end<block>"
              do {
                  // Read body
                  var currentBody = parser.parseUntilBlocks.apply(parser, allBlocks);
  
                  // Handle body with previous block name and args
                  blockNamesNode.addChild(new nodes.Literal(args.lineno, args.colno, lastBlockName));
                  blockArgCounts.addChild(new nodes.Literal(args.lineno, args.colno, lastBlockArgs.children.length));
                  bodies.push(currentBody);
  
                  // Append arguments of this block as arguments of the run function
                  lastBlockArgs.children.forEach(function(child) {
                      args.addChild(child);
                  });
  
                  // Read new block
                  lastBlockName = parser.nextToken().value;
  
                  // Parse signature and move to the end of the block
                  if (lastBlockName != endTag) {
                      lastBlockArgs = parser.parseSignature(null, true);
                  }
  
                  parser.advanceAfterBlockEnd(lastBlockName);
              } while (lastBlockName != endTag);
  
              args.addChild(blockNamesNode);
              args.addChild(blockArgCounts);
              args.addChild(new nodes.Literal(args.lineno, args.colno, NODE_ENDARGS));
  
              return new nodes.CallExtensionAsync(this, 'run', args, bodies);
          };
  
          this.run = function(context) {
              var fnArgs = Array.prototype.slice.call(arguments, 1);
  
              var args;
              var blocks = [];
              var bodies = [];
              var blockNames;
              var blockArgCounts;
              var callback;
  
              // Extract callback
              callback = fnArgs.pop();
  
              // Detect end of arguments
              var endArgIndex = fnArgs.indexOf(NODE_ENDARGS);
  
              // Extract arguments and bodies
              args = fnArgs.slice(0, endArgIndex);
              bodies = fnArgs.slice(endArgIndex + 1);
  
              // Extract block counts
              blockArgCounts = args.pop();
              blockNames = args.pop();
  
              // Recreate list of blocks
              blockNames.forEach(function(name, i) {
                  var countArgs = blockArgCounts[i];
                  var blockBody = bodies.shift();
  
                  var blockArgs = countArgs > 0? args.slice(0, countArgs) : [];
                  args = args.slice(countArgs);
                  var blockKwargs = extractKwargs(blockArgs);
  
                  blocks.push({
                      name: name,
                      body: blockBody(),
                      args: blockArgs,
                      kwargs: blockKwargs
                  });
              });
  
              var mainBlock = blocks.shift();
              mainBlock.blocks = blocks;
  
              Promise()
              .then(function() {
                  var ctx = extend({
                      ctx: context
                  }, mainContext || {});
  
                  return that.applyBlock(mainBlock, ctx);
              })
              .then(function(result) {
                  return that.blockResultToHtml(result, blocksOutput);
              })
              .nodeify(callback);
          };
      }
  
      return Ext;
  }

• example usage

  ...
  filters.forEach(function(filterFn, filterName) {
      env.addFilter(filterName, filterFn.bind(context));
  });
  
  // Add blocks
  blocks.forEach(function(block) {
      var extName = block.getExtensionName();
      var Ext = block.toNunjucksExt(context, blocksOutput);
  
      env.addExtension(extName, new Ext());
  });
  
  // Add globals
  globals.forEach(function(globalValue, globalName) {
      env.addGlobal(globalName, globalValue);
  ...

module gitbook.templateEngine

function gitbook.templateEngine (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.templateEngine.create (def)

• description and source-code

  create = function (def) {
      return new TemplateEngine({
          blocks:     Immutable.List(def.blocks || []),
          extensions: Immutable.Map(def.extensions || {}),
          filters:    Immutable.Map(def.filters || {}),
          globals:    Immutable.Map(def.globals || {}),
          context:    def.context,
          loader:     def.loader
      });
  }

• example usage

  ...
      var book = Book.createForFS(fs);
  
      return Parse.parseReadme(book)
  
      // Setup default readme if doesn't found one
      .fail(function() {
          var readmeFile = File.createWithFilepath('README' + extension);
          var readme = Readme.create(readmeFile);
          return book.setReadme(readme);
      });
  })
  .then(Parse.parseSummary)
  
  .then(function(book) {
      var logger = book.getLogger();
  ...

module gitbook.templateEngine.prototype

function gitbook.templateEngine.prototype.constructor (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.templateEngine.prototype.getBlock (name)

• description and source-code

  getBlock = function (name) {
      var blocks = this.getBlocks();
      return blocks.find(function(block) {
          return block.getName() === name;
      });
  }

• example usage

  n/a

function gitbook.templateEngine.prototype.getBlocks ()

• description and source-code

  getBlocks = function () {
      return this.get('blocks');
  }

• example usage

  ...
   */
  TemplateBlock.prototype.toNunjucksExt = function(mainContext, blocksOutput) {
      blocksOutput = blocksOutput || {};
  
      var that = this;
      var name = this.getName();
      var endTag = this.getEndTag();
      var blocks = this.getBlocks().toJS();
  
      function Ext() {
  this.tags = [name];
  
  this.parse = function(parser, nodes) {
      var lastBlockName = null;
      var lastBlockArgs = null;
  ...

function gitbook.templateEngine.prototype.getContext ()

• description and source-code

  getContext = function () {
      return this.get('context');
  }

• example usage

  ...
  */
  TemplateEngine.prototype.toNunjucks = function(blocksOutput) {
  var loader = this.getLoader();
  var blocks = this.getBlocks();
  var filters = this.getFilters();
  var globals = this.getGlobals();
  var extensions = this.getExtensions();
  var context = this.getContext();
  
  var env = new nunjucks.Environment(
      loader,
      {
          // Escaping is done after by the asciidoc/markdown parser
          autoescape: false,
  ...

function gitbook.templateEngine.prototype.getExtensions ()

• description and source-code

  getExtensions = function () {
      return this.get('extensions');
  }

• example usage

  ...
  function getParserForFile(filename) {
  return getParserByExt(path.extname(filename));
  }
  
  // List all parsable extensions
  var extensions = parsers
  .map(function(parser) {
      return parser.getExtensions();
  })
  .flatten();
  
  module.exports = {
  extensions: extensions,
  get: getParser,
  getByExt: getParserByExt,
  ...

function gitbook.templateEngine.prototype.getFilters ()

• description and source-code

  getFilters = function () {
      return this.get('filters');
  }

• example usage

  ...
  Return a nunjucks environment from this configuration
  
  @return {Nunjucks.Environment}
  */
  TemplateEngine.prototype.toNunjucks = function(blocksOutput) {
  var loader = this.getLoader();
  var blocks = this.getBlocks();
  var filters = this.getFilters();
  var globals = this.getGlobals();
  var extensions = this.getExtensions();
  var context = this.getContext();
  
  var env = new nunjucks.Environment(
      loader,
      {
  ...

function gitbook.templateEngine.prototype.getGlobals ()

• description and source-code

  getGlobals = function () {
      return this.get('globals');
  }

• example usage

  ...
  
  @return {Nunjucks.Environment}
  */
  TemplateEngine.prototype.toNunjucks = function(blocksOutput) {
  var loader = this.getLoader();
  var blocks = this.getBlocks();
  var filters = this.getFilters();
  var globals = this.getGlobals();
  var extensions = this.getExtensions();
  var context = this.getContext();
  
  var env = new nunjucks.Environment(
      loader,
      {
          // Escaping is done after by the asciidoc/markdown parser
  ...

function gitbook.templateEngine.prototype.getLoader ()

• description and source-code

  getLoader = function () {
      return this.get('loader');
  }

• example usage

  ...
  
  /**
  Return a nunjucks environment from this configuration
  
  @return {Nunjucks.Environment}
  */
  TemplateEngine.prototype.toNunjucks = function(blocksOutput) {
  var loader = this.getLoader();
  var blocks = this.getBlocks();
  var filters = this.getFilters();
  var globals = this.getGlobals();
  var extensions = this.getExtensions();
  var context = this.getContext();
  
  var env = new nunjucks.Environment(
  ...

function gitbook.templateEngine.prototype.getShortcuts ()

• description and source-code

  getShortcuts = function () {
      return this.get('shortcuts');
  }

• example usage

  ...
  
  if (!parser) {
      return Immutable.List();
  }
  
  return blocks
      .map(function(block) {
          return block.getShortcuts();
      })
      .filter(function(shortcuts) {
          return (
              shortcuts &&
              shortcuts.acceptParser(parser.getName())
          );
      });
  ...

function gitbook.templateEngine.prototype.toNunjucks (blocksOutput)

• description and source-code

  toNunjucks = function (blocksOutput) {
      var loader = this.getLoader();
      var blocks = this.getBlocks();
      var filters = this.getFilters();
      var globals = this.getGlobals();
      var extensions = this.getExtensions();
      var context = this.getContext();
  
      var env = new nunjucks.Environment(
          loader,
          {
              // Escaping is done after by the asciidoc/markdown parser
              autoescape: false,
  
              // Syntax
              tags: {
                  blockStart: '{%',
                  blockEnd: '%}',
                  variableStart: '{{',
                  variableEnd: '}}',
                  commentStart: '{###',
                  commentEnd: '###}'
              }
          }
      );
  
      // Add filters
      filters.forEach(function(filterFn, filterName) {
          env.addFilter(filterName, filterFn.bind(context));
      });
  
      // Add blocks
      blocks.forEach(function(block) {
          var extName = block.getExtensionName();
          var Ext = block.toNunjucksExt(context, blocksOutput);
  
          env.addExtension(extName, new Ext());
      });
  
      // Add globals
      globals.forEach(function(globalValue, globalName) {
          env.addGlobal(globalName, globalValue);
      });
  
      // Add other extensions
      extensions.forEach(function(ext, extName) {
          env.addExtension(extName, ext);
      });
  
      return env;
  }

• example usage

  ...
  function renderTemplate(engine, filePath, content, context) {
  context = context || {};
  
  // Mutable objects to contains all blocks requiring post-processing
  var blocks = {};
  
  // Create nunjucks environment
  var env = engine.toNunjucks(blocks);
  
  // Replace shortcuts from plugin's blocks
  content = replaceShortcuts(engine.getBlocks(), filePath, content);
  
  return timing.measure(
      'template.render',
  ...

module gitbook.templateOutput

function gitbook.templateOutput (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.templateOutput.create (content, blocks)

• description and source-code

  create = function (content, blocks) {
      return new TemplateOutput({
          content:    content,
          blocks:     Immutable.fromJS(blocks)
      });
  }

• example usage

  ...
      var book = Book.createForFS(fs);
  
      return Parse.parseReadme(book)
  
      // Setup default readme if doesn't found one
      .fail(function() {
          var readmeFile = File.createWithFilepath('README' + extension);
          var readme = Readme.create(readmeFile);
          return book.setReadme(readme);
      });
  })
  .then(Parse.parseSummary)
  
  .then(function(book) {
      var logger = book.getLogger();
  ...

module gitbook.templateOutput.prototype

function gitbook.templateOutput.prototype.constructor (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.templateOutput.prototype.getBlocks ()

• description and source-code

  getBlocks = function () {
      return this.get('blocks');
  }

• example usage

  ...
   */
  TemplateBlock.prototype.toNunjucksExt = function(mainContext, blocksOutput) {
      blocksOutput = blocksOutput || {};
  
      var that = this;
      var name = this.getName();
      var endTag = this.getEndTag();
      var blocks = this.getBlocks().toJS();
  
      function Ext() {
  this.tags = [name];
  
  this.parse = function(parser, nodes) {
      var lastBlockName = null;
      var lastBlockArgs = null;
  ...

function gitbook.templateOutput.prototype.getContent ()

• description and source-code

  getContent = function () {
      return this.get('content');
  }

• example usage

  ...
  
  @param {Output} output
  @param {Page} page: page instance to edit
  @param {Object} result: result from API
  @return {Page}
  */
  function decodePage(output, page, result) {
  var originalContent = page.getContent();
  
  // No returned value
  // Existing content will be used
  if (!result) {
      return page;
  }
  ...

function gitbook.templateOutput.prototype.setContent (content)

• description and source-code

  setContent = function (content) {
      return this.set('content', content);
  }

• example usage

  ...
  })
  
  .then(function(output) {
      var content = output.getContent();
  
      return parser.parsePage(content)
      .then(function(result) {
          return output.setContent(result.content);
      });
  })
  
  // Post processing for templating syntax
  .then(function(output) {
      return Templating.postRender(engine, output);
  })
  ...

module gitbook.templateShortcut

function gitbook.templateShortcut (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.templateShortcut.createForBlock (block, details)

• description and source-code

  createForBlock = function (block, details) {
      details = Immutable.fromJS(details);
  
      return new TemplateShortcut({
          parsers:        details.get('parsers'),
          start:          details.get('start'),
          end:            details.get('end'),
          startTag:       block.getName(),
          endTag:         block.getEndTag()
      });
  }

• example usage

  ...
   */
  TemplateBlock.prototype.getShortcuts = function() {
      var shortcuts = this.get('shortcuts');
      if (shortcuts.size === 0) {
          return undefined;
      }
  
      return TemplateShortcut.createForBlock(this, shortcuts);
  };
  
  /**
   * Return name for the nunjucks extension
   * @return {String}
   */
  TemplateBlock.prototype.getExtensionName = function() {
  ...

module gitbook.templateShortcut.prototype

function gitbook.templateShortcut.prototype.acceptParser (parser)

• description and source-code

  acceptParser = function (parser) {
      if (!is.string(parser)) {
          parser = parser.getName();
      }
  
      var parserNames = this.get('parsers');
      return parserNames.includes(parser);
  }

• example usage

  ...
      return blocks
          .map(function(block) {
              return block.getShortcuts();
          })
          .filter(function(shortcuts) {
              return (
                  shortcuts &&
                  shortcuts.acceptParser(parser.getName())
              );
          });
  }
  
  module.exports = listShortcuts;
  ...

function gitbook.templateShortcut.prototype.constructor (values)

• description and source-code

  function Record(values) {
    if (values instanceof RecordType) {
      return values;
    }
    if (!(this instanceof RecordType)) {
      return new RecordType(values);
    }
    if (!hasInitialized) {
      hasInitialized = true;
      var keys = Object.keys(defaultValues);
      setProps(RecordTypePrototype, keys);
      RecordTypePrototype.size = keys.length;
      RecordTypePrototype._name = name;
      RecordTypePrototype._keys = keys;
      RecordTypePrototype._defaultValues = defaultValues;
    }
    this._map = Map(values);
  }

• example usage

  n/a

function gitbook.templateShortcut.prototype.getEnd ()

• description and source-code

  getEnd = function () {
      return this.get('end');
  }

• example usage

  ...
   * Apply a shortcut of block to a template
   * @param {String} content
   * @param {Shortcut} shortcut
   * @return {String}
   */
  function applyShortcut(content, shortcut) {
  var start = shortcut.getStart();
  var end = shortcut.getEnd();
  
  var tagStart = shortcut.getStartTag();
  var tagEnd = shortcut.getEndTag();
  
  var regex = new RegExp(
      escapeStringRegexp(start) + '([\\s\\S]*?[^\\$])' + escapeStringRegexp(end),
     'g'
  ...

function gitbook.templateShortcut.prototype.getEndTag ()

• description and source-code

  getEndTag = function () {
      return this.get('endTag');
  }

• example usage

  ...
   * @return {Nunjucks.Extension}
   */
  TemplateBlock.prototype.toNunjucksExt = function(mainContext, blocksOutput) {
      blocksOutput = blocksOutput || {};
  
      var that = this;
      var name = this.getName();
      var endTag = this.getEndTag();
      var blocks = this.getBlocks().toJS();
  
      function Ext() {
  this.tags = [name];
  
  this.parse = function(parser, nodes) {
      var lastBlockName = null;
  ...

function gitbook.templateShortcut.prototype.getParsers ()

• description and source-code

  getParsers = function () {
      return this.get('parsers');
  }

• example usage

  n/a

function gitbook.templateShortcut.prototype.getStart ()

• description and source-code

  getStart = function () {
      return this.get('start');
  }

• example usage

  ...
  /**
   * Apply a shortcut of block to a template
   * @param {String} content
   * @param {Shortcut} shortcut
   * @return {String}
   */
  function applyShortcut(content, shortcut) {
  var start = shortcut.getStart();
  var end = shortcut.getEnd();
  
  var tagStart = shortcut.getStartTag();
  var tagEnd = shortcut.getEndTag();
  
  var regex = new RegExp(
      escapeStringRegexp(start) + '([\\s\\S]*?[^\\$])' + escapeStringRegexp(end),
  ...

function gitbook.templateShortcut.prototype.getStartTag ()

• description and source-code

  getStartTag = function () {
      return this.get('startTag');
  }

• example usage

  ...
   * @param {Shortcut} shortcut
   * @return {String}
   */
  function applyShortcut(content, shortcut) {
  var start = shortcut.getStart();
  var end = shortcut.getEnd();
  
  var tagStart = shortcut.getStartTag();
  var tagEnd = shortcut.getEndTag();
  
  var regex = new RegExp(
      escapeStringRegexp(start) + '([\\s\\S]*?[^\\$])' + escapeStringRegexp(end),
     'g'
  );
  return content.replace(regex, function(all, match) {
  ...

module gitbook.themesLoader

function gitbook.themesLoader ()

• description and source-code

  themesLoader = function () {
      if(prototype.init) {
          prototype.init.apply(this, arguments);
      }
  }

• example usage

  n/a

function gitbook.themesLoader.extend (name, props)

• description and source-code

  extend = function (name, props) {
      if(typeof name === 'object') {
          props = name;
          name = 'anonymous';
      }
      return extend(new_cls, name, props);
  }

• example usage

  ...
  
  var is = require('is');
  var path = require('path');
  var fs = require('fs');
  var expect = require('expect');
  var cheerio = require('cheerio');
  
  expect.extend({
  /**
   * Check that a file is created in a directory:
   * expect('myFolder').toHaveFile('hello.md');
   */
  toHaveFile: function(fileName) {
      var filePath = path.join(this.actual, fileName);
      var exists = fs.existsSync(filePath);
  ...

module gitbook.themesLoader.prototype

function gitbook.themesLoader.prototype.constructor ()

• description and source-code

  constructor = function () {
      if(prototype.init) {
          prototype.init.apply(this, arguments);
      }
  }

• example usage

  n/a

function gitbook.themesLoader.prototype.getSearchPath (filepath)

• description and source-code

  getSearchPath = function (filepath) {
      return this.searchPaths
          .sortBy(function(s) {
              return -s.length;
          })
          .find(function(basePath) {
              return (filepath && filepath.indexOf(basePath) === 0);
          });
  }

• example usage

  ...
  
  /**
   * Get template name from a filepath
   * @param {String} filepath
   * @return {String} name
   */
  getTemplateName: function(filepath) {
      var originalSearchPath = this.getSearchPath(filepath);
      return originalSearchPath? path.relative(originalSearchPath, filepath) : null;
  },
  
  /**
   * Resolve a template from a current template
   * @param {String|null} from
   * @param {String} to
  ...

function gitbook.themesLoader.prototype.getSource (fullpath)

• description and source-code

  getSource = function (fullpath) {
      if (!fullpath) return null;
  
      fullpath = this.resolve(null, fullpath);
      var templateName = this.getTemplateName(fullpath);
  
      if(!fullpath) {
          return null;
      }
  
      var src = fs.readFileSync(fullpath, 'utf-8');
  
      src = '{% do %}var template = template || {}; template.stack = template.stack || []; template.stack.push(template.self); template
  .self = ' + JSON.stringify(templateName) + '{% enddo %}\n' +
          src +
          '\n{% do %}template.self = template.stack.pop();{% enddo %}';
  
      return {
          src: src,
          path: fullpath,
          noCache: true
      };
  }

• example usage

  ...
  
  // Resolve the filePath
  var resolvedFilePath = loader.resolve(null, filePath);
  
  return Promise()
  .then(function() {
      if (!loader.async) {
          return loader.getSource(resolvedFilePath);
      }
  
      var deferred = Promise.defer();
      loader.getSource(resolvedFilePath, deferred.makeNodeResolver());
      return deferred.promise;
  })
  .then(function(result) {
  ...

function gitbook.themesLoader.prototype.getTemplateName (filepath)

• description and source-code

  getTemplateName = function (filepath) {
      var originalSearchPath = this.getSearchPath(filepath);
      return originalSearchPath? path.relative(originalSearchPath, filepath) : null;
  }

• example usage

  ...
       * @param {String}
       * @return {Object}
       */
      getSource: function(fullpath) {
  if (!fullpath) return null;
  
  fullpath = this.resolve(null, fullpath);
  var templateName = this.getTemplateName(fullpath);
  
  if(!fullpath) {
      return null;
  }
  
  var src = fs.readFileSync(fullpath, 'utf-8');
  ...

function gitbook.themesLoader.prototype.init (searchPaths)

• description and source-code

  init = function (searchPaths) {
      this.searchPaths = Immutable.List(searchPaths)
          .map(path.normalize);
  }

• example usage

  n/a

function gitbook.themesLoader.prototype.isRelative ()

• description and source-code

  isRelative = function () {
      return true;
  }

• example usage

  ...
  
          // 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'
      isRelative: function(filename) {
          return LocationUtils.isRelative(filename);
      }
  });
  
  module.exports = ConrefsLoader;
  ...

function gitbook.themesLoader.prototype.resolve (from, to)

• description and source-code

  resolve = function (from, to) {
      var searchPaths = this.searchPaths;
  
      // Relative template like "./test.html"
      if (PathUtils.isPureRelative(to) && from) {
          return path.resolve(path.dirname(from), to);
      }
  
      // Determine in which search folder we currently are
      var originalSearchPath = this.getSearchPath(from);
      var originalFilename = this.getTemplateName(from);
  
      // If we are including same file from a different search path
      // Slice the search paths to avoid including from previous ones
      if (originalFilename == to) {
          var currentIndex = searchPaths.indexOf(originalSearchPath);
          searchPaths = searchPaths.slice(currentIndex + 1);
      }
  
      // Absolute template to resolve in root folder
      var resultFolder = searchPaths.find(function(basePath) {
          var p = path.resolve(basePath, to);
  
          return (
              p.indexOf(basePath) === 0
              && fs.existsSync(p)
          );
      });
      if (!resultFolder) return null;
      return path.resolve(resultFolder, to);
  }

• example usage

  ...
  The `Book` class is the central point of GitBook, it centralize all access read methods. This class is defined in [book.js](https
  ://github.com/GitbookIO/gitbook/blob/master/lib/book.js).
  
  ```js
  // Read configuration from book.json
  var value = book.config.get('title', 'Default Value');
  
  // Resolve a filename to an absolute path
  var filepath = book.resolve('README.md');
  
  // Render an inline markup string
  book.renderInline('markdown', 'This is **Markdown**')
      .then(function(str) { ... })
  
  // Render a markup string (block mode)
  book.renderBlock('markdown', '* This is **Markdown**')
  ...

module gitbook.timing

function gitbook.timing.dump (logger)

• description and source-code

  function dump(logger) {
      var prefix = '    > ';
      var measured = 0;
      var totalDuration = Date.now() - startDate;
  
      // Enable debug logging
      var logLevel = logger.getLevel();
      logger.setLevel('debug');
  
      Immutable.Map(timers)
          .valueSeq()
          .sortBy(function(timer) {
              measured += timer.total;
              return timer.total;
          })
          .forEach(function(timer) {
              var percent = (timer.total * 100) / totalDuration;
  
  
              logger.debug.ln((percent.toFixed(1)) + '% of time spent in "' + timer.type + '" (' + timer.count + ' times) :');
              logger.debug.ln(prefix + 'Total: ' + time(timer.total)+ ' | Average: ' + time(timer.total / timer.count));
              logger.debug.ln(prefix + 'Min: ' + time(timer.min) + ' | Max: ' + time(timer.max));
              logger.debug.ln('---------------------------');
          });
  
  
      logger.debug.ln(time(totalDuration - measured) + ' spent in non-mesured sections');
  
      // Rollback to previous level
      logger.setLevel(logLevel);
  }

• example usage

  ...
          return Parse.parseBook(book)
          .then(function(resultBook) {
              return Output.generate(Generator, resultBook, {
                  root: outputFolder
              });
          })
          .fin(function() {
              if (kwargs.timing) timing.dump(book.getLogger());
          });
      }
  };
  ...

function gitbook.timing.measure (type, p)

• description and source-code

  function measure(type, p) {
      timers[type] = timers[type] || {
          type: type,
          count: 0,
          total: 0,
          min: undefined,
          max: 0
      };
  
      var start = Date.now();
  
      return p
      .fin(function() {
          var end = Date.now();
          var duration = (end - start);
  
          timers[type].count ++;
          timers[type].total += duration;
  
          if (is.undefined(timers[type].min)) {
              timers[type].min = duration;
          } else {
              timers[type].min = Math.min(timers[type].min, duration);
          }
  
          timers[type].max = Math.max(timers[type].max, duration);
      });
  }

• example usage

  ...
      var plugins = output.getPlugins();
  
      logger.debug.ln('calling hook "' + name + '"');
  
      // Create the JS context for plugins
      var context = Api.encodeGlobal(output);
  
      return timing.measure(
  'call.hook.' + name,
  
  // Get the arguments
  Promise(getArgument(output))
  
  // Call the hooks in serie
  .then(function(arg) {
  ...