Current File : //lib/python3/dist-packages/css_parser/css/cssvariablesrule.py
from __future__ import unicode_literals, division, absolute_import, print_function
import xml.dom
import css_parser
from . import cssrule
from .cssvariablesdeclaration import CSSVariablesDeclaration
"""CSSVariables implements (and only partly) experimental
`CSS Variables <http://disruptive-innovations.com/zoo/cssvariables/>`_
"""
__all__ = ['CSSVariablesRule']
__docformat__ = 'restructuredtext'
__version__ = '$Id: cssfontfacerule.py 1818 2009-07-30 21:39:00Z cthedot $'
import sys
if sys.version_info[0] >= 3:
string_type = str
else:
string_type = basestring
class CSSVariablesRule(cssrule.CSSRule):
"""
The CSSVariablesRule interface represents a @variables rule within a CSS
style sheet. The @variables rule is used to specify variables.
css_parser uses a :class:`~css_parser.css.CSSVariablesDeclaration` to
represent the variables.
Format::
variables
VARIABLES_SYM S* medium [ COMMA S* medium ]* LBRACE S*
variableset* '}' S*
;
for variableset see :class:`css_parser.css.CSSVariablesDeclaration`
**Media are not implemented. Reason is that css_parser is using CSS
variables in a kind of preprocessing and therefor no media information
is available at this stage. For now do not use media!**
Example::
@variables {
CorporateLogoBGColor: #fe8d12;
}
div.logoContainer {
background-color: var(CorporateLogoBGColor);
}
"""
def __init__(self, mediaText=None, variables=None, parentRule=None,
parentStyleSheet=None, readonly=False):
"""
If readonly allows setting of properties in constructor only.
"""
super(CSSVariablesRule, self).__init__(parentRule=parentRule,
parentStyleSheet=parentStyleSheet)
self._atkeyword = '@variables'
# dummy
self._media = css_parser.stylesheets.MediaList(mediaText, readonly=readonly)
if variables:
self.variables = variables
else:
self.variables = CSSVariablesDeclaration(parentRule=self)
self._readonly = readonly
def __repr__(self):
return "css_parser.css.%s(mediaText=%r, variables=%r)" % (
self.__class__.__name__,
self._media.mediaText,
self.variables.cssText)
def __str__(self):
return "<css_parser.css.%s object mediaText=%r variables=%r valid=%r " \
"at 0x%x>" % (self.__class__.__name__,
self._media.mediaText,
self.variables.cssText,
self.valid,
id(self))
def _getCssText(self):
"""Return serialized property cssText."""
return css_parser.ser.do_CSSVariablesRule(self)
def _setCssText(self, cssText):
"""
:exceptions:
- :exc:`~xml.dom.SyntaxErr`:
Raised if the specified CSS string value has a syntax error and
is unparsable.
- :exc:`~xml.dom.InvalidModificationErr`:
Raised if the specified CSS string value represents a different
type of rule than the current one.
- :exc:`~xml.dom.HierarchyRequestErr`:
Raised if the rule cannot be inserted at this point in the
style sheet.
- :exc:`~xml.dom.NoModificationAllowedErr`:
Raised if the rule is readonly.
Format::
variables
: VARIABLES_SYM S* medium [ COMMA S* medium ]* LBRACE S*
variableset* '}' S*
;
variableset
: LBRACE S* vardeclaration [ ';' S* vardeclaration ]* '}' S*
;
"""
super(CSSVariablesRule, self)._setCssText(cssText)
tokenizer = self._tokenize2(cssText)
attoken = self._nexttoken(tokenizer, None)
if self._type(attoken) != self._prods.VARIABLES_SYM:
self._log.error('CSSVariablesRule: No CSSVariablesRule found: %s' %
self._valuestr(cssText),
error=xml.dom.InvalidModificationErr)
else:
newVariables = CSSVariablesDeclaration(parentRule=self)
ok = True
beforetokens, brace = self._tokensupto2(tokenizer,
blockstartonly=True,
separateEnd=True)
if self._tokenvalue(brace) != '{':
ok = False
self._log.error('CSSVariablesRule: No start { of variable '
'declaration found: %r'
% self._valuestr(cssText), brace)
# parse stuff before { which should be comments and S only
new = {'wellformed': True}
newseq = self._tempSeq() # []
beforewellformed, expected = self._parse(expected=':',
seq=newseq, tokenizer=self._tokenize2(beforetokens),
productions={})
ok = ok and beforewellformed and new['wellformed']
variablestokens, braceorEOFtoken = self._tokensupto2(tokenizer,
blockendonly=True,
separateEnd=True)
val, type_ = self._tokenvalue(braceorEOFtoken), \
self._type(braceorEOFtoken)
if val != '}' and type_ != 'EOF':
ok = False
self._log.error('CSSVariablesRule: No "}" after variables '
'declaration found: %r'
% self._valuestr(cssText))
nonetoken = self._nexttoken(tokenizer)
if nonetoken:
ok = False
self._log.error('CSSVariablesRule: Trailing content found.',
token=nonetoken)
if 'EOF' == type_:
# add again as variables needs it
variablestokens.append(braceorEOFtoken)
# SET but may raise:
newVariables.cssText = variablestokens
if ok:
# contains probably comments only upto {
self._setSeq(newseq)
self.variables = newVariables
cssText = property(_getCssText, _setCssText,
doc="(DOM) The parsable textual representation of this "
"rule.")
media = property(doc="NOT IMPLEMENTED! As css_parser resolves variables "
"during serializing media information is lost.")
def _setVariables(self, variables):
"""
:param variables:
a CSSVariablesDeclaration or string
"""
self._checkReadonly()
# Under Pythoin 2.x this was basestring but ...
if isinstance(variables, string_type):
self._variables = CSSVariablesDeclaration(cssText=variables,
parentRule=self)
else:
variables._parentRule = self
self._variables = variables
variables = property(lambda self: self._variables, _setVariables,
doc="(DOM) The variables of this rule set, a "
":class:`css_parser.css.CSSVariablesDeclaration`.")
type = property(lambda self: self.VARIABLES_RULE,
doc="The type of this rule, as defined by a CSSRule "
"type constant.")
valid = property(lambda self: True, doc='NOT IMPLEMTED REALLY (TODO)')
# constant but needed:
wellformed = property(lambda self: True)
Mini Shell