diff --git a/lib/array.js b/lib/array.js
index 81db4134..118f7693 100644
--- a/lib/array.js
+++ b/lib/array.js
@@ -383,8 +383,6 @@ helpers.some = function(arr, cb, options) {
   if (arr == null) {
     return options.inverse(this);
   }
-
-  var result = false;
   var len = arr.length, i = -1;
   while (++i < len) {
     if (cb(arr[i], i, arr)) {
diff --git a/lib/comparison.js b/lib/comparison.js
index 13b89d31..2dcf3186 100644
--- a/lib/comparison.js
+++ b/lib/comparison.js
@@ -2,7 +2,6 @@
 
 var isOdd = require('is-odd');
 var isEven = require('is-even');
-var typeOf = require('kind-of');
 var contains = require('./utils/contains');
 var isObject = require('./object').isObject;
 var isString = require('./string').isString;
diff --git a/lib/html.js b/lib/html.js
index 17042b57..90b4d151 100644
--- a/lib/html.js
+++ b/lib/html.js
@@ -3,7 +3,6 @@
 var path = require('path');
 var tag = require('html-tag');
 var typeOf = require('kind-of');
-var merge = require('mixin-deep');
 var html = require('./utils/html');
 var utils = require('./utils');
 var parseAttr = html.parseAttributes;
@@ -51,6 +50,30 @@ helpers.css = function(array, options) {
   }).join('\n');
 };
 
+/**
+ * Truncates a string to the specified `length`, and appends
+ * it with an elipsis, `…`.
+ *
+ * ```js
+ * {{ellipsis "<span>foo bar baz</span>", 7}}
+ * //=> 'foo bar…'
+ * ```
+ * @name .ellipsis
+ * @param {String} `str`
+ * @param {Number} `length` The desired length of the returned string.
+ * @return {String} The truncated string.
+ * @api public
+ */
+
+helpers.ellipsis = function(str, limit) {
+  if (str && typeof str === "string") {
+    if (str.length <= limit) {
+      return str;
+    }
+    return helpers.truncate(str, limit) + '…';
+  }
+};
+
 /**
  * Generate one or more `<script></script>` tags with paths/urls to
  * javascript or coffeescript files.
@@ -82,6 +105,52 @@ helpers.js = function(context) {
   }).join('\n');
 };
 
+/**
+ * Strip HTML tags from a string, so that only the text nodes
+ * are preserved.
+ *
+ * ```js
+ * {{sanitize "<span>foo</span>"}}
+ * //=> 'foo'
+ * ```
+ *
+ * @param  {String} `str` The string of HTML to sanitize.
+ * @return {String}
+ * @api public
+ */
+
+helpers.sanitize = function(str) {
+  return html.sanitize(str);
+};
+
+/**
+ * Truncate a string by removing all HTML tags and limiting the result
+ * to the specified `length`. Aslo see [ellipsis][].
+ *
+ * ```js
+ * truncate("<span>foo bar baz</span>", 7);
+ * //=> 'foo bar'
+ * ```
+ *
+ * @name .truncate
+ * @param  {String} `str`
+ * @param  {Number} `limit` The desired length of the returned string.
+ * @param  {String} `suffix` Optionally supply a string to use as a suffix to
+ * denote when the string has been truncated.
+ * @return {String} The truncated string.
+ * @api public
+ */
+
+helpers.truncate = function(str, limit, suffix) {
+  if (str && typeof str === "string") {
+    var ch = typeof suffix === 'string' ? suffix : '';
+    if (str.length > limit) {
+      return html.sanitize(str).slice(0, limit - ch.length) + ch;
+    }
+    return str;
+  }
+};
+
 /**
  * Block helper for creating unordered lists (`<ul></ul>`)
  *
diff --git a/lib/path.js b/lib/path.js
index 79b8c5d3..d4692aa1 100644
--- a/lib/path.js
+++ b/lib/path.js
@@ -2,6 +2,7 @@
 
 var path = require('path');
 var relative = require('relative');
+var normalize = require('normalize-path');
 
 /**
  * Expose `helpers`
@@ -73,3 +74,27 @@ helpers.extname = function(filepath) {
 helpers.relative = function(a, b) {
   return relative(a, b);
 };
+
+/**
+ * Get specific (joined) segments of a file path by passing a
+ * range of array indices.
+ *
+ * ```js
+ * {{segments "a/b/c/d" "2" "3"}}
+ * //=> 'c/d'
+ *
+ * {{segments "a/b/c/d" "1" "3"}}
+ * //=> 'b/c/d'
+ *
+ * {{segments "a/b/c/d" "1" "2"}}
+ * //=> 'b/c'
+ * ```
+ *
+ * @param {String} `filepath` The file path to split into segments.
+ * @return {String} Returns a single, joined file path.
+ * @api public
+ */
+
+helpers.segments = function(fp, a, b) {
+  return normalize(fp).split('/').slice(a, b).join('/');
+};
diff --git a/lib/string.js b/lib/string.js
index 6bb247b4..2a6e067a 100644
--- a/lib/string.js
+++ b/lib/string.js
@@ -1,6 +1,5 @@
 'use strict';
 
-var html = require('./utils/html');
 var utils = require('./utils');
 
 /**
diff --git a/lib/utils/html.js b/lib/utils/html.js
index 6859fa7d..56149954 100644
--- a/lib/utils/html.js
+++ b/lib/utils/html.js
@@ -1,12 +1,14 @@
 'use strict';
 
+var striptags = require('striptags');
 var typeOf = require('kind-of');
+var utils = require('./');
 
 /**
  * Expose `utils`
  */
 
-var utils = module.exports;
+var html = module.exports;
 
 /**
  * Remove extra newlines from HTML, respect indentation.
@@ -16,7 +18,7 @@ var utils = module.exports;
  * @api public
  */
 
-utils.condense = function(str) {
+html.condense = function(str) {
   return str.replace(/(\n|\r){2,}/g, '\n');
 };
 
@@ -28,7 +30,7 @@ utils.condense = function(str) {
  * @api public
  */
 
-utils.padcomments = function(str) {
+html.padcomments = function(str) {
   return str.replace(/(\s*<!--)/g, '\n$1');
 };
 
@@ -40,14 +42,32 @@ utils.padcomments = function(str) {
  * @api public
  */
 
-utils.parseAttributes = function parseAttributes(hash) {
+html.parseAttributes = function parseAttributes(hash) {
   return Object.keys(hash).map(function(key) {
     return key + '="' + hash[key] + '"';
   }).join(' ');
 };
 
+/**
+ * Strip HTML tags from a string, so that only the text nodes
+ * are preserved.
+ *
+ * ```js
+ * {{sanitize "<span>foo</span>"}}
+ * //=> 'foo'
+ * ```
+ *
+ * @param  {String} `str` The string of HTML to sanitize.
+ * @return {String}
+ * @api public
+ */
+
+html.sanitize = function(str) {
+  if (!utils.isString(str)) return '';
+  return striptags(str).trim();
+};
 
-utils.toAttributes = function toAttributes(hash) {
+html.toAttributes = function toAttributes(hash) {
   var res = '';
   for (var key in hash) {
     if (hash.hasOwnProperty(key) && typeOf(hash[key] === 'string')) {
diff --git a/lib/utils/index.js b/lib/utils/index.js
index 4ac44487..5f2a855a 100644
--- a/lib/utils/index.js
+++ b/lib/utils/index.js
@@ -3,12 +3,63 @@
 
 var utils = require('export-files')(__dirname);
 
+/**
+ * Remove leading and trailing whitespace and non-word
+ * characters from the given string.
+ *
+ * @param {String} `str`
+ * @return {String}
+ */
+
+utils.chop = function(str) {
+  if (!utils.isString(str)) return '';
+  var re = /^[-_.\W\s]+|[-_.\W\s]+$/g;
+  return str.trim().replace(re, '');
+};
+
+/**
+ * Change casing on the given `string`, optionally
+ * passing a delimiter to use between words in the
+ * returned string.
+ *
+ * ```js
+ * utils.changecase('fooBarBaz');
+ * //=> 'foo bar baz'
+ *
+ * utils.changecase('fooBarBaz' '-');
+ * //=> 'foo-bar-baz'
+ * ```
+ *
+ * @name .changecase
+ * @param  {String} `string` The string to change.
+ * @return {String}
+ * @api public
+ */
+
+utils.changecase = function(str, fn) {
+  if (!utils.isString(str)) return '';
+  if (str.length === 1) {
+    return str.toLowerCase();
+  }
+
+  str = utils.chop(str).toLowerCase();
+  if (typeof fn !== 'function') {
+    fn = utils.identity;
+  }
+
+  var re = /[-_.\W\s]+(\w|$)/g;
+  return str.replace(re, function (_, ch) {
+    return fn(ch);
+  });
+};
+
 /**
  * Generate a random number
  *
  * @param  {Number} `min`
  * @param  {Number} `max`
  * @return {Number}
+ * @api public
  */
 
 utils.random = function(min, max) {
@@ -52,6 +103,27 @@ utils.result = function(value) {
   return value;
 };
 
+/**
+ * Return the given value, unchanged.
+ *
+ * @name .identity
+ * @param  {any} `val`
+ * @return {any}
+ * @api public
+ */
+
+utils.identity = function(val) {
+  return val;
+};
+
+/**
+ * Return true if `val` is a string.
+ */
+
+utils.isString = function(val) {
+  return val && typeof val === 'string';
+};
+
 /**
  * Cast `val` to an array.
  *
diff --git a/test/html.js b/test/html.js
index b51625bc..41e1d928 100644
--- a/test/html.js
+++ b/test/html.js
@@ -52,6 +52,21 @@ describe('html', function() {
     });
   });
 
+  describe('ellipsis', function() {
+    it('should return an empty string if undefined', function() {
+      var fn = hbs.compile('{{ellipsis}}');
+      fn().should.equal('');
+    });
+    it('should return then string truncated by a specified length.', function() {
+      var fn = hbs.compile('{{ellipsis "Bender should not be allowed on tv." 31}}');
+      fn().should.equal('Bender should not be allowed on…');
+    });
+    it('should return the string if shorter than the specified length.', function() {
+      var fn = hbs.compile('{{ellipsis "Bender should not be allowed on tv." 100}}');
+      fn().should.equal('Bender should not be allowed on tv.');
+    });
+  });
+
   describe('js', function() {
     it('should create an empty script tag', function() {
       hbs.compile('{{{js}}}')().should.equal('<script></script>');
@@ -81,6 +96,40 @@ describe('html', function() {
     });
   });
 
+  describe('sanitize', function() {
+    it('should return an empty string when undefined.', function() {
+      hbs.compile('{{sanitize}}')().should.equal('');
+    });
+    it('should strip html from a string.', function() {
+      var actual = hbs.compile('{{sanitize "<span>foo</span>"}}')();
+      actual.should.equal('foo');
+    });
+  });
+
+  describe('truncate', function() {
+    it('should return an empty string if undefined', function() {
+      var fn = hbs.compile('{{truncate}}');
+      fn().should.equal('');
+    });
+    it('should return the string truncated by a specified length.', function() {
+      var fn = hbs.compile('{{truncate "Bender should not be allowed on tv." 31}}');
+      fn().should.equal('Bender should not be allowed on');
+    });
+    it('should return the string if shorter than the specified length.', function() {
+      var fn = hbs.compile('{{truncate "Bender should not be allowed on tv." 100}}');
+      fn().should.equal('Bender should not be allowed on tv.');
+    });
+    it('should return then string truncated by a specified length', function() {
+      var fn = hbs.compile('{{truncate "foo bar baz qux" 7}}...');
+      fn().should.equal('foo bar...');
+    });
+
+    it('should return then string truncated by a specified length, providing a custom string to denote an omission.', function() {
+      var fn = hbs.compile('{{truncate "foo bar baz qux" 7 "…"}}');
+      fn().should.equal('foo ba…');
+    });
+  });
+
   describe('ul', function() {
     it('should should return an unordered list', function() {
       var fn = hbs.compile('{{#ul data class="names"}}{{aaa}} {{bbb}}{{/ul}}');
diff --git a/test/math.js b/test/math.js
index c2353250..e577c262 100644
--- a/test/math.js
+++ b/test/math.js
@@ -24,11 +24,11 @@ describe('math', function () {
       fn({array: [1, 3, 6, 9]}).should.equal('4.75');
     });
   });
-
-  describe('subtract', function () {
-    it('should return the difference of two numbers.', function () {
-      var fn = hbs.compile('{{subtract value 5}}');
-      fn({value: 5}).should.equal('0');
+  
+  describe('ceil', function () {
+    it('should return the value rounded up to the nearest integer.', function () {
+      var fn = hbs.compile('{{ceil value}}');
+      fn({value: 5.6}).should.equal('6');
     });
   });
 
@@ -39,13 +39,6 @@ describe('math', function () {
     });
   });
 
-  describe('multiply', function () {
-    it('should return the multiplication of two numbers.', function () {
-      var fn = hbs.compile('{{multiply value 5}}');
-      fn({value: 5}).should.equal('25');
-    });
-  });
-
   describe('floor', function () {
     it('should return the value rounded down to the nearest integer.', function () {
       var fn = hbs.compile('{{floor value}}');
@@ -53,10 +46,10 @@ describe('math', function () {
     });
   });
 
-  describe('ceil', function () {
-    it('should return the value rounded up to the nearest integer.', function () {
-      var fn = hbs.compile('{{ceil value}}');
-      fn({value: 5.6}).should.equal('6');
+  describe('multiply', function () {
+    it('should return the multiplication of two numbers.', function () {
+      var fn = hbs.compile('{{multiply value 5}}');
+      fn({value: 5}).should.equal('25');
     });
   });
 
@@ -67,6 +60,13 @@ describe('math', function () {
     });
   });
 
+  describe('subtract', function () {
+    it('should return the difference of two numbers.', function () {
+      var fn = hbs.compile('{{subtract value 5}}');
+      fn({value: 5}).should.equal('0');
+    });
+  });
+
   describe('sum', function () {
     it('should return the sum of multiple numbers.', function () {
       var fn = hbs.compile('{{sum value 67 80}}');
diff --git a/test/path.js b/test/path.js
index 17886800..28e0a9b5 100644
--- a/test/path.js
+++ b/test/path.js
@@ -45,4 +45,14 @@ describe('path', function() {
       fn().should.equal('../../assets');
     });
   });
+
+  describe('segments', function() {
+    it('should return specified path segments:', function() {
+      hbs.compile('{{segments "a/b/c/e.js" 1 3}}')().should.equal('b/c');
+      hbs.compile('{{segments "a/b/c/e.js" 1 2}}')().should.equal('b');
+      hbs.compile('{{segments "a/b/c/e.js" 0 3}}')().should.equal('a/b/c');
+      hbs.compile('{{segments "a/b/c/e.js" 2 3}}')().should.equal('c');
+      hbs.compile('{{segments "a/b/c/e.js" 0 3}}')().should.equal('a/b/c');
+    });
+  });
 });
diff --git a/test/string.js b/test/string.js
index 5b578b6c..f47c7197 100644
--- a/test/string.js
+++ b/test/string.js
@@ -6,25 +6,29 @@ var helpers = require('..');
 helpers.string({handlebars: hbs});
 
 describe('string', function() {
-  describe('capitalize', function() {
+  describe('camelcase', function() {
     it('should return an empty string if undefined', function() {
-      var fn = hbs.compile('{{capitalize}}');
+      var fn = hbs.compile('{{camelcase}}');
       fn().should.equal('');
     });
-    it('should capitalize a word.', function() {
-      var fn = hbs.compile('{{capitalize "foo"}}');
-      fn().should.equal('Foo');
+    it('should return the string in camelcase', function() {
+      var fn = hbs.compile('{{camelcase "foo bar baz qux"}}');
+      fn().should.equal('fooBarBazQux');
+    });
+    it('should lowercase a single character', function() {
+      hbs.compile('{{camelcase "f"}}')().should.equal('f');
+      hbs.compile('{{camelcase "A"}}')().should.equal('a');
     });
   });
 
-  describe('capitalizeFirst', function() {
+  describe('capitalize', function() {
     it('should return an empty string if undefined', function() {
-      var fn = hbs.compile('{{capitalizeFirst}}');
+      var fn = hbs.compile('{{capitalize}}');
       fn().should.equal('');
     });
-    it('should return the string with the first word capitalized.', function() {
-      var fn = hbs.compile('{{capitalizeFirst "bender should not be allowed on tv"}}');
-      fn().should.equal('Bender should not be allowed on tv');
+    it('should capitalize a word.', function() {
+      var fn = hbs.compile('{{capitalize "foo"}}');
+      fn().should.equal('Foo');
     });
   });
 
@@ -39,17 +43,6 @@ describe('string', function() {
     });
   });
 
-  describe('capitalizeEach', function() {
-    it('should return an empty string if undefined', function() {
-      var fn = hbs.compile('{{capitalizeEach}}');
-      fn().should.equal('');
-    });
-    it('should return the string with the every word capitalized.', function() {
-      var fn = hbs.compile('{{capitalizeEach "bender should not bE allowed on tV"}}');
-      fn().should.equal('Bender Should Not BE Allowed On TV');
-    });
-  });
-
   describe('center', function() {
     it('should return an empty string if undefined', function() {
       var fn = hbs.compile('{{center}}');
@@ -61,33 +54,48 @@ describe('string', function() {
     });
   });
 
-  describe('dashify', function() {
+  describe('chop', function() {
     it('should return an empty string if undefined', function() {
-      var fn = hbs.compile('{{dashify}}');
+      var fn = hbs.compile('{{chop}}');
       fn().should.equal('');
     });
-    it('should return the string with periods replaced with hyphens.', function() {
-      var fn = hbs.compile('{{dashify "Bender.should.not.be.allowed.on.tv."}}');
-      fn().should.equal('Bender-should-not-be-allowed-on-tv-');
+    it('should remove non-word characters from start of string', function() {
+      var fn = hbs.compile('{{chop "- foo bar baz"}}');
+      fn().should.equal('foo bar baz');
+    });
+    it('should remove non-word characters from end of string', function() {
+      var fn = hbs.compile('{{chop "foo bar baz _- "}}');
+      fn().should.equal('foo bar baz');
     });
   });
 
-  describe('ellipsis', function() {
+  describe('dashcase', function() {
     it('should return an empty string if undefined', function() {
-      var fn = hbs.compile('{{ellipsis}}');
+      var fn = hbs.compile('{{dashcase}}');
       fn().should.equal('');
     });
-    it('should return then string truncated by a specified length.', function() {
-      var fn = hbs.compile('{{ellipsis "Bender should not be allowed on tv." 31}}');
-      fn().should.equal('Bender should not be allowed on');
+    it('should return the string in dashcase', function() {
+      var fn = hbs.compile('{{dashcase "foo bar baz qux"}}');
+      fn().should.equal('foo-bar-baz-qux');
+    });
+    it('should lowercase a single character', function() {
+      hbs.compile('{{dashcase "f"}}')().should.equal('f');
+      hbs.compile('{{dashcase "A"}}')().should.equal('a');
+    });
+  });
+
+  describe('dotcase', function() {
+    it('should return an empty string if undefined', function() {
+      var fn = hbs.compile('{{dotcase}}');
+      fn().should.equal('');
     });
-    it('should return the string if shorter than the specified length.', function() {
-      var fn = hbs.compile('{{ellipsis "Bender should not be allowed on tv." 100}}');
-      fn().should.equal('Bender should not be allowed on tv.');
+    it('should return the string in dotcase', function() {
+      var fn = hbs.compile('{{dotcase "foo bar baz qux"}}');
+      fn().should.equal('foo.bar.baz.qux');
     });
-    it('should return the string truncated by a specified length, providing a custom string to denote an omission.', function() {
-      var fn = hbs.compile('{{ellipsis "Bender should not be allowed on tv." 31 "..."}}');
-      fn().should.equal('Bender should not be allowed...');
+    it('should lowercase a single character', function() {
+      hbs.compile('{{dotcase "f"}}')().should.equal('f');
+      hbs.compile('{{dotcase "A"}}')().should.equal('a');
     });
   });
 
@@ -124,6 +132,36 @@ describe('string', function() {
     });
   });
   
+  describe('pascalcase', function() {
+    it('should return an empty string if undefined', function() {
+      var fn = hbs.compile('{{pascalcase}}');
+      fn().should.equal('');
+    });
+    it('should return the string in pascalcase', function() {
+      var fn = hbs.compile('{{pascalcase "foo bar baz qux"}}');
+      fn().should.equal('FooBarBazQux');
+    });
+    it('should uppercase a single character', function() {
+      hbs.compile('{{pascalcase "f"}}')().should.equal('F');
+      hbs.compile('{{pascalcase "A"}}')().should.equal('A');
+    });
+  });
+
+  describe('pathcase', function() {
+    it('should return an empty string if undefined', function() {
+      var fn = hbs.compile('{{pathcase}}');
+      fn().should.equal('');
+    });
+    it('should return the string in pathcase', function() {
+      var fn = hbs.compile('{{pathcase "foo bar baz qux"}}');
+      fn().should.equal('foo/bar/baz/qux');
+    });
+    it('should lowercase a single character', function() {
+      hbs.compile('{{pathcase "f"}}')().should.equal('f');
+      hbs.compile('{{pathcase "A"}}')().should.equal('a');
+    });
+  });
+
   describe('plusify', function() {
     it('should return an empty string if undefined', function() {
       var fn = hbs.compile('{{plusify}}');
@@ -152,6 +190,14 @@ describe('string', function() {
       var fn = hbs.compile('{{replace "Bender Bending Rodriguez" "B" "M"}}');
       fn().should.equal('Mender Mending Rodriguez');
     });
+    it('should return the string if `a` is undefined', function() {
+      var fn = hbs.compile('{{replace "a b c"}}');
+      fn().should.equal('a b c');
+    });
+    it('should replace the string with `""` if `b` is undefined', function() {
+      var fn = hbs.compile('{{replace "a b c" "a"}}');
+      fn().should.equal(' b c');
+    });
   });
 
   describe('reverse', function() {
@@ -176,6 +222,36 @@ describe('string', function() {
     });
   });
 
+  describe('snakecase', function() {
+    it('should return an empty string if undefined', function() {
+      var fn = hbs.compile('{{snakecase}}');
+      fn().should.equal('');
+    });
+    it('should lowercase a single character', function() {
+      hbs.compile('{{snakecase "a"}}')().should.equal('a');
+      hbs.compile('{{snakecase "A"}}')().should.equal('a');
+    });
+    it('should return the string in snakecase', function() {
+      var fn = hbs.compile('{{snakecase "foo bar baz qux"}}');
+      fn().should.equal('foo_bar_baz_qux');
+    });
+  });
+
+  describe('split', function() {
+    it('should return an empty string if undefined', function() {
+      var fn = hbs.compile('{{split}}');
+      fn().should.equal('');
+    });
+    it('should split the string with the default character', function() {
+      var fn = hbs.compile('{{#each (split "a,b,c")}}<{{.}}>{{/each}}');
+      fn().should.equal('<a><b><c>');
+    });
+    it('should split the string on the given character', function() {
+      var fn = hbs.compile('{{#each (split "a|b|c" "|")}}<{{.}}>{{/each}}');
+      fn().should.equal('<a><b><c>');
+    });
+  });
+
   describe('titleize', function() {
     it('should return an empty string if undefined', function() {
       var fn = hbs.compile('{{titleize}}');
@@ -187,22 +263,18 @@ describe('string', function() {
     });
   });
 
-  describe('truncate', function() {
+  describe('trim', function() {
     it('should return an empty string if undefined', function() {
-      var fn = hbs.compile('{{truncate}}');
+      var fn = hbs.compile('{{trim}}');
       fn().should.equal('');
     });
-    it('should return the string truncated by a specified length.', function() {
-      var fn = hbs.compile('{{truncate "Bender should not be allowed on tv." 31}}');
-      fn().should.equal('Bender should not be allowed on');
-    });
-    it('should return the string if shorter than the specified length.', function() {
-      var fn = hbs.compile('{{truncate "Bender should not be allowed on tv." 100}}');
-      fn().should.equal('Bender should not be allowed on tv.');
+    it('should trim leading whitespace', function() {
+      var fn = hbs.compile('{{trim "    foo"}}');
+      fn().should.equal('foo');
     });
-    it('should return then string truncated by a specified length, providing a custom string to denote an omission.', function() {
-      var fn = hbs.compile('{{truncate "Bender should not be allowed on tv." 31 "..."}}');
-      fn().should.equal('Bender should not be allowed...');
+    it('should trim trailing whitespace', function() {
+      var fn = hbs.compile('{{trim "foo   "}}');
+      fn().should.equal('foo');
     });
   });