crew 0.0.1

data/lib/crew/template/task.crew.erb

@@ -0,0 +1,17 @@
+desc "Describe your task"
+
+# arg "name"
+
+verify do
+  # verify your task here
+end
+
+run do
+  # specify what gets run
+end
+
+test do
+  # describe how you'd test it
+  #
+  # run!
+end

data/lib/crew/tester.rb

@@ -0,0 +1,67 @@
+module Crew
+  class Tester
+    include Util
+
+    attr_accessor :hints
+
+    def initialize(home, name, &blk)
+      @name = name
+      @home = home
+      @context_name = "#{@name}_test"
+      @preparers = {}
+      DSL.new(self).load(&blk)
+    end
+
+    def context(name, &blk)
+      if name
+        @context_name = name
+      else
+        @home.add_context @context_name, &blk
+      end
+    end
+
+    def run(opts)
+      return if opts[:context_name] && @name != opts[:context_name]
+
+      prepare(opts[:force_prepare])
+
+      task_count = 0
+      test_results = {}
+
+      @home.each_task do |task|
+        next unless opts[:test_name].nil? or opts[:test_name] == task.name
+
+        preparer = @preparers.values.find {|p| p.match?(task.name)}
+        raise "couldn't find preparer for task `#{task.name}'" unless preparer
+
+        @home.in_context(@context_name) do
+          @home.setup_mode = true
+          @home.context.snapshot_name = preparer.name
+          task.context = @home.context
+          task.test!(self, opts) do |result|
+            display_result result
+          end
+        end
+      end
+    end
+
+    def add_preparer(name, &blk)
+      @preparers[name] = Preparer.new(name)
+      @preparers[name].load(&blk)
+    end
+
+    private
+    def display_result(result)
+      logger.log "Result was #{result.status} for #{result.task_name}##{result.index} [#{result.context_name}]"
+    end
+
+    def prepare(force = false)
+      @home.in_context(@context_name) do
+        @preparers.each do |name, preparer|
+          raise "nooO! #{name}" unless preparer.setup
+          @home.context.prepare_snapshot(name, force, &preparer.setup)
+        end
+      end
+    end
+  end
+end

data/lib/crew/tester/dsl.rb

@@ -0,0 +1,25 @@
+module Crew
+  class Tester
+    class DSL
+      def initialize(tester)
+        @tester = tester
+      end
+
+      def load(&blk)
+        instance_eval(&blk)
+      end
+
+      def context(name, &blk)
+        @tester.context(name, &blk)
+      end
+
+      def hints(*hints)
+        @tester.hints = hints
+      end
+
+      def prepare(name, &blk)
+        @tester.add_preparer(name, &blk)
+      end
+    end
+  end
+end

data/lib/crew/tester/preparer.rb

@@ -0,0 +1,32 @@
+module Crew
+  class Tester
+    class Preparer
+
+      attr_reader :name
+      attr_accessor :setup
+
+      def initialize(name)
+        @name = name
+        @includes = []
+        @excludes = []
+      end
+
+      def load(&blk)
+        DSL.new(self).load(&blk)
+      end
+
+      def match?(name)
+        included = @includes.any? { |inc| inc == :all or inc === name }
+        included and !@excludes.any? { |exl| exl === name }
+      end
+
+      def add_include(inc)
+        @includes << inc
+      end
+
+      def add_exclude(exl)
+        @excludes << exl
+      end
+    end
+  end
+end

data/lib/crew/tester/preparer/dsl.rb

@@ -0,0 +1,32 @@
+module Crew
+  class Tester
+    class Preparer
+      class DSL
+
+        def initialize(preparer)
+          @preparer = preparer
+        end
+
+        def load(&blk)
+          instance_eval(&blk)
+        end
+
+        def setup(&blk)
+          @preparer.setup = blk
+        end
+
+        def include(*includes)
+          includes.each do |inc|
+            @preparer.add_include(inc)
+          end
+        end
+
+        def exclude(*excludes)
+          excludes.each do |exl|
+            @preparer.add_exclude(exl)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/crew/util.rb

@@ -0,0 +1,70 @@
+require 'shellwords'
+
+module Crew
+  class AssertionError < RuntimeError
+  end
+
+  module Util
+    def assert(value, message = nil)
+      value or begin
+        message ||= "expected #{value.inspect} to be true at #{caller.first}"
+        raise AssertionError, message
+      end
+    end
+
+    def retryable(opts = {})
+      intervals = 10.times.map { 0.1 }.to_a
+      timeout = opts[:timeout]
+      max = opts[:max] || 1.0
+      out = nil
+      begin
+        Timeout::timeout(max) do
+          begin
+            Timeout::timeout(timeout) { out = yield }
+          end
+        end
+      rescue
+        if intervals.empty?
+          raise
+        else
+          sleep intervals.shift
+          retry
+        end
+      end
+      out
+    end
+
+    def logger
+      @home ? @home.logger : @logger
+    end
+
+    def poll(name, opts = {})
+      interval = opts[:interval] || 1
+      timeout = opts[:timeout]
+      spinner = logger.spinner(name)
+      val = nil
+      begin
+        logger.muted do
+          Timeout::timeout(timeout) do
+            begin
+              val = yield
+            rescue
+              spinner[false]
+              sleep interval
+              retry
+            else
+              spinner[true]
+            end
+          end
+        end
+      rescue Timeout::Error
+        assert false, "timeout of #{timeout} exceeded"
+      end
+      val
+    end
+
+    def escape(*words)
+      Shellwords.shelljoin(words)
+    end
+  end
+end

data/lib/crew/version.rb

@@ -0,0 +1,3 @@
+module Crew
+  VERSION = "0.0.1"
+end

data/spec/cli_spec.rb

@@ -0,0 +1,149 @@
+# TODO, ulimately re-implement
+
+# describe "Crew::CLI" do
+#   describe "help" do
+#     it "should run by default" do
+#       cli.expects(:help)
+#       cli.process([])
+#     end
+#
+#     it "should run when called" do
+#       cli.expects(:help)
+#       cli.process(%w(help))
+#     end
+#   end
+#
+#   describe "init" do
+#     it "should run" do
+#       Crew::Home.expects(:init)
+#       cli.process(%w(init))
+#     end
+#
+#     it "should run with force" do
+#       Crew::Home.expects(:init).with(has_entries(force: true))
+#       cli.process(%w(init -f))
+#     end
+#   end
+#
+#   describe "docs" do
+#     it "should run" do
+#       Crew::Home.any_instance.expects(:docs)
+#       cli.process(%w(docs))
+#     end
+#   end
+#
+#   describe "list" do
+#     it "should run" do
+#       Crew::Home.any_instance.expects(:list).at_least_once
+#       cli.process(%w(list))
+#     end
+#   end
+#
+#   describe "available" do
+#     it "should run" do
+#       Crew::Home.any_instance.expects(:available)
+#       cli.process(%w(available))
+#     end
+#   end
+#
+#   # TODO, this should be re-added
+#   # describe "contexts" do
+#   #  it "should run" do
+#   #    cli = Crew::CLI.new
+#   #    Crew::Home.any_instance.expects(:contexts).returns([])
+#   #    cli.process(%w(contexts))
+#   #  end
+#   # end
+#
+#   describe "update" do
+#     it "should run" do
+#       Crew::Home.any_instance.expects(:update).with("task")
+#       cli.process(%w(update task))
+#     end
+#   end
+#
+#   describe "diff" do
+#     it "should for all tasks" do
+#       Crew::Home.any_instance.expects(:diff)
+#       cli.process(%w(diff))
+#     end
+#   end
+#
+#   describe "install" do
+#     it "should run" do
+#       Crew::Home.any_instance.expects(:install).with("task")
+#       cli.process(%w(install task))
+#     end
+#   end
+#
+#   describe "uninstall" do
+#     it "should run" do
+#       Crew::Home.any_instance.expects(:uninstall).with("task")
+#       cli.process(%w(uninstall task))
+#     end
+#   end
+#
+#   describe "edit" do
+#     it "should run" do
+#       Crew::Home.any_instance.expects(:edit).with("task")
+#       cli.process(%w(edit task))
+#     end
+#   end
+#
+#   describe "info" do
+#     it "should run" do
+#       Crew::Home.any_instance.expects(:info).with("task")
+#       cli.process(%w(info task))
+#     end
+#   end
+#
+#   describe "shell" do
+#     it "should run" do
+#       Crew::Home.any_instance.expects(:shell)
+#       cli.process(%w(shell))
+#     end
+#
+#     it "should run with context" do
+#       stub = Crew::Home.any_instance
+#       stub.expects(:shell).with("blah")
+#       stub.expects(:setup_mode=).with(false)
+#       cli.process(%w(shell -c blah))
+#     end
+#
+#     it "should run with setup mode" do
+#       stub = Crew::Home.any_instance
+#       stub.expects(:shell)
+#       stub.expects(:setup_mode=).with(true)
+#       cli.process(%w(shell -s))
+#     end
+#   end
+#
+#   describe "run" do
+#     it "should run" do
+#       Crew::Home.any_instance.expects(:run).with(nil, "command")
+#       cli.process(%w(run command))
+#     end
+#
+#     it "should run with context" do
+#       stub = Crew::Home.any_instance
+#       stub.expects(:run).with("blah", "command")
+#       stub.expects(:setup_mode=).with(false)
+#       cli.process(%w(run command -c blah))
+#     end
+#
+#     it "should run with setup mode" do
+#       stub = Crew::Home.any_instance
+#       stub.expects(:run).with(nil, "command")
+#       stub.expects(:setup_mode=).with(true)
+#       cli.process(%w(run command -s))
+#     end
+#   end
+#
+#   describe "test" do
+#     it "should test" do
+#       Crew::Home.any_instance.expects(:test).with(force: false, help: false).returns([0,0])
+#       cli.process(%w(test))
+#     end
+#   end
+# end
+#

data/spec/context_spec.rb

@@ -0,0 +1,47 @@
+describe "Crew::Context" do
+  it "should dispatch a task" do
+    task("simple2") do
+      run do
+        "simple2"
+      end
+    end
+
+    task_s2 = task("simple") do
+      run do
+        simple2
+      end
+    end
+    assert_equal "simple2", task_s2.run!
+  end
+
+  describe "with a hinted task" do
+    before do
+      context.load do
+        task "simple2" do
+          run do
+            "simple2"
+          end
+
+          run :osx do
+            "simple2 osx"
+          end
+        end
+
+        task("simple") do
+          run do
+            simple2
+          end
+        end
+      end
+    end
+
+    it "should dispatch a hinted task" do
+      assert_equal "simple2", context.task("simple").run!
+    end
+
+    it "should dispatch a hinted task" do
+      context.load { hint 'osx' }
+      assert_equal "simple2 osx", context.task("simple").run!
+    end
+  end
+end