reviewer 0.1.4 → 1.0.0

data/lib/reviewer/tool/timing.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Reviewer
+  class Tool
+    # Manages timing persistence for a tool — recording, retrieving, and averaging
+    # execution times, plus tracking when the prepare command was last run.
+    class Timing
+      SIX_HOURS_IN_SECONDS = 60 * 60 * 6
+
+      # Creates a timing tracker for a specific tool
+      # @param history [History] the persistence store for timing data
+      # @param key [Symbol] the tool's unique key
+      #
+      # @return [Timing]
+      def initialize(history, key)
+        @history = history
+        @key = key
+      end
+
+      # Specifies when the tool last had its `prepare` command run
+      #
+      # @return [Time, nil] timestamp of when the `prepare` command was last run
+      def last_prepared_at
+        date_string = @history.get(@key, :last_prepared_at).to_s
+
+        date_string.empty? ? nil : DateTime.parse(date_string).to_time
+      end
+
+      # Sets the timestamp for when the tool last ran its `prepare` command
+      # @param timestamp [DateTime, Time] the value to record
+      #
+      # @return [void]
+      def last_prepared_at=(timestamp)
+        @history.set(@key, :last_prepared_at, timestamp.to_s)
+      end
+
+      # Calculates the average execution time for a command
+      # @param command [Command] the command to get timing for
+      #
+      # @return [Float] the average time in seconds or 0 if no history
+      def average_time(command)
+        times = get_timing(command)
+
+        times.any? ? times.sum / times.size : 0
+      end
+
+      # Retrieves historical timing data for a command
+      # @param command [Command] the command to look up
+      #
+      # @return [Array<Float>] the last few recorded execution times
+      def get_timing(command)
+        @history.get(@key, command.raw_string) || []
+      end
+
+      # Records the execution time for a command to calculate running averages
+      # @param command [Command] the command that was run
+      # @param time [Float, nil] the execution time in seconds
+      #
+      # @return [void]
+      def record_timing(command, time)
+        return unless time
+
+        timing = get_timing(command).take(4) << time.round(2)
+
+        @history.set(@key, command.raw_string, timing)
+      end
+
+      # Determines whether the `prepare` command was run recently enough
+      #
+      # @return [Boolean] true if the timestamp is nil or older than six hours
+      def stale?
+        !last_prepared_at || last_prepared_at < Time.now - SIX_HOURS_IN_SECONDS
+      end
+    end
+  end
+end

data/lib/reviewer/tool.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
+require_relative 'tool/conversions'
+require_relative 'tool/file_resolver'
 require_relative 'tool/settings'
+require_relative 'tool/test_file_mapper'
+require_relative 'tool/timing'
 
 module Reviewer
   # Provides an instance of a specific tool for accessing its settings and run history
@@ -8,14 +12,9 @@ module Reviewer
     extend Forwardable
     include Comparable
 
-    # In general, Reviewer tries to save time where it can. In the case of the "prepare" command
-    # used by some tools to retrieve data, it only runs it occasionally in order to save time.
-    # This is the default window that it uses to determine if the tool's preparation step should be
-    # considered stale and needs to be rerun. Frequent enough that it shouldn't get stale, but
-    # infrequent enough that it's not cumbersome.
-    SIX_HOURS_IN_SECONDS = 60 * 60 * 6
+    SIX_HOURS_IN_SECONDS = Timing::SIX_HOURS_IN_SECONDS
 
-    attr_reader :settings, :history
+    attr_reader :settings
 
     def_delegators :@settings,
                    :key,
@@ -27,78 +26,86 @@ module Reviewer
                    :links,
                    :enabled?,
                    :disabled?,
-                   :max_exit_status
+                   :skip_in_batch?,
+                   :max_exit_status,
+                   :supports_files?
 
-    alias to_sym key
-    alias to_s name
+    # Returns the tool's key as a symbol
+    # @return [Symbol] the tool's unique identifier
+    def to_sym = key
+
+    # Returns the tool's name as a string
+    # @return [String] the tool's display name
+    def to_s = name
 
     # Create an instance of a tool
     # @param tool_key [Symbol] the key to the tool from the configuration file
+    # @param config [Hash] the tool's configuration hash
+    # @param history [History] the history store for timing and state persistence
     #
     # @return [Tool] an instance of tool for accessing settings information and facts about the tool
-    def initialize(tool_key)
-      @settings = Settings.new(tool_key)
+    def initialize(tool_key, config:, history:)
+      @settings = Settings.new(tool_key, config: config)
+      @history = history
+      @timing = Timing.new(history, key)
     end
 
-    # For determining if the tool should run it's prepration command. It will only be run both if
-    # the tool has a preparation command, and the command hasn't been run 6 hours
+    # For determining if the tool should run its preparation command. It will only be run if
+    # the tool has a preparation command and it hasn't been run in the last 6 hours
     #
     # @return [Boolean] true if the tool has a configured `prepare` command that hasn't been run in
     #   the last 6 hours
-    def prepare?
-      preparable? && stale?
-    end
+    def prepare? = preparable? && stale?
 
     # Determines whether a tool has a specific command type configured
     # @param command_type [Symbol] one of the available command types defined in Command::TYPES
     #
     # @return [Boolean] true if the command type is configured and not blank
     def command?(command_type)
-      commands.key?(command_type) && !commands[command_type].nil?
+      commands.key?(command_type) && commands[command_type]
     end
 
     # Determines if the tool can run a `install` command
     #
     # @return [Boolean] true if there is a non-blank `install` command configured
-    def installable?
-      command?(:install)
+    def installable? = command?(:install)
+
+    # Returns the install command string for this tool
+    #
+    # @return [String, nil] the install command or nil if not configured
+    def install_command
+      commands[:install]
     end
 
     # Determines if the tool can run a `prepare` command
     #
     # @return [Boolean] true if there is a non-blank `prepare` command configured
-    def preparable?
-      command?(:prepare)
-    end
+    def preparable? = command?(:prepare)
 
     # Determines if the tool can run a `review` command
     #
     # @return [Boolean] true if there is a non-blank `review` command configured
-    def reviewable?
-      command?(:review)
-    end
+    def reviewable? = command?(:review)
 
     # Determines if the tool can run a `format` command
     #
     # @return [Boolean] true if there is a non-blank `format` command configured
-    def formattable?
-      command?(:format)
-    end
+    def formattable? = command?(:format)
 
-    # Specifies when the tool last had it's `prepare` command run
+    # Whether this tool matches any of the given tags and is eligible for batch runs
     #
-    # @return [DateTime] timestamp of when the `prepare` command was last run
-    def last_prepared_at
-      Reviewer.history.get(key, :last_prepared_at)
+    # @param tag_list [Array<String, Symbol>] tags to match against
+    # @return [Boolean] true if the tool is batch-eligible and shares at least one tag
+    def matches_tags?(tag_list)
+      !skip_in_batch? && tag_list.intersect?(tags)
     end
 
-    # Sets the timestamp for when the tool last ran its `prepare` command
-    # @param last_prepared_at [DateTime] the value to record for when the `prepare` command last ran
-    #
-    # @return [DateTime] timestamp of when the `prepare` command was last run
-    def last_prepared_at=(last_prepared_at)
-      Reviewer.history.set(key, :last_prepared_at, last_prepared_at)
-    end
+    def_delegators :@timing,
+                   :last_prepared_at,
+                   :last_prepared_at=,
+                   :average_time,
+                   :get_timing,
+                   :record_timing
 
     # Determines whether the `prepare` command was run recently enough
     #
@@ -107,22 +114,18 @@ module Reviewer
     def stale?
       return false unless preparable?
 
-      last_prepared_at.nil? || last_prepared_at < Time.now - SIX_HOURS_IN_SECONDS
+      @timing.stale?
     end
 
     # Convenience method for determining if a tool has a configured install link
     #
     # @return [Boolean] true if there is an `install` key under links and the value isn't blank
-    def install_link?
-      links.key?(:install) && !links[:install].nil?
-    end
+    def install_link? = links.key?(:install) && !!links[:install]
 
     # Returns the text for the install link if available
     #
     # @return [String, nil] the link if it exists, nil otherwise
-    def install_link
-      install_link? ? links.fetch(:install) : nil
-    end
+    def install_link = install_link? ? links.fetch(:install) : nil
 
     # Determines if two tools are equal
     # @param other [Tool] the tool to compare to the current instance
@@ -132,5 +135,43 @@ module Reviewer
       settings == other.settings
     end
     alias :== eql?
+
+    # Records the pass/fail status and failed files from a result into history
+    # @param result [Runner::Result] the result of running this tool
+    #
+    # @return [void]
+    def record_run(result)
+      status = result.success? ? :passed : :failed
+      @history.set(key, :last_status, status)
+
+      if result.success?
+        @history.set(key, :last_failed_files, nil)
+      else
+        files = Runner::FailedFiles.new(result.stdout, result.stderr).to_a
+        @history.set(key, :last_failed_files, files) if files.any?
+      end
+    end
+
+    # Resolves which files this tool should process
+    # @param files [Array<String>] the input files to resolve
+    #
+    # @return [Array<String>] files after mapping and filtering
+    def resolve_files(files)
+      file_resolver.resolve(files)
+    end
+
+    # Determines if this tool should be skipped because files were requested but none match
+    # @param files [Array<String>] the requested files
+    #
+    # @return [Boolean] true if files were requested but none match after resolution
+    def skip_files?(files)
+      file_resolver.skip?(files)
+    end
+
+    private
+
+    def file_resolver
+      @file_resolver ||= FileResolver.new(settings)
+    end
   end
 end

data/lib/reviewer/tools.rb

@@ -7,37 +7,39 @@ module Reviewer
     include Enumerable
 
     # Provides an instance to work with for knowing which tools to run in a given context.
-    # @param tags: nil [Array] the tags to use to filter tools for a run
-    # @param tool_names: nil [type] the explicitly provided tool names to filter tools for a run
+    # @param tags [Array] the tags to use to filter tools for a run
+    # @param tool_names [Array<String>] the explicitly provided tool names to filter tools for a run
+    # @param arguments [Arguments] the parsed CLI arguments
+    # @param history [History] the history store for status persistence
+    # @param config_file [Pathname, nil] path to the .reviewer.yml configuration file
     #
     # @return [Reviewer::Tools] collection of tools based on the current run context
-    def initialize(tags: nil, tool_names: nil)
-      @tags       = tags
-      @tool_names = tool_names
+    def initialize(tags: nil, tool_names: nil, arguments: nil, history: nil, config_file: nil)
+      @tags        = tags
+      @tool_names  = tool_names
+      @arguments   = arguments
+      @history     = history
+      @config_file = config_file
     end
 
     # The current state of all available configured tools regardless of whether they are disabled
     #
     # @return [Hash] hash representing all of the configured tools
-    def to_h
-      configured
-    end
+    def to_h = configured
     alias inspect to_h
 
     # Provides a collection of all configured tools instantiated as Tool instances
     #
     # @return [Array<Tool>] the full collection of all Tool instances
     def all
-      configured.keys.map { |tool_name| Tool.new(tool_name) }
+      configured.map { |tool_name, config| Tool.new(tool_name, config: config, history: @history) }
     end
     alias to_a all
 
-    # Provides a collection of all enabled tools instantiated as Tool instances
+    # Provides a collection of all tools that run in the default batch
     #
-    # @return [Array<Tool>] the full collection of all enabled Tool instances
-    def enabled
-      @enabled ||= all.keep_if(&:enabled?)
-    end
+    # @return [Array<Tool>] the full collection of batch-included Tool instances
+    def enabled = @enabled ||= all.reject(&:skip_in_batch?)
 
     # Provides a collection of all explicitly-specified-via-command-line tools as Tool instances
     #
@@ -54,13 +56,22 @@ module Reviewer
     end
 
     # Uses the full context of a run to provide the filtered subset of tools to use. It takes into
-    # consideration: tagged tools, explicitly-specified tools, configuration (enabled/disabled), and
-    # any other relevant details that should influence whether a specific tool should be run as part
-    # of the current batch being executed.
+    # consideration: tagged tools, explicitly-specified tools, failed tools, configuration
+    # (enabled/disabled), and any other relevant details that should influence whether a specific
+    # tool should be run as part of the current batch being executed.
     #
     # @return [Array<Tool>] the full collection of should-be-used-for-this-run tools
     def current
-      subset? ? (specified + tagged).uniq : enabled
+      return enabled unless subset? || failed_keyword?
+
+      (specified + tagged + failed).uniq
+    end
+
+    # Returns tools that failed in the previous run based on history
+    #
+    # @return [Array<Tool>] tools with :last_status of :failed in history
+    def failed_from_history
+      all.select { |tool| @history.get(tool.key, :last_status) == :failed }
     end
 
     private
@@ -70,28 +81,31 @@ module Reviewer
     # only a subset of relevant tools.
     #
     # @return [Boolean] true if any tool names or tags are provided via the command line
-    def subset?
-      tool_names.any? || tags.any?
-    end
+    def subset? = tool_names.any? || tags.any?
 
-    def configured
-      @configured ||= Loader.configuration
-    end
+    def failed
+      return [] unless failed_keyword?
 
-    def tags
-      Array(@tags || Reviewer.arguments.tags)
+      failed_from_history
     end
 
-    def tool_names
-      Array(@tool_names || Reviewer.arguments.keywords.for_tool_names)
-    end
+    def failed_keyword? = @arguments&.keywords&.failed? || false
+
+    def configured = @configured ||= Configuration::Loader.configuration(file: @config_file)
+    def tags = Array(@tags || matching_tags)
+    def tool_names = Array(@tool_names || matching_tool_names)
+    def tagged?(tool) = tool.matches_tags?(tags)
+    def named?(tool) = tool_names.map(&:to_s).include?(tool.key.to_s)
 
-    def tagged?(tool)
-      tool.enabled? && (tags & tool.tags).any?
+    def matching_tool_names
+      provided = @arguments&.keywords&.provided || []
+      provided & configured.keys.map(&:to_s)
     end
 
-    def named?(tool)
-      tool_names.map(&:to_s).include?(tool.key.to_s)
+    def matching_tags
+      provided = @arguments&.keywords&.provided || []
+      all_tags = enabled.flat_map(&:tags).uniq
+      (provided & all_tags) + Array(@arguments&.tags&.raw)
     end
   end
 end

data/lib/reviewer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Reviewer
-  VERSION = '0.1.4'
+  VERSION = '1.0.0'
 end

data/lib/reviewer.rb

@@ -2,89 +2,85 @@
 
 require 'benchmark'
 require 'forwardable'
-require 'logger'
+# require 'logger'
+require 'rainbow'
 
-require_relative 'reviewer/conversions'
+require_relative 'reviewer/configuration'
+require_relative 'reviewer/configuration/loader'
+require_relative 'reviewer/context'
+require_relative 'reviewer/history'
+require_relative 'reviewer/tool'
+require_relative 'reviewer/tools'
 
 require_relative 'reviewer/arguments'
 require_relative 'reviewer/batch'
+require_relative 'reviewer/capabilities'
 require_relative 'reviewer/command'
-require_relative 'reviewer/configuration'
-require_relative 'reviewer/guidance'
-require_relative 'reviewer/history'
-require_relative 'reviewer/keywords'
-require_relative 'reviewer/loader'
 require_relative 'reviewer/output'
-require_relative 'reviewer/printer'
+require_relative 'reviewer/prompt'
+require_relative 'reviewer/report'
 require_relative 'reviewer/runner'
+require_relative 'reviewer/session'
 require_relative 'reviewer/shell'
-require_relative 'reviewer/tool'
-require_relative 'reviewer/tools'
+require_relative 'reviewer/setup'
+require_relative 'reviewer/doctor'
 require_relative 'reviewer/version'
 
 # Primary interface for the reviewer tools
 module Reviewer
+  # Base error class for all Reviewer errors
   class Error < StandardError; end
 
   class << self
-    # Resets the loaded tools
-    def reset!
-      @tools = nil
-    end
+    # Resets the loaded tools and arguments
+    def reset! = @tools = @arguments = @prompt = @output = @history = @configuration = nil
 
     # Runs the `review` command for the specified tools/files. Reviewer expects all configured
-    # commands that are not disabled to have an entry for the `review` command.
-    # @param clear_streen [boolean] clears the screen to reduce noise when true
+    #   commands that are not disabled to have an entry for the `review` command.
     #
     # @return [void] Prints output to the console
-    def review(clear_screen: false)
-      perform(:review, clear_screen: clear_screen)
+    def review
+      handle_early_exits { exit build_session.review }
     end
 
     # Runs the `format` command for the specified tools/files for which it is configured.
-    # @param clear_streen [boolean] clears the screen to reduce noise when true
     #
     # @return [void] Prints output to the console
-    def format(clear_screen: false)
-      perform(:format, clear_screen: clear_screen)
+    def format
+      handle_early_exits { exit build_session.format }
     end
 
     # The collection of arguments that were passed via the command line.
     #
     # @return [Reviewer::Arguments] exposes tags, files, and keywords from arguments
-    def arguments
-      @arguments ||= Arguments.new
-    end
+    def arguments = @arguments ||= Arguments.new
 
     # An interface for the collection of configured tools for accessing subsets of tools
-    # based on enabled/disabled, tags, keywords, etc.
+    #   based on enabled/disabled, tags, keywords, etc.
     #
     # @return [Reviewer::Tools] exposes the set of tools to be run in a given context
-    def tools
-      @tools ||= Tools.new
-    end
+    def tools = @tools ||= Tools.new(arguments: arguments, history: history, config_file: configuration.file)
 
     # The primary output method for Reviewer to consistently display success/failure details for a
-    # unique run of each tool and the collective summary when relevant.
+    #   unique run of each tool and the collective summary when relevant.
     #
     # @return [Reviewer::Output] prints formatted output to the console.
-    def output
-      @output ||= Output.new
-    end
+    def output = @output ||= Output.new
 
     # A file store for sharing information across runs
     #
     # @return [Reviewer::History] a YAML::Store (or Pstore) containing data on tools
-    def history
-      @history ||= History.new
-    end
+    def history = @history ||= History.new(file: configuration.history_file)
+
+    # An interactive prompt for yes/no questions
+    #
+    # @return [Reviewer::Prompt] prompt instance wrapping stdin/stdout
+    def prompt = @prompt ||= Prompt.new
 
     # Exposes the configuration options for Reviewer.
     #
     # @return [Reviewer::Configuration] configuration settings instance
-    def configuration
-      @configuration ||= Configuration.new
-    end
+    def configuration = @configuration ||= Configuration.new
 
     # A block approach to configuring Reviewer.
     #
@@ -94,27 +90,91 @@ module Reviewer
     #   end
     #
     # @return [Reviewer::Configuration] Reviewer configuration settings
-    def configure
-      yield(configuration)
-    end
+    def configure = yield(configuration)
 
     private
 
-    # Provides a consistent approach to running and benchmarking commmands and preventing further
-    # execution of later tools if a command fails.
-    # @param command_type [Symbol] the specific command to run for each tool
-    #
-    # @example Run the `review` command for each relevant tool
-    #   perform(:review)
-    #
-    # @return [Hash] the exit status (in integer format) for each command run
-    def perform(command_type, clear_screen: false)
-      system('clear') if clear_screen
+    def handle_early_exits
+      return show_help if arguments.help?
+      return show_version if arguments.version?
+      return Setup.run if subcommand?(:init)
+      return run_doctor if subcommand?(:doctor)
+      return run_capabilities if capabilities_flag?
+      return run_first_time_setup unless configuration.file.exist?
+
+      yield
+    end
 
-      results = Batch.run(command_type, tools.current)
+    def subcommand?(name) = ARGV.first == name.to_s
+    def capabilities_flag? = ARGV.include?('--capabilities') || ARGV.include?('-c')
+
+    def show_help
+      output.help(help_text)
+    end
+
+    def help_text
+      <<~HELP
+        Usage: rvw [tool or tag ...] [keyword ...] [options]
+               fmt [tool or tag ...] [keyword ...] [options]
+
+        Commands:
+            rvw                          Run all enabled tools
+            rvw <tool>                   Run a single tool by its config key
+            rvw <tag>                    Run tools matching a tag
+            fmt                          Auto-fix with format commands
+            rvw init                     Generate .reviewer.yml from Gemfile.lock
+            rvw doctor                   Check configuration and tool health
+
+        Keywords:
+            staged                       Files staged for commit
+            unstaged                     Files with unstaged changes
+            modified                     All changed files (staged + unstaged)
+            untracked                    New files not yet tracked by git
+            failed                       Re-run only tools that failed last time
+
+        Options:
+        #{slop_options}
+
+        Examples:
+            rvw rubocop                  Run RuboCop only
+            rvw staged                   Review staged files across all tools
+            rvw -t security modified     Run security-tagged tools on changed files
+            rvw tests -f test/user_test.rb   Run tests on a specific file
+            rvw failed                   Re-run what failed last time
+            fmt rubocop                  Auto-fix with RuboCop
+      HELP
+    end
+
+    def slop_options
+      arguments.options.to_s.lines.drop(1).join.rstrip
+    end
+
+    def show_version
+      output.help(VERSION)
+    end
+
+    def run_capabilities
+      puts Capabilities.new(tools: tools).to_json
+    end
+
+    def run_doctor
+      report = Doctor.run(configuration: configuration, tools: tools)
+      Doctor::Formatter.new(output).print(report)
+    end
+
+    def run_first_time_setup
+      formatter = Setup::Formatter.new(output)
+      formatter.first_run_greeting
+      if prompt.yes?('Would you like to set it up now?')
+        Setup.run(configuration: configuration)
+      else
+        formatter.first_run_skip
+      end
+    end
 
-      # Return the largest exit status
-      exit results.values.max
+    def build_session
+      context = Context.new(arguments: arguments, output: output, history: history)
+      Session.new(context: context, tools: tools)
     end
   end
 end