engineyard 0.2.7

data/lib/vendor/thor/util.rb

@@ -0,0 +1,230 @@
+require 'rbconfig'
+
+class Thor
+  module Sandbox #:nodoc:
+  end
+
+  # This module holds several utilities:
+  #
+  # 1) Methods to convert thor namespaces to constants and vice-versa.
+  #
+  #   Thor::Utils.namespace_from_thor_class(Foo::Bar::Baz) #=> "foo:bar:baz"
+  #
+  # 2) Loading thor files and sandboxing:
+  #
+  #   Thor::Utils.load_thorfile("~/.thor/foo")
+  #
+  module Util
+
+    # Receives a namespace and search for it in the Thor::Base subclasses.
+    #
+    # ==== Parameters
+    # namespace<String>:: The namespace to search for.
+    #
+    def self.find_by_namespace(namespace)
+      namespace = "default#{namespace}" if namespace.empty? || namespace =~ /^:/
+      Thor::Base.subclasses.find { |klass| klass.namespace == namespace }
+    end
+
+    # Receives a constant and converts it to a Thor namespace. Since Thor tasks
+    # can be added to a sandbox, this method is also responsable for removing
+    # the sandbox namespace.
+    #
+    # This method should not be used in general because it's used to deal with
+    # older versions of Thor. On current versions, if you need to get the
+    # namespace from a class, just call namespace on it.
+    #
+    # ==== Parameters
+    # constant<Object>:: The constant to be converted to the thor path.
+    #
+    # ==== Returns
+    # String:: If we receive Foo::Bar::Baz it returns "foo:bar:baz"
+    #
+    def self.namespace_from_thor_class(constant)
+      constant = constant.to_s.gsub(/^Thor::Sandbox::/, "")
+      constant = snake_case(constant).squeeze(":")
+      constant
+    end
+
+    # Given the contents, evaluate it inside the sandbox and returns the
+    # namespaces defined in the sandbox.
+    #
+    # ==== Parameters
+    # contents<String>
+    #
+    # ==== Returns
+    # Array[Object]
+    #
+    def self.namespaces_in_content(contents, file=__FILE__)
+      old_constants = Thor::Base.subclasses.dup
+      Thor::Base.subclasses.clear
+
+      load_thorfile(file, contents)
+
+      new_constants = Thor::Base.subclasses.dup
+      Thor::Base.subclasses.replace(old_constants)
+
+      new_constants.map!{ |c| c.namespace }
+      new_constants.compact!
+      new_constants
+    end
+
+    # Returns the thor classes declared inside the given class.
+    #
+    def self.thor_classes_in(klass)
+      stringfied_constants = klass.constants.map { |c| c.to_s }
+      Thor::Base.subclasses.select do |subclass|
+        next unless subclass.name
+        stringfied_constants.include?(subclass.name.gsub("#{klass.name}::", ''))
+      end
+    end
+
+    # Receives a string and convert it to snake case. SnakeCase returns snake_case.
+    #
+    # ==== Parameters
+    # String
+    #
+    # ==== Returns
+    # String
+    #
+    def self.snake_case(str)
+      return str.downcase if str =~ /^[A-Z_]+$/
+      str.gsub(/\B[A-Z]/, '_\&').squeeze('_') =~ /_*(.*)/
+      return $+.downcase
+    end
+
+    # Receives a string and convert it to camel case. camel_case returns CamelCase.
+    #
+    # ==== Parameters
+    # String
+    #
+    # ==== Returns
+    # String
+    #
+    def self.camel_case(str)
+      return str if str !~ /_/ && str =~ /[A-Z]+.*/
+      str.split('_').map { |i| i.capitalize }.join
+    end
+
+    # Receives a namespace and tries to retrieve a Thor or Thor::Group class
+    # from it. It first searches for a class using the all the given namespace,
+    # if it's not found, removes the highest entry and searches for the class
+    # again. If found, returns the highest entry as the class name.
+    #
+    # ==== Examples
+    #
+    #   class Foo::Bar < Thor
+    #     def baz
+    #     end
+    #   end
+    #
+    #   class Baz::Foo < Thor::Group
+    #   end
+    #
+    #   Thor::Util.namespace_to_thor_class("foo:bar")     #=> Foo::Bar, nil # will invoke default task
+    #   Thor::Util.namespace_to_thor_class("baz:foo")     #=> Baz::Foo, nil
+    #   Thor::Util.namespace_to_thor_class("foo:bar:baz") #=> Foo::Bar, "baz"
+    #
+    # ==== Parameters
+    # namespace<String>
+    #
+    def self.find_class_and_task_by_namespace(namespace)
+      if namespace.include?(?:)
+        pieces = namespace.split(":")
+        task   = pieces.pop
+        klass  = Thor::Util.find_by_namespace(pieces.join(":"))
+      end
+
+      unless klass
+        klass, task = Thor::Util.find_by_namespace(namespace), nil
+      end
+
+      return klass, task
+    end
+
+    # The same as namespace_to_thor_class_and_task!, but raises an error if a klass
+    # could not be found.
+    def self.find_class_and_task_by_namespace!(namespace)
+      klass, task = find_class_and_task_by_namespace(namespace)
+      raise Error, "Could not find namespace or task #{namespace.inspect}." unless klass
+      return klass, task
+    end
+
+    # Receives a path and load the thor file in the path. The file is evaluated
+    # inside the sandbox to avoid namespacing conflicts.
+    #
+    def self.load_thorfile(path, content=nil)
+      content ||= File.binread(path)
+
+      begin
+        Thor::Sandbox.class_eval(content, path)
+      rescue Exception => e
+        $stderr.puts "WARNING: unable to load thorfile #{path.inspect}: #{e.message}"
+      end
+    end
+
+    def self.user_home
+      @@user_home ||= if ENV["HOME"]
+        ENV["HOME"]
+      elsif ENV["USERPROFILE"]
+        ENV["USERPROFILE"]
+      elsif ENV["HOMEDRIVE"] && ENV["HOMEPATH"]
+        File.join(ENV["HOMEDRIVE"], ENV["HOMEPATH"])
+      elsif ENV["APPDATA"]
+        ENV["APPDATA"]
+      else
+        begin
+          File.expand_path("~")
+        rescue
+          if File::ALT_SEPARATOR
+            "C:/"
+          else
+            "/"
+          end
+        end
+      end
+    end
+
+    # Returns the root where thor files are located, dependending on the OS.
+    #
+    def self.thor_root
+      File.join(user_home, ".thor").gsub(/\\/, '/')
+    end
+
+    # Returns the files in the thor root. On Windows thor_root will be something
+    # like this:
+    #
+    #   C:\Documents and Settings\james\.thor
+    #
+    # If we don't #gsub the \ character, Dir.glob will fail.
+    #
+    def self.thor_root_glob
+      files = Dir["#{thor_root}/*"]
+
+      files.map! do |file|
+        File.directory?(file) ? File.join(file, "main.thor") : file
+      end
+    end
+
+    # Where to look for Thor files.
+    #
+    def self.globs_for(path)
+      ["#{path}/Thorfile", "#{path}/*.thor", "#{path}/tasks/*.thor", "#{path}/lib/tasks/*.thor"]
+    end
+
+    # Return the path to the ruby interpreter taking into account multiple
+    # installations and windows extensions.
+    #
+    def self.ruby_command
+      @ruby_command ||= begin
+        ruby = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+        ruby << Config::CONFIG['EXEEXT']
+
+        # escape string in case path to ruby executable contain spaces.
+        ruby.sub!(/.*\s.*/m, '"\&"')
+        ruby
+      end
+    end
+
+  end
+end

data/lib/vendor/thor/version.rb

@@ -0,0 +1,3 @@
+class Thor
+  VERSION = "0.13.4".freeze
+end

data/spec/engineyard/api_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe EY::API do
+  it "gets the api token from ~/.eyrc if possible" do
+    write_config({"api_token" => "asdf"}, '~/.eyrc')
+    EY::API.new.should == EY::API.new("asdf")
+  end
+
+  context "fetching the token from EY cloud" do
+    before(:each) do
+      FakeWeb.register_uri(:post, "https://cloud.engineyard.com/api/v2/authenticate", :body => %|{"api_token": "asdf"}|)
+      @token = EY::API.fetch_token("a@b.com", "foo")
+    end
+
+    it "returns an EY::API" do
+      @token.should == "asdf"
+    end
+
+    it "puts the api token into .eyrc" do
+      load_config('~/.eyrc')["api_token"].should == "asdf"
+    end
+  end
+
+  describe "saving the token" do
+    context "without a custom endpoint" do
+      it "saves the api token at the root of the data" do
+        EY::API.save_token("asdf")
+        load_config('~/.eyrc')["api_token"].should == "asdf"
+      end
+    end
+
+    context "with a custom endpoint" do
+      before do
+        write_config({"endpoint" => "http://localhost/"}, 'ey.yml')
+        EY::API.save_token("asdf")
+      end
+
+      it "saves the api token" do
+        load_config('~/.eyrc').should == {"http://localhost/" => {"api_token" => "asdf"}}
+      end
+
+      it "reads the api token" do
+        EY::API.read_token.should == "asdf"
+      end
+    end
+  end
+
+  it "raises InvalidCredentials when the credentials are invalid" do
+    FakeWeb.register_uri(:post, "https://cloud.engineyard.com/api/v2/authenticate", :status => 401)
+
+    lambda {
+      EY::API.fetch_token("a@b.com", "foo")
+    }.should raise_error(EY::Error)
+  end
+
+end

data/spec/engineyard/cli/api_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'engineyard/cli'
+
+describe EY::CLI::API do
+  before(:all) do
+    EY.ui = EY::CLI::UI.new
+  end
+
+  after(:all) do
+    EY.ui = EY::UI.new
+  end
+
+  it "gets the api token from ~/.eyrc if possible" do
+    File.open(File.expand_path("~/.eyrc"), "w") do |fp|
+      YAML.dump({"api_token" => "asdf"}, fp)
+    end
+
+    EY::CLI::API.new.should == EY::CLI::API.new("asdf")
+  end
+
+  context "without saved api token" do
+    before(:each) do
+      FakeWeb.register_uri(:post, "https://cloud.engineyard.com/api/v2/authenticate", :body => %|{"api_token": "asdf"}|)
+
+      capture_stdout("\n\n") do
+        @token = EY::CLI::API.new
+      end
+    end
+
+    it "asks you for your credentials" do
+      @out.should include("Email:")
+      @out.should include("Password:")
+    end
+
+    it "gets the api token" do
+      @token.should == EY::CLI::API.new("asdf")
+    end
+
+    it "saves the api token to ~/.eyrc" do
+      YAML.load_file(File.expand_path("~/.eyrc")).should == {"api_token" => "asdf"}
+    end
+  end
+
+end

data/spec/engineyard/cli_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'engineyard/cli'
+
+describe EY::CLI do
+
+  it "sets up EY.ui" do
+    EY.ui.should be_an(EY::UI)
+    capture_stdout do
+      EY::CLI.start(["help"])
+    end
+    EY.ui.should be_an(EY::CLI::UI)
+  end
+
+  it "provides error classes" do
+    EY::CLI::EnvironmentError.should be
+    EY::CLI::BranchMismatch.should be
+    EY::CLI::DeployArgumentError.should be
+  end
+
+end # EY::CLI

data/spec/engineyard/config_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'uri'
+
+describe EY::Config do
+  describe "environments" do
+    it "get loaded from the config file" do
+      write_config("environments" => {"production" => {"default" => true}})
+      EY::Config.new.environments["production"]["default"].should be_true
+    end
+
+    it "are present when the config file has no environments key" do
+      write_config("endpoint" => "http://localhost/")
+      EY::Config.new.environments.should == {}
+    end
+  end
+
+  describe "endpoint" do
+    it "defaults to production EY Cloud" do
+      EY::Config.new.endpoint.should == EY::Config.new.default_endpoint
+    end
+
+    it "gets loaded from the config file" do
+      write_config("endpoint" => "http://localhost/")
+      EY::Config.new.endpoint.should == URI.parse("http://localhost/")
+    end
+
+    it "raises on an invalid endpoint" do
+      write_config("endpoint" => "non/absolute")
+      lambda { EY::Config.new.endpoint }.
+        should raise_error(EY::Config::ConfigurationError)
+    end
+  end
+
+  it "provides default_endpoint?" do
+    write_config("endpoint" => "http://localhost/")
+    EY::Config.new.default_endpoint?.should_not be_true
+  end
+
+  describe "files" do
+    it "looks for config/ey.yml" do
+      write_config({"endpoint" => "http://something/"}, "ey.yml")
+      write_config({"endpoint" => "http://localhost/"}, "config/ey.yml")
+      EY::Config.new.endpoint.should == URI.parse("http://localhost/")
+    end
+
+    it "looks for ey.yml" do
+      write_config({"endpoint" => "http://foo/"}, "ey.yml")
+      EY::Config.new.endpoint.should == URI.parse("http://foo/")
+    end
+
+    it "looks for the file given" do
+      write_config({"endpoint" => "http://bar/"}, "summat.yml")
+      EY::Config.new("summat.yml").endpoint.should == URI.parse("http://bar/")
+    end
+  end
+
+end

data/spec/engineyard/repo_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe EY::Repo do
+  before(:all) do
+    @path = "/tmp/ey-test/.git/"
+    @r = EY::Repo.new("/tmp/ey-test")
+  end
+
+  describe "current_branch method" do
+    it "returns the name of the current branch" do
+      set_head "ref: refs/heads/master"
+      @r.current_branch.should == "master"
+    end
+
+    it "returns nil if there is no current branch" do
+      set_head "20bf478ab6a91ec5771130aa4c8cfd3d150c4146"
+      @r.current_branch.should be_nil
+    end
+
+    def set_head(head)
+      File.open(@path+"HEAD", "w"){|f| f.write(head) }
+    end
+  end # current_branch
+
+  describe "urls method" do
+    it "returns the urls of the remotes" do
+      origin_url = "git://github.com/engineyard/engineyard.git"
+      other_url = "git@github.com:engineyard/engineyard.git"
+      set_url origin_url
+      set_url other_url, "other"
+      @r.urls.should include(origin_url)
+      @r.urls.should include(other_url)
+    end
+
+    it "returns nil if there is no origin remote" do
+      set_url nil
+      @r.urls.should be_empty
+    end
+
+    def set_url(url, remote="origin")
+      @config_path = @path+"config"
+      # This has to all shell out because FakeFS is enabled
+      if url
+        system("mkdir -p #{@path} && cd #{@path} && git init -q")
+        system("git config -f #{@config_path} remote.#{remote}.url #{url}")
+      else
+        system("rm -rf #{@config_path}")
+      end
+    end
+  end # url
+
+end # EY::Repo