def on_builder_inited(self):
# show deprecated message
if self.builder.config.rackdiag_tex_image_format:
self.builder.warn(
'rackdiag_tex_image_format is deprecated. Use rackdiag_latex_image_format.'
)
# initialize fontmap
global fontmap
try:
fontmappath = self.builder.config.rackdiag_fontmap
fontmap = FontMap(fontmappath)
except:
fontmap = FontMap(None)
try:
fontpath = self.builder.config.rackdiag_fontpath
if isinstance(fontpath, string_types):
fontpath = [fontpath]
if fontpath:
config = namedtuple('Config', 'font')(fontpath)
fontpath = detectfont(config)
fontmap.set_default_font(fontpath)
except:
pass
def test_fontmap_duplicated_fontentry1(self):
_config = u("[fontmap]\nsansserif: %s\nsansserif: %s\n") % \
(self.fontpath[0], self.fontpath[1])
config = StringIO(_config)
if sys.version_info[0] == 2:
fmap = FontMap(config)
font1 = fmap.find()
self.assertEqual('sans-serif', font1.generic_family)
self.assertEqual(self.fontpath[1], font1.path)
self.assertEqual(11, font1.size)
else:
import configparser
with self.assertRaises(configparser.DuplicateOptionError):
FontMap(config)
def test_fontmap_switch_defaultfamily(self):
_config = "[fontmap]\nserif-bold: %s\n" % self.fontpath[0]
config = StringIO(_config)
fmap = FontMap(config)
font1 = fmap.find()
self.assertEqual('sansserif-normal', font1.familyname)
self.assertEqual(None, font1.path)
self.assertEqual(11, font1.size)
fmap.set_default_fontfamily('serif-bold')
font2 = fmap.find()
self.assertEqual('serif-bold', font2.familyname)
self.assertEqual(self.fontpath[0], font2.path)
self.assertEqual(11, font2.size)
fmap.set_default_fontfamily('fantasy-italic')
font3 = fmap.find()
self.assertEqual('fantasy-italic', font3.familyname)
self.assertEqual(None, font3.path)
self.assertEqual(11, font3.size)
fmap.fontsize = 20
font4 = fmap.find()
self.assertEqual('fantasy-italic', font4.familyname)
self.assertEqual(None, font4.path)
self.assertEqual(20, font4.size)
def flowchartdiag_generate_image(source, format):
from blockdiag import parser, builder, drawer
from blockdiag.utils.fontmap import FontMap
from StringIO import StringIO
from flowchartdiag import parse, write_stmt
try:
ast = parse(source)
dot = StringIO()
dot.write("{\n")
dot.write(" orientation = portrait\n")
dot.write(" edge_layout = flowchart\n")
dot.write(" node_width = 256\n")
write_stmt(dot, ast.body)
dot.write("}\n")
tree = parser.parse_string(dot.getvalue())
diagram = builder.ScreenNodeBuilder.build(tree)
draw = drawer.DiagramDraw(format, diagram, fontmap=FontMap(),
ignore_pil=True)
draw.draw()
image = draw.save()
etype = None
error = None
except Exception, e:
image = ''
etype = e.__class__.__name__
error = str(e)
def renderToFile(self, content, imagePath):
"""
content - текст, описывающий диаграмму
imagePath - полный путь до создаваемого файла
"""
from blockdiag.parser import parse_string
from blockdiag.drawer import DiagramDraw
from blockdiag.builder import ScreenNodeBuilder
from blockdiag.utils.fontmap import FontMap
font = os.path.join(os.path.dirname(os.path.abspath(__file__)),
u"fonts", self._fontDefault)
fontmap = FontMap()
fontmap.set_default_font(font)
text = u"blockdiag {{ {content} }}".format(content=content)
tree = parse_string(text)
diagram = ScreenNodeBuilder.build(tree)
draw = DiagramDraw("png",
diagram,
imagePath,
fontmap=fontmap,
antialias=True)
draw.draw()
draw.save()
def test_fontmap_empty_config(self):
config = StringIO("")
fmap = FontMap(config)
font1 = fmap.find()
self.assertTrue(font1)
self.assertEqual('sans-serif', font1.generic_family)
self.assertEqual(None, font1.path)
self.assertEqual(11, font1.size)
element = FontElement('sansserif', 11)
font2 = fmap.find(element)
self.assertEqual(font1.familyname, font2.familyname)
self.assertEqual(font1.path, font2.path)
self.assertEqual(font1.size, font2.size)
element = FontElement('sansserif-normal', 11)
font3 = fmap.find(element)
self.assertEqual(font1.familyname, font3.familyname)
self.assertEqual(font1.path, font3.path)
self.assertEqual(font1.size, font3.size)
# non-registered familyname
element = FontElement('my-sansserif-normal', 11)
font4 = fmap.find(element)
self.assertEqual(font1.familyname, font4.familyname)
self.assertEqual(font1.path, font4.path)
self.assertEqual(font1.size, font4.size)
def create_fontmap(options):
fontmap = FontMap(options.fontmap)
if fontmap.find().path is None or options.font:
fontpath = detectfont(options)
fontmap.set_default_font(fontpath)
return fontmap
def test_fontmap_none_config(self):
fmap = FontMap()
font1 = fmap.find()
self.assertTrue(font1)
self.assertEqual('sans-serif', font1.generic_family)
self.assertEqual(None, font1.path)
self.assertEqual(11, font1.size)
def test_fontmap_with_nonexistence_fontpath(self):
_config = "[fontmap]\nserif: unknown_file\n"
config = StringIO(_config)
fmap = FontMap(config)
font1 = fmap.find()
self.assertEqual('sans-serif', font1.generic_family)
self.assertEqual(None, font1.path)
self.assertEqual(11, font1.size)
def get_fontmap():
from StringIO import StringIO
from blockdiag.utils.fontmap import FontMap
dummy = re.sub('pyc', 'py', __file__)
config = open(u"%s/../fontmaprc" % os.path.dirname(dummy)).read()
config = re.sub('FILENAME', dummy, config)
fmap = FontMap(StringIO(config))
return fmap
def test_fontmap_duplicated_fontentry2(self):
_config = u("[fontmap]\nsansserif: %s\nsansserif-normal: %s\n") % \
(self.fontpath[0], self.fontpath[1])
config = StringIO(_config)
fmap = FontMap(config)
font1 = fmap.find()
self.assertEqual('sans-serif', font1.generic_family)
self.assertEqual(self.fontpath[1], font1.path)
self.assertEqual(11, font1.size)
def test_fontmap_duplicated_fontentry1(self):
- _config = "[fontmap]\nsansserif: %s\nsansserif-normal: %s\n" % \
- (self.fontpath[0], self.fontpath[1])
- config = StringIO(_config)
- fmap = FontMap(config)
-
- font1 = fmap.find()
- self.assertEqual('sansserif', font1.generic_family)
- self.assertEqual(self.fontpath[1], font1.path)
- self.assertEqual(11, font1.size)
def _create_fontmap(fontmap, font):
"""
Inspired from :epkg:`blockdiag` source file (*_bootstrap.py*).
"""
from blockdiag.utils.fontmap import FontMap
fontmap = FontMap(fontmap)
if fontmap.find().path is None or font:
fontpath = _detectfont(font)
fontmap.set_default_font(fontpath)
return fontmap
def test_fontmap_using_fontalias(self):
_config = ("[fontmap]\nserif-bold: %s\n" +
"[fontalias]\ntest = serif-bold\n") % self.fontpath[0]
config = StringIO(_config)
fmap = FontMap(config)
element = FontElement('test', 20)
font1 = fmap.find(element)
self.assertEqual('serif-bold', font1.familyname)
self.assertEqual(self.fontpath[0], font1.path)
self.assertEqual(20, font1.size)
def test_fontmap_with_capital_character(self):
_config = "[fontmap]\nCapitalCase-sansserif: %s\n" % \
self.fontpath[0]
config = StringIO(_config)
fmap = FontMap(config)
element = FontElement('CapitalCase-sansserif', 11)
font1 = fmap.find(element)
self.assertEqual('sans-serif', font1.generic_family)
self.assertEqual('capitalcase-sansserif-normal', font1.familyname)
self.assertEqual(self.fontpath[0], font1.path)
self.assertEqual(11, font1.size)
def test_fontmap_duplicated_fontentry2(self):
# this testcase is only for python2.6 or later
if sys.version_info > (2, 6):
_config = u("[fontmap]\nsansserif: %s\nsansserif-normal: %s\n") % \
(self.fontpath[0], self.fontpath[1])
config = StringIO(_config)
fmap = FontMap(config)
font1 = fmap.find()
self.assertEqual('sans-serif', font1.generic_family)
self.assertEqual(self.fontpath[1], font1.path)
self.assertEqual(11, font1.size)
def test_fontmap_by_file(self):
tmp = tempfile.mkstemp()
_config = "[fontmap]\nsansserif: %s\nsansserif-bold: %s\n" % \
(self.fontpath[0], self.fontpath[1])
fp = os.fdopen(tmp[0], 'wt')
fp.write(_config)
fp.close()
fmap = FontMap(tmp[1])
font1 = fmap.find()
self.assertTrue(font1)
self.assertEqual('sans-serif', font1.generic_family)
self.assertEqual(self.fontpath[0], font1.path)
self.assertEqual(11, font1.size)
os.unlink(tmp[1])
def __init__(self, diagram, drawer=None, fontmap=None):
self.drawer = drawer
if diagram.node_width is not None:
self.node_width = diagram.node_width
if diagram.node_height is not None:
self.node_height = diagram.node_height
if diagram.span_width is not None:
self.span_width = diagram.span_width
if diagram.span_height is not None:
self.span_height = diagram.span_height
if fontmap is not None:
self.fontmap = fontmap
else:
self.fontmap = FontMap()
if diagram.page_padding is not None:
self.page_padding = diagram.page_padding
if diagram.edge_layout is not None:
self.edge_layout = diagram.edge_layout
# setup spreadsheet
sheet = self.spreadsheet = SpreadSheetMetrics(self)
nodes = [n for n in diagram.traverse_nodes() if n.drawable]
node_width = self.node_width
for x in range(diagram.colwidth):
widths = [n.width for n in nodes if n.xy.x == x]
if widths:
width = max(n or node_width for n in widths)
sheet.set_node_width(x, width)
node_height = self.node_height
for y in range(diagram.colheight):
heights = [n.height for n in nodes if n.xy.y == y]
if heights:
height = max(n or node_height for n in heights)
sheet.set_node_height(y, height)
def draw_blockdiag(content, filename=None, font_path=None, output_fmt='png'):
diag_type, content = content.split(" ", 1)
parser, builder, drawer = DIAG_MODULES[diag_type.strip()]
tree = parser.parse_string(content)
diagram = builder.ScreenNodeBuilder.build(tree)
fontmap = FontMap()
if font_path:
fontmap.set_default_font(font_path)
draw = drawer.DiagramDraw(output_fmt,
diagram,
filename=filename,
antialias=True,
fontmap=fontmap)
draw.draw()
return draw.save()
def test_fontmap_including_bom_by_file(self):
tmp = tempfile.mkstemp()
_config = ("[fontmap]\nsansserif: %s\n" +
"sansserif-bold: %s\n") % \
(self.fontpath[0], self.fontpath[1])
try:
fp = os.fdopen(tmp[0], 'wb')
fp.write(_config.encode('utf-8-sig'))
fp.close()
fmap = FontMap(tmp[1])
font1 = fmap.find()
self.assertTrue(font1)
self.assertEqual('sans-serif', font1.generic_family)
self.assertEqual(self.fontpath[0], font1.path)
self.assertEqual(11, font1.size)
finally:
os.unlink(tmp[1])
def test_fontmap_normal_config(self):
_config = "[fontmap]\nsansserif: %s\nsansserif-bold: %s\n" % \
(self.fontpath[0], self.fontpath[1])
config = StringIO(_config)
fmap = FontMap(config)
font1 = fmap.find()
self.assertTrue(font1)
self.assertEqual('sans-serif', font1.generic_family)
self.assertEqual(self.fontpath[0], font1.path)
self.assertEqual(11, font1.size)
element = FontElement('sansserif', 11)
font2 = fmap.find(element)
self.assertEqual(font1.familyname, font2.familyname)
self.assertEqual(font1.path, font2.path)
self.assertEqual(font1.size, font2.size)
element = FontElement('sansserif-normal', 11)
font3 = fmap.find(element)
self.assertEqual(font1.familyname, font3.familyname)
self.assertEqual(font1.path, font3.path)
self.assertEqual(font1.size, font3.size)
element = FontElement('sansserif-bold', 11)
font4 = fmap.find(element)
self.assertEqual('sansserif-bold', font4.familyname)
self.assertEqual(self.fontpath[1], font4.path)
self.assertEqual(font1.size, font4.size)
element = FontElement(None, None)
font5 = fmap.find(element)
self.assertEqual(font1.familyname, font5.familyname)
self.assertEqual(font1.path, font5.path)
self.assertEqual(font1.size, font5.size)
element = object()
font6 = fmap.find(element)
self.assertEqual(font1.familyname, font6.familyname)
self.assertEqual(font1.path, font6.path)
self.assertEqual(font1.size, font6.size)
def draw_diag(path):
read_file_and_process(path)
diagram_definition = convert_to_origin_seqdiag()
print('Converted definition : {}'.format(diagram_definition))
tree = parser.parse_string(diagram_definition)
diagram = builder.ScreenNodeBuilder.build(tree)
fm = FontMap()
fm.set_default_font('./malgun.ttf')
draw = drawer.DiagramDraw('PNG',
diagram,
filename='{}.png'.format(
path.split('/\\')[-1].split('.')[0]),
fontmap=fm)
draw.draw()
draw.save()
pass
def test_fontmap_with_nodefault_fontentry(self):
_config = "[fontmap]\nserif: %s\n" % self.fontpath[0]
config = StringIO(_config)
fmap = FontMap(config)
font1 = fmap.find()
self.assertEqual('sans-serif', font1.generic_family)
self.assertEqual(None, font1.path)
self.assertEqual(11, font1.size)
element = FontElement('serif', 11)
font2 = fmap.find(element)
self.assertEqual('serif', font2.generic_family)
self.assertEqual(self.fontpath[0], font2.path)
self.assertEqual(font1.size, font2.size)
element = FontElement('fantasy', 20)
font3 = fmap.find(element)
self.assertEqual('sans-serif', font3.generic_family)
self.assertEqual(None, font3.path)
self.assertEqual(20, font3.size)
def test_fontinfo_parse(self):
font = FontInfo("serif", None, 11)
@@ -212,15 +212,17 @@ class TestUtilsFontmap(unittest2.TestCas
self.assertEqual(11, font1.size)
def test_fontmap_duplicated_fontentry1(self):
- _config = "[fontmap]\nsansserif: %s\nsansserif-normal: %s\n" % \
- (self.fontpath[0], self.fontpath[1])
- config = StringIO(_config)
- fmap = FontMap(config)
-
- font1 = fmap.find()
- self.assertEqual('sansserif', font1.generic_family)
- self.assertEqual(self.fontpath[1], font1.path)
- self.assertEqual(11, font1.size)
+ # this testcase is only for python2.6 or later
+ if sys.version_info > (2, 6):
+ _config = "[fontmap]\nsansserif: %s\nsansserif-normal: %s\n" % \
+ (self.fontpath[0], self.fontpath[1])
+ config = StringIO(_config)
+ fmap = FontMap(config)
+
+ font1 = fmap.find()
+ self.assertEqual('sansserif', font1.generic_family)
+ self.assertEqual(self.fontpath[1], font1.path)
+ self.assertEqual(11, font1.size)
@stderr_wrapper
def test_fontmap_with_nodefault_fontentry(self):
def test_fontmap_duplicated_fontentry1(self):
_config = "[fontmap]\nsansserif: %s\nsansserif: %s\n" % \
(self.fontpath[0], self.fontpath[1])
config = StringIO(_config)
with self.assertRaises(configparser.DuplicateOptionError):
FontMap(config)
def main(args):
print("YASM: Starting...")
url_paths = []
root = {}
with open(args.file) as json_file:
data = json.load(json_file)
if args.sdsp:
data = rewrite_subdomains_as_slash(data)
# Split URL paths into elements along /
for item in data:
split = item['url'].rstrip("/").split('/')
url_paths.append(split[2:])
if args.sdsp:
url_paths[-1].append({'title': item['title'], 'url': split[-1],
'subdomain': item['subdomain']})
else:
url_paths[-1].append({'title': item['title'], 'url': split[-1]})
# Build tree structure from elements
for path in url_paths:
# Get element if it exists, set to empty if not
branch = root.setdefault(path[0], [{}, []])
for i in path[1:-1]:
branch = branch[0].setdefault(i, [{}, []])
branch[1].append(path[-1])
# Delete empty elements
delete_empty(root)
# Output JSON file (Maybe move to util file)
output_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"output")
if not os.path.exists(output_dir):
os.makedirs(output_dir)
output_file_json = os.path.join(output_dir, os.path.split(args.file)[-1])
with open(output_file_json, 'w') as outfile:
json.dump(root, outfile, indent=2, ensure_ascii=False)
# To append .gv, .pdf/.png/.svg later
output_name = output_file_json[:-len(".json")]
if args.depth == 694201337:
calc_max_depth = get_max_depth(root)
else:
calc_max_depth = args.depth
# Sitemap via dot or blockdiag
if args.engine == "dot":
dot = Digraph()
dot.graph_attr['rankdir'] = 'TB'
dot.graph_attr['splines'] = 'ortho'
dot.graph_attr['concentrate'] = 'true'
# User formatting options
dot.graph_attr['nodesep'] = args.widthpadding
dot.graph_attr['ranksep'] = args.heightpadding
dot.node_attr['shape'] = 'rect'
dot.node_attr['style'] = 'filled'
last = create_nodes(root, dot, args.depth, calc_max_depth=calc_max_depth)
graphviz_legend(last, dot)
# Save to file
# GV creates a PDF/SVG and .gv at the same time, need to rename one
dot.format = args.type
output_file_gv = output_name + ".gv"
dot.render(output_name, view=args.instant)
os.rename(output_name, output_file_gv)
elif args.engine == "blockdiag":
dotDiag = Digraph()
create_nodes(root, dotDiag, args.depth, blockdiag=True, calc_max_depth=calc_max_depth)
source = dotDiag.source
source = source.replace("digraph", "blockdiag")
# Legend/Key
blockdiag_legend = """group {
label = "Legend";
color="#808080";
Parent -> Child;
}
}"""
source = source.replace("}", blockdiag_legend)
# Colors
source = source.replace("subgraph", "group")
source = source.replace("fillcolor", ",color")
source = source.replace("style=filled", "")
# User formatting options
source = add_blockdiag_option(source,
"orientation", args.orientation)
source = add_blockdiag_option(source,
"span_width", args.widthpadding)
source = add_blockdiag_option(source,
"span_height", args.heightpadding)
tree = blockdiagParser.parse_string(source)
diagram = builder.ScreenNodeBuilder.build(tree)
# Font only needed for PDF output
# use project specific font file
fontname = "DejaVuSans.ttf"
fontpath = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"..", "util", fontname)
fontmap = FontMap()
fontmap.set_default_font(fontpath)
draw = drawer.DiagramDraw(args.type, diagram,
filename=output_name + '.' + args.type,
fontmap=fontmap)
draw.draw()
draw.save()
print("YASM: Finished.")
def __init__(self, *args, **kwargs):
super(PADImageDraw, self).__init__(*args, **kwargs)
self.fontmap = FontMap()
self.fontmap.set_default_font('/Library/Fonts/Hiragino Sans GB W3.otf')
self.font = self.fontmap.find()
def create_fontmap():
fontmap = FontMap(None)
fontmap.set_default_font(
os.path.join(os.getcwd(), 'dummy_font', 'ipag.ttf'))
return fontmap
