foreman_maintain 0.0.2 → 0.0.3

data/lib/foreman_maintain/reporter.rb

@@ -1,5 +1,10 @@
 module ForemanMaintain
   class Reporter
+    class DummySpinner
+      def update(_message)
+        # do nothing
+      end
+    end
     require 'foreman_maintain/reporter/cli_reporter'
 
     # Each public method is a hook called by executor at the specific point
@@ -7,12 +12,24 @@ module ForemanMaintain
 
     def before_execution_starts(_execution); end
 
-    def on_execution_update(_execution, _update); end
-
     def after_execution_finishes(_execution); end
 
     def after_scenario_finishes(_scenario); end
 
-    def on_next_steps_offer(_runner, _steps); end
+    def on_next_steps(_steps); end
+
+    def with_spinner(_message, &_block)
+      yield DummySpinner.new
+    end
+
+    def print(_message); end
+
+    def puts(_message); end
+
+    def ask(_message); end
+
+    def assumeyes?
+      false
+    end
   end
 end

data/lib/foreman_maintain/reporter/cli_reporter.rb

@@ -4,6 +4,12 @@ require 'highline'
 module ForemanMaintain
   class Reporter
     class CLIReporter < Reporter
+      DECISION_MAPPER = {
+        %w[y yes] => :yes,
+        %w[n next no] => :no,
+        %w[q quit] => :quit
+      }.freeze
+
       # Simple spinner able to keep updating current line
       class Spinner
         def initialize(reporter, interval = 0.1)
@@ -12,14 +18,21 @@ module ForemanMaintain
           @active = false
           @interval = interval
           @spinner_index = 0
-          @spinner_chars = %w(| / - \\)
+          @spinner_chars = %w[| / - \\]
           @current_line = ''
           @puts_needed = false
           start_spinner
         end
 
         def update(line)
-          @mutex.synchronize { @current_line = line }
+          @mutex.synchronize do
+            @current_line = line
+            print_current_line
+          end
+        end
+
+        def active?
+          @mutex.synchronize { @active }
         end
 
         def activate
@@ -28,9 +41,9 @@ module ForemanMaintain
         end
 
         def deactivate
+          return unless active?
           @mutex.synchronize do
             @active = false
-            @reporter.print "\r"
           end
         end
 
@@ -48,60 +61,127 @@ module ForemanMaintain
         def spin
           @mutex.synchronize do
             return unless @active
-            @reporter.clear_line
-            @reporter.print "\r"
-            line = "#{@spinner_chars[@spinner_index]} #{@current_line}"
-            @reporter.print(line)
+            print_current_line
             @spinner_index = (@spinner_index + 1) % @spinner_chars.size
           end
         end
+
+        def print_current_line
+          @reporter.clear_line
+          line = "#{@spinner_chars[@spinner_index]} #{@current_line}"
+          @reporter.print(line)
+        end
       end
 
-      def initialize(stdout = STDOUT, stdin = STDIN)
+      def initialize(stdout = STDOUT, stdin = STDIN, options = {})
         @stdout = stdout
         @stdin = stdin
-        @hl = HighLine.new
+        options.validate_options!(:assumeyes)
+        @assumeyes = options.fetch(:assumeyes, false)
+        @hl = HighLine.new(@stdin, @stdout)
         @max_length = 80
         @line_char = '-'
         @cell_char = '|'
         @spinner = Spinner.new(self)
+        @last_line = ''
       end
 
       def before_scenario_starts(scenario)
-        puts "Running #{scenario.description || scenario.class}"
-        hline
+        puts "\nRunning #{scenario.description || scenario.class}"
+        hline('=')
       end
 
       def before_execution_starts(execution)
-        @spinner.update(execution_info(execution, 'running'))
-        @spinner.activate
+        puts(execution_info(execution, ''))
       end
 
-      def on_execution_update(execution, update)
-        @spinner.update(execution_info(execution, update))
+      def print(string)
+        new_line_if_needed
+        @stdout.print(string)
+        @stdout.flush
+        record_last_line(string)
       end
 
-      def after_execution_finishes(execution)
+      def puts(string)
+        # we don't print the new line right away, as we want to be able to put
+        # the status label at the end of the last line, if possible.
+        # Therefore, we just mark that we need to print the new line next time
+        # we are printing something.
+        new_line_if_needed
+        @stdout.print(string)
+        @stdout.flush
+        @new_line_next_time = true
+        record_last_line(string)
+      end
+
+      def ask(message, options = {})
+        new_line_if_needed
+        options.validate_options!(:password)
+        # the answer is confirmed by ENTER which will emit a new line
+        @new_line_next_time = false
+        @last_line = ''
+        # add space at the end as otherwise highline would add new line there :/
+        message = "#{message} " unless message =~ /\s\Z/
+        answer = @hl.ask(message) { |q| q.echo = false if options[:password] }
+        answer.to_s.chomp.downcase if answer
+      end
+
+      def new_line_if_needed
+        if @new_line_next_time
+          @stdout.print("\n")
+          @stdout.flush
+          @new_line_next_time = false
+        end
+      end
+
+      def with_spinner(message)
+        new_line_if_needed
+        @spinner.activate
+        @spinner.update(message)
+        yield @spinner
+      ensure
         @spinner.deactivate
-        cell(execution_info(execution, status_label(execution, 11), @max_length - 15))
-        cell(execution.output) if execution.fail?
+        @new_line_next_time = true
+      end
+
+      def after_execution_finishes(execution)
+        puts_status(execution.status)
+        puts(execution.output) unless execution.output.empty?
         hline
+        new_line_if_needed
       end
 
       def after_scenario_finishes(_scenario); end
 
-      def on_next_steps(runner, steps)
-        choice = if steps.size > 1
-                   multiple_steps_selection(steps)
-                 elsif ask_to_confirm("Continue with step [#{steps.first.description}]?")
-                   steps.first
-                 else
-                   :quit
-                 end
-        choice == :quit ? runner.ask_to_quit : runner.add_step(choice)
+      def on_next_steps(steps)
+        return if steps.empty?
+        if steps.size > 1
+          multiple_steps_decision(steps)
+        else
+          single_step_decision(steps.first)
+        end
+      end
+
+      def clear_line
+        print "\r" + ' ' * @max_length + "\r"
+      end
+
+      private
+
+      def assumeyes?
+        @assumeyes
       end
 
-      def multiple_steps_selection(steps)
+      def single_step_decision(step)
+        answer = ask_decision("Continue with step [#{step.description}]?")
+        if answer == :yes
+          step
+        else
+          answer
+        end
+      end
+
+      def multiple_steps_decision(steps)
         puts 'There are multiple steps to proceed:'
         steps.each_with_index do |step, index|
           puts "#{index + 1}) #{step.description}"
@@ -109,68 +189,88 @@ module ForemanMaintain
         ask_to_select('Select step to continue', steps, &:description)
       end
 
-      def ask_to_confirm(message)
-        print "#{message}, [yN]"
-        answer = @stdin.gets.chomp
-        case answer
-        when 'y'
-          true
-        when 'n'
-          false
+      def ask_decision(message)
+        if assumeyes?
+          print("#{message} (assuming yes)")
+          return :yes
+        end
+        until_valid_decision do
+          filter_decision(ask("#{message}, [y(yes), n(no), q(quit)]"))
         end
       ensure
         clear_line
       end
 
+      def filter_decision(answer)
+        decision = nil
+        DECISION_MAPPER.each do |options, decision_label|
+          decision = decision_label if options.include?(answer)
+        end
+        decision
+      end
+
+      # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
       def ask_to_select(message, steps)
-        print "#{message}, (q) for quit"
-        answer = @stdin.gets.chomp
-        case answer
-        when 'q'
-          :quit
-        when /^\d+$/
-          steps[answer.to_i - 1]
+        if assumeyes?
+          puts('(assuming first option)')
+          return steps.first
+        end
+        until_valid_decision do
+          answer = ask("#{message}, [n(next), q(quit)]")
+          if answer =~ /^\d+$/ && (answer.to_i - 1) < steps.size
+            steps[answer.to_i - 1]
+          else
+            decision = filter_decision(answer)
+            if decision == :yes
+              steps.first
+            else
+              decision
+            end
+          end
         end
       ensure
         clear_line
       end
 
-      def clear_line
-        print "\r" + ' ' * @max_length + "\r"
+      # loop over the block until it returns some non-false value
+      def until_valid_decision
+        decision = nil
+        decision = yield until decision
+        decision
       end
 
-      def execution_info(execution, text, ljust = nil)
+      def execution_info(execution, text)
         prefix = "#{execution.name}:"
-        prefix = prefix.ljust(ljust) if ljust
         "#{prefix} #{text}"
       end
 
-      def status_label(execution, ljust)
+      def puts_status(status)
+        label_offset = 10
+        padding = @max_length - @last_line.to_s.size - label_offset
+        if padding < 0
+          new_line_if_needed
+          padding = @max_length - label_offset
+        end
+        @stdout.print(' ' * padding + status_label(status))
+        @new_line_next_time = true
+      end
+
+      def status_label(status)
         mapping = { :success => { :label => '[OK]', :color => :green },
                     :fail => { :label => '[FAIL]', :color => :red },
                     :running => { :label => '[RUNNING]', :color => :blue },
-                    :skipped => { :label => '[SKIPPED]', :color => :yellow } }
-        properties = mapping[execution.status]
-        @hl.color(properties[:label].ljust(ljust), properties[:color], :bold)
-      end
-
-      def hline
-        puts @line_char * @max_length
+                    :skipped => { :label => '[SKIPPED]', :color => :yellow },
+                    :warning => { :label => '[WARNING]', :color => :yellow } }
+        properties = mapping[status]
+        @hl.color(properties[:label], properties[:color], :bold)
       end
 
-      def cell(content)
-        print "#{@cell_char} #{content}".ljust(@max_length - 1)
-        puts @cell_char
+      def hline(line_char = @line_char)
+        puts line_char * @max_length
       end
 
-      def print(string)
-        @stdout.print(string)
-        @stdout.flush
-      end
-
-      def puts(string)
-        @stdout.puts(string)
-        @stdout.flush
+      def record_last_line(string)
+        @last_line = string.lines.to_a.last
       end
     end
   end

data/lib/foreman_maintain/runner.rb

@@ -2,38 +2,81 @@ module ForemanMaintain
   # Class responsible for running the scenario
   class Runner
     require 'foreman_maintain/runner/execution'
-    def initialize(reporter, scenario)
+    def initialize(reporter, scenarios, options = {})
+      options.validate_options!(:assumeyes)
+      @assumeyes = options.fetch(:assumeyes, false)
       @reporter = reporter
-      @scenario = scenario
-      @executions = []
-      @steps_to_run = @scenario.steps.dup
+      @scenarios = Array(scenarios)
+      @scenarios_with_dependencies = scenarios_with_dependencies
       @quit = false
     end
 
+    def assumeyes?
+      @assumeyes
+    end
+
+    def scenarios_with_dependencies
+      @scenarios.map do |scenario|
+        scenario.before_scenarios + [scenario]
+      end.flatten
+    end
+
     def run
-      @reporter.before_scenario_starts(@scenario)
+      scenarios_with_dependencies.each do |scenario|
+        run_scenario(scenario)
+      end
+    end
+
+    def run_scenario(scenario)
+      @steps_to_run = scenario.steps.dup
+      @reporter.before_scenario_starts(scenario)
       while !@quit && !@steps_to_run.empty?
         step = @steps_to_run.shift
+        @reporter.puts('Rerunning the check after fix procedure') if rerun_check?(step)
         execution = Execution.new(step, @reporter)
         execution.run
-        @executions << execution
-        ask_about_offered_steps(step.next_steps)
+        ask_about_offered_steps(step)
       end
-      @reporter.after_scenario_finishes(@scenario)
+      @reporter.after_scenario_finishes(scenario)
     end
 
-    def ask_to_quit
+    def ask_to_quit(_step = nil)
       @quit = true
     end
 
-    def add_step(step)
-      @steps_to_run.unshift(step)
+    def add_steps(*steps)
+      # we we add the steps at the beginning, but still keeping the
+      # order of steps passed in the arguments
+      steps.reverse.each do |step|
+        @steps_to_run.unshift(step)
+      end
     end
 
     private
 
-    def ask_about_offered_steps(steps)
-      @reporter.on_next_steps(self, steps) if steps
+    # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity
+    def ask_about_offered_steps(step)
+      if assumeyes? && rerun_check?(step)
+        @reporter.puts 'Check still failing after attempt to fix. Skipping'
+        return :no
+      end
+      if step.next_steps && !step.next_steps.empty?
+        @last_decision_step = step
+        steps = step.next_steps.map(&:ensure_instance)
+        decision = @reporter.on_next_steps(steps)
+        case decision
+        when :quit
+          ask_to_quit
+        when Executable
+          chosen_steps = [decision]
+          chosen_steps << step if step.is_a?(Check)
+          add_steps(*chosen_steps)
+        end
+      end
+    end
+
+    def rerun_check?(step)
+      @last_decision_step == step
     end
   end
 end