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,)