Ajout du GUI
This commit is contained in:
thatscringebro
817
kivy/lang/parser.py
Normal file
817
kivy/lang/parser.py
Normal file
@@ -0,0 +1,817 @@
|
||||
'''
|
||||
Parser
|
||||
======
|
||||
|
||||
Class used for the parsing of .kv files into rules.
|
||||
'''
|
||||
import os
|
||||
|
||||
import re
|
||||
import sys
|
||||
import traceback
|
||||
import ast
|
||||
import importlib
|
||||
from re import sub, findall
|
||||
from types import CodeType
|
||||
from functools import partial
|
||||
from collections import OrderedDict, defaultdict
|
||||
|
||||
import kivy.lang.builder # imported as absolute to avoid circular import
|
||||
from kivy.logger import Logger
|
||||
from kivy.cache import Cache
|
||||
from kivy import require
|
||||
from kivy.resources import resource_find
|
||||
from kivy.utils import rgba
|
||||
import kivy.metrics as Metrics
|
||||
|
||||
__all__ = ('Parser', 'ParserException')
|
||||
|
||||
|
||||
trace = Logger.trace
|
||||
global_idmap = {}
|
||||
|
||||
# register cache for creating new classtype (template)
|
||||
Cache.register('kv.lang')
|
||||
|
||||
# all previously included files
|
||||
__KV_INCLUDES__ = []
|
||||
|
||||
# precompile regexp expression
|
||||
str_re = (
|
||||
"(?:'''.*?''')|"
|
||||
"(?:(?:(?<!')|''')'(?:[^']|\\\\')+?'(?:(?!')|'''))|"
|
||||
'(?:""".*?""")|'
|
||||
'(?:(?:(?<!")|""")"(?:[^"]|\\\\")+?"(?:(?!")|"""))'
|
||||
)
|
||||
|
||||
lang_str = re.compile(f"({str_re})", re.DOTALL)
|
||||
lang_fstr = re.compile(f"([fF](?:{str_re}))", re.DOTALL)
|
||||
|
||||
lang_key = re.compile('([a-zA-Z_]+)')
|
||||
lang_keyvalue = re.compile(r'([a-zA-Z_][a-zA-Z0-9_.]*\.[a-zA-Z0-9_.]+)')
|
||||
lang_tr = re.compile(r'(_\()')
|
||||
lang_cls_split_pat = re.compile(', *')
|
||||
|
||||
# all the widget handlers, used to correctly unbind all the callbacks then the
|
||||
# widget is deleted
|
||||
_handlers = defaultdict(partial(defaultdict, list))
|
||||
|
||||
|
||||
class ProxyApp(object):
|
||||
# proxy app object
|
||||
# taken from http://code.activestate.com/recipes/496741-object-proxying/
|
||||
|
||||
__slots__ = ['_obj']
|
||||
|
||||
def __init__(self):
|
||||
object.__init__(self)
|
||||
object.__setattr__(self, '_obj', None)
|
||||
|
||||
def _ensure_app(self):
|
||||
app = object.__getattribute__(self, '_obj')
|
||||
if app is None:
|
||||
from kivy.app import App
|
||||
app = App.get_running_app()
|
||||
object.__setattr__(self, '_obj', app)
|
||||
# Clear cached application instance, when it stops
|
||||
app.bind(on_stop=lambda instance:
|
||||
object.__setattr__(self, '_obj', None))
|
||||
return app
|
||||
|
||||
def __getattribute__(self, name):
|
||||
object.__getattribute__(self, '_ensure_app')()
|
||||
return getattr(object.__getattribute__(self, '_obj'), name)
|
||||
|
||||
def __delattr__(self, name):
|
||||
object.__getattribute__(self, '_ensure_app')()
|
||||
delattr(object.__getattribute__(self, '_obj'), name)
|
||||
|
||||
def __setattr__(self, name, value):
|
||||
object.__getattribute__(self, '_ensure_app')()
|
||||
setattr(object.__getattribute__(self, '_obj'), name, value)
|
||||
|
||||
def __bool__(self):
|
||||
object.__getattribute__(self, '_ensure_app')()
|
||||
return bool(object.__getattribute__(self, '_obj'))
|
||||
|
||||
def __str__(self):
|
||||
object.__getattribute__(self, '_ensure_app')()
|
||||
return str(object.__getattribute__(self, '_obj'))
|
||||
|
||||
def __repr__(self):
|
||||
object.__getattribute__(self, '_ensure_app')()
|
||||
return repr(object.__getattribute__(self, '_obj'))
|
||||
|
||||
|
||||
global_idmap['app'] = ProxyApp()
|
||||
global_idmap['pt'] = Metrics.pt
|
||||
global_idmap['inch'] = Metrics.inch
|
||||
global_idmap['cm'] = Metrics.cm
|
||||
global_idmap['mm'] = Metrics.mm
|
||||
global_idmap['dp'] = Metrics.dp
|
||||
global_idmap['sp'] = Metrics.sp
|
||||
global_idmap['rgba'] = rgba
|
||||
|
||||
|
||||
class ParserException(Exception):
|
||||
'''Exception raised when something wrong happened in a kv file.
|
||||
'''
|
||||
|
||||
def __init__(self, context, line, message, cause=None):
|
||||
self.filename = context.filename or '<inline>'
|
||||
self.line = line
|
||||
sourcecode = context.sourcecode
|
||||
sc_start = max(0, line - 2)
|
||||
sc_stop = min(len(sourcecode), line + 3)
|
||||
sc = ['...']
|
||||
for x in range(sc_start, sc_stop):
|
||||
if x == line:
|
||||
sc += ['>> %4d:%s' % (line + 1, sourcecode[line][1])]
|
||||
else:
|
||||
sc += [' %4d:%s' % (x + 1, sourcecode[x][1])]
|
||||
sc += ['...']
|
||||
sc = '\n'.join(sc)
|
||||
|
||||
message = 'Parser: File "%s", line %d:\n%s\n%s' % (
|
||||
self.filename, self.line + 1, sc, message)
|
||||
if cause:
|
||||
message += '\n' + ''.join(traceback.format_tb(cause))
|
||||
|
||||
super(ParserException, self).__init__(message)
|
||||
|
||||
|
||||
class ParserRuleProperty(object):
|
||||
'''Represent a property inside a rule.
|
||||
'''
|
||||
|
||||
__slots__ = ('ctx', 'line', 'name', 'value', 'co_value',
|
||||
'watched_keys', 'mode', 'count', 'ignore_prev')
|
||||
|
||||
def __init__(self, ctx, line, name, value, ignore_prev=False):
|
||||
super(ParserRuleProperty, self).__init__()
|
||||
#: Associated parser
|
||||
self.ctx = ctx
|
||||
#: Line of the rule
|
||||
self.line = line
|
||||
#: Name of the property
|
||||
self.name = name
|
||||
#: Value of the property
|
||||
self.value = value
|
||||
#: Compiled value
|
||||
self.co_value = None
|
||||
#: Compilation mode
|
||||
self.mode = None
|
||||
#: Watched keys
|
||||
self.watched_keys = None
|
||||
#: Stats
|
||||
self.count = 0
|
||||
#: whether previous rules targeting name should be cleared
|
||||
self.ignore_prev = ignore_prev
|
||||
|
||||
def precompile(self):
|
||||
name = self.name
|
||||
value = self.value
|
||||
|
||||
# first, remove all the string from the value
|
||||
tmp = sub(lang_str, '', self.value)
|
||||
|
||||
# detecting how to handle the value according to the key name
|
||||
mode = self.mode
|
||||
if self.mode is None:
|
||||
self.mode = mode = 'exec' if name[:3] == 'on_' else 'eval'
|
||||
if mode == 'eval':
|
||||
# if we don't detect any string/key in it, we can eval and give the
|
||||
# result
|
||||
if re.search(lang_key, tmp) is None:
|
||||
value = '\n' * self.line + value
|
||||
self.co_value = eval(
|
||||
compile(value, self.ctx.filename or '<string>', 'eval')
|
||||
)
|
||||
return
|
||||
|
||||
# ok, we can compile.
|
||||
value = '\n' * self.line + value
|
||||
self.co_value = compile(value, self.ctx.filename or '<string>', mode)
|
||||
|
||||
# for exec mode, we don't need to watch any keys.
|
||||
if mode == 'exec':
|
||||
return
|
||||
|
||||
# now, detect obj.prop
|
||||
# find all the fstrings in the value
|
||||
fstrings = lang_fstr.findall(value)
|
||||
wk = set()
|
||||
for s in fstrings:
|
||||
expression = ast.parse(s)
|
||||
wk |= set(self.get_names_from_expression(expression.body[0].value))
|
||||
|
||||
# first, remove all the string from the value
|
||||
tmp = sub(lang_str, '', value)
|
||||
idx = tmp.find('#')
|
||||
if idx != -1:
|
||||
tmp = tmp[:idx]
|
||||
# detect key.value inside value, and split them
|
||||
wk |= set(findall(lang_keyvalue, tmp))
|
||||
if wk:
|
||||
self.watched_keys = [x.split('.') for x in wk]
|
||||
if findall(lang_tr, tmp):
|
||||
if self.watched_keys:
|
||||
self.watched_keys += [['_']]
|
||||
else:
|
||||
self.watched_keys = [['_']]
|
||||
|
||||
@classmethod
|
||||
def get_names_from_expression(cls, node):
|
||||
"""
|
||||
Look for all the symbols used in an ast node.
|
||||
"""
|
||||
if isinstance(node, ast.Name):
|
||||
yield node.id
|
||||
|
||||
if isinstance(node, (ast.JoinedStr, ast.BoolOp)):
|
||||
for n in node.values:
|
||||
if isinstance(n, ast.Str):
|
||||
# NOTE: required for python3.6
|
||||
yield from cls.get_names_from_expression(n.s)
|
||||
else:
|
||||
yield from cls.get_names_from_expression(n.value)
|
||||
|
||||
if isinstance(node, ast.BinOp):
|
||||
yield from cls.get_names_from_expression(node.right)
|
||||
yield from cls.get_names_from_expression(node.left)
|
||||
|
||||
if isinstance(node, ast.IfExp):
|
||||
yield from cls.get_names_from_expression(node.test)
|
||||
yield from cls.get_names_from_expression(node.body)
|
||||
yield from cls.get_names_from_expression(node.orelse)
|
||||
|
||||
if isinstance(node, ast.Subscript):
|
||||
yield from cls.get_names_from_expression(node.value)
|
||||
yield from cls.get_names_from_expression(node.slice)
|
||||
|
||||
if isinstance(node, ast.Slice):
|
||||
yield from cls.get_names_from_expression(node.lower)
|
||||
yield from cls.get_names_from_expression(node.upper)
|
||||
yield from cls.get_names_from_expression(node.step)
|
||||
|
||||
if isinstance(
|
||||
node,
|
||||
(ast.ListComp, ast.DictComp, ast.SetComp, ast.GeneratorExp)
|
||||
):
|
||||
for g in node.generators:
|
||||
yield from cls.get_names_from_expression(g.iter)
|
||||
|
||||
if isinstance(node, (ast.List, ast.Tuple, ast.Set)):
|
||||
for elt in node.elts:
|
||||
yield from cls.get_names_from_expression(elt)
|
||||
|
||||
if isinstance(node, ast.Dict):
|
||||
for val in node.values:
|
||||
yield from cls.get_names_from_expression(val)
|
||||
|
||||
if isinstance(node, ast.UnaryOp):
|
||||
yield from cls.get_names_from_expression(node.operand)
|
||||
|
||||
if isinstance(node, ast.comprehension):
|
||||
yield from cls.get_names_from_expression(node.iter.value)
|
||||
|
||||
if isinstance(node, ast.Attribute):
|
||||
if isinstance(node.value, ast.Name):
|
||||
yield f'{node.value.id}.{node.attr}'
|
||||
|
||||
if isinstance(node, ast.Call):
|
||||
yield from cls.get_names_from_expression(node.func)
|
||||
|
||||
for arg in node.args:
|
||||
yield from cls.get_names_from_expression(arg)
|
||||
for keyword in node.keywords:
|
||||
yield from cls.get_names_from_expression(keyword.value)
|
||||
|
||||
def __repr__(self):
|
||||
return '<ParserRuleProperty name=%r filename=%s:%d ' \
|
||||
'value=%r watched_keys=%r>' % (
|
||||
self.name, self.ctx.filename, self.line + 1,
|
||||
self.value, self.watched_keys)
|
||||
|
||||
|
||||
class ParserRule(object):
|
||||
'''Represents a rule, in terms of the Kivy internal language.
|
||||
'''
|
||||
|
||||
__slots__ = ('ctx', 'line', 'name', 'children', 'id', 'properties',
|
||||
'canvas_before', 'canvas_root', 'canvas_after',
|
||||
'handlers', 'level', 'cache_marked', 'avoid_previous_rules')
|
||||
|
||||
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 = []
|
||||
#: Indicate if any previous rules should be avoided.
|
||||
self.avoid_previous_rules = False
|
||||
|
||||
if level == 0:
|
||||
self._detect_selectors()
|
||||
else:
|
||||
self._forbid_selectors()
|
||||
|
||||
def precompile(self):
|
||||
for x in self.properties.values():
|
||||
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 hasattr(widget, name):
|
||||
continue
|
||||
value = self.properties[name].co_value
|
||||
if type(value) is CodeType:
|
||||
value = None
|
||||
widget.create_property(name, value, default_value=False)
|
||||
|
||||
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 <>)')
|
||||
|
||||
# if the very first name start with a -, avoid previous rules
|
||||
name = name[1:-1]
|
||||
if name[:1] == '-':
|
||||
self.avoid_previous_rules = True
|
||||
name = name[1:]
|
||||
|
||||
for rule in re.split(lang_cls_split_pat, name):
|
||||
crule = None
|
||||
|
||||
if not rule:
|
||||
raise ParserException(self.ctx, self.line,
|
||||
'Empty rule detected')
|
||||
|
||||
if '@' in rule:
|
||||
# new class creation ?
|
||||
# ensure the name is correctly written
|
||||
rule, baseclasses = rule.split('@', 1)
|
||||
if not re.match(lang_key, rule):
|
||||
raise ParserException(self.ctx, self.line,
|
||||
'Invalid dynamic class name')
|
||||
|
||||
# save the name in the dynamic classes dict.
|
||||
self.ctx.dynamic_classes[rule] = baseclasses
|
||||
crule = ParserSelectorName(rule)
|
||||
|
||||
else:
|
||||
# classical selectors.
|
||||
|
||||
if rule[0] == '.':
|
||||
crule = ParserSelectorClass(rule[1:])
|
||||
else:
|
||||
crule = ParserSelectorName(rule)
|
||||
|
||||
self.ctx.rules.append((crule, self))
|
||||
|
||||
def _build_template(self):
|
||||
name = self.name
|
||||
exception = ParserException(
|
||||
self.ctx, self.line,
|
||||
'Deprecated Kivy lang template syntax used "{}". Templates will '
|
||||
'be removed in a future version'.format(name))
|
||||
if name not in ('[FileListEntry@FloatLayout+TreeViewNode]',
|
||||
'[FileIconEntry@Widget]',
|
||||
'[AccordionItemTitle@Label]'):
|
||||
Logger.warning(exception)
|
||||
|
||||
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, )
|
||||
|
||||
|
||||
class Parser(object):
|
||||
'''Create a Parser object to parse a Kivy language file or Kivy content.
|
||||
'''
|
||||
|
||||
PROP_ALLOWED = ('canvas.before', 'canvas.after')
|
||||
CLASS_RANGE = list(range(ord('A'), ord('Z') + 1))
|
||||
PROP_RANGE = (
|
||||
list(range(ord('A'), ord('Z') + 1)) +
|
||||
list(range(ord('a'), ord('z') + 1)) +
|
||||
list(range(ord('0'), ord('9') + 1)) + [ord('_')])
|
||||
|
||||
__slots__ = ('rules', 'templates', 'root', 'sourcecode',
|
||||
'directives', 'filename', 'dynamic_classes')
|
||||
|
||||
def __init__(self, **kwargs):
|
||||
super(Parser, self).__init__()
|
||||
self.rules = []
|
||||
self.templates = []
|
||||
self.root = None
|
||||
self.sourcecode = []
|
||||
self.directives = []
|
||||
self.dynamic_classes = {}
|
||||
self.filename = kwargs.get('filename', None)
|
||||
content = kwargs.get('content', None)
|
||||
if content is None:
|
||||
raise ValueError('No content passed')
|
||||
self.parse(content)
|
||||
|
||||
def execute_directives(self):
|
||||
global __KV_INCLUDES__
|
||||
for ln, cmd in self.directives:
|
||||
cmd = cmd.strip()
|
||||
if __debug__:
|
||||
trace('Parser: got directive <%s>' % cmd)
|
||||
if cmd[:5] == 'kivy ':
|
||||
version = cmd[5:].strip()
|
||||
if len(version.split('.')) == 2:
|
||||
version += '.0'
|
||||
require(version)
|
||||
elif cmd[:4] == 'set ':
|
||||
try:
|
||||
name, value = cmd[4:].strip().split(' ', 1)
|
||||
except:
|
||||
Logger.exception('')
|
||||
raise ParserException(self, ln, 'Invalid directive syntax')
|
||||
try:
|
||||
value = eval(value, global_idmap)
|
||||
except:
|
||||
Logger.exception('')
|
||||
raise ParserException(self, ln, 'Invalid value')
|
||||
global_idmap[name] = value
|
||||
elif cmd[:8] == 'include ':
|
||||
ref = cmd[8:].strip()
|
||||
force_load = False
|
||||
|
||||
if ref[:6] == 'force ':
|
||||
ref = ref[6:].strip()
|
||||
force_load = True
|
||||
|
||||
# if #:include [force] "path with quotes around"
|
||||
if ref[0] == ref[-1] and ref[0] in ('"', "'"):
|
||||
c = ref[:3].count(ref[0])
|
||||
ref = ref[c:-c] if c != 2 else ref
|
||||
|
||||
if ref[-3:] != '.kv':
|
||||
Logger.warning('Lang: {0} does not have a valid Kivy'
|
||||
'Language extension (.kv)'.format(ref))
|
||||
break
|
||||
if ref in __KV_INCLUDES__:
|
||||
if not os.path.isfile(resource_find(ref) or ref):
|
||||
raise ParserException(self, ln,
|
||||
'Invalid or unknown file: {0}'
|
||||
.format(ref))
|
||||
if not force_load:
|
||||
Logger.warning('Lang: {0} has already been included!'
|
||||
.format(ref))
|
||||
continue
|
||||
else:
|
||||
Logger.debug('Lang: Reloading {0} '
|
||||
'because include was forced.'
|
||||
.format(ref))
|
||||
kivy.lang.builder.Builder.unload_file(ref)
|
||||
kivy.lang.builder.Builder.load_file(ref)
|
||||
continue
|
||||
Logger.debug('Lang: Including file: {0}'.format(0))
|
||||
__KV_INCLUDES__.append(ref)
|
||||
kivy.lang.builder.Builder.load_file(ref)
|
||||
elif cmd[:7] == 'import ':
|
||||
package = cmd[7:].strip()
|
||||
z = package.split()
|
||||
if len(z) != 2:
|
||||
raise ParserException(self, ln, 'Invalid import syntax')
|
||||
alias, package = z
|
||||
try:
|
||||
if package not in sys.modules:
|
||||
try:
|
||||
mod = importlib.__import__(package)
|
||||
except ImportError:
|
||||
module_name = '.'.join(package.split('.')[:-1])
|
||||
mod = importlib.__import__(module_name)
|
||||
# resolve the whole thing
|
||||
for part in package.split('.')[1:]:
|
||||
mod = getattr(mod, part)
|
||||
else:
|
||||
mod = sys.modules[package]
|
||||
global_idmap[alias] = mod
|
||||
except ImportError:
|
||||
Logger.exception('')
|
||||
raise ParserException(self, ln,
|
||||
'Unable to import package %r' %
|
||||
package)
|
||||
else:
|
||||
raise ParserException(self, ln, 'Unknown directive')
|
||||
|
||||
def parse(self, content):
|
||||
'''Parse the contents of a Parser file and return a list
|
||||
of root objects.
|
||||
'''
|
||||
# Read and parse the lines of the file
|
||||
lines = content.splitlines()
|
||||
if not lines:
|
||||
return
|
||||
num_lines = len(lines)
|
||||
lines = list(zip(list(range(num_lines)), lines))
|
||||
self.sourcecode = lines[:]
|
||||
|
||||
if __debug__:
|
||||
trace('Parser: parsing %d lines' % num_lines)
|
||||
|
||||
# Strip all comments
|
||||
self.strip_comments(lines)
|
||||
|
||||
# Execute directives
|
||||
self.execute_directives()
|
||||
|
||||
# Get object from the first level
|
||||
objects, remaining_lines = self.parse_level(0, lines)
|
||||
|
||||
# Precompile rules tree
|
||||
for rule in objects:
|
||||
rule.precompile()
|
||||
|
||||
# After parsing, there should be no remaining lines
|
||||
# or there's an error we did not catch earlier.
|
||||
if remaining_lines:
|
||||
ln, content = remaining_lines[0]
|
||||
raise ParserException(self, ln, 'Invalid data (not parsed)')
|
||||
|
||||
def strip_comments(self, lines):
|
||||
'''Remove all comments from all lines in-place.
|
||||
Comments need to be on a single line and not at the end of a line.
|
||||
i.e. a comment line's first non-whitespace character must be a #.
|
||||
'''
|
||||
# extract directives
|
||||
for ln, line in lines[:]:
|
||||
stripped = line.strip()
|
||||
if stripped[:2] == '#:':
|
||||
self.directives.append((ln, stripped[2:]))
|
||||
if stripped[:1] == '#':
|
||||
lines.remove((ln, line))
|
||||
if not stripped:
|
||||
lines.remove((ln, line))
|
||||
|
||||
def parse_level(self, level, lines, spaces=0):
|
||||
'''Parse the current level (level * spaces) indentation.
|
||||
'''
|
||||
indent = spaces * level if spaces > 0 else 0
|
||||
objects = []
|
||||
|
||||
current_object = None
|
||||
current_property = None
|
||||
current_propobject = 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', ' ')
|
||||
|
||||
# first indent designates the indentation
|
||||
if spaces == 0:
|
||||
spaces = len(tmp)
|
||||
|
||||
count = len(tmp)
|
||||
|
||||
if spaces > 0 and count % spaces != 0:
|
||||
raise ParserException(self, ln,
|
||||
'Invalid indentation, '
|
||||
'must be a multiple of '
|
||||
'%s spaces' % spaces)
|
||||
content = content.strip()
|
||||
rlevel = count // spaces if spaces > 0 else 0
|
||||
|
||||
# Level finished
|
||||
if count < indent:
|
||||
return objects, lines[i - 1:]
|
||||
|
||||
# Current level, create an object
|
||||
elif count == indent:
|
||||
x = content.split(':', 1)
|
||||
if not x[0]:
|
||||
raise ParserException(self, ln, 'Identifier missing')
|
||||
if (len(x) == 2 and len(x[1]) and
|
||||
not x[1].lstrip().startswith('#')):
|
||||
raise ParserException(self, ln,
|
||||
'Invalid data after declaration')
|
||||
name = x[0].rstrip()
|
||||
# if it's not a root rule, then we got some restriction
|
||||
# aka, a valid name, without point or everything else
|
||||
if count != 0:
|
||||
if False in [ord(z) in Parser.PROP_RANGE for z in name]:
|
||||
raise ParserException(self, ln, 'Invalid class name')
|
||||
|
||||
current_object = ParserRule(self, ln, name, rlevel)
|
||||
current_property = None
|
||||
objects.append(current_object)
|
||||
|
||||
# Next level, is it a property or an object ?
|
||||
elif count == indent + spaces:
|
||||
x = content.split(':', 1)
|
||||
if not x[0]:
|
||||
raise ParserException(self, ln, 'Identifier missing')
|
||||
|
||||
# It's a class, add to the current object as a children
|
||||
current_property = None
|
||||
name = x[0].rstrip()
|
||||
ignore_prev = name[0] == '-'
|
||||
if ignore_prev:
|
||||
name = name[1:]
|
||||
|
||||
if ord(name[0]) in Parser.CLASS_RANGE:
|
||||
if ignore_prev:
|
||||
raise ParserException(
|
||||
self, ln, 'clear previous, `-`, not allowed here')
|
||||
_objects, _lines = self.parse_level(
|
||||
level + 1, lines[i:], spaces)
|
||||
current_object.children = _objects
|
||||
lines = _lines
|
||||
i = 0
|
||||
|
||||
# It's a property
|
||||
else:
|
||||
if name not in Parser.PROP_ALLOWED:
|
||||
if not all(ord(z) in Parser.PROP_RANGE for z in name):
|
||||
raise ParserException(self, ln,
|
||||
'Invalid property name')
|
||||
if len(x) == 1:
|
||||
raise ParserException(self, ln, 'Syntax error')
|
||||
value = x[1].strip()
|
||||
if name == 'id':
|
||||
if len(value) <= 0:
|
||||
raise ParserException(self, ln, 'Empty id')
|
||||
if value in ('self', 'root'):
|
||||
raise ParserException(
|
||||
self, ln,
|
||||
'Invalid id, cannot be "self" or "root"')
|
||||
current_object.id = value
|
||||
elif len(value):
|
||||
rule = ParserRuleProperty(
|
||||
self, ln, name, value, ignore_prev)
|
||||
if name[:3] == 'on_':
|
||||
current_object.handlers.append(rule)
|
||||
else:
|
||||
ignore_prev = False
|
||||
current_object.properties[name] = rule
|
||||
else:
|
||||
current_property = name
|
||||
current_propobject = None
|
||||
|
||||
if ignore_prev: # it wasn't consumed
|
||||
raise ParserException(
|
||||
self, ln, 'clear previous, `-`, not allowed here')
|
||||
|
||||
# Two more levels?
|
||||
elif count == indent + 2 * spaces:
|
||||
if current_property in (
|
||||
'canvas', 'canvas.after', 'canvas.before'):
|
||||
_objects, _lines = self.parse_level(
|
||||
level + 2, lines[i:], spaces)
|
||||
rl = ParserRule(self, ln, current_property, rlevel)
|
||||
rl.children = _objects
|
||||
if current_property == 'canvas':
|
||||
current_object.canvas_root = rl
|
||||
elif current_property == 'canvas.before':
|
||||
current_object.canvas_before = rl
|
||||
else:
|
||||
current_object.canvas_after = rl
|
||||
current_property = None
|
||||
lines = _lines
|
||||
i = 0
|
||||
else:
|
||||
if current_propobject is None:
|
||||
current_propobject = ParserRuleProperty(
|
||||
self, ln, current_property, content)
|
||||
if current_property[:3] == 'on_':
|
||||
current_object.handlers.append(current_propobject)
|
||||
else:
|
||||
current_object.properties[current_property] = \
|
||||
current_propobject
|
||||
else:
|
||||
current_propobject.value += '\n' + content
|
||||
|
||||
# Too much indentation, invalid
|
||||
else:
|
||||
raise ParserException(self, ln,
|
||||
'Invalid indentation (too many levels)')
|
||||
|
||||
# Check the next line
|
||||
i += 1
|
||||
|
||||
return objects, []
|
||||
|
||||
|
||||
class ParserSelector(object):
|
||||
|
||||
def __init__(self, key):
|
||||
self.key = key.lower()
|
||||
|
||||
def match(self, widget):
|
||||
raise NotImplementedError
|
||||
|
||||
def __repr__(self):
|
||||
return '<%s key=%s>' % (self.__class__.__name__, self.key)
|
||||
|
||||
|
||||
class ParserSelectorClass(ParserSelector):
|
||||
|
||||
def match(self, widget):
|
||||
return self.key in widget.cls
|
||||
|
||||
|
||||
class ParserSelectorName(ParserSelector):
|
||||
|
||||
parents = {}
|
||||
|
||||
def get_bases(self, cls):
|
||||
for base in cls.__bases__:
|
||||
if base.__name__ == 'object':
|
||||
break
|
||||
yield base
|
||||
if base.__name__ == 'Widget':
|
||||
break
|
||||
for cbase in self.get_bases(base):
|
||||
yield cbase
|
||||
|
||||
def match(self, widget):
|
||||
parents = ParserSelectorName.parents
|
||||
cls = widget.__class__
|
||||
if cls not in parents:
|
||||
classes = [x.__name__.lower() for x in
|
||||
[cls] + list(self.get_bases(cls))]
|
||||
parents[cls] = classes
|
||||
return self.key in parents[cls]
|
||||
|
||||
def match_rule_name(self, rule_name):
|
||||
return self.key == rule_name.lower()
|
||||
Reference in New Issue
Block a user