quiet_quality 1.3.1 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7049c44ac27b14f8f599dfcb080dcd7d6aadceed0cee69f0d9f460ccb23bd66c
-  data.tar.gz: 6ec55838027c9bd81659109807e27e50199b5c54e1e17d04b2b0727819851d89
+  metadata.gz: 7ff5a82876936d746842d76e055475ba19e78d0bfff7967b2f179a2262cb5d7e
+  data.tar.gz: 529ed1d29fdf3c3c6ba381e7ab71cbf006bc44c8d608858e8ec84d67c2efb267
 SHA512:
-  metadata.gz: 1cac5b2196f3409ab37252830b115cf7ec54b0cc21e2e5a25062cb4cd79615f7378a6ac4bd2d4fd39a0c1ff6882948fa2e6e1f7029dd88b1b9989fb8910aa0b6
-  data.tar.gz: e48380c23c35946e11c011bb1bdb694f6731d93828fa06a4d725a9d9a9c347e3f8ee5a8687904593905da9be74c5d8903b09f72c815f2dbdcb5fdedcc5f8e69f
+  metadata.gz: 1b840cfe8d90929c0fcc32fdc1370310924a46464006b39afa5dceff69b8c24254d701002e77f33a845baaa7fe5373243486b5d1422a3beea4fd45a50e65ec8b
+  data.tar.gz: e3176f406a5de5a027cae5a2edcbd897395a0191dad1a6cb402bf48fb005f9dce3783d8e6778f91e7d05c03b3f12f473ee23438b9235ed5eedd5e4d588a58526

data/.github/workflows/dogfood.yml

@@ -6,7 +6,7 @@ jobs:
   QuietQuality:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
 

data/.github/workflows/linters.yml

@@ -6,7 +6,7 @@ jobs:
   StandardRB:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Set up ruby
         uses: ruby/setup-ruby@v1

data/.github/workflows/rspec.yml

@@ -11,7 +11,7 @@ jobs:
         ruby-version: ['2.7', '3.0', '3.1', '3.2', 'head']
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Set up ruby
         uses: ruby/setup-ruby@v1

data/.quiet_quality.yml

@@ -6,3 +6,4 @@ changed_files: false
 filter_messages: false
 logging: light
 colorize: true
+message_format: "%lcyan10tool| [%myellow40rule] %bred60loc  %e-90body"

data/.standard.yml

@@ -0,0 +1,3 @@
+---
+format: progress
+ruby_version: 2.7

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## Release 1.5.0
+
+* Update to comply with current standardrb rules, and use checkout@v4
+* Add a `-X/--exec` argument that allows you to let qq craft the command, but
+  then actually exec the command instead of running it and handling its output.
+  Especially useful for things like `rspec`, where the output it gives you about
+  failing tests is very useful, and qq is mostly only helpful for determining
+  what specs to run.
+* Add a `--message-format` argument and `message_format` config file option,
+  which allow for a fairly complex configuration of the output format for
+  messages, so they can be displayed in various colorized/tabular formats.
+
+## Release 1.4.0
+
+* Support specifying `excludes` per-tool, so that certain files won't be passed
+  to those tools on the command-line (#107 resolves #106)
+
 ## Release 1.3.1
 
 * Fix a bug around the logging of nil commands when runners are skipped (#104

data/README.md

@@ -151,19 +151,22 @@ The configuration file supports the following _global_ options (top-level keys):
 * `colorize`: by default, `bin/qq` will include color codes in its output, to
   make failing tools easier to spot, and messages easier to read. But you can
   supply `colorize: false` to tell it not to do that if you don't want them.
+* `message_format`: you can specify a format string with which to render the
+  messages, which interpolates values with various formatting flags. Details
+  given in the "Message Formatting" section below.
 
 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.
 
-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 tools have two additional settings that are not available at a global level:
+`file_filter` and `excludes`. `file_filter` 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:
 
 ```yaml
 rspec:
@@ -172,6 +175,49 @@ rspec:
   file_filter: "^spec/"
 ```
 
+`excludes` are more specific in meaning - this is an _array_ of regexes, and any
+file that matches any of these regexes will _not_ be passed to the tool as an
+explicit command line argument. This is generally because tools like rubocop
+have internal systems for excluding files, but if you pass a filename on the
+cli, those systems are ignored. That means that if you have changes to a
+generated file like `db/schema.rb`, and that file doesn't meet your rubocop (or
+standardrb) rules, you'll get _told_ unless you exclude it at the quiet-quality
+level as well.
+
+### Message Formatting
+
+You can supply a message-format string on the cli or in your config file, which
+will override the default formatting for message output on the CLI. These format
+strings are intended to be a single line containing "substitution tokens", which
+each look like `%[lr]?[bem]?color?(Size)(Source)`.
+
+* The first (optional) flag can be an "l", and "r", or be left off (which is the
+  same as "l"). This flag indicates the 'justification' - left or right.
+* The second (optional) flag can be a "b", an "e", or an "m", defaulting to "e";
+  these stand for "beginning", "ending", and "middle", and represent what part
+  of the string should be truncated if it needs to be shortened.
+* The third (optional) part is a color name, and can be any of "yellow", "red",
+  "green", "blue", "cyan", or "none" (leaving it off is the same as specifing
+  "none"). This is the color to use for the token in the output - note that any
+  color supplied here is used regardless of the '--colorize' flag.
+* The fourth part of the token is required, and is the _size_ of the token. If a
+  positive integer is supplied, then the token will take up that much space, and
+  will be padded on the appropriate side if necessary; if a negative integer is
+  supplied, then the token will not be padded out, but will still get truncated
+  if it is too long. The value '0' is special, and indicates that the token
+  should be neither padded nor truncated.
+* The last part of the token is a string indicating the _source_ data to
+  represent, and must be one of these values: "tool", "loc", "level", "path",
+  "lines", "rule", "body". Each of these represents one piece of data out of the
+  message object that can be rendered into the message line.
+
+Some example message formats:
+
+```text
+%lcyan8tool | %lmyellow30rule | %0loc
+%le6tool [%mblue20rule] %b45loc   %cyan-100body
+```
+
 ### CLI Options
 
 To specify which _tools_ to run (and if any are specified, the `default_tools`

data/lib/quiet_quality/cli/arg_parser.rb

@@ -67,6 +67,7 @@ module QuietQuality
           setup_filter_messages_options(parser)
           setup_colorization_options(parser)
           setup_logging_options(parser)
+          setup_message_formatting_options(parser)
           setup_verbosity_options(parser)
         end
       end
@@ -100,6 +101,11 @@ module QuietQuality
           validate_value_from("executor", name, Executors::AVAILABLE)
           set_global_option(:executor, name.to_sym)
         end
+
+        parser.on("-X", "--exec TOOL", "Exec one tool instead of managing several") do |tool_name|
+          validate_value_from("tool", tool_name, Tools::AVAILABLE)
+          set_global_option(:exec_tool, tool_name.to_sym)
+        end
       end
 
       def setup_annotation_options(parser)
@@ -163,6 +169,12 @@ module QuietQuality
         end
       end
 
+      def setup_message_formatting_options(parser)
+        parser.on("-F", "--message-format FMT", "A format string with which to print messages") do |fmt|
+          set_global_option(:message_format, fmt)
+        end
+      end
+
       def setup_verbosity_options(parser)
         parser.on("-v", "--verbose", "Log more verbosely - multiple times is more verbose") do
           QuietQuality.logger.increase_level!

data/lib/quiet_quality/cli/entrypoint.rb

@@ -18,7 +18,7 @@ module QuietQuality
           log_no_tools_text
         else
           log_options
-          executed
+          execute!
           log_results
           annotate_messages
         end
@@ -114,6 +114,26 @@ module QuietQuality
         @_executed = executor
       end
 
+      def exec_tool_options
+        @_exec_tool_options ||= options.tools
+          .detect { |topts| topts.tool_name == options.exec_tool.to_sym }
+      end
+
+      def execcer
+        @_execcer ||= QuietQuality::Executors::Execcer.new(
+          tool_options: exec_tool_options,
+          changed_files: changed_files
+        )
+      end
+
+      def execute!
+        if options.exec_tool
+          execcer.exec!
+        else
+          executed
+        end
+      end
+
       def annotate_messages
         return unless options.annotator
         info("Annotating with #{options.annotator}")

data/lib/quiet_quality/cli/message_formatter.rb

@@ -0,0 +1,190 @@
+module QuietQuality
+  module Cli
+    class MessageFormatter
+      TOKEN_MATCHING_REGEX = %r{%[a-z]*-?\d+(?:tool|loc|level|path|lines|rule|body)}
+
+      def initialize(message_format:)
+        @message_format = message_format
+      end
+
+      def format(message)
+        formatted_tokens = parsed_tokens.map { |pt| FormattedToken.new(parsed_token: pt, message: message) }
+        formatted_tokens.reduce(message_format) do |interpolating, ftok|
+          interpolating.gsub(ftok.token, ftok.formatted_token)
+        end
+      end
+
+      private
+
+      attr_reader :message_format
+
+      def tokens
+        @_tokens ||= message_format.scan(TOKEN_MATCHING_REGEX)
+      end
+
+      def parsed_tokens
+        @_parsed_tokens ||= tokens.map { |tok| ParsedToken.new(tok) }
+      end
+
+      class ParsedToken
+        TOKEN_PARSING_REGEX = %r{
+          %                                               # start the interplation token
+          (?<just>[lr])?                                  # specify the justification
+          (?<trunc>[bem])?                                # where to truncate from
+          (?<color>yellow|red|green|blue|cyan|none)?      # what color
+          (?<size>-?\d+)                                  # string size (may be negative)
+          (?<source>tool|loc|level|path|lines|rule|body)  # data source name
+        }x
+
+        COLORS = {
+          "yellow" => :yellow,
+          "red" => :red,
+          "green" => :green,
+          "blue" => :light_blue,
+          "cyan" => :light_cyan,
+          "none" => nil
+        }.freeze
+
+        JUSTIFICATIONS = {"l" => :left, "r" => :right}.freeze
+        TRUNCATIONS = {"b" => :beginning, "m" => :middle, "e" => :ending}.freeze
+
+        def initialize(token)
+          @token = token
+        end
+
+        attr_reader :token
+
+        def justification
+          JUSTIFICATIONS.fetch(token_pieces[:just]&.downcase, :left)
+        end
+
+        def truncation
+          TRUNCATIONS.fetch(token_pieces[:trunc]&.downcase, :ending)
+        end
+
+        def color
+          COLORS.fetch(token_pieces[:color]&.downcase, nil)
+        end
+
+        def size
+          raw_size.abs
+        end
+
+        def source
+          token_pieces[:source]
+        end
+
+        def allow_pad?
+          raw_size.positive?
+        end
+
+        def allow_truncate?
+          !raw_size.zero?
+        end
+
+        private
+
+        def token_pieces
+          @_token_pieces ||= token.match(TOKEN_PARSING_REGEX)
+        end
+
+        def raw_size
+          @_raw_size ||= token_pieces[:size].to_i
+        end
+      end
+      private_constant :ParsedToken
+
+      class FormattedToken
+        def initialize(parsed_token:, message:)
+          @parsed_token = parsed_token
+          @message = message
+        end
+
+        def formatted_token
+          colorized(padded(truncated(base_string)))
+        end
+
+        def token
+          parsed_token.token
+        end
+
+        private
+
+        attr_reader :parsed_token, :message
+
+        def line_range
+          if message.start_line == message.stop_line
+            message.start_line.to_s
+          else
+            "#{message.start_line}-#{message.stop_line}"
+          end
+        end
+
+        def base_string
+          case parsed_token.source
+          when "tool" then message.tool_name
+          when "loc" then location_string
+          when "level" then message.level
+          when "path" then message.path
+          when "lines" then line_range
+          when "rule" then message.rule
+          when "body" then flattened_body
+          end
+        end
+
+        def location_string
+          "#{message.path}:#{line_range}"
+        end
+
+        def flattened_body
+          message.body.gsub(/ *\n */, "\\n")
+        end
+
+        def truncated(s)
+          return s unless parsed_token.allow_truncate?
+          return s if s.length <= parsed_token.size
+          size = parsed_token.size
+
+          case parsed_token.truncation
+          when :beginning then truncate_beginning(s, size)
+          when :middle then truncate_middle(s, size)
+          when :ending then truncate_ending(s, size)
+          end
+        end
+
+        def truncate_beginning(s, size)
+          "…" + s.slice(1 - size, size - 1)
+        end
+
+        def truncate_middle(s, size)
+          front_len = (size / 2.0).floor
+          back_len = (size / 2.0).ceil - 1
+          s.slice(0, front_len) + "…" + s.slice(-back_len, back_len)
+        end
+
+        def truncate_ending(s, size)
+          s.slice(0, size - 1) + "…"
+        end
+
+        def padded(s)
+          return s unless parsed_token.allow_pad?
+          return s if s.length >= parsed_token.size
+
+          case parsed_token.justification
+          when :left then s.ljust(parsed_token.size)
+          when :right then s.rjust(parsed_token.size)
+          end
+        end
+
+        def colorized(s)
+          if parsed_token.color.nil?
+            s
+          else
+            Colorize.colorize(s, color: parsed_token.color)
+          end
+        end
+      end
+      private_constant :FormattedToken
+    end
+  end
+end

data/lib/quiet_quality/cli/presenter.rb

@@ -78,12 +78,28 @@ module QuietQuality
         s.gsub(/ *\n */, "\\n").slice(0, length)
       end
 
-      def log_message(msg)
+      def locally_formatted_message(msg)
         tool = colorize(:yellow, msg.tool_name)
         line_range = line_range_for(msg)
         rule_string = msg.rule ? "  [#{colorize(:yellow, msg.rule)}]" : ""
         truncated_body = reduce_text(msg.body, 120)
-        stream.puts "#{tool}  #{msg.path}:#{line_range}#{rule_string}  #{truncated_body}"
+        "#{tool}  #{msg.path}:#{line_range}#{rule_string}  #{truncated_body}"
+      end
+
+      def loggable_message(msg)
+        if options.message_format
+          message_formatter.format(msg)
+        else
+          stream.puts locally_formatted_message(msg)
+        end
+      end
+
+      def log_message(msg)
+        stream.puts loggable_message(msg)
+      end
+
+      def message_formatter
+        @_message_formatter ||= MessageFormatter.new(message_format: options.message_format)
       end
     end
   end

data/lib/quiet_quality/cli.rb

@@ -1,5 +1,5 @@
-require_relative "./annotators"
-require_relative "./tools"
+require_relative "annotators"
+require_relative "tools"
 
 module QuietQuality
   module Cli

data/lib/quiet_quality/config/builder.rb

@@ -22,7 +22,7 @@ module QuietQuality
         Options.new.tap { |opts| opts.tools = tools }
       end
 
-      def tool_names
+      def specified_tool_names
         if cli.tools.any?
           cli.tools
         elsif config_file&.tools&.any?
@@ -32,6 +32,14 @@ module QuietQuality
         end
       end
 
+      def exec_tool_name
+        cli.global_option(:exec_tool)
+      end
+
+      def tool_names
+        (specified_tool_names + [exec_tool_name]).compact.uniq
+      end
+
       def config_finder
         @_config_finder ||= Finder.new(from: ".")
       end
@@ -84,6 +92,7 @@ module QuietQuality
         def update_globals
           update_annotator
           update_executor
+          update_exec_tool
           update_comparison_branch
           update_logging
         end
@@ -100,6 +109,10 @@ module QuietQuality
           options.executor = Executors::AVAILABLE.fetch(executor_name)
         end
 
+        def update_exec_tool
+          set_unless_nil(options, :exec_tool, apply.global_option(:exec_tool))
+        end
+
         def update_comparison_branch
           set_unless_nil(options, :comparison_branch, apply.global_option(:comparison_branch))
         end
@@ -107,6 +120,7 @@ module QuietQuality
         def update_logging
           set_unless_nil(options, :logging, apply.global_option(:logging))
           set_unless_nil(options, :colorize, apply.global_option(:colorize))
+          set_unless_nil(options, :message_format, apply.global_option(:message_format))
         end
 
         # ---- update the tool options (apply global forms first) -------

data/lib/quiet_quality/config/file_filter.rb

@@ -0,0 +1,52 @@
+module QuietQuality
+  module Config
+    class FileFilter
+      # * regex is a regex string
+      # * excludes is an array of regex strings OR a single regex string
+      def initialize(regex: nil, excludes: nil)
+        @regex_string = regex
+        @excludes_strings = excludes
+      end
+
+      def regex
+        return nil if @regex_string.nil?
+        @_regex ||= Regexp.new(@regex_string)
+      end
+
+      def excludes
+        return @_excludes if defined?(@_excludes)
+
+        @_excludes =
+          if @excludes_strings.nil?
+            nil
+          elsif @excludes_strings.is_a?(String)
+            [Regexp.new(@excludes_strings)]
+          else
+            @excludes_strings.map { |xs| Regexp.new(xs) }
+          end
+      end
+
+      # The filter _overall_ matches if:
+      # (a) the regex either matches or is not supplied AND
+      # (b) either none of the excludes match or none are supplied
+      def match?(s)
+        regex_match?(s) && !excludes_match?(s)
+      end
+
+      private
+
+      # The regex is an allow-match - if it's not supplied, treat everything as matching.
+      def regex_match?(s)
+        return true if regex.nil?
+        regex.match?(s)
+      end
+
+      # The excludes are a list of deny-matches - if they're not supplied, treat _nothing_
+      # as matching.
+      def excludes_match?(s)
+        return false if excludes.nil? || excludes.empty?
+        excludes.any? { |exclude| exclude.match?(s) }
+      end
+    end
+  end
+end

data/lib/quiet_quality/config/options.rb

@@ -7,12 +7,14 @@ module QuietQuality
         @annotator = nil
         @executor = Executors::ConcurrentExecutor
         @tools = nil
+        @exec_tool = nil
         @comparison_branch = nil
         @colorize = true
         @logging = :normal
+        @message_format = nil
       end
 
-      attr_accessor :tools, :comparison_branch, :annotator, :executor
+      attr_accessor :tools, :comparison_branch, :annotator, :executor, :exec_tool, :message_format
       attr_reader :logging
       attr_writer :colorize
 
@@ -37,9 +39,11 @@ module QuietQuality
         {
           annotator: annotator,
           executor: executor.name,
+          exec_tool: exec_tool,
           comparison_branch: comparison_branch,
           colorize: colorize?,
           logging: logging,
+          message_format: message_format,
           tools: tool_hashes_by_name
         }
       end

data/lib/quiet_quality/config/parsed_options.rb

@@ -8,9 +8,11 @@ module QuietQuality
         :config_path,
         :annotator,
         :executor,
+        :exec_tool,
         :comparison_branch,
         :colorize,
         :logging,
+        :message_format,
         :limit_targets,
         :filter_messages,
         :file_filter

data/lib/quiet_quality/config/parser.rb

@@ -48,6 +48,7 @@ module QuietQuality
         read_global_option(opts, :unfiltered, :filter_messages, as: :reversed_boolean)
         read_global_option(opts, :colorize, :colorize, as: :boolean)
         read_global_option(opts, :logging, :logging, as: :symbol, validate_from: Options::LOGGING_LEVELS)
+        read_global_option(opts, :message_format, :message_format, as: :string)
       end
 
       def store_tool_options(opts)
@@ -64,7 +65,7 @@ module QuietQuality
         read_tool_option(opts, tool_name, :unfiltered, :filter_messages, as: :reversed_boolean)
         read_tool_option(opts, tool_name, :changed_files, :limit_targets, as: :boolean)
         read_tool_option(opts, tool_name, :all_files, :limit_targets, as: :reversed_boolean)
-        read_tool_option(opts, tool_name, :file_filter, :file_filter, as: :string)
+        read_file_filter(opts, tool_name)
       end
 
       def invalid!(message)
@@ -97,6 +98,15 @@ module QuietQuality
         opts.set_tool_option(tool, into, coerced_value)
       end
 
+      def read_file_filter(opts, tool)
+        parsed_regex = data.dig(tool.to_sym, :file_filter)
+        parsed_excludes = data.dig(tool.to_sym, :excludes)
+        if parsed_regex || parsed_excludes
+          filter = Config::FileFilter.new(regex: parsed_regex, excludes: parsed_excludes)
+          opts.set_tool_option(tool, :file_filter, filter)
+        end
+      end
+
       def validate_value(name, value, as:, from: nil)
         case as
         when :boolean then validate_boolean(name, value)

data/lib/quiet_quality/config/tool_options.rb

@@ -8,8 +8,9 @@ module QuietQuality
         @file_filter = file_filter
       end
 
+      attr_accessor :file_filter
       attr_reader :tool_name
-      attr_writer :limit_targets, :filter_messages, :file_filter
+      attr_writer :limit_targets, :filter_messages
 
       def limit_targets?
         @limit_targets
@@ -31,17 +32,13 @@ module QuietQuality
         tool_namespace::Parser
       end
 
-      def file_filter
-        return nil if @file_filter.nil?
-        Regexp.new(@file_filter)
-      end
-
       def to_h
         {
           tool_name: tool_name,
           limit_targets: limit_targets?,
           filter_messages: filter_messages?,
-          file_filter: file_filter&.to_s
+          file_filter: file_filter&.regex&.to_s,
+          excludes: file_filter&.excludes&.map(&:to_s)
         }
       end
     end

data/lib/quiet_quality/executors/execcer.rb

@@ -0,0 +1,46 @@
+module QuietQuality
+  module Executors
+    class Execcer
+      include Logging
+
+      def initialize(tool_options:, changed_files: nil)
+        @tool_options = tool_options
+        @changed_files = changed_files
+      end
+
+      def exec!
+        if runner.exec_command
+          Kernel.exec(*runner.exec_command)
+        else
+          info <<~LOG_MESSAGE
+            This runner does not believe it needs to execute at all.
+            This typically means that it was told to target changed-files, but no relevant
+            files were changed.
+          LOG_MESSAGE
+          Kernel.exit(0)
+        end
+      end
+
+      private
+
+      attr_reader :tool_options, :changed_files
+
+      def limit_targets?
+        tool_options.limit_targets?
+      end
+
+      def runner
+        @_runner ||= tool_options.runner_class.new(
+          changed_files: limit_targets? ? changed_files : nil,
+          file_filter: tool_options.file_filter
+        ).tap { |r| log_runner(r) }
+      end
+
+      def log_runner(r)
+        command_string = r.exec_command ? "`#{r.exec_command.join(" ")}`" : "(skipped)"
+        info("Runner #{r.tool_name} exec_command: #{command_string}")
+        debug("Full exec_command for #{r.tool_name}", data: r.exec_command)
+      end
+    end
+  end
+end

data/lib/quiet_quality/executors/serial_executor.rb

@@ -1,4 +1,4 @@
-require_relative "./base_executor"
+require_relative "base_executor"
 
 module QuietQuality
   module Executors

data/lib/quiet_quality/tools/base_runner.rb

@@ -23,6 +23,10 @@ module QuietQuality
         fail(NoMethodError, "BaseRunner subclass must implement `command`")
       end
 
+      def exec_command
+        fail(NoMethodError, "BaseRunner subclass must implement `exec_command`")
+      end
+
       def success_status?(stat)
         stat.success?
       end

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

@@ -10,6 +10,10 @@ module QuietQuality
           ["brakeman", "-f", "json"]
         end
 
+        def exec_command
+          ["brakeman"]
+        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)

data/lib/quiet_quality/tools/brakeman.rb

@@ -1,4 +1,4 @@
-require_relative "./rubocop"
+require_relative "rubocop"
 
 module QuietQuality
   module Tools

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

@@ -14,6 +14,10 @@ module QuietQuality
           ["haml-lint", "--reporter", "json"]
         end
 
+        def base_exec_command
+          ["haml-lint"]
+        end
+
         def relevant_path?(path)
           path.end_with?(".haml")
         end

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

@@ -10,15 +10,21 @@ module QuietQuality
           "[]"
         end
 
-        def command
+        def command(json: true)
           return nil if skip_execution?
+          base_command = ["mdl"]
+          base_command << "--json" if json
           if target_files.any?
-            ["mdl", "--json"] + target_files.sort
+            base_command + target_files.sort
           else
-            ["mdl", "--json", "."]
+            base_command + ["."]
           end
         end
 
+        def exec_command
+          command(json: false)
+        end
+
         def relevant_path?(path)
           path.end_with?(".md")
         end

data/lib/quiet_quality/tools/relevant_runner.rb

@@ -1,4 +1,4 @@
-require_relative "./base_runner"
+require_relative "base_runner"
 
 module QuietQuality
   module Tools
@@ -16,6 +16,11 @@ module QuietQuality
         base_command + target_files.sort
       end
 
+      def exec_command
+        return nil if skip_execution?
+        base_exec_command + target_files.sort
+      end
+
       def relevant_path?(path)
         fail(NoMethodError, "RelevantRunner subclass must implement `relevant_path?`")
       end
@@ -24,6 +29,10 @@ module QuietQuality
         fail(NoMethodError, "RelevantRunner subclass must implement either `command` or `base_command`")
       end
 
+      def base_exec_command
+        fail(NoMethodError, "RelevantRunner subclass must implement either `exec_command` or `base_exec_command`")
+      end
+
       def no_files_output
         fail(NoMethodError, "RelevantRunner subclass must implement `no_files_output`")
       end

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

@@ -14,6 +14,10 @@ module QuietQuality
           ["rspec", "-f", "json"]
         end
 
+        def base_exec_command
+          ["rspec"]
+        end
+
         def relevant_path?(path)
           path.end_with?("_spec.rb")
         end

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

@@ -14,6 +14,10 @@ module QuietQuality
           ["rubocop", "-f", "json"]
         end
 
+        def base_exec_command
+          ["rubocop"]
+        end
+
         def relevant_path?(path)
           path.end_with?(".rb")
         end

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

@@ -14,6 +14,10 @@ module QuietQuality
           ["standardrb", "-f", "json"]
         end
 
+        def base_exec_command
+          ["standardrb"]
+        end
+
         def relevant_path?(path)
           path.end_with?(".rb")
         end

data/lib/quiet_quality/tools/standardrb.rb

@@ -1,4 +1,4 @@
-require_relative "./rubocop"
+require_relative "rubocop"
 
 module QuietQuality
   module Tools

data/lib/quiet_quality/tools.rb

@@ -8,8 +8,8 @@ module QuietQuality
   end
 end
 
-require_relative "./tools/base_runner"
-require_relative "./tools/relevant_runner"
+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 }

data/lib/quiet_quality/version.rb

@@ -1,3 +1,3 @@
 module QuietQuality
-  VERSION = "1.3.1"
+  VERSION = "1.5.0"
 end

data/lib/quiet_quality.rb

@@ -16,7 +16,7 @@ module QuietQuality
   end
 end
 
-require_relative "./quiet_quality/logger"
-require_relative "./quiet_quality/logging"
+require_relative "quiet_quality/logger"
+require_relative "quiet_quality/logging"
 glob = File.expand_path("../quiet_quality/*.rb", __FILE__)
 Dir.glob(glob).sort.each { |f| require f }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quiet_quality
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.5.0
 platform: ruby
 authors:
 - Eric Mueller
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-14 00:00:00.000000000 Z
+date: 2023-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: git
@@ -184,6 +184,7 @@ files:
 - ".quiet_quality.yml"
 - ".rspec"
 - ".rubocop.yml"
+- ".standard.yml"
 - CHANGELOG.md
 - Gemfile
 - LICENSE
@@ -199,10 +200,12 @@ files:
 - lib/quiet_quality/cli.rb
 - lib/quiet_quality/cli/arg_parser.rb
 - lib/quiet_quality/cli/entrypoint.rb
+- lib/quiet_quality/cli/message_formatter.rb
 - lib/quiet_quality/cli/presenter.rb
 - lib/quiet_quality/colorize.rb
 - lib/quiet_quality/config.rb
 - lib/quiet_quality/config/builder.rb
+- lib/quiet_quality/config/file_filter.rb
 - lib/quiet_quality/config/finder.rb
 - lib/quiet_quality/config/options.rb
 - lib/quiet_quality/config/parsed_options.rb
@@ -211,6 +214,7 @@ files:
 - lib/quiet_quality/executors.rb
 - lib/quiet_quality/executors/base_executor.rb
 - lib/quiet_quality/executors/concurrent_executor.rb
+- lib/quiet_quality/executors/execcer.rb
 - lib/quiet_quality/executors/pipeline.rb
 - lib/quiet_quality/executors/serial_executor.rb
 - lib/quiet_quality/logger.rb
@@ -266,7 +270,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: A system for comparing quality tool outputs against the forward diffs