From b497cfb1a4b46e172af68247354905b243f60c5e Mon Sep 17 00:00:00 2001
From: Mottie <wowmotty@gmail.com>
Date: Thu, 28 Aug 2014 11:26:31 -0500
Subject: [PATCH] Filter: add defaultFilter option. Fixes #704

---
 docs/css/jq.css                               |   3 +-
 docs/example-widget-filter-any-match.html     |   7 +-
 docs/example-widget-filter-custom-search.html |  61 ++--
 docs/index.html                               |  53 +++-
 js/jquery.tablesorter.widgets.js              | 287 +++++++++++-------
 5 files changed, 272 insertions(+), 139 deletions(-)

diff --git a/docs/css/jq.css b/docs/css/jq.css
index 1b0b9473..0d1ba8a9 100644
--- a/docs/css/jq.css
+++ b/docs/css/jq.css
@@ -64,7 +64,8 @@ p.tip em, div.tip em,.label-info {padding: 2px; background-color: #5bc0de; color
 span.tip em, .label-success { background-color: #5cb85c; }
 .updated .label-success { background-color: #8eCe8e; }
 span.tip.old em, .label-default { background-color: #999; }
-span.warn em, .label.alert { background-color: #d9534f; }
+span.warning { background-color: #f0ad4e; } /* orange */
+span.warn em, .label.alert { background-color: #d9534f; } /* red */
 .label.warning { background-color: #f0ad4e; }
 tr td.lookhere, span.lookhere { background-color: rgba(230,191,153,0.5); }
 div.ui-slider .ui-slider-handle { width: 0.8em; height: 0.8em; }
diff --git a/docs/example-widget-filter-any-match.html b/docs/example-widget-filter-any-match.html
index 73e661fb..791a061d 100644
--- a/docs/example-widget-filter-any-match.html
+++ b/docs/example-widget-filter-any-match.html
@@ -30,6 +30,8 @@
 			// Set to use a jQuery selector (or jQuery object) pointing to the
 			// external filter (column specific or any match)
 			filter_external : '.search',
+			// add a default type search to the first name column
+			filter_defaultFilter: { 1 : '~{query}' },
 			// include column filters
 			filter_columnFilters: true,
 			filter_placeholder: { search : 'Search...' },
@@ -57,6 +59,7 @@
 		<h3><a href="#">Notes</a></h3>
 		<div>
 		<ul>
+			<li>In <span class="version">v2.17.8</span>, added a default fuzzy search to the "First Name" column.</li>
 			<li>This is a demo of the <a href="index.html#widget-filter-external"><code>filter_external</code></a> option (added <span class="version">v2.15</span>).</li>
 			<li>In <span class="version">v2.15</span>
 				<ul>
@@ -108,7 +111,7 @@ $('table').trigger('search', [ columns ]);</pre>
 	<h1>Demo</h1>
 
 	<div id="demo"><input class="search" type="search" data-column="all"> (Match any column)<br>
-<input class="search" type="search" data-column="1"> (First Name)<br>
+<input class="search" type="search" data-column="1"> (First Name; fuzzy search... try "be")<br>
 
 <!-- targeted by the "filter_reset" option -->
 <button type="button" class="reset">Reset Search</button>
@@ -117,7 +120,7 @@ $('table').trigger('search', [ columns ]);</pre>
 	<thead>
 		<tr>
 			<th>Rank</th>
-			<th>First Name</th>
+			<th data-placeholder="Fuzzy search">First Name</th>
 			<th>Last Name</th>
 			<th>Age</th>
 			<th>Total</th>
diff --git a/docs/example-widget-filter-custom-search.html b/docs/example-widget-filter-custom-search.html
index b0d29de4..36ad1ff0 100644
--- a/docs/example-widget-filter-custom-search.html
+++ b/docs/example-widget-filter-custom-search.html
@@ -30,27 +30,28 @@
 	</script>
 
 	<script id="js">// *** Filter search type function arguments ***
-// filter = filter input value for a column; iFilter = same as filter, except lowercase
-// exact = table cell text (or parsed data, if column parser enabled)
-// iExact = same as exact, except lowercase
+// data.filter = filter input value for a column; iFilter = same as filter, except lowercase
+// data.exact = table cell text (or parsed data, if column parser enabled)
+// data.iExact = same as exact, except lowercase
 
 // search for a match from the beginning of a string
 // "^l" matches "lion" but not "koala"
-$.tablesorter.filter.types.start = function( filter, iFilter, exact, iExact ) {
-	if ( /^\^/.test( iFilter ) ) {
-		return iExact.indexOf( iFilter.substring(1) ) === 0;
+$.tablesorter.filter.types.start = function( config, data ) {
+	if ( /^\^/.test( data.iFilter ) ) {
+		return data.iExact.indexOf( data.iFilter.substring(1) ) === 0;
 	}
 	return null;
 };
 
 // search for a match at the end of a string
 // "a$" matches "Llama" but not "aardvark"
-$.tablesorter.filter.types.end = function( filter, iFilter, exact, iExact ) {
-	if ( /\$$/.test( iFilter ) ) {
-		var fl = iFilter.length - 1,
-			f = iFilter.substring(0, fl),
-			el = iExact.length;
-		return iExact.lastIndexOf(f) + fl === el;
+$.tablesorter.filter.types.end = function( config, data ) {
+	if ( /\$$/.test( data.iFilter ) ) {
+		var filter = data.iFilter,
+			filterLength = filter.length - 1,
+			removedSymbol = filter.substring(0, filterLength),
+			exactLength = data.iExact.length;
+		return data.iExact.lastIndexOf(removedSymbol) + filterLength === exactLength;
 	}
 	return null;
 };
@@ -98,6 +99,7 @@ $(function() {
 		<h3><a href="#">Notes</a></h3>
 		<div>
 		<ul>
+			<li><span class="label warning">Notice!</span> In version <span class="version">v2.17.8</span>, some drastic changes were made to the way variables are passed to the filters. Please check out the "How to add Custom Filter types" section below.</li>
 			<li>This demo was added in <span class="version">v2.17.5</span>, but modification using these instructions works for v2.13.3+; when the filter widget was restructured to allow the adding of custom filter search types.</li>
 			<li>In this demo, two additional search types have been added as an example
 				<ul>
@@ -137,16 +139,35 @@ $(function() {
 			<li>Should it look for a symbol at the beginning, middle or end of the filter?</li>
 			<li>Does the designator need spaces around it (e.g. " and " or " or ") to prevent problems? You wouldn't be able to find the country of "Andorra" if the "and" or "or" designators didn't require spaces.</li>
 			<li>Make sure to name your filter so that it doesn't interfere with already existing ones, unless your filter is meant to replace an existing one. See the "Built-in Filters" section for a full list of filter function names.</li>
+			<li>Changed in <span class="version updated">v2.17.8</span>, only two parameters are passed to the filter type function:
+				<pre class="prettyprint lang-js">$.tablesorter.filter.types.myNewFilter = function( config, data ) { /* ... */ }</pre>
+				<ul>
+					<li><code>config</code> - tablesorter config containing all variables (<code>table.config</code>)</li>
+					<li><code>data</code> - filter data containing all filter variables. All variables are listed below.</li>
+				</ul>
+				<br>
+			</li>
 			<li>Within your filter, first test for your designator symbol.
 				<ul>
 					<li>If it exists within the filter, then do your comparison and return a boolean of <code>true</code> or <code>false</code>.</li>
-					<li>Four arguments are passed to the filter function:
+					<li>The following arguments are passed to the filter function within the <code>data</code> parameter (changed in <span class="version updated">v2.17.8</span>):
 						<ul>
-							<li><code>filter</code> - The exact text from the filter input (e.g. <code>^h</code>).</li>
-							<li><code>iFilter</code> - The text from the filter in all lower case for case insensitive searches.</li>
-							<li><code>exact</code> - The exact (or parsed) text from the current table cell; the parsed text is passed when the column has a <code>"filter-parsed"</code> class name set.</li>
-							<li><code>iExact</code> - The exact (or parsed) text in all lower case for case insensitive searches.</li>
+							<li><code>data.filter</code> - The exact text from the filter input (e.g. <code>^h</code>).</li>
+							<li><code>data.iFilter</code> - The text from the filter in all lower case for case insensitive searches.</li>
+							<li><code>data.exact</code> - The exact (or parsed) text from the current table cell, or the entire row if <code>data.anyMatch</code> is <code>true</code>; the parsed text is passed when the column has a <code>"filter-parsed"</code> class name set.</li>
+							<li><code>data.iExact</code> - The exact (or parsed) text in all lower case for case insensitive searches.<br><br></li>
+							<li><code>data.index</code> - The current column index (zero-based) being filtered. When performing an "any match", this index is equal to <code>config.columns</code> which is the last column of the table plus one.</li>
+							<li><code>data.cache</code> - The parsed text from the current table cell, or the entire row if <code>data.anyMatch</code> is <code>true</code>. This value will be in all lower case if <code>config.ignoreCase</code> is <code>true</code>.<br><br></li>
+
+							<li><code>data.anyMatch</code> - This is a boolean value indicating when the <code>data.exact</code> and <code>data.iExact</code> parameters contain data from the entire row instead of one cell. This value will always be <code>false</code> if the table does not include an associated any match filter.<br><br></li>
+
+							<li><code>data.rowArray</code> - An array of the exact text from each table cell.</li>
+							<li><code>data.cacheArray</code> - An array of parsed text from each table cell.</li>
+							<li><code>data.childRowText</code> - contains all text from any associated child rows.</li>
+
+							<li><code>data.parsed</code> - An array of boolean flags that indicate if the column data should obtained from parsed values, or not; obtained from <code>filter_useParsedData</code> setting or <code>filter-parsed</code> classes on the header cells.</li>
 						</ul>
+						<br>
 					</li>
 					<li>If your designator doesn't exist, you *must* return <code>null</code> to allow comparisons with other filter types.</li>
 				</ul>
@@ -154,17 +175,17 @@ $(function() {
 			<li>Here is a basic example with extensive comments:
 				<pre class="prettyprint lang-js">// search for a match from the beginning of a string
 // "^l" matches "lion" but not "koala"
-$.tablesorter.filter.types.start = function( filter, iFilter, exact, iExact ) {
+$.tablesorter.filter.types.start = function( config, data ) {
 	// test for filter type designator. In this example, "^" must be at the beginning of the filter
 	// for this test, the use of the case insensitive "iFilter" variable
 	// doesn't matter since we are only looking at the symbol
-	if ( /^\^/.test( iFilter ) ) {
+	if ( /^\^/.test( data.iFilter ) ) {
 		// test the table content (exact or parsed) against the filter
 		// * Don't forget to remove the designator first ( the substring(1) part ), so "^h".substring(1) becomes "h"
 		// * In this case, we do care about using "iFilter" since we're comparing it with "iExact"
 		// * We use "indexOf" so that we know the match starts from the beginning of the string.
 		// * Your function should return a boolean indicating a match, or not.
-		return iExact.indexOf( iFilter.substring(1) ) === 0;
+		return data.iExact.indexOf( data.iFilter.substring(1) ) === 0;
 	}
 	// ALWAYS return null if your custom filter type doesn't match
 	return null;
diff --git a/docs/index.html b/docs/index.html
index e3907a83..15fbd28b 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -479,7 +479,7 @@
 				<li><a href="example-widget-filter-any-match.html">external option (match any column)</a> (<span class="version">v2.13.3</span>; <span class="version updated">v2.15</span>)</li>
 				<li><a href="example-widget-filter-external-inputs.html">external inputs</a> (<span class="version">v2.14</span>; <span class="version updated">v2.15</span>)</li>
 				<li><a href="example-widget-filter-custom.html">custom</a> (v2.3.6; <span class="version updated">v2.10.1</span>)</li>
-				<li><a href="example-widget-filter-custom-search.html">custom searches</a> (<span class="version">v2.17.5</span>)</li>
+				<li><a href="example-widget-filter-custom-search.html">custom searches</a> (<span class="version">v2.17.5</span>; <span class="version updated">v2.17.8</span>)</li>
 				<li>formatter: <a href="example-widget-filter-formatter-1.html">jQuery UI widgets</a> and <a href="example-widget-filter-formatter-2.html">HTML5 Elements</a> (v2.7.7; <span class="version updated">v2.17.5</span>).</li>
 				<li>formatter: <a href="example-widget-filter-formatter-select2.html">select2</a> (<span class="version">v2.16.0</span>; <span class="version updated">v2.17.5</span>)</li>
 			</ul>
@@ -1623,6 +1623,8 @@ $(function(){
       filter_cssFilter     : '',
       // data attribute in the header cell that contains the default filter value
       filter_defaultAttrib : 'data-value',
+      // add a default column filter type "~{query}" to make fuzzy searches default; "{q1} AND {q2}" to make all searches use a logical AND.
+      filter_defaultFilter : [],
       // jQuery selector string (or jQuery object) of external search inputs
       filter_external      : '',
       // class added to filtered rows; needed by pager plugin
@@ -2043,6 +2045,55 @@ $(function(){
 				<td><a href="example-widget-filter.html">Example</a></td>
 			</tr>
 
+			<tr id="widget-defaultfilter">
+				<td><a href="#" class="permalink">filter_defaultFilter</a></td>
+				<td>Object</td>
+				<td>{ }</td>
+				<td>
+					Filter widget: Add a default filter type to a column (<span class="version">v2.17.8</span>).
+					<div class="collapsible">
+					<br>
+					<span class="label warning">Warning</span> If a column has a default filter set, the user <strong>will not</strong> be able to use other filters.<br>
+					<br>
+					Use the <a href="#widget-defaultfilter"><code>filter_defaultFilter</code></a> option as follows:
+						<pre class="prettyprint lang-js">$(function(){
+  $("table").tablesorter({
+    widgets: ["filter"],
+    widgetOptions : {
+
+      filter_defaultFilter : {
+        // target a column by class name or column index (zero-based)
+
+        '.fuzzy' : '~{q}',
+        2 : '{q}=',
+
+        // for default "anyMatches" use the column length as the index
+        // e.g. if your table has 5 columns (0,1,2,3,4), then set the anyMatch column as 5.
+        5 : '{q} or {q}' // any match column
+      }
+
+    }
+  });
+});</pre>
+					Set up the column string as follows:
+					<ul>
+						<li>Add the desired filter type symbol along with <code>{query}</code> or <code>{q}</code> to maintain positioning</li>
+						<li>Symbols can be added to the beginning <code>"~{query}"</code> (default fuzzy search) or end <code>"{q}="</code> (default exact search)</li>
+						<li>For symbols that separate queries, like "AND", "OR" or "-" (range):
+							<ul>
+								<li>Add one additional <code>{q}</code> tag.</li>
+								<li>For example, to add a default "OR" search, use <code>"{q} OR {q}"</code>.</li>
+								<li>If the user enters <code>"a b c d"</code> the column will be filtered using <code>"a OR b OR c OR d"</code>, so there is no need to add more <code>{q}</code> tags within the string; adding more will likely mess up the results.</li>
+								<li>If the user only enters <code>"a"</code>, then the column will be filtered using <code>"a OR a"</code> so as not to cause other issues.</li>
+							</ul>
+						</li>
+						<li><span class="label label-info">Note</span> It is not possible to set up a default filter search within a query. So the "wild" filter search will not work as intended (e.g. <code>{q}*</code> and <code>{q}?</code> are essentially the same as <code>{q}</code>.</li>
+					</ul>
+					</div>
+				</td>
+				<td><a href="example-widget-filter-any-match.html">Example</a></td>
+			</tr>
+
 			<tr id="widget-filter-external">
 				<td><a href="#" class="permalink">filter_external</a></td>
 				<td>String</td>
diff --git a/js/jquery.tablesorter.widgets.js b/js/jquery.tablesorter.widgets.js
index f96c7d02..6c48c048 100644
--- a/js/jquery.tablesorter.widgets.js
+++ b/js/jquery.tablesorter.widgets.js
@@ -245,7 +245,7 @@ ts.addWidget({
 			ts.benchmark("Applying " + theme + " theme", time);
 		}
 	},
-	remove: function(table, c, wo) {
+	remove: function(table, c) {
 		var $table = c.$table,
 			theme = c.theme || 'jui',
 			themes = ts.themes[ theme ] || ts.themes.jui,
@@ -354,6 +354,7 @@ ts.addWidget({
 		filter_childRows     : false, // if true, filter includes child row content in the search
 		filter_columnFilters : true,  // if true, a filter will be added to the top of each table column
 		filter_cssFilter     : '',    // css class name added to the filter row & each input in the row (tablesorter-filter is ALWAYS added)
+		filter_defaultFilter : [],    // add a default column filter type "~{query}" to make fuzzy searches default; "{q1} AND {q2}" to make all searches use a logical AND.
 		filter_external      : '',    // jQuery selector string (or jQuery object) of external filters
 		filter_filteredRow   : 'filtered', // class added to filtered rows; needed by pager plugin
 		filter_formatter     : null,  // add custom filter elements to the filter row
@@ -410,24 +411,25 @@ ts.filter = {
 		type      : /undefined|number/, // check type
 		exact     : /(^[\"|\'|=]+)|([\"|\'|=]+$)/g, // exact match (allow '==')
 		nondigit  : /[^\w,. \-()]/g, // replace non-digits (from digit & currency parser)
-		operators : /[<>=]/g // replace operators
+		operators : /[<>=]/g, // replace operators
+		query     : '(q|query)' // replace filter queries
 	},
-		// function( filter, iFilter, exact, iExact, cached, index, table, wo, parsed )
-		// filter = array of filter input values; iFilter = same array, except lowercase
-		// exact = table cell text (or parsed data if column parser enabled)
-		// iExact = same as exact, except lowercase
-		// cached = table cell text from cache, so it has been parsed
-		// index = column index; table = table element (DOM)
-		// wo = widget options (table.config.widgetOptions)
-		// parsed = array (by column) of boolean values (from filter_useParsedData or "filter-parsed" class)
+		// function( c, data ) { }
+		// c = table.config
+		// data.filter = array of filter input values; data.iFilter = same array, except lowercase
+		// data.exact = table cell text (or parsed data if column parser enabled)
+		// data.iExact = same as data.exact, except lowercase
+		// data.cache = table cell text from cache, so it has been parsed
+		// data.index = column index; table = table element (DOM)
+		// data.parsed = array (by column) of boolean values (from filter_useParsedData or "filter-parsed" class)
 	types: {
 		// Look for regex
-		regex: function( filter, iFilter, exact, iExact ) {
-			if ( ts.filter.regex.regex.test(iFilter) ) {
+		regex: function( c, data ) {
+			if ( ts.filter.regex.regex.test(data.iFilter) ) {
 				var matches,
-					regex = ts.filter.regex.regex.exec(iFilter);
+					regex = ts.filter.regex.regex.exec(data.iFilter);
 				try {
-					matches = new RegExp(regex[1], regex[2]).test( iExact );
+					matches = new RegExp(regex[1], regex[2]).test( data.iExact );
 				} catch (error) {
 					matches = false;
 				}
@@ -436,27 +438,29 @@ ts.filter = {
 			return null;
 		},
 		// Look for operators >, >=, < or <=
-		operators: function( filter, iFilter, exact, iExact, cached, index, table, wo, parsed ) {
-			if ( /^[<>]=?/.test(iFilter) ) {
+		operators: function( c, data ) {
+			if ( /^[<>]=?/.test(data.iFilter) ) {
 				var cachedValue, result,
-					c = table.config,
-					query = ts.formatFloat( iFilter.replace(ts.filter.regex.operators, ''), table ),
+					table = c.table,
+					index = data.index,
+					parsed = data.parsed[index],
+					query = ts.formatFloat( data.iFilter.replace(ts.filter.regex.operators, ''), table ),
 					parser = c.parsers[index],
 					savedSearch = query;
 				// parse filter value in case we're comparing numbers (dates)
-				if (parsed[index] || parser.type === 'numeric') {
-					result = ts.filter.parseFilter(table, $.trim('' + iFilter.replace(ts.filter.regex.operators, '')), index, parsed[index], true);
+				if (parsed || parser.type === 'numeric') {
+					result = ts.filter.parseFilter(c, $.trim('' + data.iFilter.replace(ts.filter.regex.operators, '')), index, parsed, true);
 					query = ( typeof result === "number" && result !== '' && !isNaN(result) ) ? result : query;
 				}
 
 				// iExact may be numeric - see issue #149;
 				// check if cached is defined, because sometimes j goes out of range? (numeric columns)
-				cachedValue = ( parsed[index] || parser.type === 'numeric' ) && !isNaN(query) && typeof cached !== 'undefined' ? cached :
-					isNaN(iExact) ? ts.formatFloat( iExact.replace(ts.filter.regex.nondigit, ''), table) :
-					ts.formatFloat( iExact, table );
+				cachedValue = ( parsed || parser.type === 'numeric' ) && !isNaN(query) && typeof data.cache !== 'undefined' ? data.cache :
+					isNaN(data.iExact) ? ts.formatFloat( data.iExact.replace(ts.filter.regex.nondigit, ''), table) :
+					ts.formatFloat( data.iExact, table );
 
-				if ( />/.test(iFilter) ) { result = />=/.test(iFilter) ? cachedValue >= query : cachedValue > query; }
-				if ( /</.test(iFilter) ) { result = /<=/.test(iFilter) ? cachedValue <= query : cachedValue < query; }
+				if ( />/.test(data.iFilter) ) { result = />=/.test(data.iFilter) ? cachedValue >= query : cachedValue > query; }
+				if ( /</.test(data.iFilter) ) { result = /<=/.test(data.iFilter) ? cachedValue <= query : cachedValue < query; }
 				// keep showing all rows if nothing follows the operator
 				if ( !result && savedSearch === '' ) { result = true; }
 				return result;
@@ -464,37 +468,40 @@ ts.filter = {
 			return null;
 		},
 		// Look for a not match
-		notMatch: function( filter, iFilter, exact, iExact, cached, index, table, wo, parsed ) {
-			if ( /^\!/.test(iFilter) ) {
-				iFilter = ts.filter.parseFilter(table, iFilter.replace('!', ''), index, parsed[index]);
-				if (ts.filter.regex.exact.test(iFilter)) {
+		notMatch: function( c, data ) {
+			if ( /^\!/.test(data.iFilter) ) {
+				var indx,
+					filter = ts.filter.parseFilter(c, data.iFilter.replace('!', ''), data.index, data.parsed[data.index]);
+				if (ts.filter.regex.exact.test(filter)) {
 					// look for exact not matches - see #628
-					iFilter = iFilter.replace(ts.filter.regex.exact, '');
-					return iFilter === '' ? true : $.trim(iFilter) !== iExact;
+					filter = filter.replace(ts.filter.regex.exact, '');
+					return filter === '' ? true : $.trim(filter) !== data.iExact;
 				} else {
-					var indx = iExact.search( $.trim(iFilter) );
-					return iFilter === '' ? true : !(wo.filter_startsWith ? indx === 0 : indx >= 0);
+					indx = data.iExact.search( $.trim(filter) );
+					return filter === '' ? true : !(c.widgetOptions.filter_startsWith ? indx === 0 : indx >= 0);
 				}
 			}
 			return null;
 		},
 		// Look for quotes or equals to get an exact match; ignore type since iExact could be numeric
-		exact: function( filter, iFilter, exact, iExact, cached, index, table, wo, parsed, rowArray ) {
+		exact: function( c, data ) {
 			/*jshint eqeqeq:false */
-			if (ts.filter.regex.exact.test(iFilter)) {
-				var fltr = ts.filter.parseFilter(table, iFilter.replace(ts.filter.regex.exact, ''), index, parsed[index]);
-				return rowArray ? $.inArray(fltr, rowArray) >= 0 : fltr == iExact;
+			if (ts.filter.regex.exact.test(data.iFilter)) {
+				var filter = ts.filter.parseFilter(c, data.iFilter.replace(ts.filter.regex.exact, ''), data.index, data.parsed[data.index]);
+				return data.anyMatch ? $.inArray(filter, data.rowArray) >= 0 : filter == data.iExact;
 			}
 			return null;
 		},
 		// Look for an AND or && operator (logical and)
-		and : function( filter, iFilter, exact, iExact, cached, index, table, wo, parsed ) {
-			if ( ts.filter.regex.andTest.test(filter) ) {
-				var query = iFilter.split( ts.filter.regex.andSplit ),
-					result = iExact.search( $.trim(ts.filter.parseFilter(table, query[0], index, parsed[index])) ) >= 0,
+		and : function( c, data ) {
+			if ( ts.filter.regex.andTest.test(data.filter) ) {
+				var index = data.index,
+					parsed = data.parsed[index],
+					query = data.iFilter.split( ts.filter.regex.andSplit ),
+					result = data.iExact.search( $.trim( ts.filter.parseFilter(c, query[0], index, parsed) ) ) >= 0,
 					indx = query.length - 1;
 				while (result && indx) {
-					result = result && iExact.search( $.trim(ts.filter.parseFilter(table, query[indx], index, parsed[index])) ) >= 0;
+					result = result && data.iExact.search( $.trim( ts.filter.parseFilter(c, query[indx], index, parsed) ) ) >= 0;
 					indx--;
 				}
 				return result;
@@ -502,52 +509,55 @@ ts.filter = {
 			return null;
 		},
 		// Look for a range (using " to " or " - ") - see issue #166; thanks matzhu!
-		range : function( filter, iFilter, exact, iExact, cached, index, table, wo, parsed ) {
-			if ( ts.filter.regex.toTest.test(iFilter) ) {
+		range : function( c, data ) {
+			if ( ts.filter.regex.toTest.test(data.iFilter) ) {
 				var result, tmp,
-					c = table.config,
+					table = c.table,
+					index = data.index,
+					parsed = data.parsed[index],
 					// make sure the dash is for a range and not indicating a negative number
-					query = iFilter.split( ts.filter.regex.toSplit ),
-					range1 = ts.formatFloat( ts.filter.parseFilter(table, query[0].replace(ts.filter.regex.nondigit, ''), index, parsed[index]), table ),
-					range2 = ts.formatFloat( ts.filter.parseFilter(table, query[1].replace(ts.filter.regex.nondigit, ''), index, parsed[index]), table );
+					query = data.iFilter.split( ts.filter.regex.toSplit ),
+					range1 = ts.formatFloat( ts.filter.parseFilter(c, query[0].replace(ts.filter.regex.nondigit, ''), index, parsed), table ),
+					range2 = ts.formatFloat( ts.filter.parseFilter(c, query[1].replace(ts.filter.regex.nondigit, ''), index, parsed), table );
 					// parse filter value in case we're comparing numbers (dates)
-				if (parsed[index] || c.parsers[index].type === 'numeric') {
+				if (parsed || c.parsers[index].type === 'numeric') {
 					result = c.parsers[index].format('' + query[0], table, c.$headers.eq(index), index);
 					range1 = (result !== '' && !isNaN(result)) ? result : range1;
 					result = c.parsers[index].format('' + query[1], table, c.$headers.eq(index), index);
 					range2 = (result !== '' && !isNaN(result)) ? result : range2;
 				}
-				result = ( parsed[index] || c.parsers[index].type === 'numeric' ) && !isNaN(range1) && !isNaN(range2) ? cached :
-					isNaN(iExact) ? ts.formatFloat( iExact.replace(ts.filter.regex.nondigit, ''), table) :
-					ts.formatFloat( iExact, table );
+				result = ( parsed || c.parsers[index].type === 'numeric' ) && !isNaN(range1) && !isNaN(range2) ? data.cache :
+					isNaN(data.iExact) ? ts.formatFloat( data.iExact.replace(ts.filter.regex.nondigit, ''), table) :
+					ts.formatFloat( data.iExact, table );
 				if (range1 > range2) { tmp = range1; range1 = range2; range2 = tmp; } // swap
 				return (result >= range1 && result <= range2) || (range1 === '' || range2 === '');
 			}
 			return null;
 		},
 		// Look for wild card: ? = single, * = multiple, or | = logical OR
-		wild : function( filter, iFilter, exact, iExact, cached, index, table, wo, parsed, rowArray ) {
-			if ( /[\?|\*]/.test(iFilter) || ts.filter.regex.orReplace.test(filter) ) {
-				var c = table.config,
-					query = ts.filter.parseFilter(table, iFilter.replace(ts.filter.regex.orReplace, "|"), index, parsed[index]);
+		wild : function( c, data ) {
+			if ( /[\?|\*]/.test(data.iFilter) || ts.filter.regex.orReplace.test(data.filter) ) {
+				var index = data.index,
+					parsed = data.parsed[index],
+					query = ts.filter.parseFilter(c, data.iFilter.replace(ts.filter.regex.orReplace, "|"), index, parsed);
 				// look for an exact match with the "or" unless the "filter-match" class is found
 				if (!c.$headers.filter('[data-column="' + index + '"]:last').hasClass('filter-match') && /\|/.test(query)) {
-					query = $.isArray(rowArray) ? '(' + query + ')' : '^(' + query + ')$';
+					query = data.anyMatch && $.isArray(data.rowArray) ? '(' + query + ')' : '^(' + query + ')$';
 				}
 				// parsing the filter may not work properly when using wildcards =/
-				return new RegExp( query.replace(/\?/g, '\\S{1}').replace(/\*/g, '\\S*') ).test(iExact);
+				return new RegExp( query.replace(/\?/g, '\\S{1}').replace(/\*/g, '\\S*') ).test(data.iExact);
 			}
 			return null;
 		},
 		// fuzzy text search; modified from https://github.com/mattyork/fuzzy (MIT license)
-		fuzzy: function( filter, iFilter, exact, iExact, cached, index, table, wo, parsed ) {
-			if ( /^~/.test(iFilter) ) {
+		fuzzy: function( c, data ) {
+			if ( /^~/.test(data.iFilter) ) {
 				var indx,
 					patternIndx = 0,
-					len = iExact.length,
-					pattern = ts.filter.parseFilter(table, iFilter.slice(1), index, parsed[index]);
+					len = data.iExact.length,
+					pattern = ts.filter.parseFilter(c, data.iFilter.slice(1), data.index, data.parsed[data.index]);
 				for (indx = 0; indx < len; indx++) {
-					if (iExact[indx] === pattern[patternIndx]) {
+					if (data.iExact[indx] === pattern[patternIndx]) {
 						patternIndx += 1;
 					}
 				}
@@ -580,6 +590,7 @@ ts.filter = {
 		wo.filter_formatterCount = 0;
 		wo.filter_formatterInit = [];
 
+		txt = '\\{' + ts.filter.regex.query + '\\}';
 		$.extend( regex, {
 			child : new RegExp(c.cssChildRow),
 			filtered : new RegExp(wo.filter_filteredRow),
@@ -588,7 +599,9 @@ ts.filter = {
 			toSplit : new RegExp('(?:\\s+(?:-|' + ts.language.to + ')\\s+)' ,'gi'),
 			andTest : new RegExp('\\s+(' + ts.language.and + '|&&)\\s+', 'i'),
 			andSplit : new RegExp('(?:\\s+(?:' + ts.language.and + '|&&)\\s+)', 'gi'),
-			orReplace : new RegExp('\\s+(' + ts.language.or + ')\\s+', 'gi')
+			orReplace : new RegExp('\\s+(' + ts.language.or + ')\\s+', 'gi'),
+			iQuery : new RegExp(txt, 'i'),
+			igQuery : new RegExp(txt, 'ig')
 		});
 
 		// don't build filter row if columnFilters is false or all columns are set to "filter-false" - issue #156
@@ -780,10 +793,9 @@ ts.filter = {
 		c.$table.data('lastSearch', filters);
 		return filters;
 	},
-	parseFilter: function(table, filter, column, parsed, forceParse){
-		var c = table.config;
+	parseFilter: function(c, filter, column, parsed, forceParse){
 		return forceParse || parsed ?
-			c.parsers[column].format( filter, table, [], column ) :
+			c.parsers[column].format( filter, c.table, [], column ) :
 			filter;
 	},
 	buildRow: function(table, c, wo) {
@@ -991,26 +1003,51 @@ ts.filter = {
 				}, 200);
 			});
 	},
+	defaultFilter: function(filter, mask){
+		if (filter === '') { return filter; }
+		var regex = ts.filter.regex.iQuery,
+			maskRegex = ts.filter.regex.igQuery,
+			query = $.trim(filter).split(/\s/),
+			len = query.length - 1,
+			indx = 0,
+			val = mask;
+		if ( len < 1 && mask.match( maskRegex ).length > 1 ) {
+			// only one "word" in query but mask has >1 slots
+			query[1] = query[0];
+		}
+		// replace all {query} with query words...
+		// if query = "Bob", then convert mask from "!{query}" to "!Bob"
+		// if query = "Bob Joe Frank", then convert mask "{q} OR {q}" to "Bob OR Joe OR Frank"
+		while (regex.test(val)) {
+			val = val.replace(regex, query[indx++] || '');
+			if (regex.test(val) && indx < len && (query[indx] || '') !== '') {
+				val = mask.replace(regex, val);
+			}
+		}
+		return val;
+	},
 	findRows: function(table, filters, combinedFilters) {
 		if (table.config.lastCombinedFilter === combinedFilters) { return; }
-		var cached, len, $rows, rowIndex, tbodyIndex, $tbody, $cells, columnIndex,
-			childRow, childRowText, exact, iExact, iFilter, lastSearch, matches, result,
-			notFiltered, searchFiltered, filterMatched, showRow, time, val, indx,
-			anyMatch, iAnyMatch, rowArray, rowText, iRowText, rowCache, fxn, ffxn,
+		var len, $rows, rowIndex, tbodyIndex, $tbody, $cells, columnIndex,
+			childRow, lastSearch, matches, result, showRow, time, val, indx,
+			notFiltered, searchFiltered, filterMatched, fxn, ffxn,
 			regex = ts.filter.regex,
 			c = table.config,
 			wo = c.widgetOptions,
-			columns = c.columns,
 			$tbodies = c.$table.children('tbody'), // target all tbodies #568
+			// data object passed to filters; anyMatch is a flag for the filters
+			data = { anyMatch: false },
 			// anyMatch really screws up with these types of filters
-			anyMatchNotAllowedTypes = [ 'range', 'notMatch',  'operators' ],
-			// parse columns after formatter, in case the class is added at that point
-			parsed = c.$headers.map(function(columnIndex) {
-				return c.parsers && c.parsers[columnIndex] && c.parsers[columnIndex].parsed ||
-					// getData won't return "parsed" if other "filter-" class names exist (e.g. <th class="filter-select filter-parsed">)
-					ts.getData && ts.getData(c.$headers.filter('[data-column="' + columnIndex + '"]:last'), ts.getColumnData( table, c.headers, columnIndex ), 'filter') === 'parsed' ||
-					$(this).hasClass('filter-parsed');
-			}).get();
+			noAnyMatch = [ 'range', 'notMatch',  'operators' ];
+
+		// parse columns after formatter, in case the class is added at that point
+		data.parsed = c.$headers.map(function(columnIndex) {
+			return c.parsers && c.parsers[columnIndex] && c.parsers[columnIndex].parsed ||
+				// getData won't return "parsed" if other "filter-" class names exist (e.g. <th class="filter-select filter-parsed">)
+				ts.getData && ts.getData(c.$headers.filter('[data-column="' + columnIndex + '"]:last'), ts.getColumnData( table, c.headers, columnIndex ), 'filter') === 'parsed' ||
+				$(this).hasClass('filter-parsed');
+		}).get();
+
 		if (c.debug) { time = new Date(); }
 		// filtered rows count
 		c.filteredRows = 0;
@@ -1060,15 +1097,25 @@ ts.filter = {
 					ts.log( "Searching through " + ( searchFiltered && notFiltered < len ? notFiltered : "all" ) + " rows" );
 				}
 				if ((wo.filter_$anyMatch && wo.filter_$anyMatch.length) || filters[c.columns]) {
-					anyMatch = wo.filter_$anyMatch && wo.filter_$anyMatch.val() || filters[c.columns] || '';
+					data.anyMatchFlag = true;
+					data.anyMatchFilter = wo.filter_$anyMatch && wo.filter_$anyMatch.val() || filters[c.columns] || '';
 					if (c.sortLocaleCompare) {
 						// replace accents
-						anyMatch = ts.replaceAccents(anyMatch);
+						data.anyMatchFilter = ts.replaceAccents(data.anyMatchFilter);
 					}
-					iAnyMatch = anyMatch.toLowerCase();
+					if (wo.filter_defaultFilter && regex.iQuery.test( ts.getColumnData( table, wo.filter_defaultFilter, c.columns, true ) || '')) {
+						data.anyMatchFilter = ts.filter.defaultFilter(data.anyMatchFilter, wo.filter_defaultFilter[c.columns]);
+						// clear search filtered flag because default filters are not saved to the last search
+						searchFiltered = false;
+					}
+					data.iAnyMatchFilter = data.anyMatchFilter;
 				}
+
 				// loop through the rows
 				for (rowIndex = 0; rowIndex < len; rowIndex++) {
+
+					data.cacheArray = c.cache[tbodyIndex].normalized[rowIndex];
+
 					childRow = $rows[rowIndex].className;
 					// skip child rows & already filtered rows
 					if ( regex.child.test(childRow) || (searchFiltered && regex.filtered.test(childRow)) ) { continue; }
@@ -1078,15 +1125,16 @@ ts.filter = {
 					// so, if "table.config.widgetOptions.filter_childRows" is true and there is
 					// a match anywhere in the child row, then it will make the row visible
 					// checked here so the option can be changed dynamically
-					childRowText = (childRow.length && wo.filter_childRows) ? childRow.text() : '';
-					childRowText = wo.filter_ignoreCase ? childRowText.toLocaleLowerCase() : childRowText;
+					data.childRowText = (childRow.length && wo.filter_childRows) ? childRow.text() : '';
+					data.childRowText = wo.filter_ignoreCase ? data.childRowText.toLocaleLowerCase() : data.childRowText;
 					$cells = $rows.eq(rowIndex).children();
 
-					if (anyMatch) {
-						rowArray = $cells.map(function(i){
+					if (data.anyMatchFlag) {
+						data.anyMatch = true;
+						data.rowArray = $cells.map(function(i){
 							var txt;
-							if (parsed[i]) {
-								txt = c.cache[tbodyIndex].normalized[rowIndex][i];
+							if (data.parsed[i]) {
+								txt = data.cacheArray[i];
 							} else {
 								txt = wo.filter_ignoreCase ? $(this).text().toLowerCase() : $(this).text();
 								if (c.sortLocaleCompare) {
@@ -1095,13 +1143,15 @@ ts.filter = {
 							}
 							return txt;
 						}).get();
-						rowText = rowArray.join(' ');
-						iRowText = rowText.toLowerCase();
-						rowCache = c.cache[tbodyIndex].normalized[rowIndex].slice(0,-1).join(' ');
+						data.filter = data.anyMatchFilter;
+						data.iFilter = data.iAnyMatchFilter;
+						data.exact = data.rowArray.join(' ');
+						data.iExact = data.exact.toLowerCase();
+						data.cache = data.cacheArray.slice(0,-1).join(' ');
 						filterMatched = null;
 						$.each(ts.filter.types, function(type, typeFunction) {
-							if ($.inArray(type, anyMatchNotAllowedTypes) < 0) {
-								matches = typeFunction( anyMatch, iAnyMatch, rowText, iRowText, rowCache, columns, table, wo, parsed, rowArray );
+							if ($.inArray(type, noAnyMatch) < 0) {
+								matches = typeFunction( c, data );
 								if (matches !== null) {
 									filterMatched = matches;
 									return false;
@@ -1113,30 +1163,33 @@ ts.filter = {
 						} else {
 							if (wo.filter_startsWith) {
 								showRow = false;
-								columnIndex = columns;
+								columnIndex = c.columns;
 								while (!showRow && columnIndex > 0) {
 									columnIndex--;
-									showRow = showRow || rowArray[columnIndex].indexOf(iAnyMatch) === 0;
+									showRow = showRow || data.rowArray[columnIndex].indexOf(data.iFilter) === 0;
 								}
 							} else {
-								showRow = (iRowText + childRowText).indexOf(iAnyMatch) >= 0;
+								showRow = (data.iExact + data.childRowText).indexOf(data.iFilter) >= 0;
 							}
 						}
+						data.anyMatch = false;
 					}
 
-					for (columnIndex = 0; columnIndex < columns; columnIndex++) {
+					for (columnIndex = 0; columnIndex < c.columns; columnIndex++) {
+						data.filter = filters[columnIndex];
+						data.index = columnIndex;
 						// ignore if filter is empty or disabled
-						if (filters[columnIndex]) {
-							cached = c.cache[tbodyIndex].normalized[rowIndex][columnIndex];
+						if (data.filter) {
+							data.cache = data.cacheArray[columnIndex];
 							// check if column data should be from the cell or from parsed data
-							if (wo.filter_useParsedData || parsed[columnIndex]) {
-								exact = cached;
+							if (wo.filter_useParsedData || data.parsed[columnIndex]) {
+								data.exact = data.cache;
 							} else {
 							// using older or original tablesorter
-								exact = $.trim($cells.eq(columnIndex).text());
-								exact = c.sortLocaleCompare ? ts.replaceAccents(exact) : exact; // issue #405
+								data.exact = $.trim( $cells.eq(columnIndex).text() );
+								data.exact = c.sortLocaleCompare ? ts.replaceAccents(data.exact) : data.exact; // issue #405
 							}
-							iExact = !regex.type.test(typeof exact) && wo.filter_ignoreCase ? exact.toLocaleLowerCase() : exact;
+							data.iExact = !regex.type.test(typeof data.exact) && wo.filter_ignoreCase ? data.exact.toLocaleLowerCase() : data.exact;
 							result = showRow; // if showRow is true, show that row
 
 							// in case select filter option has a different value vs text "a - z|A through Z"
@@ -1144,28 +1197,32 @@ ts.filter = {
 								c.$filters.add(c.$externalFilters).filter('[data-column="'+ columnIndex + '"]').find('select option:selected').attr('data-function-name') || '' : '';
 
 							// replace accents - see #357
-							filters[columnIndex] = c.sortLocaleCompare ? ts.replaceAccents(filters[columnIndex]) : filters[columnIndex];
-							// val = case insensitive, filters[columnIndex] = case sensitive
-							iFilter = wo.filter_ignoreCase ? (filters[columnIndex] || '').toLocaleLowerCase() : filters[columnIndex];
+							data.filter = c.sortLocaleCompare ? ts.replaceAccents(data.filter) : data.filter;
+
+							if (wo.filter_defaultFilter && regex.iQuery.test( ts.getColumnData( table, wo.filter_defaultFilter, columnIndex ) || '')) {
+								data.filter = ts.filter.defaultFilter(data.filter, wo.filter_defaultFilter[columnIndex]);
+							}
+							// val = case insensitive, columnFilter = case sensitive
+							data.iFilter = wo.filter_ignoreCase ? (data.filter || '').toLocaleLowerCase() : data.filter;
 							fxn = ts.getColumnData( table, wo.filter_functions, columnIndex );
 							if (fxn) {
 								if (fxn === true) {
 									// default selector; no "filter-select" class
 									result = (c.$headers.filter('[data-column="' + columnIndex + '"]:last').hasClass('filter-match')) ?
-										iExact.search(iFilter) >= 0 : filters[columnIndex] === exact;
+										data.iExact.search(data.iFilter) >= 0 : data.filter === data.exact;
 								} else if (typeof fxn === 'function') {
 									// filter callback( exact cell content, parser normalized content, filter input value, column index, jQuery row object )
-									result = fxn(exact, cached, filters[columnIndex], columnIndex, $rows.eq(rowIndex));
-								} else if (typeof fxn[ffxn || filters[columnIndex]] === 'function') {
+									result = fxn(data.exact, data.cache, data.filter, columnIndex, $rows.eq(rowIndex));
+								} else if (typeof fxn[ffxn || data.filter] === 'function') {
 									// selector option function
-									result = fxn[ffxn || filters[columnIndex]](exact, cached, filters[columnIndex], columnIndex, $rows.eq(rowIndex));
+									result = fxn[ffxn || data.filter](data.exact, data.cache, data.filter, columnIndex, $rows.eq(rowIndex));
 								}
 							} else {
 								filterMatched = null;
 								// cycle through the different filters
 								// filters return a boolean or null if nothing matches
 								$.each(ts.filter.types, function(type, typeFunction) {
-									matches = typeFunction( filters[columnIndex], iFilter, exact, iExact, cached, columnIndex, table, wo, parsed );
+									matches = typeFunction( c, data );
 									if (matches !== null) {
 										filterMatched = matches;
 										return false;
@@ -1175,8 +1232,8 @@ ts.filter = {
 									result = filterMatched;
 								// Look for match, and add child row data for matching
 								} else {
-									exact = (iExact + childRowText).indexOf( ts.filter.parseFilter(table, iFilter, columnIndex, parsed[columnIndex]) );
-									result = ( (!wo.filter_startsWith && exact >= 0) || (wo.filter_startsWith && exact === 0) );
+									data.exact = (data.iExact + data.childRowText).indexOf( ts.filter.parseFilter(c, data.iFilter, columnIndex, data.parsed[columnIndex]) );
+									result = ( (!wo.filter_startsWith && data.exact >= 0) || (wo.filter_startsWith && data.exact === 0) );
 								}
 							}
 							showRow = (result) ? showRow : false;