baboon 1.0.9 → 1.5.5

data/lib/baboon/cli/options.rb

@@ -1,241 +0,0 @@
-require 'optparse'
-require 'baboon/version'
-
-module Baboon
-  class CLI
-    module Options
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        # Return a new CLI instance with the given arguments pre-parsed and
-        # ready for execution.
-        def parse(args)
-          cli = new(args)
-          cli.parse_options!
-          cli
-        end
-      end
-
-      # The hash of (parsed) command-line options
-      attr_reader :options
-
-      def option_parser #:nodoc:
-        @logger = Logger.new
-        @option_parser ||= OptionParser.new do |opts|
-          opts.banner = "Usage: #{File.basename($0)} [options] action ..."
-
-          opts.on("-d", "--debug",
-            "Prompts before each remote command execution."
-          ) { |value| options[:debug] = true }
-
-          opts.on("-e", "--explain TASK",
-            "Displays help (if available) for the task."
-          ) { |value| options[:explain] = value }
-
-          opts.on("-F", "--default-config",
-            "Always use default config, even with -f."
-          ) { options[:default_config] = true }
-
-          opts.on("-f", "--file FILE",
-            "A recipe file to load. May be given more than once."
-          ) { |value| options[:recipes] << value }
-
-          opts.on("-H", "--long-help", "Explain these options and environment variables.") do
-            long_help
-            exit
-          end
-
-          opts.on("-h", "--help", "Display this help message.") do
-            puts opts
-            exit
-          end
-
-					opts.on("-l", "--logger [STDERR|STDOUT|file]",
-						"Choose logger method. STDERR used by default."
-					) do |value|
-						options[:output] = if value.nil? || value.upcase == 'STDERR'
-							 # Using default logger.
-							 nil
-						 elsif value.upcase == 'STDOUT'
-							 $stdout
-						 else
-							 value
-						 end
-					end
-
-          opts.on("-n", "--dry-run",
-            "Prints out commands without running them."
-          ) { |value| options[:dry_run] = true }
-
-          opts.on("-p", "--password",
-            "Immediately prompt for the password."
-          ) { options[:password] = nil }
-
-          opts.on("-q", "--quiet",
-            "Make the output as quiet as possible."
-          ) { options[:verbose] = 0 }
-
-          opts.on("-r", "--preserve-roles",
-            "Preserve task roles"
-          ) { options[:preserve_roles] = true }
-
-          opts.on("-S", "--set-before NAME=VALUE",
-            "Set a variable before the recipes are loaded."
-          ) do |pair|
-            name, value = pair.split(/=/, 2)
-            options[:pre_vars][name.to_sym] = value
-          end
-
-          opts.on("-s", "--set NAME=VALUE",
-            "Set a variable after the recipes are loaded."
-          ) do |pair|
-            name, value = pair.split(/=/, 2)
-            options[:vars][name.to_sym] = value
-          end
-
-          opts.on("-T", "--tasks [PATTERN]",
-            "List all tasks (matching optional PATTERN) in the loaded recipe files."
-          ) do |value|
-            options[:tasks] = if value
-              value
-            else
-              true
-            end
-            options[:verbose] ||= 0
-          end
-
-          opts.on("-t", "--tool",
-            "Abbreviates the output of -T for tool integration."
-          ) { options[:tool] = true }
-
-          opts.on("-V", "--version",
-            "Display the Baboon version, and exit."
-          ) do
-            require 'baboon/version'
-            puts "Baboon v#{Baboon::Version}"
-            exit
-          end
-
-          opts.on("-v", "--verbose",
-            "Be more verbose. May be given more than once."
-          ) do
-            options[:verbose] ||= 0
-            options[:verbose] += 1
-          end
-
-          opts.on("-X", "--skip-system-config",
-            "Don't load the system config file (Baboon.configuration)"
-          ) { options.delete(:sysconf) }
-
-          opts.on("-x", "--skip-user-config",
-            "Don't load the user config file (.caprc)"
-          ) { options.delete(:dotfile) }
-        end
-      end
-
-      # If the arguments to the command are empty, this will print the
-      # allowed options and exit. Otherwise, it will parse the command
-      # line and set up any default options.
-      def parse_options! #:nodoc:
-        @options = { :recipes => [], :actions => [],
-          :vars => {}, :pre_vars => {},
-          :sysconf => default_sysconf, :dotfile => default_dotfile }
-
-        if args.empty?
-          warn "Please specify at least one action to execute."
-          warn option_parser
-          exit
-        end
-
-        option_parser.parse!(args)
-
-        coerce_variable_types!
-
-        # if no verbosity has been specified, be verbose
-        options[:verbose] = 3 if !options.has_key?(:verbose)
-
-        look_for_default_recipe_file! if options[:default_config] || options[:recipes].empty?
-        extract_environment_variables!
-
-        options[:actions].concat(args)
-
-        password = options.has_key?(:password)
-        options[:password] = Proc.new { self.class.password_prompt }
-        options[:password] = options[:password].call if password
-      end
-
-      # Extracts name=value pairs from the remaining command-line arguments
-      # and assigns them as environment variables.
-      def extract_environment_variables! #:nodoc:
-        args.delete_if do |arg|
-          next unless arg.match(/^(\w+)=(.*)$/)
-          ENV[$1] = $2
-        end
-      end
-
-      # Looks for a default recipe file in the current directory.
-      def look_for_default_recipe_file! #:nodoc:
-        current = Dir.pwd
-
-        loop do
-          %w(Capfile capfile).each do |file|
-            if File.file?(file)
-              options[:recipes] << file
-              @logger.info "Using recipes from #{File.join(current,file)}"
-              return
-            end
-          end
-
-          pwd = Dir.pwd
-          Dir.chdir("..")
-          break if pwd == Dir.pwd # if changing the directory made no difference, then we're at the top
-        end
-
-        Dir.chdir(current)
-      end
-
-      def default_sysconf #:nodoc:
-        File.join(sysconf_directory, "Baboon.configuration")
-      end
-
-      def default_dotfile #:nodoc:
-        File.join(home_directory, ".caprc")
-      end
-
-      def sysconf_directory #:nodoc:
-        # TODO if anyone cares, feel free to submit a patch that uses a more
-        # appropriate location for this file in Windows.
-        ENV["SystemRoot"] || '/etc'
-      end
-
-      def home_directory #:nodoc:
-        ENV["HOME"] ||
-          (ENV["HOMEPATH"] && "#{ENV["HOMEDRIVE"]}#{ENV["HOMEPATH"]}") ||
-          "/"
-      end
-
-      def coerce_variable_types!
-        [:pre_vars, :vars].each do |collection|
-          options[collection].keys.each do |key|
-            options[collection][key] = coerce_variable(options[collection][key])
-          end
-        end
-      end
-
-      def coerce_variable(value)
-        case value
-        when /^"(.*)"$/ then $1
-        when /^'(.*)'$/ then $1
-        when /^\d+$/ then value.to_i
-        when /^\d+\.\d*$/ then value.to_f
-        when "true" then true
-        when "false" then false
-        when "nil" then nil
-        else value
-        end
-      end
-    end
-  end
-end

data/lib/baboon/configuration.rb

@@ -1,38 +0,0 @@
-require 'baboon'
-
-module Baboon
-  # Baboon.configuration => output of configuration options
-  class << self
-    attr_accessor :configuration
-  end
-
-  # This method should be called with a block, even though none are given
-  # in the parameters of the method
-  def self.configure
-    self.configuration ||= Configuration.new
-    yield configuration
-  end
-
-  class Configuration
-    def initialize
-      # Cannot call attr inside of class, need to class_eval it
-      class << self
-        self
-      end.class_eval do
-        # Define all of the attributes
-        BABOON_CONFIGURATION_OPTIONS.each do |name|
-          attr_accessor name
-
-          # For each given symbol we generate accessor method that sets option's
-          # value being called with an argument, or returns option's current value
-          # when called without arguments
-          define_method name do |*values|
-            value = values.first
-            value ? self.send("#{name}=", value) : instance_variable_get("@#{name}")
-          end
-        end
-      end
-      # Initialize defaults
-    end # initialize
-  end # class Configuration
-end # module Baboon

data/lib/baboon/logger.rb

@@ -1,153 +0,0 @@
-module Baboon
-  class Logger 
-    attr_accessor :level, :device, :disable_formatters
-
-    IMPORTANT = 0
-    INFO      = 1
-    DEBUG     = 2
-    TRACE     = 3
-
-    MAX_LEVEL = 3
-
-    COLORS = {
-      :none     => "0",
-      :black    => "30",
-      :red      => "31",
-      :green    => "32",
-      :yellow   => "33",
-      :blue     => "34",
-      :magenta  => "35",
-      :cyan     => "36",
-      :white    => "37"
-    }
-
-    STYLES = {
-      :bright     => 1,
-      :dim        => 2,
-      :underscore => 4,
-      :blink      => 5,
-      :reverse    => 7,
-      :hidden     => 8
-    }
-
-    # Set up default formatters
-    @formatters = [
-      # TRACE
-      { :match => /command finished/,          :color => :white,   :style => :dim, :level => 3, :priority => -10 },
-      { :match => /executing locally/,         :color => :yellow,  :level => 3, :priority => -20 },
-
-      # DEBUG
-      { :match => /executing `.*/,             :color => :green,   :level => 2, :priority => -10, :timestamp => true },
-      { :match => /.*/,                        :color => :yellow,  :level => 2, :priority => -30 },
-
-      # INFO
-      { :match => /.*out\] (fatal:|ERROR:).*/, :color => :red,     :level => 1, :priority => -10 },
-      { :match => /Permission denied/,         :color => :red,     :level => 1, :priority => -20 },
-      { :match => /sh: .+: command not found/, :color => :magenta, :level => 1, :priority => -30 },
-
-      # IMPORTANT
-      { :match => /^err ::/,                   :color => :red,     :level => 0, :priority => -10 },
-      { :match => /.*/,                        :color => :blue,    :level => 0, :priority => -20 }
-    ]
-
-    class << self
-      def add_formatter(options) #:nodoc:
-        @formatters.push(options)
-        @sorted_formatters = nil
-      end
-
-      def sorted_formatters
-        # Sort matchers in reverse order so we can break if we found a match.
-        @sorted_formatters ||= @formatters.sort_by { |i| -(i[:priority] || i[:prio] || 0) }
-      end
-    end
-
-    def initialize(options={})
-      output = options[:output] || $stderr
-      if output.respond_to?(:puts)
-        @device = output
-      else
-        @device = File.open(output.to_str, "a")
-        @needs_close = true
-      end
-
-      @options = options
-      @level = options[:level] || 0
-      @disable_formatters = options[:disable_formatters]
-    end
-
-    def close
-      device.close if @needs_close
-    end
-
-    def log(level, message, line_prefix=nil)
-      if level <= self.level
-        # Only format output if device is a TTY or formatters are not disabled
-        if device.tty? && !@disable_formatters
-          color = :none
-          style = nil
-
-          Logger.sorted_formatters.each do |formatter|
-            if (formatter[:level] == level || formatter[:level].nil?)
-              if message =~ formatter[:match] || line_prefix =~ formatter[:match]
-                color = formatter[:color] if formatter[:color]
-                style = formatter[:style] || formatter[:attribute] # (support original cap colors)
-                message.gsub!(formatter[:match], formatter[:replace]) if formatter[:replace]
-                message = formatter[:prepend] + message unless formatter[:prepend].nil?
-                message = message + formatter[:append] unless formatter[:append].nil?
-                message = Time.now.strftime('%Y-%m-%d %T') + ' ' + message if formatter[:timestamp]
-                break unless formatter[:replace]
-              end
-            end
-          end
-
-          if color == :hide
-            # Don't do anything if color is set to :hide
-            return false
-          end
-
-          term_color = COLORS[color]
-          term_style = STYLES[style]
-
-          # Don't format message if no color or style
-          unless color == :none and style.nil?
-            unless line_prefix.nil?
-              line_prefix = format(line_prefix, term_color, term_style, nil)
-            end
-            message = format(message, term_color, term_style)
-          end
-        end
-
-        indent = "%*s" % [MAX_LEVEL, "*" * (MAX_LEVEL - level)]
-        (RUBY_VERSION >= "1.9" ? message.lines : message).each do |line|
-          if line_prefix
-            device.puts "#{indent} [#{line_prefix}] #{line.strip}\n"
-          else
-            device.puts "#{indent} #{line.strip}\n"
-          end
-        end
-      end
-    end
-
-    def important(message, line_prefix=nil)
-      log(IMPORTANT, message, line_prefix)
-    end
-
-    def info(message, line_prefix=nil)
-      log(INFO, message, line_prefix)
-    end
-
-    def debug(message, line_prefix=nil)
-      log(DEBUG, message, line_prefix)
-    end
-
-    def trace(message, line_prefix=nil)
-      log(TRACE, message, line_prefix)
-    end
-
-    def format(message, color, style, nl = "\n")
-      style = "#{style};" if style
-      "\e[#{style}#{color}m" + message.to_s.strip + "\e[0m#{nl}"
-    end
-  end
-end

data/lib/generators/baboon/config/config_generator.rb

@@ -1,17 +0,0 @@
-require 'rails/generators/base'
-
-module Baboon
-  module Generators
-    class ConfigGenerator < Rails::Generators::Base
-      desc 'Creates a yaml for Baboon at config/baboon.yml'
-
-      def self.source_root
-        @source_root ||= File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
-      end
-
-      def create_initializer_file
-        template "baboon.yml", "config/baboon.yml"
-      end
-    end
-  end
-end