quiet_quality 1.2.2 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6876b975446f39615f129b4fd35f3543bb998024ea292edcac1e6e1a90f7b59b
-  data.tar.gz: 277492ea2e6b93854e3b7d16f0184a50b5c756683929fb2a1081415e8e9836df
+  metadata.gz: 921a945aaedb335246c6944ae8f460505357a73d20f4f1cf2ae3dba3e9fe9041
+  data.tar.gz: fab1f3330661738cc146e26590d489bb9fff0cc0c0318a5e9529fb9fd0802038
 SHA512:
-  metadata.gz: 7d0acaa14243573095f8741b9ca45cf56608b4ffde72f3ecd36a6ebd03cb0aeb45541ef3e4dad1c681976d5cdc3226d738a489b754d80590be032c31bbc8520b
-  data.tar.gz: 8e8daf77522762cca13480745f30df25cb2e445f2f7c69f98c20af9bc3b03bc8568299b8403ddbbc2e09fef750d3b3944c1a6f9b8dc2e4e22a4389a5419d05ab
+  metadata.gz: 84a082f31fb8a6ae290399a97fdb5918bd91c2eaa701ec7b3909fe27e2d66845ceae7db7bcf9a59dd6696c71bfe99b4cc189f1d529bea49f5f82ba849c8fb553
+  data.tar.gz: 222a7432405df57d2739c0799bc5844b1a916c76febf34c798891ee39e17ce79c17dedaec15928488a819261fdc35d3d746276109455cba7d490b2140c5d31c4

data/.quiet_quality.ci.yml

@@ -4,3 +4,4 @@ executor: concurrent
 comparison_branch: origin/main
 all_files: true
 unfiltered: true
+colorize: true

data/.quiet_quality.yml

@@ -5,3 +5,4 @@ comparison_branch: main
 changed_files: false
 filter_messages: false
 logging: light
+colorize: true

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## Release 1.3.0
+
+* Support (and enable by default) colorizing the console stderr output from
+  `bin/qq` - disable with the `--no-colorize` flag or the `colorize: false`
+  configuration entry. (#94, resolved #36)
+* Introduce a Logging facility, and add the `--verbose/-v` flag - supply it
+  either once or twice to enable (colorized) logging in either `info` or `debug`
+  level, providing much more detail about what's going on during execution.
+
 ## Release 1.2.2
 
 * Add some code to the Rspec::Parser that _cleans_ the json of certain text that

data/README.md

@@ -148,6 +148,9 @@ The configuration file supports the following _global_ options (top-level keys):
   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.
+* `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.
 
 And then each tool can have an entry, within which `changed_files` and
 `filter_messages` can be specified - the tool-specific settings override the
@@ -196,7 +199,10 @@ Usage: qq [TOOLS] [GLOBAL_OPTIONS] [TOOL_OPTIONS]
     -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)
+        --[no-]colorize              Colorize the logging output
+    -n, --normal                     Print outcomes and messages
     -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
+    -L, --logging LEVEL              Specify logging mode (from light/quiet/normal)
+    -v, --verbose                    Log more verbosely - multiple times is more verbose
 ```

data/lib/quiet_quality/cli/arg_parser.rb

@@ -65,7 +65,9 @@ module QuietQuality
           setup_annotation_options(parser)
           setup_file_target_options(parser)
           setup_filter_messages_options(parser)
+          setup_colorization_options(parser)
           setup_logging_options(parser)
+          setup_verbosity_options(parser)
         end
       end
 
@@ -136,24 +138,36 @@ module QuietQuality
         end
       end
 
+      def setup_colorization_options(parser)
+        parser.on("--[no-]colorize", "Colorize the logging output") do |value|
+          set_global_option(:colorize, value)
+        end
+      end
+
       def setup_logging_options(parser)
         parser.on("-n", "--normal", "Print outcomes and messages") do
-          set_global_option(:logging, Config::Logging::NORMAL)
+          set_global_option(:logging, :normal)
         end
 
         parser.on("-l", "--light", "Print aggregated results only") do
-          set_global_option(:logging, Config::Logging::LIGHT)
+          set_global_option(:logging, :light)
         end
 
         parser.on("-q", "--quiet", "Don't print results, only return a status code") do
-          set_global_option(:logging, Config::Logging::QUIET)
+          set_global_option(: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)
+        parser.on("-L", "--logging LEVEL", "Specify logging mode (from normal/light/quiet)") do |level|
+          validate_value_from("logging level", level.to_sym, Config::Options::LOGGING_LEVELS)
           set_global_option(:logging, level.to_sym)
         end
       end
+
+      def setup_verbosity_options(parser)
+        parser.on("-v", "--verbose", "Log more verbosely - multiple times is more verbose") do
+          QuietQuality.logger.increase_level!
+        end
+      end
     end
   end
 end

data/lib/quiet_quality/cli/entrypoint.rb

@@ -1,6 +1,8 @@
 module QuietQuality
   module Cli
     class Entrypoint
+      include Logging
+
       def initialize(argv:, output_stream: $stdout, error_stream: $stderr)
         @argv = argv
         @output_stream = output_stream
@@ -15,6 +17,7 @@ module QuietQuality
         elsif no_tools?
           log_no_tools_text
         else
+          log_options
           executed
           log_results
           annotate_messages
@@ -33,19 +36,19 @@ module QuietQuality
 
       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,
+          stream: error_stream,
+          options: options,
           outcomes: executor.outcomes,
           messages: executor.messages
         )
       end
 
+      def log_options
+        debug("Complete Options object:", data: options.to_h)
+      end
+
       def log_results
         presenter.log_results
       end
@@ -71,15 +74,15 @@ module QuietQuality
       end
 
       def log_help_text
-        logger.puts(arg_parser.help_text)
+        error_stream.puts(arg_parser.help_text)
       end
 
       def log_version_text
-        logger.puts(QuietQuality::VERSION)
+        error_stream.puts(QuietQuality::VERSION)
       end
 
       def log_no_tools_text
-        logger.puts(<<~TEXT)
+        error_stream.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
@@ -113,6 +116,7 @@ module QuietQuality
 
       def annotate_messages
         return unless options.annotator
+        info("Annotating with #{options.annotator}")
         annotator = options.annotator.new(output_stream: output_stream)
         annotator.annotate!(executed.messages)
       end

data/lib/quiet_quality/cli/presenter.rb

@@ -1,17 +1,17 @@
 module QuietQuality
   module Cli
     class Presenter
-      def initialize(logger:, logging:, outcomes:, messages:)
-        @logger = logger
-        @logging = logging
+      def initialize(stream:, options:, outcomes:, messages:)
+        @stream = stream
+        @options = options
         @outcomes = outcomes
         @messages = messages
       end
 
       def log_results
-        return if logging.quiet?
+        return if options.quiet?
 
-        if logging.light?
+        if options.light?
           log_light_outcomes
         else
           log_outcomes
@@ -21,7 +21,7 @@ module QuietQuality
 
       private
 
-      attr_reader :logger, :logging, :outcomes, :messages
+      attr_reader :stream, :options, :outcomes, :messages
 
       def failed_outcomes
         @_failed_outcomes ||= outcomes.select(&:failure?)
@@ -31,26 +31,38 @@ module QuietQuality
         @_successful_outcomes ||= outcomes.select(&:success?)
       end
 
+      def colorize(color_name, s)
+        return s unless options.colorize?
+        Colorize.colorize(s, color: color_name)
+      end
+
+      def failed_tools_text
+        colorize(:red, " (#{failed_outcomes.map(&:tool).join(", ")})")
+      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
+        line += failed_tools_text if failed_outcomes.any?
+        stream.puts line
       end
 
       def log_outcomes
         outcomes.each do |outcome|
-          result = outcome.success? ? "Passed" : "Failed"
-          logger.puts "--- #{result}: #{outcome.tool}"
+          if outcome.success?
+            stream.puts "--- " + colorize(:green, "Passed: #{outcome.tool}")
+          else
+            stream.puts "--- " + colorize(:red, "Failed: #{outcome.tool}")
+          end
         end
       end
 
       def log_messages
         return unless messages.any?
-        logger.puts "\n\n#{messages.count} messages:"
+        stream.puts "\n\n#{messages.count} messages:"
         messages.each { |msg| log_message(msg) }
       end
 
@@ -67,10 +79,11 @@ module QuietQuality
       end
 
       def log_message(msg)
+        tool = colorize(:yellow, msg.tool_name)
         line_range = line_range_for(msg)
-        rule_string = msg.rule ? "  [#{msg.rule}]" : ""
+        rule_string = msg.rule ? "  [#{colorize(:yellow, msg.rule)}]" : ""
         truncated_body = reduce_text(msg.body, 120)
-        logger.puts "#{msg.tool_name}  #{msg.path}:#{line_range}#{rule_string}  #{truncated_body}"
+        stream.puts "#{tool}  #{msg.path}:#{line_range}#{rule_string}  #{truncated_body}"
       end
     end
   end

data/lib/quiet_quality/colorize.rb

@@ -0,0 +1,19 @@
+module QuietQuality
+  module Colorize
+    CODES = {
+      red: "\e[31m",
+      green: "\e[32m",
+      yellow: "\e[33m",
+      light_blue: "\e[94m",
+      light_cyan: "\e[96m"
+    }.freeze
+
+    RESET_CODE = "\e[0m"
+
+    def self.colorize(s, color:)
+      fail(ArgumentError, "Unrecognized color '#{color}'") unless CODES.include?(color.to_sym)
+      color_code = CODES.fetch(color.to_sym)
+      "#{color_code}#{s}#{RESET_CODE}"
+    end
+  end
+end

data/lib/quiet_quality/config/builder.rb

@@ -106,6 +106,7 @@ module QuietQuality
 
         def update_logging
           set_unless_nil(options, :logging, apply.global_option(:logging))
+          set_unless_nil(options, :colorize, apply.global_option(:colorize))
         end
 
         # ---- update the tool options (apply global forms first) -------

data/lib/quiet_quality/config/options.rb

@@ -1,19 +1,56 @@
 module QuietQuality
   module Config
     class Options
+      LOGGING_LEVELS = [:quiet, :light, :normal].freeze
+
       def initialize
         @annotator = nil
         @executor = Executors::ConcurrentExecutor
         @tools = nil
         @comparison_branch = nil
-        @logging = Logging.new
+        @colorize = true
+        @logging = :normal
       end
 
       attr_accessor :tools, :comparison_branch, :annotator, :executor
       attr_reader :logging
+      attr_writer :colorize
 
       def logging=(level)
-        @logging.level = level
+        fail(ArgumentError, "Unrecognized logging level '#{level}'") unless LOGGING_LEVELS.include?(level.to_sym)
+        @logging = level.to_sym
+      end
+
+      def colorize?
+        !!@colorize
+      end
+
+      def quiet?
+        logging == :quiet
+      end
+
+      def light?
+        logging == :light
+      end
+
+      def to_h
+        {
+          annotator: annotator,
+          executor: executor.name,
+          comparison_branch: comparison_branch,
+          colorize: colorize?,
+          logging: logging,
+          tools: tool_hashes_by_name
+        }
+      end
+
+      private
+
+      def tool_hashes_by_name
+        return {} unless tools
+        tools
+          .map { |tool_option| [tool_option.tool_name, tool_option.to_h] }
+          .to_h
       end
     end
   end

data/lib/quiet_quality/config/parsed_options.rb

@@ -9,6 +9,7 @@ module QuietQuality
         :annotator,
         :executor,
         :comparison_branch,
+        :colorize,
         :logging,
         :limit_targets,
         :filter_messages,

data/lib/quiet_quality/config/parser.rb

@@ -46,7 +46,8 @@ module QuietQuality
         read_global_option(opts, :all_files, :limit_targets, 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)
+        read_global_option(opts, :colorize, :colorize, as: :boolean)
+        read_global_option(opts, :logging, :logging, as: :symbol, validate_from: Options::LOGGING_LEVELS)
       end
 
       def store_tool_options(opts)

data/lib/quiet_quality/config/tool_options.rb

@@ -35,6 +35,15 @@ module QuietQuality
         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
+        }
+      end
     end
   end
 end

data/lib/quiet_quality/executors/pipeline.rb

@@ -1,6 +1,8 @@
 module QuietQuality
   module Executors
     class Pipeline
+      include Logging
+
       def initialize(tool_options:, changed_files: nil)
         @tool_options = tool_options
         @changed_files = changed_files
@@ -25,10 +27,7 @@ module QuietQuality
 
       def messages
         return @_messages if defined?(@_messages)
-        @_messages = parser.messages
-        @_messages = relevance_filter.filter(@_messages) if filter_messages? && changed_files
-        @_messages.each { |m| locator.update!(m) } if changed_files
-        @_messages
+        @_messages = relocated(filtered(parser.messages))
       end
 
       private
@@ -51,7 +50,12 @@ module QuietQuality
         @_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)
+        info("Runner #{r.tool_name} command: `#{r.command.join(" ")}`")
+        debug("Full command for #{r.tool_name}", data: r.command)
       end
 
       def parser
@@ -65,6 +69,23 @@ module QuietQuality
       def locator
         @_locator ||= AnnotationLocator.new(changed_files: changed_files)
       end
+
+      def filtered(messages_object)
+        return messages_object unless filter_messages? && changed_files
+
+        original_count = messages_object.count
+        relevance_filter.filter(messages_object).tap do |filtered|
+          info("Messages for #{tool_name} filtered from #{original_count} to #{filtered.count}")
+        end
+      end
+
+      def relocated(messages_object)
+        if changed_files && !messages_object.empty?
+          messages_object.each { |m| locator.update!(m) }
+          info("Messages for #{tool_name} positioned into the diff for annotation purposes")
+        end
+        messages_object
+      end
     end
   end
 end

data/lib/quiet_quality/logger.rb

@@ -1,17 +1,65 @@
 module QuietQuality
   class Logger
-    def initialize(stream:, logging:)
+    LEVEL_UPS = {none: :warn, warn: :info, info: :debug}.freeze
+    LEVELS = {none: 0, warn: 1, info: 2, debug: 3}.freeze
+    COLORS = {warn: :yellow, info: :light_blue, debug: :light_cyan}.freeze
+
+    def initialize(level: :warn, stream: $stderr)
+      @level = level
       @stream = stream
-      @logging = logging
     end
 
-    def puts(s)
-      return if logging.quiet?
-      stream.puts(s)
+    attr_reader :level
+
+    def increase_level!
+      next_level = LEVEL_UPS.fetch(level, nil)
+      self.level = next_level if next_level
+    end
+
+    def show?(message_level)
+      LEVELS[message_level] <= LEVELS[level]
+    end
+
+    def level=(name)
+      fail(ArgumentError, "Unrecognized Logger level '#{name}'") unless LEVELS.include?(name.to_sym)
+      @level = name.to_sym
+    end
+
+    def warn(message, data: nil)
+      log_message(message, data, :warn)
+    end
+
+    def info(message, data: nil)
+      log_message(message, data, :info)
+    end
+
+    def debug(message, data: nil)
+      log_message(message, data, :debug)
     end
 
     private
 
-    attr_reader :stream, :logging
+    attr_reader :stream
+
+    def log_message(message, data, message_level)
+      return unless show?(message_level)
+      stream.puts formatted_message(message, data, message_level)
+      stream.flush
+    end
+
+    def formatted_message(message, data, message_level)
+      prefix = message_level.to_s.upcase.rjust(5)
+      if data
+        data_text = JSON.pretty_generate(data)
+        message = message + "\n" + data_text
+      end
+      prefixed_message = message.split("\n").map { |line| "[#{prefix}] #{line}" }.join("\n")
+      colorize(prefixed_message, message_level)
+    end
+
+    def colorize(s, message_level)
+      color = COLORS.fetch(message_level)
+      Colorize.colorize(s, color: color)
+    end
   end
 end

data/lib/quiet_quality/logging.rb

@@ -0,0 +1,21 @@
+module QuietQuality
+  module Logging
+    def warn(message, data: nil)
+      logger.warn(message, data: data)
+    end
+
+    def info(message, data: nil)
+      logger.info(message, data: data)
+    end
+
+    def debug(message, data: nil)
+      logger.debug(message, data: data)
+    end
+
+    private
+
+    def logger
+      QuietQuality.logger
+    end
+  end
+end

data/lib/quiet_quality/tools/base_runner.rb

@@ -1,6 +1,8 @@
 module QuietQuality
   module Tools
     class BaseRunner
+      include Logging
+
       # In general, we don't want to supply a huge number of arguments to a command-line tool.
       MAX_FILES = 100
 
@@ -36,6 +38,8 @@ module QuietQuality
 
       def performed_outcome
         out, err, stat = Open3.capture3(*command)
+        log_performance(err, stat)
+
         if success_status?(stat)
           Outcome.new(tool: tool_name, output: out, logging: err)
         elsif failure_status?(stat)
@@ -44,6 +48,11 @@ module QuietQuality
           fail(ExecutionError, "Execution of #{tool_name} failed with #{stat.exitstatus}")
         end
       end
+
+      def log_performance(err, stat)
+        info("Runner #{tool_name} exited with #{stat.exitstatus}")
+        debug("Runner logs from #{tool_name}:", data: err&.split("\n"))
+      end
     end
   end
 end

data/lib/quiet_quality/tools/relevant_runner.rb

@@ -48,6 +48,7 @@ module QuietQuality
       end
 
       def skipped_outcome
+        info("Runner #{tool_name} was skipped")
         Outcome.new(tool: tool_name, output: no_files_output)
       end
     end

data/lib/quiet_quality/version.rb

@@ -1,3 +1,3 @@
 module QuietQuality
-  VERSION = "1.2.2"
+  VERSION = "1.3.0"
 end

data/lib/quiet_quality.rb

@@ -10,7 +10,13 @@ require "set" # rubocop:disable Lint/RedundantRequireStatement
 
 module QuietQuality
   Error = Class.new(StandardError)
+
+  def self.logger
+    @_logger ||= QuietQuality::Logger.new
+  end
 end
 
+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 }

data/quiet_quality.gemspec

@@ -40,6 +40,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "pry", "~> 0.14"
   spec.add_development_dependency "standard", "~> 1.28"
   spec.add_development_dependency "rubocop", "~> 1.50"
-  spec.add_development_dependency "debug"
+  spec.add_development_dependency "debug", "~> 1.7"
   spec.add_development_dependency "mdl", "~> 0.12"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quiet_quality
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.3.0
 platform: ruby
 authors:
 - Eric Mueller
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-04 00:00:00.000000000 Z
+date: 2023-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: git
@@ -126,16 +126,16 @@ dependencies:
   name: debug
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: mdl
   requirement: !ruby/object:Gem::Requirement
@@ -186,10 +186,10 @@ files:
 - lib/quiet_quality/cli/arg_parser.rb
 - lib/quiet_quality/cli/entrypoint.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/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
@@ -200,6 +200,7 @@ files:
 - lib/quiet_quality/executors/pipeline.rb
 - lib/quiet_quality/executors/serial_executor.rb
 - lib/quiet_quality/logger.rb
+- lib/quiet_quality/logging.rb
 - lib/quiet_quality/message.rb
 - lib/quiet_quality/message_filter.rb
 - lib/quiet_quality/messages.rb

data/lib/quiet_quality/config/logging.rb

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