def test_naryop(self):
src = u'$a $b $c, $d $e $f, $g $h $i'
parser = Parser(src)
self.assertTrue(parser.match(tokens.START))
expr = parser.comma_expr()
expected = NaryOpExpr(
op=CommaOp(),
operands=[
NaryOpExpr(
op=WhitespaceOp(),
operands=[
VarName(name=u'a'),
VarName(name=u'b'),
VarName(name=u'c'),
]
),
NaryOpExpr(
op=WhitespaceOp(),
operands=[
VarName(name=u'd'),
VarName(name=u'e'),
VarName(name=u'f'),
]
),
NaryOpExpr(
op=WhitespaceOp(),
operands=[
VarName(name=u'g'),
VarName(name=u'h'),
VarName(name=u'i'),
]
),
]
)
self.assertEqual(dump(expected), dump(expr))
def test_simple(self):
src = u'a {}'
parser = parsers.Parser(src)
self.assertTrue(parser.match(tokens.START))
stylesheet = parser.stylesheet()
flattener = flatteners.RulesetFlattener()
stylesheet = flattener.visit(stylesheet)
expected = \
Stylesheet(
charset=None,
imports=[],
statements=[
RuleSet(
selectors=[
Selector(
children=[
SimpleSelectorSequence(
head=TypeSelector(name=u'a'),
tail=[]
)
]
),
],
statements=[]
),
]
)
self.assertEqual(dump(expected), dump(stylesheet))
def test_fwdslash_op1(self):
src = u'3/2'
parser = Parser(src)
self.assertTrue(parser.match(tokens.START))
expr = parser.comma_expr()
expected = BinaryOpExpr(
op=FwdSlashOp(),
lhs=NumberNode(number=u'3'),
rhs=NumberNode(number=u'2'),
)
self.assertEqual(dump(expected), dump(expr))
def test_fwdslash_op4(self):
src = u'3/$a'
parser = Parser(src)
self.assertTrue(parser.match(tokens.START))
expr = parser.comma_expr()
expected = BinaryOpExpr(
op=DivisionOp(),
lhs=NumberNode(number=u'3'),
rhs=VarName(name=u'a'),
)
self.assertEqual(dump(expected), dump(expr))
def test_vardef_at_end1(self):
# Variable definition at the end of a stylesheet is legal, though
# useless.
src = u'$x: 5'
parser = Parser(src)
self.assertTrue(parser.match(tokens.START))
stmt = parser.toplevel_statement()
expected = \
VarDef(
name=u'x',
expr=NumberNode(number=u'5')
)
self.assertEqual(dump(expected), dump(stmt))
def test_hsl_func2(self):
src = u'prop: hsl(180,50%,75%) ;'
parser = parsers.Parser(src)
self.assertTrue(parser.match(tokens.START))
decl = parser.declaration()
solver = solvers.Solver()
decl = solver.visit(decl)
expected = \
Declaration(
prop=Property(name=u'prop'),
expr=HSLColorNode(h=u'180', s=u'50', l=u'75'),
important=False,
)
self.assertEqual(dump(expected), dump(decl))
def test_whitespaceop(self):
src = '$a $b $c'
parser = Parser(src)
self.assertTrue(parser.match(tokens.START))
expr = parser.comma_expr()
expected = NaryOpExpr(
op=WhitespaceOp(),
operands=[
VarName(name='a'),
VarName(name='b'),
VarName(name='c'),
]
)
self.assertEqual(dump(expected), dump(expr))
def test_add_dimension_number(self):
src = u'prop: 1px+1 ;'
parser = parsers.Parser(src)
self.assertTrue(parser.match(tokens.START))
decl = parser.declaration()
solver = solvers.Solver()
decl = solver.visit(decl)
expected = \
Declaration(
prop=Property(name=u'prop'),
expr=DimensionNode(number=u'2', unit=u'px'),
important=False,
)
self.assertEqual(dump(expected), dump(decl))
def test_rgb_func2(self):
src = u'prop: rgb((128+127),50%,101) ;'
parser = parsers.Parser(src)
self.assertTrue(parser.match(tokens.START))
decl = parser.declaration()
solver = solvers.Solver()
decl = solver.visit(decl)
expected = \
Declaration(
prop=Property(name=u'prop'),
expr=RGBColorNode(r=u'255', g=u'127.5', b=u'101'),
important=False,
)
self.assertEqual(dump(expected), dump(decl))
def test_negated2(self):
src = u'prop: -1+3;'
parser = parsers.Parser(src)
self.assertTrue(parser.match(tokens.START))
decl = parser.declaration()
solver = solvers.Solver()
decl = solver.visit(decl)
expected = \
Declaration(
prop=Property(name=u'prop'),
expr=NumberNode(number=u'2'),
important=False,
)
self.assertEqual(dump(expected), dump(decl))
def test_precedence4(self):
src = '$a+$b+$c'
parser = Parser(src)
self.assertTrue(parser.match(tokens.START))
expr = parser.comma_expr()
expected = BinaryOpExpr(
op=AddOp(),
lhs=BinaryOpExpr(
op=AddOp(),
lhs=VarName(name='a'),
rhs=VarName(name='b')
),
rhs=VarName(name='c')
)
self.assertEqual(dump(expected), dump(expr))
def test_class_selector(self):
src = u'.myclass'
parser = Parser(src)
self.assertTrue(parser.match(tokens.START))
sel = parser.selector()
expected = \
Selector(
children=[
SimpleSelectorSequence(
head=None,
tail=[ClassSelector(name=u'myclass')]
),
]
)
self.assertEqual(dump(expected), dump(sel))
def test_type_selector(self):
src = u'div'
parser = Parser(src)
self.assertTrue(parser.match(tokens.START))
sel = parser.selector()
expected = \
Selector(
children=[
SimpleSelectorSequence(
head=TypeSelector(name=u'div'),
tail=[]
),
]
)
self.assertEqual(dump(expected), dump(sel))
def test_division_op1(self):
src = u'3/2/1'
parser = Parser(src)
self.assertTrue(parser.match(tokens.START))
expr = parser.comma_expr()
expected = BinaryOpExpr(
op=DivisionOp(),
lhs=BinaryOpExpr(
op=DivisionOp(),
lhs=NumberNode(number=u'3'),
rhs=NumberNode(number=u'2'),
),
rhs=NumberNode(number=u'1'),
)
self.assertEqual(dump(expected), dump(expr))
def test_noargs(self):
src = u'[ abc ]'
parser = Parser(src)
self.assertTrue(parser.match(tokens.START))
sel = parser.attrib_selector()
expected = "AttributeSelector(attr=u'abc', op=None, val=None)"
self.assertEqual(expected, dump(sel))
def test_suffix_match(self):
src = u'[ abc$=xyz ]'
parser = Parser(src)
self.assertTrue(parser.match(tokens.START))
sel = parser.attrib_selector()
expected = "AttributeSelector(attr=u'abc', op=AttrSuffixMatchOp(), val=IdentExpr(name=u'xyz'))"
self.assertEqual(expected, dump(sel))
def test_exact_match(self):
src = u'[ abc="xyz" ]'
parser = Parser(src)
self.assertTrue(parser.match(tokens.START))
sel = parser.attrib_selector()
expected = "AttributeSelector(attr=u'abc', op=AttrExactMatchOp(), val=StringNode(string=u'xyz'))"
self.assertEqual(expected, dump(sel))
def test_simple(self):
src = u' + '
parser = Parser(src)
self.assertTrue(parser.match(tokens.START))
op = parser.math_expr_operator()
self.assertTrue(op is not None)
self.assertEqual("AddOp()", dump(op))
def test_negated_expr(self):
src = u'prop: -(1 + 2) ;'
parser = parsers.Parser(src)
self.assertTrue(parser.match(tokens.START))
decl = parser.declaration()
solver = solvers.Solver()
decl = solver.visit(decl)
expected = \
Declaration(
prop=Property(name=u'prop'),
expr=UnaryOpExpr(
op=UMinus(),
operand=NumberNode(number=u'3'),
),
important=False,
)
self.assertEqual(dump(expected), dump(decl))
def test_whitespaceop5(self):
src = u'$a $b+$c $d'
parser = Parser(src)
self.assertTrue(parser.match(tokens.START))
expr = parser.comma_expr()
expected = NaryOpExpr(
op=WhitespaceOp(),
operands=[
VarName(name=u'a'),
BinaryOpExpr(
op=AddOp(),
lhs=VarName(name=u'b'),
rhs=VarName(name=u'c'),
),
VarName(name=u'd'),
]
)
self.assertEqual(dump(expected), dump(expr))
def test_pseudo_element_selector2(self):
src = u'a::foo'
parser = Parser(src)
self.assertTrue(parser.match(tokens.START))
sel = parser.selector()
expected = \
Selector(
children=[
SimpleSelectorSequence(
head=TypeSelector(name=u'a'),
tail=[
PseudoElementSelector(
node=Ident(name=u'foo')
),
]
)
]
)
self.assertEqual(dump(expected), dump(sel))
def test_negation_selector(self):
src = u'a:not( #myid )'
parser = Parser(src)
self.assertTrue(parser.match(tokens.START))
sel = parser.selector()
expected = \
Selector(
children=[
SimpleSelectorSequence(
head=TypeSelector(name=u'a'),
tail=[
NegationSelector(
arg=IdSelector(name=u'myid')
),
]
)
]
)
self.assertEqual(dump(expected), dump(sel))
def test_whitespace_combinator2(self):
src = u'a.myclass b#myid'
parser = Parser(src)
self.assertTrue(parser.match(tokens.START))
sel = parser.selector()
expected = \
Selector(
children=[
SimpleSelectorSequence(
head=TypeSelector(name=u'a'),
tail=[ClassSelector(name=u'myclass')]
),
DescendantCombinator(),
SimpleSelectorSequence(
head=TypeSelector(name=u'b'),
tail=[IdSelector(name=u'myid')]
),
]
)
self.assertEqual(dump(expected), dump(sel))
def test_child_combinator(self):
src = u'a > b'
parser = Parser(src)
self.assertTrue(parser.match(tokens.START))
sel = parser.selector()
expected = \
Selector(
children=[
SimpleSelectorSequence(
head=TypeSelector(name=u'a'),
tail=[]
),
ChildCombinator(),
SimpleSelectorSequence(
head=TypeSelector(name=u'b'),
tail=[]
),
]
)
self.assertEqual(dump(expected), dump(sel))
def test_precedence3(self):
src = '$a+$b*$c+($d - $e)'
parser = Parser(src)
self.assertTrue(parser.match(tokens.START))
expr = parser.comma_expr()
expected = BinaryOpExpr(
op=AddOp(),
lhs=BinaryOpExpr(
op=AddOp(),
lhs=VarName(name='a'),
rhs=BinaryOpExpr(
op=MultOp(),
lhs=VarName(name='b'),
rhs=VarName(name='c')
)
),
rhs=BinaryOpExpr(
op=SubtractOp(),
lhs=VarName(name='d'),
rhs=VarName(name='e')
)
)
self.assertEqual(dump(expected), dump(expr))
def test_rgb_func3(self):
src = u'prop: rgb(127,"50%",101) ;'
parser = parsers.Parser(src)
self.assertTrue(parser.match(tokens.START))
decl = parser.declaration()
solver = solvers.Solver()
decl = solver.visit(decl)
expected = \
Declaration(
prop=Property(name=u'prop'),
expr=FunctionExpr(
name=u'rgb',
expr=NaryOpExpr(
op=CommaOp(),
operands=[
NumberNode(number=u'127'),
StringNode(string=u'50%'),
NumberNode(number=u'101'),
]
)
),
important=False,
)
self.assertEqual(dump(expected), dump(decl))
def test_nesting(self):
src = u'''\
s1 {
$x: 5;
s2 {
r1: $x;
}
r2: $x;
}
'''
src = textwrap.dedent(src)
parser = parsers.Parser(src)
self.assertTrue(parser.match(tokens.START))
stylesheet = parser.stylesheet()
solver = solvers.Solver()
stylesheet = solver.visit(stylesheet)
expected = \
Stylesheet(
charset=None,
imports=[],
statements=[
RuleSet(
selectors=[
Selector(
children=[
SimpleSelectorSequence(
head=TypeSelector(name=u's1'),
tail=[]
),
]
),
],
statements=[
RuleSet(
selectors=[
Selector(
children=[
SimpleSelectorSequence(
head=TypeSelector(name=u's2'),
tail=[]
),
]
),
],
statements=[
Declaration(
prop=Property(name=u'r1'),
expr=NumberNode(number=u'5'),
important=False
),
]
),
Declaration(
prop=Property(name=u'r2'),
expr=NumberNode(number=u'5'),
important=False
),
]
),
]
)
self.assertEqual(dump(expected), dump(stylesheet))
def test_plus1(self):
src = u'$a + $b'
parser = Parser(src)
self.assertTrue(parser.match(tokens.START))
expr = parser.comma_expr()
self.assertEqual("VarName(name=u'a')", dump(expr))
def test_plus(self):
src = u'$a+$b'
parser = Parser(src)
self.assertTrue(parser.match(tokens.START))
expr = parser.comma_expr()
self.assertEqual("BinaryOpExpr(op=AddOp(), lhs=VarName(name=u'a'), rhs=VarName(name=u'b'))", dump(expr))
def test_empty(self):
src = u''
parser = Parser(src)
stylesheet = parser.parse()
self.assertEqual('Stylesheet(charset=None, imports=[], statements=[])', dump(stylesheet))
