def _resolve_placeholder(self, tree, name, include_paths):
self.__find_package_root()
if name == '%s-index' % self.argument_prefix:
if self.index:
path = find_file(self.index, include_paths)
if path is None:
self.error("invalid-config",
"Could not find index file %s" % self.index)
return PageResolutionResult(True, path, None,
self.extension_name)
return PageResolutionResult(True, None, None, self.extension_name)
if self.smart_index:
for path in OrderedSet([self.__package_root]) | self.source_roots:
possible_path = os.path.join(path, name)
if possible_path in self._get_all_sources():
override_path = find_file('%s.markdown' % name,
include_paths)
if override_path:
return PageResolutionResult(True, override_path, None,
None)
return PageResolutionResult(
True, None, self.__get_rel_source_path(possible_path),
None)
return None
def _resolve_placeholder(self, tree, name, include_paths):
self.__find_package_root()
override_path = os.path.join(self.__package_root, name)
if name == '%s-index' % self.argument_prefix:
if self.index:
path = find_file(self.index, include_paths)
if path is None:
self.error("invalid-config",
"Could not find index file %s" % self.index)
return path, self.extension_name
return True, self.extension_name
elif self.smart_index and override_path in self._get_all_sources():
path = find_file('%s.markdown' % name, include_paths)
return path or True, None
return None
def _resolve_placeholder(self, tree, name, include_paths):
ext = os.path.splitext(name)[1]
if ext != '.json':
return None
conf_path = inclusions.find_file(name, include_paths)
if not conf_path:
error(
'invalid-config',
'(%s) Could not find subproject config file %s' %
(self.project.sanitized_name, name))
self.project.add_subproject(name, conf_path)
return PageResolutionResult(True, None, None, None)
def __list_override_pages_cb(self, tree, include_paths):
if not self.smart_index:
return None
self.__find_package_root()
for source in self._get_all_sources():
source_rel = self.__get_rel_source_path(source)
for ext in ['.md', '.markdown']:
override = find_file(source_rel + ext, include_paths)
if override:
self.__overriden_pages.append(
OverridePage(source_rel, override))
break
return self.__overriden_pages
def build(self, sitemap, extensions):
ext_level = -1
extensions = {ext.argument_prefix: ext for ext in extensions.values()}
ext_pages = {}
ext_index = None
extension = None
ext_name = 'core'
sitemap_pages = sitemap.get_all_sources()
self.__all_pages = {}
for name, level in sitemap:
page = None
if level <= ext_level:
self.add_unordered_subpages(extension, ext_index, ext_pages)
extension = None
ext_level = -1
ext_pages = {}
ext_index = None
ext_name = 'core'
if extension:
smart_key = extension.get_possible_path(name)
else:
smart_key = None
if name.endswith('-index'):
ext_name = name[:-6]
extension = extensions.get(ext_name)
if extension is None:
position = sitemap.get_position(name)
error(
'index-extension-not-found',
'No extension named %s for index page' % ext_name,
filename=sitemap.source_file,
lineno=position[0],
column=position[1])
continue
ext_level = level
ext_pages = extension.make_pages()
page = ext_pages['%s-index' % ext_name]
del ext_pages['%s-index' % ext_name]
ext_index = page
elif name in ext_pages:
page = ext_pages[name]
del ext_pages[name]
elif smart_key in ext_pages:
page = ext_pages[smart_key]
del ext_pages[smart_key]
else:
source_file = find_file(name, self.project.include_paths)
if source_file is None:
position = sitemap.get_position(name)
error(
'page-not-found',
'No markdown file found for %s' % name,
filename=sitemap.source_file,
lineno=position[0],
column=position[1])
ext = os.path.splitext(name)[1]
if ext == '.json':
self.project.add_subproject(name, source_file)
page = Page(
name, True, self.project.sanitized_name, 'core')
else:
page = self.parse_page(source_file, ext_name)
page.extension_name = extension.extension_name if extension else 'core'
self.__all_pages[name] = page
subpages = sitemap_pages.get(name, [])
page.subpages = OrderedSet(subpages) | page.subpages
if not page.meta.get('auto-sort', False):
page.pre_sorted = True
if ext_index:
self.add_unordered_subpages(extension, ext_index, ext_pages)
self.root = self.__all_pages[sitemap.index_file]
def test_missing_relpath(self):
self.assertEqual(find_file('yep.md', [self._md_dir]), None)
def test_relpath(self):
path = self._create_md_file('yep.md', 'stuff')
self.assertEqual(find_file('yep.md', [self._md_dir]), path)
def test_abspath(self):
path = self._create_md_file('yep.md', 'stuff')
self.assertEqual(find_file(path, []), path)
def test_missing_abspath(self):
self.assertEqual(find_file('/nope.md', []), None)
def __parse_pages(self, sitemap):
change_tracker = self.app.change_tracker
source_files = []
source_map = {}
placeholders = []
overrides = self.list_override_pages_signal(
self, self.project.include_paths) or []
for override in overrides:
source_files.append(override.file)
source_map[override.file] = override.source_file
for i, fname in enumerate(sitemap.get_all_sources().keys()):
resolved = self.resolve_placeholder_signal(
self, fname, self.project.include_paths)
if resolved is None:
source_file = find_file(fname, self.project.include_paths)
source_files.append(source_file)
if source_file is None:
error('no-such-subpage',
'No markdown file found for %s' % fname,
filename=sitemap.source_file,
lineno=i,
column=0)
source_map[source_file] = fname
else:
resolved, ext_name = resolved
if ext_name:
self.__placeholders[fname] = ext_name
if resolved is not True:
source_files.append(resolved)
source_map[resolved] = fname
else:
if fname not in self.__all_pages:
page = Page(fname, None, '',
self.project.sanitized_name)
page.generated = True
self.__all_pages[fname] = page
placeholders.append(fname)
stale, unlisted = change_tracker.get_stale_files(
source_files, 'user-pages-%s' % self.project.sanitized_name)
old_user_symbols = set()
new_user_symbols = set()
for source_file in stale:
pagename = source_map[source_file]
prev_page = self.__all_pages.get(pagename)
if prev_page:
old_user_symbols |= prev_page.symbol_names
page = self.__parse_page(source_file)
new_user_symbols |= page.symbol_names
newly_listed_symbols = OrderedSet(page.symbol_names)
if prev_page:
newly_listed_symbols -= prev_page.symbol_names
self.stale_symbol_pages(newly_listed_symbols, page)
if prev_page:
page.subpages |= prev_page.subpages
self.__all_pages[pagename] = page
unlisted_pagenames = set()
for source_file in unlisted:
prev_page = None
rel_path = None
for ipath in self.project.include_paths:
rel_path = os.path.relpath(source_file, ipath)
prev_page = self.__all_pages.get(rel_path)
if prev_page:
break
if not prev_page:
continue
old_user_symbols |= prev_page.symbol_names
self.__all_pages.pop(rel_path)
unlisted_pagenames.add(rel_path)
def setup_subpages(pagenames, get_pagename):
"""Setup subpages for pages with names in @pagenames"""
sitemap_pages = sitemap.get_all_sources()
for pagename in pagenames:
page = self.__all_pages[get_pagename(pagename)]
subpages = sitemap_pages.get(get_pagename(pagename), [])
page.subpages = OrderedSet(subpages) | page.subpages
for subpage_name in page.subpages:
if subpage_name not in unlisted_pagenames:
subpage = self.__all_pages[subpage_name]
if not subpage.meta.get('auto-sort', False):
subpage.pre_sorted = True
page.subpages -= unlisted_pagenames
setup_subpages(source_files, lambda x: source_map[x])
setup_subpages(placeholders, lambda x: x)
return old_user_symbols - new_user_symbols
