def tearDown(self): self.__remove_tmp_dirs() TestExtension.symbols = [] TestExtension.comments = [] Logger.fatal_warnings = False Logger.silent = False Logger.reset()
def test_warning(self): test_journal = [] Logger.warn('baz', 'This baz is bad') test_journal.append( LogEntry(WARNING, 'bar', 'baz', 'This baz is bad')) self.assertListEqual(Logger.journal, test_journal)
def test_cannot_ignore_error(self): test_journal = [] Logger.add_ignored_code('foo') with self.assertRaises(FooError): Logger.error('foo', 'This foo is bad I have to care') test_journal.append(LogEntry(ERROR, 'bar', 'foo', 'This foo is bad I have to care')) self.assertListEqual(Logger.journal, test_journal)
def test_error(self): test_journal = [] with self.assertRaises(FooError) as cm: Logger.error('foo', 'This foo is bad') self.assertEqual(cm.exception.message, 'This foo is bad') test_journal.append(LogEntry(ERROR, 'bar', 'foo', 'This foo is bad')) self.assertListEqual(Logger.journal, test_journal)
def test_cannot_ignore_error(self): test_journal = [] Logger.add_ignored_code('foo') with self.assertRaises(FooError): Logger.error('foo', 'This foo is bad I have to care') test_journal.append( LogEntry(ERROR, 'bar', 'foo', 'This foo is bad I have to care')) self.assertListEqual(Logger.journal, test_journal)
def setUp(self): here = os.path.dirname(__file__) Logger.reset() self.__md_dir = os.path.abspath( os.path.join(here, 'tmp-markdown-files')) self.__output_dir = os.path.abspath(os.path.join(here, 'html')) self.__remove_tmp_dirs() os.mkdir(self.__md_dir) Logger.silent = True
def test_fatal_warnings(self): Logger.fatal_warnings = True test_journal = [] with self.assertRaises(BazError) as cm: Logger.warn('baz', 'This baz is bad') self.assertEqual(cm.exception.message, 'This baz is bad') test_journal.append(LogEntry(ERROR, 'bar', 'baz', 'This baz is bad')) self.assertListEqual(Logger.journal, test_journal)
def test_fatal_warnings(self): Logger.fatal_warnings = True test_journal = [] with self.assertRaises(BazError) as cm: Logger.warn('baz', 'This baz is bad') self.assertEqual(cm.exception.message, 'This baz is bad') test_journal.append( LogEntry(ERROR, 'bar', 'baz', 'This baz is bad')) self.assertListEqual(Logger.journal, test_journal)
def setUp(self): here = os.path.dirname(__file__) Logger.reset() self.__md_dir = os.path.abspath(os.path.join( here, 'tmp-markdown-files')) self.__output_dir = os.path.abspath(os.path.join( here, 'html')) self.__remove_tmp_dirs() os.mkdir(self.__md_dir) Logger.silent = True
def test_redefined_symbol(self): self.database.create_symbol(FunctionSymbol, unique_name='foo') Logger.fatal_warnings = True Logger.raise_on_fatal_warnings = True Logger.silent = True with self.assertRaises(RedefinedSymbolException): self.database.create_symbol(FunctionSymbol, unique_name='foo') Logger.fatal_warnings = False Logger.silent = False Logger.reset()
def execute_command(parser, config, ext_classes): """ Banana banana """ res = 0 cmd = config.get('command') get_private_folder = config.get('get_private_folder', False) if cmd == 'help': parser.print_help() elif cmd == 'run' or get_private_folder: # git.mk backward compat app = Application(ext_classes) try: app.parse_config(config) if get_private_folder: print(app.private_folder) return res res = app.run() except HotdocException: res = len(Logger.get_issues()) except Exception: # pylint: disable=broad-except print("An unknown error happened while building the documentation" " and hotdoc cannot recover from it. Please report " "a bug with this error message and the steps to " "reproduce it") traceback.print_exc() res = 1 finally: app.finalize() elif cmd == 'init': try: create_default_layout(config) except HotdocException: res = 1 elif cmd == 'conf': config.dump(conf_file=config.get('output_conf_file', None)) elif cmd is None: if config.get('version'): print(VERSION) elif config.get('makefile_path'): here = os.path.dirname(__file__) path = os.path.join(here, 'utils', 'hotdoc.mk') print(os.path.abspath(path)) elif config.get('get_conf_path'): key = config.get('get_conf_path') path = config.get_path(key, rel_to_cwd=True) if path is not None: print(path) elif config.get('get_conf_key'): key = config.get('get_conf_key') value = config.get(key, None) if value is not None: print(value) else: parser.print_usage() else: parser.print_usage() return res
def run(args): """ Banana banana """ res = 0 doc_repo = DocRepo() # pylint: disable=broad-except try: doc_repo.load_command_line(args) doc_repo.setup() doc_repo.format() doc_repo.persist() except HotdocException: res = len(Logger.get_issues()) except Exception: print("An unknown error happened while building the documentation" " and hotdoc cannot recover from it. Please report " "a bug with this error message and the steps to " "reproduce it") traceback.print_exc() res = 1 finally: doc_repo.finalize() return res
def run(args): """ Banana banana """ res = 0 doc_repo = DocRepo() # pylint: disable=broad-except try: doc_repo.load_command_line(args) doc_repo.setup() doc_repo.format() doc_repo.persist() except HotdocException: res = len(Logger.get_issues()) except Exception: print ("An unknown error happened while building the documentation" " and hotdoc cannot recover from it. Please report " "a bug with this error message and the steps to " "reproduce it") traceback.print_exc() res = 1 finally: doc_repo.finalize() return res
def setUp(self): self._test_dir = os.path.join(os.path.dirname(__file__), 'tmptestdir') try: shutil.rmtree(self._test_dir) except FileNotFoundError: pass os.mkdir(self._test_dir) os.chdir(self._test_dir) Logger.reset() self.__md_dir = os.path.abspath( os.path.join(self._test_dir, 'tmp-markdown-files')) self.__output_dir = os.path.abspath( os.path.join(self._test_dir, 'html')) self.__remove_tmp_dirs() os.mkdir(self.__md_dir) Logger.silent = True
def test_checkpoint(self): test_journal = [] Logger.warn('baz', 'This baz is bad') test_journal.append(LogEntry(WARNING, 'bar', 'baz', 'This baz is bad')) self.assertListEqual(Logger.journal, test_journal) self.assertListEqual(Logger.since_checkpoint(), test_journal) Logger.checkpoint() self.assertListEqual(Logger.since_checkpoint(), []) Logger.warn('baz', 'This baz is really bad') test_journal.append( LogEntry(WARNING, 'bar', 'baz', 'This baz is really bad')) partial_journal = [ LogEntry(WARNING, 'bar', 'baz', 'This baz is really bad') ] self.assertListEqual(Logger.journal, test_journal) self.assertListEqual(Logger.since_checkpoint(), partial_journal)
def test_checkpoint(self): test_journal = [] Logger.warn('baz', 'This baz is bad') test_journal.append( LogEntry(WARNING, 'bar', 'baz', 'This baz is bad')) self.assertListEqual(Logger.journal, test_journal) self.assertListEqual(Logger.since_checkpoint(), test_journal) Logger.checkpoint() self.assertListEqual(Logger.since_checkpoint(), []) Logger.warn('baz', 'This baz is really bad') test_journal.append(LogEntry(WARNING, 'bar', 'baz', 'This baz is really bad')) partial_journal = [LogEntry(WARNING, 'bar', 'baz', 'This baz is really bad')] self.assertListEqual(Logger.journal, test_journal) self.assertListEqual(Logger.since_checkpoint(), partial_journal)
def setUp(self): Logger.reset() Logger.silent = True Logger.register_error_code('foo', FooError, 'bar') Logger.register_warning_code('baz', BazError, 'bar')
def test_ignore_warning(self): Logger.add_ignored_code('baz') Logger.warn('baz', 'This baz is bad but I do not care') self.assertListEqual(Logger.journal, [])
def test_unknown_codes(self): with self.assertRaises(AssertionError): Logger.warn('does-not-exist', 'Should not exist') with self.assertRaises(AssertionError): Logger.error('does-not-exist', 'Should not exist')
class SitemapDuplicateError(HotdocSourceException): """ Raised when the same file was listed multiple times in a sitemap file. """ pass class SitemapError(HotdocSourceException): """ Generic sitemap error. """ pass Logger.register_error_code('bad-indent', IndentError, domain='sitemap') Logger.register_error_code('sitemap-duplicate', SitemapDuplicateError, domain='sitemap') Logger.register_error_code('sitemap-error', SitemapError, domain='sitemap') # pylint: disable=too-few-public-methods class StandaloneParser(object): """ Banana banana """ pass class Sitemap(object):
from hotdoc.core.extension import Extension from hotdoc.core.formatter import Formatter from hotdoc.core.tree import Page from hotdoc.core.exceptions import HotdocException from hotdoc.utils.loggable import error, Logger class NoSuchLicenseException(HotdocException): """ Raised when an unknown license is used """ pass Logger.register_error_code('no-such-license', NoSuchLicenseException, domain='license-extension') DESCRIPTION =\ """ This extension helps licensing your hotdoc project """ HERE = os.path.abspath(os.path.dirname(__file__)) DATA_DIR = os.path.join(HERE, 'data') BASE_COPYRIGHT_SCHEMA = {'name': And(str, len), Optional('email'): And(str, len), Optional('years', default=[]): Schema([Use(int)])}
from hotdoc.utils.setup_utils import THEME_VERSION from hotdoc.utils.utils import OrderedSet from hotdoc.utils.utils import id_from_text from hotdoc.core.exceptions import HotdocException from hotdoc.utils.loggable import Logger, warn, info class HtmlFormatterBadLinkException(HotdocException): """ Raised when a produced html page contains an empty local link to nowhere. """ pass Logger.register_warning_code('bad-local-link', HtmlFormatterBadLinkException, domain='html-formatter') HERE = os.path.dirname(__file__) # pylint: disable=too-few-public-methods class TocSection(object): """ Banana banana """ def __init__(self, summaries, name): self.summaries = summaries self.name = name self.id_ = ''.join(name.split())
class PageNotFoundException(HotdocSourceException): """ Raised when a subpage listed in the sitemap file could not be found in any of the include paths. """ pass class IndexExtensionNotFoundException(HotdocSourceException): """ Raised when the extension was not found for an index placeholder """ pass Logger.register_error_code('index-extension-not-found', IndexExtensionNotFoundException, domain='doc-tree') Logger.register_error_code('page-not-found', PageNotFoundException, domain='doc-tree') Logger.register_warning_code('invalid-page-metadata', InvalidPageMetadata, domain='doc-tree') Logger.register_warning_code('markdown-bad-link', HotdocSourceException) # pylint: disable=too-many-instance-attributes class Page: "Banana banana" meta_schema = {Optional('title'): And(str, len), Optional('short-description'): And(str), Optional('description'): And(str), Optional('render-subpages'): bool, Optional('auto-sort'): bool,
""" import re import cgi from itertools import izip_longest from hotdoc.core.comment_block import (Comment, Annotation, Tag, comment_from_tag) from hotdoc.core.exceptions import HotdocSourceException from hotdoc.utils.configurable import Configurable from hotdoc.parsers import cmark from hotdoc.utils.loggable import Logger, warn Logger.register_warning_code('gtk-doc-bad-link', HotdocSourceException) Logger.register_warning_code('gtk-doc-bad-syntax', HotdocSourceException) # http://stackoverflow.com/questions/434287/what-is-the-most-pythonic-way-to-iterate-over-a-list-in-chunks def _grouper(iterable, n_args, fillvalue=None): """ Banana banana """ args = [iter(iterable)] * n_args return izip_longest(*args, fillvalue=fillvalue) # pylint: disable=too-few-public-methods class GtkDocParser(object): """
from hotdoc.core.symbols import * from hotdoc.core.base_extension import BaseExtension, ExtDependency from hotdoc.core.base_formatter import Formatter from hotdoc.core.file_includer import find_md_file from hotdoc.core.links import Link, LinkResolver from hotdoc.core.doc_tree import Page from hotdoc.core.comment_block import Comment from hotdoc.core.exceptions import BadInclusionException from hotdoc.utils.loggable import warn, Logger from .gi_html_formatter import GIHtmlFormatter from .gi_annotation_parser import GIAnnotationParser from .fundamentals import PY_FUNDAMENTALS, JS_FUNDAMENTALS Logger.register_warning_code('missing-gir-include', BadInclusionException, 'gi-extension') class Flag (object): def __init__ (self, nick, link): self.nick = nick self.link = link class RunLastFlag (Flag): def __init__(self): Flag.__init__ (self, "Run Last", "https://developer.gnome.org/gobject/unstable/gobject-Signals.html#G-SIGNAL-RUN-LAST:CAPS") class RunFirstFlag (Flag):
yaml.add_constructor(yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG, _no_duplicates_constructor) yaml.add_constructor(u'tag:yaml.org,2002:str', _custom_str_constructor) class DocTreeNoSuchPageException(HotdocSourceException): """ Raised when a subpage listed in the sitemap file could not be found in any of the include paths. """ pass Logger.register_error_code('no-such-subpage', DocTreeNoSuchPageException, domain='doc-tree') Logger.register_warning_code('invalid-page-metadata', InvalidPageMetadata, domain='doc-tree') Logger.register_warning_code('markdown-bad-link', HotdocSourceException) # pylint: disable=too-many-instance-attributes class Page(object): "Banana banana" meta_schema = {Optional('title'): And(unicode, len), Optional('symbols'): Schema([And(unicode, len)]), Optional('short-description'): And(unicode, len)} resolving_symbol_signal = Signal() formatting_signal = Signal()
from docutils.core import publish_parts from docutils.utils import error_reporting from docutils import nodes from hotdoc.core.comment_block import Comment from hotdoc.core.exceptions import HotdocSourceException from hotdoc.utils.loggable import Logger, warn from docutils.statemachine import ViewList from docutils.writers.html4css1 import Writer as HtmlWriter from docutils.parsers.rst import roles, directives from xml.sax.saxutils import unescape from hotdoc_python_extension.napoleon import Config from hotdoc_python_extension.napoleon import docstring Logger.register_warning_code('python-doc-issue', HotdocSourceException) _google_typed_arg_regex = re.compile(r'\s*(.+?)\s*\(\s*(.+?)\s*\)') class MyGoogleDocString(docstring.GoogleDocstring): def __init__(self, *args, **kwargs): self.param_fields = [] self.attribute_fields = [] self.return_fields = [] docstring.GoogleDocstring.__init__(self, *args, **kwargs) def _consume_field(self, parse_type=True, prefer_type=False): line = next(self._line_iter) before, colon, after = self._partition_field_on_colon(line)
import os from collections import defaultdict from lxml import etree import networkx as nx from hotdoc.core.symbols import QualifiedSymbol from hotdoc.core.exceptions import BadInclusionException from hotdoc.extensions.gi.utils import * from hotdoc.extensions.gi.fundamentals import FUNDAMENTALS from hotdoc.utils.loggable import warn, Logger Logger.register_warning_code('missing-gir-include', BadInclusionException, 'gi-extension') ''' Names of boilerplate GObject macros we don't want to expose ''' SMART_FILTERS = set() def __generate_smart_filters(id_prefixes, sym_prefixes, node): sym_prefix = node.attrib['{%s}symbol-prefix' % NS_MAP['c']] SMART_FILTERS.add(('%s_IS_%s' % (sym_prefixes, sym_prefix)).upper()) SMART_FILTERS.add(('%s_TYPE_%s' % (sym_prefixes, sym_prefix)).upper()) SMART_FILTERS.add(('%s_%s' % (sym_prefixes, sym_prefix)).upper()) SMART_FILTERS.add(('%s_%s_CLASS' % (sym_prefixes, sym_prefix)).upper()) SMART_FILTERS.add(('%s_IS_%s_CLASS' % (sym_prefixes, sym_prefix)).upper()) SMART_FILTERS.add(('%s_%s_GET_CLASS' % (sym_prefixes, sym_prefix)).upper()) SMART_FILTERS.add(('%s_%s_GET_IFACE' % (sym_prefixes, sym_prefix)).upper()) __HIERARCHY_GRAPH = nx.DiGraph()
from hotdoc.core.base_extension import BaseExtension from hotdoc.core.base_formatter import Formatter from hotdoc.core.doc_tree import Page from hotdoc.core.exceptions import HotdocException from hotdoc.utils.loggable import error, warn, Logger class NoSuchLicenseException(HotdocException): """ Raised when an unknown license is used """ pass Logger.register_error_code('no-such-license', NoSuchLicenseException, domain='license-extension') DESCRIPTION=\ """ This extension helps licensing your hotdoc project """ HERE = os.path.abspath(os.path.dirname(__file__)) DATA_DIR = os.path.join(HERE, 'data') base_copyright_schema = {'name': And(unicode, len), Optional('email'): And(unicode, len), Optional('years'): Schema([Use(int)])}
Utilities and baseclasses for extensions """ import os from collections import OrderedDict from collections import defaultdict from hotdoc.core.inclusions import find_file from hotdoc.core.symbols import Symbol from hotdoc.core.tree import Page, OverridePage, PageResolutionResult from hotdoc.core.formatter import Formatter from hotdoc.utils.configurable import Configurable from hotdoc.core.exceptions import InvalidOutputException from hotdoc.utils.loggable import debug, info, warn, error, Logger from hotdoc.utils.utils import OrderedSet, DefaultOrderedDict Logger.register_warning_code('unavailable-symbol-listed', InvalidOutputException, 'extension') # pylint: disable=too-few-public-methods class ExtDependency: """ Represents a dependency on another extension. If not satisfied, the extension will not be instantiated. See the `Extension.get_dependencies` static method documentation for more information. Attributes: dependency_name: str, the name of the extension depended on. is_upstream: bool, if set to true hotdoc will arrange for
import re from hotdoc.core.exceptions import HotdocSourceException from hotdoc.core.extension import Extension from hotdoc.core.tree import Page from hotdoc.core.project import Project from hotdoc.run_hotdoc import Application from hotdoc.core.formatter import Formatter from hotdoc.utils.loggable import Logger, warn, info import typing as T if T.TYPE_CHECKING: import argparse Logger.register_warning_code('unknown-refman-link', HotdocSourceException, 'refman-links') class RefmanLinksExtension(Extension): extension_name = 'refman-links' argument_prefix = 'refman' def __init__(self, app: Application, project: Project): self.project: Project super().__init__(app, project) self._data_file: T.Optional[Path] = None self._data: T.Dict[str, str] = {} @staticmethod def add_arguments(parser: 'argparse.ArgumentParser'): group = parser.add_argument_group(
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:hotdoc="uri:hotdoc"> <xsl:variable name="subpages" select="hotdoc:subpages()" /> <xsl:template match="subpages"> <xsl:apply-templates select="$subpages" /> </xsl:template> <xsl:template match="@*|node()"> <xsl:copy> <xsl:apply-templates select="@*|node()"/> </xsl:copy> </xsl:template> </xsl:stylesheet>''') Logger.register_warning_code('bad-local-link', FormatterBadLinkException, domain='html-formatter') Logger.register_warning_code('no-image-src', FormatterBadLinkException, domain='html-formatter') Logger.register_warning_code('bad-image-src', FormatterBadLinkException, domain='html-formatter') Logger.register_warning_code('download-theme-error', HotdocException, domain='html-formatter') HERE = os.path.dirname(__file__) def _download_progress_cb(blocknum, blocksize, totalsize):
def test_ignore_domain(self): Logger.add_ignored_domain('bar') Logger.warn('baz', 'This baz is bad but I do not care') self.assertListEqual(Logger.journal, []) with self.assertRaises(FooError): Logger.error('foo', 'This foo is bad I need to care')
from hotdoc.utils.loggable import info, Logger, error from hotdoc.utils.utils import OrderedSet from hotdoc.core.extension import Extension from hotdoc.core.symbols import ClassSymbol, QualifiedSymbol, PropertySymbol, \ SignalSymbol, ReturnItemSymbol, ParameterSymbol, Symbol from hotdoc.parsers.gtk_doc import GtkDocParser from hotdoc.extensions.c.utils import CCommentExtractor from hotdoc.core.exceptions import HotdocSourceException from hotdoc.core.formatter import Formatter from hotdoc.core.comment import Comment from hotdoc.extensions.gi.gi_extension import WritableFlag, ReadableFlag, \ ConstructFlag, ConstructOnlyFlag from hotdoc.extensions.gi.gtkdoc_links import gather_gtk_doc_links from hotdoc.extensions.devhelp.devhelp_extension import TYPE_MAP Logger.register_warning_code('signal-arguments-mismatch', HotdocSourceException, 'gst-extension') DESCRIPTION =\ """ Extract gstreamer plugin documentation from sources and built plugins. """ def _cleanup_package_name(package_name): return package_name.strip('git').strip('release').strip( 'prerelease').strip('GStreamer').strip('Plug-ins').strip(' ') def create_hierarchy(element_dict):
from hotdoc.core.formatter import Formatter from hotdoc.utils.configurable import Configurable from hotdoc.core.exceptions import InvalidPageMetadata, InvalidOutputException from hotdoc.utils.loggable import debug, info, warn, error, Logger from hotdoc.utils.utils import OrderedSet, DefaultOrderedDict class SymbolListedTwiceException(InvalidPageMetadata): pass class InvalidRelocatedSourceException(InvalidPageMetadata): pass Logger.register_warning_code( 'unavailable-symbol-listed', InvalidOutputException, 'extension') Logger.register_warning_code( 'output-page-conflict', InvalidOutputException, 'extension') Logger.register_warning_code( 'symbol-listed-twice', SymbolListedTwiceException, 'extension') Logger.register_warning_code( 'invalid-relocated-source', InvalidRelocatedSourceException, 'extension') # pylint: disable=too-few-public-methods class ExtDependency: """ Represents a dependency on another extension. If not satisfied, the extension will not be instantiated.
yaml.add_constructor(yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG, _no_duplicates_constructor) yaml.add_constructor(u'tag:yaml.org,2002:str', _custom_str_constructor) class DocTreeNoSuchPageException(HotdocSourceException): """ Raised when a subpage listed in the sitemap file could not be found in any of the include paths. """ pass Logger.register_error_code('no-such-subpage', DocTreeNoSuchPageException, domain='doc-tree') Logger.register_error_code('invalid-page-metadata', InvalidPageMetadata, domain='doc-tree') # pylint: disable=too-many-instance-attributes class Page(object): "Banana banana" meta_schema = {Optional('title'): And(unicode, len), Optional('symbols'): Schema([And(unicode, len)]), Optional('short-description'): And(unicode, len)} resolving_symbol_signal = Signal() formatting_signal = Signal() def __init__(self, source_file, ast, meta=None, raw_contents=None):
if ast_node.kind == clang.cindex.TypeKind.POINTER and \ ast_node.get_pointee().get_result().kind != \ clang.cindex.TypeKind.INVALID: return True return False def info(message): core_info(message, domain='c-extension') def debug(message): core_debug(message, domain='c-extension') Logger.register_warning_code('clang-diagnostic', ParsingException, 'c-extension') Logger.register_warning_code('clang-heisenbug', ParsingException, 'c-extension') Logger.register_warning_code('clang-flags', ParsingException, 'c-extension') Logger.register_warning_code('bad-c-inclusion', BadInclusionException, 'c-extension') Logger.register_warning_code('clang-headers-not-found', HotdocException, 'c-extension') CLANG_HEADERS_WARNING = ( 'Did not find clang headers. Please report a bug with the output of the' '\'llvm-config --version\' and \'llvm-config --prefix\' commands')
from lxml import etree import lxml.html from hotdoc.core.exceptions import InvalidOutputException from hotdoc.utils.loggable import info as core_info, Logger from hotdoc.extensions.search.trie import Trie from hotdoc.utils.utils import OrderedSet def info(message): core_info(message, domain='search-extension') Logger.register_warning_code('invalid-html', InvalidOutputException, 'search-extension') SECTIONS_SELECTOR = ('./div[@id]') INITIAL_SELECTOR = ('.//div[@id="main"]') TITLE_SELECTOR = ('./h1|h2|h2|h3|h4|h5|h6') TOK_REGEX = re.compile(r'[a-zA-Z_][a-zA-Z0-9_\.]*[a-zA-Z0-9_]*') def get_sections(root, selector='./div[@id]'): return root.xpath(selector) def parse_content(section, stop_words, selector='.//p'):
def run(args, verbose=False): """ Banana banana """ parser = argparse.ArgumentParser( formatter_class=argparse.RawDescriptionHelpFormatter, add_help=False) parser.add_argument("--extra-extension-path", action="append", default=[], dest="extra_extension_path", help="An extra extension path to use") parser.add_argument('--conf-file', help='Path to the config file', dest='conf_file') tmpargs, _args = parser.parse_known_args(args) json_conf = None if tmpargs.conf_file: json_conf = load_config_json(tmpargs.conf_file) tmpargs.extra_extension_path += json_conf.get('extra_extension_path', []) # We only get these once, doing this now means all # installed extensions will show up as Configurable subclasses. try: ext_classes = get_extension_classes( sort=True, extra_extension_paths=tmpargs.extra_extension_path) except HotdocException: return 1 parser.add_argument('command', action="store", choices=('run', 'conf', 'init', 'help'), nargs="?") parser.add_argument('--output-conf-file', help='Path where to save the updated conf' ' file', dest='output_conf_file') parser.add_argument('--init-dir', help='Directory to initialize', dest='init_dir') parser.add_argument('--version', help="Print version and exit", action="store_true") parser.add_argument('--makefile-path', help="Print path to includable " "Makefile and exit", action="store_true") parser.add_argument("--get-conf-key", action="store", help="print the value for a configuration " "key") parser.add_argument("--get-conf-path", action="store", help="print the value for a configuration " "path") parser.add_argument("--get-private-folder", action="store_true", help="get the path to hotdoc's private " "folder") parser.add_argument("--has-extension", action="append", dest="has_extensions", default=[], help="Check if a given extension is available") parser.add_argument("--list-extensions", action="store_true", dest="list_extensions", help="Print " "available extensions") parser.add_argument("-", action="store_true", help="Separator to allow finishing a list" " of arguments before a command", dest="whatever") add_args_methods = set() for klass in all_subclasses(Configurable): if klass.add_arguments not in add_args_methods: klass.add_arguments(parser) add_args_methods.add(klass.add_arguments) known_args, _ = parser.parse_known_args(args) defaults = {} actual_args = {} for key, value in list(dict(vars(known_args)).items()): if value != parser.get_default(key): actual_args[key] = value if parser.get_default(key) is not None: defaults[key] = value if known_args.has_extensions: res = 0 for extension_name in known_args.has_extensions: found = False for klass in ext_classes: if klass.extension_name == extension_name: found = True if verbose: print("Extension '%s'... FOUND." % extension_name) if not found: if verbose: print("Extension '%s'... NOT FOUND." % extension_name) res = 1 return res if known_args.list_extensions: print("Extensions:") extensions = [e.extension_name for e in ext_classes] for extension in sorted(extensions): print(" - %s " % extension) return 0 if known_args.command != 'init': conf_file = actual_args.get('conf_file') if conf_file is None and os.path.exists('hotdoc.json'): conf_file = 'hotdoc.json' else: conf_file = '' config = Config(command_line_args=actual_args, conf_file=conf_file, defaults=defaults, json_conf=json_conf) Logger.parse_config(config) return execute_command(parser, config, ext_classes)
"""GitUploadExtension""" import os import shutil import subprocess from subprocess import check_output as call import urllib.parse import appdirs from hotdoc.utils.utils import recursive_overwrite from hotdoc.core.extension import Extension from hotdoc.core.exceptions import HotdocException from hotdoc.utils.loggable import Logger, warn Logger.register_warning_code('no-local-repository', HotdocException, domain='git-uploader') Logger.register_warning_code('dirty-local-repository', HotdocException, domain='git-uploader') Logger.register_warning_code('git-error', HotdocException, domain='git-uploader') DESCRIPTION =\ """ An extension to upload the result of a hotdoc build to git a repository. It can be used to upload to github pages for example. """
if ast_node.kind == cindex.TypeKind.POINTER and \ ast_node.get_pointee().get_result().kind != \ cindex.TypeKind.INVALID: return True return False def info(message): core_info(message, domain='c-extension') def debug(message): core_debug(message, domain='c-extension') Logger.register_warning_code('clang-diagnostic', ParsingException, 'c-extension') Logger.register_warning_code('clang-heisenbug', ParsingException, 'c-extension') Logger.register_warning_code('clang-flags', ParsingException, 'c-extension') Logger.register_warning_code('bad-c-inclusion', BadInclusionException, 'c-extension') Logger.register_warning_code('clang-headers-not-found', HotdocException, 'c-extension') CLANG_HEADERS_WARNING = ( 'Did not find clang headers. Please report a bug with the output of the' '\'llvm-config --version\' and \'llvm-config --prefix\' commands') def get_clang_headers(): version = subprocess.check_output(['llvm-config',
# pylint: disable=missing-docstring import json from hotdoc.core.exceptions import HotdocSourceException from hotdoc.utils.loggable import Logger, warn from hotdoc.core.extension import Extension DESCRIPTION =\ """ This extension allows to warn about missing `Since` markers in newly added API. """ Logger.register_warning_code('missing-since-marker', HotdocSourceException, 'check-missing-since-markers') class CheckMissingSinceMarkersExtension(Extension): extension_name = 'check-missing-since-markers' def __init__(self, app, project): Extension.__init__(self, app, project) self.__symbols_database = None @staticmethod def add_arguments(parser): group = parser.add_argument_group('since-markers-check-extension', DESCRIPTION) group.add_argument("--previous-symbol-index")
from lxml import etree import lxml.html from collections import defaultdict from hotdoc.core.exceptions import InvalidOutputException from hotdoc.utils.loggable import info as core_info, warn, Logger from hotdoc.extensions.search.trie import Trie from hotdoc.utils.utils import OrderedSet def info(message): core_info(message, domain='search-extension') Logger.register_warning_code('invalid-html', InvalidOutputException, 'search-extension') SECTIONS_SELECTOR=( './div[@id]' ) INITIAL_SELECTOR=( './/div[@id="main"]' ) TITLE_SELECTOR=( './ul[@class="base_symbol_header"]' '/li' '/h3' '/span' '/code'