Version 3.18.1
Show:

File: widget/js/WidgetHTMLParser.js

            /**
             * Adds HTML Parser support to the base Widget class
             *
             * @module widget
             * @submodule widget-htmlparser
             * @for Widget
             */
            
            var Widget = Y.Widget,
                Node = Y.Node,
                Lang = Y.Lang,
            
                SRC_NODE = "srcNode",
                CONTENT_BOX = "contentBox";
            
            /**
             * Object hash, defining how attribute values are to be parsed from
             * markup contained in the widget's content box. e.g.:
             * <pre>
             *   {
             *       // Set single Node references using selector syntax
             *       // (selector is run through node.one)
             *       titleNode: "span.yui-title",
             *       // Set NodeList references using selector syntax
             *       // (array indicates selector is to be run through node.all)
             *       listNodes: ["li.yui-item"],
             *       // Set other attribute types, using a parse function.
             *       // Context is set to the widget instance.
             *       label: function(contentBox) {
             *           return contentBox.one("span.title").get("innerHTML");
             *       }
             *   }
             * </pre>
             *
             * @property HTML_PARSER
             * @type Object
             * @static
             */
            Widget.HTML_PARSER = {};
            
            /**
             * The build configuration for the Widget class.
             * <p>
             * Defines the static fields which need to be aggregated,
             * when this class is used as the main class passed to
             * the <a href="Base.html#method_build">Base.build</a> method.
             * </p>
             * @property _buildCfg
             * @type Object
             * @static
             * @final
             * @private
             */
            Widget._buildCfg = {
                aggregates : ["HTML_PARSER"]
            };
            
            /**
             * The DOM node to parse for configuration values, passed to the Widget's HTML_PARSER definition
             *
             * @attribute srcNode
             * @type String | Node
             * @writeOnce
             */
            Widget.ATTRS[SRC_NODE] = {
                value: null,
                setter: Node.one,
                getter: "_getSrcNode",
                writeOnce: true
            };
            
            Y.mix(Widget.prototype, {
            
                /**
                 * @method _getSrcNode
                 * @protected
                 * @return {Node} The Node to apply HTML_PARSER to
                 */
                _getSrcNode : function(val) {
                    return val || this.get(CONTENT_BOX);
                },
            
                /**
                 * Implement the BaseCore _preAddAttrs method hook, to add
                 * the srcNode and related attributes, so that HTML_PARSER
                 * (which relies on `this.get("srcNode")`) can merge in it's
                 * results before the rest of the attributes are added.
                 *
                 * @method _preAddAttrs
                 * @protected
                 *
                 * @param attrs {Object} The full hash of statically defined ATTRS
                 * attributes being added for this instance
                 *
                 * @param userVals {Object} The hash of user values passed to
                 * the constructor
                 *
                 * @param lazy {boolean} Whether or not to add the attributes lazily
                 */
                _preAddAttrs : function(attrs, userVals, lazy) {
            
                    var preAttrs = {
                        id : attrs.id,
                        boundingBox : attrs.boundingBox,
                        contentBox : attrs.contentBox,
                        srcNode : attrs.srcNode
                    };
            
                    this.addAttrs(preAttrs, userVals, lazy);
            
                    delete attrs.boundingBox;
                    delete attrs.contentBox;
                    delete attrs.srcNode;
                    delete attrs.id;
            
                    if (this._applyParser) {
                        this._applyParser(userVals);
                    }
                },
            
                /**
                 * @method _applyParsedConfig
                 * @protected
                 * @return {Object} The merged configuration literal
                 */
                _applyParsedConfig : function(node, cfg, parsedCfg) {
                    return (parsedCfg) ? Y.mix(cfg, parsedCfg, false) : cfg;
                },
            
                /**
                 * Utility method used to apply the <code>HTML_PARSER</code> configuration for the
                 * instance, to retrieve config data values.
                 *
                 * @method _applyParser
                 * @protected
                 * @param config {Object} User configuration object (will be populated with values from Node)
                 */
                _applyParser : function(config) {
            
                    var widget = this,
                        srcNode = this._getNodeToParse(),
                        schema = widget._getHtmlParser(),
                        parsedConfig,
                        val;
            
                    if (schema && srcNode) {
                        Y.Object.each(schema, function(v, k, o) {
                            val = null;
            
                            if (Lang.isFunction(v)) {
                                val = v.call(widget, srcNode);
                            } else {
                                if (Lang.isArray(v)) {
                                    val = srcNode.all(v[0]);
                                    if (val.isEmpty()) {
                                        val = null;
                                    }
                                } else {
                                    val = srcNode.one(v);
                                }
                            }
            
                            if (val !== null && val !== undefined) {
                                parsedConfig = parsedConfig || {};
                                parsedConfig[k] = val;
                            }
                        });
                    }
                    config = widget._applyParsedConfig(srcNode, config, parsedConfig);
                },
            
                /**
                 * Determines whether we have a node reference which we should try and parse.
                 *
                 * The current implementation does not parse nodes generated from CONTENT_TEMPLATE,
                 * only explicitly set srcNode, or contentBox attributes.
                 *
                 * @method _getNodeToParse
                 * @return {Node} The node reference to apply HTML_PARSER to.
                 * @private
                 */
                _getNodeToParse : function() {
                    var srcNode = this.get("srcNode");
                    return (!this._cbFromTemplate) ? srcNode : null;
                },
            
                /**
                 * Gets the HTML_PARSER definition for this instance, by merging HTML_PARSER
                 * definitions across the class hierarchy.
                 *
                 * @private
                 * @method _getHtmlParser
                 * @return {Object} HTML_PARSER definition for this instance
                 */
                _getHtmlParser : function() {
                    // Removed caching for kweight. This is a private method
                    // and only called once so don't need to cache HTML_PARSER
                    var classes = this._getClasses(),
                        parser = {},
                        i, p;
            
                    for (i = classes.length - 1; i >= 0; i--) {
                        p = classes[i].HTML_PARSER;
                        if (p) {
                            Y.mix(parser, p, true);
                        }
                    }
                    return parser;
                }
            });