File indexing completed on 2024-04-21 05:41:05

 import logging
 import re
 import typing
 
 TYPE_RX = r"(?P<prefix>\s+type:)(?P<type>[\w\*.<>|]+)"
 
 BASE_NAME_DICT = {
     "QtObject": "QtQml.QtObject",
     "Item": "QtQuick.Item",
 }
 
 
 def post_process_type(rx, text, type):
     match = rx.search(text)
     if match:
         type = match.group("type")
         text = text[:match.start("prefix")] + text[match.end("type"):]
     return text, type
 
 def is_cxx_comment(text):
     if not isinstance(text, str):
         text = str(text)
     return text.startswith("//")
 
 
 class QmlBaseComponent():
     def __init__(self, name, version = None, should_separate_blocks = True):
         self.name = name
         self.base_name = ""
         self.elements = []
         self.should_separate_blocks = should_separate_blocks
 
         lst = name.split(".")
         self.class_name = lst[-1]
         self.namespaces = lst[:-1]
 
     def get_attributes(self):
         return [x for x in self.elements if isinstance(x, QmlAttribute)]
 
     def get_properties(self):
         return [x for x in self.elements if isinstance(x, QmlProperty)]
 
     def get_functions(self):
         return [x for x in self.elements if isinstance(x, QmlFunction)]
 
     def get_signals(self):
         return [x for x in self.elements if isinstance(x, QmlSignal)]
 
     def add_element(self, element):
         self.elements.append(element)
 
     def starts_with_cxx_comment(self):
         if not hasattr(self, "doc_is_inline") or not hasattr(self, "doc"):
             return False
         if self.doc_is_inline:
             return False
         return self.doc.startswith("//")
 
     def __str__(self):
         lst = []
         self._export_content(lst)
         return "\n".join(lst)
 
     def _export_element(self, element, lst):
         doc = str(element)
         if doc:
             lst.append(doc)
 
     def _export_elements(self, input_list, lst, filter=None):
         for element in input_list:
             if filter and not filter(element):
                 continue
             self._export_element(element, lst)
 
     def _export_element_w_access(self, element, lst, is_public,
             last_was_public, last_was_cxx_comment):
         if is_public != last_was_public:
             if is_public:
                 lst.append("public:")
             else:
                 lst.append("private:")
         elif last_was_cxx_comment and is_cxx_comment(element) and self.should_separate_blocks:
             lst.append("")
         self._export_element(element, lst)
 
     def _start_class(self, lst):
         class_decl = "class " + self.class_name
         if self.base_name:
             for alias, replacement in self.alias.items():
                 self.base_name = re.sub(alias, replacement, self.base_name)
             self.base_name = BASE_NAME_DICT.get(self.base_name, self.base_name)
 
             class_decl += " : public " + self.base_name
 
         class_decl += " {"
         lst.append(class_decl)
 
     def _end_class(self, lst):
         lst.append("};")
 
 
 class QmlClass(QmlBaseComponent):
     SINGLETON_COMMENT = "/** @remark This component is a singleton */"
     VERSION_COMMENT = "/** @version %s */"
     IMPORT_STATEMENT_COMMENT = "/** {} <br><b>Import Statement</b> \\n @code import {} @endcode */"
 
     def __init__(self, name, version=None, modulename=None, should_separate_blocks = True):
         QmlBaseComponent.__init__(self, name, version, should_separate_blocks)
         self.header_comments = []
         self.footer_comments = []
         self.imports = []
         self.alias = {}
         self.modulename = modulename
         self.version = version
 
     def add_pragma(self, decl):
         args = decl.split(' ', 2)[1].strip()
 
         if args.lower() == "singleton":
             self.header_comments.append(QmlClass.SINGLETON_COMMENT)
 
     def add_import(self, decl):
         modules = decl.split()
         module = modules[1]
         if module[0] == '"':
             # Ignore directory or javascript imports for now
             return
         if "as" in modules:
             self.alias[modules[modules.index("as")+1]] = modules[1]
         self.imports.append(module)
 
     def add_header_comment(self, obj):
         self.header_comments.append(obj)
 
     def add_footer_comment(self, obj):
         self.footer_comments.append(obj)
 
     def _export_header(self, lst):
         for module in self.imports:
             lst.append("using namespace %s;" % module.replace('.', '::'))
         if self.namespaces:
             lst.append("namespace %s {" % '::'.join(self.namespaces))
 
         lst.extend([str(x) for x in self.header_comments])
 
         if self.modulename:
             # we want to insert a newline if there has been any comments (usually a description of the class)
             newline = ""
 
             # is there any comments before this one?
             any_comments = len(self.header_comments) > 0
 
             # and if there is any comments, is the last one a SPDX message? they don't render, so don't insert a
             # useless newline
             is_spdx_last = any_comments and ("SPDX" not in self.header_comments[len(self.header_comments) - 1])
 
             if any_comments and is_spdx_last:
                 newline = "\\n"
 
             lst.append(QmlClass.IMPORT_STATEMENT_COMMENT.format(newline, self.modulename))
         if self.version:
             lst.append(QmlClass.VERSION_COMMENT % self.version)
 
 
     def _export_footer(self, lst):
         lst.extend([str(x) for x in self.footer_comments])
 
         if self.namespaces:
             lst.append("}")
 
     def _export_content(self, lst):
         self._export_header(lst)
 
         # Public members.
         self._start_class(lst)
 
         last_element_was_public = False
         last_element_was_cxx_comment = False
         for element in self.elements:
             if str(element) == "" or isinstance(element, str):
                 self._export_element_w_access(element, lst,
                         last_element_was_public, last_element_was_public,
                         last_element_was_cxx_comment)
                 last_element_was_cxx_comment = is_cxx_comment(element)
             elif element.is_public_element():
                 self._export_element_w_access(element, lst, True,
                         last_element_was_public, last_element_was_cxx_comment)
                 last_element_was_public = True
                 last_element_was_cxx_comment = False
             else:
                 self._export_element_w_access(element, lst, False,
                         last_element_was_public, last_element_was_cxx_comment)
                 last_element_was_public = False
                 last_element_was_cxx_comment = False
 
         self._end_class(lst)
         self._export_footer(lst)
 
     def is_public_element(self):
         return True
 
 
 class QmlComponent(QmlBaseComponent):
     """A component inside a QmlClass"""
 
     def __init__(self, name):
         QmlBaseComponent.__init__(self, name)
         self.comment = None
 
     def _export_content(self, lst):
         component_id = self.get_component_id()
         if component_id:
             if self.comment:
                 lst.append(self.comment)
 
             lst.append("%s %s;" % (self.class_name, component_id))
 
         # Export child components with the top-level component. This avoids
         # very deep nesting in the generated documentation.
         self._export_elements(self.elements, lst, filter=lambda x:
                               isinstance(x, QmlComponent))
 
     def get_component_id(self):
         # Returns the id of the component, if it has one
         for attr in self.get_attributes():
             if attr.name == "id":
                 return attr.value
         return None
 
     def is_public_element(self):
         return False
 
 
 class QmlArgument(object):
     def __init__(self, name):
         self.type = ""
         self.name = name
         self.default_value = None
         self.spread = False
 
     def __str__(self):
         if self.spread:
             return '.../*{}*/'.format(self.name)
         elif self.type == "":
             return self.name + self.default_value_string()
         else:
             return self.type + " " + self.name + self.default_value_string()
 
     def default_value_string(self):
         if self.default_value is None:
             return ''
         else:
             return ' = {}'.format(self.default_value)
 
     def is_public_element(self):
         return True
 
 
 class QmlAttribute(object):
     def __init__(self):
         self.name = ""
         self.value = ""
         self.type = "var"
         self.doc = ""
 
     def __str__(self):
         if self.name != "id":
             lst = []
             if len(self.doc) > 0:
                 lst.append(self.doc)
             lst.append(self.type + " " + self.name + ";")
             return "\n".join(lst)
         else:
             return ""
 
     def is_public_element(self):
         return False
 
 
 class QmlProperty(object):
     type_rx = re.compile(TYPE_RX)
 
     DEFAULT_PROPERTY_COMMENT = "/** @remark This is the default property */"
     READONLY_PROPERTY_COMMENT = "/** @remark This property is read-only */"
 
     def __init__(self):
         self.type = ""
         self.is_default = False
         self.is_readonly = False
         self.name = ""
         self.doc = ""
         self.doc_is_inline = False
 
     def __str__(self):
         self.post_process_doc()
         lst = []
         if not self.doc_is_inline:
             lst.append(self.doc + "\n")
         if self.is_default:
             lst.append(self.DEFAULT_PROPERTY_COMMENT + "\n")
         elif self.is_readonly:
             lst.append(self.READONLY_PROPERTY_COMMENT + "\n")
         lst.append("Q_PROPERTY(%s %s READ dummyGetter_%s_ignore)"
             % (self.type, self.name, self.name))
         if self.doc_is_inline:
             lst.append(" " + self.doc)
         return "".join(lst)
 
     def post_process_doc(self):
         self.doc, self.type = post_process_type(self.type_rx, self.doc, self.type)
 
     def is_public_element(self):
         # Doxygen always adds Q_PROPERTY items as public members.
         return True
 
 
 class QmlFunction(object):
     doc_arg_rx = re.compile(r"[@\\]param" + TYPE_RX + r"\s+(?P<name>\w+)")
     return_rx = re.compile(r"[@\\]returns?" + TYPE_RX)
 
     def __init__(self):
         self.type = "void"
         self.name = ""
         self.doc = ""
         self.doc_is_inline = False
         self.args = []
 
     def __str__(self):
         self.post_process_doc()
         arg_string = ", ".join([str(x) for x in self.args])
         lst = []
         if not self.doc_is_inline:
             lst.append(self.doc + "\n")
         lst.append("%s %s(%s);" % (self.type, self.name, arg_string))
         if self.doc_is_inline:
             lst.append(" " + self.doc)
         return "".join(lst)
 
     def post_process_doc(self):
         def repl(match):
             # For each argument with a specified type, update arg.type and return a typeless @param line
             type = match.group("type")
             name = match.group("name")
             for arg in self.args:
                 if arg.name == name:
                     arg.type = type
                     break
             else:
                 logging.warning("In function %s(): Unknown argument %s" % (self.name, name))
             return "@param %s" % name
 
         self.doc = self.doc_arg_rx.sub(repl, self.doc)
         self.doc, self.type = post_process_type(self.return_rx, self.doc, self.type)
 
     def is_public_element(self):
         return True
 
 
 class QmlEnum(object):
     def __init__(self):
         self.name = ""
         self.doc = ""
         self.doc_is_inline = False
         self.enumerators = []
 
     def __str__(self):
         lst = []
 
         if self.doc and not self.doc_is_inline:
             lst.append(self.doc + "\n")
         lst.append("enum class %s {" % (self.name))
         if self.doc and self.doc_is_inline:
             lst.append(" " + self.doc)
         lst.append("\n")
 
         for e in self.enumerators:
             lst.append(str(e) + "\n")
 
         lst.append("};")
         return "".join(lst)
 
     def is_public_element(self):
         return True
 
 
 class QmlEnumerator(object):
     def __init__(self, name):
         self.name = name
         self.initializer = ""
         self.is_last = False
         self.doc = ""
         self.doc_is_inline = False
 
     def __str__(self):
         lst = []
         if self.doc and not self.doc_is_inline:
             lst.append(self.doc + "\n")
         lst.append("%s" % (self.name))
         if self.initializer:
             lst.append(" = %s" % (self.initializer))
         if not self.is_last:
             lst.append(",")
         if self.doc and self.doc_is_inline:
             lst.append(" " + self.doc)
         return "".join(lst)
 
     def is_public_element(self):
         return True
 
 
 class QmlSignal(object):
     def __init__(self):
         self.name = ""
         self.doc = ""
         self.doc_is_inline = False
         self.args = []
 
     def __str__(self):
         arg_string = ", ".join([str(x) for x in self.args])
         lst = []
         if not self.doc_is_inline:
             lst.append(self.doc + "\n")
         lst.append("Q_SIGNALS: void %s(%s); " % (self.name, arg_string))
         if self.doc_is_inline:
             lst.append(self.doc + "\n")
         # Appending "public:" here makes it possible to declare a signal without
         # turning all functions defined after into signals.
         # It could be replaced with the use of Q_SIGNAL, but my version of
         # Doxygen (1.8.4) does not support it
         lst.append("public:")
         return "".join(lst)
 
     def is_public_element(self):
         # Doxygen always adds Q_SIGNALS items as public members.
         return True