@extjs/sencha-cmd-linux-32/dist/js/node_modules/fashion/src/Visitor.js

Productivity and performance optimization tool for building applications with Sencha Ext JS and Sencha Touch.

"use strict";

var Fashion = require('./export/Base.js'),
    Base = Fashion.Base;

class Visitor extends Base {

    constructor(config) {
        super(config);
        this.nodeStack = [];
    }

    visitComments(docs) {
        for (var d = 0; d < docs.length; d++) {
            this.Comment(docs[d]);
        }
    }

    visitItem(obj) {
        if (obj.docs && obj.docs.length) {
            this.visitComments(obj.docs);
        }
        obj.doVisit(this);
    }

    visit(obj) {
        while (obj && (obj.visitTarget !== undefined)) {
            obj = obj.visitTarget
        }
        if (obj) {
            if (Array.isArray(obj)) {
                for (var i = 0; i < obj.length; i++) {
                    this.visit(obj[i]);
                }
                return;
            }
            this.nodeStack.push(obj);
            this.visitItem(obj);
            this.nodeStack.pop();
        }
    }

    Comment(comment) {

    }

    /*
     visitEach (node, handlers) {
     this.visit(node.variable, handlers);
     this.visit(node.list, handlers);
     this.visit(node.statements, handlers);
     }

     visitFor (node, handlers) {
     this.visit(node.variable, handlers);
     this.visit(node.start, handlers);
     this.visit(node.end, handlers);
     this.visit(node.statements, handlers);
     }

     visitFunction (node, handlers) {
     this.visit(node.func, handlers);
     this.visit(node.statements, handlers);
     }

     visitRuleset (node, handlers) {
     this.visit(node.selectors, handlers);
     this.visit(node.statements, handlers);
     }

     visitMixin (node, handlers) {
     this.visit(node.name, handlers);
     this.visit(node.statements, handlers);
     }

     visitInclude (node, handlers) {
     this.visit(node.include, handlers);
     }

     visitDeclaration (node, handlers) {
     this.visit(node.property, handlers);
     this.visit(node.value, handlers);
     }

     visitVariableAssignment (node, handlers) {
     this.visit(node.value, handlers);
     }

     visitIf (node, handlers) {
     this.visit(node.condition, handlers);
     this.visit(node.statements, handlers);
     }

     visitElse (node, handlers) {
     this.visit(node.condition, handlers);
     this.visit(node.statements, handlers);
     }

     visitReturn (node, handlers) {
     this.visit(node.expr, handlers);
     }

     visitParenthetical (node, handlers) {
     this.visit(node.expr, handlers);
     }

     visitSelectorPart (node, handlers) {
     this.visit(node.value, handlers);
     }

     visitSelectorProperty(node, handlers) {
     this.visit(node.property, handlers);
     this.visit(node.value, handlers);
     }

     visitCompoundSelector(node, handlers) {
     this.visit(node.items, handlers);
     }

     visitMultiPartSelector(node, handlers) {
     this.visit(node.items, handlers);
     }

     visitSelectorList(node, handlers) {
     this.visit(node.items, handlers);
     }

     visitBinaryExpression (node, handlers) {
     this.visit(node.left, handlers);
     this.visit(node.right, handlers);
     }

     visitUnaryExpression (node, handlers) {
     this.visit(node.expr, handlers);
     }

     visitVariable (node, handlers) {
     // no child nodes to descend
     }

     visitConstant (node, handlers) {
     // no child nodes to descend
     }

     visitFunctionCall (node, handlers) {
     this.visit(node.args, handlers);
     }

     visitExtend (node, handlers) {
     // no child nodes to descend
     }

     visitList (node, handlers) {
     this.visit(node.items, handlers);
     }

     visitWarn (node, handlers) {
     // no child nodes to descend
     }

     visitImport (node, handlers) {
     this.visit(node.source, handlers);
     }

     visitRequire (node, handlers) {
     this.visit(node.source, handlers);
     }

     visitDebugger (node, handlers) {
     // no child nodes
     }
     */

    Each(obj) {
        obj.descend(this);
    }

    For(obj) {
        obj.descend(this);
    }

    While(obj) {
        obj.descend(this);
    }

    Charset(obj) {
        obj.descend(this);
    }

    Function(obj) {
        obj.descend(this);
    }

    Ruleset(obj) {
        obj.descend(this);
    }

    Mixin(obj) {
        obj.descend(this);
    }

    Block(obj) {
        obj.descend(this);
    }

    Include(obj) {
        obj.descend(this);
    }

    Declaration(obj) {
        obj.descend(this);
    }

    VariableAssignment(obj) {
        obj.descend(this);
    }

    Assignment(obj) {
        obj.descend(this);
    }

    If(obj) {
        obj.descend(this);
    }

    Else(obj) {
        obj.descend(this);
    }

    Return(obj) {
        obj.descend(this);
    }

    ParentheticalExpression(obj) {
        obj.descend(this);
    }

    SelectorPart(obj) {
        obj.descend(this);
    }

    SelectorProperty(obj) {
        obj.descend(this);
    }

    CompoundSelector(obj) {
        obj.descend(this);
    }

    MultiPartSelector(obj) {
        obj.descend(this);
    }

    SelectorList(obj) {
        obj.descend(this);
    }

    BinaryExpression(obj) {
        obj.descend(this);
    }

    UnaryExpression(obj) {
        obj.descend(this);
    }

    Variable(obj) {
        obj.descend(this);
    }

    Constant(obj) {
        obj.descend(this);
    }

    FunctionCall(obj) {
        obj.descend(this);
    }

    Extend(obj) {
        obj.descend(this);
    }

    List(obj) {
        obj.descend(this);
    }

    Warn(obj) {
        obj.descend(this);
    }

    Error(obj) {
        obj.descend(this);
    }

    Import(obj) {
        obj.descend(this);
    }

    Require(obj) {
        obj.descend(this);
    }

    Content(obj) {
        obj.descend(this);
    }

    Debugger(obj) {
        obj.descend(this);
    }

    Debug(obj) {
        obj.descend(this);
    }
}

Fashion.apply(Visitor.prototype, {
    nodeStack: null,
    skipBranching: false
});

module.exports = Visitor;