quiet_quality 0.1.0

data/lib/quiet_quality/executors/pipeline.rb

@@ -0,0 +1,59 @@
+module QuietQuality
+  module Executors
+    class Pipeline
+      def initialize(tool_options:, changed_files: nil)
+        @tool_options = tool_options
+        @changed_files = changed_files
+      end
+
+      def tool_name
+        tool_options.tool_name
+      end
+
+      def outcome
+        @_outcome ||= runner.invoke!
+      end
+
+      def failure?
+        outcome.failure?
+      end
+
+      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
+      end
+
+      private
+
+      attr_reader :changed_files, :tool_options
+
+      def limit_targets?
+        tool_options.limit_targets?
+      end
+
+      def filter_messages?
+        tool_options.filter_messages?
+      end
+
+      def runner
+        @_runner ||= tool_options.runner_class
+          .new(changed_files: limit_targets? ? changed_files : nil)
+      end
+
+      def parser
+        @_parser ||= tool_options.parser_class.new(outcome.output)
+      end
+
+      def relevance_filter
+        @_relevance_filter ||= MessageFilter.new(changed_files: changed_files)
+      end
+
+      def locator
+        @_locator ||= AnnotationLocator.new(changed_files: changed_files)
+      end
+    end
+  end
+end

data/lib/quiet_quality/executors/serial_executor.rb

@@ -0,0 +1,15 @@
+require_relative "./base_executor"
+
+module QuietQuality
+  module Executors
+    class SerialExecutor < BaseExecutor
+      def execute!
+        pipelines.each do |pipeline|
+          pipeline.outcome
+          pipeline.messages
+        end
+        pipelines.none?(&:failure?)
+      end
+    end
+  end
+end

data/lib/quiet_quality/executors.rb

@@ -0,0 +1,17 @@
+module QuietQuality
+  module Executors
+    Error = Class.new(::QuietQuality::Error)
+  end
+end
+
+glob = File.expand_path("../executors/*.rb", __FILE__)
+Dir.glob(glob).sort.each { |f| require f }
+
+module QuietQuality
+  module Executors
+    AVAILABLE = {
+      serial: SerialExecutor,
+      concurrent: ConcurrentExecutor
+    }.freeze
+  end
+end

data/lib/quiet_quality/message.rb

@@ -0,0 +1,25 @@
+module QuietQuality
+  class Message
+    attr_accessor :annotated_line
+    attr_reader :path, :body, :start_line, :stop_line, :level, :rule
+
+    def self.load(hash)
+      new(**hash)
+    end
+
+    def initialize(**attrs)
+      @attrs = attrs.map { |k, v| [k.to_s, v] }.to_h
+      @path = @attrs.fetch("path")
+      @body = @attrs.fetch("body")
+      @start_line = @attrs.fetch("start_line")
+      @stop_line = @attrs.fetch("stop_line", @start_line)
+      @annotated_line = @attrs.fetch("annotated_line", nil)
+      @level = @attrs.fetch("level", nil)
+      @rule = @attrs.fetch("rule", nil)
+    end
+
+    def to_h
+      @attrs.map { |k, v| [k.to_s, v] }.to_h
+    end
+  end
+end

data/lib/quiet_quality/message_filter.rb

@@ -0,0 +1,33 @@
+module QuietQuality
+  class MessageFilter
+    def initialize(changed_files:)
+      @changed_files = changed_files
+    end
+
+    def relevant?(message)
+      return false unless changed_files.include?(message.path)
+
+      file = changed_files.file(message.path)
+      return true if file.entire?
+
+      relevant_lines?(message, file)
+    end
+
+    def filter(messages)
+      Messages.new(messages.select { |m| relevant?(m) })
+    end
+
+    private
+
+    attr_reader :changed_files
+
+    def relevant_lines?(message, file)
+      if message.stop_line == message.start_line
+        file.lines.include?(message.start_line)
+      else
+        message_range = (message.start_line..message.stop_line)
+        file.line_numbers.any? { |n| message_range.cover?(n) }
+      end
+    end
+  end
+end

data/lib/quiet_quality/messages.rb

@@ -0,0 +1,54 @@
+module QuietQuality
+  class Messages
+    include Enumerable
+
+    def self.load_data(data)
+      messages = data.map { |message_data| Message.new(**message_data) }
+      new(messages)
+    end
+
+    def self.load_json(text)
+      load_data(JSON.parse(text))
+    end
+
+    def self.load_yaml(text)
+      load_data(YAML.safe_load(text))
+    end
+
+    def initialize(messages)
+      @messages = messages
+    end
+
+    def to_hashes
+      messages.map(&:to_h)
+    end
+
+    def to_json(pretty: false)
+      pretty ? JSON.pretty_generate(to_hashes) : JSON.generate(to_hashes)
+    end
+
+    def to_yaml
+      to_hashes.to_yaml
+    end
+
+    def all
+      messages
+    end
+
+    def empty?
+      messages.length == 0
+    end
+
+    def each(&block)
+      if block
+        messages.each(&block)
+      else
+        to_enum(:each)
+      end
+    end
+
+    private
+
+    attr_reader :messages
+  end
+end

data/lib/quiet_quality/tool_options.rb

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

data/lib/quiet_quality/tools/outcome.rb

@@ -0,0 +1,26 @@
+module QuietQuality
+  module Tools
+    class Outcome
+      attr_reader :output, :logging, :tool
+
+      def initialize(tool:, output:, logging: nil, failure: false)
+        @tool = tool
+        @output = output
+        @logging = logging
+        @failure = failure
+      end
+
+      def failure?
+        @failure
+      end
+
+      def success?
+        !failure?
+      end
+
+      def ==(other)
+        tool == other.tool && output == other.output && logging == other.logging && failure? == other.failure?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module QuietQuality
+  module Tools
+    module Rspec
+      class Parser
+        def initialize(text)
+          @text = text
+        end
+
+        def messages
+          return @_messages if defined?(@_messages)
+          messages = failed_examples.map { |ex| message_for(ex) }
+          @_messages = Messages.new(messages)
+        end
+
+        private
+
+        attr_reader :text
+
+        def content
+          @_content ||= JSON.parse(text, symbolize_names: true)
+        end
+
+        def examples
+          @_examples ||= content.fetch(:examples)
+        end
+
+        def failed_examples
+          @_failed_examples ||= examples.select { |ex| ex[:status] == "failed" }
+        end
+
+        def reduced_path(path)
+          path.gsub(%r{^\./}, "")
+        end
+
+        def message_for(example)
+          path = reduced_path(example.fetch(:file_path))
+          body = example.dig(:exception, :message) || example.fetch(:description)
+          line = example.fetch(:line_number)
+          rule = example.dig(:exception, :class) || "Failed Example"
+          Message.new(path: path, body: body, start_line: line, rule: rule)
+        end
+      end
+    end
+  end
+end

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

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

data/lib/quiet_quality/tools/rspec.rb

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

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

@@ -0,0 +1,46 @@
+module QuietQuality
+  module Tools
+    module Rubocop
+      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, :start_line),
+            stop_line: offense.dig(:location, :last_line),
+            level: offense.fetch(:severity, nil),
+            rule: offense.fetch(:cop_name, nil)
+          )
+        end
+      end
+    end
+  end
+end

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

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

data/lib/quiet_quality/tools/rubocop.rb

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

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

@@ -0,0 +1,8 @@
+module QuietQuality
+  module Tools
+    module Standardrb
+      class Parser < Rubocop::Parser
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module QuietQuality
+  module Tools
+    module Standardrb
+      class Runner < Rubocop::Runner
+        def command_name
+          "standardrb"
+        end
+      end
+    end
+  end
+end

data/lib/quiet_quality/tools/standardrb.rb

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

data/lib/quiet_quality/tools.rb

@@ -0,0 +1,21 @@
+require "open3"
+
+module QuietQuality
+  module Tools
+    Error = Class.new(::QuietQuality::Error)
+  end
+end
+
+glob = File.expand_path("../tools/*.rb", __FILE__)
+Dir.glob(glob).sort.each { |f| require f }
+
+# reopen the class after the tools have been loaded, so we can list them for reference elsewhere.
+module QuietQuality
+  module Tools
+    AVAILABLE = {
+      rspec: Rspec,
+      rubocop: Rubocop,
+      standardrb: Standardrb
+    }
+  end
+end

data/lib/quiet_quality/version.rb

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

data/lib/quiet_quality/version_control_systems/git.rb

@@ -0,0 +1,117 @@
+module QuietQuality
+  module VersionControlSystems
+    class Git
+      Error = Class.new(VersionControlSystems::Error)
+
+      attr_reader :git, :path
+
+      #
+      # Initializer
+      #
+      # @param [String] path Path to git repository
+      #
+      def initialize(path = ".")
+        @path = path
+        @git = ::Git.open(path)
+      end
+
+      # Retrieves the files changed in the given commit compared to the base. When no base is given,
+      # the default branch is used as the base. When no sha is given, the HEAD commit is used.
+      # Optionally, uncommitted changes can be included in the result, as well as untracked files.
+      #
+      # @param [String] base The base commit to compare against
+      # @param [String] sha The commit to compare
+      # @param [Boolean] include_uncommitted Whether to include uncommitted changes
+      # @param [Boolean] include_untracked Whether to include untracked files
+      #
+      # @return [Hash] A hash of file paths and the files changed in those files as a Set
+      def changed_files(base: nil, sha: "HEAD", include_uncommitted: true, include_untracked: false)
+        base_commit = comparison_base(sha: sha, comparison_branch: base || default_branch)
+        [
+          committed_changed_files(base_commit, sha),
+          include_uncommitted ? uncommitted_changed_files : nil,
+          include_untracked ? untracked_changed_files : nil
+        ].compact.reduce(&:merge)
+      end
+
+      #
+      # The default branch for the default remote for the local git repository
+      #
+      # @return [String] Branch name
+      def default_branch
+        self.class.default_branch(remote: git.remote.url)
+      end
+
+      #
+      # The default branch for the given remote
+      #
+      # @param [String] remote The remote repository url
+      # @return [String] Branch name
+      #
+      def self.default_branch(remote:)
+        ::Git.default_branch(remote)
+      end
+
+      #
+      # Determines the nearest common ancestor for the given `sha` compared to the `branch`.
+      #
+      # @param [String] sha The git SHA of the commit
+      # @param [String] comparison_branch The comparison branch
+      #
+      # @return [String] The nearest common ancestor (SHA)
+      #
+      def comparison_base(sha:, comparison_branch:)
+        git.merge_base(comparison_branch, sha).first.sha
+      end
+
+      private
+
+      def changed_lines_for(diff)
+        GitDiffParser.parse(diff).flat_map do |parsed_diff|
+          parsed_diff.changed_line_numbers.to_set
+        end
+      end
+
+      def committed_changed_files(base, sha)
+        ChangedFiles.new(committed_changes(base, sha))
+      end
+
+      def committed_changes(base, sha)
+        patch = git.diff(base, sha).patch
+        GitDiffParser.parse(patch).map { to_changed_file(_1) }
+      end
+
+      def to_changed_file(patch_file)
+        ChangedFile.new(path: patch_file.file, lines: patch_file.changed_line_numbers.to_set)
+      end
+
+      def uncommitted_changed_files
+        ChangedFiles.new(uncommitted_changes)
+      end
+
+      def uncommitted_changes
+        patch = git.diff.patch
+        GitDiffParser.parse(patch).map { to_changed_file(_1) }
+      end
+
+      def untracked_changed_files
+        ChangedFiles.new(untracked_changes)
+      end
+
+      def untracked_changes
+        untracked_paths.map do |file_path|
+          ChangedFile.new(path: file_path, lines: :all)
+        end
+      end
+
+      def untracked_paths
+        out, err, stat = Open3.capture3("git", "-C", path, "ls-files", "--others", "--exclude-standard")
+        unless stat.success?
+          warn err
+          fail(Error, "git ls-files failed")
+        end
+        out.split
+      end
+    end
+  end
+end