quiet_quality 1.0.3 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7372d3c4b395adb2890c54270426bf92b9a2a9e2669ef27d5145eda776d1072
-  data.tar.gz: 5877277009b82e9685e62f8f8a1f17aec823faaad93c3c8e40dcb7f2640d0e7c
+  metadata.gz: ae3f031f4d627e624ce2ae28a5cf58d8e9e0663822371089d54bda51cb1aefeb
+  data.tar.gz: c9c26fd4d3df19e70162b38ef78622cc569ea492656d9264c4a41a964931934a
 SHA512:
-  metadata.gz: 4c860d24410fd6a03390e726fdc699113f3d0c21b722e12ccf564c666b5708690d8ed90a092448f3942496a47331e10b3d3bb7580ba2e0feeafbf74ea60bdb03
-  data.tar.gz: 67b89da10e8fc43370d586d9282776c2f1f23a0fa4fcfbea5bfd596ab6520cca7c9319731fd960c63dc04e36ab7021b83e27497d52f2e10b8cdd9ef8a39ad394
+  metadata.gz: 6925f90d2f144b9bd59b4f0ca8d9a28e41cebf8570b30e3fa85cee6eefe2961aaaf246f733cd9b62de0d070afb7cca545c650ead15e45a6a39372d34c4240023
+  data.tar.gz: 3589c916dab556a467ab64c974ea91eda6a4f6f229ccda58aa51488b13b3a9a44217206fb3962697570cd176fb1bd282bee6231eccad5b50e1d948f0758eb8fb

data/.github/workflows/dogfood.yml

@@ -27,4 +27,4 @@ jobs:
         run: bundle install --jobs 4 --retry 3
 
       - name: Run QuietQuality
-        run: bundle exec bin/qq standardrb rubocop rspec --all-files --unfiltered --annotate github_stdout --comparison-branch origin/main
+        run: bundle exec bin/qq -C .quiet_quality.ci.yml

data/.quiet_quality.ci.yml

@@ -0,0 +1,6 @@
+---
+default_tools: ["standardrb", "rubocop", "markdown_lint", "rspec"]
+executor: concurrent
+comparison_branch: origin/main
+all_files: true
+unfiltered: true

data/.quiet_quality.yml

@@ -1,6 +1,7 @@
 ---
-default_tools: ["standardrb", "rubocop", "rspec"]
+default_tools: ["standardrb", "rubocop", "markdown_lint", "rspec"]
 executor: concurrent
 comparison_branch: main
 changed_files: false
 filter_messages: false
+logging: light

data/CHANGELOG.md

@@ -0,0 +1,52 @@
+# Changelog
+
+## Release 1.2.0
+
+* Support `--light`, `--quiet`, and `--logging LEVEL` arguments for less output
+  (#78, resolves #37)
+* Support the [markdownlint](https://github.com/markdownlint/markdownlint) tool
+  (#79, resolves #58)
+* Extract BaseRunner (#82) and RelevantRunner (#83) parent classes from the tool
+  runners, to allow new tools to be more easily implemented. (Resolves #81)
+* Extract a Cli::Presenter from the Entrypoint, to simplify pending work on cli
+  presentation (#84, resolves #42)
+* Update the docs a bit, and add a changelog (hi!)
+
+## Release 1.1.0
+
+* Support a `file_filter` config entry per-tool (without a cli option), to limit
+  what file paths a runner might supply to its tool based on a regex
+  (#74, resolves #68)
+* When what tools to execute is not specified (by cli or by config file), abort
+  `bin/qq` and explain, rather than assuming "all of them" (#79, resolves #58)
+* Update the config parser to handle keys named to match the cli options
+  alongside the ones that were (mistakenly) named differently. This is a
+  backwards-compatible change; if we eventually deprecate and simplify some of
+  these option names, you'll have plenty of warning (#77, resolves #75)
+* Support `--version/-V` flag (#73, resolves #69)
+
+## Release 1.0.3
+
+* Fix the printed _output_ for the case where there were some warnings from a
+  tool, but all of them were filtered out (because they targetted lines that
+  were not changed, for example). This situation should tell you that nothing
+  is wrong with your PR, not that there is a problem (#71)
+
+## Release 1.0.2
+
+* Fix the _exit status_ for the case where there were some warnings from a
+  tool, but all of them were filtered out (because they targetted lines that
+  were not changed, for example). This situation should produce a successful
+  result, and not fail a CI pipeline (#67)
+
+## Release 1.0.1
+
+* Fix the calculation of `changed_files` for the executor - in the migration
+  to Entrypoint, the actual git call to get a ChangedFiles object to pass into
+  other service classes was lost, which had the result that the entire system
+  behaved (outside of tests) as if you were always running with `--all-files`
+  (#65).
+
+## Release 1.0.0
+
+Initial functional public release.

data/README.md

@@ -14,11 +14,13 @@ that too.
 
 So far, we have support for the following tools:
 
-* rubocop
-* standardrb
-* rspec
-* haml-lint
-* brakeman (though there's no way to run this against only changed files)
+* [rubocop](https://github.com/rubocop/rubocop)
+* [standardrb](https://github.com/standardrb/standard)
+* [rspec](https://rspec.info/)
+* [haml-lint](https://github.com/sds/haml-lint)
+* [markdownlint](https://github.com/markdownlint/markdownlint)
+* [brakeman](https://brakemanscanner.org/) (though there's no way to run this
+  against only changed files)
 
 Supporting more tools is relatively straightforward - they're implemented by
 wrapping cli invocations and parsing output files (which overall seem to be much
@@ -126,6 +128,9 @@ And then run `qq -C config/quiet_quality/linters_workflow.yml`
 
 The configuration file supports the following _global_ options (top-level keys):
 
+* `default_tools`: Which tools should be run when you `qq` without specifying?
+  Valid values are: `rubocop`, `rspec`, `standardrb`, `haml_lint`, `brakeman`,
+  and `markdown_lint`.
 * `executor`: 'serial' or 'concurrent' (the latter is the default)
 * `annotator`: none set by default, and `github_stdout` is the only supported
   value so far.
@@ -139,17 +144,59 @@ The configuration file supports the following _global_ options (top-level keys):
 * `filter_messages`: defaults to false - should the resulting messages that do
   not refer to lines that were changed or added relative to the comparison
   branch be skipped? Also possible to set for each tool.
+* `logging`: defaults to full messages printed. The `light` option
+  prints a aggregated result (e.g. "3 tools executed: 1 passed, 2 failed
+  (rubocop, standardrb)"). The `quiet` option will only return a status code,
+  printing nothing.
 
 And then each tool can have an entry, within which `changed_files` and
 `filter_messages` can be specified - the tool-specific settings override the
 global ones.
 
-### CLI Options
+The tools have one additional setting that is not available at a global level:
+`file_filter`. This is a string that will be turned into a _ruby regex_, and
+used to limit what file paths are passed to the tool. For example, if you are
+working in a rails engine `engines/foo/`, and you touch one of the rspec tests
+there, you would not want `qq` in the root of the repository to run
+`rspec engines/foo/spec/foo/thing_spec.rb` - that probably won't work, as your
+engine will have its own test setup code and Gemfile. This setting is mostly
+intended to be used like this:
 
-The same options are all available on the CLI, plus some additional ones - run
-`qq --help` for a detailed list of the options, but the notable additions are:
+```yaml
+rspec:
+  changed_files: true
+  filter_messages: false
+  file_filter: "^spec/"
+```
 
-* `--help/-H`: See a list of the options
-* `--no-config/-N`: Do _not_ load a config file, even if present.
-* `--config/-C` load the supplied config file (instead of the detected one, if
-  found)
+### CLI Options
+
+To specify which _tools_ to run (and if any are specified, the `default_tools`
+from the configuration file will be ignored), you supply them as positional
+arguments: `qq rubocop rspec --all-files -L` will run the `rubocop` and `rspec`
+tools, for example.
+
+Run `qq --help` for a detailed list of the CLI options, they largely agree with
+those in the configuration file, but there are some differences. There's no way
+to specify a `file_filter` for a tool on the command-line, and there are some
+additional options available focused on managing the interactions with
+configuration files.
+
+```text
+Usage: qq [TOOLS] [GLOBAL_OPTIONS] [TOOL_OPTIONS]
+    -h, --help                       Prints this help
+    -V, --version                    Print the current version of the gem
+    -C, --config PATH                Load a config file from this path
+    -N, --no-config                  Do not load a config file, even if present
+    -E, --executor EXECUTOR          Which executor to use
+    -A, --annotate ANNOTATOR         Annotate with this annotator
+    -G, --annotate-github-stdout     Annotate with GitHub Workflow commands
+    -a, --all-files [tool]           Use the tool(s) on all files
+    -c, --changed-files [tool]       Use the tool(s) only on changed files
+    -B, --comparison-branch BRANCH   Specify the branch to compare against
+    -f, --filter-messages [tool]     Filter messages from tool(s) based on changed lines
+    -u, --unfiltered [tool]          Don't filter messages from tool(s)
+    -l, --light                      Print aggregated results only
+    -q, --quiet                      Don't print results, only return a status code
+    -L, --logging LEVEL              Specify logging mode that results will be returned in. Valid options: light, quiet
+```

data/lib/quiet_quality/cli/arg_parser.rb

@@ -65,6 +65,7 @@ module QuietQuality
           setup_annotation_options(parser)
           setup_file_target_options(parser)
           setup_filter_messages_options(parser)
+          setup_logging_options(parser)
         end
       end
 
@@ -76,6 +77,10 @@ module QuietQuality
         parser.on("-h", "--help", "Prints this help") do
           @parsed_options.helping = true
         end
+
+        parser.on("-V", "--version", "Print the current version of the gem") do
+          @parsed_options.printing_version = true
+        end
       end
 
       def setup_config_options(parser)
@@ -130,6 +135,21 @@ module QuietQuality
           read_tool_or_global_option(:filter_messages, tool, false)
         end
       end
+
+      def setup_logging_options(parser)
+        parser.on("-l", "--light", "Print aggregated results only") do
+          set_global_option(:logging, Config::Logging::LIGHT)
+        end
+
+        parser.on("-q", "--quiet", "Don't print results, only return a status code") do
+          set_global_option(:logging, Config::Logging::QUIET)
+        end
+
+        parser.on("-L", "--logging LEVEL", "Specify logging mode that results will be returned in. Valid options: light, quiet") do |level|
+          validate_value_from("logging level", level, Config::Logging::LEVELS)
+          set_global_option(:logging, level.to_sym)
+        end
+      end
     end
   end
 end

data/lib/quiet_quality/cli/entrypoint.rb

@@ -10,10 +10,13 @@ module QuietQuality
       def execute
         if helping?
           log_help_text
+        elsif printing_version?
+          log_version_text
+        elsif no_tools?
+          log_no_tools_text
         else
           executed
-          log_outcomes
-          log_messages
+          log_results
           annotate_messages
         end
 
@@ -21,13 +24,32 @@ module QuietQuality
       end
 
       def successful?
-        helping? || !executed.any_failure?
+        return true if helping? || printing_version?
+        return false if no_tools?
+        !executed.any_failure?
       end
 
       private
 
       attr_reader :argv, :output_stream, :error_stream
 
+      def logger
+        @_logger ||= QuietQuality::Logger.new(stream: error_stream, logging: options.logging)
+      end
+
+      def presenter
+        @_presenter ||= Presenter.new(
+          logger: logger,
+          logging: options.logging,
+          outcomes: executor.outcomes,
+          messages: executor.messages
+        )
+      end
+
+      def log_results
+        presenter.log_results
+      end
+
       def arg_parser
         @_arg_parser ||= ArgParser.new(argv.dup)
       end
@@ -40,8 +62,35 @@ module QuietQuality
         parsed_options.helping?
       end
 
+      def quiet_logging?
+        options.logging.quiet?
+      end
+
+      def light_logging?
+        options.logging.light?
+      end
+
+      def printing_version?
+        parsed_options.printing_version?
+      end
+
+      def no_tools?
+        options.tools.empty?
+      end
+
       def log_help_text
-        error_stream.puts(arg_parser.help_text)
+        logger.puts(arg_parser.help_text)
+      end
+
+      def log_version_text
+        logger.puts(QuietQuality::VERSION)
+      end
+
+      def log_no_tools_text
+        logger.puts(<<~TEXT)
+          You must specify one or more tools to run, either on the command-line or in the
+          default_tools key in a configuration file.
+        TEXT
       end
 
       def options
@@ -70,31 +119,6 @@ module QuietQuality
         @_executed = executor
       end
 
-      def log_outcomes
-        executed.outcomes.each do |outcome|
-          result = outcome.success? ? "Passed" : "Failed"
-          error_stream.puts "--- #{result}: #{outcome.tool}"
-        end
-      end
-
-      def log_message(msg)
-        line_range =
-          if msg.start_line == msg.stop_line
-            msg.start_line.to_s
-          else
-            "#{msg.start_line}-#{msg.stop_line}"
-          end
-        rule_string = msg.rule ? "  [#{msg.rule}]" : ""
-        truncated_body = msg.body.gsub(/ *\n */, "\\n").slice(0, 120)
-        error_stream.puts "  #{msg.path}:#{line_range}#{rule_string}  #{truncated_body}"
-      end
-
-      def log_messages
-        return unless executed.messages.any?
-        error_stream.puts "\n\n#{executed.messages.count} messages:"
-        executed.messages.each { |msg| log_message(msg) }
-      end
-
       def annotate_messages
         return unless options.annotator
         annotator = options.annotator.new(output_stream: output_stream)

data/lib/quiet_quality/cli/presenter.rb

@@ -0,0 +1,77 @@
+module QuietQuality
+  module Cli
+    class Presenter
+      def initialize(logger:, logging:, outcomes:, messages:)
+        @logger = logger
+        @logging = logging
+        @outcomes = outcomes
+        @messages = messages
+      end
+
+      def log_results
+        return if logging.quiet?
+
+        if logging.light?
+          log_light_outcomes
+        else
+          log_outcomes
+          log_messages
+        end
+      end
+
+      private
+
+      attr_reader :logger, :logging, :outcomes, :messages
+
+      def failed_outcomes
+        @_failed_outcomes ||= outcomes.select(&:failure?)
+      end
+
+      def successful_outcomes
+        @_successful_outcomes ||= outcomes.select(&:success?)
+      end
+
+      def log_light_outcomes
+        line = "%d tools executed: %d passed, %d failed" % [
+          outcomes.count,
+          successful_outcomes.count,
+          failed_outcomes.count
+        ]
+        line += " (#{failed_outcomes.map(&:tool).join(", ")})" if failed_outcomes.any?
+        logger.puts line
+      end
+
+      def log_outcomes
+        outcomes.each do |outcome|
+          result = outcome.success? ? "Passed" : "Failed"
+          logger.puts "--- #{result}: #{outcome.tool}"
+        end
+      end
+
+      def log_messages
+        return unless messages.any?
+        logger.puts "\n\n#{messages.count} messages:"
+        messages.each { |msg| log_message(msg) }
+      end
+
+      def line_range_for(msg)
+        if msg.start_line == msg.stop_line
+          msg.start_line.to_s
+        else
+          "#{msg.start_line}-#{msg.stop_line}"
+        end
+      end
+
+      def reduce_text(s, length)
+        s.gsub(/ *\n */, "\\n").slice(0, length)
+      end
+
+      def log_message(msg)
+        line_range = line_range_for(msg)
+        rule_string = msg.rule ? "  [#{msg.rule}]" : ""
+        truncated_body = reduce_text(msg.body, 120)
+        logger.puts "  #{msg.path}:#{line_range}#{rule_string}  #{truncated_body}"
+      end
+    end
+  end
+end

data/lib/quiet_quality/config/builder.rb

@@ -28,7 +28,7 @@ module QuietQuality
         elsif config_file&.tools&.any?
           config_file.tools
         else
-          Tools::AVAILABLE.keys
+          []
         end
       end
 
@@ -85,6 +85,7 @@ module QuietQuality
           update_annotator
           update_executor
           update_comparison_branch
+          update_logging
         end
 
         def update_annotator
@@ -103,12 +104,17 @@ module QuietQuality
           set_unless_nil(options, :comparison_branch, apply.global_option(:comparison_branch))
         end
 
+        def update_logging
+          set_unless_nil(options, :logging, apply.global_option(:logging))
+        end
+
         # ---- update the tool options (apply global forms first) -------
 
         def update_tools
           options.tools.each do |tool_options|
             update_tool_option(tool_options, :limit_targets)
             update_tool_option(tool_options, :filter_messages)
+            update_tool_option(tool_options, :file_filter)
           end
         end
 

data/lib/quiet_quality/config/logging.rb

@@ -0,0 +1,23 @@
+module QuietQuality
+  module Config
+    class Logging
+      LIGHT = :light
+      QUIET = :quiet
+      LEVELS = [LIGHT, QUIET].freeze
+
+      attr_accessor :level
+
+      def initialize(level: nil)
+        @level = level
+      end
+
+      def light?
+        @level == LIGHT
+      end
+
+      def quiet?
+        @level == QUIET
+      end
+    end
+  end
+end

data/lib/quiet_quality/config/options.rb

@@ -6,9 +6,15 @@ module QuietQuality
         @executor = Executors::ConcurrentExecutor
         @tools = nil
         @comparison_branch = nil
+        @logging = Logging.new
       end
 
       attr_accessor :tools, :comparison_branch, :annotator, :executor
+      attr_reader :logging
+
+      def logging=(level)
+        @logging.level = level
+      end
     end
   end
 end

data/lib/quiet_quality/config/parsed_options.rb

@@ -5,16 +5,20 @@ module QuietQuality
         @tools = []
         @tool_options = {}
         @global_options = {}
-        @helping = false
+        @helping = @printing_version = false
       end
 
       attr_accessor :tools
-      attr_writer :helping
+      attr_writer :helping, :printing_version
 
       def helping?
         @helping
       end
 
+      def printing_version?
+        @printing_version
+      end
+
       def set_global_option(name, value)
         @global_options[name.to_sym] = value
       end

data/lib/quiet_quality/config/parser.rb

@@ -38,11 +38,15 @@ module QuietQuality
       end
 
       def store_global_options(opts)
-        read_global_option(opts, :executor, as: :symbol, validate_from: Executors::AVAILABLE)
-        read_global_option(opts, :annotator, as: :symbol, validate_from: Annotators::ANNOTATOR_TYPES)
-        read_global_option(opts, :comparison_branch, as: :string)
-        read_global_option(opts, :changed_files, as: :boolean)
-        read_global_option(opts, :filter_messages, as: :boolean)
+        read_global_option(opts, :executor, :executor, as: :symbol, validate_from: Executors::AVAILABLE)
+        read_global_option(opts, :annotator, :annotator, as: :symbol, validate_from: Annotators::ANNOTATOR_TYPES)
+        read_global_option(opts, :annotate, :annotator, as: :symbol, validate_from: Annotators::ANNOTATOR_TYPES)
+        read_global_option(opts, :comparison_branch, :comparison_branch, as: :string)
+        read_global_option(opts, :changed_files, :changed_files, as: :boolean)
+        read_global_option(opts, :all_files, :changed_files, as: :reversed_boolean)
+        read_global_option(opts, :filter_messages, :filter_messages, as: :boolean)
+        read_global_option(opts, :unfiltered, :filter_messages, as: :reversed_boolean)
+        read_global_option(opts, :logging, :logging, as: :symbol, validate_from: Logging::LEVELS)
       end
 
       def store_tool_options(opts)
@@ -54,8 +58,12 @@ module QuietQuality
       def store_tool_options_for(opts, tool_name)
         entries = data.fetch(tool_name, nil)
         return if entries.nil?
-        read_tool_option(opts, tool_name, :filter_messages, as: :boolean)
-        read_tool_option(opts, tool_name, :changed_files, as: :boolean)
+
+        read_tool_option(opts, tool_name, :filter_messages, :filter_messages, as: :boolean)
+        read_tool_option(opts, tool_name, :unfiltered, :filter_messages, as: :reversed_boolean)
+        read_tool_option(opts, tool_name, :changed_files, :changed_files, as: :boolean)
+        read_tool_option(opts, tool_name, :all_files, :changed_files, as: :reversed_boolean)
+        read_tool_option(opts, tool_name, :file_filter, :file_filter, as: :string)
       end
 
       def invalid!(message)
@@ -70,27 +78,28 @@ module QuietQuality
         [true, false].include?(value)
       end
 
-      def read_global_option(opts, name, as:, validate_from: nil)
+      def read_global_option(opts, name, into, as:, validate_from: nil)
         parsed_value = data.fetch(name.to_sym, nil)
         return if parsed_value.nil?
 
         validate_value(name, parsed_value, as: as, from: validate_from)
         coerced_value = coerce_value(parsed_value, as: as)
-        opts.set_global_option(name, coerced_value)
+        opts.set_global_option(into, coerced_value)
       end
 
-      def read_tool_option(opts, tool, name, as:)
+      def read_tool_option(opts, tool, name, into, as:)
         parsed_value = data.dig(tool.to_sym, name.to_sym)
         return if parsed_value.nil?
 
         validate_value("#{tool}.#{name}", parsed_value, as: as)
         coerced_value = coerce_value(parsed_value, as: as)
-        opts.set_tool_option(tool, name, coerced_value)
+        opts.set_tool_option(tool, into, coerced_value)
       end
 
       def validate_value(name, value, as:, from: nil)
         case as
         when :boolean then validate_boolean(name, value)
+        when :reversed_boolean then validate_boolean(name, value)
         when :symbol then validate_symbol(name, value, from: from)
         when :string then validate_string(name, value)
         else
@@ -123,6 +132,7 @@ module QuietQuality
       def coerce_value(value, as:)
         case as
         when :boolean then !!value
+        when :reversed_boolean then !value
         when :string then value.to_s
         when :symbol then value.to_sym
         else

data/lib/quiet_quality/config/tool_options.rb

@@ -1,14 +1,15 @@
 module QuietQuality
   module Config
     class ToolOptions
-      def initialize(tool, limit_targets: true, filter_messages: true)
+      def initialize(tool, limit_targets: true, filter_messages: true, file_filter: nil)
         @tool_name = tool.to_sym
         @limit_targets = limit_targets
         @filter_messages = filter_messages
+        @file_filter = file_filter
       end
 
       attr_reader :tool_name
-      attr_writer :limit_targets, :filter_messages
+      attr_writer :limit_targets, :filter_messages, :file_filter
 
       def limit_targets?
         @limit_targets
@@ -29,6 +30,11 @@ module QuietQuality
       def parser_class
         tool_namespace::Parser
       end
+
+      def file_filter
+        return nil if @file_filter.nil?
+        Regexp.new(@file_filter)
+      end
     end
   end
 end

data/lib/quiet_quality/executors/base_executor.rb

@@ -22,6 +22,14 @@ module QuietQuality
         pipelines.any?(&:failure?)
       end
 
+      def successful_outcomes
+        @_successful_outcomes ||= outcomes.select(&:success?)
+      end
+
+      def failed_outcomes
+        @_failed_outcomes ||= outcomes.select(&:failure?)
+      end
+
       private
 
       attr_reader :tools, :changed_files

data/lib/quiet_quality/executors/pipeline.rb

@@ -48,8 +48,10 @@ module QuietQuality
       end
 
       def runner
-        @_runner ||= tool_options.runner_class
-          .new(changed_files: limit_targets? ? changed_files : nil)
+        @_runner ||= tool_options.runner_class.new(
+          changed_files: limit_targets? ? changed_files : nil,
+          file_filter: tool_options.file_filter
+        )
       end
 
       def parser

data/lib/quiet_quality/logger.rb

@@ -0,0 +1,17 @@
+module QuietQuality
+  class Logger
+    def initialize(stream:, logging:)
+      @stream = stream
+      @logging = logging
+    end
+
+    def puts(s)
+      return if logging.quiet?
+      stream.puts(s)
+    end
+
+    private
+
+    attr_reader :stream, :logging
+  end
+end

data/lib/quiet_quality/tools/base_runner.rb

@@ -0,0 +1,49 @@
+module QuietQuality
+  module Tools
+    class BaseRunner
+      # In general, we don't want to supply a huge number of arguments to a command-line tool.
+      MAX_FILES = 100
+
+      def initialize(changed_files: nil, file_filter: nil)
+        @changed_files = changed_files
+        @file_filter = file_filter
+      end
+
+      def invoke!
+        @_outcome ||= performed_outcome
+      end
+
+      def tool_name
+        fail(NoMethodError, "BaseRunner subclass must implement `tool_name`")
+      end
+
+      def command
+        fail(NoMethodError, "BaseRunner subclass must implement `command`")
+      end
+
+      def success_status?(stat)
+        stat.success?
+      end
+
+      # distinct from _error_ status - this is asking "does this status represent failures-found?"
+      def failure_status?(stat)
+        stat.exitstatus == 1
+      end
+
+      private
+
+      attr_reader :changed_files, :file_filter
+
+      def performed_outcome
+        out, err, stat = Open3.capture3(*command)
+        if success_status?(stat)
+          Outcome.new(tool: tool_name, output: out, logging: err)
+        elsif failure_status?(stat)
+          Outcome.new(tool: tool_name, output: out, logging: err, failure: true)
+        else
+          fail(ExecutionError, "Execution of #{tool_name} failed with #{stat.exitstatus}")
+        end
+      end
+    end
+  end
+end

data/lib/quiet_quality/tools/brakeman/runner.rb

@@ -1,34 +1,19 @@
 module QuietQuality
   module Tools
     module Brakeman
-      class Runner
-        # These are specified in constants at the top of brakeman.rb:
-        #   https://github.com/presidentbeef/brakeman/blob/main/lib/brakeman.rb#L6-L25
-        KNOWN_EXIT_STATUSES = [3, 4, 5, 6, 7, 8].to_set
-
-        def initialize(changed_files: nil)
-          @changed_files = changed_files
-        end
-
-        def invoke!
-          @_outcome ||= performed_outcome
+      class Runner < BaseRunner
+        def tool_name
+          :brakeman
         end
 
-        private
-
         def command
           ["brakeman", "-f", "json"]
         end
 
-        def performed_outcome
-          out, err, stat = Open3.capture3(*command)
-          if stat.success?
-            Outcome.new(tool: :brakeman, output: out, logging: err)
-          elsif KNOWN_EXIT_STATUSES.include?(stat.exitstatus)
-            Outcome.new(tool: :brakeman, output: out, logging: err, failure: true)
-          else
-            fail(ExecutionError, "Execution of brakeman failed with #{stat.exitstatus}")
-          end
+        # These are specified in constants at the top of brakeman.rb:
+        #   https://github.com/presidentbeef/brakeman/blob/main/lib/brakeman.rb#L6-L25
+        def failure_status?(stat)
+          [3, 4, 5, 6, 7, 8].include?(stat.exitstatus)
         end
       end
     end

data/lib/quiet_quality/tools/brakeman.rb

@@ -3,8 +3,6 @@ require_relative "./rubocop"
 module QuietQuality
   module Tools
     module Brakeman
-      ExecutionError = Class.new(Tools::Error)
-      ParsingError = Class.new(Tools::Error)
     end
   end
 end

data/lib/quiet_quality/tools/haml_lint/runner.rb

@@ -1,61 +1,29 @@
 module QuietQuality
   module Tools
     module HamlLint
-      class Runner
-        MAX_FILES = 100
-        NO_FILES_OUTPUT = %({"files": []})
-
-        # haml-lint uses the `sysexits` gem, and exits with Sysexits::EX_DATAERR for the
-        # failures case here in lib/haml_lint/cli.rb. That's mapped to status 65 - other
-        # statuses have other failure meanings, which we don't want to interpret as "problems
-        # encountered"
-        FAILURE_STATUS = 65
-
-        def initialize(changed_files: nil)
-          @changed_files = changed_files
-        end
-
-        def invoke!
-          @_outcome ||= skip_execution? ? skipped_outcome : performed_outcome
-        end
-
-        private
-
-        attr_reader :changed_files
-
-        def skip_execution?
-          changed_files && relevant_files.empty?
-        end
-
-        def relevant_files
-          return nil if changed_files.nil?
-          changed_files.paths.select { |path| path.end_with?(".haml") }
+      class Runner < RelevantRunner
+        def tool_name
+          :haml_lint
         end
 
-        def target_files
-          return [] if changed_files.nil?
-          return [] if relevant_files.length > MAX_FILES
-          relevant_files
+        def no_files_output
+          %({"files": []})
         end
 
-        def command
-          return nil if skip_execution?
-          ["haml-lint", "--reporter", "json"] + target_files.sort
+        def base_command
+          ["haml-lint", "--reporter", "json"]
         end
 
-        def skipped_outcome
-          Outcome.new(tool: :haml_lint, output: NO_FILES_OUTPUT)
+        def relevant_path?(path)
+          path.end_with?(".haml")
         end
 
-        def performed_outcome
-          out, err, stat = Open3.capture3(*command)
-          if stat.success?
-            Outcome.new(tool: :haml_lint, output: out, logging: err)
-          elsif stat.exitstatus == FAILURE_STATUS
-            Outcome.new(tool: :haml_lint, output: out, logging: err, failure: true)
-          else
-            fail(ExecutionError, "Execution of haml-lint failed with #{stat.exitstatus}")
-          end
+        # haml-lint uses the `sysexits` gem, and exits with Sysexits::EX_DATAERR for the
+        # failures case here in lib/haml_lint/cli.rb. That's mapped to status 65 - other
+        # statuses have other failure meanings, which we don't want to interpret as "problems
+        # encountered"
+        def failure_status?(stat)
+          stat.exitstatus == 65
         end
       end
     end

data/lib/quiet_quality/tools/haml_lint.rb

@@ -1,8 +1,6 @@
 module QuietQuality
   module Tools
     module HamlLint
-      ExecutionError = Class.new(Tools::Error)
-      ParsingError = Class.new(Tools::Error)
     end
   end
 end

data/lib/quiet_quality/tools/markdown_lint/parser.rb

@@ -0,0 +1,34 @@
+module QuietQuality
+  module Tools
+    module MarkdownLint
+      class Parser
+        def initialize(text)
+          @text = text
+        end
+
+        def messages
+          return @_messages if defined?(@_messages)
+          messages = content.map { |entry| message_for_entry(entry) }
+          @_messages = Messages.new(messages)
+        end
+
+        private
+
+        attr_reader :text
+
+        def content
+          @_content ||= JSON.parse(text, symbolize_names: true)
+        end
+
+        def message_for_entry(entry)
+          Message.new(
+            path: entry.fetch(:filename),
+            start_line: entry.fetch(:line),
+            rule: entry.fetch(:description),
+            body: entry.fetch(:docs)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/quiet_quality/tools/markdown_lint/runner.rb

@@ -0,0 +1,28 @@
+module QuietQuality
+  module Tools
+    module MarkdownLint
+      class Runner < RelevantRunner
+        def tool_name
+          :markdown_lint
+        end
+
+        def no_files_output
+          "[]"
+        end
+
+        def command
+          return nil if skip_execution?
+          if target_files.any?
+            ["mdl", "--json"] + target_files.sort
+          else
+            ["mdl", "--json", "."]
+          end
+        end
+
+        def relevant_path?(path)
+          path.end_with?(".md")
+        end
+      end
+    end
+  end
+end

data/lib/quiet_quality/tools/markdown_lint.rb

@@ -0,0 +1,9 @@
+module QuietQuality
+  module Tools
+    module MarkdownLint
+    end
+  end
+end
+
+glob = File.expand_path("../markdown_lint/*.rb", __FILE__)
+Dir.glob(glob).sort.each { |f| require f }

data/lib/quiet_quality/tools/relevant_runner.rb

@@ -0,0 +1,55 @@
+require_relative "./base_runner"
+
+module QuietQuality
+  module Tools
+    class RelevantRunner < BaseRunner
+      # In general, we don't want to supply a huge number of arguments to a command-line tool.
+      # This will probably become configurable later.
+      MAX_FILES = 100
+
+      def invoke!
+        @_outcome ||= skip_execution? ? skipped_outcome : performed_outcome
+      end
+
+      def command
+        return nil if skip_execution?
+        base_command + target_files.sort
+      end
+
+      def relevant_path?(path)
+        fail(NoMethodError, "RelevantRunner subclass must implement `relevant_path?`")
+      end
+
+      def base_command
+        fail(NoMethodError, "RelevantRunner subclass must implement either `command` or `base_command`")
+      end
+
+      def no_files_output
+        fail(NoMethodError, "RelevantRunner subclass must implement `no_files_output`")
+      end
+
+      private
+
+      def skip_execution?
+        changed_files && relevant_files.empty?
+      end
+
+      def relevant_files
+        return nil if changed_files.nil?
+        changed_files.paths
+          .select { |path| relevant_path?(path) }
+          .select { |path| file_filter.nil? || file_filter.match?(path) }
+      end
+
+      def target_files
+        return [] if changed_files.nil?
+        return [] if relevant_files.length > MAX_FILES
+        relevant_files
+      end
+
+      def skipped_outcome
+        Outcome.new(tool: tool_name, output: no_files_output)
+      end
+    end
+  end
+end

data/lib/quiet_quality/tools/rspec/runner.rb

@@ -1,55 +1,21 @@
 module QuietQuality
   module Tools
     module Rspec
-      class Runner
-        MAX_FILES = 100
-        NO_FILES_OUTPUT = '{"examples": [], "summary": {"failure_count": 0}}'
-
-        def initialize(changed_files: nil)
-          @changed_files = changed_files
-        end
-
-        def invoke!
-          @_outcome ||= skip_execution? ? skipped_outcome : performed_outcome
-        end
-
-        private
-
-        attr_reader :changed_files
-
-        def skip_execution?
-          changed_files && relevant_files.empty?
-        end
-
-        def relevant_files
-          return nil if changed_files.nil?
-          changed_files.paths.select { |path| path.end_with?("_spec.rb") }
-        end
-
-        def target_files
-          return [] if changed_files.nil?
-          return [] if relevant_files.length > MAX_FILES
-          relevant_files
+      class Runner < RelevantRunner
+        def tool_name
+          :rspec
         end
 
-        def command
-          return nil if skip_execution?
-          ["rspec", "-f", "json"] + target_files.sort
+        def no_files_output
+          '{"examples": [], "summary": {"failure_count": 0}}'
         end
 
-        def skipped_outcome
-          Outcome.new(tool: :rspec, output: NO_FILES_OUTPUT)
+        def base_command
+          ["rspec", "-f", "json"]
         end
 
-        def performed_outcome
-          out, err, stat = Open3.capture3(*command)
-          if stat.success?
-            Outcome.new(tool: :rspec, output: out, logging: err)
-          elsif stat.exitstatus == 1
-            Outcome.new(tool: :rspec, output: out, logging: err, failure: true)
-          else
-            fail(ExecutionError, "Execution of rspec failed with #{stat.exitstatus}")
-          end
+        def relevant_path?(path)
+          path.end_with?("_spec.rb")
         end
       end
     end

data/lib/quiet_quality/tools/rspec.rb

@@ -1,8 +1,6 @@
 module QuietQuality
   module Tools
     module Rspec
-      ExecutionError = Class.new(Tools::Error)
-      ParsingError = Class.new(Tools::Error)
     end
   end
 end

data/lib/quiet_quality/tools/rubocop/runner.rb

@@ -1,65 +1,21 @@
 module QuietQuality
   module Tools
     module Rubocop
-      class Runner
-        MAX_FILES = 100
-        NO_FILES_OUTPUT = '{"files": [], "summary": {"offense_count": 0}}'
-
-        def command_name
-          "rubocop"
-        end
-
-        # Supplying changed_files: nil means "run against all files".
-        def initialize(changed_files: nil)
-          @changed_files = changed_files
-        end
-
-        def invoke!
-          @_outcome ||= skip_execution? ? skipped_outcome : performed_outcome
-        end
-
-        private
-
-        attr_reader :changed_files
-
-        # If we were told that _no files changed_ (which is distinct from not being told that
-        # any files changed - a [] instead of a nil), then we shouldn't run rubocop at all.
-        def skip_execution?
-          changed_files && relevant_files.empty?
-        end
-
-        # Note: if target_files goes over MAX_FILES, it's _empty_ instead - that means that
-        # we run against the full repository instead of the specific files (rubocop's behavior
-        # when no target files are specified)
-        def command
-          return nil if skip_execution?
-          [command_name, "-f", "json"] + target_files.sort
-        end
-
-        def relevant_files
-          return nil if changed_files.nil?
-          changed_files.paths.select { |path| path.end_with?(".rb") }
+      class Runner < RelevantRunner
+        def tool_name
+          :rubocop
         end
 
-        def target_files
-          return [] if changed_files.nil?
-          return [] if relevant_files.length > MAX_FILES
-          relevant_files
+        def no_files_output
+          '{"files": [], "summary": {"offense_count": 0}}'
         end
 
-        def skipped_outcome
-          Outcome.new(tool: command_name.to_sym, output: NO_FILES_OUTPUT)
+        def base_command
+          ["rubocop", "-f", "json"]
         end
 
-        def performed_outcome
-          out, err, stat = Open3.capture3(*command)
-          if stat.success?
-            Outcome.new(tool: command_name.to_sym, output: out, logging: err)
-          elsif stat.exitstatus == 1
-            Outcome.new(tool: command_name.to_sym, output: out, logging: err, failure: true)
-          else
-            fail(ExecutionError, "Execution of #{command_name} failed with #{stat.exitstatus}")
-          end
+        def relevant_path?(path)
+          path.end_with?(".rb")
         end
       end
     end

data/lib/quiet_quality/tools/rubocop.rb

@@ -1,8 +1,6 @@
 module QuietQuality
   module Tools
     module Rubocop
-      ExecutionError = Class.new(Tools::Error)
-      ParsingError = Class.new(Tools::Error)
     end
   end
 end

data/lib/quiet_quality/tools/standardrb/runner.rb

@@ -1,9 +1,21 @@
 module QuietQuality
   module Tools
     module Standardrb
-      class Runner < Rubocop::Runner
-        def command_name
-          "standardrb"
+      class Runner < RelevantRunner
+        def tool_name
+          :standardrb
+        end
+
+        def no_files_output
+          '{"files": [], "summary": {"offense_count": 0}}'
+        end
+
+        def base_command
+          ["standardrb", "-f", "json"]
+        end
+
+        def relevant_path?(path)
+          path.end_with?(".rb")
         end
       end
     end

data/lib/quiet_quality/tools/standardrb.rb

@@ -3,8 +3,6 @@ require_relative "./rubocop"
 module QuietQuality
   module Tools
     module Standardrb
-      ExecutionError = Class.new(Tools::Error)
-      ParsingError = Class.new(Tools::Error)
     end
   end
 end

data/lib/quiet_quality/tools.rb

@@ -3,9 +3,14 @@ require "open3"
 module QuietQuality
   module Tools
     Error = Class.new(::QuietQuality::Error)
+    ExecutionError = Class.new(Error)
+    ParsingError = Class.new(Error)
   end
 end
 
+require_relative "./tools/base_runner"
+require_relative "./tools/relevant_runner"
+
 glob = File.expand_path("../tools/*.rb", __FILE__)
 Dir.glob(glob).sort.each { |f| require f }
 
@@ -15,6 +20,7 @@ module QuietQuality
     AVAILABLE = {
       brakeman: Brakeman,
       haml_lint: HamlLint,
+      markdown_lint: MarkdownLint,
       rspec: Rspec,
       rubocop: Rubocop,
       standardrb: Standardrb

data/lib/quiet_quality/version.rb

@@ -1,3 +1,3 @@
 module QuietQuality
-  VERSION = "1.0.3"
+  VERSION = "1.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quiet_quality
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.2.0
 platform: ruby
 authors:
 - Eric Mueller
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-24 00:00:00.000000000 Z
+date: 2023-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: git
@@ -166,9 +166,11 @@ files:
 - ".gitignore"
 - ".mdl_rules.rb"
 - ".mdlrc"
+- ".quiet_quality.ci.yml"
 - ".quiet_quality.yml"
 - ".rspec"
 - ".rubocop.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
@@ -183,9 +185,11 @@ files:
 - lib/quiet_quality/cli.rb
 - lib/quiet_quality/cli/arg_parser.rb
 - lib/quiet_quality/cli/entrypoint.rb
+- lib/quiet_quality/cli/presenter.rb
 - lib/quiet_quality/config.rb
 - lib/quiet_quality/config/builder.rb
 - lib/quiet_quality/config/finder.rb
+- lib/quiet_quality/config/logging.rb
 - lib/quiet_quality/config/options.rb
 - lib/quiet_quality/config/parsed_options.rb
 - lib/quiet_quality/config/parser.rb
@@ -195,17 +199,23 @@ files:
 - lib/quiet_quality/executors/concurrent_executor.rb
 - lib/quiet_quality/executors/pipeline.rb
 - lib/quiet_quality/executors/serial_executor.rb
+- lib/quiet_quality/logger.rb
 - lib/quiet_quality/message.rb
 - lib/quiet_quality/message_filter.rb
 - lib/quiet_quality/messages.rb
 - lib/quiet_quality/tools.rb
+- lib/quiet_quality/tools/base_runner.rb
 - lib/quiet_quality/tools/brakeman.rb
 - lib/quiet_quality/tools/brakeman/parser.rb
 - lib/quiet_quality/tools/brakeman/runner.rb
 - lib/quiet_quality/tools/haml_lint.rb
 - lib/quiet_quality/tools/haml_lint/parser.rb
 - lib/quiet_quality/tools/haml_lint/runner.rb
+- lib/quiet_quality/tools/markdown_lint.rb
+- lib/quiet_quality/tools/markdown_lint/parser.rb
+- lib/quiet_quality/tools/markdown_lint/runner.rb
 - lib/quiet_quality/tools/outcome.rb
+- lib/quiet_quality/tools/relevant_runner.rb
 - lib/quiet_quality/tools/rspec.rb
 - lib/quiet_quality/tools/rspec/parser.rb
 - lib/quiet_quality/tools/rspec/runner.rb