utils 0.2.4 → 0.6.4

data/lib/utils/line_formatter.rb

@@ -2,112 +2,171 @@ require 'tins/terminal'
 require 'term/ansicolor'
 
 begin
-  begin
-    require 'rspec'
-  rescue LoadError
-  end
-  require 'rspec/core/formatters/base_text_formatter'
-rescue LoadError
-end
-
-if defined?(RSpec) && defined?(RSpec::Core::Formatters::BaseTextFormatter)
+  require 'rspec/core'
+  require 'rspec/core/formatters'
+rescue LoadError => e
+  $DEBUG and warn "Caught #{e.class}: #{e}"
+else
   module Utils
-    class LineFormatter < RSpec::Core::Formatters::BaseTextFormatter
-      def start(example_count)
-        super
-        filename = 'errors.lst'
-        output.puts "Storing error list in #{filename.inspect}: "
-        @errors_lst = File.new(filename, 'w')
-        @errors_lst.sync = true
-      end
-
-      def close
-        super
-        @errors_lst.puts "\n#{?= * 75}\nFinished in #{format_duration(duration)}\n"
-        @errors_lst.puts summary_line(example_count, failure_count, pending_count)
-        @errors_lst.close
-      end
-
-      def example_passed(example)
-        super
-        output.puts format_line(example)
-      end
-
-      def example_pending(example)
-        super
-        output.puts format_line(example)
-      end
-
-      def example_failed(example)
-        super
-        dump_line_to_error_file(example)
-        output.puts format_line(example)
-        dump_failure_info(example)
-      end
-
-      def dump_failures
-      end
-
-      def dump_pending
-      end
-
-      def dump_commands_to_rerun_failed_examples
-      end
-
-      private
-
-      def dump_failure_for_error_file(example)
-        result = ''
-        exception = example.execution_result[:exception]
-        exception_class_name = exception_class_name_for(exception)
-        result << "#{long_padding}Failure/Error: #{read_failed_line(exception, example).strip}\n"
-        result << "#{long_padding}#{exception_class_name}:\n" unless exception_class_name =~ /RSpec/
-        exception.message.to_s.split("\n").each { |line| result << "#{long_padding}  #{line}\n" } if exception.message
-        result
-      end
-
-      def dump_line_to_error_file(example)
-        @errors_lst.flock File::LOCK_EX
-        @errors_lst.puts "%s\n%3.3fs %s\n%s\n%s" % [
-          location(example), run_time(example), example.full_description,
-          Term::ANSIColor.uncolored(dump_failure_for_error_file(example)),
-          (%w[ {{{ ] +
-           format_backtrace(example.execution_result[:exception].backtrace, example) +
-           %w[ }}} ]) * ?\n
-        ]
-      ensure
-        @errors_lst.flock File::LOCK_UN
-      end
-
-      def run_time(example)
-        example.execution_result[:run_time]
-      end
-
-      def format_line(example)
-        description =
-          if ENV['VERBOSE'].to_i == 1
-            example.full_description
+    class LineFormatter
+        ::RSpec::Core::Formatters.register self, :start, :close,
+          :example_passed, :example_pending, :example_failed, :dump_summary
+
+        def initialize(output)
+          @output = output
+          @output.sync = true
+          filename = 'errors.lst'
+          @errors_lst = File.new(filename, 'w')
+          @errors_lst.sync = true
+        end
+
+        attr_reader :output
+
+        def start(_ignore)
+          output.puts "Storing error list in #{@errors_lst.path.inspect}: "
+          output.puts ?- * Tins::Terminal.columns
+        end
+
+        def close(_ignore)
+          @errors_lst.close
+        end
+
+        def dump_summary(summary)
+          line = summary_line(summary)
+          @errors_lst.puts ?= * 80, line
+          output.puts ?= * Tins::Terminal.columns, line
+        end
+
+        def example_passed(example)
+          output.puts format_line(example)
+        end
+
+        def example_pending(example)
+          output.puts format_line(example)
+        end
+
+        def example_failed(example)
+          dump_failure_to_error_file(example)
+          output.puts format_line(example)
+          dump_failure(example)
+        end
+
+        private
+
+        def summary_line(summary)
+          failure_percentage = 100 * summary.failure_count.to_f / summary.example_count
+          failure_percentage.nan? and failure_percentage = 0.0
+          pending_percentage = 100 * summary.pending_count.to_f / summary.example_count
+          pending_percentage.nan? and pending_percentage = 0.0
+          "%u of %u (%.2f %%) failed, %u pending (%.2f %%) in %.3f seconds" % [
+            summary.failure_count,
+            summary.example_count,
+            failure_percentage,
+            summary.pending_count,
+            pending_percentage,
+            summary.duration,
+          ]
+        end
+
+        def dump_failure(example)
+          output.puts(
+            description(example, full: true),
+            dump_failure_for_example(example)
+          )
+        end
+
+        def read_failed_line(example)
+          ''.strip
+        end
+
+        def dump_failure_for_example(example)
+          result = ''
+          exception = execution_result(example).exception
+          exception_class_name = exception.class.name
+          result << "Failure/Error: #{read_failed_line(example)}\n"
+          result << "#{exception_class_name}:\n" unless exception_class_name =~ /RSpec/
+          if m = exception.message
+            m.to_s.split("\n").each { |line| result << "  #{line}\n" }
+          end
+          result
+        end
+
+        def format_backtrace(example, folding: false, limit: nil)
+          backtrace = execution_result(example).exception.backtrace
+          backtrace.nil? and return ''
+          if limit
+            backtrace = backtrace[0, limit]
+          end
+          result = []
+          folding and result << '{{{'
+          for line in backtrace
+            result << RSpec::Core::Metadata::relative_path(line)
+          end
+          folding and result << '}}}'
+          result * ?\n
+        end
+
+        def dump_failure_to_error_file(example)
+          @errors_lst.flock File::LOCK_EX
+          @errors_lst.puts "%s\n%3.3fs %s\n%s\n%s" % [
+            location(example), run_time(example), description(example, full: true),
+            dump_failure_for_example(example), format_backtrace(example, folding: true)
+          ]
+        ensure
+          @errors_lst.flock File::LOCK_UN
+        end
+
+        def execution_result(example)
+          example.example.metadata[:execution_result]
+        end
+
+        def description(example, full: ENV['VERBOSE'].to_i == 1)
+          if full
+            example.example.full_description
+          else
+            example.example.description
+          end
+        end
+
+        def run_time(example)
+          execution_result(example).run_time
+        end
+
+        def format_line(example)
+          args = [ location(example), run_time(example), description(example) ]
+          uncolored = "%s # S %3.3fs %s" % args
+          uncolored = uncolored[0, Tins::Terminal.columns]
+          case execution_result(example).status
+          when :passed
+            success_color(uncolored)
+          when :failed
+            failure_color(uncolored)
+          when :pending
+            pending_color(uncolored)
           else
-            example.description
+            uncolored % args
           end
-        args = [ location(example), run_time(example), description ]
-        uncolored = "%s # S %3.3fs %s" % args
-        uncolored = uncolored[0, Tins::Terminal.columns]
-        case example.execution_result[:status]
-        when 'passed'
-          success_color(uncolored)
-        when 'failed'
-          failure_color(uncolored)
-        when 'pending'
-          pending_color(uncolored)
-        else
-          uncolored % args
-        end
-      end
-
-      def location(example)
-        RSpec::Core::Metadata::relative_path(example.location)
-      end
+        end
+
+        def success_color(text)
+          Term::ANSIColor.green(text)
+        end
+
+        def failure_color(text)
+          Term::ANSIColor.red(text)
+        end
+
+        def pending_color(text)
+          Term::ANSIColor.yellow(text)
+        end
+
+        def location(example)
+          location = example.example.metadata[:location]
+          unless location.include?(?/)
+            location = example.example.metadata[:example_group][:location]
+          end
+          RSpec::Core::Metadata::relative_path(location)
+        end
     end
   end
 end

data/lib/utils/patterns.rb

@@ -9,6 +9,8 @@ module Utils
         @pattern = @pattern.gsub(/[^#{@cset}]/, '') if @cset
       end
 
+      attr_reader :matcher
+
       def method_missing(*a, &b)
         @matcher.__send__(*a, &b)
       end

data/lib/utils/probe_server.rb

@@ -7,19 +7,9 @@ end
 module Utils
   class ProbeServer
     class Job
-
-      class << self
-        attr_writer :colorize
-
-        def colorize?
-          !!@colorize
-        end
-      end
-      self.colorize = false
-
       def initialize(probe_server, args)
         @id           = probe_server.next_job_id
-        @args         = args
+        @args         = Array(args)
       end
 
       attr_reader :id
@@ -37,18 +27,15 @@ module Utils
       end
 
       def ok_colorize(string)
-        return string unless self.class.colorize?
         case @ok
         when false then string.white.on_red
         when true  then string.black.on_green
-        else            string.black.on_yellow
+        else            string
         end
       end
 
       def inspect
-        ok_colorize(
-          "#<Job id=#{id} args=#{args.inspect} ok=#{ok}>"
-        )
+        ok_colorize("Job##{id} #{args.map { |a| a.include?(' ') ? a.inspect : a } * ' '}")
       end
 
       alias to_s inspect
@@ -62,6 +49,12 @@ module Utils
       Thread.new { work_loop }
     end
 
+    def print(*msg)
+      if msg.first !~ /^irb: warn: can't alias / # shut your god d*mn wh*re mouth
+        super
+      end
+    end
+
     def start
       output_message "Starting probe server listening to #{@uri.inspect}.", type: :info
       DRb.start_service(@uri, self)
@@ -69,7 +62,8 @@ module Utils
         DRb.thread.join
       rescue Interrupt
         ARGV.clear << '-f'
-        output_message %{\nEntering interactive mode: Type "commands" to get help for the commands.}, type: :info
+        output_message %{\nEntering interactive mode.}, type: :info
+        help
         begin
           old, $VERBOSE = $VERBOSE, nil
           examine(self)
@@ -88,40 +82,24 @@ module Utils
 
     annotate :doc
 
-    def commands
-      annotations = self.class.doc_annotations.sort_by(&:first)
-      max_size = annotations.map { |a| a.first.size }.max
-      output_message annotations.map { |n, v| "#{n.to_s.ljust(max_size + 1)}#{v}" }
-    end
+    annotate :shortcut
 
-    doc 'Pause processing of the job queue.'
-    def pause
-      mutex.lock
-      true
-    rescue ThreadError
-      false
-    end
-
-    doc 'Continue processing of the job queue.'
-    def continue
-      mutex.unlock
-      true
-    rescue ThreadError
-      false
-    end
-
-    doc 'Return the currently running job.'
-    def job
-      queue_synchronize do
-        @job
-      end
-    end
-
-    def next_job_id
-      @current_job_id += 1
+    doc 'Display this help.'
+    shortcut :h
+    def help
+      docs      = doc_annotations.sort_by(&:first)
+      docs_size = docs.map { |a| a.first.size }.max
+      format = '%-20s %-3s %s'
+      output_message [
+          (format % %w[ command sho description ]).on_color(20).white
+        ] << docs.map { |cmd, doc|
+          shortcut = shortcut_of(cmd) and shortcut = "(#{shortcut})"
+          format % [ cmd, shortcut, doc ]
+        }
     end
 
     doc 'Enqueue a new job with the argument array <job_args>.'
+    shortcut :e
     def job_enqueue(job_args)
       job = Job.new(self, job_args)
       output_message " → #{job.inspect} enqueued.", type: :info
@@ -130,35 +108,15 @@ module Utils
     alias enqueue job_enqueue
 
     doc 'Send the <signal> to the process that is working on the current job, if any.'
-    def job_kill(signal = :TERM)
-      @pid and Process.kill signal, @pid
-    end
-
-    doc 'Shutdown the server.'
+    doc 'Quit the server.'
+    shortcut :q
     def shutdown
       output_message "Server was shutdown down – HARD!", type: :warn
-      exit! 23
-    end
-
-    doc 'List the currently pending jobs waiting to be run.'
-    def jobs_list
-      output_message @jobs_queue.instance_variable_get(:@que)
-    end
-
-    doc 'Clear all pending jobs.'
-    def jobs_clear
-      queue_synchronize do
-        unless @jobs_queue.empty?
-          @jobs_queue.clear
-          output_message "Cleared all queued jobs.", type: :warn
-          true
-        else
-          false
-        end
-      end
+      exit 23
     end
 
     doc 'Repeat the job with <job_id> or the last, it will be assigned a new id, though.'
+    shortcut :r
     def job_repeat(job_id = @history.last)
       Job === job_id and job_id = job_id.id
       if old_job = @history.find { |job| job.id == job_id }
@@ -170,6 +128,7 @@ module Utils
     end
 
     doc 'List the history of run jobs.'
+    shortcut :l
     def history_list
       output_message @history
     end
@@ -180,19 +139,39 @@ module Utils
       true
     end
 
+    class LogWrapper < BasicObject
+      def initialize(server, object)
+        @server, @object = server, object
+      end
+
+      def []=(name, value)
+        name, value = name.to_s, value.to_s
+        @server.output_message("Setting #{name}=#{value.inspect}.", type: :info)
+        @object[name] = value
+      end
+
+      def method_missing(*a, &b)
+        @object.__send__(*a, &b)
+      end
+    end
+
     doc "The environment of the server process, use env['a'] = 'b' and env['a']."
-    def env
-      ENV
+    memoize_method def env
+      LogWrapper.new(self, ENV)
     end
 
-    private
+    doc "Clear the terminal screen"
+    shortcut :c
+    def clear
+      system "clear"
+    end
 
-    def mutex
-      @jobs_queue.instance_variable_get(:@mutex)
+    for (method_name, shortcut) in shortcut_annotations
+      alias_method shortcut, method_name
     end
 
-    def queue_synchronize(&block)
-      mutex.synchronize(&block)
+    def next_job_id
+      @current_job_id += 1
     end
 
     def output_message(msg, type: nil)
@@ -204,7 +183,7 @@ module Utils
         when :info
           msg.on_color(20).white
         when :warn
-          msg.on_color(40).white
+          msg.on_color(94).white
         when :failure
           msg.on_color(124).blink.white
         else
@@ -215,10 +194,11 @@ module Utils
       self
     end
 
+    private
+
     def run_job(job)
-      @pid = fork { exec(*cmd(job.args)) }
-      output_message " → #{job.inspect} now running with pid #@pid.", type: :info
-      Process.wait @pid
+      output_message " → #{job.inspect} now running.", type: :info
+      system *cmd(job.args)
       message = " → #{job.inspect} was just run"
       if $?.success?
         job.ok = true