← Back
Editing: SpecNodes.py
## # Specification entity object # # Collects information about a particular system entity or aspect. # # The entity is of a general kind # It is defined by the particular aspects defined for it # The aspects must be 'compatible', which can be relatively checked. # The specobject is used for: # * generating tests # * generating docs # * generating help # * by creating docstrings # * by providing interactive help # # For test generation, it will delegate to test implementators. # For doc generation, it will delegate to doc implementators. # # The functionality needed here is therefore limited. # # name # aspects # # There is one predefine root # - should we call it Universe? # # The name can be full, a dotted name, or the short, last part. # # The name is treated as an aspect. # # Each aspect definition has a primary kind # Aspect kinds from guppy.gsl.Exceptions import * class SpecObject: def __init__(self, mod): self.mod = mod ## # Specification environment # Collects specifications from several files # Maps names to specification objects class SpecEnv: def __init__(self, mod): self.mod = mod self.unknown_nodes = [] self.files = [] def visit_default(self, node): print('add_unknown', node.tag) self.unknown_nodes.append(node) def visit_file(self, node): print('visit_file') file = FileEnv(self, node) self.files.append(file) def get_predefined_subjects(self, env): return (GuppyWorld(env),) class FileEnv: def __init__(self, env, node): mod = env.mod self.mod = mod self.name = self.filename = node.arg self.subjects = {} for s in env.get_predefined_subjects(self): self.subjects[s.name] = s file = Subject(self, node, self.name) node.children_accept(file) def visit_aspects_of(self, node): name = node.arg subject = self.find_subject(node, name) subject.add_aspects(node) def def_subject(self, node, name, subject): if name in self.subjects: self.error_node(node, 'Redefinition of %r.' % name) self.error_node(self.subjects[name].node, 'Previous definition of %r.' % name) else: self.subjects[name] = subject def error_node(self, node, msg, exception=None): index = node.index lineno = index + 1 print('%s:%s:' % (self.filename, lineno)) print(' %r' % self.get_line(index)) print(' %s' % msg) print() def find_subject(self, node, name): subject = self.subjects.get(name) if subject is None: self.error_node(node, 'No such subject: %r.' % name) return subject def get_line(self, index): try: with open(self.filename) as f: text = list(f.readlines())[index].rstrip() except Exception: text = None return text def get_subject(self, name): subject = self.subjects.get(name) if subject is None: subject = self.subjects[name] = Subject(self, name) return subject def get_aspect_subject(self, env, node): name = env.name+'::'+node.tag return self.get_subject(name) class Subject: def __init__(self, file, node, name): self.file = file self.node = node self.name = name self.aspects = [] def visit_default(self, node): of = node.tag.endswith('_of') name = node.arg define = name.startswith(':') if define: if of: self.file.error_node(node, "Both 'of' and '::'.") name = name[1:].strip() if of: ofsubject = self.file.find_subject(node, name) subject = self.new_subject_of(node, ofsubject) else: subject = Subject(self.file, node, name) if define: self.file.def_subject(node, name, subject) self.aspects.append(subject) node.children_accept(subject) def new_subject_of(self, node, of): tag = node.tag if tag == 'aspects_of': return AspectsOf(self.file, node, of) else: return SubjectOf(self.file, node, of) class AspectsOf(Subject): def __init__(self, file, node, of): self.node = node self.of = of self.aspects = [] def visit_default(self, node): self.of.visit_default(node) class SubjectOf(Subject): def __init__(self, file, node, of): self.node = node self.of = of self.aspects = [] class GuppyWorld(Subject): def __init__(self, env): self.file = env self.name = "Guppy World" self.node = None self.aspects = [] ## # A node represented with argument splitted in components of the form: # .tag: arg # text # ..child # ... # ..child # ... # # @param tag the text of the first line before the colon # @param arg the text of the first line after the colon (stripped) # @param text the text after the the first line before the first children # @param children the child nodes # @param index line index # @param src describes the source class SpecNode(object): __slots__ = 'tag', 'arg', 'children', 'index', 'src' def __init__(self, tag, arg, children=(), index=0, src=None): self.tag = tag self.arg = arg self.children = tuple(children) self.index = index self.src = src def __repr__(self): return '%s(%r,%r,%r)' % ( self.__class__.__name__, self.tag, self.arg, self.children) def __str__(self): return '%s(%r,%r,%s)' % ( self.__class__.__name__, self.tag, self.arg, '(%s)' % (','.join([str(c) for c in self.children]))) def arg_accept(self, visitor, prefix='visit_'): if self.arg: node = SpecNode('text', self.arg, (), self.index) node.accept(visitor, prefix) self.children_accept(visitor, prefix) def copy(self, tag=None, arg=None, children=None, index=None, src=None): if tag is None: tag = self.tag if arg is None: arg = self.arg if children is None: children = self.children if index is None: index = self.index if src is None: src = self.src return self.__class__(tag, arg, children, index, src) def children_accept(self, visitor, prefix='visit_'): for c in self.children: c.accept(visitor, prefix) def accept(self, visitor, prefix='visit_'): m = getattr(visitor, (prefix+self.tag), None) if m is None: m = getattr(visitor, (prefix+'default'), None) if m is None: msg = 'accept: unknown: %r, %r in %r' % ( prefix, self.tag, visitor) print(msg) raise ValueError(msg) return m(self) def error(self, msg, node=None): if node is None: node = self node.src.error(msg, node) def get_text(self): " Get the total text of all text children, joined with and ended with '\n' " text = [] for c in self.children: if c.tag == 'text': text.append(c.arg) if not c.arg.endswith('\n'): text.append('\n') return ''.join(text) def get_arg(self): arg = self.arg.strip() if arg.startswith(':'): arg = arg[1:].strip() return arg def get_arglist(self): arg = self.arg if arg.startswith(':'): arg = arg[1:] names = [x.strip() for x in arg.split(',')] if names == ['']: names = [] return names def get_arg_children(self): if self.arg: children = [SpecNode('text', self.arg, (), self.index, self.src)] children.extend(self.children) else: children = self.children return children def get_arg_rest(self, nostrip=0): arg = self.arg if not nostrip: arg = arg.strip() return arg, self.children def get_arg_norest(self): ''' Get the arg as by self.arg, but make sure there are no more children. ''' if self.children: raise SyntaxError('No children nodes expected in node: %s' % self) return self.arg.strip() def get_namearg(self): ''' Get the argument in the form of a name It is the argument stripped. And not allowed to contain : or , or new line. ''' name = self.arg.strip() if '\n' in name or ':' in name or ',' in name: raise SyntaxError('Invalid name: %r' % name) return name def split_attrs(self, tag=None, attrdict=False): if tag is None: tag = self.tag if attrdict: attrs = {} def addattr(tag, attr, node): if tag in attrs: node.error('Duplicate attribute: %s' % attr) else: attrs[tag] = attr else: attrs = [] def addattr(tag, attr, node): attrs.append((tag, attr)) children = [] for ch in self.children: if ch.tag == "with": for opt in ch.children: if opt.arg: arg = opt.arg else: self.error('Bad attribute, no argument.', opt) if opt.children: self.error( 'Expected no children to attribute.', opt.children[0]) if opt.arg: addattr(opt.tag, arg, opt) elif ch.tag[-1:] == '=': addattr(ch.tag[:-1], ch.arg, ch) else: children.append(ch) if len(children) == len(self.children): node = self else: node = self.__class__( tag, self.arg, children, self.index, self.src) return node, attrs class Source: def __init__(self, name, lines=None, string=None, nostrip=0, debug=0, max_errors=10): self.filename = name self.lines = lines self.string = string self.nostrip = nostrip self.debug = debug self.error_reports = [] self.max_errors = max_errors self.num_warnings = 0 self.num_errors = 0 def errmsg_context(self, context): linetext = '' filename = '<unknown file>' if context is not None: if hasattr(context, 'index'): index = context.index src = context.src else: index = context src = self if src is not None: filename = src.filename linetext = src.get_line(index=index) print('%s:%s:' % (filename, index+1)) if linetext: print(' %s' % linetext) def error(self, message, context=None, exception=None, more=(), harmless=0): self.error_reports.append( (message, context, exception, more, harmless)) if harmless: self.num_warnings += 1 else: self.num_errors += 1 self.errmsg_context(context) if harmless: print('* %s' % message) else: print('*** %s' % message) print() for msg, ctx in more: self.errmsg_context(ctx) print(' %s' % msg) print() if self.debug: import pdb pdb.set_trace() else: if self.num_errors >= self.max_errors: raise TooManyErrors('Too many errors, giving up') if exception is not None: raise exception def get_line(self, index): if self.lines is None: if self.string is None: if self.filename: try: with open(self.filename) as f: self.string = f.read() except Exception: return '' else: return '' self.lines = self.string.split('\n') return self.lines[index] class _GLUECLAMP_: _chgable_ = 'nodemap', 'SpecNode' _imports_ = ( '_parent:DottedTree', '_root:re', '_root:os', ) node_aliases_defs = ( ('attr', 'attribute'), ('c', 'comment'), ('cond', 'condition'), ('d', 'description'), ('dwh', 'description_with_header'), ('eg', 'example'), ('fop', 'function_operator'), ('iop', 'inplace_operator'), ('ka', 'key_arg'), ('op', 'operator'), ('rop', 'reverse_operator'), ('t', 'text'), ) def _get_node_aliases(self): return dict(self.node_aliases_defs) def _get_reverse_node_aliases(self): # Used to make names shorter return dict([(v, k) for k, v in self.node_aliases_defs]) def _get_is_not_ascii(self): return self.re.compile(eval(r'u"[\u0080-\uffff]"')).search ## # @return A tuple of predefined subjects. def get_predefined_subjects(self): return (GuppyWorld(self),) ## # Parses a file and makes a tree of nodes # @param file name of file containing a dotted tree # @return a SpecNode object # @more # First tag is special. # We don't interpret the first line of the file, # but uses a special file tag. def node_of_file(self, file, nostrip=0): src = Source(name=file, nostrip=nostrip) dtree = self.DottedTree.parse_file(file, src) tag = 'file' arg = file text = dtree.tag.strip() children = self.nodes_of_dforest(dtree.children, src) index = dtree.index return self.node_of_tatci(tag, arg, text, children, index, src) def node_of_string(self, string, name='<string>', nostrip=0): dtree = self.DottedTree.parse_string(string) tag = 'string' arg = name src = Source(name=name, string=string, nostrip=nostrip) text = dtree.tag.strip() index = dtree.index children = self.nodes_of_dforest(dtree.children, src) return self.node_of_tatci(tag, arg, text, children, index, src) def node_of_dtree(self, dtree, src): tag = dtree.tag textpos = tag.find('\n') if textpos == -1: textpos = len(tag) equpos = tag.find('=', 0, textpos) colonpos = tag.find(':', 0, textpos) if equpos != -1 and (colonpos == -1 or equpos < colonpos): tag, arg = (tag[:equpos].strip()+'=', tag[equpos+1:].strip()) else: if colonpos == -1: if not ' ' in tag[:textpos] or textpos >= len(tag.rstrip()): colonpos = textpos else: raise SyntaxError( 'No colon in spaced tag in node %s' % dtree) tag, arg = (tag[:colonpos].strip(), tag[colonpos+1:] ) if tag in self.node_aliases: tag = self.node_aliases[tag] tag = tag.replace(' ', '_') if tag != 'text' and not src.nostrip: arg = arg.strip() children = self.nodes_of_dforest(dtree.children, src) return self.node_of_taci(tag, arg, children, dtree.index, src) def nodes_of_dforest(self, dforest, src): onodes = [self.node_of_dtree(c, src) for c in dforest] nodes = [] for node in onodes: if node.tag != 'include': nodes.append(node) continue filename = node.arg.strip() filename = self.os.path.join(self.os.path.dirname(src.filename), filename) node = self.node_of_file(filename, nostrip=src.nostrip) nodes.extend(node.children) return tuple(nodes) def _get_node_of_taci(self): return SpecNode def node_of_tatci(self, tag, arg, text, children=(), index=0, src=None): if text: if tag == 'text': if arg: arg = arg + '\n' + text else: arg = text else: children = (self.node_of_taci( 'text', text, (), index, src),) + children return self.node_of_taci(tag, arg, children, index, src) def node_of_text(self, text): # Returns a node that is either # - a 'text' node, if text was all ascii # - a 'char' node, if text was a single non-ascii # - a 'block' with children being a sequence of char and text nodes, # if text contained ascii and non-ascii characters nodes = self.nodes_of_text(text) if len(nodes) == 1: return nodes[0] else: return self.node_of_taci('block', '', nodes) def nodes_of_text(self, text): # Returns a sequence of nodes, encoding text. nodes = [] if self.is_not_ascii(text): chars = [] for char in text: no = ord(char) if no < 128: chars.append(char) else: if chars: nodes.append(self.node_of_taci('text', ''.join(chars))) chars = [] nodes.append(self.node_of_taci('char', str(no))) if chars: nodes.append(self.node_of_taci('text', ''.join(chars))) else: nodes.append(self.node_of_taci('text', text)) return nodes def main(self): root = self._root specdir = root.os.path.join( root.os.path.dirname(root.os.path.realpath(__file__)), '../../specs') main_dt_name = root.os.path.join(specdir, "docexample.gsl") if not root.os.path.exists(main_dt_name): print('%s does not exist, skipping test' % main_dt_name) return env = self.SpecEnv(self) node = self.node_of_file(main_dt_name) node.accept(env) def print_doc(self, dt): self.print_doc() def unparse_head(self, level, tag, arg, text): head = tag if arg: head = head + ': ' + arg if text: head = head + '\n' + text tag = self.DottedTree.unparse_tag(level, head) return tag def test_main(): from guppy import Root root = Root() root.guppy.gsl.SpecNodes.main()
Save File
Cancel