trooper 0.6.0.beta → 0.6.0

data/README.md

@@ -4,39 +4,52 @@ Trooper is designed to give you the flexibility to deploy your code to any serve
 You design your deployment strategy to best fit your application and its needs. 
 Trooper comes with some built in actions that you can use in your own strategies or come up with entirely new ones.
 
-#### Please give me a try on your small project for now
-
-We have been using earlier versions of trooper were I work for the best part of 2 years, 
-but I re-wrote it for public release and so has lost a lot of its maturity.
-
 ## Installation
 
-1. Super easy! `gem install trooper` or add it to your Gemfile `gem 'trooper'`
+1. Super easy! `gem install trooper` or add it to your Gemfile `gem "trooper", "~> 0.6.0"`
 2. Pop into your terminal and run `=> trooper init`
 3. Start building you deployment strategy :)
 
 ## Usage
 
-`=> trooper deploy -e staging` or `=> trooper update`
+`=> trooper deploy -e stage` or `=> trooper update`
+
+#### Action
 
-#### Define your own strategies and actions
+An Action is a set of commands to be run in sequence, they should be small units of work. Trooper 
+comes with some build in actions but you can of course overwrite them or ignore all together. 
+Actions can also be run locally by adding the local: true option
 
 ```ruby
-action :restart_server, 'Restarting the server' do
-  run 'touch tmp/restart.txt'
-  run "echo 'Restarted'"
+action :migrate_database, 'Migrating database' do
+  cd application_path
+  rake "db:migrate RAILS_ENV=#{environment}"
 end
 
-strategy :restart, 'Restart application' do
-  actions :restart_server
+action :precompile_assets, 'Precompile assets', local: true do
+  run 'do_stuff'
+  rake "assets:precompile"
 end
+```
 
-strategy :update, 'Update the code base on the server' do
-  actions :update_repository, :install_gems
-  call :restart # call another strategy
+#### Strategy
+
+A Strategy is collection of actions to be executed in sequence, A Strategy can call other
+strategies and have prerequisites.
+
+```ruby
+strategy :deploy, "Deploy application" do
+  actions :clone_repository, :install_gems, :migrate_database
 end
 ```
 
+Once you've defined the your strategy you can call it e.g. `=> trooper my_strategy_name`
+
+#### Prerequisite
+
+A Prerequisite is a Strategy that can only run once per host
+
+
 #### Example Troopfile
 
 ```ruby
@@ -61,12 +74,18 @@ action :restart do
   run "echo 'Restarted'"
 end
 
+strategy :bootstrap, "Bootstrap application" do
+  actions :setup_trooper, :clone_repository
+end
+
 strategy :update, 'Update the code base on the server' do
+  prerequisites :bootstrap
   actions :update_repository, :install_gems
   call :restart
 end
 
 strategy :deploy, 'Full deployment to the server' do
+  prerequisites :bootstrap
   call :update
   actions :migrate_database
   call :restart

data/lib/trooper/action.rb

@@ -8,13 +8,15 @@ module Trooper
     include Trooper::DSL::Rake
     include Trooper::DSL::Bundler
 
-    attr_reader :name, :description, :config, :block
+    attr_reader :name, :description, :config, :block, :options
     attr_accessor :commands
 
     # Public: Define a new action.
     #
     # name - The name of the action.
     # description - A description of action to be used in the cli output.
+    # options - The Hash options used to refine the selection (default: {}):
+    #             :local - A boolean of whether this action should be run locally (optional).
     # block - A block containing the tasks to run in this action.
     #
     # Examples
@@ -22,8 +24,8 @@ module Trooper
     #   Action.new(:my_action, 'Does great things') { run 'touch file' }
     #
     # Returns a new action object.
-    def initialize(name, description, &block)
-      @name, @description, @config = name, description, {}
+    def initialize(name, description, options = {}, &block)
+      @name, @description, @options, @config = name, description, options, {}
       @commands, @block = [], block
     end
 
@@ -42,6 +44,22 @@ module Trooper
       commands
     end
     alias :execute :call
+
+    # Public: Modifies the commands list to include the prerequisite list checker .
+    #
+    # configuration - The configuration object to be used for block eval.
+    #
+    # Examples
+    #
+    #   @action.call(config_object) # => "..." 
+    #
+    # Returns a command String.
+    def prerequisite_call(configuration)
+      original_commands = call configuration
+      original_commands << "echo '#{self.name}' >> #{prerequisite_list}"
+      original_commands << "echo '#{self.description}'"
+      "touch #{prerequisite_list}; if grep -vz #{self.name} #{prerequisite_list}; then #{original_commands.join(' && ')}; else echo 'Already Done'; fi" 
+    end
  
     # Public: Validates the action object. (NOT WORKING)
     #
@@ -54,6 +72,18 @@ module Trooper
       true
     end
 
+    # Public: What type of action this is.
+    #
+    # Examples
+    #
+    #   @action.type # => :action
+    #   @action.type # => :local_action
+    #
+    # Returns a Symbol.
+    def type
+      options && options[:local] ? :local_action : :action
+    end
+
     # run is the base run command used by the dsl
 
     # Public: Appends command(string) to commands(array).

data/lib/trooper/arsenal.rb

@@ -2,13 +2,30 @@ module Trooper
   
   class Arsenal < Array
 
-    # find an arsenal by its name
+    # Public: Find an item in the arsenal.
+    #
+    # name - The name of the weapon object, weapon object must respond to name.
+    #
+    # Examples
+    #
+    #   Arsenal.strategies.find_by_name(:my_stratergy) # => <Strategy>
+    #   Arsenal.strategies[:my_stratergy] # => <Strategy>
+    #
+    # Returns the duplicated String.
     def find_by_name(name)
       detect { |weapon| weapon.name == name }
     end
     alias :[] :find_by_name
 
-    # add a weapon to the arsenal
+    # Public: Add a 'weapon' to the arsenal.
+    #
+    # weapon - An object that responds to a name method e.g 'weapon.name' .
+    #
+    # Examples
+    #
+    #   Arsenal.actions.add(<Action>) # => <Action>
+    #
+    # Returns the weapon passed.
     def add(weapon)
       if weapon.ok?
         remove weapon.name
@@ -17,31 +34,64 @@ module Trooper
       weapon
     end
 
-    # remove a weapon from the arsenal
+    # Public: Removes a 'weapon' from the arsenal.
+    #
+    # name - The name of the arsenal to delete.
+    #
+    # Examples
+    #
+    #   Arsenal.actions.remove(:my_action) # => [<Action>]
+    #
+    # Returns self.
     def remove(name)
       self.delete_if {|w| w.name == name}
     end
 
-    # clears arsenal
+    # Public: Clears the arsenals storage array.
+    #
+    # Examples
+    #
+    #   Arsenal.strategies.clear! # => []
+    #
+    # Returns an empty array.
     def clear!
       self.clear
     end
 
     class << self
 
-      # returns the strategies arsenal
+      # Public: Storage for the defined strategies.
+      #
+      # Examples
+      #
+      #   Arsenal.strategies # => [<Strategy>, <Strategy>]
+      #
+      # Returns the strategies arsenal.
       def strategies
         @strategies ||= new
       end
 
-      # returns the strategies arsenal
+      # Public: Storage for the defined actions.
+      #
+      # Examples
+      #
+      #   Arsenal.actions # => [<Action>, <Action>]
+      #
+      # Returns the actions arsenal.
       def actions
         @actions ||= new
       end
 
-      # clears all default arsenal
+      # Public: Clears the arsenals storage of all strategies and actions.
+      #
+      # Examples
+      #
+      #   Arsenal.reset! # => true
+      #
+      # Returns true.
       def reset!
         @strategies, @actions = nil
+        true
       end
 
     end

data/lib/trooper/config/action.rb

@@ -20,8 +20,8 @@ module Trooper
                           Actions::RollbackMigrateAction, Actions::SetupDatabaseAction, 
                           Actions::UpdateRepositoryAction]
       
-      def action(name, description = "No Description", &block)
-        action = Trooper::Action.new name, description, &block
+      def action(name, description = "No Description", options = {}, &block)
+        action = Trooper::Action.new name, description, options, &block
         Trooper::Arsenal.actions.add action
       end
 

data/lib/trooper/configuration.rb

@@ -6,6 +6,8 @@ require 'trooper/config/environment'
 require 'trooper/config/strategy'
 require 'trooper/config/defaults'
 
+require 'trooper/runner'
+
 module Trooper
   class Configuration < Hash
 
@@ -13,6 +15,13 @@ module Trooper
     include Trooper::Config::Strategy
     include Trooper::Config::Defaults
 
+    # Public: Copies the template troopfile to current dir
+    #
+    # Examples
+    #
+    #   Configuration.init # => nil
+    #
+    # Returns nil.
     def self.init
       gem_dir = File.dirname(__FILE__)
 
@@ -25,8 +34,15 @@ module Trooper
       end
     end
     
-    # initialize a new configuration object, will parse the given troopfile.
-    #   Configuration.new({:my_override => 'settings'})
+    # Public: initialize a new configuration object, will parse the given troopfile
+    #
+    # options - Default options to combine with troopfile
+    #
+    # Examples
+    #
+    #   Configuration.new({:my_override => 'settings'}) # => <Configuration>
+    #
+    # Returns a configuration object.
     def initialize(options = {})
       @loaded = false
 
@@ -34,31 +50,58 @@ module Trooper
       load_troopfile! options
     end
 
-    # returns a terminal friendly version of the configuration 
+    # Public: Terminal Friendly version of the configuration.
+    #
+    # Examples
+    #
+    #   @configuration.to_s # => '...'
+    #
+    # Returns a String.
     def to_s
       config.map {|k,v| "#{k}: #{v}" }.join("\n")
     end
 
-    # will find and execute the strategy name passed
+    # Public: Find and Execute the Strategy.
+    #
+    # strategy_name - The name of the strategy as a symbol.
+    #
+    # Examples
+    #
     #   @config.execute(:my_strategy_name)
+    #
+    # Returns boolean.
     def execute(strategy_name)
-      Arsenal.strategies[strategy_name].execute self
+      strategy = Arsenal.strategies[strategy_name]
+      Runner.new(strategy, self).execute
     end
 
-    # a way to set variables that will be available to all actions
-    #   set(:my_variable => 'sdsd') # => available as method in an action
+    # Public: Set variables that will be available to all actions.
+    #
+    # hash - A key value hash to merge with config
+    #
+    # Examples
+    #
+    #   @config.set(:my_variable => 'sdsd') # => available as method in an action
+    #
+    # Returns self.
     def set(hash)
       config.merge! hash
     end
 
-    # returns true if the troopfile was loaded
+    # Public: Check to see if troopfile is loaded.
+    #
+    # Examples
+    #
+    #   @config.loaded? # => true
+    #
+    # Returns boolean.
     def loaded?
       @loaded
     end
 
     private
 
-    def config
+    def config # :nodoc:
       self
     end
 

data/lib/trooper/host.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+
+require "net/ssh"
+require 'open3'
+
+module Trooper
+  class Host
+    
+    attr_reader :host, :user, :connection
+    
+    # Public: Initialize a new Host object.
+    #
+    # host - The String of the host location
+    # user - The String of the user name.
+    # options - The Hash of options to pass into Net::SSH
+    #           see Net::SSH for details (default: { :forward_agent => true })
+    #
+    # Examples
+    #
+    #   Host.new('my.example.com', 'admin', :forward_agent => false)
+    #
+    # Returns a Host object.
+    def initialize(host, user, options = { :forward_agent => true })
+      @host = host
+      @user = user
+      @connection = Net::SSH.start(host, user, options)
+    end
+
+    # Public: Friendly version of the object.
+    #
+    # Examples
+    #
+    #   @host.to_s # => 'foo@bar.com'
+    #
+    # Returns user@host as a String.
+    def to_s
+      "#{user}@#{host}"
+    end
+    
+    # Public: Execute a set of commands via net/ssh.
+    #
+    # command - A String or Array of command to run on a remote server
+    # options - The Hash options used to refine the selection (default: {}):
+    #             :local - Run the commands on the local machine (optional).
+    #
+    # Examples
+    #
+    #   runner.execute(['cd to/path', 'touch file']) # => ['cd to/path && touch file', :stdout, '']
+    #   runner.execute('cat file') # => ['cat file', :stdout, 'file content']
+    #   runner.execute('cat file', :local => true) # => ['cat file', :stdout, 'file content']
+    #
+    # Returns an array or raises an exception.
+    def execute(command, options = {})
+      options = {} if options == nil
+      
+      commands = parse command
+      Trooper.logger.debug commands
+      
+      if !options[:local]
+
+        connection.exec! commands do |ch, stream, data|
+          raise Trooper::StdError, "#{data}\n[ERROR INFO] #{commands}" if stream == :stderr
+          ch.wait
+          return [commands, stream, data]
+        end
+        
+      else
+
+        if commands != ''
+          begin
+            stdin, stdout, stderr = Open3.popen3(commands)
+            raise Trooper::StdError, "#{stderr.read}\n[ERROR INFO] #{commands}" if stderr.read != ''
+
+            return [commands, :stdout, stdout.read]
+          rescue Exception => e
+            raise Trooper::StdError, "#{stderr}\n[ERROR INFO] #{commands}"
+          end
+        end
+
+      end
+    end
+    
+    # Public: Close net/ssh connection.
+    #
+    # Examples
+    #
+    #   @host.close # => true
+    #
+    # Returns boolean.
+    def close
+      connection.close
+    end
+    
+    private 
+    
+    # parse command, expects a string or array
+    #   parse(['cd to/path', 'touch file']) # => 'cd to/path && touch file'
+    def parse(command)
+      case command.class.name.downcase.to_sym #Array => :array
+      when :array
+        command.compact.join(' && ')
+      when :string
+        command.chomp
+      else
+        raise Trooper::MalformedCommandError, "Command Not a String or Array: #{command.inspect}"
+      end
+    end
+    
+  end
+end

data/lib/trooper/logger.rb

@@ -47,7 +47,7 @@ module Trooper
     }
 
     def call(severity, datetime, progname, message)
-      # DEBUG < INFO < WARN < ERROR < FATAL < UNKNOWN < ACTION < SUCCESS
+      # DEBUG < INFO < WARN < ERROR < FATAL < UNKNOWN < ACTION < SUCCESS < STRATEGY
       case severity
       when "DEBUG"
         colour("#{progname} => [#{severity}] #{message}\n", :yellow)

data/lib/trooper/runner.rb

@@ -1,57 +1,102 @@
-# encoding: utf-8
-
-require "net/ssh"
-
 module Trooper
   class Runner
-    
-    attr_reader :host, :user, :connection
-    
-    # pass the host, user and any net/ssh config options
-    #   Runner.new('my.example.com', 'admin', :forward_agent => false)
-    def initialize(host, user, options = { :forward_agent => true })
-      @host = host
-      @user = user
-      @connection = Net::SSH.start(host, user, options)
+
+    attr_reader :strategy, :config, :list
+
+    # Public: initialize a new Runner.
+    #
+    # strategy - A Trooper::Strategy object to execute.
+    # config - A Trooper::Configuration object to use for deployment.
+    #
+    # Examples
+    #
+    #   Runner.new(<Strategy>, <Configuration>) # => <Runner>
+    #
+    # Returns a new Runner object.
+    def initialize(strategy, config)
+      @strategy, @config = strategy, config
+      @list = strategy.list config
     end
 
-    # returns user@host as a string
-    def to_s
-      "#{user}@#{host}"
+    # Public: Executes the strategy across mutiple hosts logging output as it goes.
+    #
+    # Examples
+    #
+    #   @runner.execute # => true
+    #
+    # Returns a boolean.
+    def execute
+      Trooper.logger.debug "Configuration\n#{config}"
+      Trooper.logger.strategy strategy.description
+      successful = nil
+      
+      hosts.each do |host|
+        begin
+          Trooper.logger.info "\e[4mRunning on #{host}\n"
+
+          list.each do |strategy_name, type, name|
+            # strategy_name, type, name
+            commands, options = build_commands strategy_name, type, name
+            runner_execute! host, commands, options if commands
+          end
+
+          successful = true
+          Trooper.logger.success "\e[4mAll Actions Completed\n"
+        rescue Exception => e
+          Trooper.logger.error "#{e.class.to_s} : #{e.message}\n\n#{e.backtrace.join("\n")}"
+
+          successful = false
+          break #stop commands running on other servers
+        ensure
+          host.close
+        end
+      end
+      
+      successful
     end
-    
-    # execute a set of commands via net/ssh, returns and array or raises an exception
-    #   runner.execute(['cd to/path', 'touch file']) # => ['cd to/path && touch file', :stdout, '']
-    #   runner.execute('cat file') # => ['cat file', :stdout, 'file content']
-    def execute(command, options = {})
-      commands = parse command
-      Trooper.logger.debug commands
-      connection.exec! commands do |ch, stream, data|
-        raise Trooper::StdError, "#{data}\n[ERROR INFO] #{commands}" if stream == :stderr
-        ch.wait
-        return [commands, stream, data]
+
+    private
+
+    # build the commands to be sent to the host object
+    def build_commands(strategy_name, type, action_name)
+      action = Arsenal.actions[action_name]
+
+      if action
+        options = action.options
+
+        case type
+        when :prerequisite
+          commands = action.prerequisite_call config 
+          Trooper.logger.action "Prerequisite: #{action.description}"
+        else
+          commands = action.call config
+          Trooper.logger.action action.description
+        end
+        
+        [commands, options]
+      else
+        raise MissingActionError, "Cant find action: #{action_name}"
       end
     end
-    
-    # close net/ssh connection
-    def close
-      connection.close
+
+    # returns an array of host objects
+    def hosts
+      @hosts ||= begin
+        r, h, u = [], (config[:hosts] rescue nil), (config[:user] rescue nil)
+        h.each {|host| r << Host.new(host, u) } if h && u; r
+      end
     end
-    
-    private 
-    
-    # parse command, expects a string or array
-    #   parse(['cd to/path', 'touch file']) # => 'cd to/path && touch file'
-    def parse(command)
-      case command.class.name.downcase.to_sym #Array => :array
-      when :array
-        command.compact.join(' && ')
-      when :string
-        command.chomp
-      else
-        raise Trooper::MalformedCommandError, "Command Not a String or Array: #{command.inspect}"
+
+    # runs the commands on a host and deals with output
+    def runner_execute!(host, commands, options = {})
+      result = host.execute commands, options
+      if result && result[1] == :stdout
+        Trooper.logger.info "#{result[2]}\n"
+        true
+      else 
+        false
       end
     end
-    
+
   end
-end
+end

data/lib/trooper/strategy.rb

@@ -1,62 +1,53 @@
-require 'trooper/runner'
+require 'trooper/host'
 
 module Trooper
   class Strategy
 
-    attr_reader :name, :description, :config, :run_list
+    attr_reader :name, :description, :config, :run_list, :prereq_run_list, :block
     
+    # Public: Initialize a new Strategy object.
+    #
+    # name - A Symbol of the strategy name
+    # description - A String of what this strategy will do.
+    # config - A Hash of config options expects a Trooper::Configuration object
+    # block - A block to be eval with the strategy object
+    #
+    # Examples
+    #
+    #   Strategy.new :my_strategy, 'Does something cool' do
+    #     actions :my_action
+    #   end
+    #
+    # Returns a Host object.
     def initialize(name, description, config = {}, &block)
       @name, @description, @config = name, description, config
-      @run_list = []
-      @block = block if block_given?
-    end
-
-    def execute(config = {})
-      @config = config
-      
-      eval_block
-
-      Trooper.logger.debug "Configuration\n#{config}"
-      Trooper.logger.strategy description
-      successful = nil
-      
-      runners.each do |runner|
-        begin
-          Trooper.logger.info "\e[4mRunning on #{runner}\n"
-
-          run_list.each do |strategy, type, name|
-            commands = build_commands strategy, type, name
-            runner_execute! runner, commands if commands
-          end
-
-          successful = true
-          Trooper.logger.success "\e[4mAll Actions Completed\n"
-        rescue Exception => e
-          Trooper.logger.error "#{e.class.to_s} : #{e.message}\n\n#{e.backtrace.join("\n")}"
-
-          successful = false
-          break #stop commands running on other servers
-        ensure
-          runner.close
-        end
-      end
-      
-      successful
-    end
-
-    def build_run_list
-      eval_block
-      run_list
+      @run_list, @prereq_run_list, @block = [], [], block
     end
 
+    # Public: Validates the strategy object. (NOT WORKING)
+    #
+    # Examples
+    #
+    #   @strategy.ok? # => true
+    #
+    # Returns true.
     def ok?
       true
     end
 
+    # Public: Add other strategies actions to the run list.
+    #
+    # strategy_names - A list of other Strategy names.
+    #
+    # Examples
+    #
+    #   @strategy.call(:my_other_strategy) # => nil
+    #
+    # Returns nil.
     def call(*strategy_names)
       [*strategy_names].each do |strategy_name|
         if Arsenal.strategies[strategy_name]
-          Arsenal.strategies[strategy_name].build_run_list.each do |action|
+          Arsenal.strategies[strategy_name].list(config).each do |action|
             # strategy_name, type, name
             @run_list << action
           end
@@ -64,75 +55,103 @@ module Trooper
       end
     end
 
+    # Public: Add other strategies actions to the prerequisite run list.
+    #
+    # strategy_names - A list of other Strategy names.
+    #
+    # Examples
+    #
+    #   @strategy.prerequisites(:my_other_strategy) # => nil
+    #
+    # Returns nil.
     def prerequisites(*strategy_names)
-      unless @run_list.detect { |a| a[2] == :prepare_prerequisite }
-        @run_list << [@name, :action, :prepare_prerequisite] 
+      if @prereq_run_list == []
+        @prereq_run_list = [[@name, :action, :prepare_prerequisite]]
       end
+
       [*strategy_names].each do |strategy_name|
         if Arsenal.strategies[strategy_name]
-          Arsenal.strategies[strategy_name].build_run_list.each do |action|
+          Arsenal.strategies[strategy_name].list(config).each do |action|
             # strategy_name, type, name
-            @run_list << [action[0], :prerequisite, action[2]]
+            @prereq_run_list << [action[0], :prerequisite, action[2]]
           end
         end  
       end
     end
 
+    # Public: Add actions to the run list.
+    #
+    # action_names - A list of Action names.
+    #
+    # Examples
+    #
+    #   @strategy.actions(:my_action) # => nil
+    #
+    # Returns nil.
     def actions(*action_names)
       [*action_names].each do |name| 
-        # strategy_name, type, name
-        @run_list << [self.name, :action, name]
+        if Arsenal.actions[name]
+          # strategy_name, type, name
+          @run_list << [self.name, Arsenal.actions[name].type, name]
+        end
       end
     end
 
-    def build_commands(strategy_name, type, action_name)
-      action = Arsenal.actions[action_name]
-
-      if action
-        commands = action.call config
+    # Public: Add an Action to the Task list but scoped to this Strategy 
+    # (Action Not available outside this object).
+    #
+    # name - The name of the action.
+    # description - A description of action to be used in the cli output.
+    # block - A block containing the tasks to run in this action.
+    #
+    # Examples
+    #
+    #   @strategy.action(:my_action, 'Does great things') { run 'touch file' }
+    #
+    # Returns an Action object.
+    def action(name, description = "No Description", &block)
+      action_name = "#{self.name}_#{name}".to_sym
+
+      action = Trooper::Action.new action_name, description, &block
+      Arsenal.actions.add action
+      actions action_name
+      
+      action
+    end
 
-        case type
-        when :prerequisite
-          commands << "echo '#{action.name}' >> #{prerequisite_list}"
-          commands << "echo '#{action.description}'"
-          commands = "touch #{prerequisite_list}; if grep -vz #{action_name} #{prerequisite_list}; then #{commands.join(' && ')}; else echo 'Already Done'; fi"    
-          Trooper.logger.action "Prerequisite: #{action.description}"
-        else
-          Trooper.logger.action action.description
-        end
-        
-        commands
-      else
-        raise MissingActionError, "Cant find action: #{action_name}"
-      end
+    # Public: The Task List.
+    #
+    # configuration - A optional Trooper::Configuration object.
+    #
+    # Examples
+    #
+    #   @strategy.list() # => [[:my_strategy, :action, :my_strategy_my_new_action]]
+    #
+    # Returns and Array of Arrays.
+    def list(configuration = {})
+      build_list(configuration) if run_list == []
+      prereq_run_list + run_list
     end
 
-    def method_missing(method_sym, *arguments, &block)
+    def method_missing(method_sym, *arguments, &block) # :nodoc:
       config[method_sym] || super
     end
 
     private
 
-    def eval_block
-      if @block
-        instance_eval &@block
-      end
+    # builds the task list by evaling the block passed on initialize
+    def build_list(configuration)
+      @config = configuration
+      eval_block(&block)
     end
 
-    def runners
-      @runners ||= begin
-        r, h, u = [], (hosts rescue nil), (user rescue nil)
-        h.each {|host| r << Runner.new(host, user) } if h && u; r
-      end
-    end
-
-    def runner_execute!(runner, commands, options = {})
-      result = runner.execute commands, options
-      if result && result[1] == :stdout
-        Trooper.logger.info "#{result[2]}\n"
-        true
-      else 
-        false
+    def eval_block(&block) # :nodoc:
+      if block_given?
+        if block.arity == 1
+          block.call self
+        else
+          instance_eval &block
+        end
       end
     end
 

data/lib/trooper/template/troopfile.rb

@@ -10,29 +10,24 @@ repository 'git@git.bar.co.uk:whatever.git'
 # Set environment specific settings and or actions   
 # env :stage do
 #   hosts 'stage.example.com', 'stage.example.com'
-#   set :my_value => 'something_else'
-
-#   action :my_action do
-#     #some action
-#   end
 # end
 
-# action :my_action do
+# action :my_action, 'Do something locally', local: true do
 #   #some action
 # end
 
-strategy :setup, 'Setting up Application on the Server' do
+strategy :bootstrap, 'Bootstraps the Application Server' do
   actions :setup_trooper, :clone_repository, :setup_database
 end
 
 strategy :update, 'Update the code base on the server' do
-  prerequisites :setup
+  prerequisites :bootstrap
   actions :update_repository, :install_gems
   call :restart
 end
 
 strategy :deploy, 'Full deployment to the server' do
-  prerequisites :setup
+  prerequisites :bootstrap
   call :update
   actions :migrate_database
   call :restart
@@ -40,4 +35,28 @@ end
 
 strategy :restart, 'Restart application' do
   actions :restart
-end
+end
+
+# Set environment specific settings and or actions   
+# env :stage do
+#   hosts 'stage.example.com', 'stage.example.com'
+#   set :my_value => 'something_else'
+
+#   action :my_action do
+#     #something different for the stage env
+#   end
+# end
+
+# action :my_action do
+#   #some action
+# end
+
+# strategy :my_strategy, 'It does something cool' do
+#   prerequisites :bootstrap
+#   actions :update_repository, :install_gems # use some built in actions
+#   #define my own action 
+#   action :my_other_action, 'Only avaliable in this strategy scope' do
+#     rake 'sometask'
+#   end
+#   call :restart
+# end

data/lib/trooper/version.rb

@@ -3,7 +3,7 @@ module Trooper
     MAJOR = 0
     MINOR = 6
     TINY  = 0
-    PRE   = 'beta'
+    PRE   = nil
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
   end
 end

data/lib/trooper.rb

@@ -23,10 +23,11 @@ module Trooper
   class StdError < TrooperError
   end
 
-  # When a command is not formed corrently arrays or strings are exceptal commands
+  # When a command is not formed corrently, arrays or strings are exceptal commands
   class MalformedCommandError < TrooperError
   end
 
+  # When a configuration file is missing
   class NoConfigurationFileError < TrooperError
   end
 

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: trooper
 version: !ruby/object:Gem::Version
-  version: 0.6.0.beta
-  prerelease: 6
+  version: 0.6.0
+  prerelease: 
 platform: ruby
 authors:
 - Richard Adams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-05 00:00:00.000000000 Z
+date: 2012-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-ssh
@@ -184,6 +184,7 @@ files:
 - lib/trooper/dsl/bundler.rb
 - lib/trooper/dsl/folders.rb
 - lib/trooper/dsl/rake.rb
+- lib/trooper/host.rb
 - lib/trooper/logger.rb
 - lib/trooper/runner.rb
 - lib/trooper/strategy.rb
@@ -208,13 +209,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2382425093214391347
+      hash: -566483630194322455
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
+      segments:
+      - 0
+      hash: -566483630194322455
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.22