mirror of
https://gitlab.gnome.org/jwestman/blueprint-compiler.git
synced 2025-05-04 15:59:08 -04:00
Compare commits
No commits in common. "main" and "v0.12.0" have entirely different histories.
227 changed files with 614 additions and 2924 deletions
|
|
@ -3,7 +3,7 @@ stages:
|
|||
- pages
|
||||
|
||||
build:
|
||||
image: registry.gitlab.gnome.org/gnome/blueprint-compiler
|
||||
image: registry.gitlab.gnome.org/jwestman/blueprint-compiler
|
||||
stage: build
|
||||
script:
|
||||
- black --check --diff ./ tests
|
||||
|
|
@ -19,7 +19,7 @@ build:
|
|||
- ninja -C _build docs/en
|
||||
- git clone https://gitlab.gnome.org/jwestman/blueprint-regression-tests.git
|
||||
- cd blueprint-regression-tests
|
||||
- git checkout 5f9e155c1333e84e6f683cdb26b02a5925fd8db3
|
||||
- git checkout 71522af3607e08143671ee0d224e65e9b9eb9f30
|
||||
- ./test.sh
|
||||
- cd ..
|
||||
coverage: '/TOTAL.*\s([.\d]+)%/'
|
||||
|
|
@ -33,7 +33,7 @@ build:
|
|||
path: coverage.xml
|
||||
|
||||
fuzz:
|
||||
image: registry.gitlab.gnome.org/gnome/blueprint-compiler
|
||||
image: registry.gitlab.gnome.org/jwestman/blueprint-compiler
|
||||
stage: build
|
||||
script:
|
||||
- meson _build
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ in the NEWS file.
|
|||
3. Make a new commit with just these two changes. Use `Release v{version}` as the commit message. Tag the commit as `v{version}` and push the tag.
|
||||
4. Create a "Post-release version bump" commit.
|
||||
5. Go to the Releases page in GitLab and create a new release from the tag.
|
||||
6. Announce the release through relevant channels (Mastodon, TWIG, etc.)
|
||||
6. Announce the release through relevant channels (Twitter, TWIG, etc.)
|
||||
|
||||
## Related projects
|
||||
|
||||
|
|
|
|||
73
NEWS.md
73
NEWS.md
|
|
@ -1,76 +1,3 @@
|
|||
# v0.16.0
|
||||
|
||||
## Added
|
||||
- Added more "go to reference" implementations in the language server
|
||||
- Added semantic token support for flag members in the language server
|
||||
- Added property documentation to the hover tooltip for notify signals
|
||||
- The language server now shows relevant sections of the reference documentation when hovering over keywords and symbols
|
||||
- Added `not-swapped` flag to signal handlers, which may be needed for signal handlers that specify an object
|
||||
- Added expression literals, which allow you to specify a Gtk.Expression property (as opposed to the existing expression support, which is for property bindings)
|
||||
|
||||
## Changed
|
||||
- The formatter adds trailing commas to lists (Alexey Yerin)
|
||||
- The formatter removes trailing whitespace from comments (Alexey Yerin)
|
||||
- Autocompleting a commonly translated property automatically adds the `_("")` syntax
|
||||
- Marking a single-quoted string as translatable now generates a warning, since gettext does not recognize it when using the configuration recommended in the blueprint documentation
|
||||
|
||||
## Fixed
|
||||
- Added support for libgirepository-2.0 so that blueprint doesn't crash due to import conflicts on newer versions of PyGObject (Jordan Petridis)
|
||||
- Fixed a bug when decompiling/porting files with enum values
|
||||
- Fixed several issues where tests would fail with versions of GTK that added new deprecations
|
||||
- Addressed a problem with the language server protocol in some editors (Luoyayu)
|
||||
- Fixed an issue where the compiler would crash instead of reporting compiler errors
|
||||
- Fixed a crash in the language server that occurred when a detailed signal (e.g. `notify::*`) was not complete
|
||||
- The language server now properly implements the shutdown command, fixing support for some editors and improving robustness when restarting (Alexey Yerin)
|
||||
- Marking a string in an array as translatable now generates an error, since it doesn't work
|
||||
-
|
||||
|
||||
## Documentation
|
||||
- Added mention of `null` in the Literal Values section
|
||||
- Add apps to Built with Blueprint section (Benedek Dévényi, Vladimir Vaskov)
|
||||
- Corrected and updated many parts of the documentation
|
||||
|
||||
# v0.14.0
|
||||
|
||||
## Added
|
||||
- Added a warning for unused imports.
|
||||
- Added an option to not print the diff when formatting with the CLI. (Gregor Niehl)
|
||||
- Added support for building Gtk.ColumnViewRow, Gtk.ColumnViewCell, and Gtk.ListHeader widgets with Gtk.BuilderListItemFactory.
|
||||
- Added support for the `after` keyword for signals. This was previously documented but not implemented. (Gregor Niehl)
|
||||
- Added support for string arrays. (Diego Augusto)
|
||||
- Added hover documentation for properties in lookup expressions.
|
||||
- The decompiler supports action widgets, translation domains, `typeof<>` syntax, and expressions. It also supports extension syntax for Adw.Breakpoint, Gtk.BuilderListItemFactory, Gtk.ComboBoxText, Gtk.SizeGroup, and Gtk.StringList.
|
||||
- Added a `decompile` subcommand to the CLI, which decompiles an XML .ui file to blueprint.
|
||||
- Accessibility relations that allow multiple values are supported using list syntax. (Julian Schmidhuber)
|
||||
|
||||
## Changed
|
||||
- The decompiler sorts imports alphabetically.
|
||||
- Translatable strings use `translatable="yes"` instead of `translatable="true"` for compatibility with xgettext. (Marco Köpcke)
|
||||
- The first line of the documentation is shown in the completion list when using the language server. (Sonny Piers)
|
||||
- Object autocomplete uses a snippet to add the braces and position the cursor inside them. (Sonny Piers)
|
||||
- The carets in the CLI diagnostic output now span the whole error message up to the end of the first line, rather than just the first character.
|
||||
- The decompiler emits double quotes, which are compatible with gettext.
|
||||
|
||||
## Fixed
|
||||
- Fixed deprecation warnings in the language server.
|
||||
- The decompiler no longer duplicates translator comments on properties.
|
||||
- Subtemplates no longer output a redundant `@generated` comment.
|
||||
- When extension syntax from a library that is not available is used, the compiler emits an error instead of crashing.
|
||||
- The language server reports semantic token positions correctly. (Szepesi Tibor)
|
||||
- The decompiler no longer emits the deprecated `bind-property` syntax. (Sonny Piers)
|
||||
- Fixed the tests when used as a Meson subproject. (Benoit Pierre)
|
||||
- Signal autocomplete generates correct syntax. (Sonny Piers)
|
||||
- The decompiler supports templates that do not specify a parent class. (Sonny Piers)
|
||||
- Adw.Breakpoint setters that set a property on the template no longer cause a crash.
|
||||
- Fixed type checking with templates that do not have a parent class.
|
||||
- Fixed online documentation links for interfaces.
|
||||
- The wording of edit suggestions is fixed for insertions and deletions.
|
||||
- When an input file uses tabs instead of spaces, the diagnostic output on the CLI aligns the caret correctly.
|
||||
- The decompiler emits correct syntax when a property binding refers to the template object.
|
||||
|
||||
## Documentation
|
||||
- Fixed typos in "Built with Blueprint" section. (Valéry Febvre, Dexter Reed)
|
||||
|
||||
# v0.12.0
|
||||
|
||||
## Added
|
||||
|
|
|
|||
|
|
@ -1,27 +0,0 @@
|
|||
<Project xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
|
||||
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
|
||||
xmlns:foaf="http://xmlns.com/foaf/0.1/"
|
||||
xmlns:gnome="http://api.gnome.org/doap-extensions#"
|
||||
xmlns="http://usefulinc.com/ns/doap#">
|
||||
|
||||
<name xml:lang="en">Blueprint</name>
|
||||
<shortdesc xml:lang="en">A modern language for creating GTK interfaces</shortdesc>
|
||||
<description xml:lang="en">Blueprint is a language and associated tooling for building user interfaces for GTK.</description>
|
||||
<category rdf:resource="http://api.gnome.org/doap-extensions#apps" />
|
||||
<programming-language>Python</programming-language>
|
||||
|
||||
<homepage
|
||||
rdf:resource="https://gnome.gitlab.gnome.org/blueprint-compiler/" />
|
||||
<download-page
|
||||
rdf:resource="https://gitlab.gnome.org/GNOME/blueprint-compiler/-/releases" />
|
||||
<bug-database
|
||||
rdf:resource="https://gitlab.gnome.org/GNOME/blueprint-compiler/issues" />
|
||||
|
||||
<maintainer>
|
||||
<foaf:Person>
|
||||
<foaf:name>James Westman</foaf:name>
|
||||
<foaf:mbox rdf:resource="mailto:james@jwestman.net" />
|
||||
<gnome:userid>jwestman</gnome:userid>
|
||||
</foaf:Person>
|
||||
</maintainer>
|
||||
</Project>
|
||||
|
|
@ -1,191 +0,0 @@
|
|||
# annotations.py
|
||||
#
|
||||
# Copyright 2024 James Westman <james@jwestman.net>
|
||||
#
|
||||
# This file is free software; you can redistribute it and/or modify it
|
||||
# under the terms of the GNU Lesser General Public License as
|
||||
# published by the Free Software Foundation; either version 3 of the
|
||||
# License, or (at your option) any later version.
|
||||
#
|
||||
# This file is distributed in the hope that it will be useful, but
|
||||
# WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
# Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General Public
|
||||
# License along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#
|
||||
# SPDX-License-Identifier: LGPL-3.0-or-later
|
||||
|
||||
# Extra information about types in common libraries that's used for things like completions.
|
||||
|
||||
import typing as T
|
||||
from dataclasses import dataclass
|
||||
|
||||
from . import gir
|
||||
|
||||
|
||||
@dataclass
|
||||
class Annotation:
|
||||
translatable_properties: T.List[str]
|
||||
|
||||
|
||||
def is_property_translated(property: gir.Property):
|
||||
ns = property.get_containing(gir.Namespace)
|
||||
ns_name = ns.name + "-" + ns.version
|
||||
if annotation := _ANNOTATIONS.get(ns_name):
|
||||
assert property.container is not None
|
||||
return (
|
||||
property.container.name + ":" + property.name
|
||||
in annotation.translatable_properties
|
||||
)
|
||||
else:
|
||||
return False
|
||||
|
||||
|
||||
_ANNOTATIONS = {
|
||||
"Gtk-4.0": Annotation(
|
||||
translatable_properties=[
|
||||
"AboutDialog:comments",
|
||||
"AboutDialog:translator-credits",
|
||||
"AboutDialog:website-label",
|
||||
"AlertDialog:detail",
|
||||
"AlertDialog:message",
|
||||
"AppChooserButton:heading",
|
||||
"AppChooserDialog:heading",
|
||||
"AppChooserWidget:default-text",
|
||||
"AssistantPage:title",
|
||||
"Button:label",
|
||||
"CellRendererText:markup",
|
||||
"CellRendererText:placeholder-text",
|
||||
"CellRendererText:text",
|
||||
"CheckButton:label",
|
||||
"ColorButton:title",
|
||||
"ColorDialog:title",
|
||||
"ColumnViewColumn:title",
|
||||
"ColumnViewRow:accessible-description",
|
||||
"ColumnViewRow:accessible-label",
|
||||
"Entry:placeholder-text",
|
||||
"Entry:primary-icon-tooltip-markup",
|
||||
"Entry:primary-icon-tooltip-text",
|
||||
"Entry:secondary-icon-tooltip-markup",
|
||||
"Entry:secondary-icon-tooltip-text",
|
||||
"EntryBuffer:text",
|
||||
"Expander:label",
|
||||
"FileChooserNative:accept-label",
|
||||
"FileChooserNative:cancel-label",
|
||||
"FileChooserWidget:subtitle",
|
||||
"FileDialog:accept-label",
|
||||
"FileDialog:title",
|
||||
"FileDialog:initial-name",
|
||||
"FileFilter:name",
|
||||
"FontButton:title",
|
||||
"FontDialog:title",
|
||||
"Frame:label",
|
||||
"Inscription:markup",
|
||||
"Inscription:text",
|
||||
"Label:label",
|
||||
"ListItem:accessible-description",
|
||||
"ListItem:accessible-label",
|
||||
"LockButton:text-lock",
|
||||
"LockButton:text-unlock",
|
||||
"LockButton:tooltip-lock",
|
||||
"LockButton:tooltip-not-authorized",
|
||||
"LockButton:tooltip-unlock",
|
||||
"MenuButton:label",
|
||||
"MessageDialog:secondary-text",
|
||||
"MessageDialog:text",
|
||||
"NativeDialog:title",
|
||||
"NotebookPage:menu-label",
|
||||
"NotebookPage:tab-label",
|
||||
"PasswordEntry:placeholder-text",
|
||||
"Picture:alternative-text",
|
||||
"PrintDialog:accept-label",
|
||||
"PrintDialog:title",
|
||||
"Printer:name",
|
||||
"PrintJob:title",
|
||||
"PrintOperation:custom-tab-label",
|
||||
"PrintOperation:export-filename",
|
||||
"PrintOperation:job-name",
|
||||
"ProgressBar:text",
|
||||
"SearchEntry:placeholder-text",
|
||||
"ShortcutLabel:disabled-text",
|
||||
"ShortcutsGroup:title",
|
||||
"ShortcutsSection:title",
|
||||
"ShortcutsShortcut:title",
|
||||
"ShortcutsShortcut:subtitle",
|
||||
"StackPage:title",
|
||||
"Text:placeholder-text",
|
||||
"TextBuffer:text",
|
||||
"TreeViewColumn:title",
|
||||
"Widget:tooltip-markup",
|
||||
"Widget:tooltip-text",
|
||||
"Window:title",
|
||||
"Editable:text",
|
||||
"FontChooser:preview-text",
|
||||
]
|
||||
),
|
||||
"Adw-1": Annotation(
|
||||
translatable_properties=[
|
||||
"AboutDialog:comments",
|
||||
"AboutDialog:translator-credits",
|
||||
"AboutWindow:comments",
|
||||
"AboutWindow:translator-credits",
|
||||
"ActionRow:subtitle",
|
||||
"ActionRow:title",
|
||||
"AlertDialog:body",
|
||||
"AlertDialog:heading",
|
||||
"Avatar:text",
|
||||
"Banner:button-label",
|
||||
"Banner:title",
|
||||
"ButtonContent:label",
|
||||
"Dialog:title",
|
||||
"ExpanderRow:subtitle",
|
||||
"MessageDialog:body",
|
||||
"MessageDialog:heading",
|
||||
"NavigationPage:title",
|
||||
"PreferencesGroup:description",
|
||||
"PreferencesGroup:title",
|
||||
"PreferencesPage:description",
|
||||
"PreferencesPage:title",
|
||||
"PreferencesRow:title",
|
||||
"SplitButton:dropdown-tooltip",
|
||||
"SplitButton:label",
|
||||
"StatusPage:description",
|
||||
"StatusPage:title",
|
||||
"TabPage:indicator-tooltip",
|
||||
"TabPage:keyword",
|
||||
"TabPage:title",
|
||||
"Toast:button-label",
|
||||
"Toast:title",
|
||||
"ViewStackPage:title",
|
||||
"ViewSwitcherTitle:subtitle",
|
||||
"ViewSwitcherTitle:title",
|
||||
"WindowTitle:subtitle",
|
||||
"WindowTitle:title",
|
||||
]
|
||||
),
|
||||
"Shumate-1.0": Annotation(
|
||||
translatable_properties=[
|
||||
"License:extra-text",
|
||||
"MapSource:license",
|
||||
"MapSource:name",
|
||||
]
|
||||
),
|
||||
"GtkSource-5": Annotation(
|
||||
translatable_properties=[
|
||||
"CompletionCell:markup",
|
||||
"CompletionCell:text",
|
||||
"CompletionSnippets:title",
|
||||
"CompletionWords:title",
|
||||
"GutterRendererText:markup",
|
||||
"GutterRendererText:text",
|
||||
"SearchSettings:search-text",
|
||||
"Snippet:description",
|
||||
"Snippet:name",
|
||||
"SnippetChunk:tooltip-text",
|
||||
"StyleScheme:description",
|
||||
"StyleScheme:name",
|
||||
]
|
||||
),
|
||||
}
|
||||
|
|
@ -125,7 +125,7 @@ class AstNode:
|
|||
return self.parent.root
|
||||
|
||||
@property
|
||||
def range(self) -> Range:
|
||||
def range(self):
|
||||
return Range(self.group.start, self.group.end, self.group.text)
|
||||
|
||||
def parent_by_type(self, type: T.Type[TType]) -> TType:
|
||||
|
|
@ -160,11 +160,6 @@ class AstNode:
|
|||
yield e
|
||||
if e.fatal:
|
||||
return
|
||||
except MultipleErrors as e:
|
||||
for error in e.errors:
|
||||
yield error
|
||||
if error.fatal:
|
||||
return
|
||||
|
||||
for child in self.children:
|
||||
yield from child._get_errors()
|
||||
|
|
@ -184,16 +179,14 @@ class AstNode:
|
|||
token = self.group.tokens.get(attr.token_name)
|
||||
if token and token.start <= idx < token.end:
|
||||
return getattr(self, name)
|
||||
else:
|
||||
return getattr(self, name)
|
||||
|
||||
for child in self.children:
|
||||
if idx in child.range:
|
||||
if docs := child.get_docs(idx):
|
||||
return docs
|
||||
|
||||
for name, attr in self._attrs_by_type(Docs):
|
||||
if not attr.token_name:
|
||||
return getattr(self, name)
|
||||
|
||||
return None
|
||||
|
||||
def get_semantic_tokens(self) -> T.Iterator[SemanticToken]:
|
||||
|
|
@ -254,7 +247,14 @@ def validate(
|
|||
if skip_incomplete and self.incomplete:
|
||||
return
|
||||
|
||||
def fill_error(e: CompileError):
|
||||
try:
|
||||
func(self)
|
||||
except CompileError as e:
|
||||
# If the node is only partially complete, then an error must
|
||||
# have already been reported at the parsing stage
|
||||
if self.incomplete:
|
||||
return
|
||||
|
||||
if e.range is None:
|
||||
e.range = (
|
||||
Range.join(
|
||||
|
|
@ -264,26 +264,8 @@ def validate(
|
|||
or self.range
|
||||
)
|
||||
|
||||
try:
|
||||
func(self)
|
||||
except CompileError as e:
|
||||
# If the node is only partially complete, then an error must
|
||||
# have already been reported at the parsing stage
|
||||
if self.incomplete:
|
||||
return
|
||||
|
||||
fill_error(e)
|
||||
|
||||
# Re-raise the exception
|
||||
raise e
|
||||
except MultipleErrors as e:
|
||||
if self.incomplete:
|
||||
return
|
||||
|
||||
for error in e.errors:
|
||||
fill_error(error)
|
||||
|
||||
raise e
|
||||
|
||||
inner._validator = True
|
||||
return inner
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@
|
|||
|
||||
import typing as T
|
||||
|
||||
from . import annotations, gir, language
|
||||
from . import gir, language
|
||||
from .ast_utils import AstNode
|
||||
from .completions_utils import *
|
||||
from .language.types import ClassName
|
||||
|
|
@ -72,9 +72,7 @@ def complete(
|
|||
|
||||
@completer([language.GtkDirective])
|
||||
def using_gtk(lsp, ast_node, match_variables):
|
||||
yield Completion(
|
||||
"using Gtk 4.0", CompletionItemKind.Keyword, snippet="using Gtk 4.0;\n"
|
||||
)
|
||||
yield Completion("using Gtk 4.0;", CompletionItemKind.Keyword)
|
||||
|
||||
|
||||
@completer(
|
||||
|
|
@ -103,13 +101,7 @@ def object_completer(lsp, ast_node, match_variables):
|
|||
ns = ast_node.root.gir.namespaces.get(match_variables[0])
|
||||
if ns is not None:
|
||||
for c in ns.classes.values():
|
||||
yield Completion(
|
||||
c.name,
|
||||
CompletionItemKind.Class,
|
||||
snippet=f"{c.name} {{\n $0\n}}",
|
||||
docs=c.doc,
|
||||
detail=c.detail,
|
||||
)
|
||||
yield Completion(c.name, CompletionItemKind.Class, docs=c.doc)
|
||||
|
||||
|
||||
@completer(
|
||||
|
|
@ -120,13 +112,7 @@ def gtk_object_completer(lsp, ast_node, match_variables):
|
|||
ns = ast_node.root.gir.namespaces.get("Gtk")
|
||||
if ns is not None:
|
||||
for c in ns.classes.values():
|
||||
yield Completion(
|
||||
c.name,
|
||||
CompletionItemKind.Class,
|
||||
snippet=f"{c.name} {{\n $0\n}}",
|
||||
docs=c.doc,
|
||||
detail=c.detail,
|
||||
)
|
||||
yield Completion(c.name, CompletionItemKind.Class, docs=c.doc)
|
||||
|
||||
|
||||
@completer(
|
||||
|
|
@ -134,7 +120,7 @@ def gtk_object_completer(lsp, ast_node, match_variables):
|
|||
matches=new_statement_patterns,
|
||||
)
|
||||
def property_completer(lsp, ast_node, match_variables):
|
||||
if ast_node.gir_class and hasattr(ast_node.gir_class, "properties"):
|
||||
if ast_node.gir_class and not isinstance(ast_node.gir_class, gir.ExternType):
|
||||
for prop_name, prop in ast_node.gir_class.properties.items():
|
||||
if (
|
||||
isinstance(prop.type, gir.BoolType)
|
||||
|
|
@ -145,23 +131,13 @@ def property_completer(lsp, ast_node, match_variables):
|
|||
CompletionItemKind.Property,
|
||||
sort_text=f"0 {prop_name}",
|
||||
snippet=f"{prop_name}: ${{1|true,false|}};",
|
||||
docs=prop.doc,
|
||||
detail=prop.detail,
|
||||
)
|
||||
elif isinstance(prop.type, gir.StringType):
|
||||
snippet = (
|
||||
f'{prop_name}: _("$0");'
|
||||
if annotations.is_property_translated(prop)
|
||||
else f'{prop_name}: "$0";'
|
||||
)
|
||||
|
||||
yield Completion(
|
||||
prop_name,
|
||||
CompletionItemKind.Property,
|
||||
sort_text=f"0 {prop_name}",
|
||||
snippet=snippet,
|
||||
docs=prop.doc,
|
||||
detail=prop.detail,
|
||||
snippet=f'{prop_name}: "$0";',
|
||||
)
|
||||
elif (
|
||||
isinstance(prop.type, gir.Enumeration)
|
||||
|
|
@ -174,17 +150,6 @@ def property_completer(lsp, ast_node, match_variables):
|
|||
CompletionItemKind.Property,
|
||||
sort_text=f"0 {prop_name}",
|
||||
snippet=f"{prop_name}: ${{1|{choices}|}};",
|
||||
docs=prop.doc,
|
||||
detail=prop.detail,
|
||||
)
|
||||
elif prop.type.full_name == "Gtk.Expression":
|
||||
yield Completion(
|
||||
prop_name,
|
||||
CompletionItemKind.Property,
|
||||
sort_text=f"0 {prop_name}",
|
||||
snippet=f"{prop_name}: expr $0;",
|
||||
docs=prop.doc,
|
||||
detail=prop.detail,
|
||||
)
|
||||
else:
|
||||
yield Completion(
|
||||
|
|
@ -192,25 +157,18 @@ def property_completer(lsp, ast_node, match_variables):
|
|||
CompletionItemKind.Property,
|
||||
sort_text=f"0 {prop_name}",
|
||||
snippet=f"{prop_name}: $0;",
|
||||
docs=prop.doc,
|
||||
detail=prop.detail,
|
||||
)
|
||||
|
||||
|
||||
@completer(
|
||||
applies_in=[language.Property, language.A11yProperty],
|
||||
applies_in=[language.Property, language.BaseAttribute],
|
||||
matches=[[(TokenType.IDENT, None), (TokenType.OP, ":")]],
|
||||
)
|
||||
def prop_value_completer(lsp, ast_node, match_variables):
|
||||
if (vt := ast_node.value_type) is not None:
|
||||
if isinstance(vt.value_type, gir.Enumeration):
|
||||
for name, member in vt.value_type.members.items():
|
||||
yield Completion(
|
||||
name,
|
||||
CompletionItemKind.EnumMember,
|
||||
docs=member.doc,
|
||||
detail=member.detail,
|
||||
)
|
||||
yield Completion(name, CompletionItemKind.EnumMember, docs=member.doc)
|
||||
|
||||
elif isinstance(vt.value_type, gir.BoolType):
|
||||
yield Completion("true", CompletionItemKind.Constant)
|
||||
|
|
@ -222,8 +180,8 @@ def prop_value_completer(lsp, ast_node, match_variables):
|
|||
matches=new_statement_patterns,
|
||||
)
|
||||
def signal_completer(lsp, ast_node, match_variables):
|
||||
if ast_node.gir_class and hasattr(ast_node.gir_class, "signals"):
|
||||
for signal_name, signal in ast_node.gir_class.signals.items():
|
||||
if ast_node.gir_class and not isinstance(ast_node.gir_class, gir.ExternType):
|
||||
for signal in ast_node.gir_class.signals:
|
||||
if not isinstance(ast_node.parent, language.Object):
|
||||
name = "on"
|
||||
else:
|
||||
|
|
@ -234,12 +192,10 @@ def signal_completer(lsp, ast_node, match_variables):
|
|||
.lower()
|
||||
)
|
||||
yield Completion(
|
||||
signal_name,
|
||||
signal,
|
||||
CompletionItemKind.Event,
|
||||
sort_text=f"1 {signal_name}",
|
||||
snippet=f"{signal_name} => \\$${{1:${name}_{signal_name.replace('-', '_')}}}()$0;",
|
||||
docs=signal.doc,
|
||||
detail=signal.detail,
|
||||
sort_text=f"1 {signal}",
|
||||
snippet=f"{signal} => \$${{1:{name}_{signal.replace('-', '_')}}}()$0;",
|
||||
)
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -31,6 +31,17 @@ new_statement_patterns = [
|
|||
]
|
||||
|
||||
|
||||
def applies_to(*ast_types):
|
||||
"""Decorator describing which AST nodes the completer should apply in."""
|
||||
|
||||
def decorator(func):
|
||||
for c in ast_types:
|
||||
c.completers.append(func)
|
||||
return func
|
||||
|
||||
return decorator
|
||||
|
||||
|
||||
def completer(applies_in: T.List, matches: T.List = [], applies_in_subclass=None):
|
||||
def decorator(func):
|
||||
def inner(prev_tokens: T.List[Token], ast_node, lsp):
|
||||
|
|
|
|||
|
|
@ -17,8 +17,8 @@
|
|||
#
|
||||
# SPDX-License-Identifier: LGPL-3.0-or-later
|
||||
|
||||
import re
|
||||
import typing as T
|
||||
from collections import defaultdict
|
||||
from dataclasses import dataclass
|
||||
from enum import Enum
|
||||
|
||||
|
|
@ -30,7 +30,7 @@ from .xml_reader import Element, parse, parse_string
|
|||
__all__ = ["decompile"]
|
||||
|
||||
|
||||
_DECOMPILERS: dict[str, list] = defaultdict(list)
|
||||
_DECOMPILERS: T.Dict = {}
|
||||
_CLOSING = {
|
||||
"{": "}",
|
||||
"[": "]",
|
||||
|
|
@ -51,32 +51,27 @@ class LineType(Enum):
|
|||
|
||||
|
||||
class DecompileCtx:
|
||||
def __init__(self, parent_gir: T.Optional[GirContext] = None) -> None:
|
||||
self.sub_decompiler = parent_gir is not None
|
||||
def __init__(self) -> None:
|
||||
self._result: str = ""
|
||||
self.gir = parent_gir or GirContext()
|
||||
self.gir = GirContext()
|
||||
self._indent: int = 0
|
||||
self._blocks_need_end: T.List[str] = []
|
||||
self._last_line_type: LineType = LineType.NONE
|
||||
self._obj_type_stack: list[T.Optional[GirType]] = []
|
||||
self._node_stack: list[Element] = []
|
||||
self.template_class: T.Optional[str] = None
|
||||
|
||||
self.gir.add_namespace(get_namespace("Gtk", "4.0"))
|
||||
|
||||
@property
|
||||
def result(self) -> str:
|
||||
imports = ""
|
||||
|
||||
if not self.sub_decompiler:
|
||||
import_lines = sorted(
|
||||
[
|
||||
f"using {ns} {namespace.version};"
|
||||
for ns, namespace in self.gir.namespaces.items()
|
||||
if ns != "Gtk"
|
||||
]
|
||||
)
|
||||
imports += "\n".join(["using Gtk 4.0;", *import_lines])
|
||||
|
||||
return formatter.format(imports + self._result)
|
||||
imports = "\n".join(
|
||||
[
|
||||
f"using {ns} {namespace.version};"
|
||||
for ns, namespace in self.gir.namespaces.items()
|
||||
]
|
||||
)
|
||||
full_string = imports + "\n" + self._result
|
||||
formatted_string = formatter.format(full_string)
|
||||
return formatted_string
|
||||
|
||||
def type_by_cname(self, cname: str) -> T.Optional[GirType]:
|
||||
if type := self.gir.get_type_by_cname(cname):
|
||||
|
|
@ -95,66 +90,10 @@ class DecompileCtx:
|
|||
|
||||
def start_block(self) -> None:
|
||||
self._blocks_need_end.append("")
|
||||
self._obj_type_stack.append(None)
|
||||
|
||||
def end_block(self) -> None:
|
||||
if close := self._blocks_need_end.pop():
|
||||
self.print(close)
|
||||
self._obj_type_stack.pop()
|
||||
|
||||
@property
|
||||
def current_obj_type(self) -> T.Optional[GirType]:
|
||||
return next((x for x in reversed(self._obj_type_stack) if x is not None), None)
|
||||
|
||||
def push_obj_type(self, type: T.Optional[GirType]) -> None:
|
||||
self._obj_type_stack[-1] = type
|
||||
|
||||
@property
|
||||
def current_node(self) -> T.Optional[Element]:
|
||||
if len(self._node_stack) == 0:
|
||||
return None
|
||||
else:
|
||||
return self._node_stack[-1]
|
||||
|
||||
@property
|
||||
def parent_node(self) -> T.Optional[Element]:
|
||||
if len(self._node_stack) < 2:
|
||||
return None
|
||||
else:
|
||||
return self._node_stack[-2]
|
||||
|
||||
@property
|
||||
def root_node(self) -> T.Optional[Element]:
|
||||
if len(self._node_stack) == 0:
|
||||
return None
|
||||
else:
|
||||
return self._node_stack[0]
|
||||
|
||||
@property
|
||||
def template_class(self) -> T.Optional[str]:
|
||||
assert self.root_node is not None
|
||||
for child in self.root_node.children:
|
||||
if child.tag == "template":
|
||||
return child["class"]
|
||||
|
||||
return None
|
||||
|
||||
def find_object(self, id: str) -> T.Optional[Element]:
|
||||
assert self.root_node is not None
|
||||
for child in self.root_node.children:
|
||||
if child.tag == "template" and child["class"] == id:
|
||||
return child
|
||||
|
||||
def find_in_children(node: Element) -> T.Optional[Element]:
|
||||
if node.tag in ["object", "menu"] and node["id"] == id:
|
||||
return node
|
||||
else:
|
||||
for child in node.children:
|
||||
if result := find_in_children(child):
|
||||
return result
|
||||
return None
|
||||
|
||||
return find_in_children(self.root_node)
|
||||
|
||||
def end_block_with(self, text: str) -> None:
|
||||
self._blocks_need_end[-1] = text
|
||||
|
|
@ -166,15 +105,7 @@ class DecompileCtx:
|
|||
if len(self._blocks_need_end):
|
||||
self._blocks_need_end[-1] = _CLOSING[line[-1]]
|
||||
|
||||
# Converts a value from an XML element to a blueprint string
|
||||
# based on the given type. Returns a tuple of translator comments
|
||||
# (if any) and the decompiled syntax.
|
||||
def decompile_value(
|
||||
self,
|
||||
value: str,
|
||||
type: T.Optional[GirType],
|
||||
translatable: T.Optional[T.Tuple[str, str, str]] = None,
|
||||
) -> T.Tuple[str, str]:
|
||||
def print_attribute(self, name: str, value: str, type: GirType) -> None:
|
||||
def get_enum_name(value):
|
||||
for member in type.members.values():
|
||||
if (
|
||||
|
|
@ -185,18 +116,13 @@ class DecompileCtx:
|
|||
return member.name
|
||||
return value.replace("-", "_")
|
||||
|
||||
if translatable is not None and truthy(translatable[0]):
|
||||
return decompile_translatable(value, *translatable)
|
||||
elif type is None:
|
||||
return "", f"{escape_quote(value)}"
|
||||
if type is None:
|
||||
self.print(f"{name}: {escape_quote(value)};")
|
||||
elif type.assignable_to(FloatType()):
|
||||
return "", str(value)
|
||||
self.print(f"{name}: {value};")
|
||||
elif type.assignable_to(BoolType()):
|
||||
val = truthy(value)
|
||||
return "", ("true" if val else "false")
|
||||
elif type.assignable_to(ArrayType(StringType())):
|
||||
items = ", ".join([escape_quote(x) for x in value.split("\n")])
|
||||
return "", f"[{items}]"
|
||||
self.print(f"{name}: {'true' if val else 'false'};")
|
||||
elif (
|
||||
type.assignable_to(self.gir.namespaces["Gtk"].lookup_type("Gdk.Pixbuf"))
|
||||
or type.assignable_to(self.gir.namespaces["Gtk"].lookup_type("Gdk.Texture"))
|
||||
|
|
@ -210,82 +136,67 @@ class DecompileCtx:
|
|||
self.gir.namespaces["Gtk"].lookup_type("Gtk.ShortcutTrigger")
|
||||
)
|
||||
):
|
||||
return "", escape_quote(value)
|
||||
self.print(f"{name}: {escape_quote(value)};")
|
||||
elif value == self.template_class:
|
||||
return "", "template"
|
||||
self.print(f"{name}: template;")
|
||||
elif type.assignable_to(
|
||||
self.gir.namespaces["Gtk"].lookup_type("GObject.Object")
|
||||
) or isinstance(type, Interface):
|
||||
return "", ("null" if value == "" else value)
|
||||
):
|
||||
self.print(f"{name}: {value};")
|
||||
elif isinstance(type, Bitfield):
|
||||
flags = [get_enum_name(flag) for flag in value.split("|")]
|
||||
return "", " | ".join(flags)
|
||||
self.print(f"{name}: {' | '.join(flags)};")
|
||||
elif isinstance(type, Enumeration):
|
||||
return "", get_enum_name(value)
|
||||
elif isinstance(type, TypeType):
|
||||
if t := self.type_by_cname(value):
|
||||
return "", f"typeof<{full_name(t)}>"
|
||||
else:
|
||||
return "", f"typeof<${value}>"
|
||||
self.print(f"{name}: {get_enum_name(value)};")
|
||||
else:
|
||||
return "", escape_quote(value)
|
||||
self.print(f"{name}: {escape_quote(value)};")
|
||||
|
||||
|
||||
def decompile_element(
|
||||
def _decompile_element(
|
||||
ctx: DecompileCtx, gir: T.Optional[GirContext], xml: Element
|
||||
) -> None:
|
||||
try:
|
||||
decompilers = [d for d in _DECOMPILERS[xml.tag] if d._filter(ctx)]
|
||||
if len(decompilers) == 0:
|
||||
decompiler = _DECOMPILERS.get(xml.tag)
|
||||
if decompiler is None:
|
||||
raise UnsupportedError(f"unsupported XML tag: <{xml.tag}>")
|
||||
|
||||
decompiler = decompilers[0]
|
||||
args: T.Dict[str, T.Optional[str]] = {
|
||||
canon(name): value for name, value in xml.attrs.items()
|
||||
}
|
||||
if decompiler._cdata:
|
||||
if len(xml.children):
|
||||
args["cdata"] = None
|
||||
else:
|
||||
args["cdata"] = xml.cdata
|
||||
|
||||
if decompiler._element:
|
||||
args = [ctx, gir, xml]
|
||||
kwargs: T.Dict[str, T.Optional[str]] = {}
|
||||
else:
|
||||
args = [ctx, gir]
|
||||
kwargs = {canon(name): value for name, value in xml.attrs.items()}
|
||||
if decompiler._cdata:
|
||||
if len(xml.children):
|
||||
kwargs["cdata"] = None
|
||||
else:
|
||||
kwargs["cdata"] = xml.cdata
|
||||
|
||||
ctx._node_stack.append(xml)
|
||||
ctx.start_block()
|
||||
gir = decompiler(ctx, gir, **args)
|
||||
|
||||
try:
|
||||
gir = decompiler(*args, **kwargs)
|
||||
except TypeError as e:
|
||||
raise UnsupportedError(tag=xml.tag)
|
||||
|
||||
if not decompiler._skip_children:
|
||||
for child in xml.children:
|
||||
decompile_element(ctx, gir, child)
|
||||
for child in xml.children:
|
||||
_decompile_element(ctx, gir, child)
|
||||
|
||||
ctx.end_block()
|
||||
ctx._node_stack.pop()
|
||||
|
||||
except UnsupportedError as e:
|
||||
raise e
|
||||
except TypeError as e:
|
||||
raise UnsupportedError(tag=xml.tag)
|
||||
|
||||
|
||||
def decompile(data: str) -> str:
|
||||
ctx = DecompileCtx()
|
||||
|
||||
xml = parse(data)
|
||||
decompile_element(ctx, None, xml)
|
||||
_decompile_element(ctx, None, xml)
|
||||
|
||||
return ctx.result
|
||||
|
||||
|
||||
def decompile_string(data: str) -> str:
|
||||
def decompile_string(data):
|
||||
ctx = DecompileCtx()
|
||||
|
||||
xml = parse_string(data)
|
||||
decompile_element(ctx, None, xml)
|
||||
_decompile_element(ctx, None, xml)
|
||||
|
||||
return ctx.result
|
||||
|
||||
|
|
@ -298,10 +209,10 @@ def canon(string: str) -> str:
|
|||
|
||||
|
||||
def truthy(string: str) -> bool:
|
||||
return string is not None and string.lower() in ["yes", "true", "t", "y", "1"]
|
||||
return string.lower() in ["yes", "true", "t", "y", "1"]
|
||||
|
||||
|
||||
def full_name(gir: GirType) -> str:
|
||||
def full_name(gir) -> str:
|
||||
return gir.name if gir.full_name.startswith("Gtk.") else gir.full_name
|
||||
|
||||
|
||||
|
|
@ -312,45 +223,17 @@ def lookup_by_cname(gir, cname: str) -> T.Optional[GirType]:
|
|||
return gir.get_containing(Repository).get_type_by_cname(cname)
|
||||
|
||||
|
||||
def decompiler(
|
||||
tag,
|
||||
cdata=False,
|
||||
parent_type: T.Optional[str] = None,
|
||||
parent_tag: T.Optional[str] = None,
|
||||
skip_children=False,
|
||||
element=False,
|
||||
):
|
||||
def decompiler(tag, cdata=False):
|
||||
def decorator(func):
|
||||
func._cdata = cdata
|
||||
func._skip_children = skip_children
|
||||
func._element = element
|
||||
|
||||
def filter(ctx):
|
||||
if parent_type is not None:
|
||||
if (
|
||||
ctx.current_obj_type is None
|
||||
or ctx.current_obj_type.full_name != parent_type
|
||||
):
|
||||
return False
|
||||
|
||||
if parent_tag is not None:
|
||||
if not any(x.tag == parent_tag for x in ctx._node_stack):
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
func._filter = filter
|
||||
|
||||
_DECOMPILERS[tag].append(func)
|
||||
_DECOMPILERS[tag] = func
|
||||
return func
|
||||
|
||||
return decorator
|
||||
|
||||
|
||||
@decompiler("interface")
|
||||
def decompile_interface(ctx, gir, domain=None):
|
||||
if domain is not None:
|
||||
ctx.print(f"translation-domain {escape_quote(domain)};")
|
||||
def decompile_interface(ctx, gir):
|
||||
return gir
|
||||
|
||||
|
||||
|
|
@ -369,11 +252,9 @@ def decompile_translatable(
|
|||
translatable: T.Optional[str],
|
||||
context: T.Optional[str],
|
||||
comments: T.Optional[str],
|
||||
) -> T.Tuple[str, str]:
|
||||
) -> T.Tuple[T.Optional[str], str]:
|
||||
if translatable is not None and truthy(translatable):
|
||||
if comments is None:
|
||||
comments = ""
|
||||
else:
|
||||
if comments is not None:
|
||||
comments = comments.replace("/*", " ").replace("*/", " ")
|
||||
comments = f"/* Translators: {comments} */"
|
||||
|
||||
|
|
@ -382,7 +263,7 @@ def decompile_translatable(
|
|||
else:
|
||||
return comments, f"_({escape_quote(string)})"
|
||||
else:
|
||||
return "", f"{escape_quote(string)}"
|
||||
return comments, f"{escape_quote(string)}"
|
||||
|
||||
|
||||
@decompiler("property", cdata=True)
|
||||
|
|
@ -399,8 +280,11 @@ def decompile_property(
|
|||
context=None,
|
||||
):
|
||||
name = name.replace("_", "-")
|
||||
if comments is not None:
|
||||
ctx.print(f"/* Translators: {comments} */")
|
||||
|
||||
if cdata is None:
|
||||
ctx.print(f"{name}: ")
|
||||
ctx.print(f"{name}: ", False)
|
||||
ctx.end_block_with(";")
|
||||
elif bind_source:
|
||||
flags = ""
|
||||
|
|
@ -411,11 +295,7 @@ def decompile_property(
|
|||
flags += " inverted"
|
||||
if "bidirectional" in bind_flags:
|
||||
flags += " bidirectional"
|
||||
|
||||
if bind_source == ctx.template_class:
|
||||
bind_source = "template"
|
||||
|
||||
ctx.print(f"{name}: bind {bind_source}.{bind_property}{flags};")
|
||||
ctx.print(f"{name}: bind-property {bind_source}.{bind_property}{flags};")
|
||||
elif truthy(translatable):
|
||||
comments, translatable = decompile_translatable(
|
||||
cdata, translatable, context, comments
|
||||
|
|
@ -425,19 +305,8 @@ def decompile_property(
|
|||
ctx.print(f"{name}: {translatable};")
|
||||
elif gir is None or gir.properties.get(name) is None:
|
||||
ctx.print(f"{name}: {escape_quote(cdata)};")
|
||||
elif (
|
||||
gir.assignable_to(ctx.gir.get_class("BuilderListItemFactory", "Gtk"))
|
||||
and name == "bytes"
|
||||
):
|
||||
sub_ctx = DecompileCtx(ctx.gir)
|
||||
|
||||
xml = parse_string(cdata)
|
||||
decompile_element(sub_ctx, None, xml)
|
||||
|
||||
ctx.print(sub_ctx.result)
|
||||
else:
|
||||
_, string = ctx.decompile_value(cdata, gir.properties.get(name).type)
|
||||
ctx.print(f"{name}: {string};")
|
||||
ctx.print_attribute(name, cdata, gir.properties.get(name).type)
|
||||
return gir
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -93,28 +93,15 @@ class CompileError(PrintableError):
|
|||
assert self.range is not None
|
||||
|
||||
line_num, col_num = utils.idx_to_pos(self.range.start + 1, code)
|
||||
end_line_num, end_col_num = utils.idx_to_pos(self.range.end + 1, code)
|
||||
line = code.splitlines(True)[line_num] if code != "" else ""
|
||||
|
||||
# Display 1-based line numbers
|
||||
line_num += 1
|
||||
end_line_num += 1
|
||||
|
||||
n_spaces = col_num - 1
|
||||
n_carets = (
|
||||
(end_col_num - col_num)
|
||||
if line_num == end_line_num
|
||||
else (len(line) - n_spaces - 1)
|
||||
)
|
||||
|
||||
n_spaces += line.count("\t", 0, col_num)
|
||||
n_carets += line.count("\t", col_num, col_num + n_carets)
|
||||
line = line.replace("\t", " ")
|
||||
|
||||
stream.write(
|
||||
f"""{self.color}{Colors.BOLD}{self.category}: {self.message}{Colors.CLEAR}
|
||||
at {filename} line {line_num} column {col_num}:
|
||||
{Colors.FAINT}{line_num :>4} |{Colors.CLEAR}{line.rstrip()}\n {Colors.FAINT}|{" "*n_spaces}{"^"*n_carets}{Colors.CLEAR}\n"""
|
||||
{Colors.FAINT}{line_num :>4} |{Colors.CLEAR}{line.rstrip()}\n {Colors.FAINT}|{" "*(col_num-1)}^{Colors.CLEAR}\n"""
|
||||
)
|
||||
|
||||
for hint in self.hints:
|
||||
|
|
@ -126,17 +113,9 @@ at {filename} line {line_num} column {col_num}:
|
|||
if action.edit_range is not None
|
||||
else self.range.text
|
||||
)
|
||||
|
||||
if old == "":
|
||||
stream.write(
|
||||
f"suggestion: insert {Colors.GREEN}{action.replace_with}{Colors.CLEAR}\n"
|
||||
)
|
||||
elif action.replace_with == "":
|
||||
stream.write(f"suggestion: remove {Colors.RED}{old}{Colors.CLEAR}\n")
|
||||
else:
|
||||
stream.write(
|
||||
f"suggestion: replace {Colors.RED}{old}{Colors.CLEAR} with {Colors.GREEN}{action.replace_with}{Colors.CLEAR}\n"
|
||||
)
|
||||
stream.write(
|
||||
f"suggestion: replace {Colors.RED}{old}{Colors.CLEAR} with {Colors.GREEN}{action.replace_with}{Colors.CLEAR}\n"
|
||||
)
|
||||
|
||||
for ref in self.references:
|
||||
line_num, col_num = utils.idx_to_pos(ref.range.start + 1, code)
|
||||
|
|
@ -161,10 +140,6 @@ class DeprecatedWarning(CompileWarning):
|
|||
pass
|
||||
|
||||
|
||||
class UnusedWarning(CompileWarning):
|
||||
pass
|
||||
|
||||
|
||||
class UpgradeWarning(CompileWarning):
|
||||
category = "upgrade"
|
||||
color = Colors.PURPLE
|
||||
|
|
@ -219,7 +194,7 @@ def report_bug(): # pragma: no cover
|
|||
f"""{Colors.BOLD}{Colors.RED}***** COMPILER BUG *****
|
||||
The blueprint-compiler program has crashed. Please report the above stacktrace,
|
||||
along with the input file(s) if possible, on GitLab:
|
||||
{Colors.BOLD}{Colors.BLUE}{Colors.UNDERLINE}https://gitlab.gnome.org/GNOME/blueprint-compiler/-/issues/new?issue
|
||||
{Colors.BOLD}{Colors.BLUE}{Colors.UNDERLINE}https://gitlab.gnome.org/jwestman/blueprint-compiler/-/issues/new?issue
|
||||
{Colors.CLEAR}"""
|
||||
)
|
||||
|
||||
|
|
|
|||
|
|
@ -20,8 +20,7 @@
|
|||
import re
|
||||
from enum import Enum
|
||||
|
||||
from . import tokenizer
|
||||
from .errors import CompilerBugError
|
||||
from . import tokenizer, utils
|
||||
from .tokenizer import TokenType
|
||||
|
||||
OPENING_TOKENS = ("{", "[")
|
||||
|
|
@ -146,10 +145,8 @@ def format(data, tab_size=2, insert_space=True):
|
|||
is_child_type = False
|
||||
|
||||
elif str_item in CLOSING_TOKENS:
|
||||
if str_item == "]" and str(last_not_whitespace) != "[":
|
||||
if str_item == "]" and last_not_whitespace != ",":
|
||||
current_line = current_line[:-1]
|
||||
if str(last_not_whitespace) != ",":
|
||||
current_line += ","
|
||||
commit_current_line()
|
||||
current_line = "]"
|
||||
elif str(last_not_whitespace) in OPENING_TOKENS:
|
||||
|
|
@ -193,13 +190,10 @@ def format(data, tab_size=2, insert_space=True):
|
|||
elif prev_line_type in require_extra_newline:
|
||||
newlines = 2
|
||||
|
||||
current_line = "\n".join(
|
||||
[line.rstrip() for line in current_line.split("\n")]
|
||||
)
|
||||
commit_current_line(LineType.COMMENT, newlines_before=newlines)
|
||||
|
||||
else: # pragma: no cover
|
||||
raise CompilerBugError()
|
||||
else:
|
||||
commit_current_line()
|
||||
|
||||
elif str_item == "(" and (
|
||||
re.match(r"^([A-Za-z_\-])+\s*\(", current_line) or watch_parentheses
|
||||
|
|
|
|||
|
|
@ -24,20 +24,8 @@ from functools import cached_property
|
|||
|
||||
import gi # type: ignore
|
||||
|
||||
try:
|
||||
gi.require_version("GIRepository", "3.0")
|
||||
from gi.repository import GIRepository # type: ignore
|
||||
|
||||
_repo = GIRepository.Repository()
|
||||
except ValueError:
|
||||
# We can remove this once we can bump the minimum dependencies
|
||||
# to glib 2.80 and pygobject 3.52
|
||||
# dependency('glib-2.0', version: '>= 2.80.0')
|
||||
# dependency('girepository-2.0', version: '>= 2.80.0')
|
||||
gi.require_version("GIRepository", "2.0")
|
||||
from gi.repository import GIRepository # type: ignore
|
||||
|
||||
_repo = GIRepository.Repository
|
||||
gi.require_version("GIRepository", "2.0")
|
||||
from gi.repository import GIRepository # type: ignore
|
||||
|
||||
from . import typelib, xml_reader
|
||||
from .errors import CompileError, CompilerBugError
|
||||
|
|
@ -54,7 +42,7 @@ def add_typelib_search_path(path: str):
|
|||
|
||||
|
||||
def get_namespace(namespace: str, version: str) -> "Namespace":
|
||||
search_paths = [*_repo.get_search_path(), *_user_search_paths]
|
||||
search_paths = [*GIRepository.Repository.get_search_path(), *_user_search_paths]
|
||||
|
||||
filename = f"{namespace}-{version}.typelib"
|
||||
|
||||
|
|
@ -86,7 +74,7 @@ def get_available_namespaces() -> T.List[T.Tuple[str, str]]:
|
|||
return _available_namespaces
|
||||
|
||||
search_paths: list[str] = [
|
||||
*_repo.get_search_path(),
|
||||
*GIRepository.Repository.get_search_path(),
|
||||
*_user_search_paths,
|
||||
]
|
||||
|
||||
|
|
@ -212,10 +200,6 @@ class ArrayType(GirType):
|
|||
def assignable_to(self, other: GirType) -> bool:
|
||||
return isinstance(other, ArrayType) and self._inner.assignable_to(other._inner)
|
||||
|
||||
@property
|
||||
def inner(self) -> GirType:
|
||||
return self._inner
|
||||
|
||||
@property
|
||||
def name(self) -> str:
|
||||
return self._inner.name + "[]"
|
||||
|
|
@ -348,17 +332,6 @@ class GirNode:
|
|||
def available_in(self) -> str:
|
||||
return self.xml.get("version")
|
||||
|
||||
@cached_property
|
||||
def detail(self) -> T.Optional[str]:
|
||||
try:
|
||||
el = self.xml.get_elements("doc")
|
||||
if len(el) == 1:
|
||||
return el[0].cdata.strip().partition("\n")[0]
|
||||
else:
|
||||
return None
|
||||
except:
|
||||
return None
|
||||
|
||||
@cached_property
|
||||
def doc(self) -> T.Optional[str]:
|
||||
sections = []
|
||||
|
|
@ -467,13 +440,10 @@ class Signature(GirNode):
|
|||
return result
|
||||
|
||||
@cached_property
|
||||
def return_type(self) -> T.Optional[GirType]:
|
||||
if self.tl.SIGNATURE_RETURN_TYPE == 0:
|
||||
return None
|
||||
else:
|
||||
return self.get_containing(Repository)._resolve_type_id(
|
||||
self.tl.SIGNATURE_RETURN_TYPE
|
||||
)
|
||||
def return_type(self) -> GirType:
|
||||
return self.get_containing(Repository)._resolve_type_id(
|
||||
self.tl.SIGNATURE_RETURN_TYPE
|
||||
)
|
||||
|
||||
|
||||
class Signal(GirNode):
|
||||
|
|
@ -493,10 +463,7 @@ class Signal(GirNode):
|
|||
args = ", ".join(
|
||||
[f"{a.type.full_name} {a.name}" for a in self.gir_signature.args]
|
||||
)
|
||||
result = f"signal {self.container.full_name}::{self.name} ({args})"
|
||||
if self.gir_signature.return_type is not None:
|
||||
result += f" -> {self.gir_signature.return_type.full_name}"
|
||||
return result
|
||||
return f"signal {self.container.full_name}::{self.name} ({args})"
|
||||
|
||||
@property
|
||||
def online_docs(self) -> T.Optional[str]:
|
||||
|
|
@ -567,7 +534,7 @@ class Interface(GirNode, GirType):
|
|||
@property
|
||||
def online_docs(self) -> T.Optional[str]:
|
||||
if ns := self.get_containing(Namespace).online_docs:
|
||||
return f"{ns}iface.{self.name}.html"
|
||||
return f"{ns}interface.{self.name}.html"
|
||||
else:
|
||||
return None
|
||||
|
||||
|
|
@ -739,7 +706,7 @@ class TemplateType(GirType):
|
|||
# we don't know the template type's interfaces, assume yes
|
||||
return True
|
||||
elif self.parent is None or isinstance(self.parent, ExternType):
|
||||
return isinstance(other, Class) or isinstance(other, ExternType)
|
||||
return isinstance(other, Class)
|
||||
else:
|
||||
return self.parent.assignable_to(other)
|
||||
|
||||
|
|
@ -908,22 +875,22 @@ class Namespace(GirNode):
|
|||
if isinstance(entry, Class)
|
||||
}
|
||||
|
||||
@cached_property
|
||||
def interfaces(self) -> T.Mapping[str, Interface]:
|
||||
return {
|
||||
name: entry
|
||||
for name, entry in self.entries.items()
|
||||
if isinstance(entry, Interface)
|
||||
}
|
||||
|
||||
def get_type(self, name) -> T.Optional[GirType]:
|
||||
"""Gets a type (class, interface, enum, etc.) from this namespace."""
|
||||
return self.entries.get(name)
|
||||
|
||||
def get_type_by_cname(self, cname: str) -> T.Optional[GirType]:
|
||||
"""Gets a type from this namespace by its C name."""
|
||||
for basic in _BASIC_TYPES.values():
|
||||
if basic.glib_type_name == cname:
|
||||
return basic()
|
||||
|
||||
for item in self.entries.values():
|
||||
if (
|
||||
hasattr(item, "cname")
|
||||
and item.cname is not None
|
||||
and item.cname == cname
|
||||
):
|
||||
if hasattr(item, "cname") and item.cname == cname:
|
||||
return item
|
||||
return None
|
||||
|
||||
|
|
@ -931,8 +898,13 @@ class Namespace(GirNode):
|
|||
"""Looks up a type in the scope of this namespace (including in the
|
||||
namespace's dependencies)."""
|
||||
|
||||
ns, name = type_name.split(".", 1)
|
||||
return self.get_containing(Repository).get_type(name, ns)
|
||||
if type_name in _BASIC_TYPES:
|
||||
return _BASIC_TYPES[type_name]()
|
||||
elif "." in type_name:
|
||||
ns, name = type_name.split(".", 1)
|
||||
return self.get_containing(Repository).get_type(name, ns)
|
||||
else:
|
||||
return self.get_type(type_name)
|
||||
|
||||
@property
|
||||
def online_docs(self) -> T.Optional[str]:
|
||||
|
|
@ -951,7 +923,7 @@ class Repository(GirNode):
|
|||
self.includes = {
|
||||
name: get_namespace(name, version) for name, version in deps
|
||||
}
|
||||
except: # pragma: no cover
|
||||
except:
|
||||
raise CompilerBugError(f"Failed to load dependencies.")
|
||||
else:
|
||||
self.includes = {}
|
||||
|
|
@ -959,6 +931,12 @@ class Repository(GirNode):
|
|||
def get_type(self, name: str, ns: str) -> T.Optional[GirType]:
|
||||
return self.lookup_namespace(ns).get_type(name)
|
||||
|
||||
def get_type_by_cname(self, name: str) -> T.Optional[GirType]:
|
||||
for ns in [self.namespace, *self.includes.values()]:
|
||||
if type := ns.get_type_by_cname(name):
|
||||
return type
|
||||
return None
|
||||
|
||||
def lookup_namespace(self, ns: str):
|
||||
"""Finds a namespace among this namespace's dependencies."""
|
||||
if ns == self.namespace.name:
|
||||
|
|
|
|||
|
|
@ -71,7 +71,7 @@ def decompile_file(in_file, out_file) -> T.Union[str, CouldNotPort]:
|
|||
print(
|
||||
f"""{Colors.FAINT}Either the original XML file had an error, or there is a bug in the
|
||||
porting tool. If you think it's a bug (which is likely), please file an issue on GitLab:
|
||||
{Colors.BLUE}{Colors.UNDERLINE}https://gitlab.gnome.org/GNOME/blueprint-compiler/-/issues/new?issue{Colors.CLEAR}\n"""
|
||||
{Colors.BLUE}{Colors.UNDERLINE}https://gitlab.gnome.org/jwestman/blueprint-compiler/-/issues/new?issue{Colors.CLEAR}\n"""
|
||||
)
|
||||
|
||||
return CouldNotPort("does not compile")
|
||||
|
|
@ -136,7 +136,7 @@ def step1():
|
|||
wrap.write(
|
||||
f"""[wrap-git]
|
||||
directory = blueprint-compiler
|
||||
url = https://gitlab.gnome.org/GNOME/blueprint-compiler.git
|
||||
url = https://gitlab.gnome.org/jwestman/blueprint-compiler.git
|
||||
revision = {VERSION}
|
||||
depth = 1
|
||||
|
||||
|
|
|
|||
|
|
@ -4,6 +4,7 @@ from .adw_breakpoint import (
|
|||
AdwBreakpointSetters,
|
||||
)
|
||||
from .adw_response_dialog import ExtAdwResponseDialog
|
||||
from .attributes import BaseAttribute
|
||||
from .binding import Binding
|
||||
from .common import *
|
||||
from .contexts import ScopeCtx, ValueTypeCtx
|
||||
|
|
@ -19,7 +20,7 @@ from .expression import (
|
|||
from .gobject_object import Object, ObjectContent
|
||||
from .gobject_property import Property
|
||||
from .gobject_signal import Signal
|
||||
from .gtk_a11y import A11yProperty, ExtAccessibility
|
||||
from .gtk_a11y import ExtAccessibility
|
||||
from .gtk_combo_box_text import ExtComboBoxItems
|
||||
from .gtk_file_filter import (
|
||||
Filters,
|
||||
|
|
@ -40,8 +41,6 @@ from .imports import GtkDirective, Import
|
|||
from .types import ClassName
|
||||
from .ui import UI
|
||||
from .values import (
|
||||
ArrayValue,
|
||||
ExprValue,
|
||||
Flag,
|
||||
Flags,
|
||||
IdentLiteral,
|
||||
|
|
|
|||
|
|
@ -81,8 +81,8 @@ class AdwBreakpointSetter(AstNode):
|
|||
return self.tokens["property"]
|
||||
|
||||
@property
|
||||
def value(self) -> T.Optional[Value]:
|
||||
return self.children[Value][0] if len(self.children[Value]) > 0 else None
|
||||
def value(self) -> Value:
|
||||
return self.children[Value][0]
|
||||
|
||||
@property
|
||||
def gir_class(self) -> T.Optional[GirType]:
|
||||
|
|
@ -98,18 +98,13 @@ class AdwBreakpointSetter(AstNode):
|
|||
and not isinstance(self.gir_class, ExternType)
|
||||
and self.property_name is not None
|
||||
):
|
||||
assert isinstance(self.gir_class, gir.Class) or isinstance(
|
||||
self.gir_class, gir.TemplateType
|
||||
)
|
||||
assert isinstance(self.gir_class, gir.Class)
|
||||
return self.gir_class.properties.get(self.property_name)
|
||||
else:
|
||||
return None
|
||||
|
||||
@property
|
||||
def document_symbol(self) -> T.Optional[DocumentSymbol]:
|
||||
if self.value is None:
|
||||
return None
|
||||
|
||||
def document_symbol(self) -> DocumentSymbol:
|
||||
return DocumentSymbol(
|
||||
f"{self.object_id}.{self.property_name}",
|
||||
SymbolKind.Property,
|
||||
|
|
@ -118,17 +113,6 @@ class AdwBreakpointSetter(AstNode):
|
|||
self.value.range.text,
|
||||
)
|
||||
|
||||
def get_reference(self, idx: int) -> T.Optional[LocationLink]:
|
||||
if idx in self.group.tokens["object"].range:
|
||||
if self.object is not None:
|
||||
return LocationLink(
|
||||
self.group.tokens["object"].range,
|
||||
self.object.range,
|
||||
self.object.ranges["id"],
|
||||
)
|
||||
|
||||
return None
|
||||
|
||||
@context(ValueTypeCtx)
|
||||
def value_type(self) -> ValueTypeCtx:
|
||||
if self.gir_property is not None:
|
||||
|
|
@ -209,46 +193,3 @@ class AdwBreakpointSetters(AstNode):
|
|||
@validate()
|
||||
def unique(self):
|
||||
self.validate_unique_in_parent("Duplicate setters block")
|
||||
|
||||
@docs("setters")
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax ExtAdwBreakpoint")
|
||||
|
||||
|
||||
@decompiler("condition", cdata=True)
|
||||
def decompile_condition(ctx: DecompileCtx, gir, cdata):
|
||||
ctx.print(f"condition({escape_quote(cdata)})")
|
||||
|
||||
|
||||
@decompiler("setter", element=True)
|
||||
def decompile_setter(ctx: DecompileCtx, gir, element):
|
||||
assert ctx.parent_node is not None
|
||||
# only run for the first setter
|
||||
for child in ctx.parent_node.children:
|
||||
if child.tag == "setter":
|
||||
if child != element:
|
||||
# already decompiled
|
||||
return
|
||||
else:
|
||||
break
|
||||
|
||||
ctx.print("setters {")
|
||||
for child in ctx.parent_node.children:
|
||||
if child.tag == "setter":
|
||||
object_id = child["object"]
|
||||
property_name = child["property"]
|
||||
obj = ctx.find_object(object_id)
|
||||
if obj is not None:
|
||||
gir_class = ctx.type_by_cname(obj["class"])
|
||||
else:
|
||||
gir_class = None
|
||||
|
||||
if object_id == ctx.template_class:
|
||||
object_id = "template"
|
||||
|
||||
comments, string = ctx.decompile_value(
|
||||
child.cdata,
|
||||
gir_class,
|
||||
(child["translatable"], child["context"], child["comments"]),
|
||||
)
|
||||
ctx.print(f"{comments} {object_id}.{property_name}: {string};")
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@
|
|||
|
||||
from ..decompiler import decompile_translatable, truthy
|
||||
from .common import *
|
||||
from .contexts import ValueTypeCtx
|
||||
from .gobject_object import ObjectContent, validate_parent_type
|
||||
from .values import StringValue
|
||||
|
||||
|
|
@ -93,6 +94,10 @@ class ExtAdwResponseDialogResponse(AstNode):
|
|||
self.value.range.text,
|
||||
)
|
||||
|
||||
@context(ValueTypeCtx)
|
||||
def value_type(self) -> ValueTypeCtx:
|
||||
return ValueTypeCtx(StringType())
|
||||
|
||||
@validate("id")
|
||||
def unique_in_parent(self):
|
||||
self.validate_unique_in_parent(
|
||||
|
|
@ -133,10 +138,6 @@ class ExtAdwResponseDialog(AstNode):
|
|||
def unique_in_parent(self):
|
||||
self.validate_unique_in_parent("Duplicate responses block")
|
||||
|
||||
@docs()
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax ExtAdwMessageDialog")
|
||||
|
||||
|
||||
@completer(
|
||||
applies_in=[ObjectContent],
|
||||
|
|
|
|||
32
blueprintcompiler/language/attributes.py
Normal file
32
blueprintcompiler/language/attributes.py
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
# attributes.py
|
||||
#
|
||||
# Copyright 2022 James Westman <james@jwestman.net>
|
||||
#
|
||||
# This file is free software; you can redistribute it and/or modify it
|
||||
# under the terms of the GNU Lesser General Public License as
|
||||
# published by the Free Software Foundation; either version 3 of the
|
||||
# License, or (at your option) any later version.
|
||||
#
|
||||
# This file is distributed in the hope that it will be useful, but
|
||||
# WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
# Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General Public
|
||||
# License along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#
|
||||
# SPDX-License-Identifier: LGPL-3.0-or-later
|
||||
|
||||
|
||||
from .common import *
|
||||
|
||||
|
||||
class BaseAttribute(AstNode):
|
||||
"""A helper class for attribute syntax of the form `name: literal_value;`"""
|
||||
|
||||
tag_name: str = ""
|
||||
attr_name: str = "name"
|
||||
|
||||
@property
|
||||
def name(self):
|
||||
return self.tokens["name"]
|
||||
|
|
@ -58,10 +58,6 @@ class BindingFlag(AstNode):
|
|||
"Only bindings with a single lookup can have flags",
|
||||
)
|
||||
|
||||
@docs()
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax Binding")
|
||||
|
||||
|
||||
class Binding(AstNode):
|
||||
grammar = [
|
||||
|
|
@ -103,10 +99,6 @@ class Binding(AstNode):
|
|||
actions=[CodeAction("use 'bind'", "bind")],
|
||||
)
|
||||
|
||||
@docs("bind")
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax Binding")
|
||||
|
||||
|
||||
@dataclass
|
||||
class SimpleBinding:
|
||||
|
|
@ -115,9 +107,3 @@ class SimpleBinding:
|
|||
no_sync_create: bool = False
|
||||
bidirectional: bool = False
|
||||
inverted: bool = False
|
||||
|
||||
|
||||
@decompiler("binding")
|
||||
def decompile_binding(ctx: DecompileCtx, gir: gir.GirContext, name: str):
|
||||
ctx.end_block_with(";")
|
||||
ctx.print(f"{name}: bind ")
|
||||
|
|
|
|||
|
|
@ -35,7 +35,6 @@ from ..errors import (
|
|||
CompileWarning,
|
||||
DeprecatedWarning,
|
||||
MultipleErrors,
|
||||
UnusedWarning,
|
||||
UpgradeWarning,
|
||||
)
|
||||
from ..gir import (
|
||||
|
|
@ -55,7 +54,6 @@ from ..lsp_utils import (
|
|||
SemanticToken,
|
||||
SemanticTokenType,
|
||||
SymbolKind,
|
||||
get_docs_section,
|
||||
)
|
||||
from ..parse_tree import *
|
||||
|
||||
|
|
|
|||
|
|
@ -79,9 +79,3 @@ class ScopeCtx:
|
|||
for child in node.children:
|
||||
if child.context[ScopeCtx] is self:
|
||||
yield from self._iter_recursive(child)
|
||||
|
||||
|
||||
@dataclass
|
||||
class ExprValueCtx:
|
||||
"""Indicates that the context is an expression literal, where the
|
||||
"item" keyword may be used."""
|
||||
|
|
|
|||
|
|
@ -18,9 +18,9 @@
|
|||
# SPDX-License-Identifier: LGPL-3.0-or-later
|
||||
|
||||
|
||||
from ..decompiler import decompile_element
|
||||
from .common import *
|
||||
from .contexts import ScopeCtx, ValueTypeCtx
|
||||
from .gtkbuilder_template import Template
|
||||
from .types import TypeName
|
||||
|
||||
expr = Sequence()
|
||||
|
|
@ -38,6 +38,10 @@ class ExprBase(AstNode):
|
|||
def type(self) -> T.Optional[GirType]:
|
||||
raise NotImplementedError()
|
||||
|
||||
@property
|
||||
def type_complete(self) -> bool:
|
||||
return True
|
||||
|
||||
@property
|
||||
def rhs(self) -> T.Optional["ExprBase"]:
|
||||
if isinstance(self.parent, Expression):
|
||||
|
|
@ -61,6 +65,10 @@ class Expression(ExprBase):
|
|||
def type(self) -> T.Optional[GirType]:
|
||||
return self.last.type
|
||||
|
||||
@property
|
||||
def type_complete(self) -> bool:
|
||||
return self.last.type_complete
|
||||
|
||||
|
||||
class InfixExpr(ExprBase):
|
||||
@property
|
||||
|
|
@ -81,16 +89,6 @@ class LiteralExpr(ExprBase):
|
|||
or self.root.is_legacy_template(self.literal.value.ident)
|
||||
)
|
||||
|
||||
@property
|
||||
def is_this(self) -> bool:
|
||||
from .values import IdentLiteral
|
||||
|
||||
return (
|
||||
not self.is_object
|
||||
and isinstance(self.literal.value, IdentLiteral)
|
||||
and self.literal.value.ident == "item"
|
||||
)
|
||||
|
||||
@property
|
||||
def literal(self):
|
||||
from .values import Literal
|
||||
|
|
@ -101,14 +99,14 @@ class LiteralExpr(ExprBase):
|
|||
def type(self) -> T.Optional[GirType]:
|
||||
return self.literal.value.type
|
||||
|
||||
@validate()
|
||||
def item_validations(self):
|
||||
if self.is_this:
|
||||
if not isinstance(self.rhs, CastExpr):
|
||||
raise CompileError('"item" must be cast to its object type')
|
||||
@property
|
||||
def type_complete(self) -> bool:
|
||||
from .values import IdentLiteral
|
||||
|
||||
if not isinstance(self.rhs.rhs, LookupOp):
|
||||
raise CompileError('"item" can only be used for looking up properties')
|
||||
if isinstance(self.literal.value, IdentLiteral):
|
||||
if object := self.context[ScopeCtx].objects.get(self.literal.value.ident):
|
||||
return not object.gir_class.incomplete
|
||||
return True
|
||||
|
||||
|
||||
class LookupOp(InfixExpr):
|
||||
|
|
@ -132,17 +130,6 @@ class LookupOp(InfixExpr):
|
|||
|
||||
return None
|
||||
|
||||
@docs("property")
|
||||
def property_docs(self):
|
||||
if not (
|
||||
isinstance(self.lhs.type, gir.Class)
|
||||
or isinstance(self.lhs.type, gir.Interface)
|
||||
):
|
||||
return None
|
||||
|
||||
if property := self.lhs.type.properties.get(self.property_name):
|
||||
return property.doc
|
||||
|
||||
@validate("property")
|
||||
def property_exists(self):
|
||||
if self.lhs.type is None:
|
||||
|
|
@ -173,28 +160,10 @@ class LookupOp(InfixExpr):
|
|||
did_you_mean=(self.property_name, self.lhs.type.properties.keys()),
|
||||
)
|
||||
|
||||
@validate("property")
|
||||
def property_deprecated(self):
|
||||
if self.lhs.type is None or not (
|
||||
isinstance(self.lhs.type, gir.Class)
|
||||
or isinstance(self.lhs.type, gir.Interface)
|
||||
):
|
||||
return
|
||||
|
||||
if property := self.lhs.type.properties.get(self.property_name):
|
||||
if property.deprecated:
|
||||
hints = []
|
||||
if property.deprecated_doc:
|
||||
hints.append(property.deprecated_doc)
|
||||
raise DeprecatedWarning(
|
||||
f"{property.signature} is deprecated",
|
||||
hints=hints,
|
||||
)
|
||||
|
||||
|
||||
class CastExpr(InfixExpr):
|
||||
grammar = [
|
||||
Keyword("as"),
|
||||
"as",
|
||||
AnyOf(
|
||||
["<", TypeName, Match(">").expected()],
|
||||
[
|
||||
|
|
@ -213,6 +182,10 @@ class CastExpr(InfixExpr):
|
|||
def type(self) -> T.Optional[GirType]:
|
||||
return self.children[TypeName][0].gir_type
|
||||
|
||||
@property
|
||||
def type_complete(self) -> bool:
|
||||
return True
|
||||
|
||||
@validate()
|
||||
def cast_makes_sense(self):
|
||||
if self.type is None or self.lhs.type is None:
|
||||
|
|
@ -236,10 +209,6 @@ class CastExpr(InfixExpr):
|
|||
],
|
||||
)
|
||||
|
||||
@docs("as")
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax CastExpression")
|
||||
|
||||
|
||||
class ClosureArg(AstNode):
|
||||
grammar = Expression
|
||||
|
|
@ -289,96 +258,8 @@ class ClosureExpr(ExprBase):
|
|||
if not self.tokens["extern"]:
|
||||
raise CompileError(f"{self.closure_name} is not a builtin function")
|
||||
|
||||
@docs("name")
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax ClosureExpression")
|
||||
|
||||
|
||||
expr.children = [
|
||||
AnyOf(ClosureExpr, LiteralExpr, ["(", Expression, ")"]),
|
||||
ZeroOrMore(AnyOf(LookupOp, CastExpr)),
|
||||
]
|
||||
|
||||
|
||||
@decompiler("lookup", skip_children=True, cdata=True)
|
||||
def decompile_lookup(
|
||||
ctx: DecompileCtx,
|
||||
gir: gir.GirContext,
|
||||
cdata: str,
|
||||
name: str,
|
||||
type: T.Optional[str] = None,
|
||||
):
|
||||
if ctx.parent_node is not None and ctx.parent_node.tag == "property":
|
||||
ctx.print("expr ")
|
||||
|
||||
if type is None:
|
||||
type = ""
|
||||
elif t := ctx.type_by_cname(type):
|
||||
type = decompile.full_name(t)
|
||||
else:
|
||||
type = "$" + type
|
||||
|
||||
assert ctx.current_node is not None
|
||||
|
||||
constant = None
|
||||
if len(ctx.current_node.children) == 0:
|
||||
constant = cdata
|
||||
elif (
|
||||
len(ctx.current_node.children) == 1
|
||||
and ctx.current_node.children[0].tag == "constant"
|
||||
):
|
||||
constant = ctx.current_node.children[0].cdata
|
||||
|
||||
if constant is not None:
|
||||
if constant == ctx.template_class:
|
||||
ctx.print("template." + name)
|
||||
elif constant == "":
|
||||
ctx.print(f"item as <{type}>.{name}")
|
||||
else:
|
||||
ctx.print(constant + "." + name)
|
||||
return
|
||||
else:
|
||||
for child in ctx.current_node.children:
|
||||
decompile.decompile_element(ctx, gir, child)
|
||||
|
||||
ctx.print(f" as <{type}>.{name}")
|
||||
|
||||
|
||||
@decompiler("constant", cdata=True)
|
||||
def decompile_constant(
|
||||
ctx: DecompileCtx, gir: gir.GirContext, cdata: str, type: T.Optional[str] = None
|
||||
):
|
||||
if ctx.parent_node is not None and ctx.parent_node.tag == "property":
|
||||
ctx.print("expr ")
|
||||
|
||||
if type is None:
|
||||
if cdata == ctx.template_class:
|
||||
ctx.print("template")
|
||||
else:
|
||||
ctx.print(cdata)
|
||||
else:
|
||||
_, string = ctx.decompile_value(cdata, ctx.type_by_cname(type))
|
||||
ctx.print(string)
|
||||
|
||||
|
||||
@decompiler("closure", skip_children=True)
|
||||
def decompile_closure(ctx: DecompileCtx, gir: gir.GirContext, function: str, type: str):
|
||||
if ctx.parent_node is not None and ctx.parent_node.tag == "property":
|
||||
ctx.print("expr ")
|
||||
|
||||
if t := ctx.type_by_cname(type):
|
||||
type = decompile.full_name(t)
|
||||
else:
|
||||
type = "$" + type
|
||||
|
||||
ctx.print(f"${function}(")
|
||||
|
||||
assert ctx.current_node is not None
|
||||
for i, node in enumerate(ctx.current_node.children):
|
||||
decompile_element(ctx, gir, node)
|
||||
|
||||
assert ctx.current_node is not None
|
||||
if i < len(ctx.current_node.children) - 1:
|
||||
ctx.print(", ")
|
||||
|
||||
ctx.end_block_with(f") as <{type}>")
|
||||
|
|
|
|||
|
|
@ -28,18 +28,7 @@ from .common import *
|
|||
from .response_id import ExtResponse
|
||||
from .types import ClassName, ConcreteClassName
|
||||
|
||||
RESERVED_IDS = {
|
||||
"this",
|
||||
"self",
|
||||
"template",
|
||||
"true",
|
||||
"false",
|
||||
"null",
|
||||
"none",
|
||||
"item",
|
||||
"expr",
|
||||
"typeof",
|
||||
}
|
||||
RESERVED_IDS = {"this", "self", "template", "true", "false", "null", "none"}
|
||||
|
||||
|
||||
class ObjectContent(AstNode):
|
||||
|
|
@ -121,12 +110,12 @@ def validate_parent_type(node, ns: str, name: str, err_msg: str):
|
|||
container_type = node.parent_by_type(Object).gir_class
|
||||
if container_type and not container_type.assignable_to(parent):
|
||||
raise CompileError(
|
||||
f"{container_type.full_name} is not a {ns}.{name}, so it doesn't have {err_msg}"
|
||||
f"{container_type.full_name} is not a {parent.full_name}, so it doesn't have {err_msg}"
|
||||
)
|
||||
|
||||
|
||||
@decompiler("object")
|
||||
def decompile_object(ctx: DecompileCtx, gir, klass, id=None):
|
||||
def decompile_object(ctx, gir, klass, id=None):
|
||||
gir_class = ctx.type_by_cname(klass)
|
||||
klass_name = (
|
||||
decompile.full_name(gir_class) if gir_class is not None else "$" + klass
|
||||
|
|
@ -135,5 +124,4 @@ def decompile_object(ctx: DecompileCtx, gir, klass, id=None):
|
|||
ctx.print(f"{klass_name} {{")
|
||||
else:
|
||||
ctx.print(f"{klass_name} {id} {{")
|
||||
ctx.push_obj_type(gir_class)
|
||||
return gir_class
|
||||
|
|
|
|||
|
|
@ -21,20 +21,19 @@
|
|||
from .binding import Binding
|
||||
from .common import *
|
||||
from .contexts import ValueTypeCtx
|
||||
from .values import ArrayValue, ExprValue, ObjectValue, Value
|
||||
from .gtkbuilder_template import Template
|
||||
from .values import ObjectValue, Value
|
||||
|
||||
|
||||
class Property(AstNode):
|
||||
grammar = Statement(
|
||||
UseIdent("name"), ":", AnyOf(Binding, ExprValue, ObjectValue, Value, ArrayValue)
|
||||
)
|
||||
grammar = Statement(UseIdent("name"), ":", AnyOf(Binding, ObjectValue, Value))
|
||||
|
||||
@property
|
||||
def name(self) -> str:
|
||||
return self.tokens["name"]
|
||||
|
||||
@property
|
||||
def value(self) -> T.Union[Binding, ExprValue, ObjectValue, Value, ArrayValue]:
|
||||
def value(self) -> T.Union[Binding, ObjectValue, Value]:
|
||||
return self.children[0]
|
||||
|
||||
@property
|
||||
|
|
@ -50,7 +49,7 @@ class Property(AstNode):
|
|||
|
||||
@property
|
||||
def document_symbol(self) -> DocumentSymbol:
|
||||
if isinstance(self.value, ObjectValue) or self.value is None:
|
||||
if isinstance(self.value, ObjectValue):
|
||||
detail = None
|
||||
else:
|
||||
detail = self.value.range.text
|
||||
|
|
|
|||
|
|
@ -27,7 +27,6 @@ from .gtkbuilder_template import Template
|
|||
class SignalFlag(AstNode):
|
||||
grammar = AnyOf(
|
||||
UseExact("flag", "swapped"),
|
||||
UseExact("flag", "not-swapped"),
|
||||
UseExact("flag", "after"),
|
||||
)
|
||||
|
||||
|
|
@ -41,31 +40,6 @@ class SignalFlag(AstNode):
|
|||
f"Duplicate flag '{self.flag}'", lambda x: x.flag == self.flag
|
||||
)
|
||||
|
||||
@validate()
|
||||
def swapped_exclusive(self):
|
||||
if self.flag in ["swapped", "not-swapped"]:
|
||||
self.validate_unique_in_parent(
|
||||
"'swapped' and 'not-swapped' flags cannot be used together",
|
||||
lambda x: x.flag in ["swapped", "not-swapped"],
|
||||
)
|
||||
|
||||
@validate()
|
||||
def swapped_unnecessary(self):
|
||||
if self.flag == "not-swapped" and self.parent.object_id is None:
|
||||
raise CompileWarning(
|
||||
"'not-swapped' is the default for handlers that do not specify an object",
|
||||
actions=[CodeAction("Remove 'not-swapped' flag", "")],
|
||||
)
|
||||
elif self.flag == "swapped" and self.parent.object_id is not None:
|
||||
raise CompileWarning(
|
||||
"'swapped' is the default for handlers that specify an object",
|
||||
actions=[CodeAction("Remove 'swapped' flag", "")],
|
||||
)
|
||||
|
||||
@docs()
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax Signal")
|
||||
|
||||
|
||||
class Signal(AstNode):
|
||||
grammar = Statement(
|
||||
|
|
@ -76,7 +50,7 @@ class Signal(AstNode):
|
|||
UseIdent("detail_name").expected("a signal detail name"),
|
||||
]
|
||||
),
|
||||
Keyword("=>"),
|
||||
"=>",
|
||||
Mark("detail_start"),
|
||||
Optional(["$", UseLiteral("extern", True)]),
|
||||
UseIdent("handler").expected("the name of a function to handle the signal"),
|
||||
|
|
@ -114,17 +88,9 @@ class Signal(AstNode):
|
|||
def flags(self) -> T.List[SignalFlag]:
|
||||
return self.children[SignalFlag]
|
||||
|
||||
# Returns True if the "swapped" flag is present, False if "not-swapped" is present, and None if neither are present.
|
||||
# GtkBuilder's default if swapped is not specified is to not swap the arguments if no object is specified, and to
|
||||
# swap them if an object is specified.
|
||||
@property
|
||||
def is_swapped(self) -> T.Optional[bool]:
|
||||
for flag in self.flags:
|
||||
if flag.flag == "swapped":
|
||||
return True
|
||||
elif flag.flag == "not-swapped":
|
||||
return False
|
||||
return None
|
||||
def is_swapped(self) -> bool:
|
||||
return any(x.flag == "swapped" for x in self.flags)
|
||||
|
||||
@property
|
||||
def is_after(self) -> bool:
|
||||
|
|
@ -143,25 +109,14 @@ class Signal(AstNode):
|
|||
|
||||
@property
|
||||
def document_symbol(self) -> DocumentSymbol:
|
||||
detail = self.ranges["detail_start", "detail_end"]
|
||||
return DocumentSymbol(
|
||||
self.full_name,
|
||||
SymbolKind.Event,
|
||||
self.range,
|
||||
self.group.tokens["name"].range,
|
||||
detail.text if detail is not None else None,
|
||||
self.ranges["detail_start", "detail_end"].text,
|
||||
)
|
||||
|
||||
def get_reference(self, idx: int) -> T.Optional[LocationLink]:
|
||||
if self.object_id is not None and idx in self.group.tokens["object"].range:
|
||||
obj = self.context[ScopeCtx].objects.get(self.object_id)
|
||||
if obj is not None:
|
||||
return LocationLink(
|
||||
self.group.tokens["object"].range, obj.range, obj.ranges["id"]
|
||||
)
|
||||
|
||||
return None
|
||||
|
||||
@validate("handler")
|
||||
def old_extern(self):
|
||||
if not self.tokens["extern"]:
|
||||
|
|
@ -209,41 +164,13 @@ class Signal(AstNode):
|
|||
if self.gir_signal is not None:
|
||||
return self.gir_signal.doc
|
||||
|
||||
@docs("detail_name")
|
||||
def detail_docs(self):
|
||||
if self.name == "notify":
|
||||
if self.gir_class is not None and not isinstance(
|
||||
self.gir_class, ExternType
|
||||
):
|
||||
prop = self.gir_class.properties.get(self.tokens["detail_name"])
|
||||
if prop is not None:
|
||||
return prop.doc
|
||||
|
||||
@docs("=>")
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax Signal")
|
||||
|
||||
|
||||
@decompiler("signal")
|
||||
def decompile_signal(
|
||||
ctx: DecompileCtx, gir, name, handler, swapped=None, after="false", object=None
|
||||
):
|
||||
def decompile_signal(ctx, gir, name, handler, swapped="false", object=None):
|
||||
object_name = object or ""
|
||||
|
||||
if object_name == ctx.template_class:
|
||||
object_name = "template"
|
||||
|
||||
name = name.replace("_", "-")
|
||||
line = f"{name} => ${handler}({object_name})"
|
||||
|
||||
if decompile.truthy(swapped):
|
||||
line += " swapped"
|
||||
elif swapped is not None:
|
||||
line += " not-swapped"
|
||||
|
||||
if decompile.truthy(after):
|
||||
line += " after"
|
||||
|
||||
line += ";"
|
||||
ctx.print(line)
|
||||
ctx.print(f"{name} => ${handler}({object_name}) swapped;")
|
||||
else:
|
||||
ctx.print(f"{name} => ${handler}({object_name});")
|
||||
return gir
|
||||
|
|
|
|||
|
|
@ -17,8 +17,8 @@
|
|||
#
|
||||
# SPDX-License-Identifier: LGPL-3.0-or-later
|
||||
|
||||
import typing as T
|
||||
|
||||
from ..decompiler import escape_quote
|
||||
from .attributes import BaseAttribute
|
||||
from .common import *
|
||||
from .contexts import ValueTypeCtx
|
||||
from .gobject_object import ObjectContent, validate_parent_type
|
||||
|
|
@ -97,16 +97,6 @@ def get_types(gir):
|
|||
}
|
||||
|
||||
|
||||
allow_duplicates = [
|
||||
"controls",
|
||||
"described-by",
|
||||
"details",
|
||||
"flow-to",
|
||||
"labelled-by",
|
||||
"owns",
|
||||
]
|
||||
|
||||
|
||||
def _get_docs(gir, name):
|
||||
name = name.replace("-", "_")
|
||||
if gir_type := (
|
||||
|
|
@ -117,11 +107,11 @@ def _get_docs(gir, name):
|
|||
return gir_type.doc
|
||||
|
||||
|
||||
class A11yProperty(AstNode):
|
||||
class A11yProperty(BaseAttribute):
|
||||
grammar = Statement(
|
||||
UseIdent("name"),
|
||||
":",
|
||||
AnyOf(Value, ["[", UseLiteral("list_form", True), Delimited(Value, ","), "]"]),
|
||||
Value,
|
||||
)
|
||||
|
||||
@property
|
||||
|
|
@ -142,8 +132,8 @@ class A11yProperty(AstNode):
|
|||
return self.tokens["name"].replace("_", "-")
|
||||
|
||||
@property
|
||||
def values(self) -> T.List[Value]:
|
||||
return list(self.children)
|
||||
def value(self) -> Value:
|
||||
return self.children[0]
|
||||
|
||||
@context(ValueTypeCtx)
|
||||
def value_type(self) -> ValueTypeCtx:
|
||||
|
|
@ -156,7 +146,7 @@ class A11yProperty(AstNode):
|
|||
SymbolKind.Field,
|
||||
self.range,
|
||||
self.group.tokens["name"].range,
|
||||
", ".join(v.range.text for v in self.values),
|
||||
self.value.range.text,
|
||||
)
|
||||
|
||||
@validate("name")
|
||||
|
|
@ -175,20 +165,6 @@ class A11yProperty(AstNode):
|
|||
check=lambda child: child.tokens["name"] == self.tokens["name"],
|
||||
)
|
||||
|
||||
@validate("name")
|
||||
def list_only_allowed_for_subset(self):
|
||||
if self.tokens["list_form"] and self.tokens["name"] not in allow_duplicates:
|
||||
raise CompileError(
|
||||
f"'{self.tokens['name']}' does not allow a list of values",
|
||||
)
|
||||
|
||||
@validate("name")
|
||||
def list_non_empty(self):
|
||||
if len(self.values) == 0:
|
||||
raise CompileError(
|
||||
f"'{self.tokens['name']}' may not be empty",
|
||||
)
|
||||
|
||||
@docs("name")
|
||||
def prop_docs(self):
|
||||
if self.tokens["name"] in get_types(self.root.gir):
|
||||
|
|
@ -223,10 +199,6 @@ class ExtAccessibility(AstNode):
|
|||
def unique_in_parent(self):
|
||||
self.validate_unique_in_parent("Duplicate accessibility block")
|
||||
|
||||
@docs("accessibility")
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax ExtAccessibility")
|
||||
|
||||
|
||||
@completer(
|
||||
applies_in=[ObjectContent],
|
||||
|
|
@ -251,37 +223,19 @@ def a11y_name_completer(lsp, ast_node, match_variables):
|
|||
)
|
||||
|
||||
|
||||
@decompiler("accessibility", skip_children=True, element=True)
|
||||
def decompile_accessibility(ctx: DecompileCtx, _gir, element):
|
||||
@decompiler("relation", cdata=True)
|
||||
def decompile_relation(ctx, gir, name, cdata):
|
||||
ctx.print_attribute(name, cdata, get_types(ctx.gir).get(name))
|
||||
|
||||
|
||||
@decompiler("state", cdata=True)
|
||||
def decompile_state(ctx, gir, name, cdata, translatable="false"):
|
||||
if decompile.truthy(translatable):
|
||||
ctx.print(f"{name}: _({escape_quote(cdata)});")
|
||||
else:
|
||||
ctx.print_attribute(name, cdata, get_types(ctx.gir).get(name))
|
||||
|
||||
|
||||
@decompiler("accessibility")
|
||||
def decompile_accessibility(ctx, gir):
|
||||
ctx.print("accessibility {")
|
||||
already_printed = set()
|
||||
types = get_types(ctx.gir)
|
||||
|
||||
for child in element.children:
|
||||
name = child["name"]
|
||||
|
||||
if name in allow_duplicates:
|
||||
if name in already_printed:
|
||||
continue
|
||||
|
||||
ctx.print(f"{name}: [")
|
||||
for value in element.children:
|
||||
if value["name"] == name:
|
||||
comments, string = ctx.decompile_value(
|
||||
value.cdata,
|
||||
types.get(value["name"]),
|
||||
(value["translatable"], value["context"], value["comments"]),
|
||||
)
|
||||
ctx.print(f"{comments} {string},")
|
||||
ctx.print("];")
|
||||
else:
|
||||
comments, string = ctx.decompile_value(
|
||||
child.cdata,
|
||||
types.get(child["name"]),
|
||||
(child["translatable"], child["context"], child["comments"]),
|
||||
)
|
||||
ctx.print(f"{comments} {name}: {string};")
|
||||
|
||||
already_printed.add(name)
|
||||
ctx.print("}")
|
||||
ctx.end_block_with("")
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@
|
|||
|
||||
|
||||
from .common import *
|
||||
from .contexts import ValueTypeCtx
|
||||
from .gobject_object import ObjectContent, validate_parent_type
|
||||
from .values import StringValue
|
||||
|
||||
|
|
@ -54,10 +55,6 @@ class Item(AstNode):
|
|||
f"Duplicate item '{self.name}'", lambda x: x.name == self.name
|
||||
)
|
||||
|
||||
@docs("name")
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax ExtComboBoxItems")
|
||||
|
||||
|
||||
class ExtComboBoxItems(AstNode):
|
||||
grammar = [
|
||||
|
|
@ -84,10 +81,6 @@ class ExtComboBoxItems(AstNode):
|
|||
def unique_in_parent(self):
|
||||
self.validate_unique_in_parent("Duplicate items block")
|
||||
|
||||
@docs("items")
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax ExtComboBoxItems")
|
||||
|
||||
|
||||
@completer(
|
||||
applies_in=[ObjectContent],
|
||||
|
|
@ -96,29 +89,3 @@ class ExtComboBoxItems(AstNode):
|
|||
)
|
||||
def items_completer(lsp, ast_node, match_variables):
|
||||
yield Completion("items", CompletionItemKind.Snippet, snippet="items [$0]")
|
||||
|
||||
|
||||
@decompiler("items", parent_type="Gtk.ComboBoxText")
|
||||
def decompile_items(ctx: DecompileCtx, gir: gir.GirContext):
|
||||
ctx.print("items [")
|
||||
|
||||
|
||||
@decompiler("item", parent_type="Gtk.ComboBoxText", cdata=True)
|
||||
def decompile_item(
|
||||
ctx: DecompileCtx,
|
||||
gir: gir.GirContext,
|
||||
cdata: str,
|
||||
id: T.Optional[str] = None,
|
||||
translatable="false",
|
||||
comments=None,
|
||||
context=None,
|
||||
):
|
||||
comments, translatable = decompile_translatable(
|
||||
cdata, translatable, context, comments
|
||||
)
|
||||
if comments:
|
||||
ctx.print(comments)
|
||||
if id:
|
||||
ctx.print(f"{id}: ")
|
||||
ctx.print(translatable)
|
||||
ctx.print(",")
|
||||
|
|
|
|||
|
|
@ -29,23 +29,25 @@ class Filters(AstNode):
|
|||
self.tokens["tag_name"],
|
||||
SymbolKind.Array,
|
||||
self.range,
|
||||
self.group.tokens["tag_name"].range,
|
||||
self.group.tokens[self.tokens["tag_name"]].range,
|
||||
)
|
||||
|
||||
@validate()
|
||||
def container_is_file_filter(self):
|
||||
validate_parent_type(self, "Gtk", "FileFilter", "file filter properties")
|
||||
|
||||
@validate("tag_name")
|
||||
@validate()
|
||||
def unique_in_parent(self):
|
||||
self.validate_unique_in_parent(
|
||||
f"Duplicate {self.tokens['tag_name']} block",
|
||||
check=lambda child: child.tokens["tag_name"] == self.tokens["tag_name"],
|
||||
)
|
||||
# The token argument to validate() needs to be calculated based on
|
||||
# the instance, hence wrapping it like this.
|
||||
@validate(self.tokens["tag_name"])
|
||||
def wrapped_validator(self):
|
||||
self.validate_unique_in_parent(
|
||||
f"Duplicate {self.tokens['tag_name']} block",
|
||||
check=lambda child: child.tokens["tag_name"] == self.tokens["tag_name"],
|
||||
)
|
||||
|
||||
@docs("tag_name")
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax ExtFileFilter")
|
||||
wrapped_validator(self)
|
||||
|
||||
|
||||
class FilterString(AstNode):
|
||||
|
|
@ -74,7 +76,8 @@ def create_node(tag_name: str, singular: str):
|
|||
return Group(
|
||||
Filters,
|
||||
[
|
||||
UseExact("tag_name", tag_name),
|
||||
Keyword(tag_name),
|
||||
UseLiteral("tag_name", tag_name),
|
||||
"[",
|
||||
Delimited(
|
||||
Group(
|
||||
|
|
|
|||
|
|
@ -83,10 +83,6 @@ class ExtLayout(AstNode):
|
|||
def unique_in_parent(self):
|
||||
self.validate_unique_in_parent("Duplicate layout block")
|
||||
|
||||
@docs("layout")
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax ExtLayout")
|
||||
|
||||
|
||||
@completer(
|
||||
applies_in=[ObjectContent],
|
||||
|
|
|
|||
|
|
@ -11,13 +11,7 @@ from .types import TypeName
|
|||
|
||||
|
||||
class ExtListItemFactory(AstNode):
|
||||
grammar = [
|
||||
UseExact("id", "template"),
|
||||
Mark("typename_start"),
|
||||
Optional(TypeName),
|
||||
Mark("typename_end"),
|
||||
ObjectContent,
|
||||
]
|
||||
grammar = [UseExact("id", "template"), Optional(TypeName), ObjectContent]
|
||||
|
||||
@property
|
||||
def id(self) -> str:
|
||||
|
|
@ -45,12 +39,9 @@ class ExtListItemFactory(AstNode):
|
|||
|
||||
@property
|
||||
def gir_class(self):
|
||||
if self.type_name is not None:
|
||||
return self.type_name.gir_type
|
||||
else:
|
||||
return self.root.gir.get_type("ListItem", "Gtk")
|
||||
return self.root.gir.get_type("ListItem", "Gtk")
|
||||
|
||||
@validate("id")
|
||||
@validate("template")
|
||||
def container_is_builder_list(self):
|
||||
validate_parent_type(
|
||||
self,
|
||||
|
|
@ -59,24 +50,17 @@ class ExtListItemFactory(AstNode):
|
|||
"sub-templates",
|
||||
)
|
||||
|
||||
@validate("id")
|
||||
@validate("template")
|
||||
def unique_in_parent(self):
|
||||
self.validate_unique_in_parent("Duplicate template block")
|
||||
|
||||
@validate("typename_start", "typename_end")
|
||||
@validate()
|
||||
def type_is_list_item(self):
|
||||
if self.type_name is not None:
|
||||
if self.type_name.glib_type_name not in (
|
||||
"GtkListItem",
|
||||
"GtkListHeader",
|
||||
"GtkColumnViewRow",
|
||||
"GtkColumnViewCell",
|
||||
):
|
||||
raise CompileError(
|
||||
f"Only Gtk.ListItem, Gtk.ListHeader, Gtk.ColumnViewRow, or Gtk.ColumnViewCell is allowed as a type here"
|
||||
)
|
||||
if self.type_name.glib_type_name != "GtkListItem":
|
||||
raise CompileError(f"Only Gtk.ListItem is allowed as a type here")
|
||||
|
||||
@validate("id")
|
||||
@validate("template")
|
||||
def type_name_upgrade(self):
|
||||
if self.type_name is None:
|
||||
raise UpgradeWarning(
|
||||
|
|
@ -103,9 +87,8 @@ class ExtListItemFactory(AstNode):
|
|||
|
||||
@property
|
||||
def action_widgets(self):
|
||||
# The sub-template shouldn't have its own actions, this is just here to satisfy XmlOutput._emit_object_or_template
|
||||
"""
|
||||
The sub-template shouldn't have it`s own actions this is
|
||||
just hear to satisfy XmlOutput._emit_object_or_template
|
||||
"""
|
||||
return None
|
||||
|
||||
@docs("id")
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax ExtListItemFactory")
|
||||
|
|
|
|||
|
|
@ -70,25 +70,6 @@ class Menu(AstNode):
|
|||
if self.id in RESERVED_IDS:
|
||||
raise CompileWarning(f"{self.id} may be a confusing object ID")
|
||||
|
||||
@docs("menu")
|
||||
def ref_docs_menu(self):
|
||||
return get_docs_section("Syntax Menu")
|
||||
|
||||
@docs("section")
|
||||
def ref_docs_section(self):
|
||||
return get_docs_section("Syntax Menu")
|
||||
|
||||
@docs("submenu")
|
||||
def ref_docs_submenu(self):
|
||||
return get_docs_section("Syntax Menu")
|
||||
|
||||
@docs("item")
|
||||
def ref_docs_item(self):
|
||||
if self.tokens["shorthand"]:
|
||||
return get_docs_section("Syntax MenuItemShorthand")
|
||||
else:
|
||||
return get_docs_section("Syntax Menu")
|
||||
|
||||
|
||||
class MenuAttribute(AstNode):
|
||||
tag_name = "attribute"
|
||||
|
|
@ -175,7 +156,6 @@ menu_item_shorthand = Group(
|
|||
[
|
||||
Keyword("item"),
|
||||
UseLiteral("tag", "item"),
|
||||
UseLiteral("shorthand", True),
|
||||
"(",
|
||||
Group(
|
||||
MenuAttribute,
|
||||
|
|
@ -286,7 +266,7 @@ def decompile_submenu(ctx, gir, id=None):
|
|||
ctx.print("submenu {")
|
||||
|
||||
|
||||
@decompiler("item", parent_tag="menu")
|
||||
@decompiler("item")
|
||||
def decompile_item(ctx, gir, id=None):
|
||||
if id:
|
||||
ctx.print(f"item {id} {{")
|
||||
|
|
|
|||
|
|
@ -94,10 +94,6 @@ class ExtScaleMark(AstNode):
|
|||
did_you_mean=(self.position, positions.keys()),
|
||||
)
|
||||
|
||||
@docs("mark")
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax ExtScaleMarks")
|
||||
|
||||
|
||||
class ExtScaleMarks(AstNode):
|
||||
grammar = [
|
||||
|
|
@ -127,10 +123,6 @@ class ExtScaleMarks(AstNode):
|
|||
def unique_in_parent(self):
|
||||
self.validate_unique_in_parent("Duplicate 'marks' block")
|
||||
|
||||
@docs("marks")
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax ExtScaleMarks")
|
||||
|
||||
|
||||
@completer(
|
||||
applies_in=[ObjectContent],
|
||||
|
|
|
|||
|
|
@ -39,12 +39,6 @@ class Widget(AstNode):
|
|||
self.group.tokens["name"].range,
|
||||
)
|
||||
|
||||
def get_reference(self, _idx: int) -> T.Optional[LocationLink]:
|
||||
if obj := self.context[ScopeCtx].objects.get(self.name):
|
||||
return LocationLink(self.range, obj.range, obj.ranges["id"])
|
||||
else:
|
||||
return None
|
||||
|
||||
@validate("name")
|
||||
def obj_widget(self):
|
||||
object = self.context[ScopeCtx].objects.get(self.tokens["name"])
|
||||
|
|
@ -94,10 +88,6 @@ class ExtSizeGroupWidgets(AstNode):
|
|||
def unique_in_parent(self):
|
||||
self.validate_unique_in_parent("Duplicate widgets block")
|
||||
|
||||
@docs("widgets")
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax ExtSizeGroupWidgets")
|
||||
|
||||
|
||||
@completer(
|
||||
applies_in=[ObjectContent],
|
||||
|
|
@ -106,13 +96,3 @@ class ExtSizeGroupWidgets(AstNode):
|
|||
)
|
||||
def size_group_completer(lsp, ast_node, match_variables):
|
||||
yield Completion("widgets", CompletionItemKind.Snippet, snippet="widgets [$0]")
|
||||
|
||||
|
||||
@decompiler("widgets")
|
||||
def size_group_decompiler(ctx, gir: gir.GirContext):
|
||||
ctx.print("widgets [")
|
||||
|
||||
|
||||
@decompiler("widget")
|
||||
def widget_decompiler(ctx, gir: gir.GirContext, name: str):
|
||||
ctx.print(name + ",")
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@ class ExtStringListStrings(AstNode):
|
|||
self.group.tokens["strings"].range,
|
||||
)
|
||||
|
||||
@validate("strings")
|
||||
@validate("items")
|
||||
def container_is_string_list(self):
|
||||
validate_parent_type(self, "Gtk", "StringList", "StringList items")
|
||||
|
||||
|
|
@ -65,10 +65,6 @@ class ExtStringListStrings(AstNode):
|
|||
def unique_in_parent(self):
|
||||
self.validate_unique_in_parent("Duplicate strings block")
|
||||
|
||||
@docs("strings")
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax ExtStringListStrings")
|
||||
|
||||
|
||||
@completer(
|
||||
applies_in=[ObjectContent],
|
||||
|
|
@ -77,25 +73,3 @@ class ExtStringListStrings(AstNode):
|
|||
)
|
||||
def strings_completer(lsp, ast_node, match_variables):
|
||||
yield Completion("strings", CompletionItemKind.Snippet, snippet="strings [$0]")
|
||||
|
||||
|
||||
@decompiler("items", parent_type="Gtk.StringList")
|
||||
def decompile_strings(ctx: DecompileCtx, gir: gir.GirContext):
|
||||
ctx.print("strings [")
|
||||
|
||||
|
||||
@decompiler("item", cdata=True, parent_type="Gtk.StringList")
|
||||
def decompile_item(
|
||||
ctx: DecompileCtx,
|
||||
gir: gir.GirContext,
|
||||
translatable="false",
|
||||
comments=None,
|
||||
context=None,
|
||||
cdata=None,
|
||||
):
|
||||
comments, translatable = decompile_translatable(
|
||||
cdata, translatable, context, comments
|
||||
)
|
||||
if comments is not None:
|
||||
ctx.print(comments)
|
||||
ctx.print(translatable + ",")
|
||||
|
|
|
|||
|
|
@ -70,10 +70,6 @@ class ExtStyles(AstNode):
|
|||
def unique_in_parent(self):
|
||||
self.validate_unique_in_parent("Duplicate styles block")
|
||||
|
||||
@docs("styles")
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax ExtStyles")
|
||||
|
||||
|
||||
@completer(
|
||||
applies_in=[ObjectContent],
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ from functools import cached_property
|
|||
|
||||
from .common import *
|
||||
from .gobject_object import Object
|
||||
from .response_id import ExtResponse, decompile_response_type
|
||||
from .response_id import ExtResponse
|
||||
|
||||
ALLOWED_PARENTS: T.List[T.Tuple[str, str]] = [
|
||||
("Gtk", "Buildable"),
|
||||
|
|
@ -53,10 +53,6 @@ class ChildExtension(AstNode):
|
|||
def child(self) -> ExtResponse:
|
||||
return self.children[0]
|
||||
|
||||
@docs()
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax ChildExtension")
|
||||
|
||||
|
||||
class ChildAnnotation(AstNode):
|
||||
grammar = ["[", AnyOf(ChildInternal, ChildExtension, ChildType), "]"]
|
||||
|
|
@ -131,15 +127,10 @@ class Child(AstNode):
|
|||
)
|
||||
|
||||
|
||||
@decompiler("child", element=True)
|
||||
def decompile_child(ctx, gir, element):
|
||||
if type := element["type"]:
|
||||
if type == "action":
|
||||
if decompiled := decompile_response_type(ctx.parent_node, element):
|
||||
ctx.print(decompiled)
|
||||
return
|
||||
|
||||
@decompiler("child")
|
||||
def decompile_child(ctx, gir, type=None, internal_child=None):
|
||||
if type is not None:
|
||||
ctx.print(f"[{type}]")
|
||||
elif internal_child := element["internal-child"]:
|
||||
elif internal_child is not None:
|
||||
ctx.print(f"[internal-child {internal_child}]")
|
||||
return gir
|
||||
|
|
|
|||
|
|
@ -88,10 +88,6 @@ class Template(Object):
|
|||
f"Only one template may be defined per file, but this file contains {len(self.parent.children[Template])}",
|
||||
)
|
||||
|
||||
@docs("id")
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax Template")
|
||||
|
||||
|
||||
@decompiler("template")
|
||||
def decompile_template(ctx: DecompileCtx, gir, klass, parent=None):
|
||||
|
|
@ -101,9 +97,8 @@ def decompile_template(ctx: DecompileCtx, gir, klass, parent=None):
|
|||
else:
|
||||
return "$" + cname
|
||||
|
||||
if parent is None:
|
||||
ctx.print(f"template {class_name(klass)} {{")
|
||||
else:
|
||||
ctx.print(f"template {class_name(klass)} : {class_name(parent)} {{")
|
||||
ctx.print(f"template {class_name(klass)} : {class_name(parent)} {{")
|
||||
|
||||
ctx.template_class = klass
|
||||
|
||||
return ctx.type_by_cname(klass) or ctx.type_by_cname(parent)
|
||||
|
|
|
|||
|
|
@ -59,12 +59,14 @@ class GtkDirective(AstNode):
|
|||
|
||||
@property
|
||||
def gir_namespace(self):
|
||||
# For better error handling, just assume it's 4.0
|
||||
return gir.get_namespace("Gtk", "4.0")
|
||||
|
||||
@docs()
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax GtkDecl")
|
||||
# validate the GTK version first to make sure the more specific error
|
||||
# message is emitted
|
||||
self.gtk_version()
|
||||
if self.tokens["version"] is not None:
|
||||
return gir.get_namespace("Gtk", self.tokens["version"])
|
||||
else:
|
||||
# For better error handling, just assume it's 4.0
|
||||
return gir.get_namespace("Gtk", "4.0")
|
||||
|
||||
|
||||
class Import(AstNode):
|
||||
|
|
@ -84,26 +86,11 @@ class Import(AstNode):
|
|||
|
||||
@validate("namespace", "version")
|
||||
def namespace_exists(self):
|
||||
gir.get_namespace(self.namespace, self.version)
|
||||
|
||||
@validate()
|
||||
def unused(self):
|
||||
if self.namespace not in self.root.used_imports:
|
||||
raise UnusedWarning(
|
||||
f"Unused import: {self.namespace}",
|
||||
self.range,
|
||||
actions=[
|
||||
CodeAction("Remove import", "", self.range.with_trailing_newline)
|
||||
],
|
||||
)
|
||||
gir.get_namespace(self.tokens["namespace"], self.tokens["version"])
|
||||
|
||||
@property
|
||||
def gir_namespace(self):
|
||||
try:
|
||||
return gir.get_namespace(self.namespace, self.version)
|
||||
return gir.get_namespace(self.tokens["namespace"], self.tokens["version"])
|
||||
except CompileError:
|
||||
return None
|
||||
|
||||
@docs()
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax Using")
|
||||
|
|
|
|||
|
|
@ -123,42 +123,3 @@ class ExtResponse(AstNode):
|
|||
|
||||
object = self.parent_by_type(Child).object
|
||||
return object.id
|
||||
|
||||
@docs()
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax ExtResponse")
|
||||
|
||||
@docs("response_id")
|
||||
def response_id_docs(self):
|
||||
if enum := self.root.gir.get_type("ResponseType", "Gtk"):
|
||||
if member := enum.members.get(self.response_id, None):
|
||||
return member.doc
|
||||
|
||||
|
||||
def decompile_response_type(parent_element, child_element):
|
||||
obj_id = None
|
||||
for obj in child_element.children:
|
||||
if obj.tag == "object":
|
||||
obj_id = obj["id"]
|
||||
break
|
||||
|
||||
if obj_id is None:
|
||||
return None
|
||||
|
||||
for child in parent_element.children:
|
||||
if child.tag == "action-widgets":
|
||||
for action_widget in child.children:
|
||||
if action_widget.cdata == obj_id:
|
||||
response_id = action_widget["response"]
|
||||
is_default = (
|
||||
" default" if decompile.truthy(action_widget["default"]) else ""
|
||||
)
|
||||
return f"[action response={response_id}{is_default}]"
|
||||
|
||||
return None
|
||||
|
||||
|
||||
@decompiler("action-widgets", skip_children=True)
|
||||
def decompile_action_widgets(ctx, gir):
|
||||
# This is handled in the <child> decompiler and decompile_response_type above
|
||||
pass
|
||||
|
|
|
|||
|
|
@ -29,7 +29,3 @@ class TranslationDomain(AstNode):
|
|||
@property
|
||||
def domain(self):
|
||||
return self.tokens["domain"]
|
||||
|
||||
@docs()
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax TranslationDomain")
|
||||
|
|
|
|||
|
|
@ -78,10 +78,9 @@ class TypeName(AstNode):
|
|||
)
|
||||
|
||||
@property
|
||||
def gir_ns(self) -> T.Optional[gir.Namespace]:
|
||||
def gir_ns(self):
|
||||
if not self.tokens["extern"]:
|
||||
return self.root.gir.namespaces.get(self.tokens["namespace"] or "Gtk")
|
||||
return None
|
||||
|
||||
@property
|
||||
def gir_type(self) -> gir.GirType:
|
||||
|
|
|
|||
|
|
@ -27,7 +27,6 @@ from .gtk_menu import Menu, menu
|
|||
from .gtkbuilder_template import Template
|
||||
from .imports import GtkDirective, Import
|
||||
from .translation_domain import TranslationDomain
|
||||
from .types import TypeName
|
||||
|
||||
|
||||
class UI(AstNode):
|
||||
|
|
@ -122,22 +121,6 @@ class UI(AstNode):
|
|||
Range(pos, pos, self.group.text),
|
||||
)
|
||||
|
||||
@cached_property
|
||||
def used_imports(self) -> T.Optional[T.Set[str]]:
|
||||
def _iter_recursive(node: AstNode):
|
||||
yield node
|
||||
for child in node.children:
|
||||
if isinstance(child, AstNode):
|
||||
yield from _iter_recursive(child)
|
||||
|
||||
result = set()
|
||||
for node in _iter_recursive(self):
|
||||
if isinstance(node, TypeName):
|
||||
ns = node.gir_ns
|
||||
if ns is not None:
|
||||
result.add(ns.name)
|
||||
return result
|
||||
|
||||
@context(ScopeCtx)
|
||||
def scope_ctx(self) -> ScopeCtx:
|
||||
return ScopeCtx(node=self)
|
||||
|
|
|
|||
|
|
@ -19,12 +19,8 @@
|
|||
|
||||
import typing as T
|
||||
|
||||
from blueprintcompiler.gir import ArrayType
|
||||
from blueprintcompiler.lsp_utils import SemanticToken
|
||||
|
||||
from .common import *
|
||||
from .contexts import ExprValueCtx, ScopeCtx, ValueTypeCtx
|
||||
from .expression import Expression
|
||||
from .contexts import ScopeCtx, ValueTypeCtx
|
||||
from .gobject_object import Object
|
||||
from .types import TypeName
|
||||
|
||||
|
|
@ -58,23 +54,6 @@ class Translated(AstNode):
|
|||
f"Cannot convert translated string to {expected_type.full_name}"
|
||||
)
|
||||
|
||||
@validate("context")
|
||||
def context_double_quoted(self):
|
||||
if self.translate_context is None:
|
||||
return
|
||||
|
||||
if not str(self.group.tokens["context"]).startswith('"'):
|
||||
raise CompileWarning("gettext may not recognize single-quoted strings")
|
||||
|
||||
@validate("string")
|
||||
def string_double_quoted(self):
|
||||
if not str(self.group.tokens["string"]).startswith('"'):
|
||||
raise CompileWarning("gettext may not recognize single-quoted strings")
|
||||
|
||||
@docs()
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax Translated")
|
||||
|
||||
|
||||
class TypeLiteral(AstNode):
|
||||
grammar = [
|
||||
|
|
@ -120,10 +99,6 @@ class TypeLiteral(AstNode):
|
|||
],
|
||||
)
|
||||
|
||||
@docs()
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax TypeLiteral")
|
||||
|
||||
|
||||
class QuotedLiteral(AstNode):
|
||||
grammar = UseQuoted("value")
|
||||
|
|
@ -225,22 +200,15 @@ class Flag(AstNode):
|
|||
return self.tokens["value"]
|
||||
|
||||
@property
|
||||
def value(self) -> T.Optional[str]:
|
||||
def value(self) -> T.Optional[int]:
|
||||
type = self.context[ValueTypeCtx].value_type
|
||||
if not isinstance(type, Enumeration):
|
||||
return None
|
||||
elif member := type.members.get(self.name):
|
||||
return member.nick
|
||||
return member.value
|
||||
else:
|
||||
return None
|
||||
|
||||
def get_semantic_tokens(self) -> T.Iterator[SemanticToken]:
|
||||
yield SemanticToken(
|
||||
self.group.tokens["value"].start,
|
||||
self.group.tokens["value"].end,
|
||||
SemanticTokenType.EnumMember,
|
||||
)
|
||||
|
||||
@docs()
|
||||
def docs(self):
|
||||
type = self.context[ValueTypeCtx].value_type
|
||||
|
|
@ -281,10 +249,6 @@ class Flags(AstNode):
|
|||
if expected_type is not None and not isinstance(expected_type, gir.Bitfield):
|
||||
raise CompileError(f"{expected_type.full_name} is not a bitfield type")
|
||||
|
||||
@docs()
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax Flags")
|
||||
|
||||
|
||||
class IdentLiteral(AstNode):
|
||||
grammar = UseIdent("value")
|
||||
|
|
@ -333,12 +297,7 @@ class IdentLiteral(AstNode):
|
|||
if self.ident == "null":
|
||||
if not self.context[ValueTypeCtx].allow_null:
|
||||
raise CompileError("null is not permitted here")
|
||||
elif self.ident == "item":
|
||||
if not self.context[ExprValueCtx]:
|
||||
raise CompileError(
|
||||
'"item" can only be used in an expression literal'
|
||||
)
|
||||
elif self.ident not in ["true", "false"]:
|
||||
else:
|
||||
raise CompileError(
|
||||
f"Could not find object with ID {self.ident}",
|
||||
did_you_mean=(
|
||||
|
|
@ -426,35 +385,6 @@ class ObjectValue(AstNode):
|
|||
)
|
||||
|
||||
|
||||
class ExprValue(AstNode):
|
||||
grammar = [Keyword("expr"), Expression]
|
||||
|
||||
@property
|
||||
def expression(self) -> Expression:
|
||||
return self.children[Expression][0]
|
||||
|
||||
@validate("expr")
|
||||
def validate_for_type(self) -> None:
|
||||
expected_type = self.parent.context[ValueTypeCtx].value_type
|
||||
expr_type = self.root.gir.get_type("Expression", "Gtk")
|
||||
if expected_type is not None and not expected_type.assignable_to(expr_type):
|
||||
raise CompileError(
|
||||
f"Cannot convert Gtk.Expression to {expected_type.full_name}"
|
||||
)
|
||||
|
||||
@docs("expr")
|
||||
def ref_docs(self):
|
||||
return get_docs_section("Syntax ExprValue")
|
||||
|
||||
@context(ExprValueCtx)
|
||||
def expr_literal(self):
|
||||
return ExprValueCtx()
|
||||
|
||||
@context(ValueTypeCtx)
|
||||
def value_type(self):
|
||||
return ValueTypeCtx(None, must_infer_type=True)
|
||||
|
||||
|
||||
class Value(AstNode):
|
||||
grammar = AnyOf(Translated, Flags, Literal)
|
||||
|
||||
|
|
@ -465,68 +395,6 @@ class Value(AstNode):
|
|||
return self.children[0]
|
||||
|
||||
|
||||
class ArrayValue(AstNode):
|
||||
grammar = ["[", Delimited(Value, ","), "]"]
|
||||
|
||||
@validate()
|
||||
def validate_for_type(self) -> None:
|
||||
expected_type = self.gir_type
|
||||
if expected_type is not None and not isinstance(expected_type, gir.ArrayType):
|
||||
raise CompileError(f"Cannot assign array to {expected_type.full_name}")
|
||||
|
||||
if expected_type is not None and not isinstance(
|
||||
expected_type.inner, StringType
|
||||
):
|
||||
raise CompileError("Only string arrays are supported")
|
||||
|
||||
@validate()
|
||||
def validate_invalid_newline(self) -> None:
|
||||
expected_type = self.gir_type
|
||||
if isinstance(expected_type, gir.ArrayType) and isinstance(
|
||||
expected_type.inner, StringType
|
||||
):
|
||||
errors = []
|
||||
for value in self.values:
|
||||
if isinstance(value.child, Literal) and isinstance(
|
||||
value.child.value, QuotedLiteral
|
||||
):
|
||||
quoted_literal = value.child.value
|
||||
literal_value = quoted_literal.value
|
||||
# literal_value can be None if there's an invalid escape sequence
|
||||
if literal_value is not None and "\n" in literal_value:
|
||||
errors.append(
|
||||
CompileError(
|
||||
"String literals inside arrays can't contain newlines",
|
||||
range=quoted_literal.range,
|
||||
)
|
||||
)
|
||||
elif isinstance(value.child, Translated):
|
||||
errors.append(
|
||||
CompileError(
|
||||
"Arrays can't contain translated strings",
|
||||
range=value.child.range,
|
||||
)
|
||||
)
|
||||
|
||||
if len(errors) > 0:
|
||||
raise MultipleErrors(errors)
|
||||
|
||||
@property
|
||||
def values(self) -> T.List[Value]:
|
||||
return self.children
|
||||
|
||||
@property
|
||||
def gir_type(self):
|
||||
return self.parent.context[ValueTypeCtx].value_type
|
||||
|
||||
@context(ValueTypeCtx)
|
||||
def child_value(self):
|
||||
if self.gir_type is None or not isinstance(self.gir_type, ArrayType):
|
||||
return ValueTypeCtx(None)
|
||||
else:
|
||||
return ValueTypeCtx(self.gir_type.inner)
|
||||
|
||||
|
||||
class StringValue(AstNode):
|
||||
grammar = AnyOf(Translated, QuotedLiteral)
|
||||
|
||||
|
|
|
|||
|
|
@ -102,10 +102,10 @@ class OpenFile:
|
|||
]
|
||||
|
||||
# convert line, column numbers to deltas
|
||||
for a, b in zip(token_lists[-2::-1], token_lists[:0:-1]):
|
||||
b[0] -= a[0]
|
||||
if b[0] == 0:
|
||||
b[1] -= a[1]
|
||||
for i, token_list in enumerate(token_lists[1:]):
|
||||
token_list[0] -= token_lists[i][0]
|
||||
if token_list[0] == 0:
|
||||
token_list[1] -= token_lists[i][1]
|
||||
|
||||
# flatten the list
|
||||
return [x for y in token_lists for x in y]
|
||||
|
|
@ -118,7 +118,6 @@ class LanguageServer:
|
|||
self.client_capabilities = {}
|
||||
self.client_supports_completion_choice = False
|
||||
self._open_files: T.Dict[str, OpenFile] = {}
|
||||
self._exited = False
|
||||
|
||||
def run(self):
|
||||
# Read <doc> tags from gir files. During normal compilation these are
|
||||
|
|
@ -126,7 +125,7 @@ class LanguageServer:
|
|||
xml_reader.PARSE_GIR.add("doc")
|
||||
|
||||
try:
|
||||
while not self._exited:
|
||||
while True:
|
||||
line = ""
|
||||
content_len = -1
|
||||
while content_len == -1 or (line != "\n" and line != "\r\n"):
|
||||
|
|
@ -150,7 +149,7 @@ class LanguageServer:
|
|||
|
||||
def _send(self, data):
|
||||
data["jsonrpc"] = "2.0"
|
||||
line = json.dumps(data, separators=(",", ":"))
|
||||
line = json.dumps(data, separators=(",", ":")) + "\r\n"
|
||||
printerr("output: " + line)
|
||||
sys.stdout.write(
|
||||
f"Content-Length: {len(line.encode())}\r\nContent-Type: application/vscode-jsonrpc; charset=utf-8\r\n\r\n{line}"
|
||||
|
|
@ -222,14 +221,6 @@ class LanguageServer:
|
|||
},
|
||||
)
|
||||
|
||||
@command("shutdown")
|
||||
def shutdown(self, id, params):
|
||||
self._send_response(id, None)
|
||||
|
||||
@command("exit")
|
||||
def exit(self, id, params):
|
||||
self._exited = True
|
||||
|
||||
@command("textDocument/didOpen")
|
||||
def didOpen(self, id, params):
|
||||
doc = params.get("textDocument")
|
||||
|
|
@ -481,12 +472,9 @@ class LanguageServer:
|
|||
),
|
||||
}
|
||||
|
||||
if isinstance(err, DeprecatedWarning):
|
||||
if isinstance(err, DeprecationWarning):
|
||||
result["tags"] = [DiagnosticTag.Deprecated]
|
||||
|
||||
if isinstance(err, UnusedWarning):
|
||||
result["tags"] = [DiagnosticTag.Unnecessary]
|
||||
|
||||
if len(err.references) > 0:
|
||||
result["relatedInformation"] = [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -19,8 +19,6 @@
|
|||
|
||||
|
||||
import enum
|
||||
import json
|
||||
import os
|
||||
import typing as T
|
||||
from dataclasses import dataclass, field
|
||||
|
||||
|
|
@ -86,7 +84,6 @@ class Completion:
|
|||
docs: T.Optional[str] = None
|
||||
text: T.Optional[str] = None
|
||||
snippet: T.Optional[str] = None
|
||||
detail: T.Optional[str] = None
|
||||
|
||||
def to_json(self, snippets: bool):
|
||||
insert_text = self.text or self.label
|
||||
|
|
@ -99,8 +96,7 @@ class Completion:
|
|||
"label": self.label,
|
||||
"kind": self.kind,
|
||||
"tags": [CompletionItemTag.Deprecated] if self.deprecated else None,
|
||||
# https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#completionItemLabelDetails
|
||||
"labelDetails": ({"detail": self.signature} if self.signature else None),
|
||||
"detail": self.signature,
|
||||
"documentation": (
|
||||
{
|
||||
"kind": "markdown",
|
||||
|
|
@ -113,7 +109,6 @@ class Completion:
|
|||
"sortText": self.sort_text,
|
||||
"insertText": insert_text,
|
||||
"insertTextFormat": insert_text_format,
|
||||
"detail": self.detail if self.detail else None,
|
||||
}
|
||||
return {k: v for k, v in result.items() if v is not None}
|
||||
|
||||
|
|
@ -202,27 +197,3 @@ class TextEdit:
|
|||
|
||||
def to_json(self):
|
||||
return {"range": self.range.to_json(), "newText": self.newText}
|
||||
|
||||
|
||||
_docs_sections: T.Optional[dict[str, T.Any]] = None
|
||||
|
||||
|
||||
def get_docs_section(section_name: str) -> T.Optional[str]:
|
||||
global _docs_sections
|
||||
|
||||
if _docs_sections is None:
|
||||
try:
|
||||
with open(
|
||||
os.path.join(os.path.dirname(__file__), "reference_docs.json")
|
||||
) as f:
|
||||
_docs_sections = json.load(f)
|
||||
except FileNotFoundError:
|
||||
_docs_sections = {}
|
||||
|
||||
if section := _docs_sections.get(section_name):
|
||||
content = section["content"]
|
||||
link = section["link"]
|
||||
content += f"\n\n---\n\n[Online documentation]({link})"
|
||||
return content
|
||||
else:
|
||||
return None
|
||||
|
|
|
|||
|
|
@ -25,7 +25,6 @@ import sys
|
|||
import typing as T
|
||||
|
||||
from . import formatter, interactive_port, parser, tokenizer
|
||||
from .decompiler import decompile_string
|
||||
from .errors import CompileError, CompilerBugError, PrintableError, report_bug
|
||||
from .gir import add_typelib_search_path
|
||||
from .lsp import LanguageServer
|
||||
|
|
@ -91,28 +90,12 @@ class BlueprintApp:
|
|||
default=2,
|
||||
type=int,
|
||||
)
|
||||
format.add_argument(
|
||||
"-n",
|
||||
"--no-diff",
|
||||
help="Do not print a full diff of the changes",
|
||||
default=False,
|
||||
action="store_true",
|
||||
)
|
||||
format.add_argument(
|
||||
"inputs",
|
||||
nargs="+",
|
||||
metavar="filenames",
|
||||
)
|
||||
|
||||
decompile = self.add_subcommand(
|
||||
"decompile", "Convert .ui XML files to blueprint", self.cmd_decompile
|
||||
)
|
||||
decompile.add_argument("--output", dest="output", default="-")
|
||||
decompile.add_argument("--typelib-path", nargs="?", action="append")
|
||||
decompile.add_argument(
|
||||
"input", metavar="filename", default=sys.stdin, type=argparse.FileType("r")
|
||||
)
|
||||
|
||||
port = self.add_subcommand("port", "Interactive porting tool", self.cmd_port)
|
||||
|
||||
lsp = self.add_subcommand(
|
||||
|
|
@ -238,25 +221,23 @@ class BlueprintApp:
|
|||
file.write(formatted_str)
|
||||
happened = "Formatted"
|
||||
|
||||
if not opts.no_diff:
|
||||
diff_lines = []
|
||||
a_lines = data.splitlines(keepends=True)
|
||||
b_lines = formatted_str.splitlines(keepends=True)
|
||||
diff_lines = []
|
||||
a_lines = data.splitlines(keepends=True)
|
||||
b_lines = formatted_str.splitlines(keepends=True)
|
||||
|
||||
for line in difflib.unified_diff(
|
||||
a_lines, b_lines, fromfile=file.name, tofile=file.name, n=5
|
||||
):
|
||||
# Work around https://bugs.python.org/issue2142
|
||||
# See:
|
||||
# https://www.gnu.org/software/diffutils/manual/html_node/Incomplete-Lines.html
|
||||
if line[-1] == "\n":
|
||||
diff_lines.append(line)
|
||||
else:
|
||||
diff_lines.append(line + "\n")
|
||||
diff_lines.append("\\ No newline at end of file\n")
|
||||
|
||||
print("".join(diff_lines))
|
||||
for line in difflib.unified_diff(
|
||||
a_lines, b_lines, fromfile=file.name, tofile=file.name, n=5
|
||||
):
|
||||
# Work around https://bugs.python.org/issue2142
|
||||
# See:
|
||||
# https://www.gnu.org/software/diffutils/manual/html_node/Incomplete-Lines.html
|
||||
if line[-1] == "\n":
|
||||
diff_lines.append(line)
|
||||
else:
|
||||
diff_lines.append(line + "\n")
|
||||
diff_lines.append("\\ No newline at end of file\n")
|
||||
|
||||
print("".join(diff_lines))
|
||||
to_print = Colors.BOLD
|
||||
if errored:
|
||||
to_print += f"{Colors.RED}Skipped {file.name}: Will not overwrite file with compile errors"
|
||||
|
|
@ -310,24 +291,6 @@ class BlueprintApp:
|
|||
if panic:
|
||||
sys.exit(1)
|
||||
|
||||
def cmd_decompile(self, opts):
|
||||
if opts.typelib_path != None:
|
||||
for typelib_path in opts.typelib_path:
|
||||
add_typelib_search_path(typelib_path)
|
||||
|
||||
data = opts.input.read()
|
||||
try:
|
||||
decompiled = decompile_string(data)
|
||||
|
||||
if opts.output == "-":
|
||||
print(decompiled)
|
||||
else:
|
||||
with open(opts.output, "w") as file:
|
||||
file.write(decompiled)
|
||||
except PrintableError as e:
|
||||
e.pretty_print(opts.input.name, data, stream=sys.stderr)
|
||||
sys.exit(1)
|
||||
|
||||
def cmd_lsp(self, opts):
|
||||
langserv = LanguageServer()
|
||||
langserv.run()
|
||||
|
|
|
|||
|
|
@ -134,25 +134,11 @@ class XmlOutput(OutputFormat):
|
|||
self._emit_expression(value.expression, xml)
|
||||
xml.end_tag()
|
||||
|
||||
elif isinstance(value, ExprValue):
|
||||
xml.start_tag("property", **props)
|
||||
self._emit_expression(value.expression, xml)
|
||||
xml.end_tag()
|
||||
|
||||
elif isinstance(value, ObjectValue):
|
||||
xml.start_tag("property", **props)
|
||||
self._emit_object(value.object, xml)
|
||||
xml.end_tag()
|
||||
|
||||
elif isinstance(value, ArrayValue):
|
||||
xml.start_tag("property", **props)
|
||||
values = list(value.values)
|
||||
for value in values[:-1]:
|
||||
self._emit_value(value, xml)
|
||||
xml.put_text("\n")
|
||||
self._emit_value(values[-1], xml)
|
||||
xml.end_tag()
|
||||
|
||||
else:
|
||||
raise CompilerBugError()
|
||||
|
||||
|
|
@ -164,7 +150,7 @@ class XmlOutput(OutputFormat):
|
|||
elif isinstance(translated, QuotedLiteral):
|
||||
return {}
|
||||
else:
|
||||
return {"translatable": "yes", "context": translated.translate_context}
|
||||
return {"translatable": "true", "context": translated.translate_context}
|
||||
|
||||
def _emit_signal(self, signal: Signal, xml: XmlEmitter):
|
||||
name = signal.name
|
||||
|
|
@ -174,8 +160,7 @@ class XmlOutput(OutputFormat):
|
|||
"signal",
|
||||
name=name,
|
||||
handler=signal.handler,
|
||||
swapped=signal.is_swapped,
|
||||
after=signal.is_after or None,
|
||||
swapped=signal.is_swapped or None,
|
||||
object=(
|
||||
self._object_id(signal, signal.object_id) if signal.object_id else None
|
||||
),
|
||||
|
|
@ -223,6 +208,12 @@ class XmlOutput(OutputFormat):
|
|||
xml.put_text(
|
||||
"|".join([str(flag.value or flag.name) for flag in value.child.flags])
|
||||
)
|
||||
elif isinstance(value.child, Translated):
|
||||
raise CompilerBugError("translated values must be handled in the parent")
|
||||
elif isinstance(value.child, TypeLiteral):
|
||||
xml.put_text(value.child.type_name.glib_type_name)
|
||||
elif isinstance(value.child, ObjectValue):
|
||||
self._emit_object(value.child.object, xml)
|
||||
else:
|
||||
raise CompilerBugError()
|
||||
|
||||
|
|
@ -244,9 +235,6 @@ class XmlOutput(OutputFormat):
|
|||
raise CompilerBugError()
|
||||
|
||||
def _emit_literal_expr(self, expr: LiteralExpr, xml: XmlEmitter):
|
||||
if expr.is_this:
|
||||
return
|
||||
|
||||
if expr.is_object:
|
||||
xml.start_tag("constant")
|
||||
else:
|
||||
|
|
@ -294,11 +282,8 @@ class XmlOutput(OutputFormat):
|
|||
def _emit_extensions(self, extension, xml: XmlEmitter):
|
||||
if isinstance(extension, ExtAccessibility):
|
||||
xml.start_tag("accessibility")
|
||||
for property in extension.properties:
|
||||
for val in property.values:
|
||||
self._emit_attribute(
|
||||
property.tag_name, "name", property.name, val, xml
|
||||
)
|
||||
for prop in extension.properties:
|
||||
self._emit_attribute(prop.tag_name, "name", prop.name, prop.value, xml)
|
||||
xml.end_tag()
|
||||
|
||||
elif isinstance(extension, AdwBreakpointCondition):
|
||||
|
|
@ -308,9 +293,6 @@ class XmlOutput(OutputFormat):
|
|||
|
||||
elif isinstance(extension, AdwBreakpointSetters):
|
||||
for setter in extension.setters:
|
||||
if setter.value is None:
|
||||
continue
|
||||
|
||||
attrs = {}
|
||||
|
||||
if isinstance(setter.value.child, Translated):
|
||||
|
|
@ -371,13 +353,12 @@ class XmlOutput(OutputFormat):
|
|||
|
||||
elif isinstance(extension, ExtScaleMarks):
|
||||
xml.start_tag("marks")
|
||||
for mark in extension.marks:
|
||||
label = mark.label.child if mark.label is not None else None
|
||||
for mark in extension.children:
|
||||
xml.start_tag(
|
||||
"mark",
|
||||
value=mark.value,
|
||||
position=mark.position,
|
||||
**self._translated_string_attrs(label),
|
||||
**self._translated_string_attrs(mark.label and mark.label.child),
|
||||
)
|
||||
if mark.label is not None:
|
||||
xml.put_text(mark.label.string)
|
||||
|
|
@ -394,9 +375,9 @@ class XmlOutput(OutputFormat):
|
|||
xml.end_tag()
|
||||
|
||||
elif isinstance(extension, ExtListItemFactory):
|
||||
child_xml = XmlEmitter(generated_notice=False)
|
||||
child_xml = XmlEmitter()
|
||||
child_xml.start_tag("interface")
|
||||
child_xml.start_tag("template", **{"class": extension.gir_class})
|
||||
child_xml.start_tag("template", **{"class": "GtkListItem"})
|
||||
self._emit_object_or_template(extension, child_xml)
|
||||
child_xml.end_tag()
|
||||
child_xml.end_tag()
|
||||
|
|
|
|||
|
|
@ -40,9 +40,7 @@ class XmlEmitter:
|
|||
self._tag_stack = []
|
||||
self._needs_newline = False
|
||||
|
||||
def start_tag(
|
||||
self, tag, **attrs: T.Union[str, GirType, ClassName, bool, None, float]
|
||||
):
|
||||
def start_tag(self, tag, **attrs: T.Union[str, GirType, ClassName, bool, None]):
|
||||
self._indent()
|
||||
self.result += f"<{tag}"
|
||||
for key, val in attrs.items():
|
||||
|
|
@ -73,7 +71,6 @@ class XmlEmitter:
|
|||
self._needs_newline = False
|
||||
|
||||
def put_cdata(self, text: str):
|
||||
text = text.replace("]]>", "]]]]><![CDATA[>")
|
||||
self.result += f"<![CDATA[{text}]]>"
|
||||
self._needs_newline = False
|
||||
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@
|
|||
#
|
||||
# SPDX-License-Identifier: LGPL-3.0-or-later
|
||||
|
||||
"""Utilities for parsing an AST from a token stream."""
|
||||
""" Utilities for parsing an AST from a token stream. """
|
||||
|
||||
import typing as T
|
||||
from enum import Enum
|
||||
|
|
@ -95,11 +95,19 @@ class ParseGroup:
|
|||
|
||||
try:
|
||||
return self.ast_type(self, children, self.keys, incomplete=self.incomplete)
|
||||
except TypeError: # pragma: no cover
|
||||
except TypeError as e:
|
||||
raise CompilerBugError(
|
||||
f"Failed to construct ast.{self.ast_type.__name__} from ParseGroup. See the previous stacktrace."
|
||||
)
|
||||
|
||||
def __str__(self):
|
||||
result = str(self.ast_type.__name__)
|
||||
result += "".join([f"\n{key}: {val}" for key, val in self.keys.items()]) + "\n"
|
||||
result += "\n".join(
|
||||
[str(child) for children in self.children.values() for child in children]
|
||||
)
|
||||
return result.replace("\n", "\n ")
|
||||
|
||||
|
||||
class ParseContext:
|
||||
"""Contains the state of the parser."""
|
||||
|
|
@ -257,6 +265,10 @@ class ParseNode:
|
|||
"""Convenience method for err()."""
|
||||
return self.err("Expected " + expect)
|
||||
|
||||
def warn(self, message) -> "Warning":
|
||||
"""Causes this ParseNode to emit a warning if it parses successfully."""
|
||||
return Warning(self, message)
|
||||
|
||||
|
||||
class Err(ParseNode):
|
||||
"""ParseNode that emits a compile error if it fails to parse."""
|
||||
|
|
@ -278,6 +290,27 @@ class Err(ParseNode):
|
|||
return True
|
||||
|
||||
|
||||
class Warning(ParseNode):
|
||||
"""ParseNode that emits a compile warning if it parses successfully."""
|
||||
|
||||
def __init__(self, child, message: str):
|
||||
self.child = to_parse_node(child)
|
||||
self.message = message
|
||||
|
||||
def _parse(self, ctx: ParseContext):
|
||||
ctx.skip()
|
||||
start_idx = ctx.index
|
||||
if self.child.parse(ctx).succeeded():
|
||||
start_token = ctx.tokens[start_idx]
|
||||
end_token = ctx.tokens[ctx.index]
|
||||
ctx.warnings.append(
|
||||
CompileWarning(self.message, start_token.start, end_token.end)
|
||||
)
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
|
||||
|
||||
class Fail(ParseNode):
|
||||
"""ParseNode that emits a compile error if it parses successfully."""
|
||||
|
||||
|
|
|
|||
|
|
@ -33,9 +33,7 @@ def parse(
|
|||
original_text = tokens[0].string if len(tokens) else ""
|
||||
ctx = ParseContext(tokens, original_text)
|
||||
AnyOf(UI).parse(ctx)
|
||||
|
||||
assert ctx.last_group is not None
|
||||
ast_node = ctx.last_group.to_ast()
|
||||
ast_node = ctx.last_group.to_ast() if ctx.last_group else None
|
||||
|
||||
errors = [*ctx.errors, *ast_node.errors]
|
||||
warnings = [*ctx.warnings, *ast_node.warnings]
|
||||
|
|
|
|||
|
|
@ -127,13 +127,6 @@ class Range:
|
|||
def text(self) -> str:
|
||||
return self.original_text[self.start : self.end]
|
||||
|
||||
@property
|
||||
def with_trailing_newline(self) -> "Range":
|
||||
if len(self.original_text) > self.end and self.original_text[self.end] == "\n":
|
||||
return Range(self.start, self.end + 1, self.original_text)
|
||||
else:
|
||||
return self
|
||||
|
||||
@staticmethod
|
||||
def join(a: T.Optional["Range"], b: T.Optional["Range"]) -> T.Optional["Range"]:
|
||||
if a is None:
|
||||
|
|
|
|||
|
|
@ -148,8 +148,8 @@ class Typelib:
|
|||
SIGNATURE_ARGUMENTS = Field(0x8, "offset")
|
||||
|
||||
ATTR_OFFSET = Field(0x0, "u32")
|
||||
ATTR_NAME = Field(0x4, "string")
|
||||
ATTR_VALUE = Field(0x8, "string")
|
||||
ATTR_NAME = Field(0x0, "string")
|
||||
ATTR_VALUE = Field(0x0, "string")
|
||||
|
||||
TYPE_BLOB_TAG = Field(0x0, "u8", 3, 5)
|
||||
TYPE_BLOB_INTERFACE = Field(0x2, "dir_entry")
|
||||
|
|
|
|||
|
|
@ -109,14 +109,14 @@ class UnescapeError(Exception):
|
|||
|
||||
def escape_quote(string: str) -> str:
|
||||
return (
|
||||
'"'
|
||||
"'"
|
||||
+ (
|
||||
string.replace("\\", "\\\\")
|
||||
.replace('"', '\\"')
|
||||
.replace("'", "\\'")
|
||||
.replace("\n", "\\n")
|
||||
.replace("\t", "\\t")
|
||||
)
|
||||
+ '"'
|
||||
+ "'"
|
||||
)
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -7,8 +7,8 @@ git clone --depth=1 https://gitlab.gnome.org/GNOME/gtk.git
|
|||
cd gtk
|
||||
meson setup builddir \
|
||||
--prefix=/usr \
|
||||
-Ddocumentation=true \
|
||||
-Dbuild-demos=false \
|
||||
-Dgtk_doc=true \
|
||||
-Ddemos=false \
|
||||
-Dbuild-examples=false \
|
||||
-Dbuild-tests=false \
|
||||
-Dbuild-testsuite=false
|
||||
|
|
|
|||
|
|
@ -1,139 +0,0 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
from dataclasses import dataclass
|
||||
from pathlib import Path
|
||||
|
||||
__all__ = ["get_docs_section"]
|
||||
|
||||
DOCS_ROOT = "https://gnome.pages.gitlab.gnome.org/blueprint-compiler"
|
||||
|
||||
|
||||
sections: dict[str, "Section"] = {}
|
||||
|
||||
|
||||
@dataclass
|
||||
class Section:
|
||||
link: str
|
||||
lines: str
|
||||
|
||||
def to_json(self):
|
||||
return {
|
||||
"content": rst_to_md(self.lines),
|
||||
"link": self.link,
|
||||
}
|
||||
|
||||
|
||||
def load_reference_docs():
|
||||
for filename in Path(os.path.dirname(__file__), "reference").glob("*.rst"):
|
||||
with open(filename) as f:
|
||||
section_name = None
|
||||
lines = []
|
||||
|
||||
def close_section():
|
||||
if section_name:
|
||||
html_file = re.sub(r"\.rst$", ".html", filename.name)
|
||||
anchor = re.sub(r"[^a-z0-9]+", "-", section_name.lower())
|
||||
link = f"{DOCS_ROOT}/reference/{html_file}#{anchor}"
|
||||
sections[section_name] = Section(link, lines)
|
||||
|
||||
for line in f:
|
||||
if m := re.match(r"\.\.\s+_(.*):", line):
|
||||
close_section()
|
||||
section_name = m.group(1)
|
||||
lines = []
|
||||
else:
|
||||
lines.append(line)
|
||||
|
||||
close_section()
|
||||
|
||||
|
||||
# This isn't a comprehensive rST to markdown converter, it just needs to handle the
|
||||
# small subset of rST used in the reference docs.
|
||||
def rst_to_md(lines: list[str]) -> str:
|
||||
result = ""
|
||||
|
||||
def rst_to_md_inline(line):
|
||||
line = re.sub(r"``(.*?)``", r"`\1`", line)
|
||||
line = re.sub(
|
||||
r":ref:`(.*?)<(.*?)>`",
|
||||
lambda m: f"[{m.group(1)}]({sections[m.group(2)].link})",
|
||||
line,
|
||||
)
|
||||
line = re.sub(r"`([^`]*?) <([^`>]*?)>`_", r"[\1](\2)", line)
|
||||
return line
|
||||
|
||||
i = 0
|
||||
n = len(lines)
|
||||
heading_levels = {}
|
||||
|
||||
def print_block(lang: str = "", code: bool = True, strip_links: bool = False):
|
||||
nonlocal result, i
|
||||
block = ""
|
||||
while i < n:
|
||||
line = lines[i].rstrip()
|
||||
if line.startswith(" "):
|
||||
line = line[3:]
|
||||
elif line != "":
|
||||
break
|
||||
|
||||
if strip_links:
|
||||
line = re.sub(r":ref:`(.*?)<(.*?)>`", r"\1", line)
|
||||
|
||||
if not code:
|
||||
line = rst_to_md_inline(line)
|
||||
|
||||
block += line + "\n"
|
||||
i += 1
|
||||
|
||||
if code:
|
||||
result += f"```{lang}\n{block.strip()}\n```\n\n"
|
||||
else:
|
||||
result += block
|
||||
|
||||
while i < n:
|
||||
line = lines[i].rstrip()
|
||||
i += 1
|
||||
if line == ".. rst-class:: grammar-block":
|
||||
print_block("text", strip_links=True)
|
||||
elif line == ".. code-block:: blueprint":
|
||||
print_block("blueprint")
|
||||
elif line == ".. note::":
|
||||
result += "#### Note\n"
|
||||
print_block(code=False)
|
||||
elif m := re.match(r"\.\. image:: (.*)", line):
|
||||
result += f"})\n"
|
||||
elif i < n and re.match(r"^((-+)|(~+)|(\++))$", lines[i]):
|
||||
level_char = lines[i][0]
|
||||
if level_char not in heading_levels:
|
||||
heading_levels[level_char] = max(heading_levels.values(), default=1) + 1
|
||||
result += (
|
||||
"#" * heading_levels[level_char] + " " + rst_to_md_inline(line) + "\n"
|
||||
)
|
||||
i += 1
|
||||
else:
|
||||
result += rst_to_md_inline(line) + "\n"
|
||||
|
||||
return result
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
if len(sys.argv) != 2:
|
||||
print("Usage: collect_sections.py <output_file>")
|
||||
sys.exit(1)
|
||||
|
||||
outfile = sys.argv[1]
|
||||
|
||||
load_reference_docs()
|
||||
|
||||
# print the sections to a json file
|
||||
with open(outfile, "w") as f:
|
||||
json.dump(
|
||||
{name: section.to_json() for name, section in sections.items()},
|
||||
f,
|
||||
indent=2,
|
||||
sort_keys=True,
|
||||
)
|
||||
|
|
@ -16,8 +16,8 @@ a module in your flatpak manifest:
|
|||
"sources": [
|
||||
{
|
||||
"type": "git",
|
||||
"url": "https://gitlab.gnome.org/GNOME/blueprint-compiler",
|
||||
"tag": "v0.16.0"
|
||||
"url": "https://gitlab.gnome.org/jwestman/blueprint-compiler",
|
||||
"tag": "v0.12.0"
|
||||
}
|
||||
]
|
||||
}
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ Blueprint is a markup language and compiler for GTK 4 user interfaces.
|
|||
|
||||
using Gtk 4.0;
|
||||
|
||||
template $MyAppWindow: ApplicationWindow {
|
||||
template MyAppWindow : ApplicationWindow {
|
||||
default-width: 600;
|
||||
default-height: 300;
|
||||
title: _("Hello, Blueprint!");
|
||||
|
|
@ -35,7 +35,7 @@ Blueprint is a markup language and compiler for GTK 4 user interfaces.
|
|||
HeaderBar {}
|
||||
|
||||
Label {
|
||||
label: bind template.main_text;
|
||||
label: bind MyAppWindow.main_text;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -59,7 +59,7 @@ Features
|
|||
Links
|
||||
-----
|
||||
|
||||
- `Source code <https://gitlab.gnome.org/GNOME/blueprint-compiler>`_
|
||||
- `Source code <https://gitlab.gnome.org/jwestman/blueprint-compiler>`_
|
||||
- `Workbench <https://github.com/sonnyp/Workbench>`_ lets you try, preview and export Blueprint
|
||||
- `GNOME Builder <https://developer.gnome.org/documentation/introduction/builder.html>`_ provides builtin support
|
||||
- `Vim syntax highlighting plugin by thetek42 <https://github.com/thetek42/vim-blueprint-syntax>`_
|
||||
|
|
@ -82,12 +82,10 @@ Built with Blueprint
|
|||
- `Blurble <https://gitlab.gnome.org/World/Blurble>`_
|
||||
- `Bottles <https://github.com/bottlesdevs/Bottles>`_
|
||||
- `Cartridges <https://github.com/kra-mo/cartridges>`_
|
||||
- `Cassette <https://gitlab.gnome.org/Rirusha/Cassette>`_
|
||||
- `Cavalier <https://github.com/NickvisionApps/Cavalier>`_
|
||||
- `Chance <https://zelikos.dev/apps/rollit>`_
|
||||
- `Commit <https://github.com/sonnyp/Commit/>`_
|
||||
- `Confy <https://confy.kirgroup.net/>`_
|
||||
- `Cozy <https://github.com/geigi/cozy>`_
|
||||
- `Daikhan <https://github.com/flathub/io.gitlab.daikhan.stable>`_
|
||||
- `Damask <https://gitlab.gnome.org/subpop/damask>`_
|
||||
- `Denaro <https://github.com/NickvisionApps/Denaro>`_
|
||||
|
|
@ -95,7 +93,7 @@ Built with Blueprint
|
|||
- `Dev Toolbox <https://github.com/aleiepure/devtoolbox>`_
|
||||
- `Dialect <https://github.com/dialect-app/dialect>`_
|
||||
- `Diccionario de la Lengua <https://codeberg.org/rafaelmardojai/diccionario-lengua>`_
|
||||
- `Doggo <https://gitlab.gnome.org/sungsphinx/Doggo>`_
|
||||
- `Dogg <https://gitlab.gnome.org/sungsphinx/Doggo>`_
|
||||
- `Dosage <https://github.com/diegopvlk/Dosage>`_
|
||||
- `Dynamic Wallpaper <https://github.com/dusansimic/dynamic-wallpaper>`_
|
||||
- `Extension Manager <https://github.com/mjakeman/extension-manager>`_
|
||||
|
|
@ -117,10 +115,11 @@ Built with Blueprint
|
|||
- `Identity <https://gitlab.gnome.org/YaLTeR/identity>`_
|
||||
- `Jogger <https://codeberg.org/baarkerlounger/jogger>`_
|
||||
- `Junction <https://github.com/sonnyp/Junction/>`_
|
||||
- `Komikku <https://codeberg.org/valos/Komikku>`_
|
||||
- `Komiku <https://github.com/flathub/info.febvre.Komikku>`_
|
||||
- `Letterpress <https://gitlab.gnome.org/World/Letterpress>`_
|
||||
- `Login Manager Settings <https://github.com/realmazharhussain/gdm-settings>`_
|
||||
- `Maniatic Launcher <https://github.com/santiagocezar/maniatic-launcher/>`_
|
||||
- `Maniatic Launcher <https://github.com/santiagocezar/maniatic-launcher/>`_
|
||||
- `Master Key <https://gitlab.com/guillermop/master-key/>`_
|
||||
- `Misson Center <https://github.com/flathub/io.missioncenter.MissionCenter>`_
|
||||
- `NewCaw <https://github.com/CodedOre/NewCaw>`_
|
||||
|
|
|
|||
|
|
@ -9,11 +9,3 @@ custom_target('docs',
|
|||
)
|
||||
|
||||
endif
|
||||
|
||||
custom_target('reference_docs.json',
|
||||
output: 'reference_docs.json',
|
||||
command: [meson.current_source_dir() / 'collect-sections.py', '@OUTPUT@'],
|
||||
build_always_stale: true,
|
||||
install: true,
|
||||
install_dir: py.get_install_dir() / 'blueprintcompiler',
|
||||
)
|
||||
|
|
@ -21,7 +21,7 @@ The tokenizer encountered an unexpected sequence of characters that aren't part
|
|||
|
||||
child_not_accepted
|
||||
------------------
|
||||
The parent class does not have child objects (it does not implement `Gtk.Buildable <https://docs.gtk.org/gtk4/iface.Buildable.html>`_ and is not a subclass of `Gio.ListStore <https://docs.gtk.org/gio/class.ListStore.html>`_). Some classes use properties instead of children to add widgets. Check the parent class's documentation.
|
||||
The parent class does not have child widgets (it does not implement `Gtk.Buildable <https://docs.gtk.org/gtk4/iface.Buildable.html>`_ and is not a subclass of `Gio.ListStore <https://docs.gtk.org/gio/class.ListStore.html>`_). Some classes use properties instead of children to add widgets. Check the parent class's documentation.
|
||||
|
||||
|
||||
.. _Diagnostic conversion_error:
|
||||
|
|
|
|||
|
|
@ -8,10 +8,10 @@ automatically.
|
|||
|
||||
.. code-block:: blueprint
|
||||
|
||||
label: bind template.account.username;
|
||||
/* ^ ^ ^
|
||||
| creates lookup expressions that are re-evaluated when
|
||||
| the account's username *or* the account itself changes
|
||||
label: bind MyAppWindow.account.username;
|
||||
/* ^ ^ ^
|
||||
| creates lookup expressions that are re-evaluated when
|
||||
| the account's username *or* the account itself changes
|
||||
|
|
||||
binds the `label` property to the expression's output
|
||||
*/
|
||||
|
|
@ -42,22 +42,22 @@ Expressions are composed of property lookups and/or closures. Property lookups a
|
|||
|
||||
.. _Syntax LookupExpression:
|
||||
|
||||
Lookups
|
||||
-------
|
||||
Lookup Expressions
|
||||
------------------
|
||||
|
||||
.. rst-class:: grammar-block
|
||||
|
||||
LookupExpression = '.' <property::ref:`IDENT<Syntax IDENT>`>
|
||||
|
||||
Lookup expressions perform a GObject property lookup on the preceding expression. They are recalculated whenever the property changes, using the `notify signal <https://docs.gtk.org/gobject/signal.Object.notify.html>`_.
|
||||
Lookup expressions perform a GObject property lookup on the preceding expression. They are recalculated whenever the property changes, using the `notify signal <https://docs.gtk.org/gobject/signal.Object.notify.html>`_
|
||||
|
||||
The type of a property expression is the type of the property it refers to.
|
||||
|
||||
|
||||
.. _Syntax ClosureExpression:
|
||||
|
||||
Closures
|
||||
--------
|
||||
Closure Expressions
|
||||
-------------------
|
||||
|
||||
.. rst-class:: grammar-block
|
||||
|
||||
|
|
@ -65,48 +65,23 @@ Closures
|
|||
|
||||
Closure expressions allow you to perform additional calculations that aren't supported in blueprint by writing those calculations as application code. These application-defined functions are created in the same way as :ref:`signal handlers<Syntax Signal>`.
|
||||
|
||||
Expressions are only reevaluated when their inputs change. Because blueprint doesn't manage a closure's application code, it can't tell what changes might affect the result. Therefore, closures must be *pure*, or deterministic. They may only calculate the result based on their immediate inputs, not properties of their inputs or outside variables.
|
||||
Expressions are only reevaluated when their inputs change. Because blueprint doesn't manage a closure's application code, it can't tell what changes might affect the result. Therefore, closures must be *pure*, or deterministic. They may only calculate the result based on their immediate inputs, properties of their inputs or outside variables.
|
||||
|
||||
Blueprint doesn't know the closure's return type, so closure expressions must be cast to the correct return type using a :ref:`cast expression<Syntax CastExpression>`.
|
||||
|
||||
|
||||
.. _Syntax CastExpression:
|
||||
|
||||
Casts
|
||||
-----
|
||||
Cast Expressions
|
||||
----------------
|
||||
|
||||
.. rst-class:: grammar-block
|
||||
|
||||
CastExpression = 'as' '<' :ref:`TypeName<Syntax TypeName>` '>'
|
||||
|
||||
Cast expressions allow Blueprint to know the type of an expression when it can't otherwise determine it. This is necessary for closures and for properties of application-defined types.
|
||||
|
||||
Example
|
||||
~~~~~~~
|
||||
Cast expressions allow Blueprint to know the type of an expression when it can't otherwise determine it.
|
||||
|
||||
.. code-block:: blueprint
|
||||
|
||||
// Cast the result of the closure so blueprint knows it's a string
|
||||
label: bind $format_bytes(template.file-size) as <string>
|
||||
|
||||
.. _Syntax ExprValue:
|
||||
|
||||
Expression Values
|
||||
-----------------
|
||||
|
||||
.. rst-class:: grammar-block
|
||||
|
||||
ExprValue = 'expr' :ref:`Expression<Syntax Expression>`
|
||||
|
||||
Some APIs take *an expression itself*--not its result--as a property value. For example, `Gtk.BoolFilter <https://docs.gtk.org/gtk4/class.BoolFilter.html>`_ has an ``expression`` property of type `Gtk.Expression <https://docs.gtk.org/gtk4/class.Expression.html>`_. This expression is evaluated for every item in a list model to determine whether the item should be filtered.
|
||||
|
||||
To define an expression for such a property, use ``expr`` instead of ``bind``. Inside the expression, you can use the ``item`` keyword to refer to the item being evaluated. You must cast the item to the correct type using the ``as`` keyword, and you can only use ``item`` in a property lookup--you may not pass it to a closure.
|
||||
|
||||
Example
|
||||
~~~~~~~
|
||||
|
||||
.. code-block:: blueprint
|
||||
|
||||
BoolFilter {
|
||||
expression: expr item as <$UserAccount>.active;
|
||||
}
|
||||
label: bind $my_closure() as <string>
|
||||
|
|
@ -10,7 +10,7 @@ Properties are the main way to set values on objects, but they are limited by th
|
|||
|
||||
Extensions are a feature of ``Gtk.Buildable``--see `Gtk.Buildable.custom_tag_start() <https://docs.gtk.org/gtk4/vfunc.Buildable.custom_tag_start.html>`_ for internal details.
|
||||
|
||||
Because they aren't part of the type system, they aren't present in typelib files like properties and signals are. Therefore, if a library adds a new extension, syntax for it must be added to Blueprint manually. If there's a commonly used extension that isn't supported by Blueprint, please `file an issue <https://gitlab.gnome.org/GNOME/blueprint-compiler/-/issues>`_.
|
||||
Because they aren't part of the type system, they aren't present in typelib files like properties and signals are. Therefore, if a library adds a new extension, syntax for it must be added to Blueprint manually. If there's a commonly used extension that isn't supported by Blueprint, please `file an issue <https://gitlab.gnome.org/jwestman/blueprint-compiler/-/issues>`_.
|
||||
|
||||
.. rst-class:: grammar-block
|
||||
|
||||
|
|
@ -37,15 +37,12 @@ Accessibility Properties
|
|||
.. rst-class:: grammar-block
|
||||
|
||||
ExtAccessibility = 'accessibility' '{' ExtAccessibilityProp* '}'
|
||||
ExtAccessibilityProp = <name::ref:`IDENT<Syntax IDENT>`> ':' (:ref:`Value <Syntax Value>` | ('[' (:ref: Value <Syntax Value>),* ']') ) ';'
|
||||
ExtAccessibilityProp = <name::ref:`IDENT<Syntax IDENT>`> ':' :ref:`Value <Syntax Value>` ';'
|
||||
|
||||
Valid in any `Gtk.Widget <https://docs.gtk.org/gtk4/class.Widget.html>`_.
|
||||
|
||||
The ``accessibility`` block defines values relevant to accessibility software. The property names and acceptable values are described in the `Gtk.AccessibleRelation <https://docs.gtk.org/gtk4/enum.AccessibleRelation.html>`_, `Gtk.AccessibleState <https://docs.gtk.org/gtk4/enum.AccessibleState.html>`_, and `Gtk.AccessibleProperty <https://docs.gtk.org/gtk4/enum.AccessibleProperty.html>`_ enums.
|
||||
|
||||
.. note::
|
||||
|
||||
Relations which allow for a list of values, for example `labelled-by`, must be given as a single relation with a list of values instead of duplicating the relation like done in Gtk.Builder.
|
||||
|
||||
.. _Syntax ExtAdwBreakpoint:
|
||||
|
||||
|
|
@ -227,7 +224,7 @@ Valid in `Gtk.BuilderListItemFactory <https://docs.gtk.org/gtk4/class.BuilderLis
|
|||
|
||||
The ``template`` block defines the template that will be used to create list items. This block is unique within Blueprint because it defines a completely separate sub-blueprint which is used to create each list item. The sub-blueprint may not reference objects in the main blueprint or vice versa.
|
||||
|
||||
The template type must be `Gtk.ListItem <https://docs.gtk.org/gtk4/class.ListItem.html>`_, `Gtk.ColumnViewRow <https://docs.gtk.org/gtk4/class.ColumnViewRow.html>`_, or `Gtk.ColumnViewCell <https://docs.gtk.org/gtk4/class.ColumnViewCell.html>`_. The template object can be referenced with the ``template`` keyword.
|
||||
The template type must be `Gtk.ListItem <https://docs.gtk.org/gtk4/class.ListItem.html>`_. The template object can be referenced with the ``template`` keyword.
|
||||
|
||||
.. code-block:: blueprint
|
||||
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ Tokens
|
|||
IDENT
|
||||
~~~~~
|
||||
|
||||
An identifier starts with an ASCII underscore ``_`` or letter ``[A-Za-z]`` and consists of ASCII underscores, letters, digits ``[0-9]``, and dashes ``-``. Dashes are included for historical reasons, since GObject properties and signals are traditionally kebab-case.
|
||||
An identifier starts with an ASCII underscore ``_`` or letter ``[A-Za-z]`` and consists of ASCII underscores, letters, digits ``[0-9]``, and dashes ``-``. Dashes are included for historical reasons, since GObject properties are traditionally kebab-case.
|
||||
|
||||
.. _Syntax NUMBER:
|
||||
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ Properties
|
|||
|
||||
.. rst-class:: grammar-block
|
||||
|
||||
Property = <name::ref:`IDENT<Syntax IDENT>`> ':' ( :ref:`Binding<Syntax Binding>` | :ref:`ExprValue<Syntax ExprValue>` | :ref:`ObjectValue<Syntax ObjectValue>` | :ref:`Value<Syntax Value>` ) ';'
|
||||
Property = <name::ref:`IDENT<Syntax IDENT>`> ':' ( :ref:`Binding<Syntax Binding>` | :ref:`ObjectValue<Syntax ObjectValue>` | :ref:`Value<Syntax Value>` ) ';'
|
||||
|
||||
Properties specify the details of each object, like a label's text, an image's icon name, or the margins on a container.
|
||||
|
||||
|
|
@ -91,7 +91,7 @@ Signal Handlers
|
|||
.. rst-class:: grammar-block
|
||||
|
||||
Signal = <name::ref:`IDENT<Syntax IDENT>`> ('::' <detail::ref:`IDENT<Syntax IDENT>`>)? '=>' '$' <handler::ref:`IDENT<Syntax IDENT>`> '(' <object::ref:`IDENT<Syntax IDENT>`>? ')' (SignalFlag)* ';'
|
||||
SignalFlag = 'after' | 'swapped' | 'not-swapped'
|
||||
SignalFlag = 'after' | 'swapped'
|
||||
|
||||
Signals are one way to respond to user input (another is `actions <https://docs.gtk.org/gtk4/actions.html>`_, which use the `action-name property <https://docs.gtk.org/gtk4/property.Actionable.action-name.html>`_).
|
||||
|
||||
|
|
@ -99,8 +99,6 @@ Signals provide a handle for your code to listen to events in the UI. The handle
|
|||
|
||||
Optionally, you can provide an object ID to use when connecting the signal.
|
||||
|
||||
The ``swapped`` flag is used to swap the order of the object and userdata arguments in C applications. If an object argument is specified, then this is the default behavior, so the ``not-swapped`` flag can be used to prevent the swap.
|
||||
|
||||
Example
|
||||
~~~~~~~
|
||||
|
||||
|
|
@ -110,6 +108,7 @@ Example
|
|||
clicked => $on_button_clicked();
|
||||
}
|
||||
|
||||
|
||||
.. _Syntax Child:
|
||||
|
||||
Children
|
||||
|
|
|
|||
|
|
@ -90,7 +90,6 @@ To reference the template object in a binding or expression, use the ``template`
|
|||
Language Implementations
|
||||
------------------------
|
||||
|
||||
- **C** ``gtk_widget_class_set_template ()``: https://docs.gtk.org/gtk4/class.Widget.html#building-composite-widgets-from-template-xml
|
||||
- **gtk-rs** ``#[template]``: https://gtk-rs.org/gtk4-rs/stable/latest/book/composite_templates.html
|
||||
- **GJS** ``GObject.registerClass()``: https://gjs.guide/guides/gtk/3/14-templates.html
|
||||
- **PyGObject** ``@Gtk.Template``: https://pygobject.gnome.org/guide/gtk_template.html
|
||||
- ``gtk_widget_class_set_template ()`` in C: https://docs.gtk.org/gtk4/class.Widget.html#building-composite-widgets-from-template-xml
|
||||
- ``#[template]`` in gtk-rs: https://gtk-rs.org/gtk4-rs/stable/latest/book/composite_templates.html
|
||||
- ``GObject.registerClass()`` in GJS: https://gjs.guide/guides/gtk/3/14-templates.html
|
||||
|
|
@ -25,7 +25,8 @@ Literals
|
|||
NumberLiteral = ( '-' | '+' )? <value::ref:`NUMBER<Syntax NUMBER>`>
|
||||
IdentLiteral = <ident::ref:`IDENT<Syntax IDENT>`>
|
||||
|
||||
Literals are used to specify values for properties. They can be strings, numbers, references to objects, ``null``, types, boolean values, or enum members.
|
||||
Literals are used to specify values for properties. They can be strings, numbers, references to objects, types, boolean values, or enum members.
|
||||
|
||||
|
||||
.. _Syntax TypeLiteral:
|
||||
|
||||
|
|
@ -109,7 +110,7 @@ Bindings
|
|||
.. rst-class:: grammar-block
|
||||
|
||||
Binding = 'bind' :ref:`Expression<Syntax Expression>` (BindingFlag)*
|
||||
BindingFlag = 'inverted' | 'bidirectional' | 'no-sync-create'
|
||||
BindingFlag = 'inverted' | 'bidirectional' | 'sync-create'
|
||||
|
||||
Bindings keep a property updated as other properties change. They can be used to keep the UI in sync with application data, or to connect two parts of the UI.
|
||||
|
||||
|
|
@ -120,8 +121,8 @@ Simple Bindings
|
|||
|
||||
A binding that consists of a source object and a single lookup is called a "simple binding". These are implemented using `GObject property bindings <https://docs.gtk.org/gobject/method.Object.bind_property.html>`_ and support a few flags:
|
||||
|
||||
- ``inverted``: For boolean properties, the target is set to the inverse of the source property.
|
||||
- ``bidirectional``: The binding is two-way, so changes to the target property will also update the source property.
|
||||
- ``inverted``: For boolean properties, the target is set to the inverse of the source property.
|
||||
- ``no-sync-create``: Normally, when a binding is created, the target property is immediately updated with the current value of the source property. This flag disables that behavior, and the bound property will be updated the next time the source property changes.
|
||||
|
||||
Complex Bindings
|
||||
|
|
@ -137,13 +138,14 @@ Example
|
|||
/* Use bindings to show a label when a switch
|
||||
* is active, without any application code */
|
||||
|
||||
Switch show_label {}
|
||||
Switch advanced_feature {}
|
||||
|
||||
Label {
|
||||
visible: bind show_label.active;
|
||||
label: _("I'm a label that's only visible when the switch is enabled!");
|
||||
Label warning {
|
||||
visible: bind advanced_feature.active;
|
||||
label: _("This is an advanced feature. Use with caution!");
|
||||
}
|
||||
|
||||
|
||||
.. _Syntax ObjectValue:
|
||||
|
||||
Object Values
|
||||
|
|
@ -168,14 +170,3 @@ String Values
|
|||
StringValue = :ref:`Translated<Syntax Translated>` | :ref:`QuotedLiteral<Syntax Literal>`
|
||||
|
||||
Menus, as well as some :ref:`extensions<Syntax Extension>`, have properties that can only be string literals or translated strings.
|
||||
|
||||
.. _Syntax ArrayValue:
|
||||
|
||||
Array Values
|
||||
-------------
|
||||
|
||||
.. rst-class:: grammar-block
|
||||
|
||||
ArrayValue = '[' (:ref:`StringValue<Syntax StringValue>`),* ']'
|
||||
|
||||
For now, it only supports :ref:`Strings<Syntax StringValue>`. This is because Gtk.Builder only supports string arrays.
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ Setting up Blueprint on a new or existing project
|
|||
Using the porting tool
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Clone `blueprint-compiler <https://gitlab.gnome.org/GNOME/blueprint-compiler>`_
|
||||
Clone `blueprint-compiler <https://gitlab.gnome.org/jwestman/blueprint-compiler>`_
|
||||
from source. You can install it using ``meson _build`` and ``ninja -C _build install``,
|
||||
or you can leave it uninstalled.
|
||||
|
||||
|
|
@ -29,7 +29,7 @@ blueprint-compiler works as a meson subproject.
|
|||
|
||||
[wrap-git]
|
||||
directory = blueprint-compiler
|
||||
url = https://gitlab.gnome.org/GNOME/blueprint-compiler.git
|
||||
url = https://gitlab.gnome.org/jwestman/blueprint-compiler.git
|
||||
revision = main
|
||||
depth = 1
|
||||
|
||||
|
|
|
|||
|
|
@ -24,8 +24,6 @@ If you're using Meson's `i18n module <https://mesonbuild.com/i18n-module.html#i1
|
|||
|
||||
i18n.gettext('package name', preset: 'glib')
|
||||
|
||||
You must use double quotes for the translated strings in order for gettext to recognize them. Newer versions of blueprint will warn you if you use single quotes.
|
||||
|
||||
Contexts
|
||||
--------
|
||||
|
||||
|
|
|
|||
|
|
@ -1,14 +1,14 @@
|
|||
project('blueprint-compiler',
|
||||
version: '0.16.0',
|
||||
version: '0.12.0',
|
||||
)
|
||||
|
||||
subdir('docs')
|
||||
|
||||
prefix = get_option('prefix')
|
||||
datadir = join_paths(prefix, get_option('datadir'))
|
||||
|
||||
py = import('python').find_installation('python3')
|
||||
|
||||
subdir('docs')
|
||||
|
||||
configure_file(
|
||||
input: 'blueprint-compiler.pc.in',
|
||||
output: 'blueprint-compiler.pc',
|
||||
|
|
|
|||
|
|
@ -1,4 +0,0 @@
|
|||
using Gtk 4.0;
|
||||
//comment
|
||||
// Trailing whitespace:
|
||||
//
|
||||
|
|
@ -1,4 +0,0 @@
|
|||
using Gtk 4.0;
|
||||
// comment
|
||||
// Trailing whitespace:
|
||||
//
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
using Gtk 4.0;
|
||||
|
||||
Box {
|
||||
styles []
|
||||
}
|
||||
|
||||
Box {
|
||||
styles ["a"]
|
||||
}
|
||||
|
||||
Box {
|
||||
styles ["a",]
|
||||
}
|
||||
|
||||
Box {
|
||||
styles ["a", "b"]
|
||||
}
|
||||
|
||||
Box {
|
||||
styles ["a", "b",]
|
||||
}
|
||||
|
|
@ -1,31 +0,0 @@
|
|||
using Gtk 4.0;
|
||||
|
||||
Box {
|
||||
styles []
|
||||
}
|
||||
|
||||
Box {
|
||||
styles [
|
||||
"a",
|
||||
]
|
||||
}
|
||||
|
||||
Box {
|
||||
styles [
|
||||
"a",
|
||||
]
|
||||
}
|
||||
|
||||
Box {
|
||||
styles [
|
||||
"a",
|
||||
"b",
|
||||
]
|
||||
}
|
||||
|
||||
Box {
|
||||
styles [
|
||||
"a",
|
||||
"b",
|
||||
]
|
||||
}
|
||||
|
|
@ -11,7 +11,7 @@ Overlay {
|
|||
notify::icon-name => $on_icon_name_changed(label) swapped;
|
||||
|
||||
styles [
|
||||
"destructive",
|
||||
"destructive"
|
||||
]
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1 +1 @@
|
|||
test('tests', py, args: ['-m', 'unittest'], workdir: meson.project_source_root())
|
||||
test('tests', py, args: ['-m', 'unittest'], workdir: meson.source_root())
|
||||
|
|
|
|||
|
|
@ -1,9 +0,0 @@
|
|||
using Gtk 4.0;
|
||||
|
||||
Box {
|
||||
accessibility {
|
||||
label: _("Hello, world!");
|
||||
labelled-by: [];
|
||||
checked: true;
|
||||
}
|
||||
}
|
||||
|
|
@ -1 +0,0 @@
|
|||
6,5,11,'labelled-by' may not be empty
|
||||
|
|
@ -1,15 +0,0 @@
|
|||
using Gtk 4.0;
|
||||
|
||||
Box {
|
||||
accessibility {
|
||||
label: _("Hello, world!");
|
||||
active-descendant: [my_label1, my_label2, my_label3];
|
||||
checked: true;
|
||||
}
|
||||
}
|
||||
|
||||
Label my_label1 {}
|
||||
|
||||
Label my_label2 {}
|
||||
|
||||
Label my_label3 {}
|
||||
|
|
@ -1 +0,0 @@
|
|||
6,5,17,'active-descendant' does not allow a list of values
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
using Gtk 4.0;
|
||||
|
||||
Label {
|
||||
label: [1];
|
||||
}
|
||||
|
|
@ -1 +0,0 @@
|
|||
4,12,3,Cannot assign array to string
|
||||
|
|
@ -1,6 +0,0 @@
|
|||
using Gtk 4.0;
|
||||
|
||||
AboutDialog about {
|
||||
valign: center;
|
||||
authors: [1];
|
||||
}
|
||||
|
|
@ -1 +0,0 @@
|
|||
5,15,1,Cannot convert number to string
|
||||
10
tests/sample_errors/deprecations.blp
Normal file
10
tests/sample_errors/deprecations.blp
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
using Gtk 4.0;
|
||||
using Gio 2.0;
|
||||
|
||||
Dialog {
|
||||
use-header-bar: 1;
|
||||
}
|
||||
|
||||
Window {
|
||||
keys-changed => $on_window_keys_changed();
|
||||
}
|
||||
1
tests/sample_errors/deprecations.err
Normal file
1
tests/sample_errors/deprecations.err
Normal file
|
|
@ -0,0 +1 @@
|
|||
4,1,6,Gtk.Dialog is deprecated
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
using Gtk 4.0;
|
||||
|
||||
BoolFilter {
|
||||
expression: expr item.visible;
|
||||
}
|
||||
|
|
@ -1 +0,0 @@
|
|||
4,20,4,"item" must be cast to its object type
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
using Gtk 4.0;
|
||||
|
||||
Label {
|
||||
label: expr 1;
|
||||
}
|
||||
|
|
@ -1 +0,0 @@
|
|||
4,10,4,Cannot convert Gtk.Expression to string
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
using Gtk 4.0;
|
||||
|
||||
BoolFilter {
|
||||
expression: expr $closure(item as <Entry>) as <bool>;
|
||||
}
|
||||
|
|
@ -1 +0,0 @@
|
|||
4,29,4,"item" can only be used for looking up properties
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
using Gtk 4.0;
|
||||
|
||||
BoolFilter {
|
||||
expression: expr item as <Label>;
|
||||
}
|
||||
|
|
@ -1 +0,0 @@
|
|||
4,20,4,"item" can only be used for looking up properties
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
using Gtk 4.0;
|
||||
|
||||
Entry {
|
||||
margin-bottom: 10.5;
|
||||
}
|
||||
|
|
@ -1 +0,0 @@
|
|||
4,18,4,Cannot convert 10.5 to integer
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
using Gtk 4.0;
|
||||
|
||||
Label {
|
||||
notify::
|
||||
}
|
||||
|
|
@ -1,2 +0,0 @@
|
|||
5,1,0,Expected a signal detail name
|
||||
4,9,3,Unexpected tokens
|
||||
|
|
@ -1,3 +0,0 @@
|
|||
using Gtk 4.0;
|
||||
|
||||
int {}
|
||||
|
|
@ -1 +0,0 @@
|
|||
3,1,3,int is not a class
|
||||
|
|
@ -1,2 +1,3 @@
|
|||
3,10,12,Use type syntax here (introduced in blueprint 0.8.0)
|
||||
8,1,6,Gtk.Dialog is deprecated
|
||||
9,18,12,Use 'template' instead of the class name (introduced in 0.8.0)
|
||||
|
|
@ -1 +1 @@
|
|||
4,11,6,Only Gtk.ListItem, Gtk.ListHeader, Gtk.ColumnViewRow, or Gtk.ColumnViewCell is allowed as a type here
|
||||
4,3,17,Only Gtk.ListItem is allowed as a type here
|
||||
|
|
@ -1,7 +0,0 @@
|
|||
using Gtk 4.0;
|
||||
|
||||
Overlay {
|
||||
child: my_menu;
|
||||
}
|
||||
|
||||
menu my_menu {}
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Add a link
Reference in a new issue