def __dump_deps_file(self, project): dest = self.config.get('deps_file_dest', None) target = self.config.get('deps_file_target') if dest is None: info("Not dumping deps file") return info("Dumping deps file to %s with target %s" % (dest, target)) destdir = os.path.dirname(dest) if not os.path.exists(destdir): os.makedirs(destdir) empty_targets = [] with open(dest, 'w', encoding='utf-8') as _: _.write(u'%s: ' % target) for dep in self.config.get_dependencies(): empty_targets.append(dep) _.write(u'%s ' % dep.replace(' ', '\\ ')) self.__dump_project_deps_file(project, _, empty_targets) for empty_target in empty_targets: _.write(u'\n\n%s:' % empty_target)
def __persist(self): if self.dry: return info('Persisting database and private files', 'persisting') self.database.persist()
def __dump_deps_file(self): dest = self.config.get('deps_file_dest') target = self.config.get('deps_file_target') if dest is None: info("Not dumping deps file") return info("Dumping deps file to %s with target %s" % (dest, target)) destdir = os.path.dirname(dest) if not os.path.exists(destdir): os.makedirs(destdir) empty_targets = [] with io.open(dest, 'w', encoding='utf-8') as _: _.write(u'%s: ' % target) if self.config: for dep in self.config.get_dependencies(): empty_targets.append(dep) _.write(u'%s ' % dep) if self.doc_tree: for page in self.doc_tree.get_pages().values(): if not page.generated: empty_targets.append(page.source_file) _.write(u'%s ' % page.source_file) for empty_target in empty_targets: _.write(u'\n\n%s:' % empty_target)
def gather_gtk_doc_links(): global GATHERED_GTKDOC_LINKS if GATHERED_GTKDOC_LINKS: return GATHERED_GTKDOC_LINKS = True # XDG_DATA_DIRS is preference-ordered, we reverse so that preferred # links override less-preferred ones for datadir in reversed([XDG_DATA_HOME] + XDG_DATA_DIRS): for path in (os.path.join(datadir, 'devhelp', 'books'), os.path.join(datadir, 'gtk-doc', 'html')): if not os.path.exists(path): info("no gtk doc to gather links from in %s" % path) continue for node in os.listdir(path): dir_ = os.path.join(path, node) if os.path.isdir(dir_): if not parse_devhelp_index(dir_): try: parse_sgml_index(dir_) except IOError: pass
def setup(self): """ Banana banana """ configurable_classes = all_subclasses(Configurable) configured = set() for subclass in configurable_classes: if subclass.parse_config not in configured: subclass.parse_config(self, self.config) configured.add(subclass.parse_config) self.__parse_config() self.doc_tree = DocTree(self.get_private_folder(), self.include_paths) for extension in self.extensions.values(): info('Setting up %s' % extension.extension_name) extension.setup() self.doc_database.flush() sitemap = SitemapParser().parse(self.sitemap_path) self.doc_tree.parse_sitemap(self.change_tracker, sitemap) info("Resolving symbols", 'resolution') self.doc_tree.resolve_symbols(self.doc_database, self.link_resolver) self.doc_database.flush()
def __get_extra_extension_classes(paths): """ Banana banana """ extra_classes = [] wset = pkg_resources.WorkingSet([]) distributions, _ = wset.find_plugins(pkg_resources.Environment(paths)) for dist in distributions: sys.path.append(dist.location) wset.add(dist) for entry_point in wset.iter_entry_points(group='hotdoc.extensions', name='get_extension_classes'): try: activation_function = entry_point.load() classes = activation_function() # pylint: disable=broad-except except Exception as exc: info("Failed to load %s %s" % (entry_point.module_name, exc)) debug(traceback.format_exc()) continue for klass in classes: extra_classes.append(klass) return extra_classes
def _split_repo_url(repo_url): sub_path = '' addr = urllib.parse.urlparse(repo_url) # Avoid blocking on password prompts env = os.environ.copy() env['GIT_ASKPASS'] = '******' while True: try: args = ['git', 'ls-remote', repo_url] info('Checking if {} is a git repo'.format(' '.join(args)), domain='git-uploader') subprocess.check_output(args, env=env, stderr=subprocess.STDOUT) return repo_url, sub_path except subprocess.CalledProcessError as e: info('No; {}'.format(e.output.decode('utf-8')), domain='git-uploader') sub_path = os.path.join(os.path.basename(addr.path), sub_path) addr = urllib.parse.ParseResult(addr.scheme, addr.netloc, os.path.dirname(addr.path), addr.params, addr.query, addr.fragment) if repo_url == addr.geturl(): break repo_url = addr.geturl() return None, None
def format_page(self, page, link_resolver, output, extensions): """ Banana banana """ info('formatting %s' % page.source_file, 'formatting') extension = extensions[page.extension_name] extension.format_page(page, link_resolver, output)
def __persist(self): if self.dry: return info('Persisting database and private files', 'persisting') self.database.persist() self.__dump_deps_file(self.project)
def finalize(self): """ Banana banana """ self.formatted_signal.clear() if self.doc_database is not None: info('Closing database') self.doc_database.close()
def info(self, message, domain=None): """ Shortcut function for `utils.loggable.info` Args: message: see `utils.loggable.info` domain: see `utils.loggable.info` """ if domain is None: domain = self.extension_name info(message, domain)
def __persist(self, project): if self.dry: return info('Persisting database and private files', 'persisting') project.persist() self.database.persist() with open(os.path.join(self.private_folder, 'change_tracker.p'), 'wb') as _: _.write(pickle.dumps(self.change_tracker)) self.__dump_deps_file(project)
def get_extension_classes(sort, extra_extension_paths=None): """ Banana banana """ all_classes = {} deps_map = {} for entry_point in pkg_resources.iter_entry_points( group='hotdoc.extensions', name='get_extension_classes'): if entry_point.module_name == 'hotdoc_c_extension.extensions': continue try: activation_function = entry_point.load() classes = activation_function() # pylint: disable=broad-except except Exception as exc: info("Failed to load %s" % entry_point.module_name, exc) debug(traceback.format_exc()) continue for klass in classes: all_classes[klass.extension_name] = klass if extra_extension_paths: for klass in __get_extra_extension_classes(extra_extension_paths): all_classes[klass.extension_name] = klass klass_list = list(all_classes.values()) if not sort: return klass_list for i, klass in enumerate(klass_list): deps = klass.get_dependencies() topodeps = set() for dep in deps: if dep.dependency_name not in all_classes: if dep.optional: continue else: error( "setup-issue", "Missing dependency %s for %s" % (dep.dependency_name, klass.extension_name)) if dep.is_upstream: topodeps.add(klass_list.index( all_classes[dep.dependency_name])) deps_map[i] = topodeps sorted_class_indices = toposort_flatten(deps_map) sorted_classes = [klass_list[i] for i in sorted_class_indices] return sorted_classes
def gather_gtk_doc_links(): gtkdoc_dir = os.path.join(DATADIR, "gtk-doc", "html") if not os.path.exists(gtkdoc_dir): info("no gtk doc to gather links from in %s" % gtkdoc_dir) return for node in os.listdir(gtkdoc_dir): dir_ = os.path.join(gtkdoc_dir, node) if os.path.isdir(dir_): if not parse_devhelp_index(dir_): try: parse_sgml_index(dir_) except IOError: pass
def format(self, link_resolver, output, extensions): """Banana banana """ info('Formatting documentation tree', 'formatting') self.__setup_folder(output) link_resolver.get_link_signal.connect(self.__get_link_cb) # Page.formatting_signal.connect(self.__formatting_page_cb) # Link.resolving_link_signal.connect(self.__link_referenced_cb) for page in self.walk(): self.format_page(page, link_resolver, output, extensions) link_resolver.get_link_signal.disconnect(self.__get_link_cb) self.__create_navigation_script(output, extensions)
def __create_change_tracker(self): try: self.change_tracker = \ pickle.load(open(os.path.join(self.get_private_folder(), 'change_tracker.p'), 'rb')) if self.change_tracker.hard_dependencies_are_stale(): raise IOError self.incremental = True info("Building incrementally") # pylint: disable=broad-except except Exception: info("Building from scratch") shutil.rmtree(self.get_private_folder(), ignore_errors=True) if self.output: shutil.rmtree(self.output, ignore_errors=True) self.change_tracker = ChangeTracker()
def persist(self): """ Banana banana """ if self.__dry: return info('Persisting database and private files', 'persisting') self.doc_tree.persist() self.doc_database.persist() pickle.dump(self.change_tracker, open(os.path.join(self.get_private_folder(), 'change_tracker.p'), 'wb')) self.__dump_deps_file()
def setup(self) -> None: super().setup() if not self._data_file: info('Meson refman extension DISABLED') return raw = Path(self._data_file).read_text(encoding='utf-8') self._data = loads(raw) # Register formater for ext in self.project.extensions.values(): ext = T.cast(Extension, ext) ext.formatter.formatting_page_signal.connect( self._formatting_page_cb) info('Meson refman extension LOADED')
def persist(self): """ Banana banana """ if self.__dry: return info('Persisting database and private files', 'persisting') self.doc_tree.persist() self.doc_database.persist() pickle.dump( self.change_tracker, open(os.path.join(self.get_private_folder(), 'change_tracker.p'), 'wb')) self.__dump_deps_file()
def parse_config(doc_repo, config): """Banana banana """ html_theme = config.get('html_theme', 'default') if html_theme == 'default': default_theme = os.path.join(HERE, '..', 'default_theme-%s' % THEME_VERSION) html_theme = os.path.abspath(default_theme) info("Using default theme") else: html_theme = config.get_path('html_theme') info("Using theme located at %s" % html_theme) HtmlFormatter.theme_path = html_theme HtmlFormatter.add_anchors = bool(config.get("html_add_anchors")) HtmlFormatter.number_headings = bool( config.get("html_number_headings"))
def __create_change_tracker(self, disable_incremental): if not disable_incremental: try: with open(os.path.join(self.private_folder, 'change_tracker.p'), 'rb') as _: self.change_tracker = pickle.loads(_.read()) if self.change_tracker.hard_dependencies_are_stale(): raise IOError self.incremental = True info("Building incrementally") # pylint: disable=broad-except except Exception: pass if not self.incremental: info("Building from scratch") shutil.rmtree(self.private_folder, ignore_errors=True) self.change_tracker = ChangeTracker()
def parse_config(doc_repo, config): """Banana banana """ html_theme = config.get('html_theme', 'default') if html_theme == 'default': default_theme = os.path.join(HERE, '..', 'default_theme-%s' % THEME_VERSION) html_theme = os.path.abspath(default_theme) info("Using default theme") else: html_theme = config.get_path('html_theme') info("Using theme located at %s" % html_theme) HtmlFormatter.theme_path = html_theme HtmlFormatter.extra_theme_path = config.get_path('html_extra_theme') HtmlFormatter.add_anchors = bool(config.get("html_add_anchors")) HtmlFormatter.number_headings = bool( config.get("html_number_headings"))
def parse_config(self, config): self.c_sources = config.get_sources('gst_c') self.cache_file = config.get('gst_cache_file') self.plugin = config.get('gst_plugin_name') self.list_plugins_page = config.get('gst_list_plugins_page', None) info('Parsing config!') self.cache = {} if self.cache_file: self.cache = GstExtension.__caches.get(self.cache_file) if not self.cache: try: with open(self.cache_file) as _: self.cache = json.load(_) except FileNotFoundError: pass if self.cache is None: self.cache = {} GstExtension.__caches[self.cache_file] = self.cache super().parse_config(config)
def setup(self): """ Banana banana """ info('Setting up %s' % self.project_name, 'project') for extension in list(self.extensions.values()): info('Setting up %s' % extension.extension_name) extension.setup() sitemap = SitemapParser().parse(self.sitemap_path) self.tree.build(sitemap, self.extensions) info("Resolving symbols", 'resolution') self.tree.resolve_symbols(self.app.database, self.app.link_resolver)
def setup(self): """ Banana banana """ info('Setting up %s' % self.project_name, 'project') self.app.database.comment_updated_signal.connect( self.__comment_updated_cb) for extension in list(self.extensions.values()): info('Setting up %s' % extension.extension_name) extension.setup() self.app.database.comment_updated_signal.disconnect( self.__comment_updated_cb) sitemap = SitemapParser().parse(self.sitemap_path) self.tree.parse_sitemap(sitemap) self.page_map.update({p: self for p in self.tree.get_pages().values()}) info("Resolving symbols", 'resolution') self.tree.resolve_symbols(self.app.database, self.app.link_resolver)
def finalize(self): if self.database is not None: info('Closing database') self.database.close() self.project.finalize()