engineyard 0.2.7

data/lib/engineyard/cli/error.rb

@@ -0,0 +1,44 @@
+module EY
+  class CLI < Thor
+    class NoAppError < EY::Error
+      def initialize(repo)
+        @repo = repo
+      end
+
+      def message
+        error = [%|There is no application configured for any of the following remotes:|]
+        @repo.urls.each{|url| error << %|\t#{url}| }
+        error << %|You can add this application at #{EY.config.endpoint}|
+        error.join("\n")
+      end
+    end
+
+    class EnvironmentError < EY::Error
+    end
+
+    class NoEnvironmentError < EnvironmentError
+      def message
+        "No environment named '#{env_name}'\nYou can create one at #{EY.config.endpoint}"
+      end
+    end
+
+    class BranchMismatch < EY::Error
+      def initialize(default_branch, branch)
+        super(nil)
+        @default_branch, @branch = default_branch, branch
+      end
+
+      def message
+        %|Your deploy branch is set to "#{@default_branch}".\n| +
+          %|If you want to deploy branch "#{@branch}", use --force.|
+      end
+    end
+
+    class DeployArgumentError < EY::Error
+      def message
+        %|"deploy" was called incorrectly. Call as "deploy [ENVIRONMENT] [BRANCH]"\n| +
+          %|You can set default environments and branches in ey.yml|
+      end
+    end
+  end
+end

data/lib/engineyard/cli/ui.rb

@@ -0,0 +1,96 @@
+module EY
+  class CLI
+    class UI < Thor::Base.shell
+
+      def error(name, message = nil)
+        begin
+          orig_out, $stdout = $stdout, $stderr
+          if message
+            say_status name, message, :red
+          elsif name
+            say name, :red
+          end
+        ensure
+          $stdout = orig_out
+        end
+      end
+
+      def warn(name, message = nil)
+        if message
+          say_status name, message, :yellow
+        elsif name
+          say name, :yellow
+        end
+      end
+
+      def info(name, message = nil)
+        if message
+          say_status name, message, :green
+        elsif name
+          say name, :green
+        end
+      end
+
+      def debug(name, message = nil)
+        return unless ENV["DEBUG"]
+
+        if message
+          message = message.inspect unless message.is_a?(String)
+          say_status name, message, :blue
+        elsif name
+          name = name.inspect unless name.is_a?(String)
+          say name, :cyan
+        end
+      end
+
+      def ask(message, password = false)
+        begin
+          EY.library 'highline'
+          @hl ||= HighLine.new($stdin)
+          if not $stdin.tty?
+            @hl.ask(message)
+          elsif password
+            @hl.ask(message) {|q| q.echo = "*" }
+          else
+            @hl.ask(message) {|q| q.readline = true }
+          end
+        rescue EOFError
+          return ''
+        end
+      end
+
+      def print_envs(envs, default_env = nil)
+        printable_envs = envs.map do |e|
+          icount = e.instances_count
+          iname = (icount == 1) ? "instance" : "instances"
+
+          e.name << " (default)" if e.name == default_env
+          env = [e.name]
+          env << "#{icount} #{iname}"
+          env << e.apps.map{|a| a.name }.join(", ")
+        end
+        print_table(printable_envs, :ident => 2)
+      end
+
+      def print_exception(e)
+        if e.message.empty? || (e.message == e.class.to_s)
+          message = nil
+        else
+          message = e.message
+        end
+
+        if ENV["DEBUG"]
+          error(e.class, message)
+          e.backtrace.each{|l| say(" "*3 + l) }
+        else
+          error(message || e.class.to_s)
+        end
+      end
+
+      def set_color(string, color, bold=false)
+        $stdout.tty? ? super : string
+      end
+
+    end
+  end
+end

data/lib/engineyard/config.rb

@@ -0,0 +1,86 @@
+require 'uri'
+
+module EY
+  class Config
+    CONFIG_FILES = ["config/ey.yml", "ey.yml"]
+
+    def initialize(file = nil)
+      require 'yaml'
+      @file = file || CONFIG_FILES.find{|f| File.exists?(f) }
+      @config = @file ? YAML.load_file(@file) : {}
+      @config.merge!("environments" => {}) unless @config["environments"]
+    end
+
+    def method_missing(meth, *args, &blk)
+      key = meth.to_s.downcase
+      if @config.key?(key)
+        @config[key]
+      else
+        super
+      end
+    end
+
+    def respond_to?(meth)
+      key = meth.to_s.downcase
+      @config.key?(key) || super
+    end
+
+    def endpoint
+      @endpoint ||= env_var_endpoint ||
+        config_file_endpoint ||
+        default_endpoint
+    end
+
+    def config_file_endpoint
+      if endpoint = @config["endpoint"]
+        assert_valid_endpoint endpoint, @file
+      end
+    end
+
+    def env_var_endpoint
+      if endpoint = ENV["CLOUD_URL"]
+        assert_valid_endpoint endpoint, "CLOUD_URL"
+      end
+    end
+
+    def default_endpoint
+      URI.parse("https://cloud.engineyard.com/")
+    end
+
+    def default_endpoint?
+      default_endpoint == endpoint
+    end
+
+    def default_environment
+      d = environments.find do |name, env|
+        env["default"]
+      end
+      d && d.first
+    end
+
+    def default_branch(environment = default_environment)
+      env = environments[environment]
+      env && env["branch"]
+    end
+
+    private
+
+    def assert_valid_endpoint(endpoint, source)
+      endpoint = URI.parse(endpoint) if endpoint.is_a?(String)
+      return endpoint if endpoint.absolute?
+
+      raise ConfigurationError.new('endpoint', endpoint.to_s, source, "endpoint must be an absolute URI")
+    end
+
+    class ConfigurationError < EY::Error
+      def initialize(key, value, source, message=nil)
+        super(nil)
+        @key, @value, @source, @message = key, value, source, message
+      end
+
+      def message
+        %|"#{@key}" from #{@source} has invalid value: #{@value.inspect}#{": #{@message}" if @message}|
+      end
+    end
+  end
+end

data/lib/engineyard/repo.rb

@@ -0,0 +1,24 @@
+module EY
+  class Repo
+
+    def initialize(path=File.expand_path('.'))
+      @path = path
+    end
+
+    def current_branch
+      head = File.read(File.join(@path, ".git/HEAD")).chomp
+      if head.gsub!("ref: refs/heads/", "")
+        head
+      else
+        nil
+      end
+    end
+
+    def urls
+      `git config -f #{@path}/.git/config --get-regexp 'remote.*.url'`.split(/\n/).map do |c|
+        c.split.last
+      end
+    end
+
+  end # Repo
+end # EY

data/lib/vendor/thor.rb

@@ -0,0 +1,244 @@
+require 'thor/base'
+
+# TODO: Update thor to allow for git-style CLI (git bisect run)
+class Thor
+  class << self
+    # Sets the default task when thor is executed without an explicit task to be called.
+    #
+    # ==== Parameters
+    # meth<Symbol>:: name of the defaut task
+    #
+    def default_task(meth=nil)
+      case meth
+        when :none
+          @default_task = 'help'
+        when nil
+          @default_task ||= from_superclass(:default_task, 'help')
+        else
+          @default_task = meth.to_s
+      end
+    end
+
+    # Defines the usage and the description of the next task.
+    #
+    # ==== Parameters
+    # usage<String>
+    # description<String>
+    #
+    def desc(usage, description, options={})
+      if options[:for]
+        task = find_and_refresh_task(options[:for])
+        task.usage = usage             if usage
+        task.description = description if description
+      else
+        @usage, @desc = usage, description
+      end
+    end
+
+    # Maps an input to a task. If you define:
+    #
+    #   map "-T" => "list"
+    #
+    # Running:
+    #
+    #   thor -T
+    #
+    # Will invoke the list task.
+    #
+    # ==== Parameters
+    # Hash[String|Array => Symbol]:: Maps the string or the strings in the array to the given task.
+    #
+    def map(mappings=nil)
+      @map ||= from_superclass(:map, {})
+
+      if mappings
+        mappings.each do |key, value|
+          if key.respond_to?(:each)
+            key.each {|subkey| @map[subkey] = value}
+          else
+            @map[key] = value
+          end
+        end
+      end
+
+      @map
+    end
+
+    # Declares the options for the next task to be declared.
+    #
+    # ==== Parameters
+    # Hash[Symbol => Object]:: The hash key is the name of the option and the value
+    # is the type of the option. Can be :string, :array, :hash, :boolean, :numeric
+    # or :required (string). If you give a value, the type of the value is used.
+    #
+    def method_options(options=nil)
+      @method_options ||= {}
+      build_options(options, @method_options) if options
+      @method_options
+    end
+
+    # Adds an option to the set of method options. If :for is given as option,
+    # it allows you to change the options from a previous defined task.
+    #
+    #   def previous_task
+    #     # magic
+    #   end
+    #
+    #   method_option :foo => :bar, :for => :previous_task
+    #
+    #   def next_task
+    #     # magic
+    #   end
+    #
+    # ==== Parameters
+    # name<Symbol>:: The name of the argument.
+    # options<Hash>:: Described below.
+    #
+    # ==== Options
+    # :desc     - Description for the argument.
+    # :required - If the argument is required or not.
+    # :default  - Default value for this argument. It cannot be required and have default values.
+    # :aliases  - Aliases for this option.
+    # :type     - The type of the argument, can be :string, :hash, :array, :numeric or :boolean.
+    # :banner   - String to show on usage notes.
+    #
+    def method_option(name, options={})
+      scope = if options[:for]
+        find_and_refresh_task(options[:for]).options
+      else
+        method_options
+      end
+
+      build_option(name, options, scope)
+    end
+
+    # Parses the task and options from the given args, instantiate the class
+    # and invoke the task. This method is used when the arguments must be parsed
+    # from an array. If you are inside Ruby and want to use a Thor class, you
+    # can simply initialize it:
+    #
+    #   script = MyScript.new(args, options, config)
+    #   script.invoke(:task, first_arg, second_arg, third_arg)
+    #
+    def start(original_args=ARGV, config={})
+      super do |given_args|
+        meth = normalize_task_name(given_args.shift)
+        task = all_tasks[meth]
+
+        if task
+          args, opts = Thor::Options.split(given_args)
+          config.merge!(:task_options => task.options)
+        else
+          args, opts = given_args, {}
+        end
+
+        task ||= Thor::Task::Dynamic.new(meth)
+        trailing = args[Range.new(arguments.size, -1)]
+        new(args, opts, config).invoke(task, trailing || [])
+      end
+    end
+
+    # Prints help information for the given task.
+    #
+    # ==== Parameters
+    # shell<Thor::Shell>
+    # task_name<String>
+    #
+    def task_help(shell, task_name)
+      meth = normalize_task_name(task_name)
+      task = all_tasks[meth]
+      handle_no_task_error(meth) unless task
+
+      shell.say "Usage:"
+      shell.say "  #{banner(task)}"
+      shell.say
+      class_options_help(shell, nil => task.options.map { |_, o| o })
+      shell.say task.description
+    end
+
+    # Prints help information for this class.
+    #
+    # ==== Parameters
+    # shell<Thor::Shell>
+    #
+    def help(shell)
+      list = printable_tasks
+      Thor::Util.thor_classes_in(self).each do |klass|
+        list += klass.printable_tasks(false)
+      end
+      list.sort!{ |a,b| a[0] <=> b[0] }
+
+      shell.say "Tasks:"
+      shell.print_table(list, :ident => 2, :truncate => true)
+      shell.say
+      class_options_help(shell)
+    end
+
+    # Returns tasks ready to be printed.
+    def printable_tasks(all=true)
+      (all ? all_tasks : tasks).map do |_, task|
+        item = []
+        item << banner(task)
+        item << (task.description ? "# #{task.description.gsub(/\s+/m,' ')}" : "")
+        item
+      end
+    end
+
+    def handle_argument_error(task, error) #:nodoc:
+      raise InvocationError, "#{task.name.inspect} was called incorrectly. Call as #{task.formatted_usage(self, banner_base == "thor").inspect}."
+    end
+
+    protected
+
+      # The banner for this class. You can customize it if you are invoking the
+      # thor class by another ways which is not the Thor::Runner. It receives
+      # the task that is going to be invoked and a boolean which indicates if
+      # the namespace should be displayed as arguments.
+      #
+      def banner(task)
+        "#{banner_base} #{task.formatted_usage(self, banner_base == "thor")}"
+      end
+
+      def baseclass #:nodoc:
+        Thor
+      end
+
+      def create_task(meth) #:nodoc:
+        if @usage && @desc
+          tasks[meth.to_s] = Thor::Task.new(meth, @desc, @usage, method_options)
+          @usage, @desc, @method_options = nil
+          true
+        elsif self.all_tasks[meth.to_s] || meth.to_sym == :method_missing
+          true
+        else
+          puts "[WARNING] Attempted to create task #{meth.inspect} without usage or description. " <<
+               "Call desc if you want this method to be available as task or declare it inside a " <<
+               "no_tasks{} block. Invoked from #{caller[1].inspect}."
+          false
+        end
+      end
+
+      def initialize_added #:nodoc:
+        class_options.merge!(method_options)
+        @method_options = nil
+      end
+
+      # Receives a task name (can be nil), and try to get a map from it.
+      # If a map can't be found use the sent name or the default task.
+      #
+      def normalize_task_name(meth) #:nodoc:
+        mapping = map[meth.to_s]
+        meth = mapping || meth || default_task
+        meth.to_s.gsub('-','_') # treat foo-bar > foo_bar
+      end
+  end
+
+  include Thor::Base
+
+  map HELP_MAPPINGS => :help
+
+  desc "help [TASK]", "Describe available tasks or one specific task"
+  def help(task=nil)
+    task ? self.class.task_help(shell, task) : self.class.help(shell)
+  end
+end