reviewer 0.1.3 → 0.1.4

data/exe/fmt

@@ -4,4 +4,4 @@
 
 require_relative '../lib/reviewer'
 
-Reviewer.format
+Reviewer.format(clear_screen: true)

data/exe/rvw

@@ -4,4 +4,4 @@
 
 require_relative '../lib/reviewer'
 
-Reviewer.review
+Reviewer.review(clear_screen: true)

data/lib/reviewer.rb

@@ -1,13 +1,23 @@
 # frozen_string_literal: true
 
-require 'active_support/core_ext/string'
 require 'benchmark'
+require 'forwardable'
+require 'logger'
+
+require_relative 'reviewer/conversions'
 
 require_relative 'reviewer/arguments'
+require_relative 'reviewer/batch'
+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/logger'
+require_relative 'reviewer/output'
+require_relative 'reviewer/printer'
 require_relative 'reviewer/runner'
+require_relative 'reviewer/shell'
 require_relative 'reviewer/tool'
 require_relative 'reviewer/tools'
 require_relative 'reviewer/version'
@@ -17,21 +27,26 @@ module Reviewer
   class Error < StandardError; end
 
   class << self
-    attr_writer :configuration
+    # Resets the loaded tools
+    def reset!
+      @tools = nil
+    end
 
     # 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
     #
     # @return [void] Prints output to the console
-    def review
-      perform(:review)
+    def review(clear_screen: false)
+      perform(:review, clear_screen: clear_screen)
     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
-      perform(:format)
+    def format(clear_screen: false)
+      perform(:format, clear_screen: clear_screen)
     end
 
     # The collection of arguments that were passed via the command line.
@@ -52,9 +67,16 @@ module Reviewer
     # 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.
     #
-    # @return [Reviewer::Logger] prints formatted output to the command line.
-    def logger
-      @logger ||= Logger.new
+    # @return [Reviewer::Output] prints formatted output to the console.
+    def output
+      @output ||= Output.new
+    end
+
+    # 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
 
     # Exposes the configuration options for Reviewer.
@@ -86,22 +108,13 @@ module Reviewer
     #   perform(:review)
     #
     # @return [Hash] the exit status (in integer format) for each command run
-    def perform(command_type)
-      results = {}
-
-      elapsed_time = Benchmark.realtime do
-        tools.current.each do |tool|
-          runner = Runner.new(tool, command_type, logger: logger)
-          exit_status = runner.run
-          results[tool.key] = exit_status
-
-          # If a single tool fails, stop there.
-          break unless exit_status <= tool.max_exit_status
-        end
-      end
-      logger.total_time(elapsed_time)
-
-      results
+    def perform(command_type, clear_screen: false)
+      system('clear') if clear_screen
+
+      results = Batch.run(command_type, tools.current)
+
+      # Return the largest exit status
+      exit results.values.max
     end
   end
 end

data/lib/reviewer/arguments.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
+require 'slop'
+
 require_relative 'arguments/keywords'
 require_relative 'arguments/files'
 require_relative 'arguments/tags'
 
-require 'slop'
-
 module Reviewer
   # Handles option parsing for `rvw` and `fmt` commands
   #
@@ -21,45 +21,61 @@ module Reviewer
   class Arguments
     attr_accessor :options
 
+    attr_reader :output
+
+    # A catch all for aguments passed to reviewer via the command-line.
+    # @param options = ARGV [Hash] options to parse and extract the relevant values for a run
+    #
+    # @return [Reviewer::Arguments] the full collection of arguments provided via the command line
     def initialize(options = ARGV)
+      @output = Output.new
       @options = Slop.parse options do |opts|
         opts.array '-f', '--files', 'a list of comma-separated files or paths', delimiter: ',', default: []
         opts.array '-t', '--tags', 'a list of comma-separated tags', delimiter: ',', default: []
 
         opts.on '-v', '--version', 'print the version' do
-          puts VERSION
+          @output.info VERSION
           exit
         end
 
         opts.on '-h', '--help', 'print the help' do
-          puts opts
+          @output.info opts
           exit
         end
       end
     end
 
-    def inspect
+    # Converts the arguments to a hash for versatility
+    #
+    # @return [Hash] The files, tags, and keywords collected from the command line options
+    def to_h
       {
         files: files.raw,
         tags: tags.raw,
         keywords: keywords.raw
       }
     end
+    alias inspect to_h
 
+    # The tag arguments collected from the command line via the `-t` or `--tags` flag
+    #
+    # @return [Arguments::Tags] an colelction of the tag arguments collected from the command-line
     def tags
       @tags ||= Arguments::Tags.new(provided: options[:tags])
     end
 
+    # The file arguments collected from the command line via the `-f` or `--files` flag
+    #
+    # @return [Arguments::Files] an collection of the file arguments collected from the command-line
     def files
       @files ||= Arguments::Files.new(provided: options[:files])
     end
 
+    # The leftover arguments collected from the command line without being associated with a flag
+    #
+    # @return [Arguments::Keywords] an collection of the leftover arguments as keywords
     def keywords
       @keywords ||= Arguments::Keywords.new(options.arguments)
     end
-
-    def tool_names
-      @tool_names ||= keywords.for_tool_names.to_a
-    end
   end
 end

data/lib/reviewer/arguments/files.rb

@@ -2,34 +2,58 @@
 
 module Reviewer
   class Arguments
-    # Generates the list of files to run the command against
+    # Generates a Ruby-friendly list (Array) of files to run the command against from the provided
+    # command line arguments
     class Files
       attr_reader :provided, :keywords
 
       alias raw provided
 
+      # Generates and instance of files from the provided arguments
+      # @param provided: Reviewer.arguments.files.raw [Array, String] file arguments provided
+      #   directly via the -f or --files flag on the command line.
+      # @param keywords: Reviewer.arguments.keywords [Array, String] keywords that can potentially
+      #   be translated to a list of files (ex. 'staged')
+      #
+      # @return [Arguments::Files] the container for determining targeted files from the provided
+      #   command line arguments
       def initialize(provided: Reviewer.arguments.files.raw, keywords: Reviewer.arguments.keywords)
         @provided = Array(provided)
         @keywords = Array(keywords)
       end
 
+      # Provides the full list of file/path values derived from the command-line arguments
+      #
+      # @return [Array<String>] full collection of the file arguments as a string
       def to_a
         file_list
       end
 
+      # Provides the full list of file/path values derived from the command-line arguments
+      #
+      # @return [String] comma-separated string of the derived tag values
       def to_s
         to_a.join(',')
       end
 
-      def inspect
+      # Summary of the state of the file arguments
+      #
+      # @return [Hash] represents the summary of the file values parsed from the command-line
+      def to_h
         {
-          provided: provided,
+          provided: provided.sort,
           from_keywords: from_keywords
         }
       end
+      alias inspect to_h
 
       private
 
+      # Combines the sorted list of unique files/paths by merging the explicitly-provided file
+      # arguments as well as those that were translated from any relevant keyword arguments.
+      #
+      # @return [Array] full list of files/paths passed via command-line including those extracted
+      #   as a result of a keyword argument like `staged`
       def file_list
         @file_list ||= [
           *provided,
@@ -37,6 +61,10 @@ module Reviewer
         ].compact.sort.uniq
       end
 
+      # Converts relevant keywords to the list of files they implicitly represent.
+      #
+      # @return [Array] list of files/paths translated from any keyword arguments that represent a
+      #   list of files
       def from_keywords
         return [] unless keywords.any?
 
@@ -44,12 +72,16 @@ module Reviewer
           next unless respond_to?(keyword.to_sym, true)
 
           send(keyword.to_sym)
-        end.flatten.uniq
+        end.flatten.compact.uniq
       end
 
+      # If `staged` is passed as a keyword via the command-line, this will get the list of staged
+      # files via Git
+      #
+      # @return [Array] list of the currently staged files
       def staged
         # Use git for list of staged fields
-        ::Reviewer::Arguments::Keywords::Git::Staged.list
+        ::Reviewer::Keywords::Git::Staged.list
       end
     end
   end

data/lib/reviewer/arguments/keywords.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'keywords/git'
-
 module Reviewer
   class Arguments
     # Handles interpreting all 'leftover' arguments and translating them to file-related,
@@ -13,19 +11,34 @@ module Reviewer
 
       alias raw provided
 
+      # Generates an instace of parsed keywords from the provided arguments
+      # @param *provided [Array<String>] the leftover (non-flag) arguments from the command line
+      #
+      # @return [Arguments::Keywords]
       def initialize(*provided)
         @provided = Array(provided.flatten)
       end
 
+      # Proves the full list of raw keyword arguments explicitly passed via command-line as an array
+      #
+      # @return [Array] full collection of the provided keyword arguments as a string
       def to_a
         provided
       end
 
+      # Provides the full list of raw keyword arguments explicitly passed via command-line as a
+      #   comma-separated string
+      #
+      # @return [String] comma-separated list of the file arguments as a string
       def to_s
         to_a.join(',')
       end
 
-      def inspect
+      # Summary of the state of keyword arguments based on how Reviewer parsed them
+      #
+      # @return [Hash] represents the summary of the keyword values parsed from the command-line and
+      #   grouped based on how they were parsed
+      def to_h
         {
           provided: provided,
           recognized: recognized,
@@ -35,6 +48,7 @@ module Reviewer
           for_tool_names: for_tool_names
         }
       end
+      alias inspect to_h
 
       # Extracts reserved keywords from the provided arguments
       #
@@ -82,17 +96,17 @@ module Reviewer
       #
       # @return [Array<String>] all unique configured tags
       def configured_tags
-        enabled_tools.map(&:tags).flatten.uniq.sort
+        tools.enabled.map(&:tags).flatten.uniq.sort
       end
 
       # Provides the complete list of all configured tool names for enabled tools
       #
-      # @return [Array<String>] all unique configured and enabled tools
+      # @return [Array<String>] all unique configured tools
       def configured_tool_names
         # We explicitly don't sort the tool names list because Reviewer uses the configuration order
         # to determine the execution order. So not sorting maintains the predicted order it will run
         # in and leaves the option to sort to the consuming code if needed
-        enabled_tools.map { |tool| tool.key.to_s }.flatten.uniq
+        tools.all.map { |tool| tool.key.to_s }
       end
 
       private
@@ -100,8 +114,8 @@ module Reviewer
       # Provides a collection of enabled Tools for convenient access
       #
       # @return [Array<Reviewer::Tool>] collection of all currently enabled tools
-      def enabled_tools
-        @enabled_tools ||= Reviewer.tools.enabled
+      def tools
+        @tools ||= Reviewer.tools
       end
 
       # Syntactic sugar for finding intersections with valid keywords
@@ -109,7 +123,7 @@ module Reviewer
       #
       # @return [Array<String>] the list of intersecting values
       def intersection_with(values)
-        values.intersection(provided).uniq.sort
+        (values & provided).uniq.sort
       end
     end
   end

data/lib/reviewer/arguments/tags.rb

@@ -8,28 +8,51 @@ module Reviewer
 
       alias raw provided
 
+      # Generates an instace of parsed tags from the provided arguments
+      # @param provided: Reviewer.arguments.tags.raw [Array<String>] tag arguments provided
+      #   directly via the -t or --tags flag on the command line.
+      # @param keywords: Reviewer.arguments.keywords [Array, String] keywords that can potentially
+      #   be translated to a list of tags based on the tags used in the configuration file
+      #
+      # @return [Arguments::Tags] the container for extracting tags from the provided command line
+      #   arguments
       def initialize(provided: Reviewer.arguments.tags.raw, keywords: Reviewer.arguments.keywords.for_tags)
         @provided = Array(provided)
         @keywords = Array(keywords)
       end
 
+      # Provides the full list of tags values derived from the command-line arguments
+      #
+      # @return [Array<String>] full collection of the tag arguments as a string
       def to_a
         tag_list
       end
 
+      # Provides the full list of tag values derived from the command-line arguments
+      #
+      # @return [String] comma-separated string of the derived tag values
       def to_s
         to_a.join(',')
       end
 
-      def inspect
+      # Summary of the state of the tag arguments
+      #
+      # @return [Hash] represents the summary of the tag values parsed from the command-line
+      def to_h
         {
-          provided: provided,
-          from_keywords: keywords
+          provided: provided.sort,
+          from_keywords: keywords.sort
         }
       end
+      alias inspect to_h
 
       private
 
+      # Combines the sorted list of unique tags by merging the explicitly-provided tag arguments
+      # as well as those that were recognized from any relevant keyword arguments.
+      #
+      # @return [Array] full list of tags passed via command-line including those matching keyword
+      #   arguments
       def tag_list
         @tag_list ||= [
           *provided,

data/lib/reviewer/batch.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Reviewer
+  # Provides a structure for running commands for a given set of tools
+  class Batch
+    class UnrecognizedCommandError < ArgumentError; end
+
+    attr_reader :command_type, :tools, :output, :results
+
+    def initialize(command_type, tools, output: Reviewer.output)
+      @command_type = command_type
+      @tools = tools
+      @output  = output
+      @results = {}
+    end
+
+    def run
+      benchmark_batch do
+        tools.each do |tool|
+          runner = Runner.new(tool, command_type, strategy)
+
+          # With multiple tools, run each one quietly.
+          # Otherwise, with just one tool
+          runner.run
+
+          # Record the exit status
+          capture_results(runner)
+
+          # If the tool fails, stop running other tools
+          break unless runner.success?
+        end
+      end
+
+      results
+    end
+
+    def self.run(*args)
+      new(*args).run
+    end
+
+    private
+
+    def multiple_tools?
+      tools.size > 1
+    end
+
+    def strategy
+      multiple_tools? ? Runner::Strategies::Quiet : Runner::Strategies::Verbose
+    end
+
+    def capture_results(runner)
+      @results[runner.tool.key] = runner.exit_status
+    end
+
+    # Records and prints the total runtime of a block
+    # @param &block [type] section of code to be timed
+    #
+    # @return [void] prints the elapsed time
+    def benchmark_batch(&block)
+      elapsed_time = Benchmark.realtime(&block)
+      output.info "\nTotal Time ".white + "#{elapsed_time.round(1)}s".bold
+    end
+  end
+end