1 /*

     2 YUI 3.10.3 (build 2fb5187)

     3 Copyright 2013 Yahoo! Inc. All rights reserved.

     4 Licensed under the BSD License.

     5 http://yuilibrary.com/license/

     6 */

     7 

     8 YUI.add('widget-htmlparser', function (Y, NAME) {

     9 

    10 /**

    11  * Adds HTML Parser support to the base Widget class

    12  *

    13  * @module widget

    14  * @submodule widget-htmlparser

    15  * @for Widget

    16  */

    17 

    18 var Widget = Y.Widget,

    19     Node = Y.Node,

    20     Lang = Y.Lang,

    21 

    22     SRC_NODE = "srcNode",

    23     CONTENT_BOX = "contentBox";

    24 

    25 /**

    26  * Object hash, defining how attribute values are to be parsed from

    27  * markup contained in the widget's content box. e.g.:

    28  * <pre>

    29  *   {

    30  *       // Set single Node references using selector syntax

    31  *       // (selector is run through node.one)

    32  *       titleNode: "span.yui-title",

    33  *       // Set NodeList references using selector syntax

    34  *       // (array indicates selector is to be run through node.all)

    35  *       listNodes: ["li.yui-item"],

    36  *       // Set other attribute types, using a parse function.

    37  *       // Context is set to the widget instance.

    38  *       label: function(contentBox) {

    39  *           return contentBox.one("span.title").get("innerHTML");

    40  *       }

    41  *   }

    42  * </pre>

    43  *

    44  * @property HTML_PARSER

    45  * @type Object

    46  * @static

    47  */

    48 Widget.HTML_PARSER = {};

    49 

    50 /**

    51  * The build configuration for the Widget class.

    52  * <p>

    53  * Defines the static fields which need to be aggregated,

    54  * when this class is used as the main class passed to

    55  * the <a href="Base.html#method_build">Base.build</a> method.

    56  * </p>

    57  * @property _buildCfg

    58  * @type Object

    59  * @static

    60  * @final

    61  * @private

    62  */

    63 Widget._buildCfg = {

    64     aggregates : ["HTML_PARSER"]

    65 };

    66 

    67 /**

    68  * The DOM node to parse for configuration values, passed to the Widget's HTML_PARSER definition

    69  *

    70  * @attribute srcNode

    71  * @type String | Node

    72  * @writeOnce

    73  */

    74 Widget.ATTRS[SRC_NODE] = {

    75     value: null,

    76     setter: Node.one,

    77     getter: "_getSrcNode",

    78     writeOnce: true

    79 };

    80 

    81 Y.mix(Widget.prototype, {

    82 

    83     /**

    84      * @method _getSrcNode

    85      * @protected

    86      * @return {Node} The Node to apply HTML_PARSER to

    87      */

    88     _getSrcNode : function(val) {

    89         return val || this.get(CONTENT_BOX);

    90     },

    91 

    92     /**

    93      * @method _applyParsedConfig

    94      * @protected

    95      * @return {Object} The merged configuration literal

    96      */

    97     _applyParsedConfig : function(node, cfg, parsedCfg) {

    98         return (parsedCfg) ? Y.mix(cfg, parsedCfg, false) : cfg;

    99     },

   100 

   101     /**

   102      * Utility method used to apply the <code>HTML_PARSER</code> configuration for the

   103      * instance, to retrieve config data values.

   104      *

   105      * @method _applyParser

   106      * @protected

   107      * @param config {Object} User configuration object (will be populated with values from Node)

   108      */

   109     _applyParser : function(config) {

   110 

   111         var widget = this,

   112             srcNode = this._getNodeToParse(),

   113             schema = widget._getHtmlParser(),

   114             parsedConfig,

   115             val;

   116 

   117         if (schema && srcNode) {

   118             Y.Object.each(schema, function(v, k, o) {

   119                 val = null;

   120 

   121                 if (Lang.isFunction(v)) {

   122                     val = v.call(widget, srcNode);

   123                 } else {

   124                     if (Lang.isArray(v)) {

   125                         val = srcNode.all(v[0]);

   126                         if (val.isEmpty()) {

   127                             val = null;

   128                         }

   129                     } else {

   130                         val = srcNode.one(v);

   131                     }

   132                 }

   133 

   134                 if (val !== null && val !== undefined) {

   135                     parsedConfig = parsedConfig || {};

   136                     parsedConfig[k] = val;

   137                 }

   138             });

   139         }

   140         config = widget._applyParsedConfig(srcNode, config, parsedConfig);

   141     },

   142 

   143     /**

   144      * Determines whether we have a node reference which we should try and parse.

   145      *

   146      * The current implementation does not parse nodes generated from CONTENT_TEMPLATE,

   147      * only explicitly set srcNode, or contentBox attributes.

   148      *

   149      * @method _getNodeToParse

   150      * @return {Node} The node reference to apply HTML_PARSER to.

   151      * @private

   152      */

   153     _getNodeToParse : function() {

   154         var srcNode = this.get("srcNode");

   155         return (!this._cbFromTemplate) ? srcNode : null;

   156     },

   157 

   158     /**

   159      * Gets the HTML_PARSER definition for this instance, by merging HTML_PARSER

   160      * definitions across the class hierarchy.

   161      *

   162      * @private

   163      * @method _getHtmlParser

   164      * @return {Object} HTML_PARSER definition for this instance

   165      */

   166     _getHtmlParser : function() {

   167         // Removed caching for kweight. This is a private method

   168         // and only called once so don't need to cache HTML_PARSER

   169         var classes = this._getClasses(),

   170             parser = {},

   171             i, p;

   172 

   173         for (i = classes.length - 1; i >= 0; i--) {

   174             p = classes[i].HTML_PARSER;

   175             if (p) {

   176                 Y.mix(parser, p, true);

   177             }

   178         }

   179         return parser;

   180     }

   181 });

   182 

   183 

   184 }, '3.10.3', {"requires": ["widget-base"]});