Feodor2
/
Mypal
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Mypal/toolkit/components/microformats/microformat-shiv.js

4524 lines
138 KiB
JavaScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

/*
Modern
microformat-shiv - v1.4.0
Built: 2016-03-02 10:03 - http://microformat-shiv.com
Copyright (c) 2016 Glenn Jones
Licensed MIT
*/
var Microformats; // jshint ignore:line
(function (root, factory) {
if (typeof define === 'function' && define.amd) {
define([], factory);
} else if (typeof exports === 'object') {
module.exports = factory();
} else {
root.Microformats = factory();
}
}(this, function () {
var modules = {};
modules.version = '1.4.0';
modules.livingStandard = '2015-09-25T12:26:04Z';
/**
* constructor
*
*/
modules.Parser = function () {
this.rootPrefix = 'h-';
this.propertyPrefixes = ['p-', 'dt-', 'u-', 'e-'];
this.excludeTags = ['br', 'hr'];
};
// create objects incase the v1 map modules don't load
modules.maps = (modules.maps)? modules.maps : {};
modules.rels = (modules.rels)? modules.rels : {};
modules.Parser.prototype = {
init: function() {
this.rootNode = null;
this.document = null;
this.options = {
'baseUrl': '',
'filters': [],
'textFormat': 'whitespacetrimmed',
'dateFormat': 'auto', // html5 for testing
'overlappingVersions': false,
'impliedPropertiesByVersion': true,
'parseLatLonGeo': false
};
this.rootID = 0;
this.errors = [];
this.noContentErr = 'No options.node or options.html was provided and no document object could be found.';
},
/**
* internal parse function
*
* @param {Object} options
* @return {Object}
*/
get: function(options) {
var out = this.formatEmpty(),
data = [],
rels;
this.init();
options = (options)? options : {};
this.mergeOptions(options);
this.getDOMContext( options );
// if we do not have any context create error
if (!this.rootNode || !this.document) {
this.errors.push(this.noContentErr);
} else {
// only parse h-* microformats if we need to
// this is added to speed up parsing
if (this.hasMicroformats(this.rootNode, options)) {
this.prepareDOM( options );
if (this.options.filters.length > 0) {
// parse flat list of items
var newRootNode = this.findFilterNodes(this.rootNode, this.options.filters);
data = this.walkRoot(newRootNode);
} else {
// parse whole document from root
data = this.walkRoot(this.rootNode);
}
out.items = data;
// don't clear-up DOM if it was cloned
if (modules.domUtils.canCloneDocument(this.document) === false) {
this.clearUpDom(this.rootNode);
}
}
// find any rels
if (this.findRels) {
rels = this.findRels(this.rootNode);
out.rels = rels.rels;
out['rel-urls'] = rels['rel-urls'];
}
}
if (this.errors.length > 0) {
return this.formatError();
}
return out;
},
/**
* parse to get parent microformat of passed node
*
* @param {DOM Node} node
* @param {Object} options
* @return {Object}
*/
getParent: function(node, options) {
this.init();
options = (options)? options : {};
if (node) {
return this.getParentTreeWalk(node, options);
}
this.errors.push(this.noContentErr);
return this.formatError();
},
/**
* get the count of microformats
*
* @param {DOM Node} rootNode
* @return {Int}
*/
count: function( options ) {
var out = {},
items,
classItems,
x,
i;
this.init();
options = (options)? options : {};
this.getDOMContext( options );
// if we do not have any context create error
if (!this.rootNode || !this.document) {
return {'errors': [this.noContentErr]};
}
items = this.findRootNodes( this.rootNode, true );
i = items.length;
while (i--) {
classItems = modules.domUtils.getAttributeList(items[i], 'class');
x = classItems.length;
while (x--) {
// find v2 names
if (modules.utils.startWith( classItems[x], 'h-' )) {
this.appendCount(classItems[x], 1, out);
}
// find v1 names
for (var key in modules.maps) {
// dont double count if v1 and v2 roots are present
if (modules.maps[key].root === classItems[x] && classItems.indexOf(key) === -1) {
this.appendCount(key, 1, out);
}
}
}
}
var relCount = this.countRels( this.rootNode );
if (relCount > 0) {
out.rels = relCount;
}
return out;
},
/**
* does a node have a class that marks it as a microformats root
*
* @param {DOM Node} node
* @param {Objecte} options
* @return {Boolean}
*/
isMicroformat: function( node, options ) {
var classes,
i;
if (!node) {
return false;
}
// if documemt gets topmost node
node = modules.domUtils.getTopMostNode( node );
// look for h-* microformats
classes = this.getUfClassNames(node);
if (options && options.filters && modules.utils.isArray(options.filters)) {
i = options.filters.length;
while (i--) {
if (classes.root.indexOf(options.filters[i]) > -1) {
return true;
}
}
return false;
}
return (classes.root.length > 0);
},
/**
* does a node or its children have microformats
*
* @param {DOM Node} node
* @param {Objecte} options
* @return {Boolean}
*/
hasMicroformats: function( node, options ) {
var items,
i;
if (!node) {
return false;
}
// if browser based documemt get topmost node
node = modules.domUtils.getTopMostNode( node );
// returns all microformat roots
items = this.findRootNodes( node, true );
if (options && options.filters && modules.utils.isArray(options.filters)) {
i = items.length;
while (i--) {
if ( this.isMicroformat( items[i], options ) ) {
return true;
}
}
return false;
}
return (items.length > 0);
},
/**
* add a new v1 mapping object to parser
*
* @param {Array} maps
*/
add: function( maps ) {
maps.forEach(function(map) {
if (map && map.root && map.name && map.properties) {
modules.maps[map.name] = JSON.parse(JSON.stringify(map));
}
});
},
/**
* internal parse to get parent microformats by walking up the tree
*
* @param {DOM Node} node
* @param {Object} options
* @param {Int} recursive
* @return {Object}
*/
getParentTreeWalk: function (node, options, recursive) {
options = (options)? options : {};
// recursive calls
if (recursive === undefined) {
if (node.parentNode && node.nodeName !== 'HTML') {
return this.getParentTreeWalk(node.parentNode, options, true);
}
return this.formatEmpty();
}
if (node !== null && node !== undefined && node.parentNode) {
if (this.isMicroformat( node, options )) {
// if we have a match return microformat
options.node = node;
return this.get( options );
}
return this.getParentTreeWalk(node.parentNode, options, true);
}
return this.formatEmpty();
},
/**
* configures what are the base DOM objects for parsing
*
* @param {Object} options
*/
getDOMContext: function( options ) {
var nodes = modules.domUtils.getDOMContext( options );
this.rootNode = nodes.rootNode;
this.document = nodes.document;
},
/**
* prepares DOM before the parse begins
*
* @param {Object} options
* @return {Boolean}
*/
prepareDOM: function( options ) {
var baseTag,
href;
// use current document to define baseUrl, try/catch needed for IE10+ error
try {
if (!options.baseUrl && this.document && this.document.location) {
this.options.baseUrl = this.document.location.href;
}
} catch (e) {
// there is no alt action
}
// find base tag to set baseUrl
baseTag = modules.domUtils.querySelector(this.document, 'base');
if (baseTag) {
href = modules.domUtils.getAttribute(baseTag, 'href');
if (href) {
this.options.baseUrl = href;
}
}
// get path to rootNode
// then clone document
// then reset the rootNode to its cloned version in a new document
var path,
newDocument,
newRootNode;
path = modules.domUtils.getNodePath(this.rootNode);
newDocument = modules.domUtils.cloneDocument(this.document);
newRootNode = modules.domUtils.getNodeByPath(newDocument, path);
// check results as early IE fails
if (newDocument && newRootNode) {
this.document = newDocument;
this.rootNode = newRootNode;
}
// add includes
if (this.addIncludes) {
this.addIncludes( this.document );
}
return (this.rootNode && this.document);
},
/**
* returns an empty structure with errors
*
* @return {Object}
*/
formatError: function() {
var out = this.formatEmpty();
out.errors = this.errors;
return out;
},
/**
* returns an empty structure
*
* @return {Object}
*/
formatEmpty: function() {
return {
'items': [],
'rels': {},
'rel-urls': {}
};
},
// find microformats of a given type and return node structures
findFilterNodes: function(rootNode, filters) {
if (modules.utils.isString(filters)) {
filters = [filters];
}
var newRootNode = modules.domUtils.createNode('div'),
items = this.findRootNodes(rootNode, true),
i = 0,
x = 0,
y = 0;
// add v1 names
y = filters.length;
while (y--) {
if (this.getMapping(filters[y])) {
var v1Name = this.getMapping(filters[y]).root;
filters.push(v1Name);
}
}
if (items) {
i = items.length;
while (x < i) {
// append matching nodes into newRootNode
y = filters.length;
while (y--) {
if (modules.domUtils.hasAttributeValue(items[x], 'class', filters[y])) {
var clone = modules.domUtils.clone(items[x]);
modules.domUtils.appendChild(newRootNode, clone);
break;
}
}
x++;
}
}
return newRootNode;
},
/**
* appends data to output object for count
*
* @param {string} name
* @param {Int} count
* @param {Object}
*/
appendCount: function(name, count, out) {
if (out[name]) {
out[name] = out[name] + count;
} else {
out[name] = count;
}
},
/**
* is the microformats type in the filter list
*
* @param {Object} uf
* @param {Array} filters
* @return {Boolean}
*/
shouldInclude: function(uf, filters) {
var i;
if (modules.utils.isArray(filters) && filters.length > 0) {
i = filters.length;
while (i--) {
if (uf.type[0] === filters[i]) {
return true;
}
}
return false;
}
return true;
},
/**
* finds all microformat roots in a rootNode
*
* @param {DOM Node} rootNode
* @param {Boolean} includeRoot
* @return {Array}
*/
findRootNodes: function(rootNode, includeRoot) {
var arr = null,
out = [],
classList = [],
items,
x,
i,
y,
key;
// build an array of v1 root names
for (key in modules.maps) {
if (modules.maps.hasOwnProperty(key)) {
classList.push(modules.maps[key].root);
}
}
// get all elements that have a class attribute
includeRoot = (includeRoot) ? includeRoot : false;
if (includeRoot && rootNode.parentNode) {
arr = modules.domUtils.getNodesByAttribute(rootNode.parentNode, 'class');
} else {
arr = modules.domUtils.getNodesByAttribute(rootNode, 'class');
}
// loop elements that have a class attribute
x = 0;
i = arr.length;
while (x < i) {
items = modules.domUtils.getAttributeList(arr[x], 'class');
// loop classes on an element
y = items.length;
while (y--) {
// match v1 root names
if (classList.indexOf(items[y]) > -1) {
out.push(arr[x]);
break;
}
// match v2 root name prefix
if (modules.utils.startWith(items[y], 'h-')) {
out.push(arr[x]);
break;
}
}
x++;
}
return out;
},
/**
* starts the tree walk to find microformats
*
* @param {DOM Node} node
* @return {Array}
*/
walkRoot: function(node) {
var context = this,
children = [],
child,
classes,
items = [],
out = [];
classes = this.getUfClassNames(node);
// if it is a root microformat node
if (classes && classes.root.length > 0) {
items = this.walkTree(node);
if (items.length > 0) {
out = out.concat(items);
}
} else {
// check if there are children and one of the children has a root microformat
children = modules.domUtils.getChildren( node );
if (children && children.length > 0 && this.findRootNodes(node, true).length > -1) {
for (var i = 0; i < children.length; i++) {
child = children[i];
items = context.walkRoot(child);
if (items.length > 0) {
out = out.concat(items);
}
}
}
}
return out;
},
/**
* starts the tree walking for a single microformat
*
* @param {DOM Node} node
* @return {Array}
*/
walkTree: function(node) {
var classes,
out = [],
obj,
itemRootID;
// loop roots found on one element
classes = this.getUfClassNames(node);
if (classes && classes.root.length && classes.root.length > 0) {
this.rootID++;
itemRootID = this.rootID;
obj = this.createUfObject(classes.root, classes.typeVersion);
this.walkChildren(node, obj, classes.root, itemRootID, classes);
if (this.impliedRules) {
this.impliedRules(node, obj, classes);
}
out.push( this.cleanUfObject(obj) );
}
return out;
},
/**
* finds child properties of microformat
*
* @param {DOM Node} node
* @param {Object} out
* @param {String} ufName
* @param {Int} rootID
* @param {Object} parentClasses
*/
walkChildren: function(node, out, ufName, rootID, parentClasses) {
var context = this,
children = [],
rootItem,
itemRootID,
value,
propertyName,
propertyVersion,
i,
x,
y,
z,
child;
children = modules.domUtils.getChildren( node );
y = 0;
z = children.length;
while (y < z) {
child = children[y];
// get microformat classes for this single element
var classes = context.getUfClassNames(child, ufName);
// a property which is a microformat
if (classes.root.length > 0 && classes.properties.length > 0 && !child.addedAsRoot) {
// create object with type, property and value
rootItem = context.createUfObject(
classes.root,
classes.typeVersion,
modules.text.parse(this.document, child, context.options.textFormat)
);
// add the microformat as an array of properties
propertyName = context.removePropPrefix(classes.properties[0][0]);
// modifies value with "implied value rule"
if (parentClasses && parentClasses.root.length === 1 && parentClasses.properties.length === 1) {
if (context.impliedValueRule) {
out = context.impliedValueRule(out, parentClasses.properties[0][0], classes.properties[0][0], value);
}
}
if (out.properties[propertyName]) {
out.properties[propertyName].push(rootItem);
} else {
out.properties[propertyName] = [rootItem];
}
context.rootID++;
// used to stop duplication in heavily nested structures
child.addedAsRoot = true;
x = 0;
i = rootItem.type.length;
itemRootID = context.rootID;
while (x < i) {
context.walkChildren(child, rootItem, rootItem.type, itemRootID, classes);
x++;
}
if (this.impliedRules) {
context.impliedRules(child, rootItem, classes);
}
this.cleanUfObject(rootItem);
}
// a property which is NOT a microformat and has not been used for a given root element
if (classes.root.length === 0 && classes.properties.length > 0) {
x = 0;
i = classes.properties.length;
while (x < i) {
value = context.getValue(child, classes.properties[x][0], out);
propertyName = context.removePropPrefix(classes.properties[x][0]);
propertyVersion = classes.properties[x][1];
// modifies value with "implied value rule"
if (parentClasses && parentClasses.root.length === 1 && parentClasses.properties.length === 1) {
if (context.impliedValueRule) {
out = context.impliedValueRule(out, parentClasses.properties[0][0], classes.properties[x][0], value);
}
}
// if we have not added this value into a property with the same name already
if (!context.hasRootID(child, rootID, propertyName)) {
// check the root and property is the same version or if overlapping versions are allowed
if ( context.isAllowedPropertyVersion( out.typeVersion, propertyVersion ) ) {
// add the property as an array of properties
if (out.properties[propertyName]) {
out.properties[propertyName].push(value);
} else {
out.properties[propertyName] = [value];
}
// add rootid to node so we can track its use
context.appendRootID(child, rootID, propertyName);
}
}
x++;
}
context.walkChildren(child, out, ufName, rootID, classes);
}
// if the node has no microformat classes, see if its children have
if (classes.root.length === 0 && classes.properties.length === 0) {
context.walkChildren(child, out, ufName, rootID, classes);
}
// if the node is a child root add it to the children tree
if (classes.root.length > 0 && classes.properties.length === 0) {
// create object with type, property and value
rootItem = context.createUfObject(
classes.root,
classes.typeVersion,
modules.text.parse(this.document, child, context.options.textFormat)
);
// add the microformat as an array of properties
if (!out.children) {
out.children = [];
}
if (!context.hasRootID(child, rootID, 'child-root')) {
out.children.push( rootItem );
context.appendRootID(child, rootID, 'child-root');
context.rootID++;
}
x = 0;
i = rootItem.type.length;
itemRootID = context.rootID;
while (x < i) {
context.walkChildren(child, rootItem, rootItem.type, itemRootID, classes);
x++;
}
if (this.impliedRules) {
context.impliedRules(child, rootItem, classes);
}
context.cleanUfObject( rootItem );
}
y++;
}
},
/**
* gets the value of a property from a node
*
* @param {DOM Node} node
* @param {String} className
* @param {Object} uf
* @return {String || Object}
*/
getValue: function(node, className, uf) {
var value = '';
if (modules.utils.startWith(className, 'p-')) {
value = this.getPValue(node, true);
}
if (modules.utils.startWith(className, 'e-')) {
value = this.getEValue(node);
}
if (modules.utils.startWith(className, 'u-')) {
value = this.getUValue(node, true);
}
if (modules.utils.startWith(className, 'dt-')) {
value = this.getDTValue(node, className, uf, true);
}
return value;
},
/**
* gets the value of a node which contains a 'p-' property
*
* @param {DOM Node} node
* @param {Boolean} valueParse
* @return {String}
*/
getPValue: function(node, valueParse) {
var out = '';
if (valueParse) {
out = this.getValueClass(node, 'p');
}
if (!out && valueParse) {
out = this.getValueTitle(node);
}
if (!out) {
out = modules.domUtils.getAttrValFromTagList(node, ['abbr'], 'title');
}
if (!out) {
out = modules.domUtils.getAttrValFromTagList(node, ['data', 'input'], 'value');
}
if (node.name === 'br' || node.name === 'hr') {
out = '';
}
if (!out) {
out = modules.domUtils.getAttrValFromTagList(node, ['img', 'area'], 'alt');
}
if (!out) {
out = modules.text.parse(this.document, node, this.options.textFormat);
}
return (out) ? out : '';
},
/**
* gets the value of a node which contains the 'e-' property
*
* @param {DOM Node} node
* @return {Object}
*/
getEValue: function(node) {
var out = {value: '', html: ''};
this.expandURLs(node, 'src', this.options.baseUrl);
this.expandURLs(node, 'href', this.options.baseUrl);
out.value = modules.text.parse(this.document, node, this.options.textFormat);
out.html = modules.html.parse(node);
return out;
},
/**
* gets the value of a node which contains the 'u-' property
*
* @param {DOM Node} node
* @param {Boolean} valueParse
* @return {String}
*/
getUValue: function(node, valueParse) {
var out = '';
if (valueParse) {
out = this.getValueClass(node, 'u');
}
if (!out && valueParse) {
out = this.getValueTitle(node);
}
if (!out) {
out = modules.domUtils.getAttrValFromTagList(node, ['a', 'area'], 'href');
}
if (!out) {
out = modules.domUtils.getAttrValFromTagList(node, ['img', 'audio', 'video', 'source'], 'src');
}
if (!out) {
out = modules.domUtils.getAttrValFromTagList(node, ['object'], 'data');
}
// if we have no protocol separator, turn relative url to absolute url
if (out && out !== '' && out.indexOf('://') === -1) {
out = modules.url.resolve(out, this.options.baseUrl);
}
if (!out) {
out = modules.domUtils.getAttrValFromTagList(node, ['abbr'], 'title');
}
if (!out) {
out = modules.domUtils.getAttrValFromTagList(node, ['data', 'input'], 'value');
}
if (!out) {
out = modules.text.parse(this.document, node, this.options.textFormat);
}
return (out) ? out : '';
},
/**
* gets the value of a node which contains the 'dt-' property
*
* @param {DOM Node} node
* @param {String} className
* @param {Object} uf
* @param {Boolean} valueParse
* @return {String}
*/
getDTValue: function(node, className, uf, valueParse) {
var out = '';
if (valueParse) {
out = this.getValueClass(node, 'dt');
}
if (!out && valueParse) {
out = this.getValueTitle(node);
}
if (!out) {
out = modules.domUtils.getAttrValFromTagList(node, ['time', 'ins', 'del'], 'datetime');
}
if (!out) {
out = modules.domUtils.getAttrValFromTagList(node, ['abbr'], 'title');
}
if (!out) {
out = modules.domUtils.getAttrValFromTagList(node, ['data', 'input'], 'value');
}
if (!out) {
out = modules.text.parse(this.document, node, this.options.textFormat);
}
if (out) {
if (modules.dates.isDuration(out)) {
// just duration
return out;
} else if (modules.dates.isTime(out)) {
// just time or time+timezone
if (uf) {
uf.times.push([className, modules.dates.parseAmPmTime(out, this.options.dateFormat)]);
}
return modules.dates.parseAmPmTime(out, this.options.dateFormat);
}
// returns a date - microformat profile
if (uf) {
uf.dates.push([className, new modules.ISODate(out).toString( this.options.dateFormat )]);
}
return new modules.ISODate(out).toString( this.options.dateFormat );
}
return '';
},
/**
* appends a new rootid to a given node
*
* @param {DOM Node} node
* @param {String} id
* @param {String} propertyName
*/
appendRootID: function(node, id, propertyName) {
if (this.hasRootID(node, id, propertyName) === false) {
var rootids = [];
if (modules.domUtils.hasAttribute(node, 'rootids')) {
rootids = modules.domUtils.getAttributeList(node, 'rootids');
}
rootids.push('id' + id + '-' + propertyName);
modules.domUtils.setAttribute(node, 'rootids', rootids.join(' '));
}
},
/**
* does a given node already have a rootid
*
* @param {DOM Node} node
* @param {String} id
* @param {String} propertyName
* @return {Boolean}
*/
hasRootID: function(node, id, propertyName) {
var rootids = [];
if (!modules.domUtils.hasAttribute(node, 'rootids')) {
return false;
}
rootids = modules.domUtils.getAttributeList(node, 'rootids');
return (rootids.indexOf('id' + id + '-' + propertyName) > -1);
},
/**
* gets the text of any child nodes with a class value
*
* @param {DOM Node} node
* @param {String} propertyName
* @return {String || null}
*/
getValueClass: function(node, propertyType) {
var context = this,
children = [],
out = [],
child,
x,
i;
children = modules.domUtils.getChildren( node );
x = 0;
i = children.length;
while (x < i) {
child = children[x];
var value = null;
if (modules.domUtils.hasAttributeValue(child, 'class', 'value')) {
switch (propertyType) {
case 'p':
value = context.getPValue(child, false);
break;
case 'u':
value = context.getUValue(child, false);
break;
case 'dt':
value = context.getDTValue(child, '', null, false);
break;
}
if (value) {
out.push(modules.utils.trim(value));
}
}
x++;
}
if (out.length > 0) {
if (propertyType === 'p') {
return modules.text.parseText( this.document, out.join(' '), this.options.textFormat);
}
if (propertyType === 'u') {
return out.join('');
}
if (propertyType === 'dt') {
return modules.dates.concatFragments(out, this.options.dateFormat).toString(this.options.dateFormat);
}
return undefined;
}
return null;
},
/**
* returns a single string of the 'title' attr from all
* the child nodes with the class 'value-title'
*
* @param {DOM Node} node
* @return {String}
*/
getValueTitle: function(node) {
var out = [],
items,
i,
x;
items = modules.domUtils.getNodesByAttributeValue(node, 'class', 'value-title');
x = 0;
i = items.length;
while (x < i) {
if (modules.domUtils.hasAttribute(items[x], 'title')) {
out.push(modules.domUtils.getAttribute(items[x], 'title'));
}
x++;
}
return out.join('');
},
/**
* finds out whether a node has h-* class v1 and v2
*
* @param {DOM Node} node
* @return {Boolean}
*/
hasHClass: function(node) {
var classes = this.getUfClassNames(node);
if (classes.root && classes.root.length > 0) {
return true;
}
return false;
},
/**
* get both the root and property class names from a node
*
* @param {DOM Node} node
* @param {Array} ufNameArr
* @return {Object}
*/
getUfClassNames: function(node, ufNameArr) {
var context = this,
out = {
'root': [],
'properties': []
},
classNames,
key,
items,
item,
i,
x,
z,
y,
map,
prop,
propName,
v2Name,
impiedRel,
ufName;
// don't get classes from excluded list of tags
if (modules.domUtils.hasTagName(node, this.excludeTags) === false) {
// find classes for node
classNames = modules.domUtils.getAttribute(node, 'class');
if (classNames) {
items = classNames.split(' ');
x = 0;
i = items.length;
while (x < i) {
item = modules.utils.trim(items[x]);
// test for root prefix - v2
if (modules.utils.startWith(item, context.rootPrefix)) {
if (out.root.indexOf(item) === -1) {
out.root.push(item);
}
out.typeVersion = 'v2';
}
// test for property prefix - v2
z = context.propertyPrefixes.length;
while (z--) {
if (modules.utils.startWith(item, context.propertyPrefixes[z])) {
out.properties.push([item, 'v2']);
}
}
// test for mapped root classnames v1
for (key in modules.maps) {
if (modules.maps.hasOwnProperty(key)) {
// only add a root once
if (modules.maps[key].root === item && out.root.indexOf(key) === -1) {
// if root map has subTree set to true
// test to see if we should create a property or root
if (modules.maps[key].subTree) {
out.properties.push(['p-' + modules.maps[key].root, 'v1']);
} else {
out.root.push(key);
if (!out.typeVersion) {
out.typeVersion = 'v1';
}
}
}
}
}
// test for mapped property classnames v1
if (ufNameArr) {
for (var a = 0; a < ufNameArr.length; a++) {
ufName = ufNameArr[a];
// get mapped property v1 microformat
map = context.getMapping(ufName);
if (map) {
for (key in map.properties) {
if (map.properties.hasOwnProperty(key)) {
prop = map.properties[key];
propName = (prop.map) ? prop.map : 'p-' + key;
if (key === item) {
if (prop.uf) {
// loop all the classList make sure
// 1. this property is a root
// 2. that there is not already an equivalent v2 property i.e. url and u-url on the same element
y = 0;
while (y < i) {
v2Name = context.getV2RootName(items[y]);
// add new root
if (prop.uf.indexOf(v2Name) > -1 && out.root.indexOf(v2Name) === -1) {
out.root.push(v2Name);
out.typeVersion = 'v1';
}
y++;
}
// only add property once
if (out.properties.indexOf(propName) === -1) {
out.properties.push([propName, 'v1']);
}
} else if (out.properties.indexOf(propName) === -1) {
out.properties.push([propName, 'v1']);
}
}
}
}
}
}
}
x++;
}
}
}
// finds any alt rel=* mappings for a given node/microformat
if (ufNameArr && this.findRelImpied) {
for (var b = 0; b < ufNameArr.length; b++) {
ufName = ufNameArr[b];
impiedRel = this.findRelImpied(node, ufName);
if (impiedRel && out.properties.indexOf(impiedRel) === -1) {
out.properties.push([impiedRel, 'v1']);
}
}
}
// if(out.root.length === 1 && out.properties.length === 1) {
// if(out.root[0].replace('h-','') === this.removePropPrefix(out.properties[0][0])) {
// out.typeVersion = 'v2';
// }
// }
return out;
},
/**
* given a v1 or v2 root name, return mapping object
*
* @param {String} name
* @return {Object || null}
*/
getMapping: function(name) {
var key;
for (key in modules.maps) {
if (modules.maps[key].root === name || key === name) {
return modules.maps[key];
}
}
return null;
},
/**
* given a v1 root name returns a v2 root name i.e. vcard >>> h-card
*
* @param {String} name
* @return {String || null}
*/
getV2RootName: function(name) {
var key;
for (key in modules.maps) {
if (modules.maps[key].root === name) {
return key;
}
}
return null;
},
/**
* whether a property is the right microformats version for its root type
*
* @param {String} typeVersion
* @param {String} propertyVersion
* @return {Boolean}
*/
isAllowedPropertyVersion: function(typeVersion, propertyVersion) {
if (this.options.overlappingVersions === true) {
return true;
}
return (typeVersion === propertyVersion);
},
/**
* creates a blank microformats object
*
* @param {String} name
* @param {String} value
* @return {Object}
*/
createUfObject: function(names, typeVersion, value) {
var out = {};
// is more than just whitespace
if (value && modules.utils.isOnlyWhiteSpace(value) === false) {
out.value = value;
}
// add type i.e. ["h-card", "h-org"]
if (modules.utils.isArray(names)) {
out.type = names;
} else {
out.type = [names];
}
out.properties = {};
// metadata properties for parsing
out.typeVersion = typeVersion;
out.times = [];
out.dates = [];
out.altValue = null;
return out;
},
/**
* removes unwanted microformats property before output
*
* @param {Object} microformat
*/
cleanUfObject: function( microformat ) {
delete microformat.times;
delete microformat.dates;
delete microformat.typeVersion;
delete microformat.altValue;
return microformat;
},
/**
* removes microformat property prefixes from text
*
* @param {String} text
* @return {String}
*/
removePropPrefix: function(text) {
var i;
i = this.propertyPrefixes.length;
while (i--) {
var prefix = this.propertyPrefixes[i];
if (modules.utils.startWith(text, prefix)) {
text = text.substr(prefix.length);
}
}
return text;
},
/**
* expands all relative URLs to absolute ones where it can
*
* @param {DOM Node} node
* @param {String} attrName
* @param {String} baseUrl
*/
expandURLs: function(node, attrName, baseUrl) {
var i,
nodes,
attr;
nodes = modules.domUtils.getNodesByAttribute(node, attrName);
i = nodes.length;
while (i--) {
try {
// the url parser can blow up if the format is not right
attr = modules.domUtils.getAttribute(nodes[i], attrName);
if (attr && attr !== '' && baseUrl !== '' && attr.indexOf('://') === -1) {
// attr = urlParser.resolve(baseUrl, attr);
attr = modules.url.resolve(attr, baseUrl);
modules.domUtils.setAttribute(nodes[i], attrName, attr);
}
} catch (err) {
// do nothing - convert only the urls we can, leave the rest as they are
}
}
},
/**
* merges passed and default options -single level clone of properties
*
* @param {Object} options
*/
mergeOptions: function(options) {
var key;
for (key in options) {
if (options.hasOwnProperty(key)) {
this.options[key] = options[key];
}
}
},
/**
* removes all rootid attributes
*
* @param {DOM Node} rootNode
*/
removeRootIds: function(rootNode) {
var arr,
i;
arr = modules.domUtils.getNodesByAttribute(rootNode, 'rootids');
i = arr.length;
while (i--) {
modules.domUtils.removeAttribute(arr[i], 'rootids');
}
},
/**
* removes all changes made to the DOM
*
* @param {DOM Node} rootNode
*/
clearUpDom: function(rootNode) {
if (this.removeIncludes) {
this.removeIncludes(rootNode);
}
this.removeRootIds(rootNode);
}
};
modules.Parser.prototype.constructor = modules.Parser;
// check parser module is loaded
if (modules.Parser) {
/**
* applies "implied rules" microformat output structure i.e. feed-title, name, photo, url and date
*
* @param {DOM Node} node
* @param {Object} uf (microformat output structure)
* @param {Object} parentClasses (classes structure)
* @param {Boolean} impliedPropertiesByVersion
* @return {Object}
*/
modules.Parser.prototype.impliedRules = function(node, uf, parentClasses) {
var typeVersion = (uf.typeVersion)? uf.typeVersion: 'v2';
// TEMP: override to allow v1 implied properties while spec changes
if (this.options.impliedPropertiesByVersion === false) {
typeVersion = 'v2';
}
if (node && uf && uf.properties) {
uf = this.impliedBackwardComp( node, uf, parentClasses );
if (typeVersion === 'v2') {
uf = this.impliedhFeedTitle( uf );
uf = this.impliedName( node, uf );
uf = this.impliedPhoto( node, uf );
uf = this.impliedUrl( node, uf );
}
uf = this.impliedValue( node, uf, parentClasses );
uf = this.impliedDate( uf );
// TEMP: flagged while spec changes are put forward
if (this.options.parseLatLonGeo === true) {
uf = this.impliedGeo( uf );
}
}
return uf;
};
/**
* apply implied name rule
*
* @param {DOM Node} node
* @param {Object} uf
* @return {Object}
*/
modules.Parser.prototype.impliedName = function(node, uf) {
// implied name rule
/*
img.h-x[alt] <img class="h-card" src="glenn.htm" alt="Glenn Jones"></a>
area.h-x[alt] <area class="h-card" href="glenn.htm" alt="Glenn Jones"></area>
abbr.h-x[title] <abbr class="h-card" title="Glenn Jones"GJ</abbr>
.h-x>img:only-child[alt]:not[.h-*] <div class="h-card"><a src="glenn.htm" alt="Glenn Jones"></a></div>
.h-x>area:only-child[alt]:not[.h-*] <div class="h-card"><area href="glenn.htm" alt="Glenn Jones"></area></div>
.h-x>abbr:only-child[title] <div class="h-card"><abbr title="Glenn Jones">GJ</abbr></div>
.h-x>:only-child>img:only-child[alt]:not[.h-*] <div class="h-card"><span><img src="jane.html" alt="Jane Doe"/></span></div>
.h-x>:only-child>area:only-child[alt]:not[.h-*] <div class="h-card"><span><area href="jane.html" alt="Jane Doe"></area></span></div>
.h-x>:only-child>abbr:only-child[title] <div class="h-card"><span><abbr title="Jane Doe">JD</abbr></span></div>
*/
var name,
value;
if (!uf.properties.name) {
value = this.getImpliedProperty(node, ['img', 'area', 'abbr'], this.getNameAttr);
var textFormat = this.options.textFormat;
// if no value for tags/properties use text
if (!value) {
name = [modules.text.parse(this.document, node, textFormat)];
} else {
name = [modules.text.parseText(this.document, value, textFormat)];
}
if (name && name[0] !== '') {
uf.properties.name = name;
}
}
return uf;
};
/**
* apply implied photo rule
*
* @param {DOM Node} node
* @param {Object} uf
* @return {Object}
*/
modules.Parser.prototype.impliedPhoto = function(node, uf) {
// implied photo rule
/*
img.h-x[src] <img class="h-card" alt="Jane Doe" src="jane.jpeg"/>
object.h-x[data] <object class="h-card" data="jane.jpeg"/>Jane Doe</object>
.h-x>img[src]:only-of-type:not[.h-*] <div class="h-card"><img alt="Jane Doe" src="jane.jpeg"/></div>
.h-x>object[data]:only-of-type:not[.h-*] <div class="h-card"><object data="jane.jpeg"/>Jane Doe</object></div>
.h-x>:only-child>img[src]:only-of-type:not[.h-*] <div class="h-card"><span><img alt="Jane Doe" src="jane.jpeg"/></span></div>
.h-x>:only-child>object[data]:only-of-type:not[.h-*] <div class="h-card"><span><object data="jane.jpeg"/>Jane Doe</object></span></div>
*/
var value;
if (!uf.properties.photo) {
value = this.getImpliedProperty(node, ['img', 'object'], this.getPhotoAttr);
if (value) {
// relative to absolute URL
if (value && value !== '' && this.options.baseUrl !== '' && value.indexOf('://') === -1) {
value = modules.url.resolve(value, this.options.baseUrl);
}
uf.properties.photo = [modules.utils.trim(value)];
}
}
return uf;
};
/**
* apply implied URL rule
*
* @param {DOM Node} node
* @param {Object} uf
* @return {Object}
*/
modules.Parser.prototype.impliedUrl = function(node, uf) {
// implied URL rule
/*
a.h-x[href] <a class="h-card" href="glenn.html">Glenn</a>
area.h-x[href] <area class="h-card" href="glenn.html">Glenn</area>
.h-x>a[href]:only-of-type:not[.h-*] <div class="h-card" ><a href="glenn.html">Glenn</a><p>...</p></div>
.h-x>area[href]:only-of-type:not[.h-*] <div class="h-card" ><area href="glenn.html">Glenn</area><p>...</p></div>
*/
var value;
if (!uf.properties.url) {
value = this.getImpliedProperty(node, ['a', 'area'], this.getURLAttr);
if (value) {
// relative to absolute URL
if (value && value !== '' && this.options.baseUrl !== '' && value.indexOf('://') === -1) {
value = modules.url.resolve(value, this.options.baseUrl);
}
uf.properties.url = [modules.utils.trim(value)];
}
}
return uf;
};
/**
* apply implied date rule - if there is a time only property try to concat it with any date property
*
* @param {DOM Node} node
* @param {Object} uf
* @return {Object}
*/
modules.Parser.prototype.impliedDate = function(uf) {
// implied date rule
// http://microformats.org/wiki/value-class-pattern#microformats2_parsers
// http://microformats.org/wiki/microformats2-parsing-issues#implied_date_for_dt_properties_both_mf2_and_backcompat
var newDate;
if (uf.times.length > 0 && uf.dates.length > 0) {
newDate = modules.dates.dateTimeUnion(uf.dates[0][1], uf.times[0][1], this.options.dateFormat);
uf.properties[this.removePropPrefix(uf.times[0][0])][0] = newDate.toString(this.options.dateFormat);
}
// clean-up object
delete uf.times;
delete uf.dates;
return uf;
};
/**
* get an implied property value from pre-defined tag/attriubte combinations
*
* @param {DOM Node} node
* @param {String} tagList (Array of tags from which an implied value can be pulled)
* @param {String} getAttrFunction (Function which can extract implied value)
* @return {String || null}
*/
modules.Parser.prototype.getImpliedProperty = function(node, tagList, getAttrFunction) {
// i.e. img.h-card
var value = getAttrFunction(node),
descendant,
child;
if (!value) {
// i.e. .h-card>img:only-of-type:not(.h-card)
descendant = modules.domUtils.getSingleDescendantOfType( node, tagList);
if (descendant && this.hasHClass(descendant) === false) {
value = getAttrFunction(descendant);
}
if (node.children.length > 0 ) {
// i.e. .h-card>:only-child>img:only-of-type:not(.h-card)
child = modules.domUtils.getSingleDescendant(node);
if (child && this.hasHClass(child) === false) {
descendant = modules.domUtils.getSingleDescendantOfType(child, tagList);
if (descendant && this.hasHClass(descendant) === false) {
value = getAttrFunction(descendant);
}
}
}
}
return value;
};
/**
* get an implied name value from a node
*
* @param {DOM Node} node
* @return {String || null}
*/
modules.Parser.prototype.getNameAttr = function(node) {
var value = modules.domUtils.getAttrValFromTagList(node, ['img', 'area'], 'alt');
if (!value) {
value = modules.domUtils.getAttrValFromTagList(node, ['abbr'], 'title');
}
return value;
};
/**
* get an implied photo value from a node
*
* @param {DOM Node} node
* @return {String || null}
*/
modules.Parser.prototype.getPhotoAttr = function(node) {
var value = modules.domUtils.getAttrValFromTagList(node, ['img'], 'src');
if (!value && modules.domUtils.hasAttributeValue(node, 'class', 'include') === false) {
value = modules.domUtils.getAttrValFromTagList(node, ['object'], 'data');
}
return value;
};
/**
* get an implied photo value from a node
*
* @param {DOM Node} node
* @return {String || null}
*/
modules.Parser.prototype.getURLAttr = function(node) {
var value = null;
if (modules.domUtils.hasAttributeValue(node, 'class', 'include') === false) {
value = modules.domUtils.getAttrValFromTagList(node, ['a'], 'href');
if (!value) {
value = modules.domUtils.getAttrValFromTagList(node, ['area'], 'href');
}
}
return value;
};
/**
*
*
* @param {DOM Node} node
* @param {Object} uf
* @return {Object}
*/
modules.Parser.prototype.impliedValue = function(node, uf, parentClasses) {
// intersection of implied name and implied value rules
if (uf.properties.name) {
if (uf.value && parentClasses.root.length > 0 && parentClasses.properties.length === 1) {
uf = this.getAltValue(uf, parentClasses.properties[0][0], 'p-name', uf.properties.name[0]);
}
}
// intersection of implied URL and implied value rules
if (uf.properties.url) {
if (parentClasses && parentClasses.root.length === 1 && parentClasses.properties.length === 1) {
uf = this.getAltValue(uf, parentClasses.properties[0][0], 'u-url', uf.properties.url[0]);
}
}
// apply alt value
if (uf.altValue !== null) {
uf.value = uf.altValue.value;
}
delete uf.altValue;
return uf;
};
/**
* get alt value based on rules about parent property prefix
*
* @param {Object} uf
* @param {String} parentPropertyName
* @param {String} propertyName
* @param {String} value
* @return {Object}
*/
modules.Parser.prototype.getAltValue = function(uf, parentPropertyName, propertyName, value) {
if (uf.value && !uf.altValue) {
// first p-name of the h-* child
if (modules.utils.startWith(parentPropertyName, 'p-') && propertyName === 'p-name') {
uf.altValue = {name: propertyName, value: value};
}
// if it's an e-* property element
if (modules.utils.startWith(parentPropertyName, 'e-') && modules.utils.startWith(propertyName, 'e-')) {
uf.altValue = {name: propertyName, value: value};
}
// if it's an u-* property element
if (modules.utils.startWith(parentPropertyName, 'u-') && propertyName === 'u-url') {
uf.altValue = {name: propertyName, value: value};
}
}
return uf;
};
/**
* if a h-feed does not have a title use the title tag of a page
*
* @param {Object} uf
* @return {Object}
*/
modules.Parser.prototype.impliedhFeedTitle = function( uf ) {
if (uf.type && uf.type.indexOf('h-feed') > -1) {
// has no name property
if (uf.properties.name === undefined || uf.properties.name[0] === '' ) {
// use the text from the title tag
var title = modules.domUtils.querySelector(this.document, 'title');
if (title) {
uf.properties.name = [modules.domUtils.textContent(title)];
}
}
}
return uf;
};
/**
* implied Geo from pattern <abbr class="p-geo" title="37.386013;-122.082932">
*
* @param {Object} uf
* @return {Object}
*/
modules.Parser.prototype.impliedGeo = function( uf ) {
var geoPair,
parts,
longitude,
latitude,
valid = true;
if (uf.type && uf.type.indexOf('h-geo') > -1) {
// has no latitude or longitude property
if (uf.properties.latitude === undefined || uf.properties.longitude === undefined ) {
geoPair = (uf.properties.name)? uf.properties.name[0] : null;
geoPair = (!geoPair && uf.properties.value)? uf.properties.value : geoPair;
if (geoPair) {
// allow for the use of a ';' as in microformats and also ',' as in Geo URL
geoPair = geoPair.replace(';', ',');
// has sep char
if (geoPair.indexOf(',') > -1 ) {
parts = geoPair.split(',');
// only correct if we have two or more parts
if (parts.length > 1) {
// latitude no value outside the range -90 or 90
latitude = parseFloat( parts[0] );
if (modules.utils.isNumber(latitude) && latitude > 90 || latitude < -90) {
valid = false;
}
// longitude no value outside the range -180 to 180
longitude = parseFloat( parts[1] );
if (modules.utils.isNumber(longitude) && longitude > 180 || longitude < -180) {
valid = false;
}
if (valid) {
uf.properties.latitude = [latitude];
uf.properties.longitude = [longitude];
}
}
}
}
}
}
return uf;
};
/**
* if a backwards compat built structure has no properties add name through this.impliedName
*
* @param {Object} uf
* @return {Object}
*/
modules.Parser.prototype.impliedBackwardComp = function(node, uf, parentClasses) {
// look for pattern in parent classes like "p-geo h-geo"
// these are structures built from backwards compat parsing of geo
if (parentClasses.root.length === 1 && parentClasses.properties.length === 1) {
if (parentClasses.root[0].replace('h-', '') === this.removePropPrefix(parentClasses.properties[0][0])) {
// if microformat has no properties apply the impliedName rule to get value from containing node
// this will get value from html such as <abbr class="geo" title="30.267991;-97.739568">Brighton</abbr>
if ( modules.utils.hasProperties(uf.properties) === false ) {
uf = this.impliedName( node, uf );
}
}
}
return uf;
};
}
// check parser module is loaded
if (modules.Parser) {
/**
* appends clones of include Nodes into the DOM structure
*
* @param {DOM node} rootNode
*/
modules.Parser.prototype.addIncludes = function(rootNode) {
this.addAttributeIncludes(rootNode, 'itemref');
this.addAttributeIncludes(rootNode, 'headers');
this.addClassIncludes(rootNode);
};
/**
* appends clones of include Nodes into the DOM structure for attribute based includes
*
* @param {DOM node} rootNode
* @param {String} attributeName
*/
modules.Parser.prototype.addAttributeIncludes = function(rootNode, attributeName) {
var arr,
idList,
i,
x,
z,
y;
arr = modules.domUtils.getNodesByAttribute(rootNode, attributeName);
x = 0;
i = arr.length;
while (x < i) {
idList = modules.domUtils.getAttributeList(arr[x], attributeName);
if (idList) {
z = 0;
y = idList.length;
while (z < y) {
this.apppendInclude(arr[x], idList[z]);
z++;
}
}
x++;
}
};
/**
* appends clones of include Nodes into the DOM structure for class based includes
*
* @param {DOM node} rootNode
*/
modules.Parser.prototype.addClassIncludes = function(rootNode) {
var id,
arr,
x = 0,
i;
arr = modules.domUtils.getNodesByAttributeValue(rootNode, 'class', 'include');
i = arr.length;
while (x < i) {
id = modules.domUtils.getAttrValFromTagList(arr[x], ['a'], 'href');
if (!id) {
id = modules.domUtils.getAttrValFromTagList(arr[x], ['object'], 'data');
}
this.apppendInclude(arr[x], id);
x++;
}
};
/**
* appends a clone of an include into another Node using Id
*
* @param {DOM node} rootNode
* @param {Stringe} id
*/
modules.Parser.prototype.apppendInclude = function(node, id) {
var include,
clone;
id = modules.utils.trim(id.replace('#', ''));
include = modules.domUtils.getElementById(this.document, id);
if (include) {
clone = modules.domUtils.clone(include);
this.markIncludeChildren(clone);
modules.domUtils.appendChild(node, clone);
}
};
/**
* adds an attribute marker to all the child microformat roots
*
* @param {DOM node} rootNode
*/
modules.Parser.prototype.markIncludeChildren = function(rootNode) {
var arr,
x,
i;
// loop the array and add the attribute
arr = this.findRootNodes(rootNode);
x = 0;
i = arr.length;
modules.domUtils.setAttribute(rootNode, 'data-include', 'true');
modules.domUtils.setAttribute(rootNode, 'style', 'display:none');
while (x < i) {
modules.domUtils.setAttribute(arr[x], 'data-include', 'true');
x++;
}
};
/**
* removes all appended include clones from DOM
*
* @param {DOM node} rootNode
*/
modules.Parser.prototype.removeIncludes = function(rootNode) {
var arr,
i;
// remove all the items that were added as includes
arr = modules.domUtils.getNodesByAttribute(rootNode, 'data-include');
i = arr.length;
while (i--) {
modules.domUtils.removeChild(rootNode, arr[i]);
}
};
}
// check parser module is loaded
if (modules.Parser) {
/**
* finds rel=* structures
*
* @param {DOM node} rootNode
* @return {Object}
*/
modules.Parser.prototype.findRels = function(rootNode) {
var out = {
'items': [],
'rels': {},
'rel-urls': {}
},
x,
i,
y,
z,
relList,
items,
item,
value,
arr;
arr = modules.domUtils.getNodesByAttribute(rootNode, 'rel');
x = 0;
i = arr.length;
while (x < i) {
relList = modules.domUtils.getAttribute(arr[x], 'rel');
if (relList) {
items = relList.split(' ');
// add rels
z = 0;
y = items.length;
while (z < y) {
item = modules.utils.trim(items[z]);
// get rel value
value = modules.domUtils.getAttrValFromTagList(arr[x], ['a', 'area'], 'href');
if (!value) {
value = modules.domUtils.getAttrValFromTagList(arr[x], ['link'], 'href');
}
// create the key
if (!out.rels[item]) {
out.rels[item] = [];
}
if (typeof this.options.baseUrl === 'string' && typeof value === 'string') {
var resolved = modules.url.resolve(value, this.options.baseUrl);
// do not add duplicate rels - based on resolved URLs
if (out.rels[item].indexOf(resolved) === -1) {
out.rels[item].push( resolved );
}
}
z++;
}
var url = null;
if (modules.domUtils.hasAttribute(arr[x], 'href')) {
url = modules.domUtils.getAttribute(arr[x], 'href');
if (url) {
url = modules.url.resolve(url, this.options.baseUrl );
}
}
// add to rel-urls
var relUrl = this.getRelProperties(arr[x]);
relUrl.rels = items;
// do not add duplicate rel-urls - based on resolved URLs
if (url && out['rel-urls'][url] === undefined) {
out['rel-urls'][url] = relUrl;
}
}
x++;
}
return out;
};
/**
* gets the properties of a rel=*
*
* @param {DOM node} node
* @return {Object}
*/
modules.Parser.prototype.getRelProperties = function(node) {
var obj = {};
if (modules.domUtils.hasAttribute(node, 'media')) {
obj.media = modules.domUtils.getAttribute(node, 'media');
}
if (modules.domUtils.hasAttribute(node, 'type')) {
obj.type = modules.domUtils.getAttribute(node, 'type');
}
if (modules.domUtils.hasAttribute(node, 'hreflang')) {
obj.hreflang = modules.domUtils.getAttribute(node, 'hreflang');
}
if (modules.domUtils.hasAttribute(node, 'title')) {
obj.title = modules.domUtils.getAttribute(node, 'title');
}
if (modules.utils.trim(this.getPValue(node, false)) !== '') {
obj.text = this.getPValue(node, false);
}
return obj;
};
/**
* finds any alt rel=* mappings for a given node/microformat
*
* @param {DOM node} node
* @param {String} ufName
* @return {String || undefined}
*/
modules.Parser.prototype.findRelImpied = function(node, ufName) {
var out,
map,
i;
map = this.getMapping(ufName);
if (map) {
for (var key in map.properties) {
if (map.properties.hasOwnProperty(key)) {
var prop = map.properties[key],
propName = (prop.map) ? prop.map : 'p-' + key,
relCount = 0;
// is property an alt rel=* mapping
if (prop.relAlt && modules.domUtils.hasAttribute(node, 'rel')) {
i = prop.relAlt.length;
while (i--) {
if (modules.domUtils.hasAttributeValue(node, 'rel', prop.relAlt[i])) {
relCount++;
}
}
if (relCount === prop.relAlt.length) {
out = propName;
}
}
}
}
}
return out;
};
/**
* returns whether a node or its children has rel=* microformat
*
* @param {DOM node} node
* @return {Boolean}
*/
modules.Parser.prototype.hasRel = function(node) {
return (this.countRels(node) > 0);
};
/**
* returns the number of rel=* microformats
*
* @param {DOM node} node
* @return {Int}
*/
modules.Parser.prototype.countRels = function(node) {
if (node) {
return modules.domUtils.getNodesByAttribute(node, 'rel').length;
}
return 0;
};
}
modules.utils = {
/**
* is the object a string
*
* @param {Object} obj
* @return {Boolean}
*/
isString: function( obj ) {
return typeof( obj ) === 'string';
},
/**
* is the object a number
*
* @param {Object} obj
* @return {Boolean}
*/
isNumber: function( obj ) {
return !isNaN(parseFloat( obj )) && isFinite( obj );
},
/**
* is the object an array
*
* @param {Object} obj
* @return {Boolean}
*/
isArray: function( obj ) {
return obj && !( obj.propertyIsEnumerable( 'length' ) ) && typeof obj === 'object' && typeof obj.length === 'number';
},
/**
* is the object a function
*
* @param {Object} obj
* @return {Boolean}
*/
isFunction: function(obj) {
return !!(obj && obj.constructor && obj.call && obj.apply);
},
/**
* does the text start with a test string
*
* @param {String} text
* @param {String} test
* @return {Boolean}
*/
startWith: function( text, test ) {
return (text.indexOf(test) === 0);
},
/**
* removes spaces at front and back of text
*
* @param {String} text
* @return {String}
*/
trim: function( text ) {
if (text && this.isString(text)) {
return (text.trim())? text.trim() : text.replace(/^\s+|\s+$/g, '');
}
return '';
},
/**
* replaces a character in text
*
* @param {String} text
* @param {Int} index
* @param {String} character
* @return {String}
*/
replaceCharAt: function( text, index, character ) {
if (text && text.length > index) {
return text.substr(0, index) + character + text.substr(index+character.length);
}
return text;
},
/**
* removes whitespace, tabs and returns from start and end of text
*
* @param {String} text
* @return {String}
*/
trimWhitespace: function( text ) {
if (text && text.length) {
var i = text.length,
x = 0;
// turn all whitespace chars at end into spaces
while (i--) {
if (this.isOnlyWhiteSpace(text[i])) {
text = this.replaceCharAt( text, i, ' ' );
} else {
break;
}
}
// turn all whitespace chars at start into spaces
i = text.length;
while (x < i) {
if (this.isOnlyWhiteSpace(text[x])) {
text = this.replaceCharAt( text, i, ' ' );
} else {
break;
}
x++;
}
}
return this.trim(text);
},
/**
* does text only contain whitespace characters
*
* @param {String} text
* @return {Boolean}
*/
isOnlyWhiteSpace: function( text ) {
return !(/[^\t\n\r ]/.test( text ));
},
/**
* removes whitespace from text (leaves a single space)
*
* @param {String} text
* @return {Sring}
*/
collapseWhiteSpace: function( text ) {
return text.replace(/[\t\n\r ]+/g, ' ');
},
/**
* does an object have any of its own properties
*
* @param {Object} obj
* @return {Boolean}
*/
hasProperties: function( obj ) {
var key;
for (key in obj) {
if ( obj.hasOwnProperty( key ) ) {
return true;
}
}
return false;
},
/**
* a sort function - to sort objects in an array by a given property
*
* @param {String} property
* @param {Boolean} reverse
* @return {Int}
*/
sortObjects: function(property, reverse) {
reverse = (reverse) ? -1 : 1;
return function (a, b) {
a = a[property];
b = b[property];
if (a < b) {
return reverse * -1;
}
if (a > b) {
return reverse * 1;
}
return 0;
};
}
};
modules.domUtils = {
// blank objects for DOM
document: null,
rootNode: null,
/**
* gets DOMParser object
*
* @return {Object || undefined}
*/
getDOMParser: function () {
if (typeof DOMParser === "undefined") {
try {
return Components.classes["@mozilla.org/xmlextras/domparser;1"]
.createInstance(Components.interfaces.nsIDOMParser);
} catch (e) {
return undefined;
}
} else {
return new DOMParser();
}
},
/**
* configures what are the base DOM objects for parsing
*
* @param {Object} options
* @return {DOM Node} node
*/
getDOMContext: function( options ) {
// if a node is passed
if (options.node) {
this.rootNode = options.node;
}
// if a html string is passed
if (options.html) {
// var domParser = new DOMParser();
var domParser = this.getDOMParser();
this.rootNode = domParser.parseFromString( options.html, 'text/html' );
}
// find top level document from rootnode
if (this.rootNode !== null) {
if (this.rootNode.nodeType === 9) {
this.document = this.rootNode;
this.rootNode = modules.domUtils.querySelector(this.rootNode, 'html');
} else {
// if it's DOM node get parent DOM Document
this.document = modules.domUtils.ownerDocument(this.rootNode);
}
}
// use global document object
if (!this.rootNode && document) {
this.rootNode = modules.domUtils.querySelector(document, 'html');
this.document = document;
}
if (this.rootNode && this.document) {
return {document: this.document, rootNode: this.rootNode};
}
return {document: null, rootNode: null};
},
/**
* gets the first DOM node
*
* @param {Dom Document}
* @return {DOM Node} node
*/
getTopMostNode: function( node ) {
// var doc = this.ownerDocument(node);
// if(doc && doc.nodeType && doc.nodeType === 9 && doc.documentElement){
// return doc.documentElement;
// }
return node;
},
/**
* abstracts DOM ownerDocument
*
* @param {DOM Node} node
* @return {Dom Document}
*/
ownerDocument: function(node) {
return node.ownerDocument;
},
/**
* abstracts DOM textContent
*
* @param {DOM Node} node
* @return {String}
*/
textContent: function(node) {
if (node.textContent) {
return node.textContent;
} else if (node.innerText) {
return node.innerText;
}
return '';
},
/**
* abstracts DOM innerHTML
*
* @param {DOM Node} node
* @return {String}
*/
innerHTML: function(node) {
return node.innerHTML;
},
/**
* abstracts DOM hasAttribute
*
* @param {DOM Node} node
* @param {String} attributeName
* @return {Boolean}
*/
hasAttribute: function(node, attributeName) {
return node.hasAttribute(attributeName);
},
/**
* does an attribute contain a value
*
* @param {DOM Node} node
* @param {String} attributeName
* @param {String} value
* @return {Boolean}
*/
hasAttributeValue: function(node, attributeName, value) {
return (this.getAttributeList(node, attributeName).indexOf(value) > -1);
},
/**
* abstracts DOM getAttribute
*
* @param {DOM Node} node
* @param {String} attributeName
* @return {String || null}
*/
getAttribute: function(node, attributeName) {
return node.getAttribute(attributeName);
},
/**
* abstracts DOM setAttribute
*
* @param {DOM Node} node
* @param {String} attributeName
* @param {String} attributeValue
*/
setAttribute: function(node, attributeName, attributeValue) {
node.setAttribute(attributeName, attributeValue);
},
/**
* abstracts DOM removeAttribute
*
* @param {DOM Node} node
* @param {String} attributeName
*/
removeAttribute: function(node, attributeName) {
node.removeAttribute(attributeName);
},
/**
* abstracts DOM getElementById
*
* @param {DOM Node || DOM Document} node
* @param {String} id
* @return {DOM Node}
*/
getElementById: function(docNode, id) {
return docNode.querySelector( '#' + id );
},
/**
* abstracts DOM querySelector
*
* @param {DOM Node || DOM Document} node
* @param {String} selector
* @return {DOM Node}
*/
querySelector: function(docNode, selector) {
return docNode.querySelector( selector );
},
/**
* get value of a Node attribute as an array
*
* @param {DOM Node} node
* @param {String} attributeName
* @return {Array}
*/
getAttributeList: function(node, attributeName) {
var out = [],
attList;
attList = node.getAttribute(attributeName);
if (attList && attList !== '') {
if (attList.indexOf(' ') > -1) {
out = attList.split(' ');
} else {
out.push(attList);
}
}
return out;
},
/**
* gets all child nodes with a given attribute
*
* @param {DOM Node} node
* @param {String} attributeName
* @return {NodeList}
*/
getNodesByAttribute: function(node, attributeName) {
var selector = '[' + attributeName + ']';
return node.querySelectorAll(selector);
},
/**
* gets all child nodes with a given attribute containing a given value
*
* @param {DOM Node} node
* @param {String} attributeName
* @return {DOM NodeList}
*/
getNodesByAttributeValue: function(rootNode, name, value) {
var arr = [],
x = 0,
i,
out = [];
arr = this.getNodesByAttribute(rootNode, name);
if (arr) {
i = arr.length;
while (x < i) {
if (this.hasAttributeValue(arr[x], name, value)) {
out.push(arr[x]);
}
x++;
}
}
return out;
},
/**
* gets attribute value from controlled list of tags
*
* @param {Array} tagNames
* @param {String} attributeName
* @return {String || null}
*/
getAttrValFromTagList: function(node, tagNames, attributeName) {
var i = tagNames.length;
while (i--) {
if (node.tagName.toLowerCase() === tagNames[i]) {
var attrValue = this.getAttribute(node, attributeName);
if (attrValue && attrValue !== '') {
return attrValue;
}
}
}
return null;
},
/**
* get node if it has no siblings. CSS equivalent is :only-child
*
* @param {DOM Node} rootNode
* @param {Array} tagNames
* @return {DOM Node || null}
*/
getSingleDescendant: function(node) {
return this.getDescendant( node, null, false );
},
/**
* get node if it has no siblings of the same type. CSS equivalent is :only-of-type
*
* @param {DOM Node} rootNode
* @param {Array} tagNames
* @return {DOM Node || null}
*/
getSingleDescendantOfType: function(node, tagNames) {
return this.getDescendant( node, tagNames, true );
},
/**
* get child node limited by presence of siblings - either CSS :only-of-type or :only-child
*
* @param {DOM Node} rootNode
* @param {Array} tagNames
* @return {DOM Node || null}
*/
getDescendant: function( node, tagNames, onlyOfType ) {
var i = node.children.length,
countAll = 0,
countOfType = 0,
child,
out = null;
while (i--) {
child = node.children[i];
if (child.nodeType === 1) {
if (tagNames) {
// count just only-of-type
if (this.hasTagName(child, tagNames)) {
out = child;
countOfType++;
}
} else {
// count all elements
out = child;
countAll++;
}
}
}
if (onlyOfType === true) {
return (countOfType === 1)? out : null;
}
return (countAll === 1)? out : null;
},
/**
* is a node one of a list of tags
*
* @param {DOM Node} rootNode
* @param {Array} tagNames
* @return {Boolean}
*/
hasTagName: function(node, tagNames) {
var i = tagNames.length;
while (i--) {
if (node.tagName.toLowerCase() === tagNames[i]) {
return true;
}
}
return false;
},
/**
* abstracts DOM appendChild
*
* @param {DOM Node} node
* @param {DOM Node} childNode
* @return {DOM Node}
*/
appendChild: function(node, childNode) {
return node.appendChild(childNode);
},
/**
* abstracts DOM removeChild
*
* @param {DOM Node} childNode
* @return {DOM Node || null}
*/
removeChild: function(childNode) {
if (childNode.parentNode) {
return childNode.parentNode.removeChild(childNode);
}
return null;
},
/**
* abstracts DOM cloneNode
*
* @param {DOM Node} node
* @return {DOM Node}
*/
clone: function(node) {
var newNode = node.cloneNode(true);
newNode.removeAttribute('id');
return newNode;
},
/**
* gets the text of a node
*
* @param {DOM Node} node
* @return {String}
*/
getElementText: function( node ) {
if (node && node.data) {
return node.data;
}
return '';
},
/**
* gets the attributes of a node - ordered by sequence in html
*
* @param {DOM Node} node
* @return {Array}
*/
getOrderedAttributes: function( node ) {
var nodeStr = node.outerHTML,
attrs = [];
for (var i = 0; i < node.attributes.length; i++) {
var attr = node.attributes[i];
attr.indexNum = nodeStr.indexOf(attr.name);
attrs.push( attr );
}
return attrs.sort( modules.utils.sortObjects( 'indexNum' ) );
},
/**
* decodes html entities in given text
*
* @param {DOM Document} doc
* @param String} text
* @return {String}
*/
decodeEntities: function( doc, text ) {
// return text;
return doc.createTextNode( text ).nodeValue;
},
/**
* clones a DOM document
*
* @param {DOM Document} document
* @return {DOM Document}
*/
cloneDocument: function( document ) {
var newNode,
newDocument = null;
if ( this.canCloneDocument( document )) {
newDocument = document.implementation.createHTMLDocument('');
newNode = newDocument.importNode( document.documentElement, true );
newDocument.replaceChild(newNode, newDocument.querySelector('html'));
}
return (newNode && newNode.nodeType && newNode.nodeType === 1)? newDocument : document;
},
/**
* can environment clone a DOM document
*
* @param {DOM Document} document
* @return {Boolean}
*/
canCloneDocument: function( document ) {
return (document && document.importNode && document.implementation && document.implementation.createHTMLDocument);
},
/**
* get the child index of a node. Used to create a node path
*
* @param {DOM Node} node
* @return {Int}
*/
getChildIndex: function (node) {
var parent = node.parentNode,
i = -1,
child;
while (parent && (child = parent.childNodes[++i])) {
if (child === node) {
return i;
}
}
return -1;
},
/**
* get a node's path
*
* @param {DOM Node} node
* @return {Array}
*/
getNodePath: function (node) {
var parent = node.parentNode,
path = [],
index = this.getChildIndex(node);
if (parent && (path = this.getNodePath(parent))) {
if (index > -1) {
path.push(index);
}
}
return path;
},
/**
* get a node from a path.
*
* @param {DOM document} document
* @param {Array} path
* @return {DOM Node}
*/
getNodeByPath: function (document, path) {
var node = document.documentElement,
i = 0,
index;
while ((index = path[++i]) > -1) {
node = node.childNodes[index];
}
return node;
},
/**
* get an array/nodeList of child nodes
*
* @param {DOM node} node
* @return {Array}
*/
getChildren: function( node ) {
return node.children;
},
/**
* create a node
*
* @param {String} tagName
* @return {DOM node}
*/
createNode: function( tagName ) {
return this.document.createElement(tagName);
},
/**
* create a node with text content
*
* @param {String} tagName
* @param {String} text
* @return {DOM node}
*/
createNodeWithText: function( tagName, text ) {
var node = this.document.createElement(tagName);
node.innerHTML = text;
return node;
}
};
modules.url = {
/**
* creates DOM objects needed to resolve URLs
*/
init: function() {
// this._domParser = new DOMParser();
this._domParser = modules.domUtils.getDOMParser();
// do not use a head tag it does not work with IE9
this._html = '<base id="base" href=""></base><a id="link" href=""></a>';
this._nodes = this._domParser.parseFromString( this._html, 'text/html' );
this._baseNode = modules.domUtils.getElementById(this._nodes, 'base');
this._linkNode = modules.domUtils.getElementById(this._nodes, 'link');
},
/**
* resolves url to absolute version using baseUrl
*
* @param {String} url
* @param {String} baseUrl
* @return {String}
*/
resolve: function(url, baseUrl) {
// use modern URL web API where we can
if (modules.utils.isString(url) && modules.utils.isString(baseUrl) && url.indexOf('://') === -1) {
// this try catch is required as IE has an URL object but no constuctor support
// http://glennjones.net/articles/the-problem-with-window-url
try {
var resolved = new URL(url, baseUrl).toString();
// deal with early Webkit not throwing an error - for Safari
if (resolved === '[object URL]') {
resolved = URI.resolve(baseUrl, url);
}
return resolved;
} catch (e) {
// otherwise fallback to DOM
if (this._domParser === undefined) {
this.init();
}
// do not use setAttribute it does not work with IE9
this._baseNode.href = baseUrl;
this._linkNode.href = url;
// dont use getAttribute as it returns orginal value not resolved
return this._linkNode.href;
}
} else {
if (modules.utils.isString(url)) {
return url;
}
return '';
}
},
};
/**
* constructor
* parses text to find just the date element of an ISO date/time string i.e. 2008-05-01
*
* @param {String} dateString
* @param {String} format
* @return {String}
*/
modules.ISODate = function ( dateString, format ) {
this.clear();
this.format = (format)? format : 'auto'; // auto or W3C or RFC3339 or HTML5
this.setFormatSep();
// optional should be full iso date/time string
if (arguments[0]) {
this.parse(dateString, format);
}
};
modules.ISODate.prototype = {
/**
* clear all states
*
*/
clear: function() {
this.clearDate();
this.clearTime();
this.clearTimeZone();
this.setAutoProfileState();
},
/**
* clear date states
*
*/
clearDate: function() {
this.dY = -1;
this.dM = -1;
this.dD = -1;
this.dDDD = -1;
},
/**
* clear time states
*
*/
clearTime: function() {
this.tH = -1;
this.tM = -1;
this.tS = -1;
this.tD = -1;
},
/**
* clear timezone states
*
*/
clearTimeZone: function() {
this.tzH = -1;
this.tzM = -1;
this.tzPN = '+';
this.z = false;
},
/**
* resets the auto profile state
*
*/
setAutoProfileState: function() {
this.autoProfile = {
sep: 'T',
dsep: '-',
tsep: ':',
tzsep: ':',
tzZulu: 'Z'
};
},
/**
* parses text to find ISO date/time string i.e. 2008-05-01T15:45:19Z
*
* @param {String} dateString
* @param {String} format
* @return {String}
*/
parse: function( dateString, format ) {
this.clear();
var parts = [],
tzArray = [],
position = 0,
datePart = '',
timePart = '',
timeZonePart = '';
if (format) {
this.format = format;
}
// discover date time separtor for auto profile
// Set to 'T' by default
if (dateString.indexOf('t') > -1) {
this.autoProfile.sep = 't';
}
if (dateString.indexOf('z') > -1) {
this.autoProfile.tzZulu = 'z';
}
if (dateString.indexOf('Z') > -1) {
this.autoProfile.tzZulu = 'Z';
}
if (dateString.toUpperCase().indexOf('T') === -1) {
this.autoProfile.sep = ' ';
}
dateString = dateString.toUpperCase().replace(' ', 'T');
// break on 'T' divider or space
if (dateString.indexOf('T') > -1) {
parts = dateString.split('T');
datePart = parts[0];
timePart = parts[1];
// zulu UTC
if (timePart.indexOf( 'Z' ) > -1) {
this.z = true;
}
// timezone
if (timePart.indexOf( '+' ) > -1 || timePart.indexOf( '-' ) > -1) {
tzArray = timePart.split( 'Z' ); // incase of incorrect use of Z
timePart = tzArray[0];
timeZonePart = tzArray[1];
// timezone
if (timePart.indexOf( '+' ) > -1 || timePart.indexOf( '-' ) > -1) {
position = 0;
if (timePart.indexOf( '+' ) > -1) {
position = timePart.indexOf( '+' );
} else {
position = timePart.indexOf( '-' );
}
timeZonePart = timePart.substring( position, timePart.length );
timePart = timePart.substring( 0, position );
}
}
} else {
datePart = dateString;
}
if (datePart !== '') {
this.parseDate( datePart );
if (timePart !== '') {
this.parseTime( timePart );
if (timeZonePart !== '') {
this.parseTimeZone( timeZonePart );
}
}
}
return this.toString( format );
},
/**
* parses text to find just the date element of an ISO date/time string i.e. 2008-05-01
*
* @param {String} dateString
* @param {String} format
* @return {String}
*/
parseDate: function( dateString, format ) {
this.clearDate();
var parts = [];
// discover timezone separtor for auto profile // default is ':'
if (dateString.indexOf('-') === -1) {
this.autoProfile.tsep = '';
}
// YYYY-DDD
parts = dateString.match( /(\d\d\d\d)-(\d\d\d)/ );
if (parts) {
if (parts[1]) {
this.dY = parts[1];
}
if (parts[2]) {
this.dDDD = parts[2];
}
}
if (this.dDDD === -1) {
// YYYY-MM-DD ie 2008-05-01 and YYYYMMDD ie 20080501
parts = dateString.match( /(\d\d\d\d)?-?(\d\d)?-?(\d\d)?/ );
if (parts[1]) {
this.dY = parts[1];
}
if (parts[2]) {
this.dM = parts[2];
}
if (parts[3]) {
this.dD = parts[3];
}
}
return this.toString(format);
},
/**
* parses text to find just the time element of an ISO date/time string i.e. 13:30:45
*
* @param {String} timeString
* @param {String} format
* @return {String}
*/
parseTime: function( timeString, format ) {
this.clearTime();
var parts = [];
// discover date separtor for auto profile // default is ':'
if (timeString.indexOf(':') === -1) {
this.autoProfile.tsep = '';
}
// finds timezone HH:MM:SS and HHMMSS ie 13:30:45, 133045 and 13:30:45.0135
parts = timeString.match( /(\d\d)?:?(\d\d)?:?(\d\d)?.?([0-9]+)?/ );
if (parts[1]) {
this.tH = parts[1];
}
if (parts[2]) {
this.tM = parts[2];
}
if (parts[3]) {
this.tS = parts[3];
}
if (parts[4]) {
this.tD = parts[4];
}
return this.toTimeString(format);
},
/**
* parses text to find just the time element of an ISO date/time string i.e. +08:00
*
* @param {String} timeString
* @param {String} format
* @return {String}
*/
parseTimeZone: function( timeString, format ) {
this.clearTimeZone();
var parts = [];
if (timeString.toLowerCase() === 'z') {
this.z = true;
// set case for z
this.autoProfile.tzZulu = (timeString === 'z')? 'z' : 'Z';
} else {
// discover timezone separtor for auto profile // default is ':'
if (timeString.indexOf(':') === -1) {
this.autoProfile.tzsep = '';
}
// finds timezone +HH:MM and +HHMM ie +13:30 and +1330
parts = timeString.match( /([\-\+]{1})?(\d\d)?:?(\d\d)?/ );
if (parts[1]) {
this.tzPN = parts[1];
}
if (parts[2]) {
this.tzH = parts[2];
}
if (parts[3]) {
this.tzM = parts[3];
}
}
this.tzZulu = 'z';
return this.toTimeString( format );
},
/**
* returns ISO date/time string in W3C Note, RFC 3339, HTML5, or auto profile
*
* @param {String} format
* @return {String}
*/
toString: function( format ) {
var output = '';
if (format) {
this.format = format;
}
this.setFormatSep();
if (this.dY > -1) {
output = this.dY;
if (this.dM > 0 && this.dM < 13) {
output += this.dsep + this.dM;
if (this.dD > 0 && this.dD < 32) {
output += this.dsep + this.dD;
if (this.tH > -1 && this.tH < 25) {
output += this.sep + this.toTimeString( format );
}
}
}
if (this.dDDD > -1) {
output += this.dsep + this.dDDD;
}
} else if (this.tH > -1) {
output += this.toTimeString( format );
}
return output;
},
/**
* returns just the time string element of an ISO date/time
* in W3C Note, RFC 3339, HTML5, or auto profile
*
* @param {String} format
* @return {String}
*/
toTimeString: function( format ) {
var out = '';
if (format) {
this.format = format;
}
this.setFormatSep();
// time can only be created with a full date
if (this.tH) {
if (this.tH > -1 && this.tH < 25) {
out += this.tH;
if (this.tM > -1 && this.tM < 61) {
out += this.tsep + this.tM;
if (this.tS > -1 && this.tS < 61) {
out += this.tsep + this.tS;
if (this.tD > -1) {
out += '.' + this.tD;
}
}
}
// time zone offset
if (this.z) {
out += this.tzZulu;
} else if (this.tzH && this.tzH > -1 && this.tzH < 25) {
out += this.tzPN + this.tzH;
if (this.tzM > -1 && this.tzM < 61) {
out += this.tzsep + this.tzM;
}
}
}
}
return out;
},
/**
* set the current profile to W3C Note, RFC 3339, HTML5, or auto profile
*
*/
setFormatSep: function() {
switch ( this.format.toLowerCase() ) {
case 'rfc3339':
this.sep = 'T';
this.dsep = '';
this.tsep = '';
this.tzsep = '';
this.tzZulu = 'Z';
break;
case 'w3c':
this.sep = 'T';
this.dsep = '-';
this.tsep = ':';
this.tzsep = ':';
this.tzZulu = 'Z';
break;
case 'html5':
this.sep = ' ';
this.dsep = '-';
this.tsep = ':';
this.tzsep = ':';
this.tzZulu = 'Z';
break;
default:
// auto - defined by format of input string
this.sep = this.autoProfile.sep;
this.dsep = this.autoProfile.dsep;
this.tsep = this.autoProfile.tsep;
this.tzsep = this.autoProfile.tzsep;
this.tzZulu = this.autoProfile.tzZulu;
}
},
/**
* does current data contain a full date i.e. 2015-03-23
*
* @return {Boolean}
*/
hasFullDate: function() {
return (this.dY !== -1 && this.dM !== -1 && this.dD !== -1);
},
/**
* does current data contain a minimum date which is just a year number i.e. 2015
*
* @return {Boolean}
*/
hasDate: function() {
return (this.dY !== -1);
},
/**
* does current data contain a minimum time which is just a hour number i.e. 13
*
* @return {Boolean}
*/
hasTime: function() {
return (this.tH !== -1);
},
/**
* does current data contain a minimum timezone i.e. -1 || +1 || z
*
* @return {Boolean}
*/
hasTimeZone: function() {
return (this.tzH !== -1);
}
};
modules.ISODate.prototype.constructor = modules.ISODate;
modules.dates = {
/**
* does text contain am
*
* @param {String} text
* @return {Boolean}
*/
hasAM: function( text ) {
text = text.toLowerCase();
return (text.indexOf('am') > -1 || text.indexOf('a.m.') > -1);
},
/**
* does text contain pm
*
* @param {String} text
* @return {Boolean}
*/
hasPM: function( text ) {
text = text.toLowerCase();
return (text.indexOf('pm') > -1 || text.indexOf('p.m.') > -1);
},
/**
* remove am and pm from text and return it
*
* @param {String} text
* @return {String}
*/
removeAMPM: function( text ) {
return text.replace('pm', '').replace('p.m.', '').replace('am', '').replace('a.m.', '');
},
/**
* simple test of whether ISO date string is a duration i.e. PY17M or PW12
*
* @param {String} text
* @return {Boolean}
*/
isDuration: function( text ) {
if (modules.utils.isString( text )) {
text = text.toLowerCase();
if (modules.utils.startWith(text, 'p') ) {
return true;
}
}
return false;
},
/**
* is text a time or timezone
* i.e. HH-MM-SS or z+-HH-MM-SS 08:43 | 15:23:00:0567 | 10:34pm | 10:34 p.m. | +01:00:00 | -02:00 | z15:00 | 0843
*
* @param {String} text
* @return {Boolean}
*/
isTime: function( text ) {
if (modules.utils.isString(text)) {
text = text.toLowerCase();
text = modules.utils.trim( text );
// start with timezone char
if ( text.match(':') && ( modules.utils.startWith(text, 'z') || modules.utils.startWith(text, '-') || modules.utils.startWith(text, '+') )) {
return true;
}
// has ante meridiem or post meridiem
if ( text.match(/^[0-9]/) &&
( this.hasAM(text) || this.hasPM(text) )) {
return true;
}
// contains time delimiter but not datetime delimiter
if ( text.match(':') && !text.match(/t|\s/) ) {
return true;
}
// if it's a number of 2, 4 or 6 chars
if (modules.utils.isNumber(text)) {
if (text.length === 2 || text.length === 4 || text.length === 6) {
return true;
}
}
}
return false;
},
/**
* parses a time from text and returns 24hr time string
* i.e. 5:34am = 05:34:00 and 1:52:04p.m. = 13:52:04
*
* @param {String} text
* @return {String}
*/
parseAmPmTime: function( text ) {
var out = text,
times = [];
// if the string has a text : or am or pm
if (modules.utils.isString(out)) {
// text = text.toLowerCase();
text = text.replace(/[ ]+/g, '');
if (text.match(':') || this.hasAM(text) || this.hasPM(text)) {
if (text.match(':')) {
times = text.split(':');
} else {
// single number text i.e. 5pm
times[0] = text;
times[0] = this.removeAMPM(times[0]);
}
// change pm hours to 24hr number
if (this.hasPM(text)) {
if (times[0] < 12) {
times[0] = parseInt(times[0], 10) + 12;
}
}
// add leading zero's where needed
if (times[0] && times[0].length === 1) {
times[0] = '0' + times[0];
}
// rejoin text elements together
if (times[0]) {
text = times.join(':');
}
}
}
// remove am/pm strings
return this.removeAMPM(text);
},
/**
* overlays a time on a date to return the union of the two
*
* @param {String} date
* @param {String} time
* @param {String} format ( Modules.ISODate profile format )
* @return {Object} Modules.ISODate
*/
dateTimeUnion: function(date, time, format) {
var isodate = new modules.ISODate(date, format),
isotime = new modules.ISODate();
isotime.parseTime(this.parseAmPmTime(time), format);
if (isodate.hasFullDate() && isotime.hasTime()) {
isodate.tH = isotime.tH;
isodate.tM = isotime.tM;
isodate.tS = isotime.tS;
isodate.tD = isotime.tD;
return isodate;
}
if (isodate.hasFullDate()) {
return isodate;
}
return new modules.ISODate();
},
/**
* concatenate an array of date and time text fragments to create an ISODate object
* used for microformat value and value-title rules
*
* @param {Array} arr ( Array of Strings )
* @param {String} format ( Modules.ISODate profile format )
* @return {Object} Modules.ISODate
*/
concatFragments: function (arr, format) {
var out = new modules.ISODate(),
i = 0,
value = '';
// if the fragment already contains a full date just return it once
if (arr[0].toUpperCase().match('T')) {
return new modules.ISODate(arr[0], format);
}
for (i = 0; i < arr.length; i++) {
value = arr[i];
// date pattern
if ( value.charAt(4) === '-' && out.hasFullDate() === false ) {
out.parseDate(value);
}
// time pattern
if ( (value.indexOf(':') > -1 || modules.utils.isNumber( this.parseAmPmTime(value) )) && out.hasTime() === false ) {
// split time and timezone
var items = this.splitTimeAndZone(value);
value = items[0];
// parse any use of am/pm
value = this.parseAmPmTime(value);
out.parseTime(value);
// parse any timezone
if (items.length > 1) {
out.parseTimeZone(items[1], format);
}
}
// timezone pattern
if (value.charAt(0) === '-' || value.charAt(0) === '+' || value.toUpperCase() === 'Z') {
if ( out.hasTimeZone() === false ) {
out.parseTimeZone(value);
}
}
}
return out;
},
/**
* parses text by splitting it into an array of time and timezone strings
*
* @param {String} text
* @return {Array} Modules.ISODate
*/
splitTimeAndZone: function ( text ) {
var out = [text],
chars = ['-', '+', 'z', 'Z'],
i = chars.length;
while (i--) {
if (text.indexOf(chars[i]) > -1) {
out[0] = text.slice( 0, text.indexOf(chars[i]) );
out.push( text.slice( text.indexOf(chars[i]) ) );
break;
}
}
return out;
}
};
modules.text = {
// normalised or whitespace or whitespacetrimmed
textFormat: 'whitespacetrimmed',
// block level tags, used to add line returns
blockLevelTags: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'hr', 'pre', 'table',
'address', 'article', 'aside', 'blockquote', 'caption', 'col', 'colgroup', 'dd', 'div',
'dt', 'dir', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'header', 'hgroup', 'hr',
'li', 'map', 'menu', 'nav', 'optgroup', 'option', 'section', 'tbody', 'testarea',
'tfoot', 'th', 'thead', 'tr', 'td', 'ul', 'ol', 'dl', 'details'],
// tags to exclude
excludeTags: ['noframe', 'noscript', 'template', 'script', 'style', 'frames', 'frameset'],
/**
* parses the text from the DOM Node
*
* @param {DOM Node} node
* @param {String} textFormat
* @return {String}
*/
parse: function(doc, node, textFormat) {
var out;
this.textFormat = (textFormat)? textFormat : this.textFormat;
if (this.textFormat === 'normalised') {
out = this.walkTreeForText( node );
if (out !== undefined) {
return this.normalise( doc, out );
}
return '';
}
return this.formatText( doc, modules.domUtils.textContent(node), this.textFormat );
},
/**
* parses the text from a html string
*
* @param {DOM Document} doc
* @param {String} text
* @param {String} textFormat
* @return {String}
*/
parseText: function( doc, text, textFormat ) {
var node = modules.domUtils.createNodeWithText( 'div', text );
return this.parse( doc, node, textFormat );
},
/**
* parses the text from a html string - only for whitespace or whitespacetrimmed formats
*
* @param {String} text
* @param {String} textFormat
* @return {String}
*/
formatText: function( doc, text, textFormat ) {
this.textFormat = (textFormat)? textFormat : this.textFormat;
if (text) {
var out = '',
regex = /(<([^>]+)>)/ig;
out = text.replace(regex, '');
if (this.textFormat === 'whitespacetrimmed') {
out = modules.utils.trimWhitespace( out );
}
// return entities.decode( out, 2 );
return modules.domUtils.decodeEntities( doc, out );
}
return '';
},
/**
* normalises whitespace in given text
*
* @param {String} text
* @return {String}
*/
normalise: function( doc, text ) {
text = text.replace( /&nbsp;/g, ' ') ; // exchanges html entity for space into space char
text = modules.utils.collapseWhiteSpace( text ); // removes linefeeds, tabs and addtional spaces
text = modules.domUtils.decodeEntities( doc, text ); // decode HTML entities
text = text.replace( '–', '-' ); // correct dash decoding
return modules.utils.trim( text );
},
/**
* walks DOM tree parsing the text from DOM Nodes
*
* @param {DOM Node} node
* @return {String}
*/
walkTreeForText: function( node ) {
var out = '',
j = 0;
if (node.tagName && this.excludeTags.indexOf( node.tagName.toLowerCase() ) > -1) {
return out;
}
// if node is a text node get its text
if (node.nodeType && node.nodeType === 3) {
out += modules.domUtils.getElementText( node );
}
// get the text of the child nodes
if (node.childNodes && node.childNodes.length > 0) {
for (j = 0; j < node.childNodes.length; j++) {
var text = this.walkTreeForText( node.childNodes[j] );
if (text !== undefined) {
out += text;
}
}
}
// if it's a block level tag add an additional space at the end
if (node.tagName && this.blockLevelTags.indexOf( node.tagName.toLowerCase() ) !== -1) {
out += ' ';
}
return (out === '')? undefined : out ;
}
};
modules.html = {
// elements which are self-closing
selfClosingElt: ['area', 'base', 'br', 'col', 'hr', 'img', 'input', 'link', 'meta', 'param', 'command', 'keygen', 'source'],
/**
* parse the html string from DOM Node
*
* @param {DOM Node} node
* @return {String}
*/
parse: function( node ) {
var out = '',
j = 0;
// we do not want the outer container
if (node.childNodes && node.childNodes.length > 0) {
for (j = 0; j < node.childNodes.length; j++) {
var text = this.walkTreeForHtml( node.childNodes[j] );
if (text !== undefined) {
out += text;
}
}
}
return out;
},
/**
* walks the DOM tree parsing the html string from the nodes
*
* @param {DOM Document} doc
* @param {DOM Node} node
* @return {String}
*/
walkTreeForHtml: function( node ) {
var out = '',
j = 0;
// if node is a text node get its text
if (node.nodeType && node.nodeType === 3) {
out += modules.domUtils.getElementText( node );
}
// exclude text which has been added with include pattern -
if (node.nodeType && node.nodeType === 1 && modules.domUtils.hasAttribute(node, 'data-include') === false) {
// begin tag
out += '<' + node.tagName.toLowerCase();
// add attributes
var attrs = modules.domUtils.getOrderedAttributes(node);
for (j = 0; j < attrs.length; j++) {
out += ' ' + attrs[j].name + '=' + '"' + attrs[j].value + '"';
}
if (this.selfClosingElt.indexOf(node.tagName.toLowerCase()) === -1) {
out += '>';
}
// get the text of the child nodes
if (node.childNodes && node.childNodes.length > 0) {
for (j = 0; j < node.childNodes.length; j++) {
var text = this.walkTreeForHtml( node.childNodes[j] );
if (text !== undefined) {
out += text;
}
}
}
// end tag
if (this.selfClosingElt.indexOf(node.tagName.toLowerCase()) > -1) {
out += ' />';
} else {
out += '</' + node.tagName.toLowerCase() + '>';
}
}
return (out === '')? undefined : out;
}
};
modules.maps['h-adr'] = {
root: 'adr',
name: 'h-adr',
properties: {
'post-office-box': {},
'street-address': {},
'extended-address': {},
'locality': {},
'region': {},
'postal-code': {},
'country-name': {}
}
};
modules.maps['h-card'] = {
root: 'vcard',
name: 'h-card',
properties: {
'fn': {
'map': 'p-name'
},
'adr': {
'map': 'p-adr',
'uf': ['h-adr']
},
'agent': {
'uf': ['h-card']
},
'bday': {
'map': 'dt-bday'
},
'class': {},
'category': {
'map': 'p-category',
'relAlt': ['tag']
},
'email': {
'map': 'u-email'
},
'geo': {
'map': 'p-geo',
'uf': ['h-geo']
},
'key': {
'map': 'u-key'
},
'label': {},
'logo': {
'map': 'u-logo'
},
'mailer': {},
'honorific-prefix': {},
'given-name': {},
'additional-name': {},
'family-name': {},
'honorific-suffix': {},
'nickname': {},
'note': {}, // could be html i.e. e-note
'org': {},
'p-organization-name': {},
'p-organization-unit': {},
'photo': {
'map': 'u-photo'
},
'rev': {
'map': 'dt-rev'
},
'role': {},
'sequence': {},
'sort-string': {},
'sound': {
'map': 'u-sound'
},
'title': {
'map': 'p-job-title'
},
'tel': {},
'tz': {},
'uid': {
'map': 'u-uid'
},
'url': {
'map': 'u-url'
}
}
};
modules.maps['h-entry'] = {
root: 'hentry',
name: 'h-entry',
properties: {
'entry-title': {
'map': 'p-name'
},
'entry-summary': {
'map': 'p-summary'
},
'entry-content': {
'map': 'e-content'
},
'published': {
'map': 'dt-published'
},
'updated': {
'map': 'dt-updated'
},
'author': {
'uf': ['h-card']
},
'category': {
'map': 'p-category',
'relAlt': ['tag']
},
'geo': {
'map': 'p-geo',
'uf': ['h-geo']
},
'latitude': {},
'longitude': {},
'url': {
'map': 'u-url',
'relAlt': ['bookmark']
}
}
};
modules.maps['h-event'] = {
root: 'vevent',
name: 'h-event',
properties: {
'summary': {
'map': 'p-name'
},
'dtstart': {
'map': 'dt-start'
},
'dtend': {
'map': 'dt-end'
},
'description': {},
'url': {
'map': 'u-url'
},
'category': {
'map': 'p-category',
'relAlt': ['tag']
},
'location': {
'uf': ['h-card']
},
'geo': {
'uf': ['h-geo']
},
'latitude': {},
'longitude': {},
'duration': {
'map': 'dt-duration'
},
'contact': {
'uf': ['h-card']
},
'organizer': {
'uf': ['h-card']},
'attendee': {
'uf': ['h-card']},
'uid': {
'map': 'u-uid'
},
'attach': {
'map': 'u-attach'
},
'status': {},
'rdate': {},
'rrule': {}
}
};
modules.maps['h-feed'] = {
root: 'hfeed',
name: 'h-feed',
properties: {
'category': {
'map': 'p-category',
'relAlt': ['tag']
},
'summary': {
'map': 'p-summary'
},
'author': {
'uf': ['h-card']
},
'url': {
'map': 'u-url'
},
'photo': {
'map': 'u-photo'
},
}
};
modules.maps['h-geo'] = {
root: 'geo',
name: 'h-geo',
properties: {
'latitude': {},
'longitude': {}
}
};
modules.maps['h-item'] = {
root: 'item',
name: 'h-item',
subTree: false,
properties: {
'fn': {
'map': 'p-name'
},
'url': {
'map': 'u-url'
},
'photo': {
'map': 'u-photo'
}
}
};
modules.maps['h-listing'] = {
root: 'hlisting',
name: 'h-listing',
properties: {
'version': {},
'lister': {
'uf': ['h-card']
},
'dtlisted': {
'map': 'dt-listed'
},
'dtexpired': {
'map': 'dt-expired'
},
'location': {},
'price': {},
'item': {
'uf': ['h-card', 'a-adr', 'h-geo']
},
'summary': {
'map': 'p-name'
},
'description': {
'map': 'e-description'
},
'listing': {}
}
};
modules.maps['h-news'] = {
root: 'hnews',
name: 'h-news',
properties: {
'entry': {
'uf': ['h-entry']
},
'geo': {
'uf': ['h-geo']
},
'latitude': {},
'longitude': {},
'source-org': {
'uf': ['h-card']
},
'dateline': {
'uf': ['h-card']
},
'item-license': {
'map': 'u-item-license'
},
'principles': {
'map': 'u-principles',
'relAlt': ['principles']
}
}
};
modules.maps['h-org'] = {
root: 'h-x-org', // drop this from v1 as it causes issue with fn org hcard pattern
name: 'h-org',
childStructure: true,
properties: {
'organization-name': {},
'organization-unit': {}
}
};
modules.maps['h-product'] = {
root: 'hproduct',
name: 'h-product',
properties: {
'brand': {
'uf': ['h-card']
},
'category': {
'map': 'p-category',
'relAlt': ['tag']
},
'price': {},
'description': {
'map': 'e-description'
},
'fn': {
'map': 'p-name'
},
'photo': {
'map': 'u-photo'
},
'url': {
'map': 'u-url'
},
'review': {
'uf': ['h-review', 'h-review-aggregate']
},
'listing': {
'uf': ['h-listing']
},
'identifier': {
'map': 'u-identifier'
}
}
};
modules.maps['h-recipe'] = {
root: 'hrecipe',
name: 'h-recipe',
properties: {
'fn': {
'map': 'p-name'
},
'ingredient': {
'map': 'e-ingredient'
},
'yield': {},
'instructions': {
'map': 'e-instructions'
},
'duration': {
'map': 'dt-duration'
},
'photo': {
'map': 'u-photo'
},
'summary': {},
'author': {
'uf': ['h-card']
},
'published': {
'map': 'dt-published'
},
'nutrition': {},
'category': {
'map': 'p-category',
'relAlt': ['tag']
},
}
};
modules.maps['h-resume'] = {
root: 'hresume',
name: 'h-resume',
properties: {
'summary': {},
'contact': {
'uf': ['h-card']
},
'education': {
'uf': ['h-card', 'h-event']
},
'experience': {
'uf': ['h-card', 'h-event']
},
'skill': {},
'affiliation': {
'uf': ['h-card']
}
}
};
modules.maps['h-review-aggregate'] = {
root: 'hreview-aggregate',
name: 'h-review-aggregate',
properties: {
'summary': {
'map': 'p-name'
},
'item': {
'map': 'p-item',
'uf': ['h-item', 'h-geo', 'h-adr', 'h-card', 'h-event', 'h-product']
},
'rating': {},
'average': {},
'best': {},
'worst': {},
'count': {},
'votes': {},
'category': {
'map': 'p-category',
'relAlt': ['tag']
},
'url': {
'map': 'u-url',
'relAlt': ['self', 'bookmark']
}
}
};
modules.maps['h-review'] = {
root: 'hreview',
name: 'h-review',
properties: {
'summary': {
'map': 'p-name'
},
'description': {
'map': 'e-description'
},
'item': {
'map': 'p-item',
'uf': ['h-item', 'h-geo', 'h-adr', 'h-card', 'h-event', 'h-product']
},
'reviewer': {
'uf': ['h-card']
},
'dtreviewer': {
'map': 'dt-reviewer'
},
'rating': {},
'best': {},
'worst': {},
'category': {
'map': 'p-category',
'relAlt': ['tag']
},
'url': {
'map': 'u-url',
'relAlt': ['self', 'bookmark']
}
}
};
modules.rels = {
// xfn
'friend': [ 'yes', 'external'],
'acquaintance': [ 'yes', 'external'],
'contact': [ 'yes', 'external'],
'met': [ 'yes', 'external'],
'co-worker': [ 'yes', 'external'],
'colleague': [ 'yes', 'external'],
'co-resident': [ 'yes', 'external'],
'neighbor': [ 'yes', 'external'],
'child': [ 'yes', 'external'],
'parent': [ 'yes', 'external'],
'sibling': [ 'yes', 'external'],
'spouse': [ 'yes', 'external'],
'kin': [ 'yes', 'external'],
'muse': [ 'yes', 'external'],
'crush': [ 'yes', 'external'],
'date': [ 'yes', 'external'],
'sweetheart': [ 'yes', 'external'],
'me': [ 'yes', 'external'],
// other rel=*
'license': [ 'yes', 'yes'],
'nofollow': [ 'no', 'external'],
'tag': [ 'no', 'yes'],
'self': [ 'no', 'external'],
'bookmark': [ 'no', 'external'],
'author': [ 'no', 'external'],
'home': [ 'no', 'external'],
'directory': [ 'no', 'external'],
'enclosure': [ 'no', 'external'],
'pronunciation': [ 'no', 'external'],
'payment': [ 'no', 'external'],
'principles': [ 'no', 'external']
};
var External = {
version: modules.version,
livingStandard: modules.livingStandard
};
External.get = function(options) {
var parser = new modules.Parser();
addV1(parser, options);
return parser.get( options );
};
External.getParent = function(node, options) {
var parser = new modules.Parser();
addV1(parser, options);
return parser.getParent( node, options );
};
External.count = function(options) {
var parser = new modules.Parser();
addV1(parser, options);
return parser.count( options );
};
External.isMicroformat = function( node, options ) {
var parser = new modules.Parser();
addV1(parser, options);
return parser.isMicroformat( node, options );
};
External.hasMicroformats = function( node, options ) {
var parser = new modules.Parser();
addV1(parser, options);
return parser.hasMicroformats( node, options );
};
function addV1(parser, options) {
if (options && options.maps) {
if (Array.isArray(options.maps)) {
parser.add(options.maps);
} else {
parser.add([options.maps]);
}
}
}
return External;
}));
try {
// mozilla jsm support
Components.utils.importGlobalProperties(["URL"]);
} catch (e) {}
this.EXPORTED_SYMBOLS = ['Microformats'];
Reference in New Issue View Git Blame Copy Permalink