reviewer 0.1.4 → 1.0.0

data/lib/reviewer/command/string/verbosity.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Reviewer
-  class Command
-    class String
-      # Assembles tool settings and provided context for silencing output
-      class Verbosity
-        include ::Reviewer::Conversions
-
-        # Even when tools provide a quiet flag, not all treat it as complete silence. In order to
-        # ensure no extraneous noise is written to the console in some contexts, command output
-        # occasionally needs to be sent to dev null to ensure there's no clutter.
-        SEND_TO_DEV_NULL = '> /dev/null'
-
-        attr_reader :flag, :level
-
-        # A wrapper for translating a desired verbosity into the correct strings to append to the
-        # command so that any output is appropriately silenced for the context under which it's
-        # currently being executed.
-        # @param flag [String] the tool-level flag to be used for silencing output
-        # @param level: Reviewer::Command::Verbosity::TOOL_SILENCE [Symbol] the target level for
-        #   silence for the the command
-        #
-        # @return [type] [description]
-        def initialize(flag, level: Reviewer::Command::Verbosity::TOOL_SILENCE)
-          @flag = String(flag)
-          @level = Verbosity(level)
-        end
-
-        # Converts the verbosity to a string that can be appended to a command string
-        #
-        # @return [String] the string to be appended to commands to ensure the correct verbosity
-        def to_s
-          to_a.map(&:strip).join(' ').strip
-        end
-
-        # Collection of values to be joined to ensure the correct verbosity
-        #
-        # @return [Array<String>] the values that need to be joined to ensure the correct verbosity
-        #   for the context
-        def to_a
-          case level.key
-          when Reviewer::Command::Verbosity::TOTAL_SILENCE then [flag, SEND_TO_DEV_NULL].compact
-          when Reviewer::Command::Verbosity::TOOL_SILENCE  then [flag].compact
-          else []
-          end
-        end
-      end
-    end
-  end
-end

data/lib/reviewer/command/verbosity.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-module Reviewer
-  class Command
-    # Defines the possible verbosity options for running commands
-    class Verbosity
-      include Comparable
-
-      class InvalidLevelError < ArgumentError; end
-
-      # Use the quiet flag and send everything to dev/null.
-      # For some tools "quiet" means "less noisy" rather than truly silent.
-      # So in those cases, dev/null handles lingering noise.
-      TOTAL_SILENCE = :total_silence
-
-      # Just the quiet flag for the tool. Basically, let the tool determine the useful output.
-      TOOL_SILENCE = :tool_silence
-
-      # Let the output scroll for eternity
-      NO_SILENCE = :no_silence
-
-      # For validation and casting purposes
-      LEVELS = [
-        TOTAL_SILENCE,
-        TOOL_SILENCE,
-        NO_SILENCE
-      ].freeze
-
-      attr_accessor :level
-
-      # Create an instance of verbosity
-      # @param level [Symbol] one of the values of verbosity defined by LEVELS
-      #
-      # @return [Command::Verbosity] an instance of verbosity
-      def initialize(level)
-        @level = level.to_sym
-
-        verify_level!
-      end
-
-      def <=>(other)
-        level <=> other.level
-      end
-
-      def to_s
-        level.to_s
-      end
-
-      def to_i
-        LEVELS.index(level)
-      end
-
-      def to_sym
-        level
-      end
-      alias key to_sym
-
-      private
-
-      def verify_level!
-        raise InvalidLevelError, "Invalid Verbosity Level: '#{level}'" unless LEVELS.include?(level)
-      end
-    end
-  end
-end

data/lib/reviewer/conversions.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Reviewer
-  # Conversion functions for special types in Reviewer
-  module Conversions
-    def Tool(value) # rubocop:disable Naming/MethodName
-      case value
-      when Tool   then value
-      when Symbol then Tool.new(value)
-      when String then Tool.new(value.to_sym)
-      else raise TypeError, "Cannot convert #{value} to Tool"
-      end
-    end
-    module_function :Tool
-
-    def Verbosity(value) # rubocop:disable Naming/MethodName
-      case value
-      when Command::Verbosity then value
-      when Symbol             then Command::Verbosity.new(value)
-      when String             then Command::Verbosity.new(value.to_sym)
-      when Integer            then Command::Verbosity.new(Command::Verbosity::LEVELS[value])
-      else raise TypeError, "Cannot convert #{value} to Verbosity"
-      end
-    end
-    module_function :Verbosity
-  end
-end

data/lib/reviewer/guidance.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml/store'
-
-module Reviewer
-  # Handles the logic around what to display after a command has been run
-  class Guidance
-    attr_reader :command, :result, :output
-
-    # Create an instance of guidance for suggesting recovery steps after errors
-    # @param command: [Command] the command that was run and needs recovery guidance
-    # @param result: [Result] the result of the command
-    # @param output: Reviewer.output [Output] the output channel for displaying content
-    #
-    # @return [Guidance] the guidance class to suggest relevant recovery steps
-    def initialize(command:, result:, output: Reviewer.output)
-      @command = command
-      @result = result
-      @output = output
-    end
-
-    # Prints the relevant guidance based on the command and result context
-    #
-    # @return [void] prints the relevant guidance to the stream
-    def show
-      case result
-      when executable_not_found? then show_missing_executable_guidance
-      when cannot_execute?       then show_unrecoverable_guidance
-      else                            show_syntax_guidance
-      end
-    end
-
-    private
-
-    # Conditional check for when the command result was that the executable couldn't be found
-    #
-    # @return [Boolean] true if the result indicates the command couldn't be found
-    def executable_not_found?
-      ->(result) { result.executable_not_found? }
-    end
-
-    # Conditional check for when the command result was that it was unable to be executed
-    #
-    # @return [Boolean] true if the result indicates the command couldn't be executed
-    def cannot_execute?
-      ->(result) { result.cannot_execute? }
-    end
-
-    # Shows the recovery guidance for when a command is missing
-    #
-    # @return [void] prints missing executable guidance
-    def show_missing_executable_guidance
-      output.missing_executable_guidance(command)
-    end
-
-    # Shows the recovery guidance for when a command generates an unrecoverable error
-    #
-    # @return [void] prints unrecoverable error guidance
-    def show_unrecoverable_guidance
-      output.unrecoverable(result.stderr)
-    end
-
-    # Shows suggestions for ignoring or disable rules when a command fails after reviewing code
-    #
-    # @return [void] prints syntax guidance
-    def show_syntax_guidance
-      output.syntax_guidance(
-        ignore_link: command.tool.links[:ignore_syntax],
-        disable_link: command.tool.links[:disable_syntax]
-      )
-    end
-  end
-end

data/lib/reviewer/keywords/git/staged.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module Reviewer
-  module Keywords
-    module Git
-      # Provides a convenient interface to get the list of staged files via Git
-      class Staged
-        OPTIONS = [
-          'diff',
-          '--staged',
-          '--name-only'
-        ].freeze
-
-        attr_reader :stdout, :stderr, :status, :exit_status
-
-        def to_a
-          stdout.strip.empty? ? [] : stdout.split("\n")
-        end
-
-        def list
-          @stdout, @stderr, @status = Open3.capture3(command)
-          @exit_status = @status.exitstatus.to_i
-
-          @status.success? ? to_a : raise_command_line_error
-        end
-
-        def self.list
-          new.list
-        end
-
-        def command
-          command_parts.join(' ')
-        end
-
-        private
-
-        def raise_command_line_error
-          message = "Git Error: #{stderr} (#{command})"
-          raise SystemCallError.new(message, exit_status)
-        end
-
-        def command_parts
-          BASE_COMMAND + OPTIONS
-        end
-      end
-    end
-  end
-end

data/lib/reviewer/keywords/git.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'git/staged'
-
-module Reviewer
-  module Keywords
-    module Git
-      BASE_COMMAND = [
-        'git',
-        '--no-pager'
-      ].freeze
-    end
-  end
-end

data/lib/reviewer/keywords.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'keywords/git'
-
-module Keywords
-  # Grouping for individual commands
-  module Git
-  end
-end

data/lib/reviewer/loader.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-
-module Reviewer
-  # Provides a collection of the configured tools
-  class Loader
-    class MissingConfigurationError < StandardError; end
-
-    class InvalidConfigurationError < StandardError; end
-
-    class MissingReviewCommandError < StandardError; end
-
-    attr_reader :configuration, :file
-
-    def initialize(file = Reviewer.configuration.file)
-      @file = file
-      @configuration = configuration_hash
-
-      validate_configuration!
-    end
-
-    def to_h
-      configuration
-    end
-
-    def self.configuration
-      new.configuration
-    end
-
-    private
-
-    def validate_configuration!
-      # Any additional guidance for configuration issues will live here
-      require_review_commands!
-    end
-
-    def require_review_commands!
-      configuration.each do |key, value|
-        commands = value[:commands]
-
-        next if commands.key?(:review)
-
-        # Ideally, folks would want to fill out everything to receive the most benefit,
-        # but realistically, the 'review' command is the only required value. If the key
-        # is missing, or maybe there was a typo, fail right away.
-        raise MissingReviewCommandError, "'#{key}' does not have a 'review' key under 'commands' in `#{file}`"
-      end
-    end
-
-    def configuration_hash
-      @configuration_hash ||= Psych.safe_load_file(@file, symbolize_names: true)
-    rescue Errno::ENOENT
-      raise MissingConfigurationError, "Tools configuration file couldn't be found at `#{file}`"
-    rescue Psych::SyntaxError => e
-      raise InvalidConfigurationError, "Tools configuration file (#{file}) has a syntax error: #{e.message}"
-    end
-  end
-end

data/lib/reviewer/printer.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Reviewer
-  # Clean formatter for logging to $stdout
-  class StandardOutFormatter < ::Logger::Formatter
-    # Overrides ::Logger::Formatter `call` to present output more concisely
-    # @param _severity [Logger::Severity] Unused - Logger severity for etnry
-    # @param _time [DateTime] Unused - Timestamp for entry
-    # @param _progname [String] Unused - Name of the current program for entry
-    # @param message [String] The string to print to $stdout
-    #
-    # @return [type] [description]
-    def call(_severity, _time, _progname, message)
-      "#{message}\n"
-    end
-  end
-
-  # Logger for $stdout
-  class Printer < ::Logger
-    def initialize(formatter = StandardOutFormatter.new)
-      super($stdout)
-      @formatter = formatter
-    end
-  end
-end

data/lib/reviewer/runner/strategies/quiet.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module Reviewer
-  class Runner
-    module Strategies
-      # Execution strategy to run a command quietly
-      class Quiet
-        attr_accessor :runner
-
-        # Create an instance of the quiet strategy for a command runner so that any output is fully
-        # suppressed so as to not create too much noise when running multiple commands.
-        # @param runner [Runner] the instance of the runner to apply the strategy to
-        #
-        # @return [Runner::Strategies::Quiet] an instance of the relevant quiet strategy
-        def initialize(runner)
-          @runner = runner
-          @runner.command.verbosity = Reviewer::Command::Verbosity::TOTAL_SILENCE
-        end
-
-        # The prepare command strategy when running a command quietly
-        #
-        # @return [void]
-        def prepare
-          # Running the prepare command, so make sure the timestamp is updated
-          runner.update_last_prepared_at
-
-          # Run the prepare command, suppressing the output and capturing the realtime benchmark
-          runner.shell.capture_prep(runner.prepare_command)
-        end
-
-        # The run command strategy when running a command verbosely
-        #
-        # @return [void]
-        def run
-          # Run the primary command, suppressing the output and capturing the realtime benchmark
-          runner.shell.capture_main(runner.command)
-
-          # If it's successful, show that it was a success and how long it took to run, otherwise,
-          # it wasn't successful and we got some explaining to do...
-          runner.success? ? show_timing_result : show_command_output
-        end
-
-        private
-
-        # Prints "Success" and the resulting timing details before moving on to the next tool
-        #
-        # @return [void]
-        def show_timing_result
-          runner.output.success(runner.timer)
-        end
-
-        # Prints "Failure" and the resulting exit status. Shows the precise command that led to the
-        # failure for easier copy and paste or making it easier to see any incorrect syntax or
-        # options that could be corrected.
-        #
-        # @return [void]
-        def show_command_output
-          runner.output.failure("Exit Status #{runner.exit_status}", command: runner.command)
-
-          # If it can't be rerun, then don't try
-          return if runner.result.total_failure?
-
-          # If it can be rerun, set the strategy to verbose so the output will be visible, and then
-          # run it with the verbose strategy so the output isn't suppressed. Long-term, it makes
-          # sense to add an option for whether to focus on speed or rich output.
-          #
-          # For now, the simplest strategy is to re-run the exact same command without suppressing
-          # the output. However, running a command twice isn't exactly efficient. Since we've
-          # already run it once and captured the output, we could just display that output, but it
-          # would be filtered through as a dumb string. That would mean it strips out color and
-          # formatting. It would save time, but what's the threshold where the time savings is worth
-          # it?
-          #
-          # Ultimately, this will be a tradeoff between how much the tool's original formatting
-          # makes it easier to scan the results and take action. For example, if a command takes
-          # 60 seconds to run, it might be faster to show the low-fidelity output immediately rather
-          # than waiting another 60 seconds for higher-fidelity output.
-          #
-          # Most likely, this will be a tool-by-tool decision and need to be added as an option to
-          # the tool configuration, but that will create additional complexity/overhead when adding
-          # a new tool.
-          #
-          # So for now, we punt. And pay close attention.
-          runner.strategy = Strategies::Verbose
-          runner.run
-        end
-      end
-    end
-  end
-end