Source code for squabble.cli

  squabble [options] [PATHS...]
  squabble (-h | --help)

  PATHS  Paths to check. If given a directory, will recursively traverse the
         path and lint all files ending in `.sql` [default: -].

  -h --help               Show this screen.
  -V --verbose            Turn on debug level logging.
  -v --version            Show version information.

  -x --expanded           Show explantions for every raised message.

  -c --config=PATH        Path to configuration file.
  -p --preset=PRESETS     Comma-separated list of presets to use as a base.
  -r --reporter=REPORTER  Use REPORTER for output rather than one in config.

  -e --explain=CODE       Show detailed explanation of a message code.
  --list-presets          List available preset configurations.
  --list-rules            List available rules.
  --show-rule=RULE        Show detailed information about RULE.

import glob
import json
import os.path
import sys

import docopt
from colorama import Style
from pkg_resources import get_distribution

import squabble
import squabble.message
from squabble import config, lint, reporter, rule
from squabble.util import strip_rst_directives

[docs]def main(): version = get_distribution('squabble').version args = docopt.docopt(__doc__, version=version) return dispatch_args(args)
[docs]def dispatch_args(args): """ Handle the command line arguments as parsed by ``docopt``. Calls the subroutine implied by the combination of command line flags and returns the exit status (or ``None``, if successful) of the program. Note that some exceptional conditions will terminate the program directly. """ if args['--verbose']: squabble.logger.setLevel('DEBUG') if args['--list-presets']: return list_presets() config_file = args['--config'] or config.discover_config_location() if config_file and not os.path.exists(config_file): sys.exit('%s: no such file or directory' % config_file) presets = args['--preset'].split(',') if args['--preset'] else [] base_config = config.load_config( config_file, preset_names=presets, reporter_name=args['--reporter']) # Load all of the rule classes into memory (need to do this now to # be able to list all rules / show rule details) rule.load_rules(plugin_paths=base_config.plugins) if args['--list-rules']: return list_rules() if args['--show-rule']: return show_rule(name=args['--show-rule']) if args['--explain']: return explain_message(code=args['--explain']) return run_linter(base_config, args['PATHS'], args['--expanded'])
[docs]def run_linter(base_config, paths, expanded): """ Run linter against all SQL files contained in ``paths``. ``paths`` may contain both files and directories. If ``paths`` is empty or only contains ``"-"``, squabble will read from stdin instead. If ``expanded`` is ``True``, print the detailed explanation of each message after the lint has finished. """ if not paths: paths = ['-'] files = collect_files(paths) issues = [] for file_name, contents in files: file_config = config.apply_file_config(base_config, contents) if file_config is None: continue issues += lint.check_file(file_config, file_name, contents), issues, dict(files)) if expanded: codes = { i.message.CODE for i in issues if i.message } for c in codes: print('\n') explain_message(c) # Make sure we have an error status if something went wrong. return 1 if issues else 0
def _slurp_file(file_name): """Read entire contents of ``file_name`` as text.""" with open(file_name, 'r') as fp: return def _slurp_stdin(): """ Read entirety of stdin and return as string, or ``None`` if a ``^c`` interrupt is triggered. """ try: return except KeyboardInterrupt: return None
[docs]def collect_files(paths): """ Given a list of files or directories, find all named files as well as any files ending in `.sql` in the directories. The return format is a list of tuples containing the file name and file contents. The value ``'-'`` is treated specially as stdin. """ files = [] for path in map(os.path.expanduser, paths): if path == '-': stdin = _slurp_stdin() if stdin is not None and stdin.strip() != '': files.append(('stdin', stdin)) elif not os.path.exists(path): sys.exit('%s: no such file or directory' % path) elif os.path.isdir(path): sql_glob = os.path.join(path, '**/*.sql') sql_files = glob.iglob(sql_glob, recursive=True) files.extend(collect_files(sql_files)) else: files.append((path, _slurp_file(path))) return files
[docs]def show_rule(name): """Print information about rule named ``name``.""" color = { 'bold': Style.BRIGHT, 'reset': Style.RESET_ALL, } try: meta = rule.Registry.get_meta(name) except squabble.UnknownRuleException: sys.exit('{bold}Unknown rule:{reset} {name}'.format(**{ 'name': name, **color })) print('{bold}{name}{reset} - {description}\n\n{help}'.format(**{ **meta, **color }))
[docs]def list_rules(): """Print out all registered rules and brief description of what they do.""" color = { 'bold': Style.BRIGHT, 'reset': Style.RESET_ALL, } all_rules = sorted(rule.Registry.all(), key=lambda r: r['name']) for meta in all_rules: desc = strip_rst_directives(meta['description']) print('{bold}{name: <32}{reset} {description}'.format(**{ **color, **meta, 'desc': desc, }))
[docs]def explain_message(code): """Print out the more detailed explanation of the given message code.""" try: code = int(code) cls = squabble.message.Registry.by_code(code) except (ValueError, KeyError): sys.exit('{bold}Unknown message code:{reset} {code}'.format( bold=Style.BRIGHT, reset=Style.RESET_ALL, code=code )) print('{bold}{name}{reset} [{code}]\n'.format( bold=Style.BRIGHT, reset=Style.RESET_ALL, code=cls.CODE, name=cls.__name__ )) explanation = cls.explain() or 'No additional info.' print(strip_rst_directives(explanation))
[docs]def list_presets(): """Print out all the preset configurations.""" for name, preset in config.PRESETS.items(): print('{bold}{name}{reset} - {description}'.format( name=name, description=preset.get('description', ''), bold=Style.BRIGHT, reset=Style.RESET_ALL )) # npm here i come left_pad = ' ' cfg = json.dumps(preset['config'], indent=4)\ .replace('\n', '\n' + left_pad) print(left_pad + cfg)