Joose = function () { throw "Modules may not be instantiated." }
Joose.top = this
Joose.VERSION = ({ /*VERSION*/VERSION : 3.011 }).VERSION
Joose.AUTHORITY = 'jsan:NPLATONOV'
// Static helpers for Arrays
Joose.A = {
each : function (array, func, scope) {
scope = scope || this
for (var i = 0, len = array.length; i < len; i++)
if (func.call(scope, array[i], i) === false) return false
},
exists : function (array, value) {
for (var i = 0, len = array.length; i < len; i++) if (array[i] == value) return true
return false
},
map : function (array, func, scope) {
scope = scope || this
var res = []
for (var i = 0, len = array.length; i < len; i++)
res.push( func.call(scope, array[i], i) )
return res
},
grep : function (array, func) {
var a = []
Joose.A.each(array, function (t) {
if (func(t)) a.push(t)
})
return a
},
remove : function (array, removeEle) {
var a = []
Joose.A.each(array, function (t) {
if (t !== removeEle) a.push(t)
})
return a
}
}
// Static helpers for Strings
Joose.S = {
saneSplit : function (str, delimeter) {
var res = (str || '').split(delimeter)
if (res.length == 1 && !res[0]) res.shift()
return res
},
uppercaseFirst : function (string) {
return string.substr(0, 1).toUpperCase() + string.substr(1, string.length - 1)
}
}
// Static helpers for objects
Joose.O = {
each : function (object, func, scope) {
scope = scope || this
for (var i in object)
if (func.call(scope, object[i], i) === false) return false
if (Joose.is_IE)
return Joose.A.each([ 'toString', 'constructor', 'hasOwnProperty' ], function (el) {
if (object.hasOwnProperty(el)) return func.call(scope, object[el], el)
})
},
eachOwn : function (object, func, scope) {
scope = scope || this
return Joose.O.each(object, function (value, name) {
if (object.hasOwnProperty(name)) return func.call(scope, value, name)
}, scope)
},
copy : function (source, target) {
target = target || {}
Joose.O.each(source, function (value, name) { target[name] = value })
return target
},
copyOwn : function (source, target) {
target = target || {}
Joose.O.eachOwn(source, function (value, name) { target[name] = value })
return target
},
getMutableCopy : function (object) {
var f = function () {}
f.prototype = object
return new f()
},
extend : function (target, source) {
return Joose.O.copy(source, target)
},
isEmpty : function (object) {
for (var i in object) if (object.hasOwnProperty(i)) return false
return true
},
isInstance: function (obj) {
return obj && obj.meta && obj.constructor == obj.meta.c
},
wantArray : function (obj) {
if (obj instanceof Array) return obj
return [ obj ]
},
// this was a bug in WebKit, which gives typeof / / == 'function'
// should be monitored and removed at some point in the future
isFunction : function (obj) {
return typeof obj == 'function' && obj.constructor != / /.constructor
}
}
//initializers
Joose.I = {
Array : function () { return [] },
Object : function () { return {} },
Function : function () { return function () {} },
Now : function () { return new Date() }
}
Joose.is_IE = '\v' == 'v'
Joose.is_NodeJS = Boolean(typeof process != 'undefined' && process.pid);
Joose.Proto = function () { throw "Modules may not be instantiated." }
Joose.Proto.Empty = function () { throw "Joose.Proto.Empty can't be instantiated" }
Joose.Proto.Empty.meta = {};
;(function () {
Joose.Proto.Object = function () {
throw "Joose.Proto.Object can't be instantiated"
}
var SUPER = function () {
var self = SUPER.caller
if (self == SUPERARG) self = self.caller
if (!self.SUPER) throw "Invalid call to SUPER"
return self.SUPER[self.methodName].apply(this, arguments)
}
var SUPERARG = function () {
return this.SUPER.apply(this, arguments[0])
}
Joose.Proto.Object.prototype = {
SUPERARG : SUPERARG,
SUPER : SUPER,
INNER : function () {
throw "Invalid call to INNER"
},
BUILD : function (config) {
return arguments.length == 1 && typeof config == 'object' && config || {}
},
initialize: function () {
},
toString: function () {
return "a " + this.meta.name
}
}
Joose.Proto.Object.meta = {
constructor : Joose.Proto.Object,
methods : Joose.O.copy(Joose.Proto.Object.prototype),
attributes : {}
}
Joose.Proto.Object.prototype.meta = Joose.Proto.Object.meta
})();
;(function () {
Joose.Proto.Class = function () {
return this.initialize(this.BUILD.apply(this, arguments)) || this
}
var bootstrap = {
VERSION : null,
AUTHORITY : null,
constructor : Joose.Proto.Class,
superClass : null,
name : null,
attributes : null,
methods : null,
meta : null,
c : null,
defaultSuperClass : Joose.Proto.Object,
BUILD : function (name, extend) {
this.name = name
return { __extend__ : extend || {} }
},
initialize: function (props) {
var extend = props.__extend__
this.VERSION = extend.VERSION
this.AUTHORITY = extend.AUTHORITY
delete extend.VERSION
delete extend.AUTHORITY
this.c = this.extractConstructor(extend)
this.adaptConstructor(this.c)
if (extend.constructorOnly) {
delete extend.constructorOnly
return
}
this.construct(extend)
},
construct : function (extend) {
if (!this.prepareProps(extend)) return
var superClass = this.superClass = this.extractSuperClass(extend)
this.processSuperClass(superClass)
this.adaptPrototype(this.c.prototype)
this.finalize(extend)
},
finalize : function (extend) {
this.processStem(extend)
this.extend(extend)
},
//if the extension returns false from this method it should re-enter 'construct'
prepareProps : function (extend) {
return true
},
extractConstructor : function (extend) {
var res = extend.hasOwnProperty('constructor') ? extend.constructor : this.defaultConstructor()
delete extend.constructor
return res
},
extractSuperClass : function (extend) {
var res = extend.isa || this.defaultSuperClass
delete extend.isa
return res
},
processStem : function () {
var superMeta = this.superClass.meta
this.methods = Joose.O.getMutableCopy(superMeta.methods || {})
this.attributes = Joose.O.getMutableCopy(superMeta.attributes || {})
},
initInstance : function (instance, props) {
Joose.O.copyOwn(props, instance)
},
defaultConstructor: function () {
return function (arg) {
var BUILD = this.BUILD
var args = BUILD && BUILD.apply(this, arguments) || arg || {}
var thisMeta = this.meta
thisMeta.initInstance(this, args)
return thisMeta.hasMethod('initialize') && this.initialize(args) || this
}
},
processSuperClass: function (superClass) {
var superProto = superClass.prototype
//non-Joose superclasses
if (!superClass.meta) {
var extend = Joose.O.copy(superProto)
extend.isa = Joose.Proto.Empty
var meta = new this.defaultSuperClass.meta.constructor(null, extend)
superClass.meta = superProto.meta = meta
meta.c = superClass
}
this.c.prototype = Joose.O.getMutableCopy(superProto)
this.c.superClass = superProto
},
adaptConstructor: function (c) {
c.meta = this
if (!c.hasOwnProperty('toString')) c.toString = function () { return this.meta.name }
},
adaptPrototype: function (proto) {
//this will fix weird semantic of native "constructor" property to more intuitive (idea borrowed from Ext)
proto.constructor = this.c
proto.meta = this
},
addMethod: function (name, func) {
func.SUPER = this.superClass.prototype
//chrome don't allow to redefine the "name" property
func.methodName = name
this.methods[name] = func
this.c.prototype[name] = func
},
addAttribute: function (name, init) {
this.attributes[name] = init
this.c.prototype[name] = init
},
removeMethod : function (name) {
delete this.methods[name]
delete this.c.prototype[name]
},
removeAttribute: function (name) {
delete this.attributes[name]
delete this.c.prototype[name]
},
hasMethod: function (name) {
return Boolean(this.methods[name])
},
hasAttribute: function (name) {
return this.attributes[name] !== undefined
},
hasOwnMethod: function (name) {
return this.hasMethod(name) && this.methods.hasOwnProperty(name)
},
hasOwnAttribute: function (name) {
return this.hasAttribute(name) && this.attributes.hasOwnProperty(name)
},
extend : function (props) {
Joose.O.eachOwn(props, function (value, name) {
if (name != 'meta' && name != 'constructor')
if (Joose.O.isFunction(value) && !value.meta)
this.addMethod(name, value)
else
this.addAttribute(name, value)
}, this)
},
subClassOf : function (classObject, extend) {
return this.subClass(extend, null, classObject)
},
subClass : function (extend, name, classObject) {
extend = extend || {}
extend.isa = classObject || this.c
return new this.constructor(name, extend).c
},
instantiate : function () {
var f = function () {}
f.prototype = this.c.prototype
var obj = new f()
return this.c.apply(obj, arguments) || obj
}
}
//micro bootstraping
Joose.Proto.Class.prototype = Joose.O.getMutableCopy(Joose.Proto.Object.prototype)
Joose.O.extend(Joose.Proto.Class.prototype, bootstrap)
Joose.Proto.Class.prototype.meta = new Joose.Proto.Class('Joose.Proto.Class', bootstrap)
Joose.Proto.Class.meta.addMethod('isa', function (someClass) {
var f = function () {}
f.prototype = this.c.prototype
return new f() instanceof someClass
})
})();
Joose.Managed = function () { throw "Modules may not be instantiated." }
Joose.Managed.Property = new Joose.Proto.Class('Joose.Managed.Property', {
name : null,
init : null,
value : null,
definedIn : null,
initialize : function (props) {
Joose.Managed.Property.superClass.initialize.call(this, props)
this.computeValue()
},
computeValue : function () {
this.value = this.init
},
//targetClass is still open at this stage
preApply : function (targetClass) {
},
//targetClass is already open at this stage
postUnApply : function (targetClass) {
},
apply : function (target) {
target[this.name] = this.value
},
isAppliedTo : function (target) {
return target[this.name] == this.value
},
unapply : function (from) {
if (!this.isAppliedTo(from)) throw "Unapply of property [" + this.name + "] from [" + from + "] failed"
delete from[this.name]
},
cloneProps : function () {
return {
name : this.name,
init : this.init,
definedIn : this.definedIn
}
},
clone : function (name) {
var props = this.cloneProps()
props.name = name || props.name
return new this.constructor(props)
}
}).c;
Joose.Managed.Property.ConflictMarker = new Joose.Proto.Class('Joose.Managed.Property.ConflictMarker', {
isa : Joose.Managed.Property,
apply : function (target) {
throw "Attempt to apply ConflictMarker [" + this.name + "] to [" + target + "]"
}
}).c;
Joose.Managed.Property.Requirement = new Joose.Proto.Class('Joose.Managed.Property.Requirement', {
isa : Joose.Managed.Property,
apply : function (target) {
if (!target.meta.hasMethod(this.name)) throw "Requirement [" + this.name + "], defined in [" + this.definedIn.definedIn.name + "] is not satisfied for class [" + target + "]"
},
unapply : function (from) {
}
}).c;
Joose.Managed.Property.Attribute = new Joose.Proto.Class('Joose.Managed.Property.Attribute', {
isa : Joose.Managed.Property,
slot : null,
initialize : function () {
Joose.Managed.Property.Attribute.superClass.initialize.apply(this, arguments)
this.slot = this.name
},
apply : function (target) {
target.prototype[this.slot] = this.value
},
isAppliedTo : function (target) {
return target.prototype[this.slot] == this.value
},
unapply : function (from) {
if (!this.isAppliedTo(from)) throw "Unapply of property [" + this.name + "] from [" + from + "] failed"
delete from.prototype[this.slot]
},
getRawValueFrom : function (instance) {
return instance[this.slot]
},
setRawValueTo : function (instance, value) {
instance[this.slot] = value
}
}).c;
Joose.Managed.Property.MethodModifier = new Joose.Proto.Class('Joose.Managed.Property.MethodModifier', {
isa : Joose.Managed.Property,
prepareWrapper : function () {
throw "Abstract method [prepareWrapper] of " + this + " was called"
},
apply : function (target) {
var name = this.name
var targetProto = target.prototype
var isOwn = targetProto.hasOwnProperty(name)
var original = targetProto[name]
var superProto = target.meta.superClass.prototype
var originalCall = isOwn ? original : function () {
return superProto[name].apply(this, arguments)
}
var methodWrapper = this.prepareWrapper({
name : name,
modifier : this.value,
isOwn : isOwn,
originalCall : originalCall,
superProto : superProto,
target : target
})
if (isOwn) methodWrapper._original = original
methodWrapper._contain = this.value
targetProto[name] = methodWrapper
},
isAppliedTo : function (target) {
var targetCont = target.prototype[this.name]
return targetCont && targetCont._contain == this.value
},
unapply : function (from) {
var name = this.name
var fromProto = from.prototype
var original = fromProto[name]._original
if (!this.isAppliedTo(from)) throw "Unapply of method [" + name + "] from class [" + from + "] failed"
//if modifier was applied to own method - restore it
if (original)
fromProto[name] = original
//otherwise - just delete it, to reveal the inherited method
else
delete fromProto[name]
}
}).c;
Joose.Managed.Property.MethodModifier.Override = new Joose.Proto.Class('Joose.Managed.Property.MethodModifier.Override', {
isa : Joose.Managed.Property.MethodModifier,
prepareWrapper : function (params) {
var modifier = params.modifier
var originalCall = params.originalCall
var superProto = params.superProto
var superMetaConst = superProto.meta.constructor
//call to Joose.Proto level, require some additional processing
var isCallToProto = (superMetaConst == Joose.Proto.Class || superMetaConst == Joose.Proto.Object) && !(params.isOwn && originalCall.IS_OVERRIDE)
var original = originalCall
if (isCallToProto) original = function () {
var beforeSUPER = this.SUPER
this.SUPER = superProto.SUPER
var res = originalCall.apply(this, arguments)
this.SUPER = beforeSUPER
return res
}
var override = function () {
var beforeSUPER = this.SUPER
this.SUPER = original
var res = modifier.apply(this, arguments)
this.SUPER = beforeSUPER
return res
}
override.IS_OVERRIDE = true
return override
}
}).c;
Joose.Managed.Property.MethodModifier.Put = new Joose.Proto.Class('Joose.Managed.Property.MethodModifier.Put', {
isa : Joose.Managed.Property.MethodModifier.Override,
prepareWrapper : function (params) {
if (params.isOwn) throw "Method [" + params.name + "] is applying over something [" + params.originalCall + "] in class [" + params.target + "]"
return Joose.Managed.Property.MethodModifier.Put.superClass.prepareWrapper.call(this, params)
}
}).c;
Joose.Managed.Property.MethodModifier.After = new Joose.Proto.Class('Joose.Managed.Property.MethodModifier.After', {
isa : Joose.Managed.Property.MethodModifier,
prepareWrapper : function (params) {
var modifier = params.modifier
var originalCall = params.originalCall
return function () {
var res = originalCall.apply(this, arguments)
modifier.apply(this, arguments)
return res
}
}
}).c;
Joose.Managed.Property.MethodModifier.Before = new Joose.Proto.Class('Joose.Managed.Property.MethodModifier.Before', {
isa : Joose.Managed.Property.MethodModifier,
prepareWrapper : function (params) {
var modifier = params.modifier
var originalCall = params.originalCall
return function () {
modifier.apply(this, arguments)
return originalCall.apply(this, arguments)
}
}
}).c;
Joose.Managed.Property.MethodModifier.Around = new Joose.Proto.Class('Joose.Managed.Property.MethodModifier.Around', {
isa : Joose.Managed.Property.MethodModifier,
prepareWrapper : function (params) {
var modifier = params.modifier
var originalCall = params.originalCall
var me
var bound = function () {
return originalCall.apply(me, arguments)
}
return function () {
me = this
var boundArr = [ bound ]
boundArr.push.apply(boundArr, arguments)
return modifier.apply(this, boundArr)
}
}
}).c;
Joose.Managed.Property.MethodModifier.Augment = new Joose.Proto.Class('Joose.Managed.Property.MethodModifier.Augment', {
isa : Joose.Managed.Property.MethodModifier,
prepareWrapper : function (params) {
var AUGMENT = function () {
//populate callstack to the most deep non-augment method
var callstack = []
var self = AUGMENT
do {
callstack.push(self.IS_AUGMENT ? self._contain : self)
self = self.IS_AUGMENT && (self._original || self.SUPER[self.methodName])
} while (self)
//save previous INNER
var beforeINNER = this.INNER
//create new INNER
this.INNER = function () {
var innerCall = callstack.pop()
return innerCall ? innerCall.apply(this, arguments) : undefined
}
//augment modifier results in hypotetical INNER call of the same method in subclass
var res = this.INNER.apply(this, arguments)
//restore previous INNER chain
this.INNER = beforeINNER
return res
}
AUGMENT.methodName = params.name
AUGMENT.SUPER = params.superProto
AUGMENT.IS_AUGMENT = true
return AUGMENT
}
}).c;
Joose.Managed.PropertySet = new Joose.Proto.Class('Joose.Managed.PropertySet', {
isa : Joose.Managed.Property,
properties : null,
propertyMetaClass : Joose.Managed.Property,
initialize : function (props) {
Joose.Managed.PropertySet.superClass.initialize.call(this, props)
//XXX this guards the meta roles :)
this.properties = props.properties || {}
},
addProperty : function (name, props) {
var metaClass = props.meta || this.propertyMetaClass
delete props.meta
props.definedIn = this
props.name = name
return this.properties[name] = new metaClass(props)
},
addPropertyObject : function (object) {
return this.properties[object.name] = object
},
removeProperty : function (name) {
var prop = this.properties[name]
delete this.properties[name]
return prop
},
haveProperty : function (name) {
return this.properties[name] != null
},
haveOwnProperty : function (name) {
return this.haveProperty(name) && this.properties.hasOwnProperty(name)
},
getProperty : function (name) {
return this.properties[name]
},
//includes inherited properties (probably you wants 'eachOwn', which process only "own" (including consumed from Roles) properties)
each : function (func, scope) {
Joose.O.each(this.properties, func, scope || this)
},
eachOwn : function (func, scope) {
Joose.O.eachOwn(this.properties, func, scope || this)
},
//synonym for each
eachAll : function (func, scope) {
this.each(func, scope)
},
cloneProps : function () {
var props = Joose.Managed.PropertySet.superClass.cloneProps.call(this)
props.propertyMetaClass = this.propertyMetaClass
return props
},
clone : function (name) {
var clone = this.cleanClone(name)
clone.properties = Joose.O.copyOwn(this.properties)
return clone
},
cleanClone : function (name) {
var props = this.cloneProps()
props.name = name || props.name
return new this.constructor(props)
},
alias : function (what) {
var props = this.properties
Joose.O.each(what, function (aliasName, originalName) {
var original = props[originalName]
if (original) this.addPropertyObject(original.clone(aliasName))
}, this)
},
exclude : function (what) {
var props = this.properties
Joose.A.each(what, function (name) {
delete props[name]
})
},
beforeConsumedBy : function () {
},
flattenTo : function (target) {
var targetProps = target.properties
this.eachOwn(function (property, name) {
var targetProperty = targetProps[name]
if (targetProperty instanceof Joose.Managed.Property.ConflictMarker) return
if (targetProperty == null) {
target.addPropertyObject(property)
return
}
if (targetProperty == property) return
target.removeProperty(name)
target.addProperty(name, {
meta : Joose.Managed.Property.ConflictMarker
})
}, this)
},
composeTo : function (target) {
this.eachOwn(function (property, name) {
if (!target.haveOwnProperty(name)) target.addPropertyObject(property)
})
},
composeFrom : function () {
if (!arguments.length) return
var flattening = this.cleanClone()
Joose.A.each(arguments, function (arg) {
var isDescriptor = !(arg instanceof Joose.Managed.PropertySet)
var propSet = isDescriptor ? arg.propertySet : arg
propSet.beforeConsumedBy(this, flattening)
if (isDescriptor) {
if (arg.alias || arg.exclude) propSet = propSet.clone()
if (arg.alias) propSet.alias(arg.alias)
if (arg.exclude) propSet.exclude(arg.exclude)
}
propSet.flattenTo(flattening)
}, this)
flattening.composeTo(this)
},
preApply : function (target) {
this.eachOwn(function (property) {
property.preApply(target)
})
},
apply : function (target) {
this.eachOwn(function (property) {
property.apply(target)
})
},
unapply : function (from) {
this.eachOwn(function (property) {
property.unapply(from)
})
},
postUnApply : function (target) {
this.eachOwn(function (property) {
property.postUnApply(target)
})
}
}).c
;
;(function () {
var __ID__ = 1
Joose.Managed.PropertySet.Mutable = new Joose.Proto.Class('Joose.Managed.PropertySet.Mutable', {
isa : Joose.Managed.PropertySet,
ID : null,
derivatives : null,
opened : null,
composedFrom : null,
initialize : function (props) {
Joose.Managed.PropertySet.Mutable.superClass.initialize.call(this, props)
//initially opened
this.opened = 1
this.derivatives = {}
this.ID = __ID__++
this.composedFrom = []
},
addComposeInfo : function () {
this.ensureOpen()
Joose.A.each(arguments, function (arg) {
this.composedFrom.push(arg)
var propSet = arg instanceof Joose.Managed.PropertySet ? arg : arg.propertySet
propSet.derivatives[this.ID] = this
}, this)
},
removeComposeInfo : function () {
this.ensureOpen()
Joose.A.each(arguments, function (arg) {
var i = 0
while (i < this.composedFrom.length) {
var propSet = this.composedFrom[i]
propSet = propSet instanceof Joose.Managed.PropertySet ? propSet : propSet.propertySet
if (arg == propSet) {
delete propSet.derivatives[this.ID]
this.composedFrom.splice(i, 1)
} else i++
}
}, this)
},
ensureOpen : function () {
if (!this.opened) throw "Mutation of closed property set: [" + this.name + "]"
},
addProperty : function (name, props) {
this.ensureOpen()
return Joose.Managed.PropertySet.Mutable.superClass.addProperty.call(this, name, props)
},
addPropertyObject : function (object) {
this.ensureOpen()
return Joose.Managed.PropertySet.Mutable.superClass.addPropertyObject.call(this, object)
},
removeProperty : function (name) {
this.ensureOpen()
return Joose.Managed.PropertySet.Mutable.superClass.removeProperty.call(this, name)
},
composeFrom : function () {
this.ensureOpen()
return Joose.Managed.PropertySet.Mutable.superClass.composeFrom.apply(this, this.composedFrom)
},
open : function () {
this.opened++
if (this.opened == 1) {
Joose.O.each(this.derivatives, function (propSet) {
propSet.open()
})
this.deCompose()
}
},
close : function () {
if (!this.opened) throw "Unmatched 'close' operation on property set: [" + this.name + "]"
if (this.opened == 1) {
this.reCompose()
Joose.O.each(this.derivatives, function (propSet) {
propSet.close()
})
}
this.opened--
},
reCompose : function () {
this.composeFrom()
},
deCompose : function () {
this.eachOwn(function (property, name) {
if (property.definedIn != this) this.removeProperty(name)
}, this)
}
}).c
})()
;
Joose.Managed.StemElement = function () { throw "Modules may not be instantiated." }
Joose.Managed.StemElement.Attributes = new Joose.Proto.Class('Joose.Managed.StemElement.Attributes', {
isa : Joose.Managed.PropertySet.Mutable,
propertyMetaClass : Joose.Managed.Property.Attribute
}).c
;
Joose.Managed.StemElement.Methods = new Joose.Proto.Class('Joose.Managed.StemElement.Methods', {
isa : Joose.Managed.PropertySet.Mutable,
propertyMetaClass : Joose.Managed.Property.MethodModifier.Put,
preApply : function () {
},
postUnApply : function () {
}
}).c;
Joose.Managed.StemElement.Requirements = new Joose.Proto.Class('Joose.Managed.StemElement.Requirements', {
isa : Joose.Managed.PropertySet.Mutable,
propertyMetaClass : Joose.Managed.Property.Requirement,
alias : function () {
},
exclude : function () {
},
flattenTo : function (target) {
this.each(function (property, name) {
if (!target.haveProperty(name)) target.addPropertyObject(property)
})
},
composeTo : function (target) {
this.flattenTo(target)
},
preApply : function () {
},
postUnApply : function () {
}
}).c;
Joose.Managed.StemElement.MethodModifiers = new Joose.Proto.Class('Joose.Managed.StemElement.MethodModifiers', {
isa : Joose.Managed.PropertySet.Mutable,
propertyMetaClass : null,
addProperty : function (name, props) {
var metaClass = props.meta
delete props.meta
props.definedIn = this
props.name = name
var modifier = new metaClass(props)
if (!this.properties[name]) this.properties[name] = []
this.properties[name].push(modifier)
return modifier
},
addPropertyObject : function (object) {
var name = object.name
if (!this.properties[name]) this.properties[name] = []
this.properties[name].push(object)
return object
},
//remove only the last modifier
removeProperty : function (name) {
if (!this.haveProperty(name)) return undefined
var modifier = this.properties[name].pop()
//if all modifiers were removed - clearing the properties
if (!this.properties[name].length) Joose.Managed.StemElement.MethodModifiers.superClass.removeProperty.call(this, name)
return modifier
},
alias : function () {
},
exclude : function () {
},
flattenTo : function (target) {
var targetProps = target.properties
this.each(function (modifiersArr, name) {
var targetModifiersArr = targetProps[name]
if (targetModifiersArr == null) targetModifiersArr = targetProps[name] = []
Joose.A.each(modifiersArr, function (modifier) {
if (!Joose.A.exists(targetModifiersArr, modifier)) targetModifiersArr.push(modifier)
})
}, this)
},
composeTo : function (target) {
this.flattenTo(target)
},
deCompose : function () {
this.each(function (modifiersArr, name) {
var i = 0
while (i < modifiersArr.length) if (modifiersArr[i].definedIn != this) modifiersArr.splice(i, 1); else i++
}, this)
},
preApply : function (target) {
},
postUnApply : function (target) {
},
apply : function (target) {
this.each(function (modifiersArr, name) {
Joose.A.each(modifiersArr, function (modifier) {
modifier.apply(target)
})
})
},
unapply : function (from) {
this.each(function (modifiersArr, name) {
for (var i = modifiersArr.length - 1; i >=0 ; i--) modifiersArr[i].unapply(from)
})
}
}).c;
Joose.Managed.PropertySet.Composition = new Joose.Proto.Class('Joose.Managed.PropertySet.Composition', {
isa : Joose.Managed.PropertySet.Mutable,
propertyMetaClass : Joose.Managed.PropertySet.Mutable,
processOrder : null,
each : function (func, scope) {
var props = this.properties
Joose.A.each(this.processOrder, function (name) {
func.call(scope || this, props[name], name)
}, this)
},
eachR : function (func, scope) {
var props = this.properties
var processOrder = this.processOrder
for(var i = processOrder.length - 1; i >= 0; i--)
func.call(scope || this, props[ processOrder[i] ], processOrder[i])
},
clone : function (name) {
var clone = this.cleanClone(name)
this.each(function (property) {
clone.addPropertyObject(property.clone())
})
return clone
},
alias : function (what) {
this.each(function (property) {
property.alias(what)
})
},
exclude : function (what) {
this.each(function (property) {
property.exclude(what)
})
},
flattenTo : function (target) {
var targetProps = target.properties
this.each(function (property, name) {
var subTarget = targetProps[name] || target.addProperty(name, {
meta : property.constructor
})
property.flattenTo(subTarget)
})
},
composeTo : function (target) {
var targetProps = target.properties
this.each(function (property, name) {
var subTarget = targetProps[name] || target.addProperty(name, {
meta : property.constructor
})
property.composeTo(subTarget)
})
},
deCompose : function () {
this.eachR(function (property) {
property.open()
})
Joose.Managed.PropertySet.Composition.superClass.deCompose.call(this)
},
reCompose : function () {
Joose.Managed.PropertySet.Composition.superClass.reCompose.call(this)
this.each(function (property) {
property.close()
})
},
unapply : function (from) {
this.eachR(function (property) {
property.unapply(from)
})
}
}).c
;
Joose.Managed.Stem = new Joose.Proto.Class('Joose.Managed.Stem', {
isa : Joose.Managed.PropertySet.Composition,
targetMeta : null,
attributesMC : Joose.Managed.StemElement.Attributes,
methodsMC : Joose.Managed.StemElement.Methods,
requirementsMC : Joose.Managed.StemElement.Requirements,
methodsModifiersMC : Joose.Managed.StemElement.MethodModifiers,
processOrder : [ 'attributes', 'methods', 'requirements', 'methodsModifiers' ],
initialize : function (props) {
Joose.Managed.Stem.superClass.initialize.call(this, props)
var targetMeta = this.targetMeta
this.addProperty('attributes', {
meta : this.attributesMC,
//it can be no 'targetMeta' in clones
properties : targetMeta ? targetMeta.attributes : {}
})
this.addProperty('methods', {
meta : this.methodsMC,
properties : targetMeta ? targetMeta.methods : {}
})
this.addProperty('requirements', {
meta : this.requirementsMC
})
this.addProperty('methodsModifiers', {
meta : this.methodsModifiersMC
})
},
reCompose : function () {
var c = this.targetMeta.c
this.preApply(c)
Joose.Managed.Stem.superClass.reCompose.call(this)
this.apply(c)
},
deCompose : function () {
var c = this.targetMeta.c
this.unapply(c)
Joose.Managed.Stem.superClass.deCompose.call(this)
this.postUnApply(c)
}
}).c
;
Joose.Managed.Builder = new Joose.Proto.Class('Joose.Managed.Builder', {
targetMeta : null,
_buildStart : function (targetMeta, props) {
targetMeta.stem.open()
Joose.A.each([ 'trait', 'traits', 'removeTrait', 'removeTraits', 'does', 'doesnot', 'doesnt' ], function (builder) {
if (props[builder]) {
this[builder](targetMeta, props[builder])
delete props[builder]
}
}, this)
},
_extend : function (props) {
if (Joose.O.isEmpty(props)) return
var targetMeta = this.targetMeta
this._buildStart(targetMeta, props)
Joose.O.eachOwn(props, function (value, name) {
var handler = this[name]
if (!handler) throw "Unknow builder [" + name + "] was used during extending of [" + targetMeta.c + "]"
handler.call(this, targetMeta, value)
}, this)
this._buildComplete(targetMeta, props)
},
_buildComplete : function (targetMeta, props) {
targetMeta.stem.close()
},
methods : function (targetMeta, info) {
Joose.O.eachOwn(info, function (value, name) {
targetMeta.addMethod(name, value)
})
},
removeMethods : function (targetMeta, info) {
Joose.A.each(info, function (name) {
targetMeta.removeMethod(name)
})
},
have : function (targetMeta, info) {
Joose.O.eachOwn(info, function (value, name) {
targetMeta.addAttribute(name, value)
})
},
havenot : function (targetMeta, info) {
Joose.A.each(info, function (name) {
targetMeta.removeAttribute(name)
})
},
havent : function (targetMeta, info) {
this.havenot(targetMeta, info)
},
after : function (targetMeta, info) {
Joose.O.each(info, function (value, name) {
targetMeta.addMethodModifier(name, value, Joose.Managed.Property.MethodModifier.After)
})
},
before : function (targetMeta, info) {
Joose.O.each(info, function (value, name) {
targetMeta.addMethodModifier(name, value, Joose.Managed.Property.MethodModifier.Before)
})
},
override : function (targetMeta, info) {
Joose.O.each(info, function (value, name) {
targetMeta.addMethodModifier(name, value, Joose.Managed.Property.MethodModifier.Override)
})
},
around : function (targetMeta, info) {
Joose.O.each(info, function (value, name) {
targetMeta.addMethodModifier(name, value, Joose.Managed.Property.MethodModifier.Around)
})
},
augment : function (targetMeta, info) {
Joose.O.each(info, function (value, name) {
targetMeta.addMethodModifier(name, value, Joose.Managed.Property.MethodModifier.Augment)
})
},
removeModifier : function (targetMeta, info) {
Joose.A.each(info, function (name) {
targetMeta.removeMethodModifier(name)
})
},
does : function (targetMeta, info) {
Joose.A.each(Joose.O.wantArray(info), function (desc) {
targetMeta.addRole(desc)
})
},
doesnot : function (targetMeta, info) {
Joose.A.each(Joose.O.wantArray(info), function (desc) {
targetMeta.removeRole(desc)
})
},
doesnt : function (targetMeta, info) {
this.doesnot(targetMeta, info)
},
trait : function () {
this.traits.apply(this, arguments)
},
traits : function (targetMeta, info) {
if (targetMeta.firstPass) return
if (!targetMeta.meta.isDetached) throw "Can't apply trait to not detached class"
targetMeta.meta.extend({
does : info
})
},
removeTrait : function () {
this.removeTraits.apply(this, arguments)
},
removeTraits : function (targetMeta, info) {
if (!targetMeta.meta.isDetached) throw "Can't remove trait from not detached class"
targetMeta.meta.extend({
doesnot : info
})
}
}).c;
Joose.Managed.Class = new Joose.Proto.Class('Joose.Managed.Class', {
isa : Joose.Proto.Class,
stem : null,
stemClass : Joose.Managed.Stem,
stemClassCreated : false,
builder : null,
builderClass : Joose.Managed.Builder,
builderClassCreated : false,
isDetached : false,
firstPass : true,
// a special instance, which, when passed as 1st argument to constructor, signifies that constructor should
// skips traits processing for this instance
skipTraitsAnchor : {},
//build for metaclasses - collects traits from roles
BUILD : function () {
var sup = Joose.Managed.Class.superClass.BUILD.apply(this, arguments)
var props = sup.__extend__
var traits = Joose.O.wantArray(props.trait || props.traits || [])
delete props.trait
delete props.traits
Joose.A.each(Joose.O.wantArray(props.does || []), function (arg) {
var role = (arg.meta instanceof Joose.Managed.Class) ? arg : arg.role
if (role.meta.meta.isDetached) traits.push(role.meta.constructor)
})
if (traits.length) props.traits = traits
return sup
},
initInstance : function (instance, props) {
Joose.O.each(this.attributes, function (attribute, name) {
if (attribute instanceof Joose.Managed.Attribute)
attribute.initFromConfig(instance, props)
else
if (props.hasOwnProperty(name)) instance[name] = props[name]
})
},
// we are using the same constructor for usual and meta- classes
defaultConstructor: function () {
return function (skipTraitsAnchor, params) {
var thisMeta = this.meta
var skipTraits = skipTraitsAnchor == thisMeta.skipTraitsAnchor
var BUILD = this.BUILD
var props = BUILD && BUILD.apply(this, skipTraits ? params : arguments) || (skipTraits ? params : skipTraitsAnchor) || {}
// either looking for traits in __extend__ (meta-class) or in usual props (usual class)
var extend = props.__extend__ || props
var traits = extend.trait || extend.traits
if (traits || extend.detached) {
delete extend.trait
delete extend.traits
delete extend.detached
if (!skipTraits) {
var classWithTrait = thisMeta.subClass({ does : traits || [] }, thisMeta.name)
var meta = classWithTrait.meta
meta.isDetached = true
return meta.instantiate(thisMeta.skipTraitsAnchor, arguments)
}
}
thisMeta.initInstance(this, props)
return thisMeta.hasMethod('initialize') && this.initialize(props) || this
}
},
finalize: function (extend) {
Joose.Managed.Class.superClass.finalize.call(this, extend)
this.stem.close()
this.afterMutate()
},
processStem : function () {
Joose.Managed.Class.superClass.processStem.call(this)
this.builder = new this.builderClass({ targetMeta : this })
this.stem = new this.stemClass({ name : this.name, targetMeta : this })
var builderClass = this.getClassInAttribute('builderClass')
if (builderClass) {
this.builderClassCreated = true
this.addAttribute('builderClass', this.subClassOf(builderClass))
}
var stemClass = this.getClassInAttribute('stemClass')
if (stemClass) {
this.stemClassCreated = true
this.addAttribute('stemClass', this.subClassOf(stemClass))
}
},
extend : function (props) {
if (props.builder) {
this.getBuilderTarget().meta.extend(props.builder)
delete props.builder
}
if (props.stem) {
this.getStemTarget().meta.extend(props.stem)
delete props.stem
}
this.builder._extend(props)
this.firstPass = false
if (!this.stem.opened) this.afterMutate()
},
getBuilderTarget : function () {
var builderClass = this.getClassInAttribute('builderClass')
if (!builderClass) throw "Attempt to extend a builder on non-meta class"
return builderClass
},
getStemTarget : function () {
var stemClass = this.getClassInAttribute('stemClass')
if (!stemClass) throw "Attempt to extend a stem on non-meta class"
return stemClass
},
getClassInAttribute : function (attributeName) {
var attrClass = this.getAttribute(attributeName)
if (attrClass instanceof Joose.Managed.Property.Attribute) attrClass = attrClass.value
return attrClass
},
addMethodModifier: function (name, func, type) {
var props = {}
props.init = func
props.meta = type
return this.stem.properties.methodsModifiers.addProperty(name, props)
},
removeMethodModifier: function (name) {
return this.stem.properties.methodsModifiers.removeProperty(name)
},
addMethod: function (name, func, props) {
props = props || {}
props.init = func
return this.stem.properties.methods.addProperty(name, props)
},
addAttribute: function (name, init, props) {
props = props || {}
props.init = init
return this.stem.properties.attributes.addProperty(name, props)
},
removeMethod : function (name) {
return this.stem.properties.methods.removeProperty(name)
},
removeAttribute: function (name) {
return this.stem.properties.attributes.removeProperty(name)
},
hasMethod: function (name) {
return this.stem.properties.methods.haveProperty(name)
},
hasAttribute: function (name) {
return this.stem.properties.attributes.haveProperty(name)
},
hasOwnMethod: function (name) {
return this.stem.properties.methods.haveOwnProperty(name)
},
hasOwnAttribute: function (name) {
return this.stem.properties.attributes.haveOwnProperty(name)
},
getMethod : function (name) {
return this.stem.properties.methods.getProperty(name)
},
getAttribute : function (name) {
return this.stem.properties.attributes.getProperty(name)
},
eachRole : function (roles, func, scope) {
Joose.A.each(roles, function (arg, index) {
var role = (arg.meta instanceof Joose.Managed.Class) ? arg : arg.role
func.call(scope || this, arg, role, index)
}, this)
},
addRole : function () {
this.eachRole(arguments, function (arg, role) {
this.beforeRoleAdd(role)
var desc = arg
//compose descriptor can contain 'alias' and 'exclude' fields, in this case actual reference should be stored
//into 'propertySet' field
if (role != arg) {
desc.propertySet = role.meta.stem
delete desc.role
} else
desc = desc.meta.stem
this.stem.addComposeInfo(desc)
}, this)
},
beforeRoleAdd : function (role) {
var roleMeta = role.meta
if (roleMeta.builderClassCreated) this.getBuilderTarget().meta.extend({
does : [ roleMeta.getBuilderTarget() ]
})
if (roleMeta.stemClassCreated) this.getStemTarget().meta.extend({
does : [ roleMeta.getStemTarget() ]
})
if (roleMeta.meta.isDetached && !this.firstPass) this.builder.traits(this, roleMeta.constructor)
},
beforeRoleRemove : function (role) {
var roleMeta = role.meta
if (roleMeta.builderClassCreated) this.getBuilderTarget().meta.extend({
doesnt : [ roleMeta.getBuilderTarget() ]
})
if (roleMeta.stemClassCreated) this.getStemTarget().meta.extend({
doesnt : [ roleMeta.getStemTarget() ]
})
if (roleMeta.meta.isDetached && !this.firstPass) this.builder.removeTraits(this, roleMeta.constructor)
},
removeRole : function () {
this.eachRole(arguments, function (arg, role) {
this.beforeRoleRemove(role)
this.stem.removeComposeInfo(role.meta.stem)
}, this)
},
getRoles : function () {
var roles = []
Joose.A.each(this.stem.composedFrom, function (composeDesc) {
//compose descriptor can contain 'alias' and 'exclude' fields, in this case actual reference is stored
//into 'propertySet' field
if (!(composeDesc instanceof Joose.Managed.PropertySet)) composeDesc = composeDesc.propertySet
roles.push(composeDesc.targetMeta.c)
})
return roles
},
does : function (role) {
var myRoles = this.getRoles()
for (var i = 0; i < myRoles.length; i++) if (role == myRoles[i]) return true
for (var i = 0; i < myRoles.length; i++) if (myRoles[i].meta.does(role)) return true
var superMeta = this.superClass.meta
// considering the case of inheriting from non-Joose classes
if (this.superClass != Joose.Proto.Empty && superMeta && superMeta.meta && superMeta.meta.hasMethod('does')) return superMeta.does(role)
return false
},
getMethods : function () {
return this.stem.properties.methods
},
getAttributes : function () {
return this.stem.properties.attributes
},
afterMutate : function () {
}
}).c;
Joose.Managed.Role = new Joose.Managed.Class('Joose.Managed.Role', {
isa : Joose.Managed.Class,
have : {
defaultSuperClass : Joose.Proto.Empty,
builderRole : null,
stemRole : null
},
methods : {
defaultConstructor : function () {
return function () {
throw "Roles cant be instantiated"
}
},
processSuperClass : function () {
if (this.superClass != this.defaultSuperClass) throw "Roles can't inherit from anything"
},
getBuilderTarget : function () {
if (!this.builderRole) {
this.builderRole = new this.constructor().c
this.builderClassCreated = true
}
return this.builderRole
},
getStemTarget : function () {
if (!this.stemRole) {
this.stemRole = new this.constructor().c
this.stemClassCreated = true
}
return this.stemRole
},
addRequirement : function (methodName) {
this.stem.properties.requirements.addProperty(methodName, {})
}
},
stem : {
methods : {
apply : function () {
},
unapply : function () {
}
}
},
builder : {
methods : {
requires : function (targetClassMeta, info) {
Joose.A.each(Joose.O.wantArray(info), function (methodName) {
targetClassMeta.addRequirement(methodName)
}, this)
}
}
}
}).c;
Joose.Managed.Attribute = new Joose.Managed.Class('Joose.Managed.Attribute', {
isa : Joose.Managed.Property.Attribute,
have : {
is : null,
builder : null,
isPrivate : false,
role : null,
publicName : null,
setterName : null,
getterName : null,
//indicates the logical readableness/writeableness of the attribute
readable : false,
writeable : false,
//indicates the physical presense of the accessor (may be absent for "combined" accessors for example)
hasGetter : false,
hasSetter : false,
required : false
},
after : {
initialize : function () {
var name = this.name
this.publicName = name.replace(/^_+/, '')
this.slot = this.isPrivate ? '$$' + name : name
this.setterName = this.setterName || this.getSetterName()
this.getterName = this.getterName || this.getGetterName()
this.readable = this.hasGetter = /^r/i.test(this.is)
this.writeable = this.hasSetter = /^.w/i.test(this.is)
}
},
override : {
computeValue : function () {
if (!Joose.O.isFunction(this.init)) this.SUPER()
},
preApply : function (targetClass) {
targetClass.meta.extend({
methods : this.getAccessorsFor(targetClass)
})
},
postUnApply : function (from) {
from.meta.extend({
removeMethods : this.getAccessorsFrom(from)
})
}
},
methods : {
getAccessorsFor : function (targetClass) {
var targetMeta = targetClass.meta
var setterName = this.setterName
var getterName = this.getterName
var methods = {}
if (this.hasSetter && !targetMeta.hasMethod(setterName)) {
methods[setterName] = this.getSetter()
methods[setterName].ACCESSOR_FROM = this
}
if (this.hasGetter && !targetMeta.hasMethod(getterName)) {
methods[getterName] = this.getGetter()
methods[getterName].ACCESSOR_FROM = this
}
return methods
},
getAccessorsFrom : function (from) {
var targetMeta = from.meta
var setterName = this.setterName
var getterName = this.getterName
var setter = this.hasSetter && targetMeta.getMethod(setterName)
var getter = this.hasGetter && targetMeta.getMethod(getterName)
var removeMethods = []
if (setter && setter.value.ACCESSOR_FROM == this) removeMethods.push(setterName)
if (getter && getter.value.ACCESSOR_FROM == this) removeMethods.push(getterName)
return removeMethods
},
getGetterName : function () {
return 'get' + Joose.S.uppercaseFirst(this.publicName)
},
getSetterName : function () {
return 'set' + Joose.S.uppercaseFirst(this.publicName)
},
getSetter : function () {
var slot = this.slot
return function (value) {
this[slot] = value
return this
}
},
getGetter : function () {
var slot = this.slot
return function () {
return this[slot]
}
},
getValueFrom : function (instance) {
var getterName = this.getterName
if (this.readable && instance.meta.hasMethod(getterName)) return instance[getterName]()
return instance[this.slot]
},
setValueTo : function (instance, value) {
var setterName = this.setterName
if (this.writeable && instance.meta.hasMethod(setterName))
instance[setterName](value)
else
instance[this.slot] = value
},
initFromConfig : function (instance, config) {
var name = this.name
var value, isSet = false
if (config.hasOwnProperty(name)) {
value = config[name]
isSet = true
} else
if (Joose.O.isFunction(this.init)) {
value = this.init.call(instance, name, config)
isSet = true
} else if (this.builder) {
value = instance[ this.builder.replace(/^this\./, '') ](name, config)
isSet = true
}
if (isSet)
this.setValueTo(instance, value)
else
if (this.required) throw "Required attribute [" + name + "] is missed during initialization of " + instance
}
}
}).c
;
Joose.Managed.PropertySet.Namespace = new Joose.Proto.Class('Joose.Managed.PropertySet.Namespace', {
isa : Joose.Managed.PropertySet,
propertyMetaClass : null,
targetMeta : null,
container : null,
initialize : function (props) {
Joose.Managed.PropertySet.Namespace.superClass.initialize.call(this, props)
this.container = this.targetMeta.c
},
addProperty : function (name, value) {
if (value && value.meta && value.meta.meta.hasAttribute('ns')) value.meta.parentNs = this.targetMeta.ns
return this.container[name] = this.properties[name] = value
},
removeProperty : function (name) {
try {
delete this.container[name]
} catch(e) {
this.container[name] = undefined
}
return Joose.Managed.PropertySet.Namespace.superClass.removeProperty.call(this, name)
}
}).c
;
Joose.Managed.Attribute.Builder = new Joose.Managed.Role('Joose.Managed.Attribute.Builder', {
have : {
defaultAttributeClass : Joose.Managed.Attribute
},
builder : {
methods : {
has : function (targetClassMeta, info) {
Joose.O.eachOwn(info, function (props, name) {
if (typeof props != 'object' || props == null || props.constructor == / /.constructor) props = { init : props }
props.meta = props.meta || targetClassMeta.defaultAttributeClass
if (/^__/.test(name)) {
name = name.replace(/^_+/, '')
props.isPrivate = true
}
targetClassMeta.addAttribute(name, props.init, props)
}, this)
},
hasnot : function (targetClassMeta, info) {
this.havenot(targetClassMeta, info)
},
hasnt : function (targetClassMeta, info) {
this.hasnot(targetClassMeta, info)
}
}
}
}).c
;
Joose.Managed.My = new Joose.Managed.Role('Joose.Managed.My', {
have : {
myClass : null,
needToReAlias : false
},
methods : {
createMy : function (extend) {
var thisMeta = this.meta
var isRole = this instanceof Joose.Managed.Role
var myExtend = extend.my || {}
delete extend.my
// Symbiont will generally have the same meta class as its hoster, excepting the cases, when the superclass also have the symbiont.
// In such cases, the meta class for symbiont will be inherited (unless explicitly specified)
if (!isRole) myExtend.isa = myExtend.isa || this.superClass.meta.myClass
if (!myExtend.meta && !myExtend.isa) myExtend.meta = this.constructor
var createdClass = this.myClass = Class(myExtend)
this.c.prototype.my = this.c.my = isRole ? createdClass : new createdClass({ HOST : this.c })
this.needToReAlias = true
},
aliasStaticMethods : function () {
this.needToReAlias = false
var c = this.c
var myProto = this.myClass.prototype
Joose.O.eachOwn(c, function (property, name) {
if (property.IS_ALIAS) delete c[ name ]
})
this.myClass.meta.stem.properties.methods.each(function (method, name) {
if (!c[ name ])
(c[ name ] = function () {
return myProto[ name ].apply(c.my, arguments)
}).IS_ALIAS = true
})
}
},
override : {
extend : function (props) {
var myClass = this.myClass
if (!myClass && this.superClass.meta.myClass) this.createMy(props)
if (props.my) {
if (!myClass)
this.createMy(props)
else {
this.needToReAlias = true
myClass.meta.extend(props.my)
delete props.my
}
}
this.SUPER(props)
if (this.needToReAlias && !(this instanceof Joose.Managed.Role)) this.aliasStaticMethods()
}
},
before : {
addRole : function () {
var myStem
Joose.A.each(arguments, function (arg) {
//instanceof Class to allow treat classes as roles
var role = (arg.meta instanceof Joose.Managed.Class) ? arg : arg.role
if (role.meta.meta.hasAttribute('myClass') && role.meta.myClass) {
if (!this.myClass) {
this.createMy({
my : {
does : role.meta.myClass
}
})
return
}
myStem = this.myClass.meta.stem
if (!myStem.opened) myStem.open()
myStem.addComposeInfo(role.my.meta.stem)
}
}, this)
if (myStem) {
myStem.close()
this.needToReAlias = true
}
},
removeRole : function () {
if (!this.myClass) return
var myStem = this.myClass.meta.stem
myStem.open()
Joose.A.each(arguments, function (role) {
if (role.meta.meta.hasAttribute('myClass') && role.meta.myClass) {
myStem.removeComposeInfo(role.my.meta.stem)
this.needToReAlias = true
}
}, this)
myStem.close()
}
}
}).c;
Joose.Namespace = function () { throw "Modules may not be instantiated." }
Joose.Namespace.Able = new Joose.Managed.Role('Joose.Namespace.Able', {
have : {
parentNs : null,
ns : null,
bodyFunc : null
},
before : {
extend : function (extend) {
if (extend.body) {
this.bodyFunc = extend.body
delete extend.body
}
}
},
after: {
//at this point targetMeta will contain 'c' which is a container for Joose.Managed.PropertySet.Namespace
adaptConstructor: function (extend) {
var localName = (this.name || '').split('.').pop()
//XXX check that 'ns' is overwritten after planting
this.ns = new Joose.Managed.PropertySet.Namespace({ name : localName, targetMeta : this })
},
afterMutate : function () {
var bodyFunc = this.bodyFunc
delete this.bodyFunc
if (bodyFunc) Joose.Namespace.Manager.my.executeIn(this.c, bodyFunc)
}
}
}).c;
Joose.Managed.Bootstrap = new Joose.Managed.Role('Joose.Managed.Bootstrap', {
does : [ Joose.Namespace.Able, Joose.Managed.My, Joose.Managed.Attribute.Builder ]
}).c
;
Joose.Meta = function () { throw "Modules may not be instantiated." }
Joose.Meta.Object = new Joose.Proto.Class('Joose.Meta.Object', {
isa : Joose.Proto.Object
}).c;
Joose.Meta.Class = new Joose.Managed.Class('Joose.Meta.Class', {
isa : Joose.Managed.Class,
does : Joose.Managed.Bootstrap,
have : {
defaultSuperClass : Joose.Meta.Object
}
}).c
;
Joose.Meta.Role = new Joose.Meta.Class('Joose.Meta.Role', {
isa : Joose.Managed.Role,
does : Joose.Managed.Bootstrap
}).c;
Joose.Namespace.Keeper = new Joose.Meta.Class('Joose.Namespace.Keeper', {
isa : Joose.Meta.Class,
have : {
externalConstructor : null
},
methods: {
defaultConstructor: function () {
return function () {
//constructors should assume that meta is attached to 'arguments.callee' (not to 'this')
var thisMeta = arguments.callee.meta
if (thisMeta instanceof Joose.Namespace.Keeper) throw "Module [" + thisMeta.c + "] may not be instantiated."
var externalConstructor = thisMeta.externalConstructor
if (typeof externalConstructor == 'function') {
externalConstructor.meta = thisMeta
return externalConstructor.apply(this, arguments)
}
throw "NamespaceKeeper of [" + thisMeta.name + "] was planted incorrectly."
}
},
//withClass should be not constructed yet on this stage (see Joose.Proto.Class.construct)
//it should be on the 'constructorOnly' life stage (should already have constructor)
plant: function (withClass) {
this.copyNamespaceState(withClass)
var keeper = this.c
keeper.meta = withClass.meta
keeper.meta.c = keeper
keeper.meta.externalConstructor = withClass
},
copyNamespaceState : function (targetClass) {
var targetMeta = targetClass.meta
targetMeta.parentNs = this.parentNs
targetMeta.ns = this.ns
}
}
}).c
;
Joose.Namespace.Manager = new Joose.Managed.Class('Joose.Namespace.Manager', {
have : {
global : null,
globalNs : null,
current : null
},
methods : {
initialize : function () {
var globalKeeper = this.global = new Joose.Namespace.Keeper('').c
var globalNs = this.globalNs = globalKeeper.meta.ns
globalNs.container = Joose.is_NodeJS && global || Joose.top
globalKeeper.meta.parentNs = globalKeeper
this.current = [ globalKeeper ]
},
getCurrent: function () {
return this.current[0]
},
executeIn : function (ns, func) {
var current = this.current
var scope = ns.meta.ns ? ns.meta.ns.container : ns
current.unshift(ns)
var res = func.call(scope, ns)
current.shift()
return res
},
earlyCreate : function (name, metaClass, props) {
props.constructorOnly = true
return new metaClass(name, props).c
},
//this function establishing the full "namespace chain" (including the last element)
create : function (nsName, metaClass, extend) {
//if no name provided, then we creating an anonymous class, so just skip all the namespace manipulations
if (!nsName) return new metaClass(nsName, extend).c
var me = this
if (/^\./.test(nsName)) return this.executeIn(this.global, function () {
return me.create(nsName.replace(/^\./, ''), metaClass, extend)
})
props = extend || {}
var parts = Joose.S.saneSplit(nsName, '.')
var object = this.getCurrent()
var soFar = Joose.S.saneSplit(object.meta.name, '.')
for(var i = 0; i < parts.length; i++) {
var part = parts[i]
var isLast = i == parts.length - 1
if (part == "meta" || part == "my" || !part) throw "Module name [" + nsName + "] may not include a part called 'meta' or 'my' or empty part."
var cur = (object == this.global ? this.global.meta.ns.container : object)[part]//object.meta.ns.getProperty(part)
soFar.push(part)
var soFarName = soFar.join(".")
var needFinalize = false
var nsKeeper
if (typeof cur == "undefined") {
if (isLast) {
nsKeeper = this.earlyCreate(soFarName, metaClass, props)
needFinalize = true
} else
nsKeeper = new Joose.Namespace.Keeper(soFarName).c
if (object.meta)
object.meta.ns.addProperty(part, nsKeeper)
else
object[part] = nsKeeper
cur = nsKeeper
} else if (isLast && cur && cur.meta) {
//XXX needs cleanup and sanitizing
if (cur.meta.constructor == metaClass && extend)
cur.meta.extend(props)
else if (cur.meta instanceof Joose.Namespace.Keeper && metaClass != Joose.Namespace.Keeper) {
cur.meta.plant(this.earlyCreate(soFarName, metaClass, props))
needFinalize = true
}
else if (metaClass != Joose.Namespace.Keeper)
throw "Re-declaration of class " + soFarName + "with different meta is not allowed"
else
//`Module` over something case
cur.meta.extend(props)
} else
if (isLast && !(cur && cur.meta && cur.meta.meta && cur.meta.meta.hasAttribute('ns'))) throw "Trying to setup module " + soFarName + " failed. There is already something: " + cur
if (needFinalize) cur.meta.construct(props)
object = cur
}
return object
},
// //this function establishing the full "namespace chain" (including the last element)
// prepareNamespace : function (nsName) {
//
// var parts = Joose.S.saneSplit(nsName, '.')
// var object = this.getCurrent()
// var soFar = Joose.S.saneSplit(object.meta.name, '.')
//
// for(var i = 0; i < parts.length; i++) {
// var part = parts[i]
//
// if (part == "meta" || part == "my" || !part) throw "Module name [" + nsName + "] may not include a part called 'meta' or 'my' or empty part."
//
// var cur = (object == this.global ? this.global.meta.ns.container : object)[part]
//
// soFar.push(part)
//
// if (cur === undefined) {
// var nsKeeper = new Joose.Namespace.Keeper(soFar.join(".")).c
//
// var objectMeta = object.meta
//
// if (objectMeta && objectMeta.ns)
// objectMeta.ns.addProperty(part, nsKeeper)
// else
// object[part] = nsKeeper
//
// cur = nsKeeper
// }
//
// object = cur
// }
//
// if (!(object && object.meta && object.meta.ns)) throw "Trying to setup module " + soFarName + " failed. There is already something: " + object
//
// return object
// },
prepareProperties : function (name, props, defaultMeta, callback) {
if (name && typeof name != 'string') {
props = name
name = null
}
var meta
if (props && props.meta) {
meta = props.meta
delete props.meta
}
if (!meta)
if (props && typeof props.isa == 'function' && props.isa.meta)
meta = props.isa.meta.constructor
else
meta = defaultMeta
return callback.call(this, name, meta, props)
},
getDefaultHelperFor : function (metaClass) {
var me = this
return function (name, props) {
return me.prepareProperties(name, props, metaClass, function (name, meta, props) {
return me.create(name, meta, props)
})
}
},
register : function (helperName, metaClass, func) {
var me = this
if (this.meta.hasMethod(helperName)) {
var helper = function () {
return me[helperName].apply(me, arguments)
}
if (!Joose.top[helperName]) Joose.top[helperName] = helper
if (!Joose[helperName]) Joose[helperName] = helper
// declaring NodeJS global
if (Joose.is_NodeJS && !global[helperName]) global[helperName] = helper
} else {
var methods = {}
methods[helperName] = func || this.getDefaultHelperFor(metaClass)
this.meta.extend({
methods : methods
})
this.register(helperName)
}
},
Module : function (name, props) {
return this.prepareProperties(name, props, Joose.Namespace.Keeper, function (name, meta, props) {
if (typeof props == 'function') props = { body : props }
return this.create(name, meta, props)
})
}
}
}).c
Joose.Namespace.Manager.my = new Joose.Namespace.Manager()
Joose.Namespace.Manager.my.register('Class', Joose.Meta.Class)
Joose.Namespace.Manager.my.register('Role', Joose.Meta.Role)
Joose.Namespace.Manager.my.register('Module');
;
Class('JooseX.Namespace.Depended.Manager', {
my : {
have : {
INC : Joose.is_NodeJS ? require.paths : [ 'lib', '/jsan/index.html' ],
disableCaching : true,
resources : {},
resourceTypes : {},
ANONYMOUS_RESOURCE_COUNTER : 0
},
methods : {
//get own resource of some thing (resource will be also attached to that abstract thing)
//if the something is requesting own resource its considered loaded
getMyResource : function (type, token, me) {
var resource = this.getResource({
type : type,
token : token
})
if (resource.attachedTo && resource.attachedTo != me) throw resource + " is already attached to [" + resource.attachedTo + "]"
resource.attachedTo = me
resource.loaded = true
resource.loading = false
return resource
},
getResource : function (descriptor) {
if (typeof descriptor == 'object') {
var type = descriptor.type = descriptor.type || 'javascript'
var token = descriptor.token
var requiredVersion = descriptor.version
delete descriptor.version
} else
if (typeof descriptor == 'string') {
var match = /^(\w+):\/\/(.+)/.exec(descriptor)
if (match) {
// type & token are explicitly specified
type = match[1]
token = match[2]
if (type == 'http' || type == 'https') {
token = type + '/doc/m/mi/michaelsbradleyjr/Hash/006/lib/Task/Hash//index.html' + token
type = 'javascript'
}
} else {
// no type specified
token = descriptor
type = /\//.test(token) || /\.js$/.test(token) ? 'javascript' : 'joose'
}
}
if (!token) {
token = '__ANONYMOUS_RESOURCE__' + this.ANONYMOUS_RESOURCE_COUNTER++
descriptor = undefined
}
var id = type + '/doc/m/mi/michaelsbradleyjr/Hash/006/lib/Task/Hash//index.html' + token
var resource = this.resources[id]
if (!resource) {
var resourceClass = this.resourceTypes[type]
if (!resourceClass) throw "Unknown resource type: [" + type + "]"
resource = this.resources[id] = new resourceClass(typeof descriptor == 'object' ? descriptor : {
token : token,
type : type
})
}
resource.setRequiredVersion(requiredVersion)
return resource
},
registerResourceClass : function (typeName, resourceClass) {
this.resourceTypes[typeName] = resourceClass
},
use : function (dependenciesInfo, callback, scope) {
var nsManager = Joose.Namespace.Manager.my
var global = nsManager.global
Class({
use : dependenciesInfo,
body : function () {
if (callback) nsManager.executeIn(global, function (ns) {
callback.call(scope || this, ns)
})
}
})
}
}
}
})
use = function (dependenciesInfo, callback, scope) {
JooseX.Namespace.Depended.Manager.my.use(dependenciesInfo, callback, scope)
}
use.paths = JooseX.Namespace.Depended.Manager.my.INC
Joose.I.FutureClass = function (className) {
return function () {
return eval(className)
}
}
/**
Name
====
JooseX.Namespace.Depended.Manager - A global collection of all resources
SYNOPSIS
========
JooseX.Namespace.Depended.Manager.my.registerResourceClass('custom-type', JooseX.Namespace.Depended.Resource.Custom)
DESCRIPTION
===========
`JooseX.Namespace.Depended.Manager` is a global collection of all resources.
**Note:** Its a pure [static](/go/index_l_Joose.Manual.Static.html) class - all its methods and properties are static.
METHODS
=======
### registerResourceClass
> `void registerResourceClass(String type, Class constructor)`
> After you've created your custom resource class, you need to register it with call to this method.
> Then you can refer to new resources with the following descriptors:
{
type : 'custom-type',
token : 'some-token'
}
GETTING HELP
============
This extension is supported via github issues tracker: <http://github.com/SamuraiJack/JooseX-Namespace-Depended-Manager/issues>
For general Joose questions you can also visit #joose on irc.freenode.org or the forum at: [http://joose.it/forum](http://joose.it/forum)
SEE ALSO
========
Authoring [JooseX.Namespace.Depended](Authoring.html)
Abstract base resource class: [JooseX.Namespace.Depended.Resource](Resource.html)
General documentation for Joose: <http://openjsan.org/go/?l=Joose>
BUGS
====
All complex software has bugs lurking in it, and this module is no exception.
Please report any bugs through the web interface at [http://github.com/SamuraiJack/JooseX-Namespace-Depended-Manager/issues](http://github.com/SamuraiJack/JooseX-Namespace-Depended-Manager/issues)
AUTHORS
=======
Nickolay Platonov [nplatonov@cpan.org](mailto:nplatonov@cpan.org)
COPYRIGHT AND LICENSE
=====================
Copyright (c) 2009, Nickolay Platonov
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of Nickolay Platonov nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
;
Class('JooseX.Namespace.Depended.Resource', {
has : {
attachedTo : null,
type : null,
token : null,
id : null,
loading : false,
loaded : false,
ready : false,
presence : null,
readyness : null,
loadedFromURL : null,
readyListeners : Joose.I.Array,
dependencies : Joose.I.Object,
onBeforeReady : { is : 'rw', init : null },
readyDelegated : false,
version : { is : 'rw', init : null },
requiredVersion : { is : 'rw', init : null },
hasReadyCheckScheduled : false
},
after: {
initialize: function () {
if (!this.id) this.id = this.type + '/doc/m/mi/michaelsbradleyjr/Hash/006/lib/Task/Hash//index.html' + this.token
}
},
methods: {
setOnBeforeReady : function (func) {
if (this.onBeforeReady) throw "Can't redefine 'onBeforeReady' for " + this
this.onBeforeReady = func
},
setVersion : function (version) {
if (!version) return
if (this.version && this.version != version) throw "Cant redefine version of " + this
var requiredVersion = this.requiredVersion
if (requiredVersion && version < requiredVersion) throw "Versions conflict on " + this + " required [" + requiredVersion + "], got [" + version + "]"
this.version = version
},
setRequiredVersion : function (version) {
if (!version) return
var requiredVersion = this.requiredVersion
if (!requiredVersion || version > requiredVersion)
if (this.isLoaded() || this.loading)
throw "Cant increase required version - " + this + " is already loaded"
else
this.requiredVersion = version
},
toString : function () {
return "Resource: id=[" + this.id + "], type=[" + this.meta.name + "]"
},
addDescriptor : function (descriptor) {
var resource = JooseX.Namespace.Depended.Manager.my.getResource(descriptor)
var dependencies = this.dependencies
var resourceID = resource.id
//if there is already such dependency or the resource is ready
if (dependencies[ resourceID ] || resource.isReady()) return
var me = this
//pushing listener to the end(!) of the list
resource.readyListeners.push(function () {
delete dependencies[ resourceID ]
me.checkReady()
})
//adding dependency
dependencies[ resourceID ] = resource
//we are not ready, since there are depedencies to load
this.ready = false
},
handleDependencies : function () {
// || {} required for classes on which this Role was applied after they were created - they have this.dependencies not initialized
Joose.O.eachOwn(this.dependencies || {}, function (resource) {
resource.handleLoad()
})
this.checkReady()
},
checkReady : function () {
if (!Joose.O.isEmpty(this.dependencies) || this.hasReadyCheckScheduled) return
if (this.onBeforeReady) {
if (!this.readyDelegated) {
this.readyDelegated = true
var me = this
this.onBeforeReady(function(){
me.fireReady()
}, me)
}
} else
this.fireReady()
},
fireReady: function () {
this.ready = true
var listeners = this.readyListeners
this.readyListeners = []
Joose.A.each(listeners, function (listener) {
listener()
})
},
isReady : function () {
if (!this.isLoaded()) return false
var isReady = false
try {
isReady = this.readyness()
} catch (e) {
}
return isReady || this.ready
},
isLoaded : function () {
var isPresent = false
try {
isPresent = this.presence()
} catch (e) {
}
return isPresent || this.loaded
},
handleLoad: function() {
if (this.isLoaded()) {
this.checkReady()
return
}
if (this.loading) return
this.loading = true
var urls = Joose.O.wantArray(this.getUrls())
var me = this
// this delays the 'checkReady' until the resourse will be *fully* materialized
// *fully* means that even the main class of the resource is already "ready"
// the possible other classes in the same file could be not
// see 110_several_classes_in_file.t.js, 120_script_tag_transport.t.js for example
me.hasReadyCheckScheduled = true
var onsuccess = function (resourceBlob, url) {
me.loaded = true
me.loading = false
me.loadedFromURL = url
me.materialize(resourceBlob, url)
me.hasReadyCheckScheduled = false
me.checkReady()
}
var onerror = function (e) {
//if no more urls
if (!urls.length) throw me + " not found"
me.load(urls.shift(), onsuccess, onerror)
}
this.load(urls.shift(), onsuccess, onerror)
},
getUrls: function () {
throw "Abstract resource method 'getUrls' was called"
},
load : function (url, onsuccess, onerror) {
throw "Abstract resource method 'load' was called"
},
materialize : function (resourceBlob) {
throw "Abstract resource method 'materialize' was called"
}
}
})
/**
Name
====
JooseX.Namespace.Depended.Resource - Abstract resource class
SYNOPSIS
========
//mostly for subclassing only
Class("JooseX.Namespace.Depended.Resource.JavaScript", {
isa : JooseX.Namespace.Depended.Resource,
...
})
DESCRIPTION
===========
`JooseX.Namespace.Depended.Resource` is an abstract resource class. Its not supposed to be used directly, instead you should use
one of its subclasses.
ATTRIBUTES
==========
### attachedTo
> `Object attachedTo`
> An arbitrary object to which this resource is attached (its a corresponding class in JooseX.Namespace.Depended)
### type
> `String type`
> A type of resource - plain string. `JooseX.Namespace.Depended.Manager` maintain a collection of resource types, accessible
### token
> `String token`
> A token of resource - plain string with arbitrary semantic. Each subclass should provide this semantic along with `token -> url` conertion method (locator)
### id
> `String id`
> An id of resource - is computed as `type + '/doc/m/mi/michaelsbradleyjr/Hash/006/lib/Task/Hash//index.html' + token'
### loading
> `Boolean loading`
> A sign whether this resource is currently loading
### loaded
> `Boolean loaded`
> A sign whether this resource is already loaded
### ready
> `Boolean ready`
> A sign whether this resource is considered ready. Resource is ready, when its loaded, and all its dependencies are ready.
### loadedFromURL
> `String loadedFromURL`
> An url, from which the resource was loaded.
### readyListeners
> `Array[Function] readyListeners`
> An array of functions, which will be called after this resource becomes ready. Functions will be called sequentially.
### dependencies
> `Object dependencies`
> An object containing the dependencies of this resource. Keys are the `id`s of resources and the values - the resource instances itself.
### onBeforeReady
> `Function onBeforeReady`
> A function, which will be called, right after the all dependencies of the resource became ready, but before its own `readyListeners` will be called.
It supposed to perform any needed additional actions to post-process the loaded resource.
> Function will receive two arguments - the 1st is the callback, which should be called when `onBeforeReady` will finish its work. 2nd is the resource instance.
### version
> `r/w Number version`
> A version of this resource. Currently is handled as Number, this may change in future releases.
### requiredVersion
> `r/w Number requiredVersion`
> A *requiredVersion* version of this resource. Required here means the maximum version from all references to this resource.
METHODS
=======
### addDescriptor
> `void addDescriptor(Object|String descriptor)`
> Add the resource, described with passed descriptor as the dependency for this resource.
### getUrls
> `String|Array[String] getUrls()`
> Abstract method, will throw an exception if not overriden. It should return the array of urls (or a single url) from which this resource can be potentially loaded.
This method should take into account the `JooseX.Namespace.Depended.Manager.my.INC` setting
### load
> `void load(String url, Function onsuccess, Function onerror)`
> Abstract method, will throw an exception if not overriden. It should load the content of the resource from the passed `url`. If there was an error during loading
(for example file not found) should not throw the exception. Instead, should call the `onerror` continuation with it (exception instance).
> After successfull loading, should call the `onsuccess` continuation with the resource content as 1st argument, and `url` as 2nd: `onsuccess(text, url)`
### materialize
> `void materialize(String resourceBlob, String url)`
> Abstract method, will throw an exception if not overriden. It should "materialize" the resource. The concrete semantic of this action is determined by resource nature.
For example this method can create some tag in the DOM tree, or execute the code or something else.
> Currently this method is supposed to operate synchronously, this may change in future releases.
SEE ALSO
========
Web page of this package: <http://github.com/SamuraiJack/JooseX-Namespace-Depended-Resource/>
General documentation for Joose: <http://openjsan.org/go/?l=Joose>
BUGS
====
All complex software has bugs lurking in it, and this module is no exception.
Please report any bugs through the web interface at <http://github.com/SamuraiJack/JooseX-Namespace-Depended-Resource/issues>
AUTHORS
=======
Nickolay Platonov <nplatonov@cpan.org>
COPYRIGHT AND LICENSE
=====================
Copyright (c) 2009-2010, Nickolay Platonov
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of Nickolay Platonov nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
;
Role('JooseX.Namespace.Depended.Materialize.Eval', {
requires : [ 'handleLoad' ],
methods : {
materialize : function (resourceBlob) {
;(function (){
eval(resourceBlob)
})()
}
}
})
/**
Name
====
JooseX.Namespace.Depended.Materialize.Eval - materializator, which treat the resource content as JavaScript code, and use `eval` function to evalute it
SYNOPSIS
========
//generally for consuming only
Class("JooseX.Namespace.Depended.Resource.Custom", {
isa : JooseX.Namespace.Depended.Resource,
does : [ JooseX.Namespace.Depended.Materialize.Eval, ...]
...
})
DESCRIPTION
===========
`JooseX.Namespace.Depended.Materialize.Eval` is a materializator role. It provide the implementation of `materialize` method.
SEE ALSO
========
Authoring [JooseX.Namespace.Depended](../Authoring.html)
Abstract base resource class: [JooseX.Namespace.Depended.Resource](../Resource.html)
General documentation for Joose: <http://openjsan.org/go/?l=Joose>
AUTHORS
=======
Nickolay Platonov <nplatonov@cpan.org>
COPYRIGHT AND LICENSE
=====================
Copyright (c) 2009-2010, Nickolay Platonov
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of Nickolay Platonov nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/;
Class('JooseX.Namespace.Depended.Resource.JavaScript', {
isa : JooseX.Namespace.Depended.Resource,
has : {
hasDirectUrl : false
},
after: {
initialize: function () {
var me = this
if (this.type == 'nonjoose') this.type = 'javascript'
var presence = this.presence
if (typeof presence == 'string') this.presence = function () {
return eval(presence)
}
if (!presence) this.presence = function () {
return eval(me.token)
}
if (!this.readyness) this.readyness = this.presence
}
},
methods : {
BUILD : function (config) {
var token = config.token
var match = /^=(.*)/.exec(token)
if (match) {
this.hasDirectUrl = true
token = match[1]
}
if (/^http/.test(token)) {
this.hasDirectUrl = true
config.trait = JooseX.Namespace.Depended.Transport.ScriptTag
}
if (/^\//.test(token)) this.hasDirectUrl = true
return config
},
getUrls : function () {
var url = this.token
if (this.hasDirectUrl) return [ url ]
var manager = JooseX.Namespace.Depended.Manager.my
return Joose.A.map(manager.INC, function (libroot) {
libroot = libroot.replace(/\/$/, '')
return [ libroot ].concat(url).join('/index.html') + (manager.disableCaching ? '?disableCaching=' + new Date().getTime() : '')
})
}
}
})
JooseX.Namespace.Depended.Manager.my.registerResourceClass('javascript', JooseX.Namespace.Depended.Resource.JavaScript)
JooseX.Namespace.Depended.Manager.my.registerResourceClass('nonjoose', JooseX.Namespace.Depended.Resource.JavaScript)
;
Class('JooseX.Namespace.Depended.Resource.JooseClass', {
isa : JooseX.Namespace.Depended.Resource.JavaScript,
// NOTE : we don't add the default materialization and transport roles here - they'll be added
// in one of the Bootstrap/*.js files
after: {
initialize: function () {
var me = this
this.presence = function () {
var c = eval(me.token)
return c && c.meta.resource
}
this.readyness = function () {
var c = eval(me.token)
return c && c.meta.resource.ready
}
}
},
methods : {
addDescriptor : function (descriptor) {
if (typeof descriptor == 'object' && !descriptor.token)
Joose.O.eachOwn(descriptor, function (version, name) {
this.addDescriptor({
type : 'joose',
token : name,
version : version
})
}, this)
else
this.SUPER(descriptor)
},
getUrls : function () {
var urls = []
var className = this.token.split('.')
var manager = JooseX.Namespace.Depended.Manager.my
return Joose.A.map(manager.INC, function (libroot) {
libroot = libroot.replace(/\/$/, '')
return [ libroot ].concat(className).join('/index.html') + '/doc/m/mi/michaelsbradleyjr/Hash/006/lib/Task/Hash/.js' + (manager.disableCaching ? '?disableCaching=' + new Date().getTime() : '')
})
}
}
})
JooseX.Namespace.Depended.Manager.my.registerResourceClass('joose', JooseX.Namespace.Depended.Resource.JooseClass);
Class("JooseX.SimpleRequest", {
have : {
req : null
},
methods: {
initialize: function () {
if (window.XMLHttpRequest)
this.req = new XMLHttpRequest()
else
this.req = new ActiveXObject("Microsoft.XMLHTTP")
},
getText: function (urlOrOptions, async, callback, scope) {
var req = this.req
var headers
var url
if (typeof urlOrOptions != 'string') {
headers = urlOrOptions.headers
url = urlOrOptions.url
async = async || urlOrOptions.async
callback = callback || urlOrOptions.callback
scope = scope || urlOrOptions.scope
} else url = urlOrOptions
req.open('GET', url, async || false)
if (headers) Joose.O.eachOwn(headers, function (value, name) {
req.setRequestHeader(name, value)
})
try {
req.onreadystatechange = function (event) {
if (async && req.readyState == 4) {
if (req.status == 200 || req.status == 0) callback.call(scope || this, true, req.responseText)
else callback.call(scope || this, false, "File not found: " + url)
}
};
req.send(null)
} catch (e) {
throw "File not found: " + url
}
if (!async)
if (req.status == 200 || req.status == 0) return req.responseText; else throw "File not found: " + url
return null
}
}
})
/**
Name
====
JooseX.SimpleRequest - Simple XHR request abstraction
SYNOPSIS
========
var req = new JooseX.SimpleRequest()
//asynchronous
req.getText('http://google.com', true, function (success, text) {
if (success) {
...
}
}, this)
//synchronous
try {
var text = req.getText('http://google.com')
} catch (e) {
}
//more options
req.getText({
url : 'http://google.com',
async : true,
callback : function (success, text) {
if (success) {
...
}
},
scope : this,
headers : {
'X-Custom-Header1' : 'Value',
'X-Custom-Header2' : 'Value'
}
})
DESCRIPTION
===========
`JooseX.SimpleRequest` is a *simple* XHR request abstraction (yet it works reasonably well across all major browsers).
It implements only 'GET' requests. If you need more features, you may want to look for another package.
METHODS
=======
### getText
> `void getText(String url, true, Function callback, [Object scope])`
> The signature above corresponds to asynchrnous usage. Method do not return the value and do not throws exception on error.
Instead, the success/error flag and returned text will be passed to `callback` functions, which will be executed in optional `scope`
> `String getText(String url)`
> The signature above corresponds to synchronous usage. Method returns the fetched text and throws exception on error.
> `void|String getText(Object params)`
> The signature above combine both variants of usage. The parameters for the call are passed as object with the following keys:
> - `url` - url to fetch text from
> - `async` - `true` for asynchrnous mode, `false` for synchronous
> - `callback` - the callback function. Will be called in asynchronous usage mode as callback(success, text)
> - `scope` - optional scope for `callback`
> - `headers` - object which key/value pairs will be used to initialize the headers of the request
SEE ALSO
========
Web page of this package: <http://github.com/SamuraiJack/JooseX-SimpleRequest/>
General documentation for Joose: <http://openjsan.org/go/?l=Joose>
BUGS
====
All complex software has bugs lurking in it, and this module is no exception.
Please report any bugs through the web interface at <http://github.com/SamuraiJack/JooseX-SimpleRequest/issues>
AUTHORS
=======
Nickolay Platonov <nplatonov@cpan.org>
COPYRIGHT AND LICENSE
=====================
Copyright (c) 2009, Nickolay Platonov
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of Nickolay Platonov nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
[Test.Run.Result]: Result.html
[Test.Run.Harness]: Harness.html
GETTING HELP
============
This extension is supported via github issues tracker: <http://github.com/SamuraiJack/JooseX-SimpleRequest/issues>
For general Joose questions you can also visit #joose on irc.freenode.org or the forum at: [http://joose.it/forum](http://joose.it/forum)
SEE ALSO
========
Web page of this module: <http://github.com/SamuraiJack/JooseX-SimpleRequest/>
General documentation for Joose: <http://openjsan.org/go/?l=Joose>
BUGS
====
All complex software has bugs lurking in it, and this module is no exception.
Please report any bugs through the web interface at [http://github.com/SamuraiJack/JooseX-SimpleRequest/issues](http://github.com/SamuraiJack/JooseX-SimpleRequest/issues)
AUTHORS
=======
Malte Ubl
Nickolay Platonov [nplatonov@cpan.org](mailto:nplatonov@cpan.org)
COPYRIGHT AND LICENSE
=====================
Copyright (c) 2009, Nickolay Platonov
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of Nickolay Platonov nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
;
Role('JooseX.Meta.Lazy', {
have : {
pendedProps : null,
originalConstructor : null,
isEager : false
},
before : {
prepareProps : function (extend) {
if (extend.eager) this.isEager = true
delete extend.eager
},
extend : function (props) {
if (this.pending) this.finalize()
}
},
after : {
adaptConstructor: function (c) {
c.getMeta = function () {
var meta = this.meta
if (meta.pending) meta.finalize()
return meta
}
}
},
override : {
extractConstructor : function (extend) {
var originalConstructor = this.SUPER(extend)
this.adaptConstructor(originalConstructor)
return function () {
var thisMeta = arguments.callee.meta
if (thisMeta.pending) thisMeta.finalize()
return originalConstructor.apply(this, arguments)
}
},
//is not re-entrant
finalize : function (props) {
if (this.isEager) return this.SUPER(props)
if (!this.pending) {
this.pending = true
this.pendedProps = props
return
}
this.pending = false
this.isEager = true
this.SUPER(this.pendedProps)
delete this.pendedProps
}
},
body : function () {
//lazy checker will be installed system wide (into Joose.Managed.Bootstrap) to monitor for each usual class
//whether the superclass or a role being added is lazy
var LazyChecker = Role({
meta : Joose.Managed.Role,
have : {
pending : false
},
before : {
addRole : function () {
Joose.A.each(arguments, function(arg) {
var role = (arg.meta instanceof Joose.Managed.Class) ? arg : arg.role
var roleMeta = role.meta
if (roleMeta.meta.hasAttribute('pending') && roleMeta.pending) roleMeta.finalize()
})
},
finalize : function (extend) {
if (!(this instanceof Joose.Managed.Role) && this.superClass != this.defaultSuperClass) {
var superMeta = this.superClass.meta
if (superMeta && superMeta.meta.hasAttribute('pending') && superMeta.pending) superMeta.finalize()
}
}
}
})
Joose.Managed.Bootstrap.meta.extend({
does : LazyChecker
})
Joose.Namespace.Manager.my.register('LazyClass', Class('Class', {
isa : Joose.Meta.Class,
meta : Joose.Meta.Class,
does : JooseX.Meta.Lazy
}))
Joose.Namespace.Manager.my.register('LazyRole', Class('Role', {
isa : Joose.Meta.Role,
meta : Joose.Meta.Class,
does : JooseX.Meta.Lazy
}))
}
})
/**
Name
====
JooseX.Meta.Lazy - A trait to make your metaclasses lazy
SYNOPSIS
========
Role("Some.Lazy.Role", {
trait : JooseX.Meta.Lazy,
has : {
...
},
methods : {
...
}
})
Class("Some.Lazy.Class", {
trait : JooseX.Meta.Lazy,
does : Some.Lazy.Role
has : {
...
},
methods : {
...
}
})
// your class and role will be actually created only in this call
var instance = new Some.Lazy.Class({
})
// alternative declaration - no traits required
LazyRole("Some.Lazy.Role", {
...
})
LazyClass("Some.Lazy.Class", {
...
})
DESCRIPTION
===========
`JooseX.Meta.Lazy` is a meta-role, making your class (or role) lazy. "Lazy" here means, that the creation of the
metaclass instance will be deferred until the first instantiation of class (or first consumption of role).
If you have a *big* class hierarchy (like the [bridged ExtJS hierarchy](/go/index_l_JooseX.Bridge.Ext.html) for example or your own framework),
this module can reduce the initialization time.
You can apply it as a trait (the 1st example in the synopsys), or you can use the new declaration helpers: `LazyClass` or `LazyRole`
INHERITANCE
===========
Note, that by default, subclasses uses the same metaclass as their parents. Thus, if you'll subclass the lazy class, the resulting class will be
also lazy. If you'd like to avoid this, see the next section for details.
`eager` BUILDER
===============
If you are using the lazy metaclass and still wants to create a normal class, you can use new builder `eager` for that:
Class("Some.Lazy.Class", {
trait : JooseX.Meta.Lazy,
...
})
Class("Some.Eager.Class", {
isa : Some.Lazy.Class // will provide the lazy meta for this class
eager : true // will create class immediately
})
GETTING HELP
============
This extension is supported via github issues tracker: <http://github.com/SamuraiJack/JooseX-Meta-Lazy/issues>
For general Joose questions you can also visit #joose on irc.freenode.org or the forum at: <http://joose.it/forum>
SEE ALSO
========
Web page of this module: <http://github.com/SamuraiJack/JooseX-Meta-Lazy/>
General documentation for Joose: <http://openjsan.org/go/?l=Joose>
BUGS
====
All complex software has bugs lurking in it, and this module is no exception.
Please report any bugs through the web interface at <http://github.com/SamuraiJack/JooseX-Meta-Lazy/issues>
ACKNOWLEDGMENTS
===============
Many thanks to Malte Ubl for the idea of this module.
AUTHORS
=======
Nickolay Platonov <nplatonov@cpan.org>
COPYRIGHT AND LICENSE
=====================
Copyright (c) 2009, Nickolay Platonov
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of Nickolay Platonov nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
;
Role('JooseX.Namespace.Depended.Materialize.ScriptTag', {
requires : [ 'handleLoad' ],
methods : {
materialize : function (resourceBlob) {
var loaderNode = document.createElement("script")
loaderNode.text = resourceBlob
//adding to body, because Safari do not create HEAD for iframe's documents
document.body.appendChild(loaderNode)
}
}
})
;
Role('JooseX.Namespace.Depended.Transport.XHRAsync', {
requires : [ 'handleLoad' ],
override : {
load: function (url, onsuccess, onerror) {
var req = new JooseX.SimpleRequest()
try {
req.getText(url, true, function (success, text) {
if (!success) {
onerror(this + " not found")
return
}
onsuccess(text, url)
})
} catch (e) {
onerror(e)
}
}
}
})
/**
Name
====
JooseX.Namespace.Depended.Transport.XHRAsync - transport, which use the asynchronous XHR request for resource loading
SYNOPSIS
========
//generally for consuming only
Class("JooseX.Namespace.Depended.Resource.Custom", {
isa : JooseX.Namespace.Depended.Resource,
does : [ JooseX.Namespace.Depended.Transport.XHRAsync, ...]
...
})
DESCRIPTION
===========
`JooseX.Namespace.Depended.Transport.XHRAsync` is a transport role. It provide the implementation of `load` method, which use the
asynchronous XHR request for resource loading.
SEE ALSO
========
Authoring [JooseX.Namespace.Depended](../Authoring.html)
Abstract base resource class: [JooseX.Namespace.Depended.Resource](../Resource.html)
General documentation for Joose: <http://openjsan.org/go/?l=Joose>
AUTHORS
=======
Nickolay Platonov <nplatonov@cpan.org>
COPYRIGHT AND LICENSE
=====================
Copyright (c) 2009-2010, Nickolay Platonov
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of Nickolay Platonov nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/;
Role('JooseX.Namespace.Depended.Transport.XHRSync', {
requires : [ 'handleLoad' ],
override : {
load: function (url, onsuccess, onerror) {
var req = new JooseX.SimpleRequest()
var text;
try {
text = req.getText(url)
} catch (e) {
onerror(e)
return
}
onsuccess(text, url)
}
}
})
/**
Name
====
JooseX.Namespace.Depended.Transport.XHRSync - transport, which use the synchronous XHR request for resource loading
SYNOPSIS
========
//generally for consuming only
Class("JooseX.Namespace.Depended.Resource.Custom", {
isa : JooseX.Namespace.Depended.Resource,
does : [ JooseX.Namespace.Depended.Transport.XHRSync, ...]
...
})
DESCRIPTION
===========
`JooseX.Namespace.Depended.Transport.XHRSync` is a transport role. It provide the implementation of `load` method, which use the
synchronous XHR request for resource loading.
SEE ALSO
========
Authoring [JooseX.Namespace.Depended](../Authoring.html)
Abstract base resource class: [JooseX.Namespace.Depended.Resource](../Resource.html)
General documentation for Joose: <http://openjsan.org/go/?l=Joose>
AUTHORS
=======
Nickolay Platonov <nplatonov@cpan.org>
COPYRIGHT AND LICENSE
=====================
Copyright (c) 2009-2010, Nickolay Platonov
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of Nickolay Platonov nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/;
Role('JooseX.Namespace.Depended.Transport.ScriptTag', {
requires : [ 'handleLoad' ],
override : {
load: function (url, onsuccess, onerror) {
var loaderNode = document.createElement("script")
// if (Joose.is_IE) var errorTimeOut
loaderNode.onload = loaderNode.onreadystatechange = function () {
if (!loaderNode.readyState || loaderNode.readyState == "loaded" || loaderNode.readyState == "complete" || loaderNode.readyState == 4 && loaderNode.status == 200)
//surely for IE6..
setTimeout(function () { onsuccess(loaderNode.text, url) }, 1)
}
loaderNode.setAttribute("type", "text/javascript")
loaderNode.setAttribute("src", url)
document.getElementsByTagName("head")[0].appendChild(loaderNode)
},
materialize : function () {
}
}
})
/**
Name
====
JooseX.Namespace.Depended.Transport.ScriptTag - transport, which use the <script> tag for resource loading
SYNOPSIS
========
//generally for consuming only
Class("JooseX.Namespace.Depended.Resource.Custom", {
isa : JooseX.Namespace.Depended.Resource,
does : [ JooseX.Namespace.Depended.Transport.ScriptTag, ...]
...
})
DESCRIPTION
===========
`JooseX.Namespace.Depended.Transport.ScriptTag` is a transport role. It provide the implementation of `load` method, which use the
<script> tag for resource loading. It also overrides the `materialize` method as <script> tag execute the code along with loading.
SEE ALSO
========
Authoring [JooseX.Namespace.Depended](../Authoring.html)
Abstract base resource class: [JooseX.Namespace.Depended.Resource](../Resource.html)
General documentation for Joose: <http://openjsan.org/go/?l=Joose>
AUTHORS
=======
Nickolay Platonov <nplatonov@cpan.org>
COPYRIGHT AND LICENSE
=====================
Copyright (c) 2009-2010, Nickolay Platonov
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of Nickolay Platonov nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/;
Role('JooseX.Namespace.Depended.Transport.NodeJS', {
requires : [ 'handleLoad' ],
override : {
load: function (url, onsuccess, onerror) {
var fs = require('fs')
fs.readFile(url, function (err, data) {
if (err) {
onerror(err)
return
}
onsuccess(data, url)
})
}
}
})
/**
Name
====
JooseX.Namespace.Depended.Transport.Node - transport, which use the `fs.readFile()` call of NodeJS, to load the content of resource.
SYNOPSIS
========
//generally for consuming only
Class("JooseX.Namespace.Depended.Resource.Custom", {
isa : JooseX.Namespace.Depended.Resource,
does : [ JooseX.Namespace.Depended.Transport.Node, ...]
...
})
DESCRIPTION
===========
`JooseX.Namespace.Depended.Transport.Node` is a transport role. It provide the implementation of `load` method,
which use the `fs.readFile()` call of NodeJS for resource loading.
SEE ALSO
========
Authoring [JooseX.Namespace.Depended](../Authoring.html)
Abstract base resource class: [JooseX.Namespace.Depended.Resource](../Resource.html)
General documentation for Joose: <http://openjsan.org/go/?l=Joose>
AUTHORS
=======
Nickolay Platonov <nplatonov@cpan.org>
COPYRIGHT AND LICENSE
=====================
Copyright (c) 2009-2010, Nickolay Platonov
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of Nickolay Platonov nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/;
Role('JooseX.Namespace.Depended.Materialize.NodeJS', {
requires : [ 'handleLoad' ],
methods : {
materialize : function (resourceBlob, url) {
// global scope
if (process.global == global)
process.compile(
'(function (exports, require, module, __filename, __dirname) {' + resourceBlob + '})',
url
)(exports, require, module, __filename, __dirname)
else
// running in Test.Run
(function (){
eval(resourceBlob + '')
})()
}
}
})
/**
Name
====
JooseX.Namespace.Depended.Materialize.NodeJS - materializator, which execute the code, using the `Script.runInThisContext` call of NodeJS.
SYNOPSIS
========
//generally for consuming only
Class("JooseX.Namespace.Depended.Resource.Custom", {
isa : JooseX.Namespace.Depended.Resource,
does : [ JooseX.Namespace.Depended.Materialize.NodeJS, ...]
...
})
DESCRIPTION
===========
`JooseX.Namespace.Depended.Materialize.NodeJS` is a materializator role. It provide the implementation of `materialize` method.
SEE ALSO
========
Authoring [JooseX.Namespace.Depended](../Authoring.html)
Abstract base resource class: [JooseX.Namespace.Depended.Resource](../Resource.html)
General documentation for Joose: <http://openjsan.org/go/?l=Joose>
AUTHORS
=======
Nickolay Platonov <nplatonov@cpan.org>
COPYRIGHT AND LICENSE
=====================
Copyright (c) 2009-2010, Nickolay Platonov
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of Nickolay Platonov nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/;
Class('JooseX.Namespace.Depended.Resource.Require', {
isa : JooseX.Namespace.Depended.Resource,
methods : {
getUrls : function () {
return [ this.token ]
},
load: function (url, onsuccess, onerror) {
require.async(url, function (err) {
if (err instanceof Error)
onerror(err)
else
onsuccess('', url)
})
},
materialize : function () {
}
}
})
JooseX.Namespace.Depended.Manager.my.registerResourceClass('require', JooseX.Namespace.Depended.Resource.Require)
;
Role('JooseX.Namespace.Depended', {
/*VERSION*/VERSION : 0.08,
meta : Joose.Managed.Role,
requires : [ 'prepareProperties' ],
have : {
containResources : [ 'use', 'meta', 'isa', 'does', 'trait', 'traits' ]
},
override: {
prepareProperties : function (name, extend, defaultMeta, callback) {
if (name && typeof name != 'string') {
extend = name
name = null
}
extend = extend || {}
var summaredDeps = []
var extendMy = extend.my
//gathering all the related resourses from various builders
//also gathering resourses of 'my'
Joose.A.each(this.containResources, function (propName) {
this.collectDependencies(extend[propName], summaredDeps, extend, propName)
if (extendMy && extendMy[propName]) this.collectDependencies(extendMy[propName], summaredDeps, extendMy, propName)
}, this)
//and from externally collected additional resources
this.alsoDependsFrom(extend, summaredDeps)
var resource = JooseX.Namespace.Depended.Manager.my.getResource({
type : 'joose',
token : name
})
if (extend.VERSION) resource.setVersion(extend.VERSION)
//BEGIN executes right after the all dependencies are loaded, but before this module becomes ready (before body())
//this allows to manually control the "ready-ness" of module (custom pre-processing)
//BEGIN receives the function (callback), which should be called at the end of custom processing
if (extend.BEGIN) {
resource.setOnBeforeReady(extend.BEGIN)
delete extend.BEGIN
}
Joose.A.each(summaredDeps, function (descriptor) {
resource.addDescriptor(descriptor)
})
//skip constructing for classes w/o dependencies
if (Joose.O.isEmpty(resource.dependencies)) {
this.inlineDependencies(extend)
var res = this.SUPER(name, extend, defaultMeta, callback)
//this will allow to classes which don't have dependencies to be ready synchronously
resource.checkReady()
return res
} else {
// defer the dependencies loading, because they actually could be provided later in the same bundle file
// this, however, affect performance, so bundles should be created in the dependencies-ordered way
setTimeout(function () {
resource.handleDependencies()
}, 0)
// debugging warning
if (typeof ENABLE_DEFERRED_DEPS_WARNING != 'undefined')
console.log('Deferred deps handling for class [' + name + '], deps = [' + JSON.stringify(resource.dependencies) + ']')
}
var me = this
//unshift is critical for correct order of readyListerens processing!
//constructing is delaying until resource will become ready
resource.readyListeners.unshift(function () {
me.inlineDependencies(extend)
me.prepareProperties(name, extend, defaultMeta, callback)
})
return this.create(name, Joose.Namespace.Keeper, {})
},
create : function () {
var meta = this.SUPERARG(arguments).meta
meta.resource = meta.resource || JooseX.Namespace.Depended.Manager.my.getMyResource('joose', meta.name, meta.c)
return meta.c
}
},
//eof override
methods : {
alsoDependsFrom : function (extend, summaredDeps) {
},
collectDependencies : function (from, to, extend, propName) {
Joose.A.each(Joose.O.wantArray(from), function (descriptor) {
if (descriptor && typeof descriptor != 'function') to.push(descriptor)
})
},
inlineDependencies : function (extend) {
this.inlineDeps(extend)
var extendMy = extend.my
if (extendMy) this.inlineDeps(extendMy)
},
inlineDeps : function (extend) {
delete extend.use
Joose.A.each(this.containResources, function (propName) {
if (extend[propName]) {
var descriptors = []
Joose.A.each(Joose.O.wantArray(extend[propName]), function (descriptor, index) {
var descType = typeof descriptor
if (descType == 'function')
descriptors.push(descriptor.meta ? descriptor : descriptor())
else
if (descType == 'object')
if (descriptor.token)
descriptors.push(eval(descriptor.token))
else
Joose.O.each(descriptor, function (version, name) {
descriptors.push(eval(name))
})
else
if (descType == 'string')
descriptors.push(eval(descriptor))
else
throw "Wrong dependency descriptor format: " + descriptor
})
if (propName != 'isa' && propName != 'meta')
extend[propName] = descriptors
else
if (descriptors.length > 1)
throw "Cant specify several super- or meta- classes"
else
extend[propName] = descriptors[0]
}
})
}
}
})
Joose.Namespace.Manager.meta.extend({
does : JooseX.Namespace.Depended
})
Joose.Namespace.Keeper.meta.extend({
after: {
copyNamespaceState: function (targetClass) {
targetClass.meta.resource = this.resource
}
}
})
;
if (Joose.is_NodeJS) {
JooseX.Namespace.Depended.Resource.JavaScript.meta.extend({
does : [ JooseX.Namespace.Depended.Transport.NodeJS, JooseX.Namespace.Depended.Materialize.NodeJS ]
})
JooseX.Namespace.Depended.Manager.my.disableCaching = false
Joose.Namespace.Manager.my.containResources.unshift('require')
JooseX.Namespace.Depended.meta.extend({
override : {
collectDependencies : function (from, to, extend, propName) {
if (propName != 'require') return this.SUPERARG(arguments)
if (!from) return
Joose.A.each(Joose.O.wantArray(from), function (url) {
to.push({
type : 'require',
token : url
})
})
delete extend.require
}
}
})
} else
JooseX.Namespace.Depended.Resource.JavaScript.meta.extend({
does : [ JooseX.Namespace.Depended.Transport.XHRAsync, JooseX.Namespace.Depended.Materialize.Eval ]
})
;
;
/*//////////////////////////////////////////////////////////////////////////
* THIS PROGRAM IS A DERIVATIVE OF AN EXISTING WORK :: 4 September 2010
* See: http://pajhome.org.uk/crypt/md5/scripts.html
*
* Significant but mostly superficial changes have been made to the structure of the
* source so that it conforms to the Joose3 object system for JavaScript
* See: http://joose.it/
/*//////////////////////////////////////////////////////////////////////////
Class('Encode', {
/*VERSION*/VERSION : 0.06,
my : {
has : {
/*
* Configurable variables. You may need to tweak these to be compatible with
* the server-side, but the defaults work in most cases.
*/
hexcase : {
is : 'rw',
init : 0
},
b64pad : {
is : 'rw',
init : ''
}
},
methods : {
/*
* Convert a raw string to a hex string
*/
rstr2hex : function (input) {
// try { this.getHexcase() } catch(e) { this.setHexcase(0) }
var hex_tab = this.getHexcase() ? '0123456789ABCDEF' : '0123456789abcdef'
var output = ''
var x
for(var i = 0; i < input.length; i++) {
x = input.charCodeAt(i)
output += hex_tab.charAt((x >>> 4) & 0x0F)
+ hex_tab.charAt( x & 0x0F)
}
return output
},
/*
* Convert a raw string to a base-64 string
*/
rstr2b64 : function (input) {
// try { this.getB64pad() } catch(e) { this.setB64pad('') }
var tab = '/doc/m/mi/michaelsbradleyjr/Hash/006/lib/Task/Hash/ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789/index.html'
var output = ''
var len = input.length
for(var i = 0; i < len; i += 3) {
var triplet = (input.charCodeAt(i) << 16)
| (i + 1 < len ? input.charCodeAt(i+1) << 8 : 0)
| (i + 2 < len ? input.charCodeAt(i+2) : 0)
for(var j = 0; j < 4; j++) {
if(i * 8 + j * 6 > input.length * 8) output += b64pad
else output += tab.charAt((triplet >>> 6*(3-j)) & 0x3F)
}
}
return output
},
/*
* Convert a raw string to an arbitrary string encoding
*/
rstr2any : function (input, encoding) {
var divisor = encoding.length
var i, j, q, x, quotient
/* Convert to an array of 16-bit big-endian values, forming the dividend */
var dividend = Array(Math.ceil(input.length / 2))
for(i = 0; i < dividend.length; i++) {
dividend[i] = (input.charCodeAt(i * 2) << 8) | input.charCodeAt(i * 2 + 1)
}
/*
* Repeatedly perform a long division. The binary array forms the dividend,
* the length of the encoding is the divisor. Once computed, the quotient
* forms the dividend for the next step. All remainders are stored for later
* use.
*/
var full_length = Math.ceil(input.length * 8 / (Math.log(encoding.length) / Math.log(2)))
var remainders = Array(full_length)
for(j = 0; j < full_length; j++) {
quotient = Array()
x = 0
for(i = 0; i < dividend.length; i++) {
x = (x << 16) + dividend[i]
q = Math.floor(x / divisor)
x -= q * divisor
if(quotient.length > 0 || q > 0)
quotient[quotient.length] = q
}
remainders[j] = x
dividend = quotient
}
/* Convert the remainders to the output string */
var output = ''
for(i = remainders.length - 1; i >= 0; i--)
output += encoding.charAt(remainders[i])
return output
},
/*
* Encode a string as utf-8.
* For efficiency, this assumes the input is valid utf-16.
*/
str2rstr_utf8 : function (input) {
var output = ''
var i = -1
var x, y
while(++i < input.length) {
/* Decode utf-16 surrogate pairs */
x = input.charCodeAt(i)
y = i + 1 < input.length ? input.charCodeAt(i + 1) : 0
if(0xD800 <= x && x <= 0xDBFF && 0xDC00 <= y && y <= 0xDFFF) {
x = 0x10000 + ((x & 0x03FF) << 10) + (y & 0x03FF)
i++
}
/* Encode output as utf-8 */
if(x <= 0x7F) {
output += String.fromCharCode(x)
}
else if(x <= 0x7FF) {
output += String.fromCharCode(0xC0 | ((x >>> 6 ) & 0x1F),
0x80 | ( x & 0x3F))
}
else if(x <= 0xFFFF) {
output += String.fromCharCode(0xE0 | ((x >>> 12) & 0x0F),
0x80 | ((x >>> 6 ) & 0x3F),
0x80 | ( x & 0x3F))
}
else if(x <= 0x1FFFFF) {
output += String.fromCharCode(0xF0 | ((x >>> 18) & 0x07),
0x80 | ((x >>> 12) & 0x3F),
0x80 | ((x >>> 6 ) & 0x3F),
0x80 | ( x & 0x3F))
}
}
return output
},
/*
* Encode a string as utf-16
*/
str2rstr_utf16le : function (input) {
var output = ''
for(var i = 0; i < input.length; i++) {
output += String.fromCharCode( input.charCodeAt(i) & 0xFF,
(input.charCodeAt(i) >>> 8) & 0xFF)
}
return output
},
str2rstr_utf16be : function (input) {
var output = ''
for(var i = 0; i < input.length; i++) {
output += String.fromCharCode((input.charCodeAt(i) >>> 8) & 0xFF,
input.charCodeAt(i) & 0xFF)
}
return output
},
/*
* Convert a raw string to an array of little-endian words
* Characters >255 have their high-byte silently ignored.
*/
rstr2binl : function (input) {
var output = Array(input.length >> 2)
for(var i = 0; i < output.length; i++) {
output[i] = 0
}
for(var i = 0; i < input.length * 8; i += 8) {
output[i>>5] |= (input.charCodeAt(i / 8) & 0xFF) << (i%32)
}
return output
},
/*
* Convert an array of little-endian words to a string
*/
binl2rstr : function (input) {
var output = ''
for(var i = 0; i < input.length * 32; i += 8) {
output += String.fromCharCode((input[i>>5] >>> (i % 32)) & 0xFF)
}
return output
},
/*
* Convert a raw string to an array of big-endian words
* Characters >255 have their high-byte silently ignored.
*/
rstr2binb : function (input) {
var output = Array(input.length >> 2)
for(var i = 0; i < output.length; i++) {
output[i] = 0
}
for(var i = 0; i < input.length * 8; i += 8) {
output[i>>5] |= (input.charCodeAt(i / 8) & 0xFF) << (24 - i % 32)
}
return output
},
/*
* Convert an array of big-endian words to a string
*/
binb2rstr : function (input) {
var output = ''
for(var i = 0; i < input.length * 32; i += 8) {
output += String.fromCharCode((input[i>>5] >>> (24 - i % 32)) & 0xFF)
}
return output
}
}
}
})
/*///////////////////// ORIGINAL LICENSE BELOW ////////////////////////////////
* Copyright (c) 1998 - 2009, Paul Johnston & Contributors
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the <ORGANIZATION> nor the names of its contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
/*///////////////////////////////////////////////////////////////////////////
;
Joose.Class('Hash', {
/*VERSION*/VERSION : 0.06,
use : [ 'Encode', 'Hash.MD5', 'Hash.SHA1', 'Hash.SHA256', 'Hash.SHA512', 'Hash.RIPEMD160' ],
my : {
methods : {
md5 : function (str) {
return Hash.MD5.hex_md5(str)
},
sha1 : function (str) {
return Hash.SHA1.hex_sha1(str)
},
sha256 : function (str) {
return Hash.SHA256.hex_sha256(str)
},
sha512 : function (str) {
return Hash.SHA512.hex_sha512(str)
},
rmd160 : function (str) {
return Hash.RIPEMD160.hex_rmd160(str)
},
oTa : function (obj, loop) {
if (this.typeOf(obj) != 'object') { throw 'not an object' }
if (loop) {
var noCirc = obj
}
else {
// on the first pass, check for circular structures in the input object
var noCirc = JSON.parse(JSON.stringify(obj))
}
var thisClass = this
var toArray = function (element, index) {
switch (element[1]) {
case 'object':
return [element[0], 1, thisClass.oTa(noCirc[element[0]], true)]
case 'array':
return [element[0], thisClass.array_check_for_objects(noCirc[element[0]])]
default:
return [element[0], noCirc[element[0]]]
}
}
var kt = this.keysAndTypes(noCirc, true)
var tA = []
return tA = Joose.A.map(kt, toArray)
},
typeOf : function (value) {
var s = typeof value
if (s === 'object') {
if (value) {
if (typeof value.length === 'number' && !(value.propertyIsEnumerable('length')) && typeof value.splice === 'function') {
s = 'array'
}
}
else {
s = 'null'
}
}
return s
},
keys : function (obj) {
if (this.typeOf(obj) != 'object') { throw 'not an object' }
var keys = []
for (var key in obj) {
keys.push(key)
}
return keys
},
keysAndTypes : function (obj, sort) {
if (sort) {
var Keys = this.keys(obj).sort()
}
else {
var Keys = this.keys(obj)
}
var thisClass = this
var kAt = function (element, index) {
return [element, thisClass.typeOf(obj[element])]
}
var kt = []
return kt = Joose.A.map(Keys, kAt)
},
array_check_for_objects : function (a) {
thisClass = this
var expand = function (element, index) {
switch (thisClass.typeOf(element)) {
case 'object':
return thisClaTarray(element, true)
case 'array':
return thisClass.array_check_for_objects(element)
default:
return element
}
}
ea = []
return ea = Joose.A.map(a, expand)
}
}
}
})
;
/*//////////////////////////////////////////////////////////////////////////
* THIS PROGRAM IS A DERIVATIVE OF AN EXISTING WORK :: 4 September 2010
* See: http://pajhome.org.uk/crypt/md5/scripts.html
*
* Significant but mostly superficial changes have been made to the structure of the
* source so that it conforms to the Joose3 object system for JavaScript
* See: http://joose.it/
/*//////////////////////////////////////////////////////////////////////////
Joose.Class('Hash.MD5', {
/*VERSION*/VERSION : 0.06,
my : {
methods : {
/*
* Configurable variables. You may need to tweak these to be compatible with
* the server-side, but the defaults work in most cases.
*/
hex_md5 : function (s) {
return Encode.rstr2hex(this.rstr_md5(Encode.str2rstr_utf8(s)))
},
b64_md5 : function (s) {
return Encode.rstr2b64(this.rstr_md5(Encode.str2rstr_utf8(s)))
},
any_md5 : function (s, e) {
return Encode.rstr2any(this.rstr_md5(Encode.str2rstr_utf8(s)), e)
},
hex_hmac_md5 : function (k, d) {
return Encode.rstr2hex(this.rstr_hmac_md5(Encode.str2rstr_utf8(k), Encode.str2rstr_utf8(d)))
},
b64_hmac_md5 : function (k, d) {
return Encode.rstr2b64(this.rstr_hmac_md5(Encode.str2rstr_utf8(k), Encode.str2rstr_utf8(d)))
},
any_hmac_md5 : function (k, d, e) {
return Encode.rstr2any(this.rstr_hmac_md5(Encode.str2rstr_utf8(k), Encode.str2rstr_utf8(d)), e)
},
/*
* Perform a simple self-test to see if the VM is working
*/
md5_vm_test : function () {
return this.hex_md5('abc').toLowerCase() == '900150983cd24fb0d6963f7d28e17f72'
},
/*
* Calculate the MD5 of a raw string
*/
rstr_md5 : function (s) {
return Encode.binl2rstr(this.binl_md5(Encode.rstr2binl(s), s.length * 8))
},
/*
* Calculate the HMAC-MD5, of a key and some data (raw strings)
*/
rstr_hmac_md5 : function (key, data) {
var bkey = Encode.rstr2binl(key)
if(bkey.length > 16) bkey = this.binl_md5(bkey, key.length * 8)
var ipad = Array(16), opad = Array(16)
for(var i = 0; i < 16; i++) {
ipad[i] = bkey[i] ^ 0x36363636
opad[i] = bkey[i] ^ 0x5C5C5C5C
}
var hash = this.binl_md5(ipad.concat(Encode.rstr2binl(data)), 512 + data.length * 8)
return Encode.binl2rstr(this.binl_md5(opad.concat(hash), 512 + 128))
},
/*
* Calculate the MD5 of an array of little-endian words, and a bit length.
*/
binl_md5 : function (x, len) {
/* append padding */
x[len >> 5] |= 0x80 << ((len) % 32)
x[(((len + 64) >>> 9) << 4) + 14] = len
var a = 1732584193
var b = -271733879
var c = -1732584194
var d = 271733878
for(var i = 0; i < x.length; i += 16) {
var olda = a
var oldb = b
var oldc = c
var oldd = d
a = this.md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936)
d = this.md5_ff(d, a, b, c, x[i+ 1], 12, -389564586)
c = this.md5_ff(c, d, a, b, x[i+ 2], 17, 606105819)
b = this.md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330)
a = this.md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897)
d = this.md5_ff(d, a, b, c, x[i+ 5], 12, 1200080426)
c = this.md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341)
b = this.md5_ff(b, c, d, a, x[i+ 7], 22, -45705983)
a = this.md5_ff(a, b, c, d, x[i+ 8], 7 , 1770035416)
d = this.md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417)
c = this.md5_ff(c, d, a, b, x[i+10], 17, -42063)
b = this.md5_ff(b, c, d, a, x[i+11], 22, -1990404162)
a = this.md5_ff(a, b, c, d, x[i+12], 7 , 1804603682)
d = this.md5_ff(d, a, b, c, x[i+13], 12, -40341101)
c = this.md5_ff(c, d, a, b, x[i+14], 17, -1502002290)
b = this.md5_ff(b, c, d, a, x[i+15], 22, 1236535329)
a = this.md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510)
d = this.md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632)
c = this.md5_gg(c, d, a, b, x[i+11], 14, 643717713)
b = this.md5_gg(b, c, d, a, x[i+ 0], 20, -373897302)
a = this.md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691)
d = this.md5_gg(d, a, b, c, x[i+10], 9 , 38016083)
c = this.md5_gg(c, d, a, b, x[i+15], 14, -660478335)
b = this.md5_gg(b, c, d, a, x[i+ 4], 20, -405537848)
a = this.md5_gg(a, b, c, d, x[i+ 9], 5 , 568446438)
d = this.md5_gg(d, a, b, c, x[i+14], 9 , -1019803690)
c = this.md5_gg(c, d, a, b, x[i+ 3], 14, -187363961)
b = this.md5_gg(b, c, d, a, x[i+ 8], 20, 1163531501)
a = this.md5_gg(a, b, c, d, x[i+13], 5 , -1444681467)
d = this.md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784)
c = this.md5_gg(c, d, a, b, x[i+ 7], 14, 1735328473)
b = this.md5_gg(b, c, d, a, x[i+12], 20, -1926607734)
a = this.md5_hh(a, b, c, d, x[i+ 5], 4 , -378558)
d = this.md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463)
c = this.md5_hh(c, d, a, b, x[i+11], 16, 1839030562)
b = this.md5_hh(b, c, d, a, x[i+14], 23, -35309556)
a = this.md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060)
d = this.md5_hh(d, a, b, c, x[i+ 4], 11, 1272893353)
c = this.md5_hh(c, d, a, b, x[i+ 7], 16, -155497632)
b = this.md5_hh(b, c, d, a, x[i+10], 23, -1094730640)
a = this.md5_hh(a, b, c, d, x[i+13], 4 , 681279174)
d = this.md5_hh(d, a, b, c, x[i+ 0], 11, -358537222)
c = this.md5_hh(c, d, a, b, x[i+ 3], 16, -722521979)
b = this.md5_hh(b, c, d, a, x[i+ 6], 23, 76029189)
a = this.md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487)
d = this.md5_hh(d, a, b, c, x[i+12], 11, -421815835)
c = this.md5_hh(c, d, a, b, x[i+15], 16, 530742520)
b = this.md5_hh(b, c, d, a, x[i+ 2], 23, -995338651)
a = this.md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844)
d = this.md5_ii(d, a, b, c, x[i+ 7], 10, 1126891415)
c = this.md5_ii(c, d, a, b, x[i+14], 15, -1416354905)
b = this.md5_ii(b, c, d, a, x[i+ 5], 21, -57434055)
a = this.md5_ii(a, b, c, d, x[i+12], 6 , 1700485571)
d = this.md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606)
c = this.md5_ii(c, d, a, b, x[i+10], 15, -1051523)
b = this.md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799)
a = this.md5_ii(a, b, c, d, x[i+ 8], 6 , 1873313359)
d = this.md5_ii(d, a, b, c, x[i+15], 10, -30611744)
c = this.md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380)
b = this.md5_ii(b, c, d, a, x[i+13], 21, 1309151649)
a = this.md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070)
d = this.md5_ii(d, a, b, c, x[i+11], 10, -1120210379)
c = this.md5_ii(c, d, a, b, x[i+ 2], 15, 718787259)
b = this.md5_ii(b, c, d, a, x[i+ 9], 21, -343485551)
a = this.safe_add(a, olda)
b = this.safe_add(b, oldb)
c = this.safe_add(c, oldc)
d = this.safe_add(d, oldd)
}
return Array(a, b, c, d)
},
/*
* These functions implement the four basic operations the algorithm uses.
*/
md5_cmn : function (q, a, b, x, s, t) {
return this.safe_add(this.bit_rol(this.safe_add(this.safe_add(a, q), this.safe_add(x, t)), s),b)
},
md5_ff : function (a, b, c, d, x, s, t) {
return this.md5_cmn((b & c) | ((~b) & d), a, b, x, s, t)
},
md5_gg : function (a, b, c, d, x, s, t) {
return this.md5_cmn((b & d) | (c & (~d)), a, b, x, s, t)
},
md5_hh : function (a, b, c, d, x, s, t) {
return this.md5_cmn(b ^ c ^ d, a, b, x, s, t)
},
md5_ii : function (a, b, c, d, x, s, t) {
return this.md5_cmn(c ^ (b | (~d)), a, b, x, s, t)
},
/*
* Add integers, wrapping at 2^32. This uses 16-bit operations internally
* to work around bugs in some JS interpreters.
*/
safe_add : function (x, y) {
var lsw = (x & 0xFFFF) + (y & 0xFFFF)
var msw = (x >> 16) + (y >> 16) + (lsw >> 16)
return (msw << 16) | (lsw & 0xFFFF)
},
/*
* Bitwise rotate a 32-bit number to the left.
*/
bit_rol : function (num, cnt) {
return (num << cnt) | (num >>> (32 - cnt))
}
}
}
})
/*///////////////////// ORIGINAL LICENSE BELOW ////////////////////////////////
* A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
* Digest Algorithm, as defined in RFC 1321.
* Version 2.2 Copyright (C) Paul Johnston 1999 - 2009
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
* Distributed under the BSD License
* All rights reserved.
*
* See http://pajhome.org.uk/crypt/md5 for more info.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the <ORGANIZATION> nor the names of its contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
/*///////////////////////////////////////////////////////////////////////////
;
/*//////////////////////////////////////////////////////////////////////////
* THIS PROGRAM IS A DERIVATIVE OF AN EXISTING WORK :: 7 September 2010
* See: http://pajhome.org.uk/crypt/md5/scripts.html
*
* Significant but mostly superficial changes have been made to the structure of the
* source so that it conforms to the Joose3 object system for JavaScript
* See: http://joose.it/
/*//////////////////////////////////////////////////////////////////////////
Joose.Class('Hash.SHA1', {
/*VERSION*/VERSION : 0.06,
my : {
methods : {
/*
* These are the functions you'll usually want to call
* They take string arguments and return either hex or base-64 encoded strings
*/
hex_sha1 : function (s) { return Encode.rstr2hex(this.rstr_sha1(Encode.str2rstr_utf8(s))) },
b64_sha1 : function (s) { return Encode.rstr2b64(this.rstr_sha1(Encode.str2rstr_utf8(s))) },
any_sha1 : function (s, e) { return Encode.rstr2any(this.rstr_sha1(Encode.str2rstr_utf8(s)), e) },
hex_hmac_sha1 : function (k, d) { return Encode.rstr2hex(this.rstr_hmac_sha1(Encode.str2rstr_utf8(k), Encode.str2rstr_utf8(d))) },
b64_hmac_sha1 : function (k, d) { return Encode.rstr2b64(this.rstr_hmac_sha1(Encode.str2rstr_utf8(k), Encode.str2rstr_utf8(d))) },
any_hmac_sha1 : function (k, d, e) { return Encode.rstr2any(this.rstr_hmac_sha1(Encode.str2rstr_utf8(k), Encode.str2rstr_utf8(d)), e) },
/*
* Perform a simple self-test to see if the VM is working
*/
sha1_vm_test : function () {
return this.hex_sha1('abc').toLowerCase() == 'a9993e364706816aba3e25717850c26c9cd0d89d'
},
/*
* Calculate the SHA1 of a raw string
*/
rstr_sha1 : function (s) {
return Encode.binb2rstr(this.binb_sha1(Encode.rstr2binb(s), s.length * 8))
},
/*
* Calculate the HMAC-SHA1 of a key and some data (raw strings)
*/
rstr_hmac_sha1 : function (key, data) {
var bkey = rstr2binb(key)
if(bkey.length > 16) { bkey = this.binb_sha1(bkey, key.length * 8) }
var ipad = Array(16), opad = Array(16)
for(var i = 0; i < 16; i++) {
ipad[i] = bkey[i] ^ 0x36363636
opad[i] = bkey[i] ^ 0x5C5C5C5C
}
var hash = this.binb_sha1(ipad.concat(Encode.rstr2binb(data)), 512 + data.length * 8)
return Encode.binb2rstr(this.binb_sha1(opad.concat(hash), 512 + 160))
},
/*
* Calculate the SHA-1 of an array of big-endian words, and a bit length
*/
binb_sha1 : function (x, len) {
/* append padding */
x[len >> 5] |= 0x80 << (24 - len % 32)
x[((len + 64 >> 9) << 4) + 15] = len
var w = Array(80)
var a = 1732584193
var b = -271733879
var c = -1732584194
var d = 271733878
var e = -1009589776
for(var i = 0; i < x.length; i += 16) {
var olda = a
var oldb = b
var oldc = c
var oldd = d
var olde = e
for(var j = 0; j < 80; j++) {
if(j < 16) { w[j] = x[i + j] }
else { w[j] = this.bit_rol(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1) }
var t = this.safe_add(this.safe_add(this.bit_rol(a, 5), this.sha1_ft(j, b, c, d)),
this.safe_add(this.safe_add(e, w[j]), this.sha1_kt(j)))
e = d
d = c
c = this.bit_rol(b, 30)
b = a
a = t
}
a = this.safe_add(a, olda)
b = this.safe_add(b, oldb)
c = this.safe_add(c, oldc)
d = this.safe_add(d, oldd)
e = this.safe_add(e, olde)
}
return Array(a, b, c, d, e)
},
/*
* Perform the appropriate triplet combination function for the current
* iteration
*/
sha1_ft : function (t, b, c, d) {
if(t < 20) { return (b & c) | ((~b) & d) }
if(t < 40) { return b ^ c ^ d }
if(t < 60) { return (b & c) | (b & d) | (c & d) }
return b ^ c ^ d
},
/*
* Determine the appropriate additive constant for the current iteration
*/
sha1_kt : function (t) {
return (t < 20) ? 1518500249 : (t < 40) ? 1859775393 :
(t < 60) ? -1894007588 : -899497514
},
/*
* Add integers, wrapping at 2^32. This uses 16-bit operations internally
* to work around bugs in some JS interpreters.
*/
safe_add : function (x, y) {
var lsw = (x & 0xFFFF) + (y & 0xFFFF)
var msw = (x >> 16) + (y >> 16) + (lsw >> 16)
return (msw << 16) | (lsw & 0xFFFF)
},
/*
* Bitwise rotate a 32-bit number to the left.
*/
bit_rol : function (num, cnt) {
return (num << cnt) | (num >>> (32 - cnt))
}
}
}
})
/*///////////////////// ORIGINAL LICENSE BELOW ////////////////////////////////
* A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
* in FIPS 180-1
* Version 2.2 Copyright Paul Johnston 2000 - 2009.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
* Distributed under the BSD License
* All rights reserved.
*
* See http://pajhome.org.uk/crypt/md5 for details.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the <ORGANIZATION> nor the names of its contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
/*///////////////////////////////////////////////////////////////////////////
;
/*//////////////////////////////////////////////////////////////////////////
* THIS PROGRAM IS A DERIVATIVE OF AN EXISTING WORK :: 4 September 2010
* See: http://pajhome.org.uk/crypt/md5/scripts.html
*
* Significant but mostly superficial changes have been made to the structure of the
* source so that it conforms to the Joose3 object system for JavaScript
* See: http://joose.it/
/*//////////////////////////////////////////////////////////////////////////
Joose.Class('Hash.SHA256', {
/*VERSION*/VERSION : 0.06,
my : {
has : {
sha256_K : {
is : 'ro',
init : [
1116352408, 1899447441, -1245643825, -373957723, 961987163, 1508970993,
-1841331548, -1424204075, -670586216, 310598401, 607225278, 1426881987,
1925078388, -2132889090, -1680079193, -1046744716, -459576895, -272742522,
264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986,
-1740746414, -1473132947, -1341970488, -1084653625, -958395405, -710438585,
113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291,
1695183700, 1986661051, -2117940946, -1838011259, -1564481375, -1474664885,
-1035236496, -949202525, -778901479, -694614492, -200395387, 275423344,
430227734, 506948616, 659060556, 883997877, 958139571, 1322822218,
1537002063, 1747873779, 1955562222, 2024104815, -2067236844, -1933114872,
-1866530822, -1538233109, -1090935817, -965641998
]
}
},
methods : {
/*
* These are the functions you'll usually want to call
* They take string arguments and return either hex or base-64 encoded strings
*/
hex_sha256 : function (s) {
return Encode.rstr2hex(this.rstr_sha256(Encode.str2rstr_utf8(s)))
},
b64_sha256 : function (s) {
return Encode.rstr2b64(this.rstr_sha256(Encode.str2rstr_utf8(s)))
},
any_sha256 : function (s, e) {
return Encode.rstr2any(this.rstr_sha256(Encode.str2rstr_utf8(s)), e)
},
hex_hmac_sha256 : function (k, d) {
return Encode.rstr2hex(this.rstr_hmac_sha256(Encode.str2rstr_utf8(k), Encode.str2rstr_utf8(d)))
},
b64_hmac_sha256 : function (k, d) {
return Encode.rstr2b64(this.rstr_hmac_sha256(Encode.str2rstr_utf8(k), Encode.str2rstr_utf8(d)))
},
any_hmac_sha256 : function (k, d, e) {
return Encode.rstr2any(this.rstr_hmac_sha256(Encode.str2rstr_utf8(k), Encode.str2rstr_utf8(d)), e)
},
/*
* Perform a simple self-test to see if the VM is working
*/
sha256_vm_test : function () {
return this.hex_sha256('abc').toLowerCase() == 'ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad'
},
/*
* Calculate the sha256 of a raw string
*/
rstr_sha256 : function (s) {
return Encode.binb2rstr(this.binb_sha256(Encode.rstr2binb(s), s.length * 8))
},
/*
* Calculate the HMAC-sha256 of a key and some data (raw strings)
*/
rstr_hmac_sha256 : function (key, data) {
var bkey = Encode.rstr2binb(key)
if(bkey.length > 16) bkey = this.binb_sha256(bkey, key.length * 8)
var ipad = Array(16), opad = Array(16)
for(var i = 0; i < 16; i++) {
ipad[i] = bkey[i] ^ 0x36363636
opad[i] = bkey[i] ^ 0x5C5C5C5C
}
var hash = this.binb_sha256(ipad.concat(Encode.rstr2binb(data)), 512 + data.length * 8)
return Encode.binb2rstr(this.binb_sha256(opad.concat(hash), 512 + 256))
},
/*
* Main sha256 function, with its support functions
*/
sha256_S : function (X, n) {return ( X >>> n ) | (X << (32 - n))},
sha256_R : function (X, n) {return ( X >>> n )},
sha256_Ch : function (x, y, z) {return ((x & y) ^ ((~x) & z))},
sha256_Maj : function (x, y, z) {return ((x & y) ^ (x & z) ^ (y & z))},
sha256_Sigma0256 : function (x) {return (this.sha256_S(x, 2) ^ this.sha256_S(x, 13) ^ this.sha256_S(x, 22))},
sha256_Sigma1256 : function (x) {return (this.sha256_S(x, 6) ^ this.sha256_S(x, 11) ^ this.sha256_S(x, 25))},
sha256_Gamma0256 : function (x) {return (this.sha256_S(x, 7) ^ this.sha256_S(x, 18) ^ this.sha256_R(x, 3))},
sha256_Gamma1256 : function (x) {return (this.sha256_S(x, 17) ^ this.sha256_S(x, 19) ^ this.sha256_R(x, 10))},
sha256_Sigma0512 : function (x) {return (this.sha256_S(x, 28) ^ this.sha256_S(x, 34) ^ this.sha256_S(x, 39))},
sha256_Sigma1512 : function (x) {return (this.sha256_S(x, 14) ^ this.sha256_S(x, 18) ^ this.sha256_S(x, 41))},
sha256_Gamma0512 : function (x) {return (this.sha256_S(x, 1) ^ this.sha256_S(x, 8) ^ this.sha256_R(x, 7))},
sha256_Gamma1512 : function (x) {return (this.sha256_S(x, 19) ^ this.sha256_S(x, 61) ^ this.sha256_R(x, 6))},
binb_sha256 : function (m, l) {
var HASH = [ 1779033703, -1150833019, 1013904242, -1521486534, 1359893119, -1694144372, 528734635, 1541459225 ]
var W = new Array(64)
var a, b, c, d, e, f, g, h
var i, j, T1, T2
/* append padding */
m[l >> 5] |= 0x80 << (24 - l % 32)
m[((l + 64 >> 9) << 4) + 15] = l
for (i = 0; i < m.length; i += 16) {
a = HASH[0]
b = HASH[1]
c = HASH[2]
d = HASH[3]
e = HASH[4]
f = HASH[5]
g = HASH[6]
h = HASH[7]
for (j = 0; j < 64; j++) {
if (j < 16) W[j] = m[j + i]
else W[j] = this.safe_add(this.safe_add(this.safe_add(this.sha256_Gamma1256(W[j - 2]), W[j - 7]),
this.sha256_Gamma0256(W[j - 15])), W[j - 16])
T1 = this.safe_add(this.safe_add(this.safe_add(this.safe_add(h, this.sha256_Sigma1256(e)), this.sha256_Ch(e, f, g)),
this.sha256_K[j]), W[j])
T2 = this.safe_add(this.sha256_Sigma0256(a), this.sha256_Maj(a, b, c))
h = g
g = f
f = e
e = this.safe_add(d, T1)
d = c
c = b
b = a
a = this.safe_add(T1, T2)
}
HASH[0] = this.safe_add(a, HASH[0])
HASH[1] = this.safe_add(b, HASH[1])
HASH[2] = this.safe_add(c, HASH[2])
HASH[3] = this.safe_add(d, HASH[3])
HASH[4] = this.safe_add(e, HASH[4])
HASH[5] = this.safe_add(f, HASH[5])
HASH[6] = this.safe_add(g, HASH[6])
HASH[7] = this.safe_add(h, HASH[7])
}
return HASH
},
safe_add : function (x, y) {
var lsw = (x & 0xFFFF) + (y & 0xFFFF)
var msw = (x >> 16) + (y >> 16) + (lsw >> 16)
return (msw << 16) | (lsw & 0xFFFF)
}
}
}
})
/*///////////////////// ORIGINAL LICENSE BELOW /////////////////////////////////
* A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
* in FIPS 180-2
* Version 2.2 Copyright Angel Marin, Paul Johnston 2000 - 2009.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
* Distributed under the BSD License
* All rights reserved.
*
* See http://pajhome.org.uk/crypt/md5 for details.
* Also http://anmar.eu.org/projects/jssha2/
*
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the <ORGANIZATION> nor the names of its contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
/*//////////////////////////////////////////////////////////////////////////////
;
/*//////////////////////////////////////////////////////////////////////////
* THIS PROGRAM IS A DERIVATIVE OF AN EXISTING WORK :: 7 September 2010
* See: http://pajhome.org.uk/crypt/md5/scripts.html
*
* Significant but mostly superficial changes have been made to the structure of the
* source so that it conforms to the Joose3 object system for JavaScript
* See: http://joose.it/
/*//////////////////////////////////////////////////////////////////////////
Joose.Class('Hash.SHA512', {
/*VERSION*/VERSION : 0.06,
use : [ 'Int64' ],
my : {
has : {
sha512_k : {
is : 'rw',
init : null
}
},
methods : {
/*
* These are the functions you'll usually want to call
* They take string arguments and return either hex or base-64 encoded strings
*/
hex_sha512 : function (s) { return Encode.rstr2hex(this.rstr_sha512(Encode.str2rstr_utf8(s))) },
b64_sha512 : function (s) { return Encode.rstr2b64(this.rstr_sha512(Encode.str2rstr_utf8(s))) },
any_sha512 : function (s, e) { return Encode.rstr2any(this.rstr_sha512(Encode.str2rstr_utf8(s)), e)},
hex_hmac_sha512 : function (k, d) { return Encode.rstr2hex(this.rstr_hmac_sha512(Encode.str2rstr_utf8(k), Encode.str2rstr_utf8(d))) },
b64_hmac_sha512 : function (k, d) { return Encode.rstr2b64(this.rstr_hmac_sha512(Encode.str2rstr_utf8(k), Encode.str2rstr_utf8(d))) },
any_hmac_sha512 : function (k, d, e) { return Encode.rstr2any(this.rstr_hmac_sha512(Encode.str2rstr_utf8(k), Encode.str2rstr_utf8(d)), e)},
/*
* Perform a simple self-test to see if the VM is working
*/
sha512_vm_test : function () {
return this.hex_sha512('abc').toLowerCase() == 'ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f'
},
/*
* Calculate the SHA-512 of a raw string
*/
rstr_sha512 : function (s) {
return Encode.binb2rstr(this.binb_sha512(Encode.rstr2binb(s), s.length * 8))
},
/*
* Calculate the HMAC-SHA-512 of a key and some data (raw strings)
*/
rstr_hmac_sha512 : function (key, data) {
var bkey = Encode.rstr2binb(key)
if(bkey.length > 32) bkey = this.binb_sha512(bkey, key.length * 8)
var ipad = Array(32), opad = Array(32)
for(var i = 0; i < 32; i++) {
ipad[i] = bkey[i] ^ 0x36363636
opad[i] = bkey[i] ^ 0x5C5C5C5C
}
var hash = this.binb_sha512(ipad.concat(Encode.rstr2binb(data)), 1024 + data.length * 8)
return Encode.binb2rstr(this.binb_sha512(opad.concat(hash), 1024 + 512))
},
/*
* Calculate the SHA-512 of an array of big-endian dwords, and a bit length
*/
binb_sha512 : function (x, len) {
//Initial hash values
var H = new Array(
new Int64({ h : 0x6a09e667, l : -205731576}),
new Int64({ h : -1150833019, l : -2067093701}),
new Int64({ h : 0x3c6ef372, l : -23791573}),
new Int64({ h : -1521486534, l : 0x5f1d36f1}),
new Int64({ h : 0x510e527f, l : -1377402159}),
new Int64({ h : -1694144372, l : 0x2b3e6c1f}),
new Int64({ h : 0x1f83d9ab, l : -79577749}),
new Int64({ h : 0x5be0cd19, l : 0x137e2179})
)
var T1 = new Int64({ h : 0, l : 0}),
T2 = new Int64({ h : 0, l : 0}),
a = new Int64({ h : 0, l : 0}),
b = new Int64({ h : 0, l : 0}),
c = new Int64({ h : 0, l : 0}),
d = new Int64({ h : 0, l : 0}),
e = new Int64({ h : 0, l : 0}),
f = new Int64({ h : 0, l : 0}),
g = new Int64({ h : 0, l : 0}),
h = new Int64({ h : 0, l : 0}),
//Temporary variables not specified by the document
s0 = new Int64({ h : 0, l : 0}),
s1 = new Int64({ h : 0, l : 0}),
Ch = new Int64({ h : 0, l : 0}),
Maj = new Int64({ h : 0, l : 0}),
r1 = new Int64({ h : 0, l : 0}),
r2 = new Int64({ h : 0, l : 0}),
r3 = new Int64({ h : 0, l : 0})
var j, i
var W = new Array(80)
for(i=0; i<80; i++) {
W[i] = new Int64({ h : 0, l : 0})
}
// append padding to the source string. The format is described in the FIPS.
x[len >> 5] |= 0x80 << (24 - (len & 0x1f))
x[((len + 128 >> 10)<< 5) + 31] = len
for(i = 0; i<x.length; i+=32) { //32 dwords is the block size
Int64.copy(a, H[0])
Int64.copy(b, H[1])
Int64.copy(c, H[2])
Int64.copy(d, H[3])
Int64.copy(e, H[4])
Int64.copy(f, H[5])
Int64.copy(g, H[6])
Int64.copy(h, H[7])
for(j=0; j<16; j++) {
W[j].h = x[i + 2*j]
W[j].l = x[i + 2*j + 1]
}
for(j=16; j<80; j++) {
//sigma1
Int64.rrot(r1, W[j-2], 19)
Int64.revrrot(r2, W[j-2], 29)
Int64.shr(r3, W[j-2], 6)
s1.l = r1.l ^ r2.l ^ r3.l
s1.h = r1.h ^ r2.h ^ r3.h
//sigma0
Int64.rrot(r1, W[j-15], 1)
Int64.rrot(r2, W[j-15], 8)
Int64.shr(r3, W[j-15], 7)
s0.l = r1.l ^ r2.l ^ r3.l
s0.h = r1.h ^ r2.h ^ r3.h
Int64.add4(W[j], s1, W[j-7], s0, W[j-16])
}
for(j = 0; j < 80; j++) {
//Ch
Ch.l = (e.l & f.l) ^ (~e.l & g.l)
Ch.h = (e.h & f.h) ^ (~e.h & g.h)
//Sigma1
Int64.rrot(r1, e, 14)
Int64.rrot(r2, e, 18)
Int64.revrrot(r3, e, 9)
s1.l = r1.l ^ r2.l ^ r3.l
s1.h = r1.h ^ r2.h ^ r3.h
//Sigma0
Int64.rrot(r1, a, 28)
Int64.revrrot(r2, a, 2)
Int64.revrrot(r3, a, 7)
s0.l = r1.l ^ r2.l ^ r3.l
s0.h = r1.h ^ r2.h ^ r3.h
//Maj
Maj.l = (a.l & b.l) ^ (a.l & c.l) ^ (b.l & c.l)
Maj.h = (a.h & b.h) ^ (a.h & c.h) ^ (b.h & c.h)
Int64.add5(T1, h, s1, Ch, this.getSha512_k()[j], W[j])
Int64.add(T2, s0, Maj)
Int64.copy(h, g)
Int64.copy(g, f)
Int64.copy(f, e)
Int64.add(e, d, T1)
Int64.copy(d, c)
Int64.copy(c, b)
Int64.copy(b, a)
Int64.add(a, T1, T2)
}
Int64.add(H[0], H[0], a)
Int64.add(H[1], H[1], b)
Int64.add(H[2], H[2], c)
Int64.add(H[3], H[3], d)
Int64.add(H[4], H[4], e)
Int64.add(H[5], H[5], f)
Int64.add(H[6], H[6], g)
Int64.add(H[7], H[7], h)
}
//represent the hash as an array of 32-bit dwords
var hash = new Array(16)
for(i=0; i<8; i++) {
hash[2*i] = H[i].h
hash[2*i + 1] = H[i].l
}
return hash
},
initialize : function () {
this.setSha512_k(
new Array(
new Int64({ h : 0x428a2f98, l : -685199838}), new Int64({ h : 0x71374491, l : 0x23ef65cd}),
new Int64({ h : -1245643825, l : -330482897}), new Int64({ h : -373957723, l : -2121671748}),
new Int64({ h : 0x3956c25b, l : -213338824}), new Int64({ h : 0x59f111f1, l : -1241133031}),
new Int64({ h : -1841331548, l : -1357295717}), new Int64({ h : -1424204075, l : -630357736}),
new Int64({ h : -670586216, l : -1560083902}), new Int64({ h : 0x12835b01, l : 0x45706fbe}),
new Int64({ h : 0x243185be, l : 0x4ee4b28c}), new Int64({ h : 0x550c7dc3, l : -704662302}),
new Int64({ h : 0x72be5d74, l : -226784913}), new Int64({ h : -2132889090, l : 0x3b1696b1}),
new Int64({ h : -1680079193, l : 0x25c71235}), new Int64({ h : -1046744716, l : -815192428}),
new Int64({ h : -459576895, l : -1628353838}), new Int64({ h : -272742522, l : 0x384f25e3}),
new Int64({ h : 0xfc19dc6, l : -1953704523}), new Int64({ h : 0x240ca1cc, l : 0x77ac9c65}),
new Int64({ h : 0x2de92c6f, l : 0x592b0275}), new Int64({ h : 0x4a7484aa, l : 0x6ea6e483}),
new Int64({ h : 0x5cb0a9dc, l : -1119749164}), new Int64({ h : 0x76f988da, l : -2096016459}),
new Int64({ h : -1740746414, l : -295247957}), new Int64({ h : -1473132947, l : 0x2db43210}),
new Int64({ h : -1341970488, l : -1728372417}), new Int64({ h : -1084653625, l : -1091629340}),
new Int64({ h : -958395405, l : 0x3da88fc2}), new Int64({ h : -710438585, l : -1828018395}),
new Int64({ h : 0x6ca6351, l : -536640913}), new Int64({ h : 0x14292967, l : 0xa0e6e70}),
new Int64({ h : 0x27b70a85, l : 0x46d22ffc}), new Int64({ h : 0x2e1b2138, l : 0x5c26c926}),
new Int64({ h : 0x4d2c6dfc, l : 0x5ac42aed}), new Int64({ h : 0x53380d13, l : -1651133473}),
new Int64({ h : 0x650a7354, l : -1951439906}), new Int64({ h : 0x766a0abb, l : 0x3c77b2a8}),
new Int64({ h : -2117940946, l : 0x47edaee6}), new Int64({ h : -1838011259, l : 0x1482353b}),
new Int64({ h : -1564481375, l : 0x4cf10364}), new Int64({ h : -1474664885, l : -1136513023}),
new Int64({ h : -1035236496, l : -789014639}), new Int64({ h : -949202525, l : 0x654be30}),
new Int64({ h : -778901479, l : -688958952}), new Int64({ h : -694614492, l : 0x5565a910}),
new Int64({ h : -200395387, l : 0x5771202a}), new Int64({ h : 0x106aa070, l : 0x32bbd1b8}),
new Int64({ h : 0x19a4c116, l : -1194143544}), new Int64({ h : 0x1e376c08, l : 0x5141ab53}),
new Int64({ h : 0x2748774c, l : -544281703}), new Int64({ h : 0x34b0bcb5, l : -509917016}),
new Int64({ h : 0x391c0cb3, l : -976659869}), new Int64({ h : 0x4ed8aa4a, l : -482243893}),
new Int64({ h : 0x5b9cca4f, l : 0x7763e373}), new Int64({ h : 0x682e6ff3, l : -692930397}),
new Int64({ h : 0x748f82ee, l : 0x5defb2fc}), new Int64({ h : 0x78a5636f, l : 0x43172f60}),
new Int64({ h : -2067236844, l : -1578062990}), new Int64({ h : -1933114872, l : 0x1a6439ec}),
new Int64({ h : -1866530822, l : 0x23631e28}), new Int64({ h : -1538233109, l : -561857047}),
new Int64({ h : -1090935817, l : -1295615723}), new Int64({ h : -965641998, l : -479046869}),
new Int64({ h : -903397682, l : -366583396}), new Int64({ h : -779700025, l : 0x21c0c207}),
new Int64({ h : -354779690, l : -840897762}), new Int64({ h : -176337025, l : -294727304}),
new Int64({ h : 0x6f067aa, l : 0x72176fba}), new Int64({ h : 0xa637dc5, l : -1563912026}),
new Int64({ h : 0x113f9804, l : -1090974290}), new Int64({ h : 0x1b710b35, l : 0x131c471b}),
new Int64({ h : 0x28db77f5, l : 0x23047d84}), new Int64({ h : 0x32caab7b, l : 0x40c72493}),
new Int64({ h : 0x3c9ebe0a, l : 0x15c9bebc}), new Int64({ h : 0x431d67c4, l : -1676669620}),
new Int64({ h : 0x4cc5d4be, l : -885112138}), new Int64({ h : 0x597f299c, l : -60457430}),
new Int64({ h : 0x5fcb6fab, l : 0x3ad6faec}), new Int64({ h : 0x6c44198c, l : 0x4a475817}))
)
}
}
}
})
Joose.Class('Int64', {
my : {
methods : {
//Copies src into dst, assuming both are 64-bit numbers
copy : function (dst, src) {
dst.h = src.h
dst.l = src.l
},
//Right-rotates a 64-bit number by shift
//Won't handle cases of shift>=32
//The function revrrot() is for that
rrot : function (dst, x, shift) {
dst.l = (x.l >>> shift) | (x.h << (32-shift))
dst.h = (x.h >>> shift) | (x.l << (32-shift))
},
//Reverses the dwords of the source and then rotates right by shift.
//This is equivalent to rotation by 32+shift
revrrot : function (dst, x, shift) {
dst.l = (x.h >>> shift) | (x.l << (32-shift))
dst.h = (x.l >>> shift) | (x.h << (32-shift))
},
//Bitwise-shifts right a 64-bit number by shift
//Won't handle shift>=32, but it's never needed in SHA512
shr : function (dst, x, shift) {
dst.l = (x.l >>> shift) | (x.h << (32-shift))
dst.h = (x.h >>> shift)
},
//Adds two 64-bit numbers
//Like the original implementation, does not rely on 32-bit operations
add : function (dst, x, y) {
var w0 = (x.l & 0xffff) + (y.l & 0xffff)
var w1 = (x.l >>> 16) + (y.l >>> 16) + (w0 >>> 16)
var w2 = (x.h & 0xffff) + (y.h & 0xffff) + (w1 >>> 16)
var w3 = (x.h >>> 16) + (y.h >>> 16) + (w2 >>> 16)
dst.l = (w0 & 0xffff) | (w1 << 16)
dst.h = (w2 & 0xffff) | (w3 << 16)
},
//Same, except with 4 addends. Works faster than adding them one by one.
add4 : function (dst, a, b, c, d) {
var w0 = (a.l & 0xffff) + (b.l & 0xffff) + (c.l & 0xffff) + (d.l & 0xffff)
var w1 = (a.l >>> 16) + (b.l >>> 16) + (c.l >>> 16) + (d.l >>> 16) + (w0 >>> 16)
var w2 = (a.h & 0xffff) + (b.h & 0xffff) + (c.h & 0xffff) + (d.h & 0xffff) + (w1 >>> 16)
var w3 = (a.h >>> 16) + (b.h >>> 16) + (c.h >>> 16) + (d.h >>> 16) + (w2 >>> 16)
dst.l = (w0 & 0xffff) | (w1 << 16)
dst.h = (w2 & 0xffff) | (w3 << 16)
},
//Same, except with 5 addends
add5 : function (dst, a, b, c, d, e) {
var w0 = (a.l & 0xffff) + (b.l & 0xffff) + (c.l & 0xffff) + (d.l & 0xffff) + (e.l & 0xffff)
var w1 = (a.l >>> 16) + (b.l >>> 16) + (c.l >>> 16) + (d.l >>> 16) + (e.l >>> 16) + (w0 >>> 16)
var w2 = (a.h & 0xffff) + (b.h & 0xffff) + (c.h & 0xffff) + (d.h & 0xffff) + (e.h & 0xffff) + (w1 >>> 16)
var w3 = (a.h >>> 16) + (b.h >>> 16) + (c.h >>> 16) + (d.h >>> 16) + (e.h >>> 16) + (w2 >>> 16)
dst.l = (w0 & 0xffff) | (w1 << 16)
dst.h = (w2 & 0xffff) | (w3 << 16)
}
}
},
has : {
h : {
is : 'rw',
init : null
},
l : {
is : 'rw',
init : null
}
}
})
/*///////////////////// ORIGINAL LICENSE BELOW ////////////////////////////////
* A JavaScript implementation of the Secure Hash Algorithm, SHA-512, as defined
* in FIPS 180-2
* Version 2.2 Copyright Anonymous Contributor, Paul Johnston 2000 - 2009.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
* Distributed under the BSD License
* All rights reserved.
*
* See http://pajhome.org.uk/crypt/md5 for details.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the <ORGANIZATION> nor the names of its contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
/*///////////////////////////////////////////////////////////////////////////
;
/*//////////////////////////////////////////////////////////////////////////
* THIS PROGRAM IS A DERIVATIVE OF AN EXISTING WORK :: 7 September 2010
* See: http://pajhome.org.uk/crypt/md5/scripts.html
*
* Significant but mostly superficial changes have been made to the structure of the
* source so that it conforms to the Joose3 object system for JavaScript
* See: http://joose.it/
/*//////////////////////////////////////////////////////////////////////////
Joose.Class('Hash.RIPEMD160', {
/*VERSION*/VERSION : 0.06,
my : {
has : {
rmd160_r1 : {
is : 'ro',
init : [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
]
},
rmd160_r2 : {
is : 'ro',
init : [
5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
]
},
rmd160_s1 : {
is : 'ro',
init : [
11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,
7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
]
},
rmd160_s2 : {
is : 'ro',
init : [
8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
]
},
},
methods : {
/*
* These are the functions you'll usually want to call
* They take string arguments and return either hex or base-64 encoded strings
*/
hex_rmd160 : function (s) { return Encode.rstr2hex(this.rstr_rmd160(Encode.str2rstr_utf8(s))) },
b64_rmd160 : function (s) { return Encode.rstr2b64(this.rstr_rmd160(Encode.str2rstr_utf8(s))) },
any_rmd160 : function (s, e) { return Encode.rstr2any(this.rstr_rmd160(Encode.str2rstr_utf8(s)), e) },
hex_hmac_rmd160 : function (k, d) { return Encode.rstr2hex(this.rstr_hmac_rmd160(Encode.str2rstr_utf8(k), Encode.str2rstr_utf8(d))) },
b64_hmac_rmd160 : function (k, d) { return Encode.rstr2b64(this.rstr_hmac_rmd160(Encode.str2rstr_utf8(k), Encode.str2rstr_utf8(d))) },
any_hmac_rmd160 : function (k, d, e) { return Encode.rstr2any(this.rstr_hmac_rmd160(Encode.str2rstr_utf8(k), Encode.str2rstr_utf8(d)), e) },
/*
* Perform a simple self-test to see if the VM is working
*/
rmd160_vm_test : function () {
return this.hex_rmd160('abc').toLowerCase() == '8eb208f7e05d987a9b044a8e98c6b087f15a0bfc'
},
/*
* Calculate the rmd160 of a raw string
*/
rstr_rmd160 : function (s) {
return Encode.binl2rstr(this.binl_rmd160(Encode.rstr2binl(s), s.length * 8))
},
/*
* Calculate the HMAC-rmd160 of a key and some data (raw strings)
*/
rstr_hmac_rmd160 : function (key, data) {
var bkey = Encode.rstr2binl(key)
if(bkey.length > 16) bkey = this.binl_rmd160(bkey, key.length * 8)
var ipad = Array(16), opad = Array(16)
for(var i = 0; i < 16; i++) {
ipad[i] = bkey[i] ^ 0x36363636
opad[i] = bkey[i] ^ 0x5C5C5C5C
}
var hash = this.binl_rmd160(ipad.concat(rstr2binl(data)), 512 + data.length * 8)
return Encode.binl2rstr(this.binl_rmd160(opad.concat(hash), 512 + 160))
},
/*
* Calculate the RIPE-MD160 of an array of little-endian words, and a bit length.
*/
binl_rmd160 : function (x, len) {
/* append padding */
x[len >> 5] |= 0x80 << (len % 32)
x[(((len + 64) >>> 9) << 4) + 14] = len
var h0 = 0x67452301
var h1 = 0xefcdab89
var h2 = 0x98badcfe
var h3 = 0x10325476
var h4 = 0xc3d2e1f0
for (var i = 0; i < x.length; i += 16) {
var T
var A1 = h0, B1 = h1, C1 = h2, D1 = h3, E1 = h4
var A2 = h0, B2 = h1, C2 = h2, D2 = h3, E2 = h4
for (var j = 0; j <= 79; ++j) {
T = this.safe_add(A1, this.rmd160_f(j, B1, C1, D1))
T = this.safe_add(T, x[i + this.getRmd160_r1()[j]])
T = this.safe_add(T, this.rmd160_K1(j))
T = this.safe_add(this.bit_rol(T, this.getRmd160_s1()[j]), E1)
A1 = E1
E1 = D1
D1 = this.bit_rol(C1, 10)
C1 = B1
B1 = T
T = this.safe_add(A2, this.rmd160_f(79-j, B2, C2, D2))
T = this.safe_add(T, x[i + this.getRmd160_r2()[j]])
T = this.safe_add(T, this.rmd160_K2(j))
T = this.safe_add(this.bit_rol(T, this.getRmd160_s2()[j]), E2)
A2 = E2
E2 = D2
D2 = this.bit_rol(C2, 10)
C2 = B2
B2 = T
}
T = this.safe_add(h1, this.safe_add(C1, D2))
h1 = this.safe_add(h2, this.safe_add(D1, E2))
h2 = this.safe_add(h3, this.safe_add(E1, A2))
h3 = this.safe_add(h4, this.safe_add(A1, B2))
h4 = this.safe_add(h0, this.safe_add(B1, C2))
h0 = T
}
return [h0, h1, h2, h3, h4]
},
rmd160_f : function (j, x, y, z) {
return ( 0 <= j && j <= 15) ? (x ^ y ^ z) :
(16 <= j && j <= 31) ? (x & y) | (~x & z) :
(32 <= j && j <= 47) ? (x | ~y) ^ z :
(48 <= j && j <= 63) ? (x & z) | (y & ~z) :
(64 <= j && j <= 79) ? x ^ (y | ~z) :
'rmd160_f: j out of range'
},
rmd160_K1 : function (j) {
return ( 0 <= j && j <= 15) ? 0x00000000 :
(16 <= j && j <= 31) ? 0x5a827999 :
(32 <= j && j <= 47) ? 0x6ed9eba1 :
(48 <= j && j <= 63) ? 0x8f1bbcdc :
(64 <= j && j <= 79) ? 0xa953fd4e :
'rmd160_K1: j out of range'
},
rmd160_K2 : function (j) {
return ( 0 <= j && j <= 15) ? 0x50a28be6 :
(16 <= j && j <= 31) ? 0x5c4dd124 :
(32 <= j && j <= 47) ? 0x6d703ef3 :
(48 <= j && j <= 63) ? 0x7a6d76e9 :
(64 <= j && j <= 79) ? 0x00000000 :
'rmd160_K2: j out of range'
},
/*
* Add integers, wrapping at 2^32. This uses 16-bit operations internally
* to work around bugs in some JS interpreters.
*/
safe_add : function (x, y) {
var lsw = (x & 0xFFFF) + (y & 0xFFFF)
var msw = (x >> 16) + (y >> 16) + (lsw >> 16)
return (msw << 16) | (lsw & 0xFFFF)
},
/*
* Bitwise rotate a 32-bit number to the left.
*/
bit_rol : function (num, cnt) {
return (num << cnt) | (num >>> (32 - cnt))
}
}
}
})
/*///////////////////// ORIGINAL LICENSE BELOW ////////////////////////////////
* A JavaScript implementation of the RIPEMD-160 Algorithm
* Version 2.2 Copyright Jeremy Lin, Paul Johnston 2000 - 2009.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
* Distributed under the BSD License
* All rights reserved.
*
* See http://pajhome.org.uk/crypt/md5 for details.
* Also http://www.ocf.berkeley.edu/~jjlin/jsotp/
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the <ORGANIZATION> nor the names of its contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
/*///////////////////////////////////////////////////////////////////////////
;