def testUnregister(self):
# Without unregister
root = moosesyntax.get_moose_syntax_tree(self.json)
node = moosetree.find(
root, lambda n: n.fullpath() == '/UserObjects/AreaPostprocessor')
self.assertEqual(node['moose_base'], 'Postprocessor')
self.assertEqual(node['parent_syntax'], 'UserObjects/*')
self.assertFalse(node.removed)
node = moosetree.find(root,
lambda n: n.fullpath() == '/Bounds/ConstantAux')
self.assertFalse(node.removed)
# With unregister(objects should be removed)
root = moosesyntax.get_moose_syntax_tree(self.json,
unregister={
'Postprocessor':
'UserObjects/*',
'AuxKernel': 'Bounds/*'
})
node = moosetree.find(
root, lambda n: n.fullpath() == '/UserObjects/AreaPostprocessor')
self.assertTrue(node.removed)
node = moosetree.find(root,
lambda n: n.fullpath() == '/Bounds/ConstantAux')
self.assertTrue(node.removed)
def testAllowTestObjects(self):
root = moosesyntax.get_moose_syntax_tree(self.json)
node = moosetree.find(
root, lambda n: n.fullpath() == '/UserObjects/TestCSVReader')
self.assertTrue(node.removed)
root = moosesyntax.get_moose_syntax_tree(self.json,
allow_test_objects=True)
node = moosetree.find(
root, lambda n: n.fullpath() == '/UserObjects/TestCSVReader')
self.assertFalse(node.removed)
def testNodes(self):
root = moosesyntax.get_moose_syntax_tree(self.json)
# SyntaxNode
node = moosetree.find(root, lambda n: n.fullpath() == '/Adaptivity')
self.assertEqual(node.name, 'Adaptivity')
self.assertIsInstance(node, moosesyntax.SyntaxNode)
self.assertEqual(node.hidden, False)
self.assertEqual(node.removed, False)
self.assertEqual(node.group, None)
self.assertEqual(node.groups(), {'MooseApp'})
self.assertIn('SetAdaptivityOptionsAction',
[action.name for action in node.actions()])
self.assertIn('Indicators', [syntax.name for syntax in node.syntax()])
node = moosetree.find(root,
lambda n: n.fullpath() == '/Adaptivity/Markers')
self.assertIn('BoxMarker', [obj.name for obj in node.objects()])
# MooseObjectNode
node = moosetree.find(
root, lambda n: n.fullpath() == '/Functions/ParsedFunction')
self.assertEqual(node.name, 'ParsedFunction')
self.assertIsInstance(node, moosesyntax.MooseObjectNode)
self.assertEqual(node.hidden, False)
self.assertEqual(node.removed, False)
self.assertEqual(node.alias, None)
self.assertEqual(node.group, 'MooseApp')
self.assertEqual(node.classname, 'MooseParsedFunction')
self.assertIn('Function', node.description)
self.assertTrue(
node.source.endswith(
'framework/src/functions/MooseParsedFunction.C'))
self.assertTrue(
node.header.endswith(
'framework/include/functions/MooseParsedFunction.h'))
self.assertIsInstance(node.parameters, dict)
self.assertIn('value', node.parameters)
# ActionNode
node = moosetree.find(
root, lambda n: n.fullpath() == '/Outputs/CommonOutputAction')
self.assertEqual(node.name, 'CommonOutputAction')
self.assertIsInstance(node, moosesyntax.ActionNode)
self.assertEqual(node.hidden, False)
self.assertEqual(node.removed, False)
self.assertEqual(node.group, 'MooseApp')
self.assertIn('common_output', node.tasks)
# MooseObjectActionNode
node = moosetree.find(
root, lambda n: n.fullpath() == '/Outputs/AddOutputAction')
self.assertEqual(node.name, 'AddOutputAction')
self.assertIsInstance(node, moosesyntax.ActionNode)
self.assertEqual(node.hidden, False)
self.assertEqual(node.removed, False)
self.assertEqual(node.group, 'MooseApp')
self.assertIn('add_output', node.tasks)
def testMarkdown(self):
root = moosesyntax.get_moose_syntax_tree(
self.json,
markdown={
'/AuxKernels/ADMaterialRealAux':
'auxkernels/ADMaterialRealAux.md'
})
node = moosetree.find(
root, lambda n: n.fullpath() == '/AuxKernels/ADMaterialRealAux')
self.assertEqual(node.markdown, 'auxkernels/ADMaterialRealAux.md')
def execute(self, **kwargs):
"""Perform app syntax checking"""
# Check that the supplied content dir exists
content_dir = mooseutils.eval_path(self.content_directory)
if not os.path.isdir(content_dir):
content_dir = os.path.join(self.working_dir, content_dir)
if not os.path.isdir(content_dir):
raise NotADirectoryError("'content_directory' input is not a directory: {}".format(content_dir))
# Populate the available list of files
file_cache = mooseutils.git_ls_files(content_dir)
# Check that the supplied exe dir exists
exe_dir = mooseutils.eval_path(self.exe_directory)
if not os.path.isdir(exe_dir):
exe_dir = os.path.join(self.working_dir, exe_dir)
if not os.path.isdir(exe_dir):
raise NotADirectoryError("'exe_directory' input is not a directory: {}".format(exe_dir))
# Locate the executable
exe = mooseutils.find_moose_executable(exe_dir, name=self.exe_name, show_error=False)
if exe is None:
raise OSError("An executable was not found in '{}' with a name '{}'.".format(exe_dir, self.exe_name))
# Determine the application type (e.g., MooseTestApp)
if self.app_types is None:
out = subprocess.check_output([exe, '--type'], encoding='utf-8')
match = re.search(r'^MooseApp Type:\s+(?P<type>.*?)$', out, flags=re.MULTILINE)
if match:
self.app_types = [match.group("type").replace('TestApp', 'App')]
# Build syntax tree if not provided
if self.app_syntax is None:
# Get the removed/alias information
remove = self._loadYamlFiles(self.remove)
alias = self._loadYamlFiles(self.alias)
unregister = self._loadYamlFiles(self.unregister)
# Build the complete syntax tree
self.app_syntax = moosesyntax.get_moose_syntax_tree(exe, remove=remove,
alias=alias, unregister=unregister)
# Perform the checks
kwargs.setdefault('syntax_prefix', mooseutils.eval_path(self.syntax_prefix))
kwargs.setdefault('object_prefix', mooseutils.eval_path(self.object_prefix))
kwargs.setdefault('allow_test_objects', self.allow_test_objects)
logger = check_syntax(self.app_syntax, self.app_types, file_cache, **kwargs)
return logger
def __initApplicationSyntax(self):
"""Initialize the application syntax."""
start = time.time()
LOG.info("Reading MOOSE application syntax...")
exe = mooseutils.eval_path(self['executable'])
exe = mooseutils.find_moose_executable(exe,
name=self['app_name'],
show_error=False)
self._app_exe = exe
if exe is None:
LOG.error("Failed to locate a valid executable in %s.",
self['executable'])
else:
try:
self._app_syntax = moosesyntax.get_moose_syntax_tree(
exe,
remove=self['remove'],
alias=self['alias'],
unregister=self['unregister'])
out = mooseutils.runExe(exe, ['--type'])
match = re.search(r'^MooseApp Type:\s+(?P<type>.*?)$',
out,
flags=re.MULTILINE)
if match:
self._app_type = match.group("type")
else:
msg = "Failed to determine application type by running the following:\n"
msg += " {} --type".format(exe)
LOG.error(msg)
except Exception as e:
msg = "Failed to load application executable from '{}' with the following error; " \
"application syntax is being disabled.\n".format(exe)
msg += '\n{}\n'.format(
mooseutils.colorText(traceback.format_exc(), 'GREY'))
msg += "This typically indicates that the application is not producing JSON output " \
"correctly, try running the following:\n" \
" {} --json --allow-test-objects\n".format(exe)
self.setActive(False)
LOG.error(msg)
# Enable test objects by removing the test flag (i.e., don't consider them test objects)
if self['allow-test-objects'] and (self._app_syntax is not None):
for node in moosetree.iterate(self._app_syntax):
node.test = False
LOG.info("MOOSE application syntax complete [%s sec.]",
time.time() - start)
def testRemove(self):
# Test with flat list
root = moosesyntax.get_moose_syntax_tree(
self.json, remove=['/Outputs', '/Kernels/Diffusion'])
node = moosetree.find(root, lambda n: n.fullpath() == '/Outputs')
self.assertTrue(all([n.removed
for n in node])) # children should be marked
node = moosetree.find(root, lambda n: n.fullpath() == '/Kernels')
self.assertFalse(node.removed)
node = moosetree.find(root,
lambda n: n.fullpath() == '/Kernels/Diffusion')
self.assertTrue(node.removed)
node = moosetree.find(root,
lambda n: n.fullpath() == '/Kernels/ADDiffusion')
self.assertFalse(node.removed)
# Test with dict of lists
remove = dict(first=['/Outputs', '/Kernels/Diffusion'],
second=['/Kernels/ADDiffusion'])
root = moosesyntax.get_moose_syntax_tree(self.json, remove=remove)
node = moosetree.find(root, lambda n: n.fullpath() == '/Outputs')
self.assertTrue(all([n.removed
for n in node])) # children should be marked
node = moosetree.find(root, lambda n: n.fullpath() == '/Kernels')
self.assertFalse(node.removed)
node = moosetree.find(root,
lambda n: n.fullpath() == '/Kernels/Diffusion')
self.assertTrue(node.removed)
node = moosetree.find(root,
lambda n: n.fullpath() == '/Kernels/ADDiffusion')
self.assertTrue(node.removed)
def testHide(self):
# Test with flat list
root = moosesyntax.get_moose_syntax_tree(
self.json, hide=['/Outputs', '/Kernels/Diffusion'])
node = moosetree.find(root, lambda n: n.fullpath() == '/Outputs')
self.assertFalse(any([n.hidden
for n in node])) # children should not be marked
node = moosetree.find(root, lambda n: n.fullpath() == '/Kernels')
self.assertFalse(node.hidden)
node = moosetree.find(root,
lambda n: n.fullpath() == '/Kernels/Diffusion')
self.assertTrue(node.hidden)
node = moosetree.find(root,
lambda n: n.fullpath() == '/Kernels/ADDiffusion')
self.assertFalse(node.hidden)
# Test with dict of lists
hide = dict(first=['/Outputs', '/Kernels/Diffusion'],
second=['/Kernels/ADDiffusion'])
root = moosesyntax.get_moose_syntax_tree(self.json, hide=hide)
node = moosetree.find(root, lambda n: n.fullpath() == '/Outputs')
self.assertFalse(any([n.hidden
for n in node])) # children should not be marked
node = moosetree.find(root, lambda n: n.fullpath() == '/Kernels')
self.assertFalse(node.hidden)
node = moosetree.find(root,
lambda n: n.fullpath() == '/Kernels/Diffusion')
self.assertTrue(node.hidden)
node = moosetree.find(root,
lambda n: n.fullpath() == '/Kernels/ADDiffusion')
self.assertTrue(node.hidden)
def __initApplicationSyntax(self):
"""Initialize the application syntax."""
start = time.time()
LOG.info("Reading MOOSE application syntax...")
exe = mooseutils.eval_path(self['executable'])
exe = mooseutils.find_moose_executable(exe,
name=self['app_name'],
show_error=False)
self._app_exe = exe
if exe is None:
LOG.error("Failed to locate a valid executable in %s.",
self['executable'])
else:
try:
self._app_syntax = moosesyntax.get_moose_syntax_tree(
exe,
remove=self['remove'],
alias=self['alias'],
unregister=self['unregister'])
out = mooseutils.runExe(exe, ['--type'])
match = re.search(r'^MooseApp Type:\s+(?P<type>.*?)$',
out,
flags=re.MULTILINE)
if match:
self._app_type = match.group("type")
else:
msg = "Failed to determine application type by running the following:\n"
msg += " {} --type".format(exe)
LOG.error(msg)
except Exception as e:
msg = "Failed to load application executable from '%s', " \
"application syntax is being disabled:\n%s"
self.setActive(False)
LOG.error(msg, exe, e)
# Enable test objects by removing the test flag (i.e., don't consider them test objects)
if self['allow-test-objects']:
for node in moosetree.iterate(self._app_syntax):
node.test = False
LOG.info("MOOSE application syntax complete [%s sec.]",
time.time() - start)
def testTestApp(self):
root = moosesyntax.get_moose_syntax_tree(self.json)
node = moosetree.find(root, lambda n: n.fullpath() == '/Testing')
self.assertTrue(node.removed)
self.assertTrue(node(0).removed)
self.assertTrue(node(0, 0).removed)
def testRun(self):
location = os.path.abspath(
os.path.join(os.path.dirname(__file__), '..', '..', '..', 'test'))
exe = mooseutils.find_moose_executable(location)
root = moosesyntax.get_moose_syntax_tree(exe)
def testAlias(self):
root = moosesyntax.get_moose_syntax_tree(
self.json, alias={'/Kernels/Diffusion': '/Physics/Diffusion'})
node = moosetree.find(root,
lambda n: n.fullpath() == '/Kernels/Diffusion')
self.assertIn(node.alias, '/Physics/Diffusion')
def execute(self, **kwargs):
"""Perform app syntax checking"""
# Check that the supplied content dir exists
content_dir = mooseutils.eval_path(self.content_directory)
if not os.path.isdir(content_dir):
content_dir = os.path.join(self.working_dir, content_dir)
if not os.path.isdir(content_dir):
raise NotADirectoryError(
"'content_directory' input is not a directory: {}".format(
content_dir))
# Populate the available list of files
file_cache = mooseutils.git_ls_files(content_dir)
# Check that the supplied exe dir exists
exe_dir = mooseutils.eval_path(self.exe_directory)
if not os.path.isdir(exe_dir):
exe_dir = os.path.join(self.working_dir, exe_dir)
if not os.path.isdir(exe_dir):
raise NotADirectoryError(
"'exe_directory' input is not a directory: {}".format(exe_dir))
# Locate the executable
exe = mooseutils.find_moose_executable(exe_dir,
name=self.exe_name,
show_error=False)
if exe is None:
raise OSError(
"An executable was not found in '{}' with a name '{}'.".format(
exe_dir, self.exe_name))
# Build syntax tree if not provided
if self.app_syntax is None:
# Get the hidden/removed/alias information
hide = self._loadYamlFiles(self.hidden)
remove = self._loadYamlFiles(self.remove)
alias = self._loadYamlFiles(self.alias)
unregister = self._loadYamlFiles(self.unregister)
# Build the complete syntax tree
self.app_syntax = moosesyntax.get_moose_syntax_tree(
exe,
hide=hide,
remove=remove,
alias=alias,
unregister=unregister,
allow_test_objects=self.allow_test_objects)
# Determine the application type (e.g., MooseTestApp)
if self.app_types is None:
out = mooseutils.run_executable(exe, ['--type'])
match = re.search(r'^MooseApp Type:\s+(?P<type>.*?)$',
out,
flags=re.MULTILINE)
if match:
self.app_types = [
match.group("type").replace('TestApp', 'App')
]
# Perform the checks
kwargs.setdefault('syntax_prefix',
mooseutils.eval_path(self.syntax_prefix))
kwargs.setdefault('object_prefix',
mooseutils.eval_path(self.object_prefix))
logger = check_syntax(self.app_syntax, self.app_types, file_cache,
**kwargs)
# Create stub pages
if self.generate_stubs:
func = lambda n: (not n.removed) \
and ('_md_file' in n) \
and ((n['_md_file'] is None) or n['_is_stub']) \
and ((n.group in self.app_types) \
or (n.groups() == set(self.app_types)))
for node in moosetree.iterate(self.app_syntax, func):
self._createStubPage(node)
# Dump
if self.dump_syntax:
print(self.app_syntax)
return logger
