def __init__(self, ctx, line, name, level):
super(ParserRule, self).__init__()
#: Level of the rule in the kv
self.level = level
#: Associated parser
self.ctx = ctx
#: Line of the rule
self.line = line
#: Name of the rule
self.name = name
#: List of children to create
self.children = []
#: Id given to the rule
self.id = None
#: Properties associated to the rule
self.properties = OrderedDict()
#: Canvas normal
self.canvas_root = None
#: Canvas before
self.canvas_before = None
#: Canvas after
self.canvas_after = None
#: Handlers associated to the rule
self.handlers = []
#: Properties cache list: mark which class have already been checked
self.cache_marked = []
if level == 0:
self._detect_selectors()
else:
self._forbid_selectors()
def __init__(self, ctx, line, name, level):
super(ParserRule, self).__init__()
#: Level of the rule in the kv
self.level = level
#: Associated parser
self.ctx = ctx
#: Line of the rule
self.line = line
#: Name of the rule
self.name = name
#: List of children to create
self.children = []
#: Id given to the rule
self.id = None
#: Properties associated to the rule
self.properties = OrderedDict()
#: Canvas normal
self.canvas_root = None
#: Canvas before
self.canvas_before = None
#: Canvas after
self.canvas_after = None
#: Handlers associated to the rule
self.handlers = []
#: Properties cache list: mark which class have already been checked
self.cache_marked = []
if level == 0:
self._detect_selectors()
else:
self._forbid_selectors()
class ParserRule(object):
'''Represent a rule, in term if Kivy internal language
'''
__slots__ = ('ctx', 'line', 'name', 'children', 'id', 'properties',
'canvas_before', 'canvas_root', 'canvas_after',
'handlers', 'level', 'cache_marked')
def __init__(self, ctx, line, name, level):
super(ParserRule, self).__init__()
#: Level of the rule in the kv
self.level = level
#: Associated parser
self.ctx = ctx
#: Line of the rule
self.line = line
#: Name of the rule
self.name = name
#: List of children to create
self.children = []
#: Id given to the rule
self.id = None
#: Properties associated to the rule
self.properties = OrderedDict()
#: Canvas normal
self.canvas_root = None
#: Canvas before
self.canvas_before = None
#: Canvas after
self.canvas_after = None
#: Handlers associated to the rule
self.handlers = []
#: Properties cache list: mark which class have already been checked
self.cache_marked = []
if level == 0:
self._detect_selectors()
else:
self._forbid_selectors()
def precompile(self):
for x in self.properties.itervalues():
x.precompile()
for x in self.handlers:
x.precompile()
for x in self.children:
x.precompile()
if self.canvas_before:
self.canvas_before.precompile()
if self.canvas_root:
self.canvas_root.precompile()
if self.canvas_after:
self.canvas_after.precompile()
def create_missing(self, widget):
# check first if the widget class already been processed by this rule
cls = widget.__class__
if cls in self.cache_marked:
return
self.cache_marked.append(cls)
for name in self.properties:
if not hasattr(widget, name):
widget.create_property(name)
def _forbid_selectors(self):
c = self.name[0]
if c == '<' or c == '[':
raise ParserException(
self.ctx, self.line,
'Selectors rules are allowed only at the first level')
def _detect_selectors(self):
c = self.name[0]
if c == '<':
self._build_rule()
elif c == '[':
self._build_template()
else:
if self.ctx.root is not None:
raise ParserException(
self.ctx, self.line,
'Only one root object is allowed by .kv')
self.ctx.root = self
def _build_rule(self):
name = self.name
if __debug__:
trace('Builder: build rule for %s' % name)
if name[0] != '<' or name[-1] != '>':
raise ParserException(self.ctx, self.line,
'Invalid rule (must be inside <>)')
rules = name[1:-1].split(',')
for rule in rules:
if not len(rule):
raise ParserException(self.ctx, self.line,
'Empty rule detected')
crule = None
if rule[0] == '.':
crule = ParserSelectorClass(rule[1:])
elif rule[0] == '#':
crule = ParserSelectorId(rule[1:])
else:
crule = ParserSelectorName(rule)
self.ctx.rules.append((crule, self))
def _build_template(self):
name = self.name
if __debug__:
trace('Builder: build template for %s' % name)
if name[0] != '[' or name[-1] != ']':
raise ParserException(self.ctx, self.line,
'Invalid template (must be inside [])')
item_content = name[1:-1]
if not '@' in item_content:
raise ParserException(self.ctx, self.line,
'Invalid template name (missing @)')
template_name, template_root_cls = item_content.split('@')
self.ctx.templates.append((template_name, template_root_cls, self))
def __repr__(self):
return '<ParserRule name=%r>' % (self.name, )
def __init__(self):
PythonConfigParser.__init__(self)
self._sections = OrderedDict()
self.filename = None
self._callbacks = []
def __init__(self):
ConfigParser.__init__(self)
self._sections = OrderedDict()
class ParserRule(object):
'''Represent a rule, in term if Kivy internal language
'''
__slots__ = ('ctx', 'line', 'name', 'children', 'id', 'properties',
'canvas_before', 'canvas_root', 'canvas_after',
'handlers', 'level', 'cache_marked')
def __init__(self, ctx, line, name, level):
super(ParserRule, self).__init__()
#: Level of the rule in the kv
self.level = level
#: Associated parser
self.ctx = ctx
#: Line of the rule
self.line = line
#: Name of the rule
self.name = name
#: List of children to create
self.children = []
#: Id given to the rule
self.id = None
#: Properties associated to the rule
self.properties = OrderedDict()
#: Canvas normal
self.canvas_root = None
#: Canvas before
self.canvas_before = None
#: Canvas after
self.canvas_after = None
#: Handlers associated to the rule
self.handlers = []
#: Properties cache list: mark which class have already been checked
self.cache_marked = []
if level == 0:
self._detect_selectors()
else:
self._forbid_selectors()
def precompile(self):
for x in self.properties.itervalues():
x.precompile()
for x in self.handlers:
x.precompile()
for x in self.children:
x.precompile()
if self.canvas_before:
self.canvas_before.precompile()
if self.canvas_root:
self.canvas_root.precompile()
if self.canvas_after:
self.canvas_after.precompile()
def create_missing(self, widget):
# check first if the widget class already been processed by this rule
cls = widget.__class__
if cls in self.cache_marked:
return
self.cache_marked.append(cls)
for name in self.properties:
if not hasattr(widget, name):
widget.create_property(name)
def _forbid_selectors(self):
c = self.name[0]
if c == '<' or c == '[':
raise ParserException(self.ctx, self.line,
'Selectors rules are allowed only at the first level')
def _detect_selectors(self):
c = self.name[0]
if c == '<':
self._build_rule()
elif c == '[':
self._build_template()
else:
if self.ctx.root is not None:
raise ParserException(self.ctx, self.line,
'Only one root object is allowed by .kv')
self.ctx.root = self
def _build_rule(self):
name = self.name
if __debug__:
trace('Builder: build rule for %s' % name)
if name[0] != '<' or name[-1] != '>':
raise ParserException(self.ctx, self.line,
'Invalid rule (must be inside <>)')
rules = name[1:-1].split(',')
for rule in rules:
if not len(rule):
raise ParserException(self.ctx, self.line,
'Empty rule detected')
crule = None
if rule[0] == '.':
crule = ParserSelectorClass(rule[1:])
elif rule[0] == '#':
crule = ParserSelectorId(rule[1:])
else:
crule = ParserSelectorName(rule)
self.ctx.rules.append((crule, self))
def _build_template(self):
name = self.name
if __debug__:
trace('Builder: build template for %s' % name)
if name[0] != '[' or name[-1] != ']':
raise ParserException(self.ctx, self.line,
'Invalid template (must be inside [])')
item_content = name[1:-1]
if not '@' in item_content:
raise ParserException(self.ctx, self.line,
'Invalid template name (missing @)')
template_name, template_root_cls = item_content.split('@')
self.ctx.templates.append((template_name, template_root_cls, self))
def __repr__(self):
return '<ParserRule name=%r>' % (self.name, )
def parse_level(self, level, lines):
'''Parse the current level (level * 4) indentation
'''
indent = 4 * level
objects = []
current_object = None
current_property = None
i = 0
while i < len(lines):
line = lines[i]
ln, content = line
# Get the number of space
tmp = content.lstrip(' \t')
# Replace any tab with 4 spaces
tmp = content[:len(content) - len(tmp)]
tmp = tmp.replace('\t', ' ')
count = len(tmp)
if count % 4 != 0:
raise ParserError(
self, ln, 'Invalid indentation, must be a multiple of 4')
content = content.strip()
# Level finished
if count < indent:
return objects, lines[i - 1:]
# Current level, create an object
elif count == indent:
current_object = OrderedDict()
current_object['__line__'] = ln
current_object['__ctx__'] = self
current_property = None
x = content.split(':', 1)
if not len(x[0]):
raise ParserError(self, ln, 'Identifier missing')
if len(x) == 2 and len(x[1]):
raise ParserError(self, ln,
'Invalid data after declaration')
objects.append((x[0], current_object))
# Next level, is it a property or an object ?
elif count == indent + 4:
x = content.split(':', 1)
if not len(x[0]):
raise ParserError(self, ln, 'Identifier missing')
# It's a class, add to the current object as a children
current_property = None
name = x[0]
if ord(name[0]) in Parser.CLASS_RANGE or name[0] == '+':
_objects, _lines = self.parse_level(level + 1, lines[i:])
current_object['children'] = (_objects, ln, self)
lines = _lines
i = 0
# It's a property
else:
if len(x) == 1:
raise ParserError(self, ln, 'Syntax error')
value = x[1].strip()
if len(value):
current_object[name] = (value, ln, self)
else:
current_property = name
# Two more level ?
elif count == indent + 8:
if current_property not in ('canvas', 'canvas.after',
'canvas.before'):
raise ParserError(
self, ln, 'Invalid indentation, only allowed '
'for canvas')
_objects, _lines = self.parse_level(level + 2, lines[i:])
current_object[current_property] = (_objects, ln, self)
current_property = None
lines = _lines
i = 0
# Too much indent, invalid
else:
raise ParserError(self, ln,
'Invalid indentation (too much level)')
# Check the next line
i += 1
return objects, []
class ParserRule(object):
"""Represent a rule, in term if Kivy internal language
"""
__slots__ = (
"ctx",
"line",
"name",
"children",
"id",
"properties",
"canvas_before",
"canvas_root",
"canvas_after",
"handlers",
"level",
"cache_marked",
)
def __init__(self, ctx, line, name, level):
super(ParserRule, self).__init__()
#: Level of the rule in the kv
self.level = level
#: Associated parser
self.ctx = ctx
#: Line of the rule
self.line = line
#: Name of the rule
self.name = name
#: List of children to create
self.children = []
#: Id given to the rule
self.id = None
#: Properties associated to the rule
self.properties = OrderedDict()
#: Canvas normal
self.canvas_root = None
#: Canvas before
self.canvas_before = None
#: Canvas after
self.canvas_after = None
#: Handlers associated to the rule
self.handlers = []
#: Properties cache list: mark which class have already been checked
self.cache_marked = []
if level == 0:
self._detect_selectors()
else:
self._forbid_selectors()
def precompile(self):
for x in self.properties.itervalues():
x.precompile()
for x in self.handlers:
x.precompile()
for x in self.children:
x.precompile()
if self.canvas_before:
self.canvas_before.precompile()
if self.canvas_root:
self.canvas_root.precompile()
if self.canvas_after:
self.canvas_after.precompile()
def create_missing(self, widget):
# check first if the widget class already been processed by this rule
cls = widget.__class__
if cls in self.cache_marked:
return
self.cache_marked.append(cls)
for name in self.properties:
if not hasattr(widget, name):
widget.create_property(name)
def _forbid_selectors(self):
c = self.name[0]
if c == "<" or c == "[":
raise ParserException(self.ctx, self.line, "Selectors rules are allowed only at the first level")
def _detect_selectors(self):
c = self.name[0]
if c == "<":
self._build_rule()
elif c == "[":
self._build_template()
else:
if self.ctx.root is not None:
raise ParserException(self.ctx, self.line, "Only one root object is allowed by .kv")
self.ctx.root = self
def _build_rule(self):
name = self.name
if __debug__:
trace("Builder: build rule for %s" % name)
if name[0] != "<" or name[-1] != ">":
raise ParserException(self.ctx, self.line, "Invalid rule (must be inside <>)")
rules = name[1:-1].split(",")
for rule in rules:
if not len(rule):
raise ParserException(self.ctx, self.line, "Empty rule detected")
crule = None
if rule[0] == ".":
crule = ParserSelectorClass(rule[1:])
elif rule[0] == "#":
crule = ParserSelectorId(rule[1:])
else:
crule = ParserSelectorName(rule)
self.ctx.rules.append((crule, self))
def _build_template(self):
name = self.name
if __debug__:
trace("Builder: build template for %s" % name)
if name[0] != "[" or name[-1] != "]":
raise ParserException(self.ctx, self.line, "Invalid template (must be inside [])")
item_content = name[1:-1]
if not "@" in item_content:
raise ParserException(self.ctx, self.line, "Invalid template name (missing @)")
template_name, template_root_cls = item_content.split("@")
self.ctx.templates.append((template_name, template_root_cls, self))
def __repr__(self):
return "<ParserRule name=%r>" % (self.name,)
