def load_config(filename, **kwargs):
"""
Read the config.yml file and create the Translator object.
"""
config = yaml_load(filename, root=MooseDocs.ROOT_DIR)
# Replace 'default' and 'disable' key in Extensions to allow for recursive_update to accept command line
for key in config.get('Extensions', dict()).keys():
if config['Extensions'][key] == 'default':
config['Extensions'][key] = dict()
if config['Extensions'][key] == 'disable':
config['Extensions'][key] = dict(active=False)
# Apply command-line key value pairs
recursive_update(config, kwargs)
extensions = _yaml_load_extensions(config)
reader = _yaml_load_object('Reader', config, DEFAULT_READER)
renderer = _yaml_load_object('Renderer', config, DEFAULT_RENDERER)
content = _yaml_load_content(config, reader.EXTENSIONS)
executioner = _yaml_load_object('Executioner', config, DEFAULT_EXECUTIONER)
translator = _yaml_load_object('Translator', config, DEFAULT_TRANSLATOR,
content, reader, renderer, extensions, executioner)
return translator, config
def load_config(filename, **kwargs):
"""
Read the config.yml file and create the Translator object.
"""
config = yaml_load(filename, root=MooseDocs.ROOT_DIR)
recursive_update(config, kwargs)
extensions = _yaml_load_extensions(config)
reader = _yaml_load_object('Reader', config, DEFAULT_READER)
renderer = _yaml_load_object('Renderer', config, DEFAULT_RENDERER)
content = _yaml_load_content(config, reader.EXTENSIONS)
executioner = _yaml_load_object('Executioner', config, DEFAULT_EXECUTIONER)
translator = _yaml_load_object('Translator', config, DEFAULT_TRANSLATOR,
content, reader, renderer, extensions, executioner)
return translator, config
def _target(self, nodes, barrier, page_attributes, read, tokenize, render, write):
"""Target function for multiprocessing.Process() calls."""
if read:
for node in nodes:
self._page_content[node.uid] = self.read(node)
page_attributes[node.uid] = node.attributes
barrier.wait()
self._updateAttributes(page_attributes)
if tokenize:
for node in nodes:
mooseutils.recursive_update(node.attributes, page_attributes[node.uid])
self._page_ast[node.uid] = self.tokenize(node, self._page_content[node.uid])
page_attributes[node.uid] = node.attributes
barrier.wait()
self._updateAttributes(page_attributes)
if render:
for node in nodes:
mooseutils.recursive_update(node.attributes, page_attributes[node.uid])
self._page_result[node.uid] = self.render(node, self._page_ast[node.uid])
page_attributes[node.uid] = node.attributes
barrier.wait()
self._updateAttributes(page_attributes)
if write:
for node in nodes:
mooseutils.recursive_update(node.attributes, page_attributes[node.uid])
self.write(node, self._page_result[node.uid])
def _target(self, nodes, barrier, page_attributes):
"""Target function for multiprocessing.Process calls."""
local_content = dict()
local_ast = dict()
local_result = dict()
# READ
for node in nodes:
Executioner.setMutable(node, True)
content = self.read(node)
page_attributes[node.uid] = node.attributes
Executioner.setMutable(node, False)
local_content[node.uid] = content
barrier.wait()
self._updateAttributes(page_attributes)
# TOKENIZE
for node in nodes:
content = local_content.pop(node.uid)
Executioner.setMutable(node, True)
mooseutils.recursive_update(node.attributes,
page_attributes[node.uid])
ast = self.tokenize(node, content)
page_attributes[node.uid] = node.attributes
Executioner.setMutable(node, False)
local_ast[node.uid] = ast
barrier.wait()
self._updateAttributes(page_attributes)
# RENDER
for node in nodes:
ast = local_ast.pop(node.uid)
Executioner.setMutable(node, True)
mooseutils.recursive_update(node.attributes,
page_attributes[node.uid])
result = self.render(node, ast)
page_attributes[node.uid] = node.attributes
Executioner.setMutable(node, False)
local_result[node.uid] = result
barrier.wait()
self._updateAttributes(page_attributes)
# WRITE
for node in nodes:
result = local_result.pop(node.uid)
Executioner.setMutable(node, True)
mooseutils.recursive_update(node.attributes,
page_attributes[node.uid])
result = self.write(node, result)
Executioner.setMutable(node, False)
def main(options):
"""
Main function for the build command.
Inputs:
options[argparse options]: Complete options from argparse, see MooseDocs/main.py
"""
t = time.time()
# Infinite nested dict
tree = lambda: collections.defaultdict(tree)
kwargs = tree()
# Setup executioner
if options.executioner:
kwargs['Executioner']['type'] = options.executioner
# Disable extensions
if options.stable:
pass
elif options.fast:
options.disable += ['MooseDocs.extensions.appsyntax', 'MooseDocs.extensions.navigation',
'MooseDocs.extensions.sqa', 'MooseDocs.extensions.civet',
'MooseDocs.extensions.gitutils']
else:
options.disable += ['MooseDocs.extensions.sqa', 'MooseDocs.extensions.civet',
'MooseDocs.extensions.gitutils']
for name in options.disable:
kwargs['Extensions'][name] = dict(active=False)
if options.hide_source:
kwargs['Extensions']['MooseDocs.extensions.modal']['show_source'] = False
# Apply Translator settings
if options.destination:
kwargs['Translator']['destination'] = mooseutils.eval_path(options.destination)
if options.profile:
kwargs['Translator']['profile'] = True
# Apply '--args' and override anything already set
if options.args is not None:
mooseutils.recursive_update(kwargs, options.args)
# Create translators for the specified configuration files, provide kwargs to override them
config_files = options.config if isinstance(options.config, list) else [options.config]
subconfigs = len(config_files) > 1
LOG.info("Loading configuration file{}".format('s' if subconfigs else ''))
translators, contents, configurations = common.load_configs(config_files, **kwargs)
# Initialize the translator objects
for index, translator in enumerate(translators):
if subconfigs:
LOG.info('Initializing translator object loaded from %s', config_files[index])
translator.init(contents[index])
# init methods can add pages (e.g., civet.py), but don't add pages from another translator
contents[index] = [page for page in translator.getPages() if page.translator is translator]
# Identify the first translator in the list as the "primary" one for convenience
primary = translators[0]
pooled = sorted(primary.getPages(), key=(lambda p: p.local))
# Dump page tree from content pool and syntax list from all translators with AppSyntax
if options.dump:
for page in pooled:
print('{}: {}'.format(page.local, page.source))
for index, translator in enumerate(translators):
for extension in translator.extensions:
if isinstance(extension, MooseDocs.extensions.appsyntax.AppSyntaxExtension):
if subconfigs:
LOG.info('Building syntax list specified by %s', config_files[index])
extension.preExecute()
print(extension.syntax)
break
return 0
# TODO: See `navigation.postExecute`
# The navigation "home" should be a markdown file, when all the apps update to this we
# can remove this as well as the use of it by CIVET
home = options.home
if options.serve and (home is not None) and (not home.endswith('.md')):
home = 'http://127.0.0.1:{}'.format(options.port)
if home is not None:
for ext in primary.extensions:
if 'home' in ext:
ext.update(home=home)
# Set default for --clean: clean when --files is NOT used.
if options.clean is None:
options.clean = options.files == []
else:
options.clean = options.clean.lower() in ['true', 'yes', '1']
if options.clean and os.path.exists(primary.destination):
LOG.info("Cleaning destination %s", primary.destination)
shutil.rmtree(primary.destination)
# Update contents lists if only building certain files
if options.files:
for index, translator in enumerate(translators):
func = lambda p: (p in contents[index]
and any([p.local.startswith(f) for f in options.files]))
contents[index] = translator.findPages(func)
# Execute the read and tokenize methods on all translators
for index, translator in enumerate(translators):
if subconfigs:
LOG.info('Reading content specified by %s', config_files[index])
translator.execute(contents[index], num_threads=options.num_threads, render=False, write=False)
# Finally, execute the render and write methods
for index, translator in enumerate(translators):
if subconfigs:
LOG.info('Writing content specified by %s', config_files[index])
translator.execute(contents[index], num_threads=options.num_threads, read=False, tokenize=False)
LOG.info('Total Time [%s sec.]', time.time() - t)
# Run live server and watch for content changes
if options.serve:
watcher = MooseDocsWatcher(translators, pooled, configurations, options.num_threads)
server = livereload.Server(watcher=watcher)
server.serve(root=primary.destination, host=options.host, port=options.port)
return 0
def main(options):
"""
Main function for the build command.
Inputs:
options[argparse options]: Complete options from argparse, see MooseDocs/main.py
"""
# Infinite nested dict
tree = lambda: collections.defaultdict(tree)
kwargs = tree()
# Setup executioner
if options.executioner:
kwargs['Executioner']['type'] = options.executioner
# Disable extensions
if options.fast:
options.disable += [
'MooseDocs.extensions.appsyntax',
'MooseDocs.extensions.navigation', 'MooseDocs.extensions.sqa',
'MooseDocs.extensions.civet'
]
for name in options.disable:
kwargs['Extensions'][name] = dict(active=False)
# Apply '--args' and override anything already set
if options.args is not None:
mooseutils.recursive_update(kwargs, options.args)
# Create translator, provide kwargs to override content of file
translator, _ = common.load_config(options.config, **kwargs)
if options.destination:
translator.update(
destination=mooseutils.eval_path(options.destination))
if options.profile:
translator.executioner.update(profile=True)
translator.init()
# Replace "home" with local server
home = options.home
if options.serve:
home = 'http://127.0.0.1:{}'.format(options.port)
if home is not None:
for ext in translator.extensions:
if 'home' in ext:
ext.update(home=home)
# Dump page tree
if options.dump:
for page in translator.getPages():
print('{}: {}'.format(page.local, page.source))
for ext in translator.extensions:
if isinstance(ext,
MooseDocs.extensions.appsyntax.AppSyntaxExtension):
ext.preExecute()
print(ext.syntax)
return 0
# Set default for --clean: clean when --files is NOT used.
if options.clean is None:
options.clean = options.files == []
else:
options.clean = options.clean.lower() in ['true', 'yes', '1']
if options.clean and os.path.exists(translator['destination']):
log = logging.getLogger('MooseDocs.build')
log.info("Cleaning destination %s", translator['destination'])
shutil.rmtree(translator['destination'])
# Perform build
if options.files:
nodes = []
for filename in options.files:
nodes += translator.findPages(filename)
translator.execute(nodes, options.num_threads)
else:
translator.execute(None, options.num_threads)
if options.serve:
watcher = MooseDocsWatcher(translator, options)
server = livereload.Server(watcher=watcher)
server.serve(root=translator['destination'],
host=options.host,
port=options.port)
return 0
def _updateAttributes(self, page_attributes):
"""Update the local page objects with attributes gathered from the other processes"""
for page in self._page_objects:
mooseutils.recursive_update(page.attributes, page_attributes[page.uid])
def setGlobalAttribute(self, key, value):
"""Set a global attribute to be communicated across processors."""
with self._lock:
mooseutils.recursive_update(self._global_attributes, {key: value})
