reviewer 0.1.3 → 0.1.4

data/lib/reviewer/guidance.rb

@@ -0,0 +1,73 @@
+# 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/history.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'yaml/store'
+
+module Reviewer
+  # Provides an instance of a storage resource for persisting data across runs
+  class History
+    attr_reader :file, :store
+
+    def initialize(file = Reviewer.configuration.history_file)
+      @file = file
+      @store = YAML::Store.new(file)
+    end
+
+    def set(group, attribute, value)
+      store.transaction do |s|
+        s[group] = {} if s[group].nil?
+        s[group][attribute] = value
+      end
+    end
+
+    def get(group, attribute)
+      store.transaction do |s|
+        s[group].nil? ? nil : s[group][attribute]
+      end
+    end
+
+    def reset!
+      return unless File.exist?(file)
+
+      FileUtils.rm(file)
+    end
+
+    def self.reset!
+      new.reset!
+    end
+  end
+end

data/lib/reviewer/keywords.rb

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

data/lib/reviewer/keywords/git.rb

@@ -0,0 +1,14 @@
+# 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/git/staged.rb

@@ -0,0 +1,48 @@
+# 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/loader.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'yaml'
-require 'active_support/core_ext/hash/indifferent_access'
 
 module Reviewer
   # Provides a collection of the configured tools
@@ -16,7 +15,7 @@ module Reviewer
 
     def initialize(file = Reviewer.configuration.file)
       @file = file
-      @configuration = HashWithIndifferentAccess.new(configuration_hash)
+      @configuration = configuration_hash
 
       validate_configuration!
     end
@@ -50,7 +49,7 @@ module Reviewer
     end
 
     def configuration_hash
-      @configuration_hash ||= YAML.load_file(@file)
+      @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

data/lib/reviewer/output.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'colorize'
+
+module Reviewer
+  # Friendly API for printing nicely-formatted output to the console
+  class Output
+    SUCCESS = 'Success'
+    FAILURE = 'Failure ·'
+    DIVIDER = ('-' * 60).to_s
+
+    attr_reader :printer
+
+    def initialize(printer: Reviewer.configuration.printer)
+      @printer = printer
+    end
+
+    def info(message)
+      printer.info message
+    end
+
+    def blank_line
+      printer.info
+    end
+
+    def divider
+      blank_line
+      printer.info DIVIDER.light_black
+      blank_line
+    end
+
+    def tool_summary(tool)
+      printer.info "\n#{tool.name}".bold + ' · '.light_black + tool.description
+    end
+
+    def current_command(command)
+      command = String(command)
+
+      printer.info "\nNow Running:"
+      printer.info command.light_black
+    end
+
+    def exit_status(value)
+      failure("Exit Status #{value}")
+    end
+
+    def success(timer)
+      message = SUCCESS.green.bold + " #{timer.total_seconds}s".green
+      message += " (#{timer.prep_percent}% preparation)".yellow if timer.prepped?
+
+      printer.info message
+    end
+
+    def failure(details, command: nil)
+      printer.error "#{FAILURE} #{details}".red.bold
+
+      return if command.nil?
+
+      blank_line
+      printer.error 'Failed Command:'.red.bold
+      printer.error String(command).light_black
+    end
+
+    def unrecoverable(details)
+      printer.error 'Unrecoverable Error:'.red.bold
+      printer.error details
+    end
+
+    def guidance(summary, details)
+      return if details.nil?
+
+      blank_line
+      printer.info summary
+      printer.info details.to_s.light_black
+    end
+
+    def missing_executable_guidance(command)
+      tool = command.tool
+      installation_command = Command.new(tool, :install, :no_silence).string if tool.installable?
+      install_link = tool.install_link
+
+      failure("Missing executable for '#{tool}'", command: command)
+      guidance('Try installing the tool:', installation_command)
+      guidance('Read the installation guidance:', install_link)
+    end
+
+    def syntax_guidance(ignore_link: nil, disable_link: nil)
+      guidance('Selectively Ignore a Rule:', ignore_link)
+      guidance('Fully Disable a Rule:', disable_link)
+    end
+  end
+end

data/lib/reviewer/printer.rb

@@ -0,0 +1,25 @@
+# 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.rb

@@ -1,102 +1,73 @@
 # frozen_string_literal: true
 
-require 'open3'
+require_relative 'runner/strategies/quiet'
+require_relative 'runner/strategies/verbose'
 
 module Reviewer
-  # Handles running, benchmarking, and printing output for a single command
+  # Wrapper for executng a command and printing the results
   class Runner
-    EXECUTABLE_NOT_FOUND_EXIT_STATUS_CODE = 127
+    extend Forwardable
 
-    attr_accessor :tool, :command
+    attr_accessor :strategy
 
-    attr_reader :elapsed_time,
-                :last_command_run,
-                :stdout,
-                :stderr,
-                :status,
-                :exit_status,
-                :logger
+    attr_reader :command, :shell, :output
 
-    def initialize(tool, command, logger: Logger.new)
-      @tool = tool
-      @command = command
-      @logger = logger
+    def_delegators :@command, :tool
+    def_delegators :@shell, :result, :timer
+    def_delegators :result, :exit_status
+
+    def initialize(tool, command_type, strategy = Strategies::Quiet, output: Reviewer.output)
+      @command = Command.new(tool, command_type)
+      @strategy = strategy
+      @shell = Shell.new
+      @output = output
     end
 
     def run
-      logger.running(tool)
+      # Show which tool is about to run
+      output.tool_summary(tool)
 
-      @elapsed_time = Benchmark.realtime do
-        tool.format_command? ? run_format : run_review
+      # Run the provided strategy
+      strategy.new(self).tap do |run_strategy|
+        run_strategy.prepare if run_prepare_step?
+        run_strategy.run
       end
 
-      print_result
-      exit_status
-    end
+      # If it failed,
+      guidance.show unless success?
 
-    private
-
-    def shell_out(cmd)
-      @stdout, @stderr, @status = Open3.capture3(cmd)
-      @exit_status = status.exitstatus
-      @last_command_run = cmd
-    end
-
-    def run_review
-      shell_out(tool.preparation_command) if tool.prepare_command?
-      shell_out(tool.review_command(seed: seed))
-    end
-
-    def run_format
-      shell_out(tool.format_command) if tool.format_command?
-    end
-
-    def review_verbosely
-      cmd = tool.review_command(:no_silence, seed: seed)
-      logger.rerunning(tool, cmd)
-      system(cmd)
-    end
-
-    def print_result
-      if status.success?
-        logger.success(elapsed_time)
-      else
-        recovery_guidance
-      end
+      exit_status
     end
 
-    def recovery_guidance
-      logger.failure(error_message)
-      logger.command(last_command_run)
-      if missing_executable?
-        missing_executable_guidance
+    def success?
+      # Some review tools return a range of non-zero exit statuses and almost never return 0.
+      # (`yarn audit` is a good example.) Those tools can be configured to accept a non-zero exit
+      # status so they aren't constantly considered to be failing over minor issues.
+      #
+      # But when other command types (prepare, install, format) are run, they either succeed or they
+      # fail. With no shades of gray in those cases, anything other than a 0 is a failure.
+      if command.type == :review
+        exit_status <= tool.max_exit_status
       else
-        review_verbosely
+        exit_status.zero?
       end
     end
 
-    def error_message
-      if missing_executable?
-        "Missing executable for '#{tool}'"
-      else
-        "Exit Status #{exit_status}"
-      end
+    def run_prepare_step?
+      command.type != :prepare && tool.prepare?
     end
 
-    def missing_executable_guidance
-      logger.guidance('Try installing the tool:', tool.installation_command) if tool.install_command?
-      logger.guidance('Read the installation guidance:', tool.settings.links[:install]) if tool.install_link?
+    def prepare_command
+      @prepare_command ||= Command.new(tool, :prepare, command.verbosity)
     end
 
-    def missing_executable?
-      (@exit_status == EXECUTABLE_NOT_FOUND_EXIT_STATUS_CODE) ||
-        stderr.include?("can't find executable")
+    def update_last_prepared_at
+      # Touch the `last_prepared_at` timestamp for the tool so it waits before running again.
+      tool.last_prepared_at = Time.now
     end
 
-    def seed
-      # Keep the same seed for each instance so re-running generates the same results as the failure.
-      # Otherwise, re-running after the failure will change the seed and show different results.
-      @seed ||= Random.rand(100_000)
+    def guidance
+      @guidance ||= Reviewer::Guidance.new(command: command, result: result, output: output)
     end
   end
 end