scripted 0.0.1

data/lib/scripted/formatters/default.rb

@@ -0,0 +1,62 @@
+require "scripted/formatters/blank"
+
+# The default provides two things:
+#
+# * Print the regular command output
+# * Print exceptions that happen during the output
+#
+# When running commands in parallel, output would be intertwined. That's why
+# this formatter buffers the output if outputting to a file, than the file will
+# have the output in the right order at the end.
+module Scripted
+  module Formatters
+    class Default < Blank
+
+      def initialize(*)
+        super
+        @buffers = Hash.new { |h,k| h[k] = StringIO.new }
+      end
+
+      def each_char(output, command)
+        if file?
+          @buffers[command].print output
+        else
+          print output
+        end
+      end
+
+      def exception(command, exception)
+        command_puts command, red("  #{exception.class} during the execution of #{command.name.inspect}:")
+        exception.to_s.split("\n").each do |line|
+          command_puts command, red("    #{line}")
+        end
+        clean_backtrace(exception.backtrace).each do |line|
+          command_puts command, cyan("    # #{line}")
+        end
+      end
+
+      def close
+        if file?
+          @buffers.each do |command, output|
+            output.rewind
+            puts output.read
+          end
+        end
+      end
+
+      def command_puts(command, *args)
+        if file?
+          @buffers[command].puts *args
+        else
+          puts *args
+        end
+      end
+
+      def clean_backtrace(backtrace)
+        gem_path = File.expand_path("../../../", __FILE__)
+        backtrace.reject { |line| line.start_with?(gem_path) }
+      end
+
+    end
+  end
+end

data/lib/scripted/formatters/human_status.rb

@@ -0,0 +1,38 @@
+module Scripted
+  module Formatters
+    module HumanStatus
+
+      def human_status(command)
+        translations = {
+          :running                                  => "running",
+          :success_ran_because_other_command_failed => "success, ran because other command failed",
+          :failed_ran_because_other_command_failed  => "failed, ran because other command failed",
+          :skipped_because_no_other_command_failed  => "skipped, because no other command failed",
+          :failed_but_ignored                       => "failed, but ignored",
+          :success                                  => "success",
+          :failed_and_halted                        => "failed and halted",
+          :failed                                   => "failed",
+          :not_executed                             => "didn't run",
+          :unknown                                  => "unknown"
+        }
+        translations[status_code(command)]
+      end
+
+      def status_code(command)
+        case
+        when command.running?                                then :running
+        when command.only_when_failed? && command.success?   then :success_ran_because_other_command_failed
+        when command.only_when_failed? && command.failed?    then :failed_ran_because_other_command_failed
+        when command.only_when_failed? && !command.executed? then :skipped_because_no_other_command_failed
+        when command.failed_but_unimportant?                 then :failed_but_ignored
+        when command.success?                                then :success
+        when command.halted?                                 then :failed_and_halted
+        when command.failed?                                 then :failed
+        when !command.executed?                              then :not_executed
+        else :unknown
+        end
+      end
+
+    end
+  end
+end

data/lib/scripted/formatters/stats.rb

@@ -0,0 +1,38 @@
+require "scripted/formatters/blank"
+require 'scripted/formatters/human_status'
+
+
+module Scripted
+  module Formatters
+    class Stats < Blank
+      include HumanStatus
+
+      begin
+        require 'fastercsv'
+        CSV = FasterCSV
+      rescue LoadError
+        require 'csv'
+      end
+
+      def stop(commands, runner)
+        if out.is_a?(File)
+          CSV.open(out.path, "wb", &csv(commands))
+        else
+          puts CSV.generate(&csv(commands))
+        end
+      end
+
+    private
+
+    def csv(commands)
+      lambda do |csv|
+        csv << ["name", "runtime", "status"]
+        commands.each do |command|
+          csv << [command.name, command.runtime, human_status(command)]
+        end
+      end
+    end
+
+    end
+  end
+end

data/lib/scripted/formatters/table.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+require "scripted/formatters/blank"
+require 'scripted/formatters/human_status'
+
+module Scripted
+  module Formatters
+    class Table < Blank
+      include HumanStatus
+
+      def stop(commands, runner)
+        report_lines << [ Column["Command"], Column["Runtime"], Column["Status"] ]
+        commands.each do |command|
+          report_lines << [ Column[command.name], Column[command.runtime, "s"], Column[human_status(command)] ]
+        end
+        widths = report_lines.transpose.map { |line| line.max_by(&:size).size }
+        header = report_lines.shift
+        puts ""
+        puts ""
+        puts separator(widths, "┌", "┬", "┐")
+        puts report_line(header, widths)
+        puts separator(widths, "├", "┼", "┤")
+        report_lines.each do |line|
+          puts report_line(line, widths)
+        end
+        puts separator(widths, "└", "┴", "┘")
+        puts "  Total runtime: #{Column[runner.runtime, "s"]}"
+      end
+
+      private
+
+      def separator(widths, left, middle, right)
+        cyan(left) + widths.map { |width| force_encoding(cyan("─") * (width + 2)) }.join(cyan(middle)) + cyan(right)
+      end
+
+      def report_line(line, widths)
+        cyan("│ ") + force_encoding(line.zip(widths).map { |(column, width)| column.aligned(width) }.join(cyan(" │ "))) + cyan(" │")
+      end
+
+      def report_lines
+        @report_lines ||= []
+      end
+
+      def force_encoding(text)
+        if text.respond_to?(:force_encoding)
+          text.force_encoding('utf-8')
+        else # ruby 1.8
+          text
+        end
+      end
+
+      class Column
+
+        attr_reader :value, :suffix
+
+        def self.[](value, suffix = "")
+          new(value, suffix)
+        end
+
+        def initialize(value, suffix)
+          @value, @suffix = value, suffix
+        end
+
+        def to_s
+          string = case value
+                   when Fixnum
+                     value.to_s
+                   when Numeric
+                     "%.3f" % value
+                   when NilClass
+                     nil
+                   else
+                     value.to_s
+                   end
+          if string
+            "#{string}#{suffix}"
+          else
+            ""
+          end
+        end
+
+        def size
+          to_s.size
+        end
+
+        def aligned(width)
+          case value
+          when Numeric
+            to_s.rjust(width)
+          else
+            to_s.ljust(width)
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/scripted/formatters/websocket.rb

@@ -0,0 +1,137 @@
+require 'time'
+require 'json'
+require 'net/http'
+require "scripted/formatters/blank"
+require "scripted/formatters/human_status"
+
+module Scripted
+  module Formatters
+    class Websocket < Blank
+      include HumanStatus
+
+      def initialize(out, configuration)
+        @uri = URI.parse(out)
+        super(@uri, configuration)
+        @buffers = Hash.new { |h,k| h[k] = "" }
+        @flusher = Thread.new do
+          loop do
+            flush
+            sleep 0.1
+          end
+        end
+        publish :action => :initialize
+      end
+
+      def each_char(char, command)
+        @buffers[command] << char
+      end
+
+      def start(commands, runner)
+        flush!
+        publish :action => :start, :commands => commands.map { |command| command_json(command) }, :runner => runner_json(runner)
+      end
+
+      def stop(commands, runner)
+        flush!
+        publish :action => :stop, :commands => commands.map { |command| command_json(command) }, :runner => runner_json(runner)
+      end
+
+      def exception(command, exception)
+        flush!
+        publish :action => :exception, :command => command_json(command), :exception => exception, :backtrace => exception.backtrace
+      end
+
+      def done(command)
+        flush!
+        publish :action => :done, :command => command_json(command)
+      end
+
+      def halted(command)
+        flush!
+        publish :action => :halted, :command => command_json(command)
+      end
+
+      def execute(command)
+        flush!
+        publish :action => :execute, :command => command_json(command)
+      end
+
+      def flush!
+        flush
+        @buffer = ""
+      end
+
+      def flush
+        if output != ""
+          publish :action => :output, :output => output
+        end
+      end
+
+      def close
+        @flusher.exit
+        flush!
+        publish :action => :close
+      end
+
+      private
+
+      def publish(data)
+        message = {:channel => "/scripted", :data => data }
+        Net::HTTP.post_form(@uri, :message => message.to_json)
+      rescue Errno::ECONNREFUSED
+        unless @warned
+          warn red("No connection to #{@uri}")
+          @warned = true
+        end
+      end
+
+      def output
+        @buffers.map { |command, output| { :command => command_json(command), :output => output } }
+      end
+
+
+      def command_json(command)
+        { :name                   => command.name,
+          :forced                 => command.forced?,
+          :success                => command.success?,
+          :halted                 => command.halted?,
+          :executed               => command.executed?,
+          :only_when_failed       => command.only_when_failed?,
+          :parallel               => command.parallel?,
+          :parallel_id            => command.parallel_id,
+          :failed_but_unimportant => command.failed_but_unimportant?,
+          :unimportant            => command.unimportant?,
+          :command_type           => command.command.executable.class.to_s,
+          :runtime                => command.runtime,
+          :started_at             => time(command.started_at),
+          :ended_at               => time(command.ended_at),
+          :running                => command.running?,
+          :id                     => command.object_id,
+          :human_status           => human_status(command),
+          :status_code            => status_code(command)
+        }
+      end
+
+      def runner_json(runner)
+        { :started_at => time(runner.started_at),
+          :ended_at   => time(runner.ended_at),
+          :runtime    => runner.runtime,
+          :halted     => runner.halted?,
+          :running    => runner.running?,
+          :executed   => runner.executed?,
+          :failed     => runner.failed?
+        }
+      end
+
+      def time(time)
+        if time
+          time.utc.iso8601
+        else
+          time
+        end
+      end
+
+    end
+
+  end
+end

data/lib/scripted/group.rb

@@ -0,0 +1,49 @@
+require "scripted/command"
+
+module Scripted
+  class Group
+
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+      @parallel = false
+      @parallel_id = (object_id ** 2)
+    end
+
+    def define(&block)
+      instance_eval &block if block
+    end
+
+    def run(name, &block)
+      next_parallel_id unless in_parallel?
+      commands << Command.new(name, :parallel_id => parallel_id, &block)
+    end
+
+    def parallel(&block)
+      @parallel = true
+      yield
+      @parallel = false
+      next_parallel_id
+    end
+
+    def commands
+      @commands ||= []
+    end
+
+    private
+
+    def parallel_id
+      @parallel_id
+    end
+
+    def next_parallel_id
+      @parallel_id += 1
+    end
+
+    def in_parallel?
+      @parallel
+    end
+
+  end
+end

data/lib/scripted/output/command_logger.rb

@@ -0,0 +1,42 @@
+module Scripted
+  module Output
+    class CommandLogger
+
+      attr_reader :logger, :command
+
+      attr_reader :read, :write, :reader
+
+      def initialize(logger, command)
+
+        @logger, @command = logger, command
+
+        @read, @write = IO.pipe
+
+        @reader = Thread.new do
+          read.each_char do |char|
+            logger.send_to_formatters :each_char, char, command
+          end
+        end
+
+      end
+
+      def to_io
+        write
+      end
+
+      def sync
+        read.sync
+        write.sync
+        sleep 0.01
+      end
+
+      def close
+        sync
+        reader.exit
+        write.close
+        read.close
+      end
+
+    end
+  end
+end