Debian Codegraph @

blueprintcompiler/outputs/xml/__init__.py

raw
1 import typing as T
2
3 from ...language import *
4 from .. import OutputFormat
5 from .xml_emitter import XmlEmitter
6
7
8 class XmlOutput(OutputFormat):
9 def __init__(self, indent: T.Optional[int] = 2, generated_notice: bool = True):
10 self.indent = indent
11 self.generated_notice = generated_notice
12
13 def emit(self, ui: UI) -> str:
14 xml = XmlEmitter(self.indent, self.generated_notice)
15 self._emit_ui(ui, xml)
16 return xml.result
17
18 def _emit_ui(self, ui: UI, xml: XmlEmitter):
19 if domain := ui.translation_domain:
20 xml.start_tag("interface", domain=domain.domain)
21 else:
22 xml.start_tag("interface")
23
24 self._emit_gtk_directive(ui.gtk_decl, xml)
25
26 for x in ui.contents:
27 if isinstance(x, Template):
28 self._emit_template(x, xml)
29 elif isinstance(x, Object):
30 self._emit_object(x, xml)
31 elif isinstance(x, Menu):
32 self._emit_menu(x, xml)
33 else:
34 raise CompilerBugError()
35
36 xml.end_tag()
37
38 def _emit_gtk_directive(self, gtk: GtkDirective, xml: XmlEmitter):
39 xml.put_self_closing("requires", lib="gtk", version=gtk.gir_namespace.version)
40
41 def _emit_template(self, template: Template, xml: XmlEmitter):
42 xml.start_tag(
43 "template", **{"class": template.gir_class}, parent=template.parent_type
44 )
45 self._emit_object_or_template(template, xml)
46 xml.end_tag()
47
48 def _emit_object(self, obj: Object, xml: XmlEmitter):
49 xml.start_tag(
50 "object",
51 **{"class": obj.class_name},
52 id=obj.id,
53 )
54 self._emit_object_or_template(obj, xml)
55 xml.end_tag()
56
57 def _emit_object_or_template(
58 self, obj: T.Union[Object, Template, ExtListItemFactory], xml: XmlEmitter
59 ):
60 for child in obj.content.children:
61 if isinstance(child, Property):
62 self._emit_property(child, xml)
63 elif isinstance(child, Signal):
64 self._emit_signal(child, xml)
65 elif isinstance(child, Child):
66 self._emit_child(child, xml)
67 else:
68 self._emit_extensions(child, xml)
69
70 # List action widgets
71 action_widgets = obj.action_widgets
72 if action_widgets:
73 xml.start_tag("action-widgets")
74 for action_widget in action_widgets:
75 xml.start_tag(
76 "action-widget",
77 response=action_widget.response_id,
78 default=action_widget.is_default or None,
79 )
80 xml.put_text(action_widget.widget_id)
81 xml.end_tag()
82 xml.end_tag()
83
84 def _emit_menu(self, menu: Menu, xml: XmlEmitter):
85 xml.start_tag(menu.tag, id=menu.id)
86 for child in menu.items:
87 if isinstance(child, Menu):
88 self._emit_menu(child, xml)
89 elif isinstance(child, MenuAttribute):
90 xml.start_tag(
91 "attribute",
92 name=child.name,
93 **self._translated_string_attrs(child.value.child),
94 )
95 xml.put_text(child.value.string)
96 xml.end_tag()
97 else:
98 raise CompilerBugError()
99 xml.end_tag()
100
101 def _emit_property(self, property: Property, xml: XmlEmitter):
102 value = property.value
103
104 props: T.Dict[str, T.Optional[str]] = {
105 "name": property.name,
106 }
107
108 if isinstance(value, Value):
109 child = value.child
110
111 if isinstance(child, Translated):
112 xml.start_tag(
113 "property", **props, **self._translated_string_attrs(child)
114 )
115 xml.put_text(child.string)
116 xml.end_tag()
117 else:
118 xml.start_tag("property", **props)
119 self._emit_value(value, xml)
120 xml.end_tag()
121
122 elif isinstance(value, Binding):
123 if simple := value.simple_binding:
124 props["bind-source"] = self._object_id(value, simple.source)
125 props["bind-property"] = simple.property_name
126 flags = []
127 if not simple.no_sync_create:
128 flags.append("sync-create")
129 if simple.inverted:
130 flags.append("invert-boolean")
131 if simple.bidirectional:
132 flags.append("bidirectional")
133 props["bind-flags"] = "|".join(flags) or None
134
135 xml.put_self_closing("property", **props)
136 else:
137 xml.start_tag("binding", **props)
138 self._emit_expression(value.expression, xml)
139 xml.end_tag()
140
141 elif isinstance(value, ExprValue):
142 xml.start_tag("property", **props)
143 self._emit_expression(value.expression, xml)
144 xml.end_tag()
145
146 elif isinstance(value, Menu):
147 xml.start_tag("property", **props)
148 self._emit_menu(value, xml)
149 xml.end_tag()
150
151 elif isinstance(value, ObjectValue):
152 xml.start_tag("property", **props)
153 self._emit_object(value.object, xml)
154 xml.end_tag()
155
156 elif isinstance(value, ArrayValue):
157 xml.start_tag("property", **props)
158 values = list(value.values)
159 if len(values) > 0:
160 for value in values[:-1]:
161 self._emit_value(value, xml)
162 xml.put_text("\n")
163 self._emit_value(values[-1], xml)
164 xml.end_tag()
165
166 else:
167 raise CompilerBugError()
168
169 def _translated_string_attrs(
170 self, translated: T.Optional[T.Union[QuotedLiteral, Translated]]
171 ) -> T.Dict[str, T.Optional[str]]:
172 if translated is None:
173 return {}
174 elif isinstance(translated, QuotedLiteral):
175 return {}
176 else:
177 return {"translatable": "yes", "context": translated.translate_context}
178
179 def _emit_signal(self, signal: Signal, xml: XmlEmitter):
180 name = signal.name
181 if signal.detail_name:
182 name += "::" + signal.detail_name
183 xml.put_self_closing(
184 "signal",
185 name=name,
186 handler=signal.handler,
187 swapped=signal.is_swapped,
188 after=signal.is_after or None,
189 object=(
190 self._object_id(signal, signal.object_id) if signal.object_id else None
191 ),
192 )
193
194 def _emit_child(self, child: Child, xml: XmlEmitter):
195 child_type = internal_child = None
196 if child.annotation is not None:
197 annotation = child.annotation.child
198 if isinstance(annotation, ChildType):
199 child_type = annotation.child_type
200 elif isinstance(annotation, ChildInternal):
201 internal_child = annotation.internal_child
202 elif isinstance(annotation, ChildExtension):
203 child_type = "action"
204 else:
205 raise CompilerBugError()
206
207 xml.start_tag("child", type=child_type, internal_child=internal_child)
208 self._emit_object(child.object, xml)
209 xml.end_tag()
210
211 def _emit_literal(self, literal: Literal, xml: XmlEmitter):
212 value = literal.value
213 if isinstance(value, IdentLiteral):
214 value_type = value.context[ValueTypeCtx].value_type
215 if isinstance(value_type, gir.BoolType):
216 xml.put_text(value.ident)
217 elif isinstance(value_type, gir.Enumeration):
218 xml.put_text(str(value_type.members[value.ident].value))
219 else:
220 xml.put_text(self._object_id(value, value.ident))
221 elif isinstance(value, TypeLiteral):
222 xml.put_text(value.type_name.glib_type_name)
223 else:
224 if isinstance(value.value, float) and value.value == int(value.value):
225 xml.put_text(int(value.value))
226 else:
227 xml.put_text(value.value)
228
229 def _emit_value(self, value: Value, xml: XmlEmitter):
230 if isinstance(value.child, Literal):
231 self._emit_literal(value.child, xml)
232 elif isinstance(value.child, Flags):
233 xml.put_text(
234 "|".join([str(flag.value or flag.name) for flag in value.child.flags])
235 )
236 else:
237 raise CompilerBugError()
238
239 def _emit_expression(self, expression: Expression, xml: XmlEmitter):
240 self._emit_expression_part(expression.last, xml)
241
242 def _emit_expression_part(self, expression: ExprBase, xml: XmlEmitter):
243 if isinstance(expression, TranslatedExpr):
244 self._emit_translated_expr(expression, xml)
245 elif isinstance(expression, LiteralExpr):
246 self._emit_literal_expr(expression, xml)
247 elif isinstance(expression, LookupOp):
248 self._emit_lookup_op(expression, xml)
249 elif isinstance(expression, Expression):
250 self._emit_expression(expression, xml)
251 elif isinstance(expression, CastExpr):
252 self._emit_cast_expr(expression, xml)
253 elif isinstance(expression, ClosureExpr):
254 self._emit_closure_expr(expression, xml)
255 elif isinstance(expression, TryExpr):
256 self._emit_try_expr(expression, xml)
257 else:
258 raise CompilerBugError()
259
260 def _emit_translated_expr(self, expr: TranslatedExpr, xml: XmlEmitter):
261 xml.start_tag(
262 "constant",
263 type="gchararray",
264 **self._translated_string_attrs(expr.translated),
265 )
266 xml.put_text(expr.translated.string)
267 xml.end_tag()
268
269 def _emit_literal_expr(self, expr: LiteralExpr, xml: XmlEmitter):
270 if expr.is_this:
271 return
272
273 if (
274 isinstance(expr.literal.value, IdentLiteral)
275 and expr.literal.value.ident == "null"
276 and not expr.is_object
277 ):
278 xml.put_self_closing("constant", initial=True, type=expr.type)
279 return
280
281 if expr.is_object:
282 xml.start_tag("constant")
283 else:
284 xml.start_tag("constant", type=expr.type)
285 self._emit_literal(expr.literal, xml)
286 xml.end_tag()
287
288 def _emit_lookup_op(self, expr: LookupOp, xml: XmlEmitter):
289 xml.start_tag("lookup", name=expr.property_name, type=expr.lhs.type)
290 if isinstance(expr.lhs, LiteralExpr) and expr.lhs.is_object:
291 # If it's an object literal, we can skip the <constant> tag
292 self._emit_literal(expr.lhs.literal, xml)
293 else:
294 self._emit_expression_part(expr.lhs, xml)
295 xml.end_tag()
296
297 def _emit_cast_expr(self, expr: CastExpr, xml: XmlEmitter):
298 self._emit_expression_part(expr.lhs, xml)
299
300 def _emit_closure_expr(self, expr: ClosureExpr, xml: XmlEmitter):
301 xml.start_tag("closure", function=expr.closure_name, type=expr.type)
302 for arg in expr.args:
303 self._emit_expression_part(arg.expr, xml)
304 xml.end_tag()
305
306 def _emit_try_expr(self, expr: TryExpr, xml: XmlEmitter):
307 xml.start_tag("try")
308 for e in expr.expressions:
309 self._emit_expression_part(e, xml)
310 xml.end_tag()
311
312 def _emit_attribute(
313 self,
314 tag: str,
315 attr: str,
316 name: str,
317 value: T.Union[Value, StringValue],
318 xml: XmlEmitter,
319 ):
320 attrs = {attr: name}
321
322 if isinstance(value.child, Translated):
323 xml.start_tag(tag, **attrs, **self._translated_string_attrs(value.child))
324 xml.put_text(value.child.string)
325 xml.end_tag()
326 elif isinstance(value.child, QuotedLiteral):
327 xml.start_tag(tag, **attrs)
328 xml.put_text(value.child.value)
329 xml.end_tag()
330 else:
331 xml.start_tag(tag, **attrs)
332 self._emit_value(value, xml)
333 xml.end_tag()
334
335 def _emit_extensions(self, extension, xml: XmlEmitter):
336 if isinstance(extension, ExtAccessibility):
337 xml.start_tag("accessibility")
338 for property in extension.properties:
339 for val in property.values:
340 self._emit_attribute(
341 property.tag_name, "name", property.name, val, xml
342 )
343 xml.end_tag()
344
345 elif isinstance(extension, AdwBreakpointCondition):
346 xml.start_tag("condition")
347 xml.put_text(extension.condition)
348 xml.end_tag()
349
350 elif isinstance(extension, AdwBreakpointSetters):
351 for setter in extension.setters:
352 if setter.value is None:
353 continue
354
355 attrs = {}
356
357 if isinstance(setter.value.child, Translated):
358 attrs = self._translated_string_attrs(setter.value.child)
359
360 xml.start_tag(
361 "setter",
362 object=self._object_id(setter, setter.object_id),
363 property=setter.property_name,
364 **attrs,
365 )
366 if isinstance(setter.value.child, Translated):
367 xml.put_text(setter.value.child.string)
368 elif (
369 isinstance(setter.value.child, Literal)
370 and isinstance(setter.value.child.value, IdentLiteral)
371 and setter.value.child.value.ident == "null"
372 and setter.context[ScopeCtx].objects.get("null") is None
373 ):
374 pass
375 else:
376 self._emit_value(setter.value, xml)
377 xml.end_tag()
378
379 elif isinstance(extension, Filters):
380 xml.start_tag(extension.tokens["tag_name"])
381 for prop in extension.children:
382 xml.start_tag(prop.tokens["tag_name"])
383 xml.put_text(prop.tokens["name"])
384 xml.end_tag()
385 xml.end_tag()
386
387 elif isinstance(extension, ExtComboBoxItems):
388 xml.start_tag("items")
389 for prop in extension.children:
390 self._emit_attribute("item", "id", prop.name, prop.value, xml)
391 xml.end_tag()
392
393 elif isinstance(extension, ExtLayout):
394 xml.start_tag("layout")
395 for prop in extension.children:
396 self._emit_attribute("property", "name", prop.name, prop.value, xml)
397 xml.end_tag()
398
399 elif isinstance(extension, ExtAdwResponseDialog):
400 xml.start_tag("responses")
401 for response in extension.responses:
402 assert response.value is not None
403 xml.start_tag(
404 "response",
405 id=response.id,
406 **self._translated_string_attrs(response.value.child),
407 enabled=None if response.enabled else "false",
408 appearance=response.appearance,
409 )
410 xml.put_text(response.value.string)
411 xml.end_tag()
412 xml.end_tag()
413
414 elif isinstance(extension, ExtLevelBarOffsets):
415 xml.start_tag("offsets")
416 for offset in extension.offsets:
417 xml.put_self_closing("offset", name=offset.name, value=offset.value)
418 xml.end_tag()
419
420 elif isinstance(extension, ExtScaleMarks):
421 xml.start_tag("marks")
422 for mark in extension.marks:
423 label = mark.label.child if mark.label is not None else None
424 xml.start_tag(
425 "mark",
426 value=mark.value,
427 position=mark.position,
428 **self._translated_string_attrs(label),
429 )
430 if mark.label is not None:
431 xml.put_text(mark.label.string)
432 xml.end_tag()
433 xml.end_tag()
434
435 elif isinstance(extension, ExtStringListStrings):
436 xml.start_tag("items")
437 for string in extension.children:
438 value = string.child
439 xml.start_tag("item", **self._translated_string_attrs(value.child))
440 xml.put_text(value.string)
441 xml.end_tag()
442 xml.end_tag()
443
444 elif isinstance(extension, ExtListItemFactory):
445 child_xml = XmlEmitter(generated_notice=False)
446 child_xml.start_tag("interface")
447 child_xml.start_tag("template", **{"class": extension.gir_class})
448 self._emit_object_or_template(extension, child_xml)
449 child_xml.end_tag()
450 child_xml.end_tag()
451 xml.start_tag("property", name="bytes")
452 xml.put_cdata(child_xml.result)
453 xml.end_tag()
454
455 elif isinstance(extension, ExtStyles):
456 xml.start_tag("style")
457 for style in extension.children:
458 xml.put_self_closing("class", name=style.name)
459 xml.end_tag()
460
461 elif isinstance(extension, ExtSizeGroupWidgets):
462 xml.start_tag("widgets")
463 for prop in extension.children:
464 xml.put_self_closing("widget", name=prop.name)
465 xml.end_tag()
466
467 else:
468 raise CompilerBugError()
469
470 def _object_id(self, node: AstNode, id: str) -> str:
471 if id == "template" and node.context[ScopeCtx].template is not None:
472 return node.context[ScopeCtx].template.gir_class.glib_type_name
473 else:
474 return id