engineyard-serverside 1.2.0

data/lib/vendor/thor/lib/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/lib/thor/version.rb

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

data/lib/vendor/thor/thor.gemspec

@@ -0,0 +1,120 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Thorfile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{thor}
+  s.version = "0.13.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Yehuda Katz", "Jos\303\251 Valim"]
+  s.date = %q{2010-02-17}
+  s.description = %q{A scripting framework that replaces rake, sake and rubigen}
+  s.email = %q{ruby-thor@googlegroups.com}
+  s.executables = ["thor", "rake2thor"]
+  s.extra_rdoc_files = [
+    "CHANGELOG.rdoc",
+     "LICENSE",
+     "README.rdoc",
+     "Thorfile"
+  ]
+  s.files = [
+    "CHANGELOG.rdoc",
+     "LICENSE",
+     "README.rdoc",
+     "Thorfile",
+     "bin/rake2thor",
+     "bin/thor",
+     "lib/thor.rb",
+     "lib/thor/actions.rb",
+     "lib/thor/actions/create_file.rb",
+     "lib/thor/actions/directory.rb",
+     "lib/thor/actions/empty_directory.rb",
+     "lib/thor/actions/file_manipulation.rb",
+     "lib/thor/actions/inject_into_file.rb",
+     "lib/thor/base.rb",
+     "lib/thor/core_ext/file_binary_read.rb",
+     "lib/thor/core_ext/hash_with_indifferent_access.rb",
+     "lib/thor/core_ext/ordered_hash.rb",
+     "lib/thor/error.rb",
+     "lib/thor/group.rb",
+     "lib/thor/invocation.rb",
+     "lib/thor/parser.rb",
+     "lib/thor/parser/argument.rb",
+     "lib/thor/parser/arguments.rb",
+     "lib/thor/parser/option.rb",
+     "lib/thor/parser/options.rb",
+     "lib/thor/rake_compat.rb",
+     "lib/thor/runner.rb",
+     "lib/thor/shell.rb",
+     "lib/thor/shell/basic.rb",
+     "lib/thor/shell/color.rb",
+     "lib/thor/task.rb",
+     "lib/thor/util.rb",
+     "lib/thor/version.rb"
+  ]
+  s.homepage = %q{http://yehudakatz.com}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{textmate}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{A scripting framework that replaces rake, sake and rubigen}
+  s.test_files = [
+    "spec/actions/create_file_spec.rb",
+     "spec/actions/directory_spec.rb",
+     "spec/actions/empty_directory_spec.rb",
+     "spec/actions/file_manipulation_spec.rb",
+     "spec/actions/inject_into_file_spec.rb",
+     "spec/actions_spec.rb",
+     "spec/base_spec.rb",
+     "spec/core_ext/hash_with_indifferent_access_spec.rb",
+     "spec/core_ext/ordered_hash_spec.rb",
+     "spec/fixtures/application.rb",
+     "spec/fixtures/bundle/execute.rb",
+     "spec/fixtures/doc/config.rb",
+     "spec/group_spec.rb",
+     "spec/invocation_spec.rb",
+     "spec/parser/argument_spec.rb",
+     "spec/parser/arguments_spec.rb",
+     "spec/parser/option_spec.rb",
+     "spec/parser/options_spec.rb",
+     "spec/rake_compat_spec.rb",
+     "spec/runner_spec.rb",
+     "spec/shell/basic_spec.rb",
+     "spec/shell/color_spec.rb",
+     "spec/shell_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/task_spec.rb",
+     "spec/thor_spec.rb",
+     "spec/util_spec.rb",
+     "spec/actions",
+     "spec/core_ext",
+     "spec/fixtures",
+     "spec/fixtures/bundle",
+     "spec/fixtures/bundle/main.thor",
+     "spec/fixtures/doc",
+     "spec/fixtures/doc/%file_name%.rb.tt",
+     "spec/fixtures/doc/components",
+     "spec/fixtures/doc/README",
+     "spec/fixtures/group.thor",
+     "spec/fixtures/invoke.thor",
+     "spec/fixtures/script.thor",
+     "spec/fixtures/task.thor",
+     "spec/parser",
+     "spec/sandbox",
+     "spec/shell",
+     "spec/spec.opts"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/spec/custom_deploy_spec.rb

@@ -0,0 +1,95 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "the EY::Deploy API" do
+  it "calls tasks in the right order" do
+    class TestDeploy < EY::Deploy
+      # This happens before require_custom_tasks, so it's not
+      # overrideable. That's why it's not in @call_order.
+      def update_repository_cache() end
+
+      # cheat a bit; we don't actually want to do these things
+      def require_custom_tasks() end
+      def callback(*_) end
+      def puts(*_) 'stfu' end
+
+      attr_reader :call_order
+      def initialize(*a)
+        super
+        @call_order = []
+      end
+
+      def push_code()                              @call_order << 'push_code'                              end
+      def copy_repository_cache()                  @call_order << 'copy_repository_cache'                  end
+      def create_revision_file()                   @call_order << 'create_revision_file'                   end
+      def bundle()                                 @call_order << 'bundle'                                 end
+      def symlink_configs()                        @call_order << 'symlink_configs'                        end
+      def migrate()                                @call_order << 'migrate'                                end
+      def symlink()                                @call_order << 'symlink'                                end
+      def restart()                                @call_order << 'restart'                                end
+      def cleanup_old_releases()                   @call_order << 'cleanup_old_releases'                   end
+      def conditionally_enable_maintenance_page()  @call_order << 'conditionally_enable_maintenance_page'  end
+      def disable_maintenance_page()               @call_order << 'disable_maintenance_page'               end
+    end
+
+    td = TestDeploy.new(EY::Deploy::Configuration.new)
+    td.deploy
+    td.call_order.should == %w(
+      push_code
+      copy_repository_cache
+      create_revision_file
+      bundle
+      symlink_configs
+      conditionally_enable_maintenance_page
+      migrate
+      symlink
+      restart
+      disable_maintenance_page
+      cleanup_old_releases)
+  end
+
+  describe "task overrides" do
+    class TestQuietDeploy < EY::Deploy
+      def puts(*_) 'quiet' end
+    end
+
+    before(:each) do
+      @tempdir = `mktemp -d -t custom_deploy_spec`.strip
+      @config = EY::Deploy::Configuration.new('repository_cache' => @tempdir)
+      @deploy = TestQuietDeploy.new(@config)
+    end
+
+    def write_eydeploy(relative_path, contents = "def got_new_methods() 'from the file on disk' end")
+      FileUtils.mkdir_p(File.join(
+          @tempdir,
+          File.dirname(relative_path)))
+
+      File.open(File.join(@tempdir, relative_path), 'w') do |f|
+        f.write contents
+      end
+    end
+
+    it "requires 'eydeploy.rb' and adds any defined methods to the deploy" do
+      write_eydeploy 'eydeploy.rb'
+      @deploy.require_custom_tasks.should be_true
+      @deploy.got_new_methods.should == 'from the file on disk'
+    end
+
+    it "falls back to 'config/eydeploy.rb'" do
+      write_eydeploy 'config/eydeploy.rb'
+      @deploy.require_custom_tasks.should be_true
+      @deploy.got_new_methods.should == 'from the file on disk'
+    end
+
+    it "lets you super up from any defined methods" do
+      write_eydeploy 'eydeploy.rb', "def value() super << ' + derived' end"
+
+      class TestDeploySuper < TestQuietDeploy
+        def value() 'base' end
+      end
+
+      deploy = TestDeploySuper.new(@config)
+      deploy.require_custom_tasks.should be_true
+      deploy.value.should == "base + derived"
+    end
+  end
+end