/**
|
* Copyright (c) 2005 - 2010, James Auldridge
|
* All rights reserved.
|
*
|
* Licensed under the BSD, MIT, and GPL (your choice!) Licenses:
|
* http://code.google.com/p/cookies/wiki/License
|
*
|
*/
|
var jaaulde = window.jaaulde || {};
|
jaaulde.utils = jaaulde.utils || {};
|
jaaulde.utils.cookies = (function ()
|
{
|
var resolveOptions, assembleOptionsString, parseCookies, constructor, defaultOptions = {
|
expiresAt: null,
|
path: '/',
|
domain: null,
|
secure: false
|
};
|
/**
|
* resolveOptions - receive an options object and ensure all options are present and valid, replacing with defaults where necessary
|
*
|
* @access private
|
* @static
|
* @parameter Object options - optional options to start with
|
* @return Object complete and valid options object
|
*/
|
resolveOptions = function (options)
|
{
|
var returnValue, expireDate;
|
|
if (typeof options !== 'object' || options === null)
|
{
|
returnValue = defaultOptions;
|
}
|
else
|
{
|
returnValue = {
|
expiresAt: defaultOptions.expiresAt,
|
path: defaultOptions.path,
|
domain: defaultOptions.domain,
|
secure: defaultOptions.secure
|
};
|
|
if (typeof options.expiresAt === 'object' && options.expiresAt instanceof Date)
|
{
|
returnValue.expiresAt = options.expiresAt;
|
}
|
else if (typeof options.hoursToLive === 'number' && options.hoursToLive !== 0)
|
{
|
expireDate = new Date();
|
expireDate.setTime(expireDate.getTime() + (options.hoursToLive * 60 * 60 * 1000));
|
returnValue.expiresAt = expireDate;
|
}
|
|
if (typeof options.path === 'string' && options.path !== '')
|
{
|
returnValue.path = options.path;
|
}
|
|
if (typeof options.domain === 'string' && options.domain !== '')
|
{
|
returnValue.domain = options.domain;
|
}
|
|
if (options.secure === true)
|
{
|
returnValue.secure = options.secure;
|
}
|
}
|
|
return returnValue;
|
};
|
/**
|
* assembleOptionsString - analyze options and assemble appropriate string for setting a cookie with those options
|
*
|
* @access private
|
* @static
|
* @parameter options OBJECT - optional options to start with
|
* @return STRING - complete and valid cookie setting options
|
*/
|
assembleOptionsString = function (options)
|
{
|
options = resolveOptions(options);
|
|
return (
|
(typeof options.expiresAt === 'object' && options.expiresAt instanceof Date ? '; expires=' + options.expiresAt.toGMTString() : '') +
|
'; path=' + options.path +
|
(typeof options.domain === 'string' ? '; domain=' + options.domain : '') +
|
(options.secure === true ? '; secure' : '')
|
);
|
};
|
/**
|
* parseCookies - retrieve document.cookie string and break it into a hash with values decoded and unserialized
|
*
|
* @access private
|
* @static
|
* @return OBJECT - hash of cookies from document.cookie
|
*/
|
parseCookies = function ()
|
{
|
var cookies = {}, i, pair, name, value, separated = document.cookie.split(';'), unparsedValue;
|
for (i = 0; i < separated.length; i = i + 1)
|
{
|
pair = separated[i].split('=');
|
name = pair[0].replace(/^\s*/, '').replace(/\s*$/, '');
|
|
try
|
{
|
value = decodeURIComponent(pair[1]);
|
}
|
catch (e1)
|
{
|
value = pair[1];
|
}
|
|
if (typeof JSON === 'object' && JSON !== null && typeof JSON.parse === 'function')
|
{
|
try
|
{
|
unparsedValue = value;
|
value = JSON.parse(value);
|
}
|
catch (e2)
|
{
|
value = unparsedValue;
|
}
|
}
|
|
cookies[name] = value;
|
}
|
return cookies;
|
};
|
|
constructor = function () { };
|
|
/**
|
* get - get one, several, or all cookies
|
*
|
* @access public
|
* @paramater Mixed cookieName - String:name of single cookie; Array:list of multiple cookie names; Void (no param):if you want all cookies
|
* @return Mixed - Value of cookie as set; Null:if only one cookie is requested and is not found; Object:hash of multiple or all cookies (if multiple or all requested);
|
*/
|
constructor.prototype.get = function (cookieName)
|
{
|
var returnValue, item, cookies = parseCookies();
|
|
if (typeof cookieName === 'string')
|
{
|
returnValue = (typeof cookies[cookieName] !== 'undefined') ? cookies[cookieName] : null;
|
}
|
else if (typeof cookieName === 'object' && cookieName !== null)
|
{
|
returnValue = {};
|
for (item in cookieName)
|
{
|
if (typeof cookies[cookieName[item]] !== 'undefined')
|
{
|
returnValue[cookieName[item]] = cookies[cookieName[item]];
|
}
|
else
|
{
|
returnValue[cookieName[item]] = null;
|
}
|
}
|
}
|
else
|
{
|
returnValue = cookies;
|
}
|
|
return returnValue;
|
};
|
/**
|
* filter - get array of cookies whose names match the provided RegExp
|
*
|
* @access public
|
* @paramater Object RegExp - The regular expression to match against cookie names
|
* @return Mixed - Object:hash of cookies whose names match the RegExp
|
*/
|
constructor.prototype.filter = function (cookieNameRegExp)
|
{
|
var cookieName, returnValue = {}, cookies = parseCookies();
|
|
if (typeof cookieNameRegExp === 'string')
|
{
|
cookieNameRegExp = new RegExp(cookieNameRegExp);
|
}
|
|
for (cookieName in cookies)
|
{
|
if (cookieName.match(cookieNameRegExp))
|
{
|
returnValue[cookieName] = cookies[cookieName];
|
}
|
}
|
|
return returnValue;
|
};
|
/**
|
* set - set or delete a cookie with desired options
|
*
|
* @access public
|
* @paramater String cookieName - name of cookie to set
|
* @paramater Mixed value - Any JS value. If not a string, will be JSON encoded; NULL to delete
|
* @paramater Object options - optional list of cookie options to specify
|
* @return void
|
*/
|
constructor.prototype.set = function (cookieName, value, options)
|
{
|
if (typeof options !== 'object' || options === null)
|
{
|
options = {};
|
}
|
|
if (typeof value === 'undefined' || value === null)
|
{
|
value = '';
|
options.hoursToLive = -8760;
|
}
|
|
else if (typeof value !== 'string')
|
{
|
if (typeof JSON === 'object' && JSON !== null && typeof JSON.stringify === 'function')
|
{
|
value = JSON.stringify(value);
|
}
|
else
|
{
|
throw new Error('cookies.set() received non-string value and could not serialize.');
|
}
|
}
|
|
|
var optionsString = assembleOptionsString(options);
|
|
document.cookie = cookieName + '=' + encodeURIComponent(value) + optionsString;
|
};
|
/**
|
* del - delete a cookie (domain and path options must match those with which the cookie was set; this is really an alias for set() with parameters simplified for this use)
|
*
|
* @access public
|
* @paramater MIxed cookieName - String name of cookie to delete, or Bool true to delete all
|
* @paramater Object options - optional list of cookie options to specify ( path, domain )
|
* @return void
|
*/
|
constructor.prototype.del = function (cookieName, options)
|
{
|
var allCookies = {}, name;
|
|
if (typeof options !== 'object' || options === null)
|
{
|
options = {};
|
}
|
|
if (typeof cookieName === 'boolean' && cookieName === true)
|
{
|
allCookies = this.get();
|
}
|
else if (typeof cookieName === 'string')
|
{
|
allCookies[cookieName] = true;
|
}
|
|
for (name in allCookies)
|
{
|
if (typeof name === 'string' && name !== '')
|
{
|
this.set(name, null, options);
|
}
|
}
|
};
|
/**
|
* test - test whether the browser is accepting cookies
|
*
|
* @access public
|
* @return Boolean
|
*/
|
constructor.prototype.test = function ()
|
{
|
var returnValue = false, testName = 'cT', testValue = 'data';
|
|
this.set(testName, testValue);
|
|
if (this.get(testName) === testValue)
|
{
|
this.del(testName);
|
returnValue = true;
|
}
|
|
return returnValue;
|
};
|
/**
|
* setOptions - set default options for calls to cookie methods
|
*
|
* @access public
|
* @param Object options - list of cookie options to specify
|
* @return void
|
*/
|
constructor.prototype.setOptions = function (options)
|
{
|
if (typeof options !== 'object')
|
{
|
options = null;
|
}
|
|
defaultOptions = resolveOptions(options);
|
};
|
|
return new constructor();
|
})();
|
|
(function ()
|
{
|
if (window.jQuery)
|
{
|
(function ($)
|
{
|
$.cookies = jaaulde.utils.cookies;
|
|
var extensions = {
|
/**
|
* $( 'selector' ).cookify - set the value of an input field, or the innerHTML of an element, to a cookie by the name or id of the field or element
|
* (field or element MUST have name or id attribute)
|
*
|
* @access public
|
* @param options OBJECT - list of cookie options to specify
|
* @return jQuery
|
*/
|
cookify: function (options)
|
{
|
return this.each(function ()
|
{
|
var i, nameAttrs = ['name', 'id'], name, $this = $(this), value;
|
|
for (i in nameAttrs)
|
{
|
if (!isNaN(i))
|
{
|
name = $this.attr(nameAttrs[i]);
|
if (typeof name === 'string' && name !== '')
|
{
|
if ($this.is(':checkbox, :radio'))
|
{
|
if ($this.attr('checked'))
|
{
|
value = $this.val();
|
}
|
}
|
else if ($this.is(':input'))
|
{
|
value = $this.val();
|
}
|
else
|
{
|
value = $this.html();
|
}
|
|
if (typeof value !== 'string' || value === '')
|
{
|
value = null;
|
}
|
|
$.cookies.set(name, value, options);
|
|
break;
|
}
|
}
|
}
|
});
|
},
|
/**
|
* $( 'selector' ).cookieFill - set the value of an input field or the innerHTML of an element from a cookie by the name or id of the field or element
|
*
|
* @access public
|
* @return jQuery
|
*/
|
cookieFill: function ()
|
{
|
return this.each(function ()
|
{
|
var n, getN, nameAttrs = ['name', 'id'], name, $this = $(this), value;
|
|
getN = function ()
|
{
|
n = nameAttrs.pop();
|
return !!n;
|
};
|
|
while (getN())
|
{
|
name = $this.attr(n);
|
if (typeof name === 'string' && name !== '')
|
{
|
value = $.cookies.get(name);
|
if (value !== null)
|
{
|
if ($this.is(':checkbox, :radio'))
|
{
|
if ($this.val() === value)
|
{
|
$this.attr('checked', 'checked');
|
}
|
else
|
{
|
$this.removeAttr('checked');
|
}
|
}
|
else if ($this.is(':input'))
|
{
|
$this.val(value);
|
}
|
else
|
{
|
$this.html(value);
|
}
|
}
|
|
break;
|
}
|
}
|
});
|
},
|
/**
|
* $( 'selector' ).cookieBind - call cookie fill on matching elements, and bind their change events to cookify()
|
*
|
* @access public
|
* @param options OBJECT - list of cookie options to specify
|
* @return jQuery
|
*/
|
cookieBind: function (options)
|
{
|
return this.each(function ()
|
{
|
var $this = $(this);
|
$this.cookieFill().change(function ()
|
{
|
$this.cookify(options);
|
});
|
});
|
}
|
};
|
|
$.each(extensions, function (i)
|
{
|
$.fn[i] = this;
|
});
|
|
})(window.jQuery);
|
}
|
})();
|
