[packages/gi-docgen] upstream patch for fixing double type qualify; rel 2

atler atler at pld-linux.org
Tue Nov 9 00:46:24 CET 2021


commit 224c5ef8a051a29c19855ad361ace97d19f77a10
Author: Jan Palus <atler at pld-linux.org>
Date:   Tue Nov 9 00:44:37 2021 +0100

    upstream patch for fixing double type qualify; rel 2
    
    from https://gitlab.gnome.org/GNOME/gi-docgen/-/commit/72f3c5dbe27aabb5f7a376afda23f3dfc3c2e212

 gi-docgen.spec     |   4 +-
 qualify_type.patch | 122 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 125 insertions(+), 1 deletion(-)
---
diff --git a/gi-docgen.spec b/gi-docgen.spec
index 07165be..e81d58c 100644
--- a/gi-docgen.spec
+++ b/gi-docgen.spec
@@ -6,11 +6,12 @@ Summary:	Documentation tool for GObject-based libraries
 Summary(pl.UTF-8):	Narzędzie do dokumentowania bibliotek opartych na GObject
 Name:		gi-docgen
 Version:	2021.8
-Release:	1
+Release:	2
 License:	Apache v2.0 or GPL v3+
 Group:		Development/Tools
 Source0:	https://download.gnome.org/sources/gi-docgen/2021/%{name}-%{version}.tar.xz
 # Source0-md5:	39693836341205e2d514b3eb05a9ec8a
+Patch0:		qualify_type.patch
 URL:		https://gitlab.gnome.org/GNOME/gi-docgen
 BuildRequires:	python3-modules >= 1:3.6
 BuildRequires:	python3-setuptools
@@ -59,6 +60,7 @@ Dokumentacja do narzędzia GI-Docgen.
 
 %prep
 %setup -q
+%patch0 -p1
 
 %build
 %py3_build
diff --git a/qualify_type.patch b/qualify_type.patch
new file mode 100644
index 0000000..5e1514e
--- /dev/null
+++ b/qualify_type.patch
@@ -0,0 +1,122 @@
+From 72f3c5dbe27aabb5f7a376afda23f3dfc3c2e212 Mon Sep 17 00:00:00 2001
+From: Emmanuele Bassi <ebassi at gnome.org>
+Date: Thu, 28 Oct 2021 19:17:06 +0100
+Subject: [PATCH] gir: Do not qualify type names that are already qualified
+
+Otherwise we're going to duplicate the namespace of a type, and then
+splitting the namespace from the type name won't work any more.
+
+We already do this for class ancestors, but we failed to do this for
+interface requirements and class implementations.
+
+Fixes: #111
+---
+ gidocgen/gdgenerate.py |  1 +
+ gidocgen/gir/ast.py    | 48 +++++++++++++++++++++++++++---------------
+ gidocgen/gir/parser.py |  2 +-
+ 3 files changed, 33 insertions(+), 18 deletions(-)
+
+diff --git a/gidocgen/gdgenerate.py b/gidocgen/gdgenerate.py
+index 6c84777..c705777 100644
+--- a/gidocgen/gdgenerate.py
++++ b/gidocgen/gdgenerate.py
+@@ -1153,6 +1153,7 @@ class TemplateInterface:
+             self.requires_ctype = requires.ctype
+ 
+         self.requires_fqtn = f"{self.requires_namespace}.{self.requires_name}"
++        log.debug(f"Preqrequisite for {self.fqtn}: {self.requires_fqtn}")
+ 
+         self.symbol_prefix = f"{namespace.symbol_prefix[0]}_{interface.symbol_prefix}"
+         self.type_cname = interface.base_ctype
+diff --git a/gidocgen/gir/ast.py b/gidocgen/gir/ast.py
+index 650b4cc..8a7294a 100644
+--- a/gidocgen/gir/ast.py
++++ b/gidocgen/gir/ast.py
+@@ -970,13 +970,14 @@ class Repository:
+ 
+     def resolve_interface_requires(self) -> None:
+         def find_prerequisite_type(includes, ns, name):
+-            for repo in includes.values():
+-                if repo.namespace.name != ns:
+-                    continue
+-                prereq = repo.namespace.find_prerequisite_type(name)
+-                if prereq is not None:
+-                    return Type(name=f"{repo.namespace.name}.{prereq.name}", ctype=prereq.ctype)
+-            return None
++            repository = includes.get(ns)
++            if repository is None:
++                return None
++            prereq = repository.namespace.find_prerequisite_type(name)
++            # If the prerequisite type is unqualified, then we qualify it here
++            if '.' not in prereq.name:
++                prereq.name = f"{repository.namespace.name}.{prereq.name}"
++            return prereq
+ 
+         ifaces = self.namespace.get_interfaces()
+         for iface in ifaces:
+@@ -993,12 +994,24 @@ class Repository:
+                 prerequisite = self.namespace.find_prerequisite_type(iface.prerequisite.name)
+             if prerequisite is not None:
+                 if prerequisite.ctype is None:
+-                    t = self._lookup_type(prerequisite.name)
+-                    prerequisite.ctype = t.ctype
++                    if '.' not in prerequisite.name:
++                        name = f"{self.namespace.name}.{prerequisite.name}"
++                    else:
++                        name = prerequisite.name
++                    t = self._lookup_type(name)
++                    if t is not None:
++                        prerequisite.ctype = t.ctype
++                    else:
++                        # This is kind of a kludge, but apparently we can get into
++                        # class definitions missing a c:type; if that happens, we
++                        # take the identifier prefix of the namespace and append the
++                        # class name, because that's the inverse of how g-ir-scanner
++                        # determines the class name
++                        prerequisite.ctype = f"{self.namespace.identifier_prefix[0]}{prerequisite.name}"
+                 iface.prerequisite = prerequisite
+                 log.debug(f"Prerequisite type for interface {iface}: {iface.prerequisite}")
+ 
+-    def resolve_class_type(self) -> None:
++    def resolve_class_ctype(self) -> None:
+         classes = self.namespace.get_classes()
+         for cls in classes:
+             if cls.ctype is None:
+@@ -1020,13 +1033,14 @@ class Repository:
+ 
+     def resolve_class_implements(self) -> None:
+         def find_interface_type(includes, ns, name):
+-            for repo in includes.values():
+-                if repo.namespace.name != ns:
+-                    continue
+-                iface = repo.namespace.find_interface(name)
+-                if iface is not None:
+-                    return Type(name=f"{repo.namespace.name}.{iface.name}", ctype=iface.ctype)
+-            return None
++            repository = includes.get(ns)
++            if repository is None:
++                return None
++            iface = repository.namespace.find_interface(name)
++            # If the interface type is unqualified, then we qualify it here
++            if '.' not in iface.name:
++                iface.name = f"{repository.namespace.name}.{iface.name}"
++            return iface
+ 
+         classes = self.namespace.get_classes()
+         for cls in classes:
+diff --git a/gidocgen/gir/parser.py b/gidocgen/gir/parser.py
+index cdab096..df155cb 100644
+--- a/gidocgen/gir/parser.py
++++ b/gidocgen/gir/parser.py
+@@ -96,7 +96,7 @@ class GirParser:
+                 repository.girfile = girfile.name
+             self._repository = repository
+             self._repository.resolve_empty_ctypes(self._seen_types)
+-            self._repository.resolve_class_type()
++            self._repository.resolve_class_ctype()
+             self._repository.resolve_class_implements()
+             self._repository.resolve_class_ancestors()
+             self._repository.resolve_class_descendants()
+-- 
+GitLab
+
================================================================

---- gitweb:

http://git.pld-linux.org/gitweb.cgi/packages/gi-docgen.git/commitdiff/224c5ef8a051a29c19855ad361ace97d19f77a10



More information about the pld-cvs-commit mailing list