noahtheduke.splint.runner — io.github.noahtheduke/splint 1.11

Handles parsing and linting all of given files.

build-result-map clj

(build-result-map ctx files)

check-all-rules-of-type clj

(check-all-rules-of-type ctx rules form)

For each rule: if the rule is enabled, call check-rule. If check-rule returns a non-nil result, add or append it to the accumulator. Otherwise, return the accumulator.

check-and-recur clj

(check-and-recur ctx rules-by-type filename parent-form form)

Check a given form and then map recur over each of the form's children.

check-files! clj

(check-files! ctx rules-by-type files)

Call into the relevant check-path-X function, depending on the given config.

check-files-parallel clj

(check-files-parallel ctx rules-by-type files)

check-files-serial clj

(check-files-serial ctx rules-by-type files)

check-form clj

(check-form ctx rules form)

Checks a given form against the appropriate rules then calls on-match to build the diagnostic and store it in ctx.

check-pattern clj

(check-pattern ctx rule pattern form)

Call :pattern on the form and if it hits, call :on-match on it.

Only attach parent-form to the metadata after :pattern is true, cuz parent-form can be potentially massive.

This has implications for pattern writing, where predicates can't rely on that metadata to exist.

check-rule clj

(check-rule ctx rule form)

Rules either have :pattern or :patterns defined, never both. To avoid iteration and seq manipulation costs, handle them separately.

Use reduced to early exit when checking multiple patterns as we don't want to create multiple diagnostics for a single form and rule.

exception->ex-info clj

(exception->ex-info ex data)

get-extension clj

(get-extension file)

parse-and-check-file clj

(parse-and-check-file ctx
                      rules-by-type
                      {:keys [ext file contents] :as file-obj})

Parse the given file and then check each form.

pre-filter-rules clj

(pre-filter-rules ctx rules-by-type)

Fully remove disabled rules or rules that don't apply to the current filetype.

prepare-context clj

(prepare-context rules config)

prepare-rules clj

(prepare-rules config rules)

resolve-files-from-paths clj

(resolve-files-from-paths ctx paths)

right-ext? clj

(right-ext? ext rule)

right-path? clj

(right-path? ctx rule)

run clj

(run args)

Convert command line args to usable options, pass to runner, print output.

run-impl clj

(run-impl paths config)

(run-impl paths config rules)

Actually perform check

runner-error->diagnostic clj

(runner-error->diagnostic ex)

slurp-file clj

(slurp-file file-obj)

support-clojure-version? clj

(support-clojure-version? config rule)

update-rules clj

(update-rules rules-by-type form)