quiet_quality 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f9c943644f5453e92b2b839bf42f8f031f67b13d6c8385c89822b17b02dccf60
+  data.tar.gz: 780325cd5db5fdac051880d404756887e60882929503e76876f178945d167f92
+SHA512:
+  metadata.gz: 3afd25c6af0810f3c6195ba0947173be2b926e1d689d7e095458c18e97e445a40935ce62cb730195a0b33a93f57568d4328a4260651183df08a7cac41b5cb8eb
+  data.tar.gz: c345f28884539737a9d37b1aaa8480ee06957c43d6b83b8eaa7d302855285f3f098f8f2b110b880da54cfdec7e4105a81a9701358494e92b9425849fc7231576

data/.github/workflows/dogfood.yml

@@ -0,0 +1,28 @@
+name: QuietQuality Itself
+
+on: [push]
+
+jobs:
+  QuietQuality:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.2
+
+      - name: Cache gems
+        uses: actions/cache@v3
+        with:
+          path: vendor/bundle
+          key: ${{ runner.os }}-dogfood-${{ hashFiles('Gemfile.lock') }}
+          restore-keys:
+            ${{ runner.os }}-dogfood-
+
+      - name: Install gems
+        run: bundle install --jobs 4 --retry 3
+
+      - name: Run QuietQuality
+        run: bundle exec bin/qq standardrb rubocop rspec --all-files --unfiltered --annotate github_stdout

data/.github/workflows/linters.yml

@@ -0,0 +1,31 @@
+name: Linters
+
+on: [push]
+
+jobs:
+  StandardRB:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.2
+
+      - name: Cache gems
+        uses: actions/cache@v3
+        with:
+          path: vendor/bundle
+          key: ${{ runner.os }}-linters-${{ hashFiles('Gemfile.lock') }}
+          restore-keys:
+            ${{ runner.os }}-linters-
+
+      - name: Install gems
+        run: bundle install --jobs 4 --retry 3
+
+      - name: Run standard
+        run: bundle exec standardrb
+
+      - name: Run rubocop (complexity checks)
+        run: bundle exec rubocop --parallel

data/.github/workflows/rspec.yml

@@ -0,0 +1,33 @@
+name: RSpec
+
+on: [push]
+
+jobs:
+  RSpec:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby-version: ['2.7', '3.0', '3.1', '3.2', 'head']
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+
+      - name: Cache gems
+        uses: actions/cache@v3
+        with:
+          path: vendor/bundle
+          key: ${{ runner.os }}-rspec-${{ matrix.ruby-version }}-${{ hashFiles('Gemfile.lock') }}
+          restore-keys:
+            ${{ runner.os }}-rspec-${{ matrix.ruby-version }}-
+
+      - name: Install gems
+        run: bundle install --jobs 4 --retry 3
+
+      - name: Run RSpec
+        run: bundle exec rspec

data/.gitignore

@@ -0,0 +1,6 @@
+.ruby-version
+.ruby-gemset
+Gemfile.lock
+*.gem
+coverage/
+tmp/*

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,21 @@
+---
+AllCops:
+  SuggestExtensions: false
+  DisabledByDefault: true
+
+Metrics/AbcSize:
+  Max: 15
+Metrics/CyclomaticComplexity:
+  Max: 8
+Metrics/PerceivedComplexity:
+  Max: 7
+
+Metrics/ClassLength:
+  CountComments: false
+  Max: 150
+Metrics/MethodLength:
+  CountComments: false
+  Max: 15
+Metrics/ParameterLists:
+  Max: 5
+  CountKeywordArgs: true

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright 2023 Eric Mueller
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,34 @@
+# QuietQuality
+
+Work in Progress
+
+But essentially, QuietQuality is intended for two purposes:
+
+1. Let you conveniently run tools like rubocop, rspec, and standard against the _relevant_
+   files locally (the files that have changed locally relative to the default branch)
+2. Let you run those tools in CI (probably github actions) and annotate any issues found
+   with _new or modified_ code, without bothering you about existing issues that you didn't
+   touch.
+
+
+Basic usage examples:
+
+```
+# you have five commits in your feature branch and 3 more files changes but not committed.
+# this will run rubocop against all of those files.
+qq rubocop
+
+# run rspec against the changed specs, and annotate any failing specs (well, the first 10
+# of them) against the commit using github's inline output-based annotation approach. Which
+# will of course only produce actual annotations if this happens to have been run in a
+# github action.
+qq rspec --annotate=stdout
+
+# run standardrb against all of the files (not just the changed ones). Still only print out
+# problems to lines that have changed, so not particularly useful :-)
+qq standard --all --incremental
+
+# run all of the tools against the entire repository, and print the first three messages
+# out for each tool.
+qq all --all --full --limit-per-tool=3
+```

data/bin/qq

@@ -0,0 +1,35 @@
+#!/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

data/lib/quiet_quality/annotation_locator.rb

@@ -0,0 +1,33 @@
+module QuietQuality
+  class AnnotationLocator
+    def initialize(changed_files:)
+      @changed_files = changed_files
+    end
+
+    def update!(message)
+      changed_file = changed_files.file(message.path)
+      message.annotated_line = changed_file ? file_line_for(message, changed_file) : nil
+    end
+
+    def update_all!(messages)
+      messages.map { |m| update!(m) }.compact.length
+    end
+
+    private
+
+    attr_reader :changed_files
+
+    def file_line_for(message, changed_file)
+      return message.stop_line if changed_file.entire?
+      message_range = (message.start_line..message.stop_line)
+      last_match(changed_file.line_numbers, message_range)
+    end
+
+    def last_match(array, range)
+      array.reverse_each do |value|
+        return value if range.cover?(value)
+      end
+      nil
+    end
+  end
+end

data/lib/quiet_quality/annotators/github_stdout.rb

@@ -0,0 +1,36 @@
+module QuietQuality
+  module Annotators
+    class GithubStdout
+      # github will only accept the first 10 annotations of each type in this form.
+      MAX_ANNOTATIONS = 10
+
+      def initialize(output_stream: $stdout)
+        @output_stream = output_stream
+      end
+
+      def annotate!(messages)
+        messages.first(MAX_ANNOTATIONS).each do |message|
+          output_stream.puts self.class.format(message)
+        end
+      end
+
+      # Example annotation output from github's docs:
+      # ::warning file={name},line={line},title={title}::{message}
+      # See https://docs.github.com/en/actions/using-workflows/workflow-commands-for-github-actions#setting-a-warning-message
+      def self.format(message)
+        attributes = {
+          file: message.path,
+          line: message.annotated_line || message.start_line,
+          title: message.rule
+        }.compact
+
+        attributes_string = attributes.map { |k, v| "#{k}=#{v}" }.join(",")
+        "::warning #{attributes_string}::#{message.body}"
+      end
+
+      private
+
+      attr_reader :output_stream
+    end
+  end
+end

data/lib/quiet_quality/annotators.rb

@@ -0,0 +1,19 @@
+glob = File.expand_path("../annotators/*.rb", __FILE__)
+Dir.glob(glob).sort.each { |f| require(f) }
+
+module QuietQuality
+  module Annotators
+    Unrecognized = Class.new(Error)
+
+    ANNOTATOR_TYPES = {
+      github_stdout: Annotators::GithubStdout
+    }.freeze
+
+    def self.annotate!(annotator:, messages:, limit: nil)
+      limited_messages = limit ? messages.first(limit) : messages
+      ANNOTATOR_TYPES.fetch(annotator.to_sym).new.annotate!(limited_messages)
+    rescue KeyError
+      fail Unrecognized, "Unrecognized annotator_type '#{annotator}'"
+    end
+  end
+end

data/lib/quiet_quality/changed_file.rb

@@ -0,0 +1,40 @@
+module QuietQuality
+  class ChangedFile
+    attr_reader :path
+
+    def initialize(path:, lines:)
+      @path = path
+
+      if lines == :all || lines == "all"
+        @entire = true
+        @lines = nil
+      else
+        @entire = false
+        @lines = lines
+      end
+    end
+
+    def entire?
+      @entire
+    end
+
+    def lines
+      return nil if @lines.nil?
+      @_lines ||= @lines.to_set
+    end
+
+    def line_numbers
+      return nil if @lines.nil?
+      @_line_numbers ||= @lines.sort
+    end
+
+    def merge(other)
+      if path != other.path
+        fail ArgumentError, "Cannot merge ChangedFiles '#{path}' and '#{other.path}', they're different files"
+      end
+
+      new_lines = (entire? || other.entire?) ? :all : (lines + other.lines).to_a
+      self.class.new(path: path, lines: new_lines)
+    end
+  end
+end

data/lib/quiet_quality/changed_files.rb

@@ -0,0 +1,35 @@
+module QuietQuality
+  class ChangedFiles
+    attr_reader :files
+
+    def initialize(files)
+      @files = files
+    end
+
+    def paths
+      @_paths ||= files.map(&:path)
+    end
+
+    def file(path)
+      files_by_path.fetch(path, nil)
+    end
+
+    def include?(path)
+      files_by_path.include?(path)
+    end
+
+    def merge(other)
+      merged_files = []
+      (files + other.files)
+        .group_by(&:path)
+        .each_pair { |_path, pfiles| merged_files << pfiles.reduce(&:merge) }
+      self.class.new(merged_files)
+    end
+
+    private
+
+    def files_by_path
+      @_files_by_path ||= files.map { |f| [f.path, f] }.to_h
+    end
+  end
+end

data/lib/quiet_quality/cli/option_parser.rb

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

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

@@ -0,0 +1,49 @@
+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/cli.rb

@@ -0,0 +1,12 @@
+require_relative "./annotators"
+require_relative "./tools"
+
+module QuietQuality
+  module Cli
+    Error = Class.new(QuietQuality::Error)
+    UsageError = Class.new(Error)
+  end
+end
+
+glob = File.expand_path("../cli/*.rb", __FILE__)
+Dir.glob(glob).sort.each { |f| require f }

data/lib/quiet_quality/executors/base_executor.rb

@@ -0,0 +1,46 @@
+module QuietQuality
+  module Executors
+    class BaseExecutor
+      def initialize(tools:, changed_files: nil)
+        @tools = tools
+        @changed_files = changed_files
+      end
+
+      def execute!
+        fail NoMethodError, "execute! should be implemented by the subclass of BaseExecutor"
+      end
+
+      def outcomes
+        @_outcomes ||= pipelines.map(&:outcome)
+      end
+
+      def messages
+        @_messages ||= Messages.new(pipelines.map(&:messages).map(&:all).reduce(&:+))
+      end
+
+      def any_failure?
+        pipelines.any?(&:failure?)
+      end
+
+      private
+
+      attr_reader :tools, :changed_files
+
+      def pipelines
+        @_pipelines ||= tools.map do |topts|
+          Pipeline.new(tool_options: topts, changed_files: changed_files)
+        end
+      end
+
+      def pipeline_by_tool
+        @_pipeline_by_tool ||= pipelines
+          .map { |p| [p.tool_name, p] }
+          .to_h
+      end
+
+      def pipeline_for(tool)
+        pipeline_by_tool.fetch(tool.to_sym)
+      end
+    end
+  end
+end

data/lib/quiet_quality/executors/concurrent_executor.rb

@@ -0,0 +1,20 @@
+module QuietQuality
+  module Executors
+    class ConcurrentExecutor < BaseExecutor
+      def execute!
+        threads = pipelines.map { |pipeline| threaded_pipeline(pipeline) }
+        threads.each(&:join)
+        pipelines.none?(&:failure?)
+      end
+
+      private
+
+      def threaded_pipeline(pipeline)
+        Thread.new do
+          pipeline.outcome
+          pipeline.messages
+        end
+      end
+    end
+  end
+end