crew 0.0.1

data/lib/crew/home/dsl.rb

@@ -0,0 +1,46 @@
+module Crew
+  class Home
+    class DSL
+      def initialize(home)
+        @home = home
+      end
+
+      def before(&cb)
+        @home.add_callback(:before, &cb)
+      end
+
+      def after(&cb)
+        @home.add_callback(:after, &cb)
+      end
+
+      def load(path = nil, &blk)
+        instance_eval(File.read(path), path, 1) if path
+        instance_eval(&blk) if blk
+      end
+
+      def context(name, &blk)
+        @home.add_context(name, &blk)
+      end
+
+      def default_context(name)
+        @home.default_context_name = name
+      end
+
+      def source(source)
+        @home.sources << source
+      end
+
+      def hint(hint)
+        @home.hints << hint
+      end
+
+      def test(name, &blk)
+        @home.add_tester(name, &blk)
+      end
+
+      def default_test(name)
+        @home.default_test_name = name
+      end
+    end
+  end
+end

data/lib/crew/logger.rb

@@ -0,0 +1,127 @@
+module Crew
+  class Logger
+    def initialize(mute = false)
+      @indent = 0
+      @mute = mute
+      writer.sync = true
+    end
+
+    def muted
+      original_mute = @mute
+      @mute = true
+      begin
+        yield
+      ensure
+        @mute = original_mute
+      end
+    end
+
+    def info(text)
+      log text
+    end
+
+    def sh(command)
+      log "#{'$'.color(:blue)} #{command}"
+    end
+
+    def cd(dir)
+      log "cd #{dir}".color("#aaaaaa")
+    end
+
+    def spinner(label)
+      muted do
+        $stderr.write "  " * @indent
+        index = 0
+        states = %w(◴ ◷ ◶ ◵)
+        spin = proc do |val|
+          if index > 0
+            $stderr.write "\b" * (label.size + 2)
+          end
+          if val
+            $stderr.write "* ".color(:green)
+            $stderr.puts label
+          else
+            $stderr.write states[index % states.size].color(:yellow)
+            $stderr.write " #{label}"
+            index += 1
+          end
+        end
+        spin[false]
+        spin
+      end
+    end
+
+    def task(command, args)
+      log "#{command} #{args.to_s}".color("#aaaaaa")
+      out = nil
+      begin
+        indent do
+          out = yield
+        end
+        pass_line = "#{'✓'.color(:green)} #{command}"
+        pass_line << " #{'# =>'.color(:magenta)} #{out.inspect}"
+        log pass_line
+        out
+      rescue AssertionError
+        log "#{'✘'.color(:red)} #{command}"
+        raise
+      rescue => e
+        log "#{'!!!'.color(:blue)} #{command} ([#{e.class}] #{e.message})"
+        raise
+      end
+    end
+
+    def test(name)
+      log "Testing #{name.inverse}"
+      indent do
+        yield
+      end
+    end
+
+    def pass_test(name)
+      log "#{'✓'.color(:green)} Passed test #{name.inverse}"
+    end
+
+    def skip_test(name)
+      log "#{'/'.color(:yellow)} Skipping test #{name.inverse}"
+    end
+
+    def fail_test(name)
+      log "#{'✘'.color(:red)} Failing test #{name.inverse}"
+    end
+
+    def no_test(name)
+      log "#{'≈'.color(:blue)} No tests for #{name}"
+    end
+
+    def context(name)
+      log "--> [#{name.color(:cyan)}] starting"
+      start_time = Time.new.to_f
+      indent do
+        yield
+      end
+      end_time = Time.new.to_f
+      log "<-- [#{name.color(:cyan)}] ended in %0.2f seconds" % [end_time - start_time]
+    end
+
+    def log(line)
+      writer.write "  " * @indent
+      writer.puts line
+    end
+
+    def set_logging(enabled)
+      @logging = enabled
+    end
+
+    def indent
+      @indent += 1
+      yield
+    ensure
+      @indent -= 1
+    end
+
+    def writer
+      @mute ? StringIO.new : $stderr
+    end
+  end
+end

data/lib/crew/task.rb

@@ -0,0 +1,242 @@
+module Crew
+  class Task
+    include Util
+
+    NoMatchingHintsError = Class.new(RuntimeError)
+
+    attr_accessor :desc, :context, :default_hints
+    attr_reader :name, :arguments, :path, :home
+
+    def initialize(home, name, load_path = nil, &dsl_blk)
+      @home, @name, @load_path, @dsl_blk = home, name, load_path, dsl_blk
+      @context = @home.context
+      reset!
+    end
+
+    def installed?
+      File.exist?(@load_path) && @load_path.start_with?(home_dir)
+    end
+
+    def home_dir
+      @home.home_path
+    end
+
+    def reset!
+      @desc = ""
+      @templates = {}
+      @arguments = Arguments.new
+      @setups = {}
+      @verifiers = {}
+      @runners = {}
+      @tests = []
+      @default_hints = []
+      dsl = DSL.new(self, &@dsl_blk)
+      dsl.load(@load_path) if @load_path
+    end
+
+    def source
+      File.read(@load_path)
+    end
+
+    def args
+      @arguments.proxy(self)
+    end
+
+    def untested?
+      @tests.empty?
+    end
+
+    def passing?
+      results = Dir[File.join(all_tests_path_prefix, "**", "*.json")].collect do |result|
+        JSON.parse(File.read(result))['status']
+      end
+      results.uniq!
+      results.all? {|r| %w(pass skip).include?(r)}
+    end
+
+    def method_missing(name, *args, &blk)
+      if t = task(name.to_s)
+        t.run!(*args, &blk)
+      else
+        super(name, *args, &blk)
+      end
+    end
+
+    def cd(dir, &blk)
+      @context.cd(dir, &blk)
+    end
+
+    def sh(cmd, opts = {})
+      @context.sh(cmd, opts)
+    end
+
+    def sh_with_code(cmd, opts = {})
+      @context.sh_with_code(cmd, opts)
+    end
+
+    def task(name)
+      @context.task(name)
+    end
+
+    def save_data(*args)
+      @context.save_data(*args)
+    end
+
+    def save_file(*args)
+      @context.save_file(*args)
+    end
+
+    def hint(h)
+      @context.hint(h)
+    end
+
+    def hints
+      @context.hints
+    end
+
+    def reconnect!
+      @context.reconnect!
+    end
+
+    def run!(*incoming_args, &blk)
+      reset!
+      @context.with_callbacks do
+        @arguments.process!(incoming_args, &blk)
+        @context.logger.task(@name, args) do
+          success = false
+          task_finished = false
+
+          @context.home.perform_setup { setup }
+          raise "task '#{@name}' has been called from within setup, but, has no verifier" if @context.home.in_setup && !verifiable?
+          success = verifiable? && verified?
+          unless success
+            raise "can't perform `#{@name}' because we're in setup mode, but, we're not actually performing the setup" if @context.home.in_setup && !@context.home.setup_mode
+            @out = run
+            if verifiable?
+              @out = nil
+              verified? or raise "validator for '#{@name}' failed after the task completed successfully"
+            end
+          end
+          @out
+        end
+      end
+    end
+
+    def digest
+      Digest::SHA1.hexdigest(source)
+    end
+
+    def test!(tester, opts = {})
+      @tests.each_with_index do |(hints, test_block), index|
+        force = opts[:force]
+        skip = !hints.all? {|h| tester.hints.include?(h)}
+        test = Test.new(self, test_path_prefix, index, skip, test_block)
+        if test.result.status == 'fail' && opts[:failed_only]
+          force = true
+        end
+        test.clear_cached_result! if force
+        yield test.run_test!(opts[:fast])
+      end
+      clear_extra_results!
+    end
+
+    def add_template(name, contents)
+      @templates[name] = contents
+    end
+
+    def template(name, locals = {})
+      template = @templates.fetch(name)
+      ERB.new(template).result(OpenStruct.new(locals).instance_eval { binding })
+    end
+
+    def add_test(*hints, &test)
+      @tests << [(@default_hints + hints).map(&:to_s), test]
+    end
+
+    def add_setup(*hints, &block)
+      add_to_list(@setups, hints, block)
+    end
+
+    def add_verify(*hints, &block)
+      add_to_list(@verifiers, hints, block)
+    end
+
+    def add_run(*hints, &block)
+      add_to_list(@runners, hints, block)
+    end
+
+    def verify
+      eval_for_matching_hints(@verifiers) { raise_no_matching_hints }
+    end
+
+    def setup
+      eval_for_matching_hints(@setups)
+    end
+
+    private
+    def raise_no_matching_hints
+      raise NoMatchingHintsError, "#{@name} with hints #{@context.hints.to_a}"
+    end
+
+    def add_to_list(list, hints, block)
+      # TODO
+      raise "task #{@name} tries to add an empty blah" unless block && list
+      combined_hints = (@default_hints + hints).map(&:to_s)
+      list[combined_hints] = block
+    end
+
+    def eval_for_matching_hints(list, *args)
+      matching_hints = list.keys.sort_by {|hints| hints.length}.reverse.find do |hints|
+        hints.all? { |h| @context.hints.include?(h) }
+      end
+      if matching_hints
+        instance_exec(*args, &list[matching_hints])
+      else
+        yield if block_given?
+      end
+    end
+
+    def all_tests_path_prefix
+      parts = digest.match(/^(..)(..)(..)(.*)/)
+      File.join(@home.test_path, parts[1], parts[2], parts[3], parts[4], "tests")
+    end
+
+    def test_path_prefix
+      raise unless @context
+      File.join(all_tests_path_prefix, @context.name)
+    end
+
+    def run
+      eval_for_matching_hints(@runners) {
+        raise_no_matching_hints
+      }
+    end
+
+    def verifiable?
+      !@verifiers.empty?
+    end
+
+    def verified?
+      !verifiable? or begin
+        verify
+      rescue AssertionError
+        false
+      else
+        true
+      end
+    end
+
+    def clear_extra_results!
+      index = @tests.size
+      while path = File.join(test_path_prefix, "#{index}.json")
+        return unless File.exist?(path)
+        File.unlink(path)
+        index += 1
+      end
+    end
+
+    def clear_cached_results!
+      FileUtils.rm_rf(test_path_prefix)
+    end
+  end
+end

data/lib/crew/task/arguments.rb

@@ -0,0 +1,132 @@
+module Crew
+  class Task
+    class Arguments
+
+      class BlockDefinition
+        def initialize(opts, &block)
+          @opts = opts
+          @args = Arguments.new
+          Arguments::DSL.load(@args, &block)
+        end
+
+        def process(&blk)
+          # TODO make better
+          blk
+        end
+      end
+
+      class Definition
+        attr_reader :type, :name, :desc
+
+        def initialize(name, type, desc, opts)
+          @name, @type, @desc, @opts = name, type, desc, opts
+        end
+
+        def value(args, opts)
+          val = case @type
+          when :required then args.shift
+          when :opt      then opts.key?(@name) ? opts[@name] : @opts[:default]
+          when :glob     then args.slice!(0, args.size)
+          else                raise "unknown #{@name}"
+          end
+          if @opts[:type] == Integer
+            val = Integer(val)
+          end
+          val
+        end
+
+        def required?
+          @type == :required
+        end
+
+        def glob?
+          @type == :glob
+        end
+      end
+
+      class Proxy
+        attr_reader :block
+
+        def initialize(task, params, block)
+          @task, @params, @block = task, params, block
+        end
+
+        def method_missing(name, *args)
+          if @params.key?(name.to_s)
+            @params[name.to_s].is_a?(Proc) ? @task.instance_eval(&@params[name.to_s]) : @params[name.to_s]
+          else
+            super
+          end
+        end
+
+        def to_s
+          @params.empty? ? "" : "(" + @params.map do |k, v|
+            val = v.inspect
+            if val.size > 50
+              val = val[0..22] + "..." + val[-22..-1]
+            end
+            "#{k}=#{val}"
+          end.join(" ") + ")"
+        end
+      end
+
+      attr_reader :definitions
+
+      def initialize
+        @definitions = []
+      end
+
+      def process!(args, &blk)
+        opts = args.last.is_a?(Hash) ? args.pop : {}
+        opts = opts.each_with_object({}){|(k,v), h| h[k.to_s] = v}
+        if args.size < minimum_args or (maximum_args && args.size > maximum_args)
+          message = "wrong number of arguments (got #{args.size} expected at least #{minimum_args})"
+          message << " and at most #{maximum_args}" if maximum_args
+          raise ArgumentError, message
+        end
+        @args = args
+        @opts = opts
+        @block = @block_definition.process(&blk) if @block_definition
+        raise if blk && @block_definition.nil?
+      end
+
+      def define(arg, type, desc, opts)
+        @definitions << Definition.new(arg, type, desc, opts)
+      end
+
+      def define_block(opts, &block)
+        @block_definition = BlockDefinition.new(opts, &block)
+      end
+
+      def proxy(task)
+        args = @args.clone
+        @proxy ||= begin
+          params = {}
+          @definitions.each { |definition| params[definition.name.to_s] = definition.value(args, @opts) }
+          Proxy.new(task, params, @block)
+        end
+      end
+
+      private
+      def minimum_args
+        required_count
+      end
+
+      def maximum_args
+        glob_count > 0 ? nil : (total_count - glob_count)
+      end
+
+      def required_count
+        @definitions.count {|a| a.required? }
+      end
+
+      def glob_count
+        @definitions.count {|a| a.glob? }
+      end
+
+      def total_count
+        @definitions.count
+      end
+    end
+  end
+end