reviewer 0.1.3 → 0.1.4

data/lib/reviewer/command.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative 'command/string'
+require_relative 'command/verbosity'
+
+module Reviewer
+  # The core funtionality to translate a tool, command type, and verbosity into a runnable command
+  class Command
+    include Conversions
+
+    SEED_SUBSTITUTION_VALUE = '$SEED'
+
+    attr_reader :tool, :type
+
+    # Creates an instance of the Command class to synthesize a command string using the tool,
+    # command type, and verbosity.
+    # @param tool [Tool, Symbol] a tool or tool key to use to look up the command and options
+    # @param type [Symbol] the desired command type (:install, :prepare, :review, :format)
+    # @param verbosity = Verbosity::TOTAL_SILENCE [Symbol] the desired verbosity for the command
+    #
+    # @return [Command] the intersection of a tool, command type, and verbosity
+    def initialize(tool, type, verbosity = Verbosity::TOTAL_SILENCE)
+      @tool = Tool(tool)
+      @type = type.to_sym
+      @verbosity = Verbosity(verbosity)
+    end
+
+    # The final command string with all of the conditions appled
+    #
+    # @return [String] the final, valid command string to run
+    def string
+      @string ||= seed_substitution? ? seeded_string : raw_string
+    end
+    alias to_s string
+
+    # Getter for @verbosity. Since the setter is custom, the getter needs to be explicitly declared.
+    # Otherwise, using `attr_accessor` and then overriding the setter muddies the waters.
+    #
+    # @return [Verbosity] the current verbosity setting for the command
+    def verbosity # rubocop:disable Style/TrivialAccessors
+      @verbosity
+    end
+
+    # Override verbosity assignment to clear the related memoized values when verbosity changes
+    # @param verbosity [Verbosity, Symbol] the desired verbosity for the command
+    #
+    # @return [Verbosity] the updated verbosity level for the command
+    def verbosity=(verbosity)
+      # Unmemoize string since the verbosity has been changed
+      @raw_string = nil
+      @string = nil
+
+      @verbosity = Verbosity(verbosity)
+    end
+
+    # Generates a seed that can be re-used across runs so that the results are consistent across
+    # related runs for tools that would otherwise change the seed automatically every run.
+    # Since not all tools will use the seed, there's no need to generate it in the initializer.
+    # Instead, it's memoized if it's used.
+    #
+    # @return [Integer] a random integer to pass to tools that use seeds
+    def seed
+      @seed ||= Random.rand(100_000)
+
+      # Store the seed for reference
+      Reviewer.history.set(tool.key, :last_seed, @seed)
+
+      @seed
+    end
+
+    private
+
+    # The raw command string before any substitutions. For example, since seeds need to remain
+    # consistent from one run to the next, they're
+    #
+    # @return [type] [description]
+    def raw_string
+      @raw_string ||= String.new(
+        type,
+        tool_settings: tool.settings,
+        verbosity: verbosity
+      ).to_s
+    end
+
+    # The version of the command with the SEED_SUBSTITUTION_VALUE replaced
+    #
+    # @return [String] the command string with the SEED_SUBSTITUTION_VALUE replaced
+    def seeded_string
+      # Update the string with the memoized seed value
+      raw_string.gsub(SEED_SUBSTITUTION_VALUE, seed.to_s)
+    end
+
+    # Determines if the raw command string has a SEED_SUBSTITUTION_VALUE that needs replacing
+    #
+    # @return [Boolean] true if the raw command string contains the SEED_SUBSTITUTION_VALUE
+    def seed_substitution?
+      raw_string.include?(SEED_SUBSTITUTION_VALUE)
+    end
+  end
+end

data/lib/reviewer/command/string.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative 'string/env'
+require_relative 'string/flags'
+require_relative 'string/verbosity'
+
+module Reviewer
+  class Command
+    # Assembles tool tool_settings into a usable command string for the command type and verbosity
+    class String
+      include Conversions
+
+      attr_reader :command_type, :tool_settings, :verbosity
+
+      def initialize(command_type, tool_settings:, verbosity: nil)
+        @command_type = command_type
+        @tool_settings = tool_settings
+        @verbosity = Verbosity(verbosity)
+      end
+
+      def to_s
+        to_a
+          .map(&:strip) # Remove extra spaces on the components
+          .join(' ')    # Merge the components
+          .strip        # Strip extra spaces from the end result
+      end
+
+      def to_a
+        [
+          env_variables,
+          body,
+          flags,
+          verbosity_options
+        ].compact
+      end
+
+      def env_variables
+        Env.new(tool_settings.env).to_s
+      end
+
+      def body
+        tool_settings.commands.fetch(command_type)
+      end
+
+      def flags
+        # Flags to be used for `review` commands.
+        # 1. The `review` commands are the only commands that use flags
+        # 2. If no flags are configured, this won't do much
+        #
+        # Note: Since verbosity is handled separately, flags for 'quiet' are handled separately at a
+        #   lower level by design and excluded from this check. They are not included with the other
+        #   configured flags.
+        return nil unless flags?
+
+        Flags.new(tool_settings.flags).to_s
+      end
+
+      def verbosity_options
+        Verbosity.new(tool_settings.quiet_option, level: verbosity.level).to_s
+      end
+
+      private
+
+      # Determines whether the string needs flags added
+      #
+      # @return [Boolean] true if it's a review command and it has flags configured
+      def flags?
+        command_type == :review && tool_settings.flags.any?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Reviewer
+  class Command
+    class String
+      # Assembles tool environment variables into a single string or array
+      class Env
+        attr_reader :env_pairs
+
+        def initialize(env_pairs)
+          @env_pairs = env_pairs
+        end
+
+        def to_s
+          to_a.compact.join(' ')
+        end
+
+        def to_a
+          env = []
+          env_pairs.each { |key, value| env << env(key, value) }
+          env
+        end
+
+        private
+
+        def env(key, value)
+          return nil if key.to_s.strip.empty? || value.to_s.strip.empty?
+
+          value = needs_quotes?(value) ? "'#{value}'" : value
+
+          "#{key.to_s.strip.upcase}=#{value.to_s.strip}"
+        end
+
+        def needs_quotes?(value)
+          value.is_a?(::String) && value.include?(' ')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Reviewer
+  class Command
+    class String
+      # Assembles tool flag settings into a single string or array
+      class Flags
+        attr_reader :flag_pairs
+
+        def initialize(flag_pairs)
+          @flag_pairs = flag_pairs
+        end
+
+        def to_s
+          to_a.join(' ')
+        end
+
+        def to_a
+          flags = []
+          flag_pairs.each { |key, value| flags << flag(key, value) }
+          flags
+        end
+
+        private
+
+        def flag(key, value)
+          dash = key.to_s.size == 1 ? '-' : '--'
+
+          value = needs_quotes?(value) ? "'#{value}'" : value
+
+          "#{dash}#{key} #{value}".strip
+        end
+
+        def needs_quotes?(value)
+          value.is_a?(::String) && value.include?(' ')
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -1,16 +1,36 @@
 # frozen_string_literal: true
 
+require 'pathname'
+
 module Reviewer
   # Configuration values container for Reviewer
   class Configuration
     DEFAULT_PATH = Dir.pwd.freeze
-    DEFAULT_FILE_NAME = '.reviewer.yml'
-    DEFAULT_FILE = "#{DEFAULT_PATH}/#{DEFAULT_FILE_NAME}"
 
-    attr_accessor :file
+    DEFAULT_CONFIG_FILE_NAME = '.reviewer.yml'
+    DEFAULT_HISTORY_FILE_NAME = '.reviewer_history.yml'
+
+    DEFAULT_CONFIG_LOCATION = "#{DEFAULT_PATH}/#{DEFAULT_CONFIG_FILE_NAME}"
+    DEFAULT_HISTORY_LOCATION = "#{DEFAULT_PATH}/#{DEFAULT_HISTORY_FILE_NAME}"
+
+    attr_accessor :file, :history_file, :printer
 
     def initialize
-      @file = DEFAULT_FILE
+      @file = Pathname(DEFAULT_CONFIG_LOCATION)
+      @history_file = Pathname(DEFAULT_HISTORY_LOCATION)
+      @printer = ::Reviewer::Printer.new
+
+      # Future Configuration Options:
+      # - seed_substitution_value(string): Currently a constant of `$SEED` in Reviewer::Command, but
+      #   may need to be configurable in case any command-line strings have other legitimate uses
+      #   for the value such that it may need to be override. Ideally, it woudl be changed to3
+      #   something obscure enough that conflicts wouldn't happen, but you never know
+      # - benchmark_everything(:dev, :optimize): Use the `time_up` gem to measure and show all the results
+      #   for each tool and step to help identify and reduce bottlenecks. It would mainly be a flag
+      #   for use in development, but it could also help folks troubleshoot their speed in finer
+      #   detail than the standard Reviewer output
+      # - default_preparation_refresh(integer time): Right now, it's hard-coded at 6 hours, but that may require
+      #   tuning for individual tools
     end
   end
 end

data/lib/reviewer/conversions.rb

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