quiet_quality 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9c943644f5453e92b2b839bf42f8f031f67b13d6c8385c89822b17b02dccf60
-  data.tar.gz: 780325cd5db5fdac051880d404756887e60882929503e76876f178945d167f92
+  metadata.gz: 92fb13c8040117b5c0117af41e7253d793c2818a05c4d69b8f522677f20b96a7
+  data.tar.gz: 27da41d1430f7a09a22444fa117904f231b8feec6006c48393bd9d0cf9859707
 SHA512:
-  metadata.gz: 3afd25c6af0810f3c6195ba0947173be2b926e1d689d7e095458c18e97e445a40935ce62cb730195a0b33a93f57568d4328a4260651183df08a7cac41b5cb8eb
-  data.tar.gz: c345f28884539737a9d37b1aaa8480ee06957c43d6b83b8eaa7d302855285f3f098f8f2b110b880da54cfdec7e4105a81a9701358494e92b9425849fc7231576
+  metadata.gz: 020bb9aa46fc7a1d5989dbf7f03538533b6f54006e23003f90209a6baacbb03c015cee81f00893047bc7c39260788d62a4380157ee95b610acd08acd64746569
+  data.tar.gz: 68d20464b4f83e819ef8e8128420e84cadb857183238167aa4a9b4947890d571ec636836656bc728dc3b459b75668152e1c510f034a8ddc8d49e5403150ec3b3

data/.quiet_quality.yml

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

data/bin/qq

@@ -1,35 +1,3 @@
 #!/usr/bin/env ruby
 require_relative "../lib/quiet_quality"
-
-opt_parser = QuietQuality::Cli::OptionParser.new(ARGV)
-tool_names, global_options, tool_options = opt_parser.parse!
-options = QuietQuality::Cli::OptionsBuilder.new(tool_names: tool_names, global_options: global_options, tool_options: tool_options).options
-
-executor = options.executor.new(tools: options.tools)
-executor.execute!
-
-executor.outcomes.each do |outcome|
-  result = outcome.success? ? "Passed" : "Failed"
-  warn "--- #{result}: #{outcome.tool}"
-end
-
-messages = executor.messages
-if messages.any?
-  warn "\n\n#{messages.count} messages:"
-  messages.each do |msg|
-    line_range = msg.start_line == msg.stop_line ? msg.start_line.to_s : "#{msg.start_line}-#{msg.stop_line}"
-    body = msg.body.gsub(/ *\n */, "\\n").slice(0, 120)
-    warn "  #{msg.path}:#{line_range}   #{msg.rule}"
-    warn "      #{body}"
-  end
-end
-
-if options.annotator
-  warn "\n\n"
-  options.annotator.new.annotate!(messages)
-end
-
-if executor.any_failure?
-  warn "failures detected in one or more tools"
-  exit(1)
-end
+exit(1) unless QuietQuality::Cli::Entrypoint.new(argv: ARGV).execute.successful?

data/lib/quiet_quality/cli/arg_parser.rb

@@ -0,0 +1,135 @@
+require "optparse"
+
+module QuietQuality
+  module Cli
+    class ArgParser
+      def initialize(args)
+        @args = args
+        @parsed_options = Config::ParsedOptions.new
+        @parsed = false
+      end
+
+      def parsed_options
+        unless @parsed
+          parser.parse!(@args)
+          @parsed_options.tools = validated_tool_names(@args.dup).map(&:to_sym)
+          @parsed = true
+        end
+        @parsed_options
+      end
+
+      def help_text
+        @_help_text ||= parser.to_s
+      end
+
+      private
+
+      def set_global_option(name, value)
+        @parsed_options.set_global_option(name, value)
+      end
+
+      def set_tool_option(tool, name, value)
+        @parsed_options.set_tool_option(tool, name, value)
+      end
+
+      def validate_value_from(name, value, allowed)
+        return if allowed.include?(value.to_sym)
+        fail(UsageError, "Unrecognized #{name}: #{value}")
+      end
+
+      def validated_tool_names(names)
+        names.each { |name| validate_value_from("tool", name, Tools::AVAILABLE) }
+      end
+
+      # There are several flags that _may_ take a 'tool' argument - if they do, they are tool
+      # options; if they don't, they are global options. (optparse allows an optional argument
+      # to a flag if the string representing it is not a 'string in all caps'. So `[FOO]` or `foo`
+      # would be optional, but `FOO` would be required. This helper simplifies handling those.
+      def read_tool_or_global_option(name, tool, value)
+        if tool
+          validate_value_from("tool", tool, Tools::AVAILABLE)
+          set_tool_option(tool, name, value)
+        else
+          set_global_option(name, value)
+        end
+      end
+
+      # -- Set up the option parser itself -------------------------
+
+      def parser
+        @_parser ||= ::OptionParser.new do |parser|
+          setup_banner(parser)
+          setup_help_output(parser)
+          setup_config_options(parser)
+          setup_executor_options(parser)
+          setup_annotation_options(parser)
+          setup_file_target_options(parser)
+          setup_filter_messages_options(parser)
+        end
+      end
+
+      def setup_banner(parser)
+        parser.banner = "Usage: qq [TOOLS] [GLOBAL_OPTIONS] [TOOL_OPTIONS]"
+      end
+
+      def setup_help_output(parser)
+        parser.on("-h", "--help", "Prints this help") do
+          @parsed_options.helping = true
+        end
+      end
+
+      def setup_config_options(parser)
+        parser.on("-C", "--config PATH", "Load a config file from this path") do |path|
+          set_global_option(:config_path, path)
+        end
+
+        parser.on("-N", "--no-config", "Do not load a config file, even if present") do
+          set_global_option(:no_config, true)
+        end
+      end
+
+      def setup_executor_options(parser)
+        parser.on("-E", "--executor EXECUTOR", "Which executor to use") do |name|
+          validate_value_from("executor", name, Executors::AVAILABLE)
+          set_global_option(:executor, name.to_sym)
+        end
+      end
+
+      def setup_annotation_options(parser)
+        parser.on("-A", "--annotate ANNOTATOR", "Annotate with this annotator") do |name|
+          validate_value_from("annotator", name, Annotators::ANNOTATOR_TYPES)
+          set_global_option(:annotator, name.to_sym)
+        end
+
+        # shortcut option
+        parser.on("-G", "--annotate-github-stdout", "Annotate with GitHub Workflow commands") do
+          set_global_option(:annotator, :github_stdout)
+        end
+      end
+
+      def setup_file_target_options(parser)
+        parser.on("-a", "--all-files [tool]", "Use the tool(s) on all files") do |tool|
+          read_tool_or_global_option(:all_files, tool, true)
+        end
+
+        parser.on("-c", "--changed-files [tool]", "Use the tool(s) only on changed files") do |tool|
+          read_tool_or_global_option(:all_files, tool, false)
+        end
+
+        parser.on("-B", "--comparison-branch BRANCH", "Specify the branch to compare against") do |branch|
+          set_global_option(:comparison_branch, branch)
+        end
+      end
+
+      def setup_filter_messages_options(parser)
+        parser.on("-f", "--filter-messages [tool]", "Filter messages from tool(s) based on changed lines") do |tool|
+          read_tool_or_global_option(:filter_messages, tool, true)
+        end
+
+        parser.on("-u", "--unfiltered [tool]", "Don't filter messages from tool(s)") do |tool|
+          read_tool_or_global_option(:filter_messages, tool, false)
+        end
+      end
+    end
+  end
+end

data/lib/quiet_quality/cli/entrypoint.rb

@@ -0,0 +1,95 @@
+module QuietQuality
+  module Cli
+    class Entrypoint
+      def initialize(argv:, output_stream: $stdout, error_stream: $stderr)
+        @argv = argv
+        @output_stream = output_stream
+        @error_stream = error_stream
+      end
+
+      def execute
+        if helping?
+          log_help_text
+        else
+          executed
+          log_outcomes
+          log_messages
+          annotate_messages
+        end
+
+        self
+      end
+
+      def successful?
+        helping? || !executed.any_failure?
+      end
+
+      private
+
+      attr_reader :argv, :output_stream, :error_stream
+
+      def arg_parser
+        @_arg_parser ||= ArgParser.new(argv.dup)
+      end
+
+      def parsed_options
+        @_parsed_options ||= arg_parser.parsed_options
+      end
+
+      def helping?
+        parsed_options.helping?
+      end
+
+      def log_help_text
+        error_stream.puts(arg_parser.help_text)
+      end
+
+      def options
+        return @_options if defined?(@_options)
+        builder = Config::Builder.new(parsed_cli_options: parsed_options)
+        @_options = builder.options
+      end
+
+      def executor
+        @_executor ||= options.executor.new(tools: options.tools)
+      end
+
+      def executed
+        return @_executed if defined?(@_executed)
+        executor.execute!
+        @_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)
+        annotator.annotate!(executed.messages)
+      end
+    end
+  end
+end

data/lib/quiet_quality/config/builder.rb

@@ -0,0 +1,123 @@
+module QuietQuality
+  module Config
+    class Builder
+      def initialize(parsed_cli_options:)
+        @cli = parsed_cli_options
+      end
+
+      def options
+        return @_options if defined?(@_options)
+        options = build_initial_options
+        Updater.new(options: options, apply: config_file).update! if config_file
+        Updater.new(options: options, apply: cli).update!
+        @_options = options
+      end
+
+      private
+
+      attr_reader :cli
+
+      def build_initial_options
+        tools = tool_names.map { |name| ToolOptions.new(name) }
+        Options.new.tap { |opts| opts.tools = tools }
+      end
+
+      def tool_names
+        if cli.tools.any?
+          cli.tools
+        elsif config_file&.tools&.any?
+          config_file.tools
+        else
+          Tools::AVAILABLE.keys
+        end
+      end
+
+      def config_finder
+        @_config_finder ||= Finder.new(from: ".")
+      end
+
+      def config_path
+        return @_config_path if defined?(@_config_path)
+
+        @_config_path =
+          if cli.global_option(:no_config)
+            nil
+          elsif cli.global_option(:config_path)
+            cli.global_option(:config_path)
+          elsif config_finder.config_path
+            config_finder.config_path
+          end
+      end
+
+      def config_file
+        return @_parsed_config_options if defined?(@_parsed_config_options)
+
+        if config_path
+          parser = Parser.new(config_path)
+          @_parsed_config_options = parser.parsed_options
+        else
+          @_parsed_config_options = nil
+        end
+      end
+
+      class Updater
+        def initialize(options:, apply:)
+          @options, @apply = options, apply
+        end
+
+        def update!
+          update_globals
+          update_tools
+        end
+
+        private
+
+        attr_reader :options, :apply
+
+        def set_unless_nil(object, method, value)
+          return if value.nil?
+          object.send("#{method}=", value)
+        end
+
+        # ---- update the global options -------------
+
+        def update_globals
+          update_annotator
+          update_executor
+          update_comparison_branch
+        end
+
+        def update_annotator
+          annotator_name = apply.global_option(:annotator)
+          return if annotator_name.nil?
+          options.annotator = Annotators::ANNOTATOR_TYPES.fetch(annotator_name)
+        end
+
+        def update_executor
+          executor_name = apply.global_option(:executor)
+          return if executor_name.nil?
+          options.executor = Executors::AVAILABLE.fetch(executor_name)
+        end
+
+        def update_comparison_branch
+          set_unless_nil(options, :comparison_branch, apply.global_option(:comparison_branch))
+        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)
+          end
+        end
+
+        def update_tool_option(tool_options, option_name)
+          tool_name = tool_options.tool_name
+          set_unless_nil(tool_options, option_name, apply.global_option(option_name))
+          set_unless_nil(tool_options, option_name, apply.tool_option(tool_name, option_name))
+        end
+      end
+    end
+  end
+end

data/lib/quiet_quality/config/finder.rb

@@ -0,0 +1,45 @@
+module QuietQuality
+  module Config
+    class Finder
+      CONFIG_FILENAME = ".quiet_quality.yml"
+      MAXIMUM_SEARCH_DEPTH = 100
+
+      def initialize(from:)
+        @from = from
+      end
+
+      def config_path
+        return @_config_path if defined?(@_config_path)
+        each_successive_enclosing_directory do |dir_path|
+          file_path = dir_path.join(CONFIG_FILENAME)
+          if file_path.exist?
+            return @_config_path = file_path.to_s
+          end
+        end
+        @_config_path = nil
+      rescue Errno::EACCES
+        @_config_path = nil
+      end
+
+      private
+
+      attr_reader :from
+
+      def config_path_within(dir)
+        File.join(dir, CONFIG_FILENAME)
+      end
+
+      def each_successive_enclosing_directory(max_depth: 100, &block)
+        d = Pathname.new(from)
+        depth = 0
+        MAXIMUM_SEARCH_DEPTH.times do
+          block.call(d.expand_path)
+          d = d.parent
+          depth += 1
+          return nil if d.root?
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/quiet_quality/config/options.rb

@@ -0,0 +1,14 @@
+module QuietQuality
+  module Config
+    class Options
+      def initialize
+        @annotator = nil
+        @executor = Executors::ConcurrentExecutor
+        @tools = nil
+        @comparison_branch = nil
+      end
+
+      attr_accessor :tools, :comparison_branch, :annotator, :executor
+    end
+  end
+end

data/lib/quiet_quality/config/parsed_options.rb

@@ -0,0 +1,36 @@
+module QuietQuality
+  module Config
+    class ParsedOptions
+      def initialize
+        @tools = []
+        @tool_options = {}
+        @global_options = {}
+        @helping = false
+      end
+
+      attr_accessor :tools
+      attr_writer :helping
+
+      def helping?
+        @helping
+      end
+
+      def set_global_option(name, value)
+        @global_options[name.to_sym] = value
+      end
+
+      def global_option(name)
+        @global_options.fetch(name.to_sym, nil)
+      end
+
+      def set_tool_option(tool, name, value)
+        @tool_options[tool.to_sym] ||= {}
+        @tool_options[tool.to_sym][name.to_sym] = value
+      end
+
+      def tool_option(tool, name)
+        @tool_options.dig(tool.to_sym, name.to_sym)
+      end
+    end
+  end
+end

data/lib/quiet_quality/config/parser.rb

@@ -0,0 +1,134 @@
+module QuietQuality
+  module Config
+    class Parser
+      InvalidConfig = Class.new(Config::Error)
+
+      def initialize(path)
+        @path = path
+      end
+
+      def parsed_options
+        @_parsed_options ||= ParsedOptions.new.tap do |opts|
+          store_default_tools(opts)
+          store_global_options(opts)
+          store_tool_options(opts)
+        end
+      end
+
+      private
+
+      attr_reader :path
+
+      def text
+        @_text ||= File.read(path)
+      end
+
+      def data
+        @_data ||= YAML.safe_load(text, symbolize_names: true)
+      end
+
+      def store_default_tools(opts)
+        tool_names = data.fetch(:default_tools, [])
+        invalid!("default_tools must be an array") unless tool_names.is_a?(Array)
+        tool_names.each do |name|
+          invalid!("each default tool must be a string") unless name.is_a?(String)
+          invalid!("unrecognized tool name '#{name}'") unless valid_tool?(name)
+        end
+        opts.tools = tool_names.map(&:to_sym)
+      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)
+      end
+
+      def store_tool_options(opts)
+        Tools::AVAILABLE.keys.each do |tool_name|
+          store_tool_options_for(opts, tool_name)
+        end
+      end
+
+      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)
+      end
+
+      def invalid!(message)
+        fail(InvalidConfig, message)
+      end
+
+      def valid_tool?(name)
+        Tools::AVAILABLE.key?(name.to_sym)
+      end
+
+      def valid_boolean?(value)
+        [true, false].include?(value)
+      end
+
+      def read_global_option(opts, name, 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)
+      end
+
+      def read_tool_option(opts, tool, name, 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)
+      end
+
+      def validate_value(name, value, as:, from: nil)
+        case as
+        when :boolean then validate_boolean(name, value)
+        when :symbol then validate_symbol(name, value, from: from)
+        when :string then validate_string(name, value)
+        else
+          fail ArgumentError, "validate_value does not handle type #{as}"
+        end
+      end
+
+      def validate_boolean(name, value)
+        return if valid_boolean?(value)
+        invalid!("option #{name} must be either true or false")
+      end
+
+      def validate_symbol(name, value, from: nil)
+        unless value.is_a?(String) || value.is_a?(Symbol)
+          invalid!("option #{name} must be a string or symbol")
+        end
+
+        unless from.nil? || from.include?(value.to_sym)
+          allowed_list = from.respond_to?(:keys) ? from.keys : from
+          allowed_string = allowed_list.map(&:to_s).join(", ")
+          invalid!("option #{name} must be one of the allowed values: #{allowed_string}")
+        end
+      end
+
+      def validate_string(name, value)
+        invalid!("option #{name} must be a string") unless value.is_a?(String)
+        invalid!("option #{name} must not be empty") if value.empty?
+      end
+
+      def coerce_value(value, as:)
+        case as
+        when :boolean then !!value
+        when :string then value.to_s
+        when :symbol then value.to_sym
+        else
+          fail ArgumentError, "coerce_value does not handle type #{as}"
+        end
+      end
+    end
+  end
+end

data/lib/quiet_quality/config/tool_options.rb

@@ -0,0 +1,34 @@
+module QuietQuality
+  module Config
+    class ToolOptions
+      def initialize(tool, limit_targets: true, filter_messages: true)
+        @tool_name = tool.to_sym
+        @limit_targets = limit_targets
+        @filter_messages = filter_messages
+      end
+
+      attr_reader :tool_name
+      attr_writer :limit_targets, :filter_messages
+
+      def limit_targets?
+        @limit_targets
+      end
+
+      def filter_messages?
+        @filter_messages
+      end
+
+      def tool_namespace
+        Tools::AVAILABLE.fetch(tool_name)
+      end
+
+      def runner_class
+        tool_namespace::Runner
+      end
+
+      def parser_class
+        tool_namespace::Parser
+      end
+    end
+  end
+end

data/lib/quiet_quality/config.rb

@@ -0,0 +1,8 @@
+module QuietQuality
+  module Config
+    Error = Class.new(QuietQuality::Error)
+  end
+end
+
+glob = File.expand_path("../config/*.rb", __FILE__)
+Dir.glob(glob).sort.each { |f| require f }

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

@@ -0,0 +1,45 @@
+module QuietQuality
+  module Tools
+    module Brakeman
+      class Parser
+        def initialize(text)
+          @text = text
+        end
+
+        def messages
+          return @_messages if defined?(@_messages)
+          check_errors!
+          messages = warnings.map { |w| message_for(w) }
+          @_messages = Messages.new(messages)
+        end
+
+        private
+
+        attr_reader :text
+
+        def data
+          @_data ||= JSON.parse(text, symbolize_names: true)
+        end
+
+        def check_errors!
+          errors = data[:errors]
+          return if errors.nil? || errors.empty?
+          fail(ParsingError, "Found #{errors.length} errors in brakeman output")
+        end
+
+        def warnings
+          data[:warnings] || []
+        end
+
+        def message_for(warning)
+          path = warning.fetch(:file)
+          body = warning.fetch(:message)
+          line = warning.fetch(:line)
+          level = warning.fetch(:confidence, nil)
+          rule = warning.fetch(:warning_type)
+          Message.new(path: path, body: body, start_line: line, level: level, rule: rule)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+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
+        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
+        end
+      end
+    end
+  end
+end

data/lib/quiet_quality/tools/brakeman.rb

@@ -0,0 +1,13 @@
+require_relative "./rubocop"
+
+module QuietQuality
+  module Tools
+    module Brakeman
+      ExecutionError = Class.new(Tools::Error)
+      ParsingError = Class.new(Tools::Error)
+    end
+  end
+end
+
+glob = File.expand_path("../brakeman/*.rb", __FILE__)
+Dir.glob(glob).sort.each { |f| require f }

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

@@ -0,0 +1,45 @@
+module QuietQuality
+  module Tools
+    module HamlLint
+      class Parser
+        def initialize(text)
+          @text = text
+        end
+
+        def messages
+          return @_messages if defined?(@_messages)
+          messages = content
+            .fetch(:files)
+            .map { |f| messages_for_file(f) }
+            .flatten
+          @_messages = Messages.new(messages)
+        end
+
+        private
+
+        attr_reader :text
+
+        def content
+          @_content ||= JSON.parse(text, symbolize_names: true)
+        end
+
+        def messages_for_file(file_details)
+          path = file_details.fetch(:path)
+          file_details.fetch(:offenses).map do |offense|
+            message_for_offense(path, offense)
+          end
+        end
+
+        def message_for_offense(path, offense)
+          Message.new(
+            path: path,
+            body: offense.fetch(:message),
+            start_line: offense.dig(:location, :line),
+            level: offense.fetch(:severity, nil),
+            rule: offense.fetch(:linter_name, nil)
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+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") }
+        end
+
+        def target_files
+          return [] if changed_files.nil?
+          return [] if relevant_files.length > MAX_FILES
+          relevant_files
+        end
+
+        def command
+          return nil if skip_execution?
+          ["haml-lint", "--reporter", "json"] + target_files.sort
+        end
+
+        def skipped_outcome
+          Outcome.new(tool: :haml_lint, output: NO_FILES_OUTPUT)
+        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
+        end
+      end
+    end
+  end
+end

data/lib/quiet_quality/tools/haml_lint.rb

@@ -0,0 +1,11 @@
+module QuietQuality
+  module Tools
+    module HamlLint
+      ExecutionError = Class.new(Tools::Error)
+      ParsingError = Class.new(Tools::Error)
+    end
+  end
+end
+
+glob = File.expand_path("../haml_lint/*.rb", __FILE__)
+Dir.glob(glob).sort.each { |f| require f }

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

@@ -15,7 +15,7 @@ module QuietQuality
 
         private
 
-        attr_reader :changed_files, :error_stream
+        attr_reader :changed_files
 
         def skip_execution?
           changed_files && relevant_files.empty?

data/lib/quiet_quality/tools.rb

@@ -13,6 +13,8 @@ Dir.glob(glob).sort.each { |f| require f }
 module QuietQuality
   module Tools
     AVAILABLE = {
+      brakeman: Brakeman,
+      haml_lint: HamlLint,
       rspec: Rspec,
       rubocop: Rubocop,
       standardrb: Standardrb

data/lib/quiet_quality/version.rb

@@ -1,3 +1,3 @@
 module QuietQuality
-  VERSION = "0.1.0"
+  VERSION = "1.0.0"
 end

data/lib/quiet_quality.rb

@@ -2,6 +2,7 @@ require "git"
 require "git_diff_parser"
 require "json"
 require "yaml"
+require "pathname"
 
 # 'set' doesn't need requiring after ruby 3.2, but it won't hurt anything.
 # And we're compatible back to 2.6

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quiet_quality
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Eric Mueller
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-10 00:00:00.000000000 Z
+date: 2023-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: git
@@ -150,6 +150,7 @@ files:
 - ".github/workflows/linters.yml"
 - ".github/workflows/rspec.yml"
 - ".gitignore"
+- ".quiet_quality.yml"
 - ".rspec"
 - ".rubocop.yml"
 - Gemfile
@@ -163,9 +164,15 @@ files:
 - lib/quiet_quality/changed_file.rb
 - lib/quiet_quality/changed_files.rb
 - lib/quiet_quality/cli.rb
-- lib/quiet_quality/cli/option_parser.rb
-- lib/quiet_quality/cli/options.rb
-- lib/quiet_quality/cli/options_builder.rb
+- lib/quiet_quality/cli/arg_parser.rb
+- lib/quiet_quality/cli/entrypoint.rb
+- lib/quiet_quality/config.rb
+- lib/quiet_quality/config/builder.rb
+- lib/quiet_quality/config/finder.rb
+- lib/quiet_quality/config/options.rb
+- lib/quiet_quality/config/parsed_options.rb
+- lib/quiet_quality/config/parser.rb
+- lib/quiet_quality/config/tool_options.rb
 - lib/quiet_quality/executors.rb
 - lib/quiet_quality/executors/base_executor.rb
 - lib/quiet_quality/executors/concurrent_executor.rb
@@ -174,8 +181,13 @@ files:
 - lib/quiet_quality/message.rb
 - lib/quiet_quality/message_filter.rb
 - lib/quiet_quality/messages.rb
-- lib/quiet_quality/tool_options.rb
 - lib/quiet_quality/tools.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/outcome.rb
 - lib/quiet_quality/tools/rspec.rb
 - lib/quiet_quality/tools/rspec/parser.rb

data/lib/quiet_quality/cli/option_parser.rb

@@ -1,103 +0,0 @@
-require "optparse"
-
-module QuietQuality
-  module Cli
-    class OptionParser
-      attr_reader :options, :tool_options, :output
-
-      def initialize(args)
-        @args = args
-        @options = {
-          executor: :concurrent
-        }
-        @tool_options = {}
-        @output = nil
-      end
-
-      def parse!
-        parser.parse!(@args)
-        [positional, options, tool_options]
-      end
-
-      def positional
-        @args
-      end
-
-      private
-
-      def parser
-        ::OptionParser.new do |parser|
-          setup_banner(parser)
-          setup_help_output(parser)
-          setup_executor_options(parser)
-          setup_annotation_options(parser)
-          setup_file_target_options(parser)
-          setup_filter_messages_options(parser)
-        end
-      end
-
-      def setup_banner(parser)
-        parser.banner = "Usage: qq [TOOLS] [GLOBAL_OPTIONS] [TOOL_OPTIONS]"
-      end
-
-      def setup_help_output(parser)
-        parser.on("-h", "--help", "Prints this help") do
-          @output = parser.to_s
-          @options[:exit_immediately] = true
-        end
-      end
-
-      def setup_executor_options(parser)
-        parser.on("-E", "--executor EXECUTOR", "Which executor to use") do |name|
-          fail(UsageError, "Executor not recognized: #{name}") unless Executors::AVAILABLE.include?(name.to_sym)
-          @options[:executor] = name.to_sym
-        end
-      end
-
-      def setup_annotation_options(parser)
-        parser.on("-A", "--annotate ANNOTATOR", "Annotate with this annotator") do |name|
-          fail(UsageError, "Annotator not recognized: #{name}") unless Annotators::ANNOTATOR_TYPES.include?(name.to_sym)
-          @options[:annotator] = name.to_sym
-        end
-
-        # shortcut option
-        parser.on("-G", "--annotate-github-stdout", "Annotate with GitHub Workflow commands") do
-          @options[:annotator] = :github_stdout
-        end
-      end
-
-      def read_tool_or_global_option(name, tool, value)
-        if tool
-          @tool_options[tool.to_sym] ||= {}
-          @tool_options[tool.to_sym][name] = value
-        else
-          @options[name] = value
-        end
-      end
-
-      def setup_file_target_options(parser)
-        parser.on("-a", "--all-files [tool]", "Use the tool(s) on all files") do |tool|
-          read_tool_or_global_option(:all_files, tool, true)
-        end
-
-        parser.on("-c", "--changed-files [tool]", "Use the tool(s) only on changed files") do |tool|
-          read_tool_or_global_option(:all_files, tool, false)
-        end
-
-        parser.on("-B", "--comparison-branch BRANCH", "Specify the branch to compare against") do |branch|
-          @options[:comparison_branch] = branch
-        end
-      end
-
-      def setup_filter_messages_options(parser)
-        parser.on("-f", "--filter-messages [tool]", "Filter messages from tool(s) based on changed lines") do |tool|
-          read_tool_or_global_option(:filter_messages, tool, true)
-        end
-
-        parser.on("-u", "--unfiltered [tool]", "Don't filter messages from tool(s)") do |tool|
-          read_tool_or_global_option(:filter_messages, tool, false)
-        end
-      end
-    end
-  end
-end

data/lib/quiet_quality/cli/options.rb

@@ -1,27 +0,0 @@
-module QuietQuality
-  module Cli
-    class Options
-      def initialize
-        @annotator = nil
-        @executor = Executors::ConcurrentExecutor
-        @tools = nil
-        @comparison_branch = nil
-      end
-
-      attr_reader :annotator, :executor
-      attr_accessor :tools, :comparison_branch
-
-      def annotator=(name)
-        @annotator = Annotators::ANNOTATOR_TYPES.fetch(name.to_sym)
-      rescue KeyError
-        fail(UsageError, "Unrecognized annotator: #{name}")
-      end
-
-      def executor=(name)
-        @executor = Executors::AVAILABLE.fetch(name.to_sym)
-      rescue KeyError
-        fail(UsageError, "Unrecognized executor: #{name}")
-      end
-    end
-  end
-end

data/lib/quiet_quality/cli/options_builder.rb

@@ -1,49 +0,0 @@
-module QuietQuality
-  module Cli
-    class OptionsBuilder
-      def initialize(tool_names:, global_options:, tool_options:)
-        @raw_tool_names = tool_names
-        @raw_global_options = global_options
-        @raw_tool_options = tool_options
-      end
-
-      def options
-        return @_options if defined?(@_options)
-        options = Options.new
-        set_unless_nil(options, :annotator, @raw_global_options[:annotator])
-        set_unless_nil(options, :executor, @raw_global_options[:executor])
-        set_unless_nil(options, :comparison_branch, @raw_global_options[:comparison_branch])
-        options.tools = tool_names.map { |tool_name| tool_options_for(tool_name) }
-        @_options = options
-      end
-
-      private
-
-      def set_unless_nil(object, method, value)
-        return if value.nil?
-        object.send("#{method}=", value)
-      end
-
-      def tool_options_for(tool_name)
-        raw_tool_opts = @raw_tool_options.fetch(tool_name.to_sym, {})
-        ToolOptions.new(tool_name).tap do |tool_options|
-          set_unless_nil(tool_options, :limit_targets, @raw_global_options[:limit_targets])
-          set_unless_nil(tool_options, :limit_targets, raw_tool_opts[:limit_targets])
-
-          set_unless_nil(tool_options, :filter_messages, @raw_global_options[:filter_messages])
-          set_unless_nil(tool_options, :filter_messages, raw_tool_opts[:filter_messages])
-        end
-      end
-
-      def tool_names
-        names = @raw_tool_names.empty? ? Tools::AVAILABLE.keys : @raw_tool_names
-        names.map(&:to_sym).tap do |names|
-          unexpected_names = names - Tools::AVAILABLE.keys
-          if unexpected_names.any?
-            fail(UsageError, "Tool(s) not recognized: #{unexpected_names.join(", ")}")
-          end
-        end
-      end
-    end
-  end
-end

data/lib/quiet_quality/tool_options.rb

@@ -1,32 +0,0 @@
-module QuietQuality
-  class ToolOptions
-    def initialize(tool, limit_targets: true, filter_messages: true)
-      @tool_name = tool.to_sym
-      @limit_targets = limit_targets
-      @filter_messages = filter_messages
-    end
-
-    attr_reader :tool_name
-    attr_writer :limit_targets, :filter_messages
-
-    def limit_targets?
-      @limit_targets
-    end
-
-    def filter_messages?
-      @filter_messages
-    end
-
-    def tool_namespace
-      Tools::AVAILABLE.fetch(tool_name)
-    end
-
-    def runner_class
-      tool_namespace::Runner
-    end
-
-    def parser_class
-      tool_namespace::Parser
-    end
-  end
-end