Sindbad~EG File Manager
##
# 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()
Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists