def setUpClass(cls): cls.MOOSE_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')) cls._cache = mooseutils.git_ls_files(cls.MOOSE_DIR) cls.file_is_stub = getattr(sys.modules['moosesqa.check_syntax'], 'file_is_stub') cls.find_md_file = getattr(sys.modules['moosesqa.check_syntax'], 'find_md_file') cls._check_node = getattr(sys.modules['moosesqa.check_syntax'], '_check_node')
def doc_tree(items): """ Create a tree of files for processing. Inputs: inputs: [list[dict(),...] A list of dict items, each dict entry must contain the 'root_dir' and 'content' fields that are passed to the doc_import function. """ # Error checking if not isinstance(items, list) or any(not isinstance(x, dict) for x in items): LOG.error( 'The supplied items must be a list of dict items, each with a "root_dir" and ' 'optionally a "content" entry.') return None # Define a dict for storing nodes by path nodes = dict() # Create the root node nodes[()] = page.DirectoryNode(source='') # Create the file tree for value in items: if 'root_dir' not in value: LOG.error( 'The supplied items must be a list of dict items, each with a "root_dir" and ' 'optionally a "content" entry.') root = mooseutils.eval_path(value['root_dir']) if not os.path.isabs(root): root = os.path.join(MooseDocs.ROOT_DIR, root) # Update the project files MooseDocs.PROJECT_FILES.update( mooseutils.git_ls_files(mooseutils.git_root_dir(root))) files = doc_import(root, content=value.get('content', None)) for filename in files: key = tuple(filename.replace(root, '').strip('/').split('/')) # Create directory nodes if they don't exist for i in range(1, len(key)): dir_key = key[:i] if dir_key not in nodes: nodes[dir_key] = page.DirectoryNode(nodes[key[:i - 1]], name=key[i - 1], source=os.path.join( root, *dir_key)) # Create the file node, if it doesn't already exist. This enforces that the first # item in the supplied content lists is the page that is rendered. if key not in nodes: nodes[key] = create_file_node(nodes[key[:-1]], key[-1], filename) return nodes[()]
def _locate_filenames(directories, ext): """Locate files in the directories with the given extension.""" out = set() for location in directories: for filename in mooseutils.git_ls_files(os.path.join(MooseDocs.ROOT_DIR, location)): if filename.endswith(ext) and not os.path.islink(filename): out.add(filename) return out
def _getFiles(locations): """Get complete list of files for the given *locations*.""" file_list = list() for working_dir in locations: path = mooseutils.eval_path(working_dir) if mooseutils.git_is_repo(path): file_list += mooseutils.git_ls_files(path) else: file_list += glob.glob(os.path.join(path, '**', '*.*'), recursive=True) return file_list
def compute_requirement_stats(location, specs=['tests'], working_dir=None, show=True, list_missing=False): """ Report requirement statistics for the test spec files with the supplied location. Inputs: location: Path to directory contain test specifications, the supplied path should be relative to the cwd input. specs: The filename(s) to consider working_dir: The working directory, if not supplied the root directory of the repository is used """ from .hit_load import hit_load tests_with_missing_requirements = set() working_dir = git_root_dir( os.getcwd()) if working_dir is None else working_dir data = SQAStats(location) location = os.path.join(working_dir, location) for filename in git_ls_files(location): if not os.path.isfile(filename): continue fname = os.path.basename(filename) if fname in specs: root = hit_load(filename) has_requirement = False for child in root.children[0]: data.tests += 1 deprecated = root.children[0].get( 'deprecated', False) or child.get('deprecated', False) if deprecated: data.tests_deprecated += 1 if child.get('requirement', None): has_requirement = True data.tests_with_requirement += 1 elif not deprecated: tests_with_missing_requirements.add((filename, child.name)) data.files += 1 if show: print(data) if list_missing and tests_with_missing_requirements: print('\nMissing Requirements:') for filename, test in tests_with_missing_requirements: print('{}:{}'.format(filename, test)) return data
def execute(self, **kwargs): """Determine the status""" file_list = list() for working_dir in self.working_dirs: path = mooseutils.eval_path(working_dir) if mooseutils.is_git_repo(path): file_list += mooseutils.git_ls_files(path) else: file_list += glob.glob(os.path.join(path, '**', '*.*'), recursive=True) logger = check_documents(self.documents, file_list, **kwargs) return logger
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 doc_tree(items): """ Create a tree of files for processing. Inputs: inputs: [list[dict(),...] A list of dict items, each dict entry must contain the 'root_dir' and 'content' fields that are passed to the doc_import function. """ # Error checking if not isinstance(items, list) or any(not isinstance(x, dict) for x in items): LOG.error('The supplied items must be a list of dict items, each with a "root_dir" and ' 'optionally a "content" entry.') return None # Define a dict for storing nodes by path nodes = dict() # Create the root node nodes[()] = page.DirectoryNode(source='') # Create the file tree for value in items: if 'root_dir' not in value: LOG.error('The supplied items must be a list of dict items, each with a "root_dir" and ' 'optionally a "content" entry.') root = mooseutils.eval_path(value['root_dir']) if not os.path.isabs(root): root = os.path.join(MooseDocs.ROOT_DIR, root) # Update the project files MooseDocs.PROJECT_FILES.update(mooseutils.git_ls_files(mooseutils.git_root_dir(root))) files = doc_import(root, content=value.get('content', None)) for filename in files: key = tuple(filename.replace(root, '').strip('/').split('/')) # Create directory nodes if they don't exist for i in range(1, len(key)): dir_key = key[:i] if dir_key not in nodes: nodes[dir_key] = page.DirectoryNode(nodes[key[:i-1]], name=key[i-1], source=os.path.join(root, *dir_key)) # Create the file node nodes[key] = create_file_node(nodes[key[:-1]], key[-1], filename) return nodes[()]
def get_content(items, in_ext): """ Create a tree of files for processing. Inputs: items: [list[dict(),...] A list of dict items, each dict entry must contain the 'root_dir' and 'content' fields that are passed to the doc_import function. in_ext[tuple]: Set of extensions to be converted (e.g., ('.md', )). out_ext[str]: The extension of rendered result (e.g., '.html'). """ if not isinstance(items, list) or any(not isinstance(x, dict) for x in items): LOG.error( 'The supplied items must be a list of dict items, each with a "root_dir" and ' 'optionally a "content" entry.') return None roots = set() nodes = dict() for root, filename, external in get_files(items, in_ext): roots.add(root) key = filename.replace(root, '').strip('/') parts = key.split('/') # Create directory nodes if they don't exist for i in range(1, len(parts)): dir_key = os.path.join(*parts[:i]) if dir_key not in nodes: nodes[dir_key] = pages.Directory(dir_key, external=external, source=os.path.join( root, dir_key)) # Create the file node, if it doesn't already exist. This enforces that the first # item in the supplied content lists is the page that is rendered. if key not in nodes: nodes[key] = create_file_page(key, filename, in_ext) nodes[key].external = external # Update the project files for root in roots: if mooseutils.is_git_repo(root): MooseDocs.PROJECT_FILES.update( mooseutils.git_ls_files(mooseutils.git_root_dir(root))) else: MooseDocs.PROJECT_FILES.update(mooseutils.list_files(root)) return list(nodes.values())
def get_requirements_from_tests(directories, specs): """ Build requirements dictionary from the provided directories. Input: directories[list]: A list of directories to consider specs[list]: A list of test specification names (e.g., ['tests']) """ out = collections.defaultdict(list) for location in directories: for filename in sorted(mooseutils.git_ls_files(location)): if os.path.isfile(filename) and (os.path.basename(filename) in specs): group = os.path.relpath(filename, location).split('/')[0] out[group] += get_requirements_from_file(filename) return out
def get_requirements(directories, specs): """ Build requirements dictionary from the provided directories. """ out = collections.defaultdict(list) for location in directories: for filename in mooseutils.git_ls_files(location): if not os.path.isfile(filename): continue fname = os.path.basename(filename) if fname in specs: _add_requirements(out, location, filename) for i, requirements in enumerate(out.itervalues()): for j, req in enumerate(requirements): req.label = "F{}.{}".format(i+1, j+1) return out
def _find_file(working_dir, pattern): """ Helper for finding file in repository. see _create_specification """ if pattern.startswith('/'): pattern = os.path.join(working_dir, pattern.strip('/')) matches = [f for f in mooseutils.git_ls_files(working_dir) if f.endswith(pattern)] if not matches: raise NameError("Unable to locate a test specification with pattern: {}".format(pattern)) elif len(matches) > 1: msg = "Located multiple test specifications with pattern: {}\n".format(pattern) msg += " \n".join(matches) raise NameError(msg) return matches[0]
def get_content(items, in_ext): """ Create a tree of files for processing. Inputs: items: [list[dict(),...] A list of dict items, each dict entry must contain the 'root_dir' and 'content' fields that are passed to the doc_import function. in_ext[tuple]: Set of extensions to be converted (e.g., ('.md', )). out_ext[str]: The extension of rendered result (e.g., '.html'). """ if not isinstance(items, list) or any(not isinstance(x, dict) for x in items): LOG.error('The supplied items must be a list of dict items, each with a "root_dir" and ' 'optionally a "content" entry.') return None roots = set() nodes = dict() for root, filename in get_files(items, in_ext): roots.add(root) key = filename.replace(root, '').strip('/') parts = key.split('/') # Create directory nodes if they don't exist for i in range(1, len(parts)): dir_key = os.path.join(*parts[:i]) if dir_key not in nodes: nodes[dir_key] = MooseDocs.tree.pages.Directory(dir_key, source=os.path.join(root, dir_key)) # Create the file node, if it doesn't already exist. This enforces that the first # item in the supplied content lists is the page that is rendered. if key not in nodes: nodes[key] = create_file_page(key, filename, in_ext) # Update the project files for root in roots: if mooseutils.is_git_repo(root): MooseDocs.PROJECT_FILES.update(mooseutils.git_ls_files(mooseutils.git_root_dir(root))) else: MooseDocs.PROJECT_FILES.update(mooseutils.list_files(root)) return nodes.values()
def get_requirements(directories, specs, prefix='F', category=None): """ Build requirements dictionary from the provided directories. """ out = collections.defaultdict(list) for location in directories: for filename in sorted(mooseutils.git_ls_files(location)): if not os.path.isfile(filename): continue fname = os.path.basename(filename) if fname in specs: _add_requirements(out, location, filename) for i, requirements in enumerate(out.values()): for j, req in enumerate(requirements): if category: req.label = "{}{}.{}.{}".format(prefix, category, i + 1, j + 1) else: req.label = "{}{}.{}".format(prefix, i + 1, j + 1) return out
def compute_requirement_stats(location, specs=['tests'], working_dir=None, show=True): """ Report requirement statistics for the test spec files with the supplied location. Inputs: location: Path to directory contain test specifications, the supplied path should be relative to the cwd input. specs: The filename(s) to consider working_dir: The working directory, if not supplied the root directory of the repository is used """ working_dir = git_root_dir( os.getcwd()) if working_dir is None else working_dir data = SQAStats(location) location = os.path.join(working_dir, location) for filename in git_ls_files(location): if not os.path.isfile(filename): continue fname = os.path.basename(filename) if fname in specs: root = hit_load(filename) has_requirement = False for child in root.children[0]: data.tests += 1 if child.get('requirement', None): has_requirement = True data.tests_with_requirement += 1 data.files += 1 if has_requirement: data.files_with_requirement += 1 if show: print(data) return data
def report_requirement_stats(location, specs): """ Report requirement statistics for the test spec files with the supplied location. """ requirements = 0 tests = 0 for filename in mooseutils.git_ls_files(location): if not os.path.isfile(filename): continue fname = os.path.basename(filename) if fname in specs: root = mooseutils.hit_load(filename) for child in root.children[0]: tests += 1 if child.get('requirement', None): requirements += 1 complete = float(requirements) / float(tests) print 'Requirement Definitions ({:2.1f}% complete):'.format(complete * 100) print ' Location: {}'.format(location) print ' Specs: {}'.format(' '.join(specs)) print ' Total Number of Tests: {}'.format(tests) print ' Tests with Requirements: {}'.format(requirements)
def check_documents(documents, file_list=None, **kwargs): """ Tool for checking SQA document deficiencies """ # Setup logger, assume the names of the documents with a "log_" prefix are the logging flags (see get_documents) for doc in documents: kwargs.setdefault("log_" + doc.name, logging.ERROR) logger = LogHelper(__name__, **kwargs) # Setup file_list, if not provided if (file_list is None) and (not mooseutils.is_git_repo()): msg = "If the 'file_list' is not provided then the working directory must be a git repository." raise ValueError(msg) elif file_list is None: root = mooseutils.git_root_dir() file_list = mooseutils.git_ls_files(root, recurse_submodules=False) # Perform document checks for doc in documents: _check_document(doc.name, doc.filename, file_list, logger) return logger
def report_requirement_stats(location, specs): """ Report requirement statistics for the test spec files with the supplied location. """ requirements = 0 tests = 0 for filename in mooseutils.git_ls_files(location): if not os.path.isfile(filename): continue fname = os.path.basename(filename) if fname in specs: root = mooseutils.hit_load(filename) for child in root.children[0]: tests += 1 if child.get('requirement', None): requirements += 1 complete = float(requirements)/float(tests) print 'Requirement Definitions ({:2.1f}% complete):'.format(complete*100) print ' Location: {}'.format(location) print ' Specs: {}'.format(' '.join(specs)) print ' Total Number of Tests: {}'.format(tests) print ' Tests with Requirements: {}'.format(requirements)
import subprocess import logging if sys.version_info < (3, 6): print('"MOOSEDocs" requires python version 3.6 or greater, version {}.{} is being used.' \ .format(sys.version_info[0], sys.version_info[1])) sys.exit(1) import mooseutils # Current logging level, used to allow for debug only type checking, etc. LOG_LEVEL = logging.NOTSET # The repository root location ROOT_DIR = mooseutils.git_root_dir() os.environ['ROOT_DIR'] = ROOT_DIR # Setup MOOSE_DIR/ROOT_DIR MOOSE_DIR = os.getenv('MOOSE_DIR', None) if MOOSE_DIR is None: print( "The MOOSE_DIR environment must be set, this should be set within moosedocs.py." ) sys.exit(1) # List all files with git, this is done here to avoid running this command many times PROJECT_FILES = mooseutils.git_ls_files(ROOT_DIR) PROJECT_FILES.update(mooseutils.git_ls_files(MOOSE_DIR)) PROJECT_FILES.update( mooseutils.git_ls_files(os.path.join(MOOSE_DIR, 'large_media')))
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
MSG += " pip install --upgrade --user anytree" print MSG sys.exit(1) import mooseutils # Markdown component types TODO: Move these to reader BLOCK = 'block' INLINE = 'inline' # Current logging level, used to allow for debug only type checking, etc. LOG_LEVEL = logging.NOTSET # The repository root location ROOT_DIR = mooseutils.git_root_dir() os.environ['ROOT_DIR'] = ROOT_DIR # File extensions to consider when building the content tree FILE_EXT = ('.md', '.jpg', '.jpeg', '.gif', '.png', '.svg', '.ogg', '.webm', '.mp4', '.css', \ '.js', '.bib', '.woff', '.woff2') # Setup MOOSE_DIR/ROOT_DIR MOOSE_DIR = os.getenv('MOOSE_DIR', None) if MOOSE_DIR is None: print "The MOOSE_DIR environment must be set, this should be set within moosedocs.py." sys.exit(1) # List all files with git, this is done here to avoid running this command many times PROJECT_FILES = mooseutils.git_ls_files(ROOT_DIR) PROJECT_FILES.update(mooseutils.git_ls_files(MOOSE_DIR))
def check_requirements(requirements, file_list=None, color_text=True, allowed_collections=None, allowed_classifications=None, **kwargs): """ Tool for checking Requirement for deficiencies """ # Create key values for the logging messages log_default = kwargs.get('log_default', logging.ERROR) kwargs.setdefault('log_deprecated_requirement', log_default) kwargs.setdefault('log_deprecated_design', log_default) kwargs.setdefault('log_deprecated_issues', log_default) kwargs.setdefault('log_deprecated_detail', log_default) kwargs.setdefault('log_deprecated_verification', log_default) kwargs.setdefault('log_deprecated_validation', log_default) kwargs.setdefault('log_deprecated_with_details', log_default) kwargs.setdefault('log_missing', log_default) kwargs.setdefault('log_missing_requirement', log_default) kwargs.setdefault('log_missing_design', log_default) kwargs.setdefault('log_missing_issues', log_default) kwargs.setdefault('log_empty_requirement', log_default) kwargs.setdefault('log_empty_design', log_default) kwargs.setdefault('log_empty_issues', log_default) kwargs.setdefault('log_empty_verification', log_default) kwargs.setdefault('log_empty_validation', log_default) kwargs.setdefault('log_top_level_detail', log_default) kwargs.setdefault('log_missing_detail', log_default) kwargs.setdefault('log_empty_detail', log_default) kwargs.setdefault('log_extra_requirement', log_default) kwargs.setdefault('log_extra_design', log_default) kwargs.setdefault('log_extra_issues', log_default) kwargs.setdefault('log_extra_collections', log_default) kwargs.setdefault('log_invalid_collection', log_default) kwargs.setdefault('log_issue_format', log_default) kwargs.setdefault('log_design_files', log_default) kwargs.setdefault('log_validation_files', log_default) kwargs.setdefault('log_verification_files', log_default) kwargs.setdefault('log_testable', log_default) kwargs.setdefault('log_duplicate_requirement', log_default) kwargs.setdefault('log_duplicate_detail', log_default) logger = RequirementLogHelper(__name__, **kwargs) RequirementLogHelper.COLOR_TEXT = color_text # Setup file_list, if not provided if (file_list is None) and (not mooseutils.git_is_repo()): msg = "If the 'file_list' is not provided then the working directory must be a git repository." raise ValueError(msg) elif file_list is None: root = mooseutils.git_root_dir() ver = mooseutils.git_version() file_list = mooseutils.git_ls_files(root, recurse_submodules=True) # Setup allowed collections if allowed_collections is None: allowed_collections = set(moosesqa.MOOSESQA_COLLECTIONS) # Storage container for duplicate detection requirement_dict = collections.defaultdict(set) # Check each Requirement object for deficiencies for req in requirements: _check_requirement(req, logger, file_list, allowed_collections) if req.requirement is not None: key = [req.requirement] for detail in req.details: if detail.detail is not None: key.append(detail.detail) requirement_dict['\n'.join(key)].add(req) # Duplicate checking for txt, value in requirement_dict.items(): if len(value) > 1: msg = 'Duplicate requirements found:' msg += '\n{}\n'.format( mooseutils.colorText(txt, 'GREY', colored=color_text)) for r in value: r.duplicate = True msg += RequirementLogHelper._colorTestInfo(r, None, None, None) LogHelper.log(logger, 'log_duplicate_requirement', msg.strip('\n')) return logger
#* All rights reserved, see COPYRIGHT for full restrictions #* https://github.com/idaholab/moose/blob/master/COPYRIGHT #* #* Licensed under LGPL 2.1, please see LICENSE for details #* https://www.gnu.org/licenses/lgpl-2.1.html import os import sys import subprocess import logging import mooseutils # Current logging level, used to allow for debug only type checking, etc. LOG_LEVEL = logging.NOTSET # The repository root location ROOT_DIR = mooseutils.git_root_dir() os.environ['ROOT_DIR'] = ROOT_DIR # Setup MOOSE_DIR/ROOT_DIR MOOSE_DIR = os.getenv('MOOSE_DIR', None) if MOOSE_DIR is None: print( "The MOOSE_DIR environment must be set, this should be set within moosedocs.py." ) sys.exit(1) # List all files with git, this is done here to avoid running this command many times PROJECT_FILES = mooseutils.git_ls_files(ROOT_DIR) PROJECT_FILES.update(mooseutils.git_ls_files(MOOSE_DIR))
def testGitLsFiles(self): files = mooseutils.git_ls_files() self.assertIn(os.path.abspath(__file__), files)
os.path.join(os.path.dirname(__name__), '..', '..', 'moose')) if not os.path.exists(MOOSE_DIR): raise Exception( 'Failed to locate MOOSE, specify the MOOSE_DIR environment variable.') os.environ['MOOSE_DIR'] = MOOSE_DIR # Locate BlackBear directory BLACKBEAR_DIR = os.getenv('BLACKBEAR_DIR', os.path.join(os.getcwd(), '..', 'blackbear')) if not os.path.exists(os.path.join(BLACKBEAR_DIR, 'src')): BLACKBEAR_DIR = os.getenv( 'BLACKBEAR_DIR', os.path.join(os.getcwd(), '..', '..', 'blackbear')) if not os.path.exists(BLACKBEAR_DIR): raise Exception( 'Failed to locate BlackBear, specify the BLACKBEAR_DIR environment variable.' ) os.environ['BLACKBEAR_DIR'] = os.path.abspath(BLACKBEAR_DIR) # Append MOOSE python directory MOOSE_PYTHON_DIR = os.path.join(MOOSE_DIR, 'python') if MOOSE_PYTHON_DIR not in sys.path: sys.path.append(MOOSE_PYTHON_DIR) import MooseDocs import mooseutils MooseDocs.PROJECT_FILES.update(mooseutils.git_ls_files(BLACKBEAR_DIR)) from MooseDocs import main if __name__ == '__main__': sys.exit(main.run())
*['{:,}'.format(totals[key]) for key in titles])) if __name__ == '__main__': args = get_options() # Populate desired langauges lang = collections.OrderedDict() for key in args.languages: lang[key] = LANGUAGES[key] # List all files in the repository all_files = set() for location in args.locations: all_files.update( mooseutils.git_ls_files(os.path.abspath(args.locations[0]), exclude=args.exclude)) # Group filenames by extension groups = collections.defaultdict(list) for filename in all_files: for key, func in lang.items(): if func(filename): groups[key].append(filename) # Report author counts by file type counts = collections.defaultdict(lambda: {g: 0 for g in lang.keys()}) for group, files in groups.items(): print('Counting {} lines...'.format(group), end='') with multiprocessing.Pool(processes=args.num_threads) as pool: for c in pool.imap_unordered(target, files): update_count(c, group, counts)