def test1(self):
factory = UML.ElementFactory()
c = factory.create(UML.Class)
p = factory.create(UML.Package)
c.package = p
self.assertEquals(c.package, p)
self.assertEquals(c.namespace, p)
self.failUnless(c in p.ownedElement)
def testOwnedMember_Unlink(self):
factory = UML.ElementFactory()
c = factory.create(UML.Class)
p = factory.create(UML.Package)
c.package = p
c.unlink()
self.assertEquals([p], factory.lselect())
def test_extension_metaclass(self):
factory = UML.ElementFactory()
c = factory.create(UML.Class)
c.name = 'Class'
s = factory.create(UML.Stereotype)
s.name = 'Stereotype'
e = UML.model.create_extension(factory, c, s)
self.assertEquals(c, e.metaclass)
def test_namedelement_qualifiedname(self):
factory = UML.ElementFactory()
p = factory.create(UML.Package)
p.name = 'Package'
c = factory.create(UML.Class)
c.name = 'Class'
self.assertEquals(('Class', ), c.qualifiedName)
p.ownedClassifier = c
self.assertEquals(('Package', 'Class'), c.qualifiedName)
def test_namedelement_qualifiedname(self):
factory = UML.ElementFactory()
p = factory.create(UML.Package)
p.name = "Package"
c = factory.create(UML.Class)
c.name = "Class"
self.assertEqual(("Class", ), c.qualifiedName)
p.ownedClassifier = c
self.assertEqual(("Package", "Class"), c.qualifiedName)
def test_operation_parameter_deletion(self):
factory = UML.ElementFactory()
self.assertEquals(0, len(factory.lselect()))
c = factory.create(UML.Class)
c.name = 'Class'
o = factory.create(UML.Operation)
c.ownedOperation = o
UML.parse(o, 'a(x: int, y: int)')
c.unlink()
self.assertEquals(0, len(factory.lselect()), factory.lselect())
def test_verifier():
factory = UML.ElementFactory(EventManager())
c = factory.create(UML.Class)
p = factory.create(UML.Property)
c.ownedAttribute = p
assert not orphan_references(factory)
# Now create a separate item, not part of the factory:
m = UML.Comment(id="acd123")
m.annotatedElement = c
assert m in c.ownedComment
assert orphan_references(factory)
def test_metaclass_extension(self):
factory = UML.ElementFactory()
c = factory.create(UML.Class)
c.name = 'Class'
s = factory.create(UML.Stereotype)
s.name = 'Stereotype'
self.assertEquals([], c.extension)
self.assertEquals([], s.extension)
e = UML.model.create_extension(factory, c, s)
print(e.memberEnd)
self.assertEquals([e], c.extension)
self.assertEquals([], s.extension)
assert e.ownedEnd.type is s
def test_property_navigability(self):
factory = UML.ElementFactory()
p = factory.create(UML.Property)
assert p.navigability is None
c1 = factory.create(UML.Class)
c2 = factory.create(UML.Class)
a = UML.model.create_association(factory, c1, c2)
assert a.memberEnd[0].navigability is None
assert a.memberEnd[1].navigability is None
UML.model.set_navigability(a, a.memberEnd[0], True)
assert a.memberEnd[0].navigability is True
assert a.memberEnd[1].navigability is None
UML.model.set_navigability(a, a.memberEnd[0], False)
assert a.memberEnd[0].navigability is False
assert a.memberEnd[1].navigability is None
def test_association_endType(self):
factory = UML.ElementFactory()
c1 = UML.Class()
c2 = UML.Class()
a = UML.Association()
a.memberEnd = UML.Property()
a.memberEnd = UML.Property()
a.memberEnd[0].type = c1
a.memberEnd[1].type = c2
c1.ownedAttribute = a.memberEnd[0]
c2.ownedAttribute = a.memberEnd[1]
assert c1 in a.endType
assert c2 in a.endType
c3 = UML.Class()
a.memberEnd[1].type = c3
assert c1 in a.endType
assert c3 in a.endType
def setUp(self):
self.factory = UML.ElementFactory()
def factory():
event_manager = EventManager()
return UML.ElementFactory(event_manager)
dest='format',
metavar='format',
help='output file format, default pdf',
default='pdf',
choices=['pdf', 'svg', 'png'])
parser.add_option('-r', '--regex', dest='regex', metavar='regex',
help='process diagrams which name matches given regular expresion;' \
' name includes package name; regular expressions are case insensitive')
(options, args) = parser.parse_args()
if not args:
parser.print_help()
sys.exit(1)
factory = UML.ElementFactory()
name_re = None
if options.regex:
name_re = re.compile(options.regex, re.I)
# we should have some gaphor files to be processed at this point
for model in args:
message('loading model %s' % model)
storage.load(model, factory)
message('\nready for rendering\n')
for diagram in factory.select(lambda e: e.isKindOf(UML.Diagram)):
odir = pkg2dir(diagram.package)
# just diagram name
parser.add_option(
"-r",
"--regex",
dest="regex",
metavar="regex",
help="process diagrams which name matches given regular expresion;"
" name includes package name; regular expressions are case insensitive",
)
(options, args) = parser.parse_args()
if not args:
parser.print_help()
# sys.exit(1)
model = UML.ElementFactory()
name_re = None
if options.regex:
name_re = re.compile(options.regex, re.I)
# we should have some gaphor files to be processed at this point
for model in args:
message("loading model %s" % model)
storage.load(model, model)
message("\nready for rendering\n")
for diagram in model.select(lambda e: e.isKindOf(UML.Diagram)):
odir = pkg2dir(diagram.package)
# just diagram name
def test_ids(self):
factory = UML.ElementFactory()
c = factory.create(UML.Class)
assert c.id
p = factory.create_as(UML.Class, id=False)
assert p.id is False, p.id
def main():
def message(msg):
"""
Print message if user set verbose mode.
"""
global options
if options.verbose:
print(msg, file=sys.stderr)
usage = "usage: %prog [options] file1 file2..."
parser = optparse.OptionParser(usage=usage)
parser.add_option("-v",
"--verbose",
dest="verbose",
action="store_true",
help="verbose output")
parser.add_option(
"-u",
"--use-underscores",
dest="underscores",
action="store_true",
help="use underscores instead of spaces for output filenames",
)
parser.add_option("-d",
"--dir",
dest="dir",
metavar="directory",
help="output to directory")
parser.add_option(
"-f",
"--format",
dest="format",
metavar="format",
help="output file format, default pdf",
default="pdf",
choices=["pdf", "svg", "png"],
)
parser.add_option(
"-r",
"--regex",
dest="regex",
metavar="regex",
help="process diagrams which name matches given regular expresion;"
" name includes package name; regular expressions are case insensitive",
)
(options, args) = parser.parse_args()
if not args:
parser.print_help()
# sys.exit(1)
model = UML.ElementFactory()
name_re = None
if options.regex:
name_re = re.compile(options.regex, re.I)
# we should have some gaphor files to be processed at this point
for model in args:
message(f"loading model {model}")
storage.load(model, model)
message("\nready for rendering\n")
for diagram in model.select(lambda e: e.isKindOf(UML.Diagram)):
odir = pkg2dir(diagram.package)
# just diagram name
dname = diagram.name
# full diagram name including package path
pname = f"{odir}/{dname}"
if options.underscores:
odir = odir.replace(" ", "_")
dname = dname.replace(" ", "_")
if name_re and not name_re.search(pname):
message(f"skipping {pname}")
continue
if options.dir:
odir = f"{options.dir}/{odir}"
outfilename = f"{odir}/{dname}.{options.format}"
if not os.path.exists(odir):
message(f"creating dir {odir}")
os.makedirs(odir)
message(f"rendering: {pname} -> {outfilename}...")
view = View(diagram.canvas)
view.painter = ItemPainter()
tmpsurface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 0, 0)
tmpcr = cairo.Context(tmpsurface)
view.update_bounding_box(tmpcr)
tmpcr.show_page()
tmpsurface.flush()
w, h = view.bounding_box.width, view.bounding_box.height
if options.format == "pdf":
surface = cairo.PDFSurface(outfilename, w, h)
elif options.format == "svg":
surface = cairo.SVGSurface(outfilename, w, h)
elif options.format == "png":
surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, int(w + 1),
int(h + 1))
else:
assert False, f"unknown format {options.format}"
cr = cairo.Context(surface)
view.matrix.translate(-view.bounding_box.x, -view.bounding_box.y)
view.paint(cr)
cr.show_page()
if options.format == "png":
surface.write_to_png(outfilename)
surface.flush()
surface.finish()
