Man pages parser written in JavaScript, supports `an` and `doc` macros - WIP
Switch branches/tags
Nothing to show
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
benchmarks
dist
src
test
.codeclimate.yml
.eslintignore
.eslintrc
.gitignore
.jsbeautifyrc
.travis.yml
CHANGELOG
LICENSE
Makefile
README.md
bower.json
package.json

README.md

jroff

travis Code Climate Test Coverage

About

For a real-life example of Jroff in action, check out grapse.

Jroff is a man page parser written in JavaScript, featuring:

  • Partial support for groff-native commands
  • Full support for an macros
  • Full support for doc macros

The main functionality of the library is to produce an AST ready to be consumed by a generator.

At the moment, only a single HTML generator has been implemented, but the plan is to implement several more in the near future.

Usage

An annotated version of the code can be found here

HTML Generator

Using the generator is fairly simple. You only have to create a new instance and call the generate method every time you want to parse a string containing groff text.

The generate function takes two arguments: the source string and an optional name from the macro library that will be used to parse the result:

// Instantiate a new generator
var generator = new Jroff.HTMLGenerator();
// Generate the HTML output
var result = generator.generate('.Op Fl 0 Ns Op Ar octal', 'doc');

This is what we see when we print the result variable:

<span>[<strong>-0 <span>[<i>octal</i>]</span></strong>]</span>

Parser

The parser takes a string as a source, being capable of building an AST from it. Using the parser is very straightforward, but it is nearly useless without a generator:

// Instantiate a new parser class
var parser = new Jroff.Parser('.Op Fl lorem ipsum');
// Build the AST
var ast = parser.buildAST();

This is what we see when we inspect the ast variable:

[{
  "value": "Op",
  "kind": 2,
  "nodes": [{
    "value": " ",
    "kind": 5,
    "nodes": []
  }, {
    "value": "Fl",
    "kind": 3,
    "nodes": [{
      "value": " lorem ipsum",
      "kind": 5,
      "nodes": []
    }]
  }]
}]

Defining New Macros

You can define a specific macro for your project by adding a new item in the Jroff.macros.defaults object, using the macro name as a key and the function with a specific macro functionality as the value:

Jroff.macros.defaults.sp = function (spacing) {
    spacing = spacing || '2';
    return '<hr style="margin-top:' + spacing + 'em;visibility:hidden;">';
};

Internally, all macros are defined like this. You can check out src/macros/defaults.js for more examples.

Contributing

For regular development, you need to have Node.js >=0.10 installed in your system. Then,

Clone the repository.

git clone git@bitbucket.org:roperzh/jroff_final.git
cd jroff_final

Install the required dependencies.

npm install

Finally, build your local copy and run the tests.

make all

Brief Description of the Organization of the Code

dist: This folder stores the bundled versions of the code.

src/core: As the name of the folder suggests, this is the core of the library. There is no HTML-related code here, only code to parse and build the AST.

src/generators: Generators are entities that can consume the AST generated by the parser and produce an output. At the moment, only one HTML generator has been implemented.

src/macros: Stores macro commands and macro packages. At the moment, it only supports an and doc packages. Macros supported by groff are stored in default.js

src/utils: Utility functions and miscellany.

Brief Description of Make Commands

make dist: beautifies and builds minified and concatenated versions of the code.

make hint: runs eslint over the test files and the concatenated, non-minified version of the code.

make beautify: runs js-beautify over all JavaScript files.

make doc: generates local documentation based on the current version of the code. This is useful for previewing documentation before publishing it. See the next section for more details.

Documenting New Code

This library uses jsdoc3 to generate documentation, so all new code must be documented using jsdoc tags. A useful reference can be found here.

Also, due to some limitations with jsdoc and UMD, the @alias tag must be added to all functions, constructors, and namespaces manually.

Generating Documentation

The Makefile includes a useful command that generates and pushes the documentation onto GitHub and GitHub pages. You can simply run:

make doc-build

Note: Please make sure to stash or commit all your changes before generating the documentation.

If you want to preview the changes before pushing the documentation, you can generate it with the doc task and then open docs/index.html on your browser.

An example of this using OS X:

make doc
open docs/index.html

Benchmarks

Running benchmarks is a complicated task, even more so in this case since there aren't other libraries to use as a reference and compare the results with.

Therefore, what these benchmarks are for is to compare different versions of the library with three arbitrary man pages: Git, Node.js, and Ruby

This benchmark should be used only for drawing estimative comparisons between versions or complex features.

If you want to run the benchmarks and compare the new data with the latest stored results:

make bench

Alternatively, you can store the results of the benchmark in the cache file (benchmarks/benchmarks.json) with an -s flag:

make bench flags='-s'

To-Dos

  • Add support for nested numeric lists
  • Add support for -width arguments in lists
  • Add missing macros

Links

License

All the code contained in this repository, unless explicitly stated, is licensed under an MIT license.

A copy of the license can be found in the LICENSE file.