Created
June 30, 2014 19:11
-
-
Save grossadamm/11add4b4681df3a23804 to your computer and use it in GitHub Desktop.
Jasmine-fixture requirejs
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* jasmine-fixture - 1.2.0 | |
* Makes injecting HTML snippets into the DOM easy & clean! | |
* https://github.com/searls/jasmine-fixture | |
*/ | |
(function() { | |
var createHTMLBlock, | |
__slice = [].slice; | |
require(['jquery'], function($) { | |
var ewwSideEffects, jasmineFixture, originalAffix, originalJasmineDotFixture, originalJasmineFixture, root, _, _ref; | |
root = this; | |
originalJasmineFixture = root.jasmineFixture; | |
originalJasmineDotFixture = (_ref = root.jasmine) != null ? _ref.fixture : void 0; | |
originalAffix = root.affix; | |
_ = function(list) { | |
return { | |
inject: function(iterator, memo) { | |
var item, _i, _len, _results; | |
_results = []; | |
for (_i = 0, _len = list.length; _i < _len; _i++) { | |
item = list[_i]; | |
_results.push(memo = iterator(memo, item)); | |
} | |
return _results; | |
} | |
}; | |
}; | |
root.jasmineFixture = function($) { | |
var $whatsTheRootOf, affix, create, jasmineFixture, noConflict; | |
affix = function(selectorOptions) { | |
return create.call(this, selectorOptions, true); | |
}; | |
create = function(selectorOptions, attach) { | |
var $top; | |
$top = null; | |
_(selectorOptions.split(/[ ](?=[^\]]*?(?:\[|$))/)).inject(function($parent, elementSelector) { | |
var $el; | |
if (elementSelector === ">") { | |
return $parent; | |
} | |
$el = createHTMLBlock($, elementSelector); | |
if (attach || $top) { | |
$el.appendTo($parent); | |
} | |
$top || ($top = $el); | |
return $el; | |
}, $whatsTheRootOf(this)); | |
return $top; | |
}; | |
noConflict = function() { | |
var currentJasmineFixture, _ref1; | |
currentJasmineFixture = jasmine.fixture; | |
root.jasmineFixture = originalJasmineFixture; | |
if ((_ref1 = root.jasmine) != null) { | |
_ref1.fixture = originalJasmineDotFixture; | |
} | |
root.affix = originalAffix; | |
return currentJasmineFixture; | |
}; | |
$whatsTheRootOf = function(that) { | |
if (that.jquery != null) { | |
return that; | |
} else if ($('#jasmine_content').length > 0) { | |
return $('#jasmine_content'); | |
} else { | |
return $('<div id="jasmine_content"></div>').appendTo('body'); | |
} | |
}; | |
jasmineFixture = { | |
affix: affix, | |
create: create, | |
noConflict: noConflict | |
}; | |
ewwSideEffects(jasmineFixture); | |
return jasmineFixture; | |
}; | |
ewwSideEffects = function(jasmineFixture) { | |
var _ref1; | |
if ((_ref1 = root.jasmine) != null) { | |
_ref1.fixture = jasmineFixture; | |
} | |
$.fn.affix = root.affix = jasmineFixture.affix; | |
return afterEach(function() { | |
return $('#jasmine_content').remove(); | |
}); | |
}; | |
if ($) { | |
return jasmineFixture = root.jasmineFixture($); | |
} else { | |
return root.affix = function() { | |
var nowJQueryExists; | |
nowJQueryExists = window.jQuery || window.$; | |
if (nowJQueryExists != null) { | |
jasmineFixture = root.jasmineFixture(nowJQueryExists); | |
return affix.call.apply(affix, [this].concat(__slice.call(arguments))); | |
} else { | |
throw new Error("jasmine-fixture requires jQuery to be defined at window.jQuery or window.$"); | |
} | |
}; | |
} | |
}) | |
createHTMLBlock = (function() { | |
var bindData, bindEvents, parseAttributes, parseClasses, parseContents, parseEnclosure, parseReferences, parseVariableScope, regAttr, regAttrDfn, regAttrs, regCBrace, regClass, regClasses, regData, regDatas, regEvent, regEvents, regExclamation, regId, regReference, regTag, regTagNotContent, regZenTagDfn; | |
createHTMLBlock = function($, ZenObject, data, functions, indexes) { | |
var ZenCode, arr, block, blockAttrs, blockClasses, blockHTML, blockId, blockTag, blocks, el, el2, els, forScope, indexName, inner, len, obj, origZenCode, paren, result, ret, zc, zo; | |
if ($.isPlainObject(ZenObject)) { | |
ZenCode = ZenObject.main; | |
} else { | |
ZenCode = ZenObject; | |
ZenObject = { | |
main: ZenCode | |
}; | |
} | |
origZenCode = ZenCode; | |
if (indexes === undefined) { | |
indexes = {}; | |
} | |
if (ZenCode.charAt(0) === "!" || $.isArray(data)) { | |
if ($.isArray(data)) { | |
forScope = ZenCode; | |
} else { | |
obj = parseEnclosure(ZenCode, "!"); | |
obj = obj.substring(obj.indexOf(":") + 1, obj.length - 1); | |
forScope = parseVariableScope(ZenCode); | |
} | |
while (forScope.charAt(0) === "@") { | |
forScope = parseVariableScope("!for:!" + parseReferences(forScope, ZenObject)); | |
} | |
zo = ZenObject; | |
zo.main = forScope; | |
el = $(); | |
if (ZenCode.substring(0, 5) === "!for:" || $.isArray(data)) { | |
if (!$.isArray(data) && obj.indexOf(":") > 0) { | |
indexName = obj.substring(0, obj.indexOf(":")); | |
obj = obj.substr(obj.indexOf(":") + 1); | |
} | |
arr = ($.isArray(data) ? data : data[obj]); | |
zc = zo.main; | |
if ($.isArray(arr) || $.isPlainObject(arr)) { | |
$.map(arr, function(value, index) { | |
var next; | |
zo.main = zc; | |
if (indexName !== undefined) { | |
indexes[indexName] = index; | |
} | |
if (!$.isPlainObject(value)) { | |
value = { | |
value: value | |
}; | |
} | |
next = createHTMLBlock($, zo, value, functions, indexes); | |
if (el.length !== 0) { | |
return $.each(next, function(index, value) { | |
return el.push(value); | |
}); | |
} | |
}); | |
} | |
if (!$.isArray(data)) { | |
ZenCode = ZenCode.substr(obj.length + 6 + forScope.length); | |
} else { | |
ZenCode = ""; | |
} | |
} else if (ZenCode.substring(0, 4) === "!if:") { | |
result = parseContents("!" + obj + "!", data, indexes); | |
if (result !== "undefined" || result !== "false" || result !== "") { | |
el = createHTMLBlock($, zo, data, functions, indexes); | |
} | |
ZenCode = ZenCode.substr(obj.length + 5 + forScope.length); | |
} | |
ZenObject.main = ZenCode; | |
} else if (ZenCode.charAt(0) === "(") { | |
paren = parseEnclosure(ZenCode, "(", ")"); | |
inner = paren.substring(1, paren.length - 1); | |
ZenCode = ZenCode.substr(paren.length); | |
zo = ZenObject; | |
zo.main = inner; | |
el = createHTMLBlock($, zo, data, functions, indexes); | |
} else { | |
blocks = ZenCode.match(regZenTagDfn); | |
block = blocks[0]; | |
if (block.length === 0) { | |
return ""; | |
} | |
if (block.indexOf("@") >= 0) { | |
ZenCode = parseReferences(ZenCode, ZenObject); | |
zo = ZenObject; | |
zo.main = ZenCode; | |
return createHTMLBlock($, zo, data, functions, indexes); | |
} | |
block = parseContents(block, data, indexes); | |
blockClasses = parseClasses($, block); | |
if (regId.test(block)) { | |
blockId = regId.exec(block)[1]; | |
} | |
blockAttrs = parseAttributes(block, data); | |
blockTag = (block.charAt(0) === "{" ? "span" : "div"); | |
if (ZenCode.charAt(0) !== "#" && ZenCode.charAt(0) !== "." && ZenCode.charAt(0) !== "{") { | |
blockTag = regTag.exec(block)[1]; | |
} | |
if (block.search(regCBrace) !== -1) { | |
blockHTML = block.match(regCBrace)[1]; | |
} | |
blockAttrs = $.extend(blockAttrs, { | |
id: blockId, | |
"class": blockClasses, | |
html: blockHTML | |
}); | |
el = $("<" + blockTag + ">", blockAttrs); | |
el.attr(blockAttrs); | |
el = bindEvents(block, el, functions); | |
el = bindData(block, el, data); | |
ZenCode = ZenCode.substr(blocks[0].length); | |
ZenObject.main = ZenCode; | |
} | |
if (ZenCode.length > 0) { | |
if (ZenCode.charAt(0) === ">") { | |
if (ZenCode.charAt(1) === "(") { | |
zc = parseEnclosure(ZenCode.substr(1), "(", ")"); | |
ZenCode = ZenCode.substr(zc.length + 1); | |
} else if (ZenCode.charAt(1) === "!") { | |
obj = parseEnclosure(ZenCode.substr(1), "!"); | |
forScope = parseVariableScope(ZenCode.substr(1)); | |
zc = obj + forScope; | |
ZenCode = ZenCode.substr(zc.length + 1); | |
} else { | |
len = Math.max(ZenCode.indexOf("+"), ZenCode.length); | |
zc = ZenCode.substring(1, len); | |
ZenCode = ZenCode.substr(len); | |
} | |
zo = ZenObject; | |
zo.main = zc; | |
els = $(createHTMLBlock($, zo, data, functions, indexes)); | |
els.appendTo(el); | |
} | |
if (ZenCode.charAt(0) === "+") { | |
zo = ZenObject; | |
zo.main = ZenCode.substr(1); | |
el2 = createHTMLBlock($, zo, data, functions, indexes); | |
$.each(el2, function(index, value) { | |
return el.push(value); | |
}); | |
} | |
} | |
ret = el; | |
return ret; | |
}; | |
bindData = function(ZenCode, el, data) { | |
var datas, i, split; | |
if (ZenCode.search(regDatas) === 0) { | |
return el; | |
} | |
datas = ZenCode.match(regDatas); | |
if (datas === null) { | |
return el; | |
} | |
i = 0; | |
while (i < datas.length) { | |
split = regData.exec(datas[i]); | |
if (split[3] === undefined) { | |
$(el).data(split[1], data[split[1]]); | |
} else { | |
$(el).data(split[1], data[split[3]]); | |
} | |
i++; | |
} | |
return el; | |
}; | |
bindEvents = function(ZenCode, el, functions) { | |
var bindings, fn, i, split; | |
if (ZenCode.search(regEvents) === 0) { | |
return el; | |
} | |
bindings = ZenCode.match(regEvents); | |
if (bindings === null) { | |
return el; | |
} | |
i = 0; | |
while (i < bindings.length) { | |
split = regEvent.exec(bindings[i]); | |
if (split[2] === undefined) { | |
fn = functions[split[1]]; | |
} else { | |
fn = functions[split[2]]; | |
} | |
$(el).bind(split[1], fn); | |
i++; | |
} | |
return el; | |
}; | |
parseAttributes = function(ZenBlock, data) { | |
var attrStrs, attrs, i, parts; | |
if (ZenBlock.search(regAttrDfn) === -1) { | |
return undefined; | |
} | |
attrStrs = ZenBlock.match(regAttrDfn); | |
attrs = {}; | |
i = 0; | |
while (i < attrStrs.length) { | |
parts = regAttr.exec(attrStrs[i]); | |
attrs[parts[1]] = ""; | |
if (parts[3] !== undefined) { | |
attrs[parts[1]] = parseContents(parts[3], data); | |
} | |
i++; | |
} | |
return attrs; | |
}; | |
parseClasses = function($, ZenBlock) { | |
var classes, clsString, i; | |
ZenBlock = ZenBlock.match(regTagNotContent)[0]; | |
if (ZenBlock.search(regClasses) === -1) { | |
return undefined; | |
} | |
classes = ZenBlock.match(regClasses); | |
clsString = ""; | |
i = 0; | |
while (i < classes.length) { | |
clsString += " " + regClass.exec(classes[i])[1]; | |
i++; | |
} | |
return $.trim(clsString); | |
}; | |
parseContents = function(ZenBlock, data, indexes) { | |
var html; | |
if (indexes === undefined) { | |
indexes = {}; | |
} | |
html = ZenBlock; | |
if (data === undefined) { | |
return html; | |
} | |
while (regExclamation.test(html)) { | |
html = html.replace(regExclamation, function(str, str2) { | |
var begChar, fn, val; | |
begChar = ""; | |
if (str.indexOf("!for:") > 0 || str.indexOf("!if:") > 0) { | |
return str; | |
} | |
if (str.charAt(0) !== "!") { | |
begChar = str.charAt(0); | |
str = str.substring(2, str.length - 1); | |
} | |
fn = new Function("data", "indexes", "var r=undefined;" + "with(data){try{r=" + str + ";}catch(e){}}" + "with(indexes){try{if(r===undefined)r=" + str + ";}catch(e){}}" + "return r;"); | |
val = unescape(fn(data, indexes)); | |
return begChar + val; | |
}); | |
} | |
html = html.replace(/\\./g, function(str) { | |
return str.charAt(1); | |
}); | |
return unescape(html); | |
}; | |
parseEnclosure = function(ZenCode, open, close, count) { | |
var index, ret; | |
if (close === undefined) { | |
close = open; | |
} | |
index = 1; | |
if (count === undefined) { | |
count = (ZenCode.charAt(0) === open ? 1 : 0); | |
} | |
if (count === 0) { | |
return; | |
} | |
while (count > 0 && index < ZenCode.length) { | |
if (ZenCode.charAt(index) === close && ZenCode.charAt(index - 1) !== "\\") { | |
count--; | |
} else { | |
if (ZenCode.charAt(index) === open && ZenCode.charAt(index - 1) !== "\\") { | |
count++; | |
} | |
} | |
index++; | |
} | |
ret = ZenCode.substring(0, index); | |
return ret; | |
}; | |
parseReferences = function(ZenCode, ZenObject) { | |
ZenCode = ZenCode.replace(regReference, function(str) { | |
var fn; | |
str = str.substr(1); | |
fn = new Function("objs", "var r=\"\";" + "with(objs){try{" + "r=" + str + ";" + "}catch(e){}}" + "return r;"); | |
return fn(ZenObject, parseReferences); | |
}); | |
return ZenCode; | |
}; | |
parseVariableScope = function(ZenCode) { | |
var forCode, rest, tag; | |
if (ZenCode.substring(0, 5) !== "!for:" && ZenCode.substring(0, 4) !== "!if:") { | |
return undefined; | |
} | |
forCode = parseEnclosure(ZenCode, "!"); | |
ZenCode = ZenCode.substr(forCode.length); | |
if (ZenCode.charAt(0) === "(") { | |
return parseEnclosure(ZenCode, "(", ")"); | |
} | |
tag = ZenCode.match(regZenTagDfn)[0]; | |
ZenCode = ZenCode.substr(tag.length); | |
if (ZenCode.length === 0 || ZenCode.charAt(0) === "+") { | |
return tag; | |
} else if (ZenCode.charAt(0) === ">") { | |
rest = ""; | |
rest = parseEnclosure(ZenCode.substr(1), "(", ")", 1); | |
return tag + ">" + rest; | |
} | |
return undefined; | |
}; | |
regZenTagDfn = /([#\.\@]?[\w-]+|\[([\w-!?=:"']+(="([^"]|\\")+")? {0,})+\]|\~[\w$]+=[\w$]+|&[\w$]+(=[\w$]+)?|[#\.\@]?!([^!]|\\!)+!){0,}(\{([^\}]|\\\})+\})?/i; | |
regTag = /(\w+)/i; | |
regId = /(?:^|\b)#([\w-!]+)/i; | |
regTagNotContent = /((([#\.]?[\w-]+)?(\[([\w!]+(="([^"]|\\")+")? {0,})+\])?)+)/i; | |
regClasses = /(\.[\w-]+)/g; | |
regClass = /\.([\w-]+)/i; | |
regReference = /(@[\w$_][\w$_\d]+)/i; | |
regAttrDfn = /(\[([\w-!]+(="?([^"]|\\")+"?)? {0,})+\])/ig; | |
regAttrs = /([\w-!]+(="([^"]|\\")+")?)/g; | |
regAttr = /([\w-!]+)(="?((([\w]+\[.*?\])|[^"\]]|\\")+)"?)?/i; | |
regCBrace = /\{(([^\}]|\\\})+)\}/i; | |
regExclamation = /(?:([^\\]|^))!([^!]|\\!)+!/g; | |
regEvents = /\~[\w$]+(=[\w$]+)?/g; | |
regEvent = /\~([\w$]+)=([\w$]+)/i; | |
regDatas = /&[\w$]+(=[\w$]+)?/g; | |
regData = /&([\w$]+)(=([\w$]+))?/i; | |
return createHTMLBlock; | |
})(); | |
}).call(this); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment