@jaredwray/fumanchu 1.0.0

package/lib/html.js

@@ -0,0 +1,218 @@
+'use strict';
+
+var path = require('path');
+var util = require('handlebars-utils');
+var html = require('./utils/html');
+var utils = require('./utils');
+var parseAttr = html.parseAttributes;
+var helpers = module.exports;
+
+/**
+ * Stringify attributes on the options `hash`.
+ *
+ * ```handlebars
+ * <!-- value = 'bar' -->
+ * <div{{attr foo=value}}></div>
+ * <!-- results in: <div foo="bar"></div>
+ * ```
+ * @param {Object} `options`
+ * @return {String}
+ * @api public
+ */
+
+helpers.attr = function(options) {
+  var val = parseAttr((options && options.hash) || {});
+  return val.trim() ? ' ' + val : '';
+};
+
+/**
+ * Add an array of `<link>` tags. Automatically resolves
+ * relative paths to `options.assets` if passed on the context.
+ *
+ * ```handlebars
+ * <!-- {stylesheets: ['foo.css', 'bar.css']} -->
+ * {{css stylesheets}}
+ *
+ * <!-- results in: -->
+ * <!-- <link type="text/css" rel="stylesheet" href="foo.css"> -->
+ * <!-- <link type="text/css" rel="stylesheet" href="bar.css"> -->
+ * ```
+ * @param {String|Array} `list` One or more stylesheet urls.
+ * @return {String}
+ * @api public
+ */
+
+helpers.css = function(list, options) {
+  if (arguments.length < 2) {
+    options = list;
+    list = [];
+  }
+
+  var styles = util.arrayify(list);
+  var assets = '';
+
+  if (this && this.options) {
+    assets = this.options.assets || '';
+  }
+
+  if (options.hash.href) {
+    styles = util.arrayify(options.hash.href);
+  }
+
+  return styles.map(function(item) {
+    var ext = path.extname(item);
+    var fp = item;
+
+    if (!/(^\/\/)|(:\/\/)/.test(item)) {
+      fp = path.posix.join(assets, item);
+    }
+
+    if (ext === '.less') {
+      return '<link type="text/css" rel="stylesheet/less" href="' + fp + '">';
+    }
+    return '<link type="text/css" rel="stylesheet" href="' + fp + '">';
+  }).join('\n');
+};
+
+/**
+ * Generate one or more `<script></script>` tags with paths/urls to
+ * javascript or coffeescript files.
+ *
+ * ```handlebars
+ * {{js scripts}}
+ * ```
+ * @param {Object} `context`
+ * @return {String}
+ * @api public
+ */
+
+helpers.js = function(context) {
+  if (utils.typeOf(context) === 'object') {
+    var attr = parseAttr(context.hash);
+    return '<script' + (attr ? ' ' + attr : '') + '></script>';
+  }
+
+  if (utils.typeOf(context) === 'string') {
+    return '<script src="' + context + '"></script>';
+  }
+
+  context = util.arrayify(context);
+  return context.map(function(fp) {
+    return (path.extname(fp) === '.coffee')
+      ? utils.tag('script', {type: 'text/coffeescript', src: fp})
+      : utils.tag('script', {src: fp});
+  }).join('\n');
+};
+
+/**
+ * Strip HTML tags from a string, so that only the text nodes
+ * are preserved.
+ *
+ * ```handlebars
+ * {{sanitize "<span>foo</span>"}}
+ * <!-- results in: 'foo' -->
+ * ```
+ *
+ * @param {String} `str` The string of HTML to sanitize.
+ * @return {String}
+ * @api public
+ */
+
+helpers.sanitize = function(str) {
+  return html.sanitize(str);
+};
+
+/**
+ * Block helper for creating unordered lists (`<ul></ul>`)
+ *
+ * @param {Object} `context`
+ * @param {Object} `options`
+ * @return {String}
+ * @block
+ * @api public
+ */
+
+helpers.ul = function(context, options) {
+  return ('<ul ' + (parseAttr(options.hash)) + '>') + context.map(function(item) {
+    if (typeof item !== 'string') {
+      item = options.fn(item);
+    }
+    return '<li>' + item + '</li>';
+  }).join('\n') + '</ul>';
+};
+
+/**
+ * Block helper for creating ordered lists  (`<ol></ol>`)
+ *
+ * @param {Object} `context`
+ * @param {Object} `options`
+ * @return {String}
+ * @block
+ * @api public
+ */
+
+helpers.ol = function(context, options) {
+  return ('<ol ' + (parseAttr(options.hash)) + '>') + context.map(function(item) {
+    if (typeof item !== 'string') {
+      item = options.fn(item);
+    }
+    return '<li>' + item + '</li>';
+  }).join('\n') + '</ol>';
+};
+
+/**
+ * Returns a `<figure>` with a thumbnail linked to a full picture
+ *
+ * @param {Object} `context` Object with values/attributes to add to the generated elements:
+ * @param {String} `context.alt`
+ * @param {String} `context.src`
+ * @param {Number} `context.width`
+ * @param {Number} `context.height`
+ * @return {String} HTML `<figure>` element with image and optional caption/link.
+ * @contributor: Marie Hogebrandt <https://github.com/Melindrea>
+ * @api public
+ */
+
+helpers.thumbnailImage = function(context) {
+  var figure = '';
+  var image = '';
+
+  var link = context.full || false;
+  var imageAttributes = {
+    alt: context.alt,
+    src: context.thumbnail,
+    width: context.size.width,
+    height: context.size.height
+  };
+
+  var figureAttributes = { id: 'image-' + context.id };
+  var linkAttributes = { href: link, rel: 'thumbnail' };
+
+  if (context.classes) {
+    if (context.classes.image) {
+      imageAttributes.class = context.classes.image.join(' ');
+    }
+    if (context.classes.figure) {
+      figureAttributes.class = context.classes.figure.join(' ');
+    }
+    if (context.classes.link) {
+      linkAttributes.class = context.classes.link.join(' ');
+    }
+  }
+
+  figure += '<figure ' + parseAttr(figureAttributes) + '>\n';
+  image += '<img ' + parseAttr(imageAttributes) + '>\n';
+
+  if (link) {
+    figure += '<a ' + parseAttr(linkAttributes) + '>\n' + image + '</a>\n';
+  } else {
+    figure += image;
+  }
+
+  if (context.caption) {
+    figure += '<figcaption>' + context.caption + '</figcaption>\n';
+  }
+
+  figure += '</figure>';
+  return figure;
+};

package/lib/i18n.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var util = require('handlebars-utils');
+var utils = require('./utils');
+var helpers = module.exports;
+
+/**
+ * i18n helper. See [button-i18n](https://github.com/assemble/buttons)
+ * for a working example.
+ *
+ * @contributor Laurent Goderre <https://github.com/LaurentGoderrre>
+ * @param {String} `key`
+ * @param {Object} `options`
+ * @return {String}
+ * @api public
+ */
+
+helpers.i18n = function(prop, locals, options) {
+  if (util.isOptions(locals)) {
+    options = locals;
+    locals = {};
+  }
+
+  if (!util.isString(prop)) {
+    throw new Error('{{i18n}} helper expected "key" to be a string');
+  }
+
+  var opts = util.options(this, locals, options);
+  var context = Object.assign({}, this, opts);
+
+  var lang = context.language || context.lang;
+
+  if (!util.isString(lang)) {
+    throw new TypeError('{{i18n}} helper expected "language" to be a string');
+  }
+
+  var cache = context[lang];
+  if (typeof cache === 'undefined') {
+    throw new Error('{{i18n}} helper cannot find language "' + lang + '"');
+  }
+
+  var result = utils.get(cache, prop);
+  if (typeof result === 'undefined') {
+    throw new Error('{{i18n}} helper cannot find property "' + prop + '" for language "' + lang + '"');
+  }
+
+  return result;
+};

package/lib/index.js

@@ -0,0 +1,24 @@
+'use strict';
+
+module.exports = {
+  array: require('./array'),
+  code: require('./code'),
+  collection: require('./collection'),
+  comparison: require('./comparison'),
+  date: require('./date'),
+  fs: require('./fs'),
+  html: require('./html'),
+  i18n: require('./i18n'),
+  inflection: require('./inflection'),
+  logging: require('./logging'),
+  markdown: require('./markdown'),
+  match: require('./match'),
+  math: require('./math'),
+  misc: require('./misc'),
+  number: require('./number'),
+  object: require('./object'),
+  path: require('./path'),
+  regex: require('./regex'),
+  string: require('./string'),
+  url: require('./url')
+};

package/lib/inflection.js

@@ -0,0 +1,78 @@
+'use strict';
+
+var util = require('handlebars-utils');
+var helpers = module.exports;
+
+/**
+ * Returns either the `singular` or `plural` inflection of a word based on
+ * the given `count`.
+ *
+ * ```handlebars
+ * {{inflect 0 "string" "strings"}}
+ * <!-- "strings" -->
+ * {{inflect 1 "string" "strings"}}
+ * <!-- "string" -->
+ * {{inflect 1 "string" "strings" true}}
+ * <!-- "1 string" -->
+ * {{inflect 2 "string" "strings"}}
+ * <!-- "strings" -->
+ * {{inflect 2 "string" "strings" true}}
+ * <!-- "2 strings" -->
+ * ```
+ * @param {Number} `count`
+ * @param {String} `singular` The singular form
+ * @param {String} `plural` The plural form
+ * @param {String} `includeCount`
+ * @return {String}
+ * @api public
+ */
+
+helpers.inflect = function(count, singular, plural, includeCount) {
+  var word = (count > 1 || count === 0) ? plural : singular;
+  if (includeCount === true) {
+    return String(count) + ' ' + word;
+  } else {
+    return word;
+  }
+};
+
+/**
+ * Returns an ordinalized number as a string.
+ *
+ * ```handlebars
+ * {{ordinalize 1}}
+ * <!-- '1st' -->
+ * {{ordinalize 21}}
+ * <!-- '21st' -->
+ * {{ordinalize 29}}
+ * <!-- '29th' -->
+ * {{ordinalize 22}}
+ * <!-- '22nd' -->
+ * ```
+ *
+ * @param {String} `val` The value to ordinalize.
+ * @return {String} The ordinalized number
+ * @api public
+ */
+
+helpers.ordinalize = function(val) {
+  var num = Math.abs(Math.round(val));
+  var str = String(val);
+  var res = num % 100;
+
+  if (util.indexOf([11, 12, 13], res) >= 0) {
+    return str + 'th';
+  }
+
+  switch (num % 10) {
+    case 1:
+      return str + 'st';
+    case 2:
+      return str + 'nd';
+    case 3:
+      return str + 'rd';
+    default: {
+      return str + 'th';
+    }
+  }
+};

package/lib/logging.js

@@ -0,0 +1,8 @@
+'use strict';
+
+/**
+ * [logging-helpers](https://github.com/helpers/logging-helpers).
+ * @api public
+ */
+
+module.exports = require('logging-helpers');

package/lib/markdown.js

@@ -0,0 +1,55 @@
+'use strict';
+
+/**
+ * Expose markdown `helpers` (for performance we're using getters so
+ * that the helpers are only loaded if called)
+ */
+
+var helpers = module.exports;
+var markdown;
+
+/**
+ * Block helper that converts a string of inline markdown to HTML.
+ *
+ * ```handlebars
+ * {{#markdown}}
+ * # Foo
+ * {{/markdown}}
+ * <!-- results in: <h1>Foo</h1> -->
+ * ```
+ * @name .markdown
+ * @param {Object} `context`
+ * @param {Object} `options`
+ * @return {String}
+ * @block
+ * @api public
+ */
+
+Object.defineProperty(helpers, 'markdown', {
+  configurable: true,
+  enumerable: true,
+  set: function(val) {
+    markdown = val;
+  },
+  get: function() {
+    // this is defined as a getter to avoid calling this function
+    // unless the helper is actually used
+    return markdown || (markdown = require('helper-for-markdown')());
+  }
+});
+
+/**
+ * Read a markdown file from the file system and inject its contents after
+ * converting it to HTML.
+ *
+ * ```handlebars
+ * {{md "foo/bar.md"}}
+ * ```
+ * @param {Object} `context`
+ * @param {Object} `options`
+ * @return {String}
+ * @block
+ * @api public
+ */
+
+helpers.md = require('helper-md');

package/lib/match.js

@@ -0,0 +1,61 @@
+'use strict';
+
+var util = require('handlebars-utils');
+var utils = require('./utils');
+var helpers = module.exports;
+
+/**
+ * Returns an array of strings that match the given glob pattern(s).
+ * Options may be passed on the options hash or locals.
+ *
+ * ```handlebars
+ * {{match (readdir "foo") "*.js"}}
+ * {{match (readdir "foo") (toRegex "\\.js$")}}
+ * ```
+ * @param {Array|String} `files`
+ * @param {Array|String} `patterns` One or more glob patterns.
+ * @param {Object} `locals`
+ * @param {Object} `options`
+ * @return {Array} Array of matches
+ * @api public
+ */
+
+helpers.match = function(files, patterns, locals, options) {
+  var opts = util.options(this, locals, options);
+  if (typeof patterns === 'string') {
+    patterns = patterns.split(/, */);
+  }
+  return utils.mm(files, patterns, opts);
+};
+
+/**
+ * Returns true if a filepath contains the given pattern.
+ * Options may be passed on the options hash or locals.
+ *
+ * ```handlebars
+ * {{isMatch "foo.md" "*.md"}}
+ * <!-- results in: true -->
+ * ```
+ *
+ * @param {String} `filepath`
+ * @param {String} `pattern`
+ * @param {Object} `options`
+ * @return {Boolean}
+ * @api public
+ */
+
+helpers.isMatch = function(files, patterns, locals, options) {
+  var opts = util.options(this, locals, options);
+  return utils.mm.isMatch(files, patterns, opts);
+};
+
+/**
+ * Alias for micromatch helper. Deprecated in v0.9.0.
+ */
+
+helpers.mm = function() {
+  console.log('the {{mm}} helper is depcrecated and will be removed');
+  console.log('in handlebars-helpers v1.0.0, please use the {{match}}');
+  console.log('helper instead.');
+  return helpers.match.apply(this, arguments);
+};