def main(argv: Optional[List[str]] = None) -> int:
"""Linter CLI entry point."""
if argv is None:
argv = sys.argv
initialize_options(argv[1:])
console_options["force_terminal"] = options.colored
reconfigure(console_options)
initialize_logger(options.verbosity)
_logger.debug("Options: %s", options)
app = App(options=options)
prepare_environment()
check_ansible_presence(exit_on_error=True)
# On purpose lazy-imports to avoid pre-loading Ansible
# pylint: disable=import-outside-toplevel
from ansiblelint.generate_docs import rules_as_rich, rules_as_rst, rules_as_str
from ansiblelint.rules import RulesCollection
rules = RulesCollection(options.rulesdirs)
if options.listrules:
_rule_format_map: Dict[str, Callable[..., Any]] = {
'plain': rules_as_str,
'rich': rules_as_rich,
'rst': rules_as_rst,
}
console.print(_rule_format_map[options.format](rules), highlight=False)
return 0
if options.listtags:
console.print(render_yaml(rules.listtags()))
return 0
if isinstance(options.tags, str):
options.tags = options.tags.split(',')
from ansiblelint.runner import _get_matches
result = _get_matches(rules, options)
mark_as_success = False
if result.matches and options.progressive:
_logger.info(
"Matches found, running again on previous revision in order to detect regressions"
)
with _previous_revision():
old_result = _get_matches(rules, options)
# remove old matches from current list
matches_delta = list(set(result.matches) - set(old_result.matches))
if len(matches_delta) == 0:
_logger.warning(
"Total violations not increased since previous "
"commit, will mark result as success. (%s -> %s)",
len(old_result.matches),
len(matches_delta),
)
mark_as_success = True
ignored = 0
for match in result.matches:
# if match is not new, mark is as ignored
if match not in matches_delta:
match.ignored = True
ignored += 1
if ignored:
_logger.warning(
"Marked %s previously known violation(s) as ignored due to"
" progressive mode.",
ignored,
)
app.render_matches(result.matches)
return report_outcome(result,
mark_as_success=mark_as_success,
options=options)
def main() -> int:
"""Linter CLI entry point."""
cwd = pathlib.Path.cwd()
options = cli.get_config(sys.argv[1:])
initialize_logger(options.verbosity)
_logger.debug("Options: %s", options)
formatter_factory: Any = formatters.Formatter
if options.quiet:
formatter_factory = formatters.QuietFormatter
if options.parseable:
formatter_factory = formatters.ParseableFormatter
if options.parseable_severity:
formatter_factory = formatters.ParseableSeverityFormatter
formatter = formatter_factory(cwd, options.display_relative_path)
if options.use_default_rules:
rulesdirs = options.rulesdir + [DEFAULT_RULESDIR]
else:
rulesdirs = options.rulesdir or [DEFAULT_RULESDIR]
rules = RulesCollection(rulesdirs)
if options.listrules:
formatted_rules = rules if options.format == 'plain' else rules_as_rst(rules)
print(formatted_rules)
return 0
if options.listtags:
print(rules.listtags())
return 0
if isinstance(options.tags, str):
options.tags = options.tags.split(',')
skip = set()
for s in options.skip_list:
skip.update(str(s).split(','))
options.skip_list = frozenset(skip)
if not options.playbook:
# no args triggers auto-detection mode
playbooks = get_playbooks_and_roles(options=options)
else:
playbooks = sorted(set(options.playbook))
matches = list()
checked_files: Set[Any] = set()
for playbook in playbooks:
runner = Runner(rules, playbook, options.tags,
options.skip_list, options.exclude_paths,
options.verbosity, checked_files)
matches.extend(runner.run())
for match in sorted(matches):
print(formatter.format(match, options.colored))
if matches:
return 2
else:
return 0
def main(argv: List[str] = None) -> int:
"""Linter CLI entry point."""
if argv is None:
argv = sys.argv
cwd = pathlib.Path.cwd()
options = cli.get_config(argv[1:])
if options.colored is None:
options.colored = hasattr(sys.stdout, 'isatty') and sys.stdout.isatty()
if options.colored is not None:
console_options["force_terminal"] = options.colored
reconfigure(console_options)
initialize_logger(options.verbosity)
_logger.debug("Options: %s", options)
formatter_factory = choose_formatter_factory(options)
formatter = formatter_factory(cwd, options.display_relative_path)
rulesdirs = get_rules_dirs([str(rdir) for rdir in options.rulesdir],
options.use_default_rules)
rules = RulesCollection(rulesdirs)
if options.listrules:
console.print(
_rule_format_map[options.format](rules),
highlight=False)
return 0
if options.listtags:
console.print(
render_yaml(rules.listtags())
)
return 0
if isinstance(options.tags, str):
options.tags = options.tags.split(',')
options.skip_list = _sanitize_list_options(options.skip_list)
options.warn_list = _sanitize_list_options(options.warn_list)
result = _get_matches(rules, options)
mark_as_success = False
if result.matches and options.progressive:
_logger.info(
"Matches found, running again on previous revision in order to detect regressions")
with _previous_revision():
old_result = _get_matches(rules, options)
# remove old matches from current list
matches_delta = list(set(result.matches) - set(old_result.matches))
if len(matches_delta) == 0:
_logger.warning(
"Total violations not increased since previous "
"commit, will mark result as success. (%s -> %s)",
len(old_result.matches), len(matches_delta))
mark_as_success = True
ignored = 0
for match in result.matches:
# if match is not new, mark is as ignored
if match not in matches_delta:
match.ignored = True
ignored += 1
if ignored:
_logger.warning(
"Marked %s previously known violation(s) as ignored due to"
" progressive mode.", ignored)
_render_matches(result.matches, options, formatter, cwd)
return report_outcome(result, mark_as_success=mark_as_success, options=options)
def main() -> int:
"""Linter CLI entry point."""
cwd = pathlib.Path.cwd()
options = cli.get_config(sys.argv[1:])
initialize_logger(options.verbosity)
_logger.debug("Options: %s", options)
formatter_factory = choose_formatter_factory(options)
formatter = formatter_factory(cwd, options.display_relative_path)
rulesdirs = get_rules_dirs([str(rdir) for rdir in options.rulesdir],
options.use_default_rules)
rules = RulesCollection(rulesdirs)
if options.listrules:
console.print(_rule_format_map[options.format](rules), highlight=False)
return 0
if options.listtags:
print(rules.listtags())
return 0
if isinstance(options.tags, str):
options.tags = options.tags.split(',')
skip = set()
for s in options.skip_list:
skip.update(str(s).split(','))
options.skip_list = frozenset(skip)
if not options.playbook:
# no args triggers auto-detection mode
playbooks = get_playbooks_and_roles(options=options)
else:
playbooks = sorted(set(options.playbook))
matches = list()
checked_files: Set[str] = set()
for playbook in playbooks:
runner = Runner(rules, playbook, options.tags, options.skip_list,
options.exclude_paths, options.verbosity,
checked_files)
matches.extend(runner.run())
# Assure we do not print duplicates and the order is consistent
matches = sorted(set(matches))
for match in matches:
print(formatter.format(match, options.colored))
# If run under GitHub Actions we also want to emit output recognized by it.
if os.getenv('GITHUB_ACTIONS') == 'true' and os.getenv('GITHUB_WORKFLOW'):
formatter = formatters.AnnotationsFormatter(cwd, True)
for match in matches:
print(formatter.format(match))
if matches:
return report_outcome(matches, options=options)
else:
return 0
def main() -> int:
"""Linter CLI entry point."""
cwd = pathlib.Path.cwd()
options = cli.get_config(sys.argv[1:])
initialize_logger(options.verbosity)
_logger.debug("Options: %s", options)
formatter_factory: Any = formatters.Formatter
if options.quiet:
formatter_factory = formatters.QuietFormatter
if options.parseable:
formatter_factory = formatters.ParseableFormatter
if options.parseable_severity:
formatter_factory = formatters.ParseableSeverityFormatter
formatter = formatter_factory(cwd, options.display_relative_path)
if options.use_default_rules:
rulesdirs = options.rulesdir + [DEFAULT_RULESDIR]
else:
rulesdirs = options.rulesdir or [DEFAULT_RULESDIR]
rules = RulesCollection(rulesdirs)
if options.listrules:
formatted_rules = rules if options.format == 'plain' else rules_as_rst(
rules)
print(formatted_rules)
return 0
if options.listtags:
print(rules.listtags())
return 0
if isinstance(options.tags, str):
options.tags = options.tags.split(',')
skip = set()
for s in options.skip_list:
skip.update(str(s).split(','))
options.skip_list = frozenset(skip)
if not options.playbook:
# no args triggers auto-detection mode
playbooks = get_playbooks_and_roles(options=options)
else:
playbooks = sorted(set(options.playbook))
matches = list()
checked_files: Set[str] = set()
for playbook in playbooks:
runner = Runner(rules, playbook, options.tags, options.skip_list,
options.exclude_paths, options.verbosity,
checked_files)
matches.extend(runner.run())
# Assure we do not print duplicates and the order is consistent
matches = sorted(set(matches))
for match in matches:
print(formatter.format(match, options.colored))
# If run under GitHub Actions we also want to emit output recognized by it.
if os.getenv('GITHUB_ACTIONS') == 'true' and os.getenv('GITHUB_WORKFLOW'):
formatter = formatters.AnnotationsFormatter(cwd, True)
for match in matches:
print(formatter.format(match))
if matches:
return 2
else:
return 0
def main() -> int:
"""Linter CLI entry point."""
cwd = pathlib.Path.cwd()
options = cli.get_config(sys.argv[1:])
initialize_logger(options.verbosity)
_logger.debug("Options: %s", options)
formatter_factory = choose_formatter_factory(options)
formatter = formatter_factory(cwd, options.display_relative_path)
rulesdirs = get_rules_dirs([str(rdir) for rdir in options.rulesdir],
options.use_default_rules)
rules = RulesCollection(rulesdirs)
if options.listrules:
console.print(_rule_format_map[options.format](rules), highlight=False)
return 0
if options.listtags:
print(rules.listtags())
return 0
if isinstance(options.tags, str):
options.tags = options.tags.split(',')
skip = set()
for s in options.skip_list:
skip.update(str(s).split(','))
options.skip_list = frozenset(skip)
matches = _get_matches(rules, options)
# Assure we do not print duplicates and the order is consistent
matches = sorted(set(matches))
mark_as_success = False
if matches and options.progressive:
_logger.info(
"Matches found, running again on previous revision in order to detect regressions"
)
with _previous_revision():
old_matches = _get_matches(rules, options)
# remove old matches from current list
matches_delta = list(set(matches) - set(old_matches))
if len(matches_delta) == 0:
_logger.warning(
"Total violations not increased since previous "
"commit, will mark result as success. (%s -> %s)",
len(old_matches), len(matches_delta))
mark_as_success = True
ignored = 0
for match in matches:
# if match is not new, mark is as ignored
if match not in matches_delta:
match.ignored = True
ignored += 1
if ignored:
_logger.warning(
"Marked %s previously known violation(s) as ignored due to"
" progressive mode.", ignored)
_render_matches(matches, options, formatter, cwd)
if matches and not mark_as_success:
return report_outcome(matches, options=options)
else:
return 0
def main(args):
# formatter = formatters.Formatter()
parser = optparse.OptionParser("%prog [options] [playbook.yml [playbook2 ...]]|roledirectory",
version="%prog " + __version__)
parser.add_option('-L', dest='listrules', default=False,
action='store_true', help="list all the rules")
parser.add_option('-q', dest='quiet',
default=False,
action='store_true',
help="quieter, although not silent output")
parser.add_option('-p', dest='parseable',
default=False,
action='store_true',
help="parseable output in the format of pep8")
parser.add_option('--parseable-severity', dest='parseable_severity',
default=False,
action='store_true',
help="parseable output including severity of rule")
parser.add_option('-r', action='append', dest='rulesdir',
default=[], type='str',
help="specify one or more rules directories using "
"one or more -r arguments. Any -r flags override "
"the default rules in %s, unless -R is also used."
% DEFAULT_RULESDIR)
parser.add_option('-R', action='store_true',
default=False,
dest='use_default_rules',
help="Use default rules in %s in addition to any extra "
"rules directories specified with -r. There is "
"no need to specify this if no -r flags are used"
% DEFAULT_RULESDIR)
parser.add_option('-t', dest='tags',
action='append',
default=[],
help="only check rules whosef id/tags match these values")
parser.add_option('-T', dest='listtags', action='store_true',
help="list all the tags")
parser.add_option('-v', dest='verbosity', action='count',
help="Increase verbosity level",
default=0)
parser.add_option('-x', dest='skip_list', default=[], action='append',
help="only check rules whose id/tags do not " +
"match these values")
parser.add_option('--nocolor', dest='colored',
default=hasattr(sys.stdout, 'isatty') and sys.stdout.isatty(),
action='store_false',
help="disable colored output")
parser.add_option('--force-color', dest='colored',
action='store_true',
help="Try force colored output (relying on ansible's code)")
parser.add_option('--exclude', dest='exclude_paths', action='append',
help='path to directories or files to skip. This option'
' is repeatable.',
default=[])
parser.add_option('-c', dest='config_file',
help='Specify configuration file to use. Defaults to ".ansible-lint"')
options, args = parser.parse_args(args)
config = load_config(options.config_file)
if config:
if 'quiet' in config:
options.quiet = options.quiet or config['quiet']
if 'parseable' in config:
options.parseable = options.parseable or config['parseable']
if 'parseable_severity' in config:
options.parseable_severity = options.parseable_severity or \
config['parseable_severity']
if 'use_default_rules' in config:
options.use_default_rules = options.use_default_rules or config['use_default_rules']
if 'verbosity' in config:
options.verbosity = options.verbosity + config['verbosity']
options.exclude_paths.extend(
config.get('exclude_paths', []))
if 'rulesdir' in config:
options.rulesdir = options.rulesdir + config['rulesdir']
if 'skip_list' in config:
options.skip_list = options.skip_list + config['skip_list']
if 'tags' in config:
options.tags = options.tags + config['tags']
if options.quiet:
formatter = formatters.QuietFormatter()
if options.parseable:
formatter = formatters.ParseableFormatter()
if options.parseable_severity:
formatter = formatters.ParseableSeverityFormatter()
# # # no args triggers auto-detection mode
# if len(args) == 0 and not (options.listrules or options.listtags):
# args = get_playbooks_and_roles(options=options)
if options.use_default_rules:
rulesdirs = options.rulesdir + [DEFAULT_RULESDIR]
else:
rulesdirs = options.rulesdir or [DEFAULT_RULESDIR]
rules = RulesCollection(rulesdirs)
# for rulesdir in rulesdirs:
# rules.extend(RulesCollection.load_plugins(rulesdir))
if options.listrules:
print(rules)
return 0
if options.listtags:
print(rules.listtags())
return 0
if isinstance(options.tags, six.string_types):
options.tags = options.tags.split(',')
skip = set()
for s in options.skip_list:
skip.update(str(s).split(','))
options.skip_list = frozenset(skip)
playbooks = sorted(set(args))
matches = list()
checked_files = set()
for playbook in playbooks:
runner = Runner(playbook=playbook, rules=rules)
matches.extend(runner.run())
matches.sort(key=lambda x: (normpath(x.filename), x.linenumber, x.rule.id))
return matches
