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