scripted 0.0.1

data/features/steps/scripted_steps.rb

@@ -0,0 +1,25 @@
+Then /^it should pass$/ do
+  assert_success true
+end
+
+Then /^it should fail$/ do
+  assert_success false
+end
+
+Given /^the configuration:$/ do |string|
+  write_file "scripted.rb", string
+end
+
+Then /^it should have taken about (\d+) seconds$/ do |seconds|
+  last_line = all_output.split("\n").reject { |line| line =~ /^\s*$/ }.last.strip
+  total = /Total runtime: (\d+\.\d+)s/.match(last_line)
+  expect(total[1].to_f).to be_within(0.5).of(seconds.to_f)
+end
+
+When /^I run scripted$/ do
+  run_simple "scripted", false
+end
+
+Then /^the file "(.*?)" should contain:$/ do |file, partial_content|
+  check_file_content(file, partial_content, true)
+end

data/features/support/aruba.rb

@@ -0,0 +1,5 @@
+require 'aruba/cucumber'
+
+Before do
+  @aruba_timeout_seconds = 10
+end

data/features/support/env.rb

@@ -0,0 +1,2 @@
+require 'bundler/setup'
+Bundler.setup

data/install

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -e
+gem which bundler >/dev/null 2>&1 || gem install bundler
+bundle update
+bundle exec scripted

data/lib/scripted.rb

@@ -0,0 +1,28 @@
+Thread.abort_on_exception = true
+
+require "scripted/error"
+require "scripted/version" unless defined?(Scripted::VERSION)
+require "scripted/configuration"
+require "scripted/runner"
+
+module Scripted
+
+  # Runs scripted.
+  #
+  # You can pass a configuration with group names,
+  # or you can pass a block, which will be the ad-hoc configuration.
+  def self.run(configuration = nil, *group_names, &block)
+    raise NotConfigured if configuration.nil? && block.nil?
+    config = configuration || configure(&block)
+    Runner.start!(config, *group_names)
+  end
+
+  # Configure scripted, returning a configuration which can be run later.
+  # Optionally pass a block to configure in place.
+  def self.configure(&block)
+    config = Configuration.new
+    config.evaluate(&block) if block_given?
+    config
+  end
+
+end

data/lib/scripted/command.rb

@@ -0,0 +1,82 @@
+require "scripted/commands/shell"
+require "scripted/commands/rake"
+require "scripted/commands/ruby"
+
+module Scripted
+  class Command
+
+    attr_reader :name
+
+    def initialize(name, options = {}, &block)
+      @name = name
+      @options = options
+      define(&block) if block
+    end
+
+    def define(&block)
+      instance_eval &block
+    end
+
+    def executable
+      @command || Commands::Shell.new(@name)
+    end
+
+    def execute!(logger)
+      executable.execute!(logger)
+    end
+
+    def sh(command)
+      @command = Commands::Shell.new(command)
+    end
+    alias_method :`, :sh
+
+    def rake(command)
+      @command = Commands::Rake.new(command)
+    end
+
+    def ruby(&code)
+      @command = Commands::Ruby.new(code)
+    end
+
+    def important!
+      @important = true
+    end
+
+    def important?
+      !!@important
+    end
+
+    def unimportant?
+      !!@unimportant
+    end
+
+    def unimportant!
+      @unimportant = true
+    end
+
+    def forced!
+      @forced = true
+    end
+
+    def forced?
+      !!@forced
+    end
+
+    def parallel_id
+      @options[:parallel_id]
+    end
+
+    def run_in_parallel_with?(other)
+      other && parallel_id == other.parallel_id
+    end
+
+    def only_when_failed?
+      !!@only_when_failed
+    end
+
+    def only_when_failed!
+      @only_when_failed = true
+    end
+
+  end
+end

data/lib/scripted/commands/rake.rb

@@ -0,0 +1,25 @@
+require 'scripted/commands/shell'
+require 'scripted/commands/ruby'
+
+module Scripted
+  module Commands
+    class Rake
+
+      attr_reader :command
+
+      def initialize(command)
+        @command = command
+      end
+
+      def execute!(log = STDOUT)
+        task = Rake::Task[command]
+      rescue NameError
+        # not running from within Rake, so falling back shelling out
+        Shell.new("rake #{command} --trace").execute!(log)
+      else
+        Ruby.new(lambda { task.invoke }).execute!(log)
+      end
+
+    end
+  end
+end

data/lib/scripted/commands/ruby.rb

@@ -0,0 +1,22 @@
+module Scripted
+  module Commands
+    class Ruby
+
+      def initialize(code)
+        @code = code
+      end
+
+      def execute!(log = STDOUT)
+        old_stdout = $stdout
+        old_stderr = $stderr
+        $stdout = log
+        $stderr = log
+        @code.call
+      ensure
+        $stdout = old_stdout
+        $stderr = old_stderr
+      end
+
+    end
+  end
+end

data/lib/scripted/commands/shell.rb

@@ -0,0 +1,28 @@
+require 'childprocess'
+
+module Scripted
+  module Commands
+    class Shell
+
+      attr_reader :command
+
+      def initialize(command)
+        @command = command
+      end
+
+      def execute!(log = STDOUT)
+        process = ChildProcess.build(command)
+
+        process.io.stdout = log
+        process.io.stderr = log
+        process.start
+
+        process.wait
+        if process.exit_code != 0
+          fail CommandFailed, "`#{command}` failed with exit status #{process.exit_code}"
+        end
+      end
+
+    end
+  end
+end

data/lib/scripted/configuration.rb

@@ -0,0 +1,103 @@
+require "scripted/error"
+require "scripted/group"
+
+module Scripted
+
+  class ConfigurationError       < Error;              end
+  class NoFormatterForOutput     < ConfigurationError; end
+  class ConfigFileNotFound       < ConfigurationError; end
+  class ConfigurationSyntaxError < ConfigurationError; end
+
+  class Configuration
+
+    attr_accessor :color
+
+    # Defines a group
+    def group(name, &block)
+      groups[name].define(&block)
+    end
+
+    # Defines a command in the `:default` group.
+    def run(name, &block)
+      groups[:default].define { run(name, &block) }
+    end
+    alias :` :run
+
+    # Makes a parallel block inside the `:default` group.
+    def parallel(&block)
+      groups[:default].define { parallel(&block) }
+    end
+
+    def formatter(name, options = {})
+      formatters << options.merge(:name => name)
+    end
+
+    def color?
+      color.nil? ? true : color
+    end
+
+    def out(out)
+      if formatters.any?
+        formatters.last[:out] = out
+      else
+        fail NoFormatterForOutput, "You must first specify a formatter to use this option"
+      end
+    end
+
+    def formatters
+      @formatters ||= []
+    end
+
+    def config_file(*file_names)
+      file_names.each do |file_name|
+        config_files << file_name
+      end
+    end
+
+    def config_files
+      @config_files ||= []
+    end
+
+    def absolute_config_files
+      config_files.map { |file_name| File.expand_path(file_name) }.uniq
+    end
+
+    def groups
+      @groups ||= Hash.new { |hash, key| hash[key] = Group.new(key) }
+    end
+
+    def with_default_config_file!
+      config_file "scripted.rb" if config_files.empty? && File.exist?("scripted.rb")
+    end
+
+    def load_files
+      absolute_config_files.each do |file_name|
+        load_file(file_name)
+      end
+      if groups.empty?
+        raise_config_file_error("scripted.rb")
+      end
+    end
+
+    def load_file(file_name)
+      source = File.open(file_name, 'r:utf-8').read
+      evaluate source, file_name, 1
+    rescue Errno::ENOENT => error
+      raise_config_file_error(file_name)
+    end
+
+    def evaluate(*args, &block)
+      instance_eval(*args, &block)
+    rescue Exception => error
+      my_error = ConfigurationSyntaxError.new("#{error.message} (#{error.class})")
+      my_error.set_backtrace error.backtrace
+      raise my_error
+    end
+
+    def raise_config_file_error(file_name)
+      raise ConfigFileNotFound, "No such file -- #{File.expand_path(file_name)}\nEither create a file called 'scripted.rb', or specify another file to load"
+    end
+
+  end
+
+end

data/lib/scripted/error.rb

@@ -0,0 +1,13 @@
+module Scripted
+  class Error < RuntimeError
+  end
+
+  class RunningFailed < Error
+  end
+
+  class CommandFailed < Error
+  end
+
+  class NotConfigured < Error
+  end
+end

data/lib/scripted/formatters/announcer.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+require "scripted/formatters/blank"
+require 'thread'
+
+module Scripted
+  module Formatters
+    class Announcer < Blank
+
+      def initialize(*)
+        super
+        @semaphore = Mutex.new
+      end
+
+      def start(commands, runner)
+        @length = [ 50, commands.max_by { |command| command.name.size }.name.size + 4 ].max
+      end
+
+      # wrapped in a synchronize block to prevent asynchronous output clogging the output
+      def execute(command)
+        @semaphore.synchronize do
+          puts ""
+          puts cyan("┌" + force_encoding("─" * (@length - 2)) + "┐")
+          puts "#{cyan("│")} #{command.name.center(@length - 4)} #{cyan("│")}"
+          puts cyan("└" + force_encoding("─" * (@length - 2)) + "┘")
+          puts ""
+        end
+      end
+
+      def force_encoding(text)
+        if text.respond_to?(:force_encoding)
+          text.force_encoding('utf-8')
+        else # ruby 1.8
+          text
+        end
+      end
+
+    end
+  end
+end

data/lib/scripted/formatters/blank.rb

@@ -0,0 +1,97 @@
+module Scripted
+  module Formatters
+    class Blank
+
+      attr_reader :raw_out, :configuration
+
+      # Called whn Scripted starts.
+      # If you override this, don't forget to call `super`.
+      def initialize(out, configuration)
+        @raw_out = out || $stderr
+        @configuration = configuration
+      end
+
+      # Called when the commands to be run have been selected
+      # No command has yet been run
+      def start(commands, runner)
+      end
+
+      # Called after all commands have been run.
+      def stop(commands, runner)
+      end
+
+      # Called whenever a command has failed.
+      def exception(command, exception)
+      end
+
+      # Called whenever a command has been run.
+      def done(command)
+      end
+
+      # Called when an important command has failed.
+      def halted(command)
+      end
+
+      # Called just before a command starts running
+      def execute(command)
+      end
+
+      # Called just before scripted exits. Useful for closing streams and
+      # closing connections.
+      def close
+      end
+
+      # Called for each character that went to stdout or stderr.
+      # Doesn't include output of other formatters.
+      def each_char(output, command)
+      end
+
+      private
+
+      def red(text);      color(31, text);  end
+      def green(text);    color(32, text);  end
+      def yellow(text);   color(33, text);  end
+      def blue(text);     color(34, text);  end
+      def magenta(text);  color(35, text);  end
+      def cyan(text);     color(36, text);  end
+      def white(text);    color(37, text);  end
+
+      def color(code, text)
+        if color_enabled?
+          "\e[#{code}m#{text}\e[0m"
+        else
+          text
+        end
+      end
+
+      def out
+        @out ||= build_out
+      end
+
+      def build_out
+        if raw_out.is_a?(String)
+          File.open(raw_out, 'w:utf-8')
+        else
+          raw_out
+        end
+      end
+
+      def file?
+        out.is_a?(File)
+      end
+
+      def puts(*args)
+        out.puts(*args)
+      end
+
+      def print(*args)
+        out.print(*args)
+      end
+
+      def color_enabled?
+        configuration.color? && !out.is_a?(File)
+      end
+
+    end
+  end
+end