marked 0.2.6 → 0.2.10

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011-2012, Christopher Jeffrey (https://github.com/chjj/)
+Copyright (c) 2011-2013, Christopher Jeffrey (https://github.com/chjj/)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/Makefile

@@ -6,4 +6,7 @@ clean:
 	@rm marked.js
 	@rm marked.min.js
 
+bench:
+	@node test --bench
+
 .PHONY: clean all

package/README.md

@@ -1,7 +1,200 @@
 # marked
 
-A full-featured markdown parser and compiler, written in javascript.
-Built for speed.
+> A full-featured markdown parser and compiler, written in javascript. Built
+> for speed.
+
+[![NPM version](https://badge.fury.io/js/marked.png)][badge]
+
+## Install
+
+``` bash
+npm install marked --save
+```
+
+## Usage
+
+Minimal usage:
+
+```js
+console.log(marked('I am using __markdown__.'));
+// Outputs: <p>I am using <i>markdown</i>.</p>
+```
+
+Example using all options:
+
+```js
+// Set default options except highlight which has no default
+marked.setOptions({
+  gfm: true,
+  highlight: function (code, lang, callback) {
+    pygmentize({ lang: lang, format: 'html' }, code, function (err, result) {
+      if (err) return callback(err);
+      callback(null, result.toString());
+    });
+  },
+  tables: true,
+  breaks: false,
+  pedantic: false,
+  sanitize: true,
+  smartLists: true,
+  smartypants: false,
+  langPrefix: 'lang-'
+});
+
+// Using async version of marked
+marked('I am using __markdown__.', function (err, content) {
+  if (err) throw err;
+  console.log(content);
+});
+```
+
+## marked(markdownString, [options], [callback])
+
+### markdownString
+
+Type: `String`
+
+String of markdown source to be compiled.
+
+### options
+
+Type: `Object`
+
+Hash of options. Can also be set using the `marked.setOptions` method as seen
+above.
+
+### callback
+
+Type: `Function`
+
+Function called when the `markdownString` has been fully parsed when using
+async highlighting. If the `options` argument is omitted, this can be used as
+the second argument as seen above:
+
+## Options
+
+### gfm
+
+Type: `Boolean`
+Default: `true`
+
+Enable [GitHub flavored markdown][gfm].
+
+### highlight
+
+Type: `Function`
+
+A function to highlight code blocks. The function takes three arguments: code,
+lang, and callback. The above example uses async highlighting with
+[node-pygementize-bundled][pygmentize], and here is a synchronous example using
+[highlight.js][highlight] which doesn't require the callback argument:
+
+```js
+marked.setOptions({
+  highlight: function (code, lang) {
+    return hljs.highlightAuto(lang, code).value;
+  }
+});
+```
+
+#### highlight arguments
+
+`code`
+
+Type: `String`
+
+The section of code to pass to the highlighter.
+
+`lang`
+
+Type: `String`
+
+The programming language specified in the code block.
+
+`callback`
+
+Type: `String`
+
+The callback function to call when using an async highlighter.
+
+### tables
+
+Type: `Boolean`
+Default: `true`
+
+Enable GFM [tables][tables].
+This option requires the `gfm` option to be true.
+
+### breaks
+
+Type: `Boolean`
+Default: `false`
+
+Enable GFM [line breaks][breaks].
+This option requires the `gfm` option to be true.
+
+### pedantic
+
+Type: `Boolean`
+Default: `false`
+
+Conform to obscure parts of `markdown.pl` as much as possible. Don't fix any of
+the original markdown bugs or poor behavior.
+
+### sanitize
+
+Type: `Boolean`
+Default: `false`
+
+Sanitize the output. Ignore any HTML that has been input.
+
+### smartLists
+
+Type: `Boolean`
+Default: `true`
+
+Use smarter list behavior than the original markdown. May eventually be
+default with the old behavior moved into `pedantic`.
+
+### smartypants
+
+Type: `Boolean`
+Default: `false`
+
+Use "smart" typograhic punctuation for things like quotes and dashes.
+
+### langPrefix
+
+Type: `String`
+Default: `lang-`
+
+Set the prefix for code block classes.
+
+## Access to lexer and parser
+
+You also have direct access to the lexer and parser if you so desire.
+
+``` js
+var tokens = marked.lexer(text, options);
+console.log(marked.parser(tokens));
+```
+
+``` js
+var lexer = new marked.Lexer(options);
+var tokens = lexer.lex(text);
+console.log(tokens);
+console.log(lexer.rules);
+```
+
+## CLI
+
+``` bash
+$ marked -o hello.html
+hello world
+^D
+$ cat hello.html
+<p>hello world</p>
+```
 
 ## Benchmarks
 
@@ -34,10 +227,17 @@ For those feeling skeptical: These benchmarks run the entire markdown test suite
 1000 times. The test suite tests every feature. It doesn't cater to specific
 aspects.
 
-## Install
+node v0.8.x
 
 ``` bash
-$ npm install marked
+$ node test --bench
+marked completed in 3411ms.
+marked (gfm) completed in 3727ms.
+marked (pedantic) completed in 3201ms.
+robotskirt completed in 808ms.
+showdown (reuse converter) completed in 11954ms.
+showdown (new converter) completed in 17774ms.
+markdown-js completed in 17191ms.
 ```
 
 ## Another Javascript Markdown Parser
@@ -57,46 +257,8 @@ of performance, but did not in order to be exactly what you expect in terms
 of a markdown rendering. In fact, this is why marked could be considered at a
 disadvantage in the benchmarks above.
 
-Along with implementing every markdown feature, marked also implements
-[GFM features](http://github.github.com/github-flavored-markdown/).
-
-## Options
-
-marked has 4 different switches which change behavior.
-
-- __pedantic__: Conform to obscure parts of `markdown.pl` as much as possible.
-  Don't fix any of the original markdown bugs or poor behavior.
-- __gfm__: Enable github flavored markdown (enabled by default).
-- __sanitize__: Sanitize the output. Ignore any HTML that has been input.
-- __highlight__: A callback to highlight code blocks.
-
-None of the above are mutually exclusive/inclusive.
-
-## Usage
-
-``` js
-// Set default options
-marked.setOptions({
-  gfm: true,
-  pedantic: false,
-  sanitize: true,
-  // callback for code highlighter
-  highlight: function(code, lang) {
-    if (lang === 'js') {
-      return javascriptHighlighter(code);
-    }
-    return code;
-  }
-});
-console.log(marked('i am using __markdown__.'));
-```
-
-You also have direct access to the lexer and parser if you so desire.
-
-``` js
-var tokens = marked.lexer(text);
-console.log(marked.parser(tokens));
-```
+Along with implementing every markdown feature, marked also implements [GFM
+features][gfmf].
 
 ``` bash
 $ node
@@ -108,18 +270,49 @@ $ node
   links: {} ]
 ```
 
-## CLI
+## Running Tests & Contributing
+
+If you want to submit a pull request, make sure your changes pass the test
+suite. If you're adding a new feature, be sure to add your own test.
+
+The marked test suite is set up slightly strangely: `test/new` is for all tests
+that are not part of the original markdown.pl test suite (this is where your
+test should go if you make one). `test/original` is only for the original
+markdown.pl tests. `test/tests` houses both types of tests after they have been
+combined and moved/generated by running `node test --fix` or `marked --test
+--fix`.
+
+In other words, if you have a test to add, add it to `test/new/` and then
+regenerate the tests with `node test --fix`. Commit the result. If your test
+uses a certain feature, for example, maybe it assumes GFM is *not* enabled, you
+can add `.nogfm` to the filename. So, `my-test.text` becomes
+`my-test.nogfm.text`. You can do this with any marked option. Say you want
+line breaks and smartypants enabled, your filename should be:
+`my-test.breaks.smartypants.text`.
+
+To run the tests:
 
 ``` bash
-$ marked -o hello.html
-hello world
-^D
-$ cat hello.html
-<p>hello world</p>
+cd marked/
+node test
 ```
 
+### Contribution and License Agreement
+
+If you contribute code to marked, you are implicitly allowing your code to be
+distributed under the MIT license. You are also implicitly verifying that all
+code is your original work. `</legalese>`
+
 ## License
 
-Copyright (c) 2011-2012, Christopher Jeffrey. (MIT License)
+Copyright (c) 2011-2013, Christopher Jeffrey. (MIT License)
 
 See LICENSE for more info.
+
+[gfm]: https://help.github.com/articles/github-flavored-markdown
+[gfmf]: http://github.github.com/github-flavored-markdown/
+[pygmentize]: https://github.com/rvagg/node-pygmentize-bundled
+[highlight]: https://github.com/isagalaev/highlight.js
+[badge]: http://badge.fury.io/js/marked
+[tables]: https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet#wiki-tables
+[breaks]: https://help.github.com/articles/github-flavored-markdown#newlines

package/bin/marked

@@ -2,7 +2,7 @@
 
 /**
  * Marked CLI
- * Copyright (c) 2011-2012, Christopher Jeffrey (MIT License)
+ * Copyright (c) 2011-2013, Christopher Jeffrey (MIT License)
  */
 
 var fs = require('fs')
@@ -13,7 +13,7 @@ var fs = require('fs')
  * Man Page
  */
 
-var help = function() {
+function help() {
   var spawn = require('child_process').spawn;
 
   var options = {
@@ -26,33 +26,54 @@ var help = function() {
   spawn('man',
     [__dirname + '/../man/marked.1'],
     options);
-};
+}
 
 /**
  * Main
  */
 
-var main = function(argv) {
+function main(argv, callback) {
   var files = []
     , options = {}
-    , data = ''
     , input
     , output
     , arg
-    , tokens;
+    , tokens
+    , opt;
 
-  var getarg = function() {
+  function getarg() {
     var arg = argv.shift();
-    arg = arg.split('=');
-    if (arg.length > 1) {
-      argv.unshift(arg.slice(1).join('='));
+
+    if (arg.indexOf('--') === 0) {
+      // e.g. --opt
+      arg = arg.split('=');
+      if (arg.length > 1) {
+        // e.g. --opt=val
+        argv.unshift(arg.slice(1).join('='));
+      }
+      arg = arg[0];
+    } else if (arg[0] === '-') {
+      if (arg.length > 2) {
+        // e.g. -abc
+        argv = arg.substring(1).split('').map(function(ch) {
+          return '-' + ch;
+        }).concat(argv);
+        arg = argv.shift();
+      } else {
+        // e.g. -a
+      }
+    } else {
+      // e.g. foo
     }
-    return arg[0];
-  };
+
+    return arg;
+  }
 
   while (argv.length) {
     arg = getarg();
     switch (arg) {
+      case '--test':
+        return require('../test').main(process.argv.slice());
       case '-o':
       case '--output':
         output = argv.shift();
@@ -65,63 +86,102 @@ var main = function(argv) {
       case '--tokens':
         tokens = true;
         break;
-      case '--gfm':
-        options.gfm = true;
-        break;
-      case '--sanitize':
-        options.sanitize = true;
-        break;
-      case '--pedantic':
-        options.pedantic = true;
-        break;
       case '-h':
       case '--help':
         return help();
       default:
-        files.push(arg);
+        if (arg.indexOf('--') === 0) {
+          opt = camelize(arg.replace(/^--(no-)?/, ''));
+          if (!marked.defaults.hasOwnProperty(opt)) {
+            continue;
+          }
+          if (arg.indexOf('--no-') === 0) {
+            options[opt] = typeof marked.defaults[opt] !== 'boolean'
+              ? null
+              : false;
+          } else {
+            options[opt] = typeof marked.defaults[opt] !== 'boolean'
+              ? argv.shift()
+              : true;
+          }
+        } else {
+          files.push(arg);
+        }
         break;
     }
   }
 
-  if (!input) {
-    if (files.length <= 2) {
-      var stdin = process.stdin;
-
-      stdin.setEncoding('utf8');
-      stdin.resume();
-
-      stdin.on('data', function(text) {
-        data += text;
-      });
-
-      stdin.on('end', write);
-
-      return;
+  function getData(callback) {
+    if (!input) {
+      if (files.length <= 2) {
+        return getStdin(callback);
+      }
+      input = files.pop();
     }
-    input = files.pop();
+    return fs.readFile(input, 'utf8', callback);
   }
 
-  data = fs.readFileSync(input, 'utf8');
-  write();
-
-  function write() {
-    marked.setOptions(options);
+  return getData(function(err, data) {
+    if (err) return callback(err);
 
     data = tokens
-      ? JSON.stringify(marked.lexer(data), null, 2)
-      : marked(data);
+      ? JSON.stringify(marked.lexer(data, options), null, 2)
+      : marked(data, options);
 
     if (!output) {
       process.stdout.write(data + '\n');
-    } else {
-      fs.writeFileSync(output, data);
+      return callback();
     }
+
+    return fs.writeFile(output, data, callback);
+  });
+}
+
+/**
+ * Helpers
+ */
+
+function getStdin(callback) {
+  var stdin = process.stdin
+    , buff = '';
+
+  stdin.setEncoding('utf8');
+
+  stdin.on('data', function(data) {
+    buff += data;
+  });
+
+  stdin.on('error', function(err) {
+    return callback(err);
+  });
+
+  stdin.on('end', function() {
+    return callback(null, buff);
+  });
+
+  try {
+    stdin.resume();
+  } catch (e) {
+    callback(e);
   }
-};
+}
+
+function camelize(text) {
+  return text.replace(/(\w)-(\w)/g, function(_, a, b) {
+    return a + b.toUpperCase();
+  });
+}
+
+/**
+ * Expose / Entry Point
+ */
 
 if (!module.parent) {
   process.title = 'marked';
-  main(process.argv.slice());
+  main(process.argv.slice(), function(err, code) {
+    if (err) throw err;
+    return process.exit(code || 0);
+  });
 } else {
   module.exports = main;
 }

package/component.json

@@ -0,0 +1,10 @@
+{
+  "name": "marked",
+  "version": "0.2.9",
+  "repo": "chjj/marked",
+  "description": "A markdown parser built for speed",
+  "keywords": ["markdown", "markup", "html"],
+  "scripts": ["lib/marked.js"],
+  "main": "lib/marked.js",
+  "license": "MIT"
+}