com.google.common.css.compiler.passes.UniformVisitor Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of closure-stylesheets Show documentation
Show all versions of closure-stylesheets Show documentation
Closure Stylesheets is an extension to CSS that adds variables,
functions,
conditionals, and mixins to standard CSS. The tool also supports
minification, linting, RTL flipping, and CSS class renaming.
/*
* Copyright 2012 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.common.css.compiler.passes;
import com.google.common.css.compiler.ast.CssAttributeSelectorNode;
import com.google.common.css.compiler.ast.CssBlockNode;
import com.google.common.css.compiler.ast.CssClassSelectorNode;
import com.google.common.css.compiler.ast.CssCombinatorNode;
import com.google.common.css.compiler.ast.CssComponentNode;
import com.google.common.css.compiler.ast.CssCompositeValueNode;
import com.google.common.css.compiler.ast.CssConditionalBlockNode;
import com.google.common.css.compiler.ast.CssConditionalRuleNode;
import com.google.common.css.compiler.ast.CssDeclarationBlockNode;
import com.google.common.css.compiler.ast.CssDeclarationNode;
import com.google.common.css.compiler.ast.CssDefinitionNode;
import com.google.common.css.compiler.ast.CssFontFaceNode;
import com.google.common.css.compiler.ast.CssForLoopRuleNode;
import com.google.common.css.compiler.ast.CssFunctionNode;
import com.google.common.css.compiler.ast.CssIdSelectorNode;
import com.google.common.css.compiler.ast.CssImportBlockNode;
import com.google.common.css.compiler.ast.CssImportRuleNode;
import com.google.common.css.compiler.ast.CssKeyListNode;
import com.google.common.css.compiler.ast.CssKeyNode;
import com.google.common.css.compiler.ast.CssKeyframeRulesetNode;
import com.google.common.css.compiler.ast.CssKeyframesNode;
import com.google.common.css.compiler.ast.CssMediaRuleNode;
import com.google.common.css.compiler.ast.CssMixinDefinitionNode;
import com.google.common.css.compiler.ast.CssMixinNode;
import com.google.common.css.compiler.ast.CssNode;
import com.google.common.css.compiler.ast.CssNodesListNode;
import com.google.common.css.compiler.ast.CssPageRuleNode;
import com.google.common.css.compiler.ast.CssPageSelectorNode;
import com.google.common.css.compiler.ast.CssPropertyValueNode;
import com.google.common.css.compiler.ast.CssProvideNode;
import com.google.common.css.compiler.ast.CssPseudoClassNode;
import com.google.common.css.compiler.ast.CssPseudoElementNode;
import com.google.common.css.compiler.ast.CssRequireNode;
import com.google.common.css.compiler.ast.CssRootNode;
import com.google.common.css.compiler.ast.CssRulesetNode;
import com.google.common.css.compiler.ast.CssSelectorListNode;
import com.google.common.css.compiler.ast.CssSelectorNode;
import com.google.common.css.compiler.ast.CssTreeVisitor;
import com.google.common.css.compiler.ast.CssUnknownAtRuleNode;
import com.google.common.css.compiler.ast.CssValueNode;
/**
* A visitor with a pair of operations (enter and leave) that
* apply to every node type.
*/
public class UniformVisitor implements CssTreeVisitor {
public void enter(CssNode node) {}
public void leave(CssNode node) {}
@Override
public boolean enterConditionalRule(CssConditionalRuleNode node) {
enter(node);
return true;
}
/** Called after visiting a {@code CssConditionalRuleNode}'s sub trees */
@Override
public void leaveConditionalRule(CssConditionalRuleNode node) {
leave(node);
}
/** Called before visiting a {@code CssImportRuleNode}'s sub trees */
@Override
public boolean enterImportRule(CssImportRuleNode node) {
enter(node);
return true;
}
/** Called after visiting a {@code CssImportRuleNode}'s sub trees */
@Override
public void leaveImportRule(CssImportRuleNode node) {
leave(node);
}
/** Called before visiting a {@code CssMediaRuleNode}'s sub trees */
@Override
public boolean enterMediaRule(CssMediaRuleNode node) {
enter(node);
return true;
}
/** Called after visiting a {@code CssMediaRuleNode}'s sub trees */
@Override
public void leaveMediaRule(CssMediaRuleNode node) {
leave(node);
}
/** Called before visiting a {@code CssPageRuleNode}'s sub trees */
@Override
public boolean enterPageRule(CssPageRuleNode node) {
enter(node);
return true;
}
/** Called after visiting a {@code CssPageRuleNode}'s sub trees */
@Override
public void leavePageRule(CssPageRuleNode node) {
leave(node);
}
/** Called before visiting a {@code CssPageSelectorNode}'s sub trees */
@Override
public boolean enterPageSelector(CssPageSelectorNode node) {
enter(node);
return true;
}
/** Called after visiting a {@code CssPageSelectorNode}'s sub trees */
@Override
public void leavePageSelector(CssPageSelectorNode node) {
leave(node);
}
/** Called before visiting a {@code CssFontFaceNode}'s sub trees */
@Override
public boolean enterFontFace(CssFontFaceNode node) {
enter(node);
return true;
}
/** Called after visiting a {@code CssFontFaceNode}'s sub trees */
@Override
public void leaveFontFace(CssFontFaceNode node) {
leave(node);
}
/**
* @return {@code true} if the contents of the rule should be visited,
* false otherwise. {@link #leaveDefinition(CssDefinitionNode)}
* will still be called.
*/
@Override
public boolean enterDefinition(CssDefinitionNode node) {
enter(node);
return true;
}
/** Called after visiting a {@code CssDefinitionNode}'s sub trees */
@Override
public void leaveDefinition(CssDefinitionNode node) {
leave(node);
}
/** Called before visiting a {@code CssUnknownAtRuleNode}'s sub trees */
@Override
public boolean enterUnknownAtRule(CssUnknownAtRuleNode node) {
enter(node);
return true;
}
/** Called after visiting a {@code CssUnknownAtRuleNode}'s sub trees */
@Override
public void leaveUnknownAtRule(CssUnknownAtRuleNode node) {
leave(node);
}
/** Called between adjacent nodes in a media type list */
@Override
public boolean enterMediaTypeListDelimiter(
CssNodesListNode node) {
// this very special state does not represent a node
return true;
}
/** Called between adjacent nodes in a media type list */
@Override
public void leaveMediaTypeListDelimiter(
CssNodesListNode node) {
// this very special state does not represent a node
}
/** Called before visiting a {@code CssComponentNode}'s sub trees */
@Override
public boolean enterComponent(CssComponentNode node) {
enter(node);
return true;
}
/** Called after visiting a {@code CssComponentNode}'s sub trees */
@Override
public void leaveComponent(CssComponentNode node) {
leave(node);
}
/** Called before visiting a {@code CssKeyframesNode}'s sub trees */
@Override
public boolean enterKeyframesRule(CssKeyframesNode node) {
enter(node);
return true;
}
/** Called after visiting a {@code CssKeyframesNode}'s sub trees */
@Override
public void leaveKeyframesRule(CssKeyframesNode node) {
leave(node);
}
/** Called before visiting a {@code CssMixinDefinitionNode}'s sub trees */
@Override
public boolean enterMixinDefinition(CssMixinDefinitionNode node) {
enter(node);
return true;
}
/** Called after visiting a {@code CssMixinDefinitionNode}'s sub trees */
@Override
public void leaveMixinDefinition(CssMixinDefinitionNode node) {
leave(node);
}
/** Called before visiting a {@code CssMixinNode}'s sub trees */
@Override
public boolean enterMixin(CssMixinNode node) {
enter(node);
return true;
}
/** Called after visiting a {@code CssMixinNode}'s sub trees */
@Override
public void leaveMixin(CssMixinNode node) {
leave(node);
}
/** Called before visiting a {@code CssRootNode}'s sub trees */
@Override
public boolean enterTree(CssRootNode root) {
enter(root);
return true;
}
/** Called after visiting a {@code CssRootNode}'s sub trees */
@Override
public void leaveTree(CssRootNode root) {
leave(root);
}
/** Called before visiting a {@code CssImportBlockNode}'s sub trees */
@Override
public boolean enterImportBlock(CssImportBlockNode block) {
enter(block);
return true;
}
/** Called after visiting a {@code CssImportBlockNode}'s sub trees */
@Override
public void leaveImportBlock(CssImportBlockNode block) {
leave(block);
}
/** Called before visiting a {@code CssBlockNode}'s sub trees */
@Override
public boolean enterBlock(CssBlockNode block) {
enter(block);
return true;
}
/** Called after visiting a {@code CssBlockNode}'s sub trees */
@Override
public void leaveBlock(CssBlockNode block) {
leave(block);
}
/** Called before visiting a {@code CssConditionalBlockNode}'s sub trees */
@Override
public boolean enterConditionalBlock(CssConditionalBlockNode block) {
enter(block);
return true;
}
/** Called after visiting a {@code CssConditionalBlockNode}'s sub trees */
@Override
public void leaveConditionalBlock(CssConditionalBlockNode block) {
leave(block);
}
/** Called before visiting a {@code CssDeclarationBlockNode}'s sub trees */
@Override
public boolean enterDeclarationBlock(CssDeclarationBlockNode block) {
enter(block);
return true;
}
/** Called after visiting a {@code CssDeclarationBlockNode}'s sub trees */
@Override
public void leaveDeclarationBlock(CssDeclarationBlockNode block) {
leave(block);
}
/**
* Called before visiting a {@code CssRulesetNode}'s sub trees.
*
* @return whether ruleset children should be visited
*/
@Override
public boolean enterRuleset(CssRulesetNode ruleset) {
enter(ruleset);
return true;
}
/** Called after visiting a {@code CssRulesetNode}'s sub trees */
@Override
public void leaveRuleset(CssRulesetNode ruleset) {
leave(ruleset);
}
/** Called before visiting a {@code CssSelectorListNode}'s sub trees */
@Override
public boolean enterSelectorBlock(CssSelectorListNode block) {
enter(block);
return true;
}
/** Called after visiting a {@code CssSelectorListNode}'s sub trees */
@Override
public void leaveSelectorBlock(CssSelectorListNode block) {
leave(block);
}
/** Called before visiting a {@code CssDeclarationNode}'s sub trees */
@Override
public boolean enterDeclaration(CssDeclarationNode declaration) {
enter(declaration);
return true;
}
/** Called after visiting a {@code CssDeclarationNode}'s sub trees */
@Override
public void leaveDeclaration(CssDeclarationNode declaration) {
leave(declaration);
}
/** Called before visiting a {@code CssSelectorNode}'s sub trees */
@Override
public boolean enterSelector(CssSelectorNode selector) {
enter(selector);
return true;
}
/** Called after visiting a {@code CssSelectorNode}'s sub trees */
@Override
public void leaveSelector(CssSelectorNode selector) {
leave(selector);
}
/** Called before visiting a {@code CssClassSelectorNode}'s sub trees */
@Override
public boolean enterClassSelector(CssClassSelectorNode classSelector) {
enter(classSelector);
return true;
}
/** Called after visiting a {@code CssClassSelectorNode}'s sub trees */
@Override
public void leaveClassSelector(CssClassSelectorNode classSelector) {
leave(classSelector);
}
/** Called before visiting a {@code CssIdSelectorNode}'s sub trees */
@Override
public boolean enterIdSelector(CssIdSelectorNode idSelector) {
enter(idSelector);
return true;
}
/** Called after visiting a {@code CssIdSelectorNode}'s sub trees */
@Override
public void leaveIdSelector(CssIdSelectorNode idSelector) {
leave(idSelector);
}
/** Called before visiting a {@code CssPseudoClassNode}'s sub trees */
@Override
public boolean enterPseudoClass(CssPseudoClassNode pseudoClass) {
enter(pseudoClass);
return true;
}
/** Called after visiting a {@code CssPseudoClassNode}'s sub trees */
@Override
public void leavePseudoClass(CssPseudoClassNode pseudoClass) {
leave(pseudoClass);
}
/** Called before visiting a {@code CssPseudoElementNode}'s sub trees */
@Override
public boolean enterPseudoElement(CssPseudoElementNode pseudoElement) {
enter(pseudoElement);
return true;
}
/** Called after visiting a {@code CssPseudoElementNode}'s sub trees */
@Override
public void leavePseudoElement(CssPseudoElementNode pseudoElement) {
leave(pseudoElement);
}
/** Called before visiting a {@code CssAttributeSelectorNode}'s sub trees */
@Override
public boolean enterAttributeSelector(CssAttributeSelectorNode attributeSelector) {
enter(attributeSelector);
return true;
}
/** Called after visiting a {@code CssAttributeSelectorNode}'s sub trees */
@Override
public void leaveAttributeSelector(CssAttributeSelectorNode attributeSelector) {
leave(attributeSelector);
}
/** Called before visiting a {@code CssPropertyValueNode}'s sub trees */
@Override
public boolean enterPropertyValue(CssPropertyValueNode propertyValue) {
enter(propertyValue);
return true;
}
/** Called after visiting a {@code CssPropertyValueNode}'s sub trees */
@Override
public void leavePropertyValue(CssPropertyValueNode propertyValue) {
leave(propertyValue);
}
/** Called before visiting a {@code CssValueNode} that is a
{@code CssCompositeValueNode} */
@Override
public boolean enterCompositeValueNode(CssCompositeValueNode value) {
enter(value);
return true;
}
/** Called after visiting a {@code CssValueNode} that is a
{@code CssCompositeValueNode} */
@Override
public void leaveCompositeValueNode(CssCompositeValueNode value) {
leave(value);
}
/** Called between values in a {@code CssCompositeValueNode} */
@Override
public boolean enterCompositeValueNodeOperator(
CssCompositeValueNode parent) {
// this very special state does not represent a node
return true;
}
/** Called between values in a {@code CssCompositeValueNode} */
@Override
public void leaveCompositeValueNodeOperator(CssCompositeValueNode parent) {
}
/** Called before visiting a {@code CssFunctionNode}'s sub trees */
@Override
public boolean enterFunctionNode(CssFunctionNode value) {
enter(value);
return true;
}
/** Called after visiting a {@code CssFunctionNode}'s sub trees. */
@Override
public void leaveFunctionNode(CssFunctionNode value) {
leave(value);
}
/** Called before visiting a {@code CssFunctionNode}'s sub trees */
@Override
public boolean enterArgumentNode(CssValueNode value) {
enter(value);
return true;
}
/** Called after visiting a {@code CssFunctionNode}'s sub trees. */
@Override
public void leaveArgumentNode(CssValueNode value) {
leave(value);
}
/** Called before visiting a {@code CssCombinatorNode}'s sub trees */
@Override
public boolean enterCombinator(CssCombinatorNode combinator) {
enter(combinator);
return true;
}
/** Called after visiting a {@code CssCombinatorNode}'s sub trees */
@Override
public void leaveCombinator(CssCombinatorNode combinator) {
leave(combinator);
}
/** Called before visiting a {@code CssKeyNode}'s sub trees */
@Override
public boolean enterKey(CssKeyNode key) {
enter(key);
return true;
}
/** Called after visiting a {@code CssKeyNode}'s sub trees */
@Override
public void leaveKey(CssKeyNode key) {
leave(key);
}
/** Called before visiting a {@code CssKeyListNode}'s sub trees */
@Override
public boolean enterKeyBlock(CssKeyListNode block) {
enter(block);
return true;
}
/** Called after visiting a {@code CssKeyListNode}'s sub trees */
@Override
public void leaveKeyBlock(CssKeyListNode block) {
leave(block);
}
/** Called before visiting a {@code CssKeyframeRulesetNode}'s sub trees */
@Override
public boolean enterKeyframeRuleset(CssKeyframeRulesetNode key) {
enter(key);
return true;
}
/** Called after visiting a {@code CssKeyframeRulesetNode}'s sub trees */
@Override
public void leaveKeyframeRuleset(CssKeyframeRulesetNode key) {
leave(key);
}
@Override
public boolean enterValueNode(CssValueNode n) {
enter(n);
return true;
}
@Override
public void leaveValueNode(CssValueNode n) {
leave(n);
}
@Override
public boolean enterForLoop(CssForLoopRuleNode node) {
enter(node);
return true;
}
@Override
public void leaveForLoop(CssForLoopRuleNode node) {
leave(node);
}
/** Traverse the (sub) tree starting at {@code node} */
@Override
public void visit(CssNode node) {}
/** Called before visiting a {@code CssProvideNode} */
@Override
public boolean enterProvideNode(CssProvideNode node) {
enter(node);
return true;
}
/** Called after visiting a {@code CssProvideNode} */
@Override
public void leaveProvideNode(CssProvideNode node) {
leave(node);
}
/** Called before visiting a {@code CssRequireNode} */
@Override
public boolean enterRequireNode(CssRequireNode node) {
enter(node);
return true;
}
/** Called after visiting a {@code CssRequireNode} */
@Override
public void leaveRequireNode(CssRequireNode node) {
leave(node);
}
}