File indexing completed on 2024-04-14 05:34:18

 #!/usr/bin/env python3
 
 import argparse
 import codecs
 import logging
 import os
 import re
 import sys
 
 import doxyqml.qmlparser as qmlparser
 
 from doxyqml import __version__, DESCRIPTION
 from doxyqml.lexer import Lexer, LexerError
 from doxyqml.qmlclass import QmlClass
 
 
 def coord_for_idx(text, idx):
     head, sep, tail = text[:idx].rpartition("\n")
     if sep == "\n":
         row = head.count("\n") + 2
     else:
         row = 1
     col = len(tail) + 1
     return row, col
 
 
 def line_for_idx(text, idx):
     bol = text.rfind("\n", 0, idx)
     if bol == -1:
         bol = 0
     eol = text.find("\n", idx)
     return text[bol:eol]
 
 
 def info_for_error_at(text, idx):
     row, col = coord_for_idx(text, idx)
     line = line_for_idx(text, idx)
     msg = line + "\n" + "-" * (col - 1) + "^"
     return row, msg
 
 
 def parse_args(argv):
     parser = argparse.ArgumentParser(
         prog="doxyqml",
         description=DESCRIPTION,
         )
     parser.add_argument("-d", "--debug",
                         action="store_true",
                         help="Log debug info to stderr")
     parser.add_argument("--namespace",
                         action='append',
                         default=[],
                         help="Wrap the generated C++ classes in NAMESPACE")
     parser.add_argument("--no-since-version",
                         action="store_true",
                         default=False,
                         help="Don't append \"Since: [version]\" info to docstring")
     parser.add_argument('--no-nested-components',
                         action='store_true',
                         default=False,
                         help="Don't create private member documentation for nested components")
     parser.add_argument('--version',
                         action='version',
                         version='%%(prog)s %s' % __version__)
     parser.add_argument("qml_file",
                         help="The QML file to parse")
 
     return parser.parse_args(argv)
 
 
 def find_qmldir_file(qml_file):
     dir = os.path.dirname(qml_file)
 
     while True:
         # Check if `dir` contains a file of the name "qmldir".
         name = os.path.join(dir, 'qmldir')
 
         if os.path.isfile(name):
             return name
 
         # Pick parent of `dir`. Abort once parent stops changing,
         # either because we reached the root directory, or because
         # relative paths were used and we reached the currrent
         # working directory.
         parent = os.path.dirname(dir)
 
         if parent == dir:
             return None
 
         dir = parent
 
 
 def find_classname(qml_file, namespace=None):
     classname = os.path.basename(qml_file).split(".")[0]
     classversion = None
     modulename = ''
 
     qmldir = find_qmldir_file(qml_file)
 
     if qmldir:
         text = open(qmldir).read()
         match = re.match(r'^module\s+((?:\w|\.)+)\s*$', text, re.MULTILINE)
 
         if match:
             modulename = match.group(1)
 
         basedir = os.path.dirname(qmldir)
 
         rx_object_type = re.compile(r'^(\w+)\s+(\d+(?:\.\d+)*)\s+(\S+)\s*$', re.MULTILINE)
 
         # skip internal classes
         if "internal" in text:
             return None, None, None
 
         for name, version, path in rx_object_type.findall(text):
             filename = os.path.join(basedir, path)
 
             if os.path.isfile(filename) and os.path.samefile(qml_file, filename):
                 classversion = version
                 classname = name
                 break
 
     if modulename:
         classname = modulename + '.' + classname
 
     if namespace:
         classname = '.'.join(namespace) + '.' + classname
 
     return classname, classversion, modulename
 
 
 def main(argv=None, out=None):
     if argv is None:
         argv = sys.argv[1:]
     if out is None:
         out = sys.stdout
 
     args = parse_args(argv)
 
     name = args.qml_file
     namespace = args.namespace
 
     encoding = "utf-8"
     first_4_bytes = open(name, 'rb').read(4)
     if (first_4_bytes.startswith(codecs.BOM_UTF8)):
         encoding = "utf-8-sig"
     text = open(name, encoding=encoding).read()
 
     lexer = Lexer(text)
     try:
         lexer.tokenize()
     except LexerError as exc:
         logging.error("Failed to tokenize %s" % name)
         row, msg = info_for_error_at(text, exc.idx)
         logging.error("Lexer error line %d: %s\n%s", row, exc, msg)
         if args.debug:
             raise
         else:
             return -1
 
     if args.debug:
         for token in lexer.tokens:
             print("%20s %s" % (token.type, token.value))
 
     classname, classversion, modulename = find_classname(name, namespace)
     if args.no_since_version:
         classversion = None
 
     if classname is None:
         return
 
     qml_class = QmlClass(classname, classversion, modulename, not args.no_nested_components)
 
     try:
         qmlparser.parse(lexer.tokens, qml_class, not args.no_nested_components)
     except qmlparser.QmlParserError as exc:
         logging.error("Failed to parse %s" % name)
         row, msg = info_for_error_at(text, exc.token.idx)
         logging.error("Lexer error line %d: %s\n%s", row, exc, msg)
         if args.debug:
             raise
         else:
             return -1
 
     out = codecs.getwriter("utf-8")(out.buffer)
     print(qml_class, file=out)
 
     return 0
 
 
 if __name__ == "__main__":
     sys.exit(main())
 # vi: ts=4 sw=4 et