'libs/jquery',
'libs/underscore',
'smartxml/smartxml',
- 'smartxml/transformations'
-], function($, _, smartxml, transformations) {
+ 'smartxml/transformations',
+ 'wlxml/extensions/metadata/metadata',
+ 'wlxml/extensions/comments/comments',
+ 'wlxml/extensions/edumed/edumed'
+], function($, _, smartxml, transformations, metadataExtension, commentExtension, edumedExtension) {
'use strict';
-// utils
+/* globals Node */
-var isMetaAttribute = function(attrName) {
- return attrName.substr(0, 5) === 'meta-';
+
+var WLXMLDocumentNodeMethods = {
+ isInside: function(query) {
+ var parent = this.getParent(query);
+ return !!parent;
+ },
+ getParent: function(query) {
+ /* globals Node */
+ var me = this.nodeType === Node.ELEMENT_NODE ? [this] : [],
+ toret;
+ me.concat(this.parents()).some(function(node) {
+ if(node.is(query)) {
+ toret = node;
+ }
+ return !!toret || (!node.sameNode(this) && node.isContextRoot());
+ }.bind(this));
+
+ return toret;
+ },
+ isContextRoot: function() {
+ var me = this.nodeType === Node.ELEMENT_NODE ? [this] : [],
+ toret = false;
+ if(!this.parent()) {
+ return true;
+ }
+ me.concat(this.parents()).some(function(node) {
+ if(_.isFunction(node.object.isContextRoot) && node.object.isContextRoot(this)) {
+ toret = true;
+ return true;
+ }
+ }.bind(this));
+ return toret;
+ },
+ getContextRoot: function() {
+ var contextRoot;
+ [this].concat(this.parents()).some(function(n) {
+ if(n.isContextRoot()) {
+ contextRoot = n;
+ return true;
+ }
+ });
+ return contextRoot;
+ },
+ hasSameContextRoot: function(other) {
+ return this.getContextRoot().sameNode(other.getContextRoot());
+ }
};
-//
+var getClassLists = function(klassName) {
+ var toret = [],
+ classParts = [''].concat(klassName.split('.')),
+ classCurrent;
-var AttributesList = function() {};
-AttributesList.prototype = Object.create({});
-AttributesList.prototype.keys = function() {
- return _.keys(this);
+ classParts.forEach(function(part) {
+ classCurrent = classCurrent ? classCurrent + '.' + part : part;
+ toret.push(classCurrent);
+ });
+ return toret;
};
var installObject = function(instance, klass) {
- var methods = instance.document.classMethods[klass];
- if(methods) {
- instance.object = Object.create(_.extend({
- transform: function(name, args) {
- // TODO: refactor with DocumentElement.transform
- var Transformation = instance.document.classTransformations[klass].get(name),
- transformation;
- if(Transformation) {
- transformation = new Transformation(instance.document, instance, args);
- }
- return instance.document.transform(transformation);
- }
- }, methods));
- _.keys(methods).forEach(function(key) {
+ var methods = {},
+ transformations = {};
+
+ getClassLists(klass).forEach(function(klassName) {
+ _.extend(methods, instance.document.classMethods[klassName] || {});
+ _.extend(methods, instance.document.classTransformations[klassName] || {});
+ });
+ instance.object = Object.create(_.extend({}, methods, transformations));
+ _.keys(methods).concat(_.keys(transformations)).forEach(function(key) {
+ if(_.isFunction(instance.object[key])) {
instance.object[key] = _.bind(instance.object[key], instance);
- });
- }
-}
+ }
+ });
+};
var WLXMLElementNode = function(nativeNode, document) {
smartxml.ElementNode.call(this, nativeNode, document);
};
WLXMLElementNode.prototype = Object.create(smartxml.ElementNode.prototype);
-$.extend(WLXMLElementNode.prototype, smartxml.ElementNode.prototype, {
+$.extend(WLXMLElementNode.prototype, WLXMLDocumentNodeMethods, smartxml.ElementNode.prototype, {
getClass: function() {
return this.getAttr('class') || '';
},
+ getClassHierarchy: function() {
+ return getClassLists(this.getClass());
+ },
setClass: function(klass) {
- var methods, object;
if(klass !== this.klass) {
installObject(this, klass);
return this.setAttr('class', klass);
}
},
- is: function(klass) {
- return this.getClass().substr(0, klass.length) === klass;
+ is: function(query) {
+ if(typeof query === 'string') {
+ query = {klass: query};
+ }
+ return (_.isUndefined(query.klass) || this.getClass().substr(0, query.klass.length) === query.klass) &&
+ (_.isUndefined(query.tagName) || this.getTagName() === query.tagName);
},
- getMetaAttributes: function() {
- var toret = new AttributesList(),
- classParts = [''].concat(this.getClass().split('.')),
- classCurrent, classDesc;
-
- classParts.forEach(function(part) {
- classCurrent = classCurrent ? classCurrent + '.' + part : part;
- classDesc = this.document.options.wlxmlClasses[classCurrent];
- if(classDesc) {
- _.keys(classDesc.attrs).forEach(function(attrName) {
- toret[attrName] = _.extend({value: this.getAttr('meta-' + attrName)}, classDesc.attrs[attrName]);
- }.bind(this));
- }
+ hasChild: function(query) {
+ return this.contents().some(function(child) {
+ return child.is(query);
}.bind(this));
- return toret;
},
- setMetaAttribute: function(key, value) {
- this.setAttr('meta-'+key, value);
- },
- getOtherAttributes: function() {
- var toret = {};
- this.getAttrs().forEach(function(attr) {
- if(attr.name !== 'class' && !isMetaAttribute(attr.name)) {
- toret[attr.name] = attr.value;
- }
- });
- return toret;
+ find: function(query) {
+ var doc = this.document;
+ return this._$.find('*')
+ .map(function() {
+ return doc.createDocumentNode(this);
+ })
+ .filter(function() {
+ return this.is(query);
+ });
},
_getXMLDOMToDump: function() {
- var DOM = this._$.clone(true, true);
+ var DOM = this._$.clone(true, true),
+ doc = this.document;
DOM.find('*').addBack().each(function() {
var el = $(this),
data = el.data();
- var txt;
+ var txt, documentNode, metaNode;
if(data[formatter_prefix+ 'orig_before']) {
txt = idx > 0 && contents[idx-1].nodeType === Node.TEXT_NODE ? contents[idx-1] : null;
el.append(data[formatter_prefix+ 'orig_end']);
}
}
+
+
+ if(this.nodeType === Node.ELEMENT_NODE) {
+ documentNode = doc.createDocumentNode(this);
+ metaNode = $('<metadata>');
+ documentNode.getMetadata().forEach(function(row) {
+ metaNode.append('<dc:'+ row.key + '>' + row.value + '</dc:' + row.key + '>');
+ });
+ if(metaNode.children().length) {
+ $(this).prepend(metaNode);
+ }
+ }
});
return DOM;
}
});
-WLXMLElementNode.prototype.transformations.register(transformations.createContextTransformation({
- name: 'wlxml.setMetaAttribute',
- impl: function(args) {
- this.setMetaAttribute(args.name, args.value);
- },
- getChangeRoot: function() {
- return this.context;
- }
-}));
-
-
var WLXMLDocumentNode = function() {
smartxml.DocumentNode.apply(this, arguments);
-}
+};
WLXMLDocumentNode.prototype = Object.create(smartxml.DocumentNode.prototype);
-var WLXMLDocument = function(xml, options) {
- smartxml.Document.call(this, xml);
- this.options = options;
-
- // this.DocumentNodeFactory = function() {
- // WLXMLDocumentNode.apply(this, arguments);
- // };
-
- // this.DocumentNodeFactory.prototype = Object.create(WLXMLDocumentNode.prototype);
-
- this.ElementNodeFactory = function() {
- WLXMLElementNode.apply(this, arguments);
- }
- this.ElementNodeFactory.prototype = Object.create(WLXMLElementNode.prototype);
- this.ElementNodeFactory.prototype.transformations = new transformations.TransformationStorage();
-
- this.TextNodeFactory = function() {
- smartxml.TextNode.apply(this, arguments);
- }
- this.TextNodeFactory.prototype = Object.create(smartxml.TextNode.prototype);
- this.TextNodeFactory.prototype.transformations = new transformations.TransformationStorage();
+var WLXMLTextNode = function() {
+ smartxml.TextNode.apply(this, arguments);
+};
+WLXMLTextNode.prototype = Object.create(smartxml.TextNode.prototype);
+$.extend(WLXMLTextNode.prototype, WLXMLDocumentNodeMethods, {
+ is: function() { return false; }
+});
+var WLXMLDocument = function(xml, options) {
this.classMethods = {};
this.classTransformations = {};
+ smartxml.Document.call(this, xml, [metadataExtension, commentExtension, edumedExtension]);
+ this.options = options;
};
var formatter_prefix = '_wlxml_formatter_';
WLXMLDocument.prototype = Object.create(smartxml.Document.prototype);
$.extend(WLXMLDocument.prototype, {
ElementNodeFactory: WLXMLElementNode,
+ TextNodeFactory: WLXMLTextNode,
loadXML: function(xml) {
smartxml.Document.prototype.loadXML.call(this, xml, {silent: true});
- $(this.dom).find(':not(iframe)').addBack().contents()
+ this.trigger('contentSet');
+ },
+
+ normalizeXML: function(nativeNode) {
+ var doc = this,
+ prefixLength = 'dc:'.length;
+
+ $(nativeNode).find('metadata').each(function() {
+ var metadataNode = $(this),
+ owner = doc.createDocumentNode(metadataNode.parent()[0]),
+ metadata = owner.getMetadata();
+
+ metadataNode.children().each(function() {
+ metadata.add({key: (this.tagName).toLowerCase().substr(prefixLength), value: $(this).text()}, {undoable: false});
+ });
+ metadataNode.remove();
+ });
+ nativeNode.normalize();
+ $(nativeNode).find('*').each(function() {
+ if (this.childNodes.length === 0) {
+ var fakeTextNode = window.document.createTextNode("");
+ this.appendChild(fakeTextNode);
+ }
+ });
+
+ $(nativeNode).find(':not(iframe)').addBack().contents()
.filter(function() {return this.nodeType === Node.TEXT_NODE;})
.each(function() {
var el = $(this),
elParent = el.parent(),
hasSpanParent = elParent.prop('tagName') === 'SPAN',
hasSpanBefore = el.prev().length && $(el.prev()).prop('tagName') === 'SPAN',
- hasSpanAfter = el.next().length && $(el.next()).prop('tagName') === 'SPAN';
+ hasSpanAfter = el.next().length && $(el.next()).prop('tagName') === 'SPAN',
+ onlyChild = el.is(':only-child');
var addInfo = function(toAdd, where, transformed, original) {
}
}
- if(!text.transformed) {
+ if(!text.transformed && !onlyChild) {
addInfo(text.original, 'below');
el.remove();
return true; // continue
}
//}
}
-
+ /* globals document */
el.replaceWith(document.createTextNode(text.transformed));
});
- this.trigger('contentSet');
- },
-
- registerExtension: function(extension) {
- //debugger;
- var doc = this,
- existingPropertyName = _.values(this);
-
- [
- {source: extension.document, target: doc},
- {source: extension.documentNode, target: [doc.ElementNodeFactory.prototype, doc.TextNodeFactory.prototype]},
-
- ].forEach(function(x) {
- if(x.source && x.source.methods) {
- existingPropertyName = _.values(x.target)
- _.pairs(x.source.methods).forEach(function(pair) {
- var methodName = pair[0],
- method = pair[1],
- targets = _.isArray(x.target) ? x.target : [x.target];
- if(_.contains(existingPropertyName, methodName)) {
- throw new Error('Cannot extend XXX with method name {methodName}. Name already exists.'.replace('{methodName}', methodName));
- }
- targets.forEach(function(target) {
- target[methodName] = method;
- });
-
- });
- }
- });
+
+ },
- var getTrans = function(desc, methodName) {
- if(typeof desc === 'function') {
- desc = {impl: desc};
- }
- if(!desc.impl) {
- throw new Error('Got transformation description without implementation.')
- }
- desc.name = desc.name || methodName;
- return desc;
+ registerClassTransformation: function(Transformation, className) {
+ var thisClassTransformations = (this.classTransformations[className] = this.classTransformations[className] || {});
+ thisClassTransformations[Transformation.prototype.name] = function() {
+ var nodeInstance = this;
+ var args = Array.prototype.slice.call(arguments, 0);
+ return nodeInstance.transform(Transformation, args);
};
+ },
- if(extension.document && extension.document.transformations) {
- _.pairs(extension.document.transformations).forEach(function(pair) {
- var transformation = getTrans(pair[1], pair[0]);
- doc.transformations.register(transformations.createContextTransformation(transformation));
- });
- }
+ registerClassMethod: function(methodName, method, className) {
+ var thisClassMethods = (this.classMethods[className] = this.classMethods[className] || {});
+ thisClassMethods[methodName] = method;
+ },
- if(extension.documentNode && extension.documentNode.transformations) {
- _.pairs(extension.documentNode.transformations).forEach(function(pair) {
- var transformation = getTrans(pair[1], pair[0]);
-
- doc.ElementNodeFactory.prototype.transformations.register(transformations.createContextTransformation(transformation));
- doc.TextNodeFactory.prototype.transformations.register(transformations.createContextTransformation(transformation));
- });
- }
+ registerExtension: function(extension) {
+ smartxml.Document.prototype.registerExtension.call(this, extension);
+ var doc = this;
_.pairs(extension.wlxmlClass).forEach(function(pair) {
var className = pair[0],
- classExtension = pair[1],
- thisClassMethods = (doc.classMethods[className] = doc.classMethods[className] || {}),
- thisClassTransformations = (doc.classTransformations[className] = doc.classTransformations[className] || new transformations.TransformationStorage());
-
- _.extend(thisClassMethods, classExtension.methods || {}); //@ warning/throw on override?
-
+ classExtension = pair[1];
+
+ _.pairs(classExtension.methods || {}).forEach(function(pair) {
+ var name = pair[0],
+ method = pair[1];
+ doc.registerClassMethod(name, method, className);
+ });
_.pairs(classExtension.transformations || {}).forEach(function(pair) {
- var transformation = getTrans(pair[1], pair[0]);
- thisClassTransformations.register(transformations.createContextTransformation(transformation));
- });
+ var name = pair[0],
+ desc = pair[1];
+ doc.registerClassTransformation(transformations.createContextTransformation(desc, name), className);
+ });
});
}
});
-var wlxmlClasses = {
- 'uri': {
- attrs: {uri: {type: 'string'}}
- }
-};
-
-var classMethods = {};
-
return {
- WLXMLDocumentFromXML: function(xml, options) {
- options = _.extend({wlxmlClasses: wlxmlClasses}, options);
- return new WLXMLDocument(xml, options);
+ WLXMLDocumentFromXML: function(xml, options, Factory) {
+ Factory = Factory || WLXMLDocument;
+ return new Factory(xml, options);
},
-
WLXMLElementNodeFromXML: function(xml) {
return this.WLXMLDocumentFromXML(xml).root;
},
- registerExtension: function(extension) {
- // @@ depracated
- if(extension.documentTransformations) {
- extension.documentTransformations.forEach(function(method) {
- WLXMLDocument.prototype.transformations.register(transformations.createContextTransformation(method));
- });
- }
-
- _.pairs(extension.classMethods).forEach(function(pair) {
- var className = pair[0],
- methods = pair[1];
- _.pairs(methods).forEach(function(pair) {
- var methodName = pair[0],
- method = pair[1];
- classMethods[className] = classMethods[className] || {};
- classMethods[className][methodName] = method;
- });
-
- });
-
- _.extend(WLXMLDocument.prototype, extension.documentMethods);
-
- }
-
+ WLXMLDocument: WLXMLDocument,
+ getClassHierarchy: getClassLists
};
});
\ No newline at end of file
fnp / fnpeditor.git / blobdiff