engineyard-serverside 2.0.0 → 2.0.1

data/lib/vendor/thor/lib/thor/shell/color.rb

@@ -50,10 +50,46 @@ class Thor
       # on Highline implementation and it automatically appends CLEAR to the end
       # of the returned String.
       #
-      def set_color(string, color, bold=false)
-        color = self.class.const_get(color.to_s.upcase) if color.is_a?(Symbol)
-        bold  = bold ? BOLD : ""
-        "#{bold}#{color}#{string}#{CLEAR}"
+      # Pass foreground, background and bold options to this method as
+      # symbols.
+      #
+      # Example:
+      #
+      #   set_color "Hi!", :red, :on_white, :bold
+      #
+      # The available colors are:
+      #
+      #   :bold
+      #   :black
+      #   :red
+      #   :green
+      #   :yellow
+      #   :blue
+      #   :magenta
+      #   :cyan
+      #   :white
+      #   :on_black
+      #   :on_red
+      #   :on_green
+      #   :on_yellow
+      #   :on_blue
+      #   :on_magenta
+      #   :on_cyan
+      #   :on_white
+      def set_color(string, *colors)
+        if colors.all? { |color| color.is_a?(Symbol) || color.is_a?(String) }
+          ansi_colors = colors.map { |color| lookup_color(color) }
+          "#{ansi_colors.join}#{string}#{CLEAR}"
+        else
+          # The old API was `set_color(color, bold=boolean)`. We
+          # continue to support the old API because you should never
+          # break old APIs unnecessarily :P
+          foreground, bold = colors
+          foreground = self.class.const_get(foreground.to_s.upcase) if foreground.is_a?(Symbol)
+
+          bold       = bold ? BOLD : ""
+          "#{bold}#{foreground}#{string}#{CLEAR}"
+        end
       end
 
       protected

data/lib/vendor/thor/lib/thor/shell/html.rb

@@ -0,0 +1,123 @@
+require 'thor/shell/basic'
+
+class Thor
+  module Shell
+    # Inherit from Thor::Shell::Basic and add set_color behavior. Check
+    # Thor::Shell::Basic to see all available methods.
+    #
+    class HTML < Basic
+      # The start of an HTML bold sequence.
+      BOLD       = "font-weight: bold"
+
+      # Set the terminal's foreground HTML color to black.
+      BLACK      = 'color: black'
+      # Set the terminal's foreground HTML color to red.
+      RED        = 'color: red'
+      # Set the terminal's foreground HTML color to green.
+      GREEN      = 'color: green'
+      # Set the terminal's foreground HTML color to yellow.
+      YELLOW     = 'color: yellow'
+      # Set the terminal's foreground HTML color to blue.
+      BLUE       = 'color: blue'
+      # Set the terminal's foreground HTML color to magenta.
+      MAGENTA    = 'color: magenta'
+      # Set the terminal's foreground HTML color to cyan.
+      CYAN       = 'color: cyan'
+      # Set the terminal's foreground HTML color to white.
+      WHITE      = 'color: white'
+
+      # Set the terminal's background HTML color to black.
+      ON_BLACK   = 'background-color: black'
+      # Set the terminal's background HTML color to red.
+      ON_RED     = 'background-color: red'
+      # Set the terminal's background HTML color to green.
+      ON_GREEN   = 'background-color: green'
+      # Set the terminal's background HTML color to yellow.
+      ON_YELLOW  = 'background-color: yellow'
+      # Set the terminal's background HTML color to blue.
+      ON_BLUE    = 'background-color: blue'
+      # Set the terminal's background HTML color to magenta.
+      ON_MAGENTA = 'background-color: magenta'
+      # Set the terminal's background HTML color to cyan.
+      ON_CYAN    = 'background-color: cyan'
+      # Set the terminal's background HTML color to white.
+      ON_WHITE   = 'background-color: white'
+
+      # Set color by using a string or one of the defined constants. If a third
+      # option is set to true, it also adds bold to the string. This is based
+      # on Highline implementation and it automatically appends CLEAR to the end
+      # of the returned String.
+      #
+      def set_color(string, *colors)
+        if colors.all? { |color| color.is_a?(Symbol) || color.is_a?(String) }
+          html_colors = colors.map { |color| lookup_color(color) }
+          "<span style=\"#{html_colors.join("; ")};\">#{string}</span>"
+        else
+          color, bold = colors
+          html_color = self.class.const_get(color.to_s.upcase) if color.is_a?(Symbol)
+          styles = [html_color]
+          styles << BOLD if bold
+          "<span style=\"#{styles.join("; ")};\">#{string}</span>"
+        end
+      end
+
+      # Ask something to the user and receives a response.
+      #
+      # ==== Example
+      # ask("What is your name?")
+      #
+      # TODO: Implement #ask for Thor::Shell::HTML
+      def ask(statement, color=nil)
+        raise NotImplementedError, "Implement #ask for Thor::Shell::HTML"
+      end
+
+      protected
+
+        # Overwrite show_diff to show diff with colors if Diff::LCS is
+        # available.
+        #
+        def show_diff(destination, content) #:nodoc:
+          if diff_lcs_loaded? && ENV['THOR_DIFF'].nil? && ENV['RAILS_DIFF'].nil?
+            actual  = File.binread(destination).to_s.split("\n")
+            content = content.to_s.split("\n")
+
+            Diff::LCS.sdiff(actual, content).each do |diff|
+              output_diff_line(diff)
+            end
+          else
+            super
+          end
+        end
+
+        def output_diff_line(diff) #:nodoc:
+          case diff.action
+            when '-'
+              say "- #{diff.old_element.chomp}", :red, true
+            when '+'
+              say "+ #{diff.new_element.chomp}", :green, true
+            when '!'
+              say "- #{diff.old_element.chomp}", :red, true
+              say "+ #{diff.new_element.chomp}", :green, true
+            else
+              say "  #{diff.old_element.chomp}", nil, true
+          end
+        end
+
+        # Check if Diff::LCS is loaded. If it is, use it to create pretty output
+        # for diff.
+        #
+        def diff_lcs_loaded? #:nodoc:
+          return true  if defined?(Diff::LCS)
+          return @diff_lcs_loaded unless @diff_lcs_loaded.nil?
+
+          @diff_lcs_loaded = begin
+            require 'diff/lcs'
+            true
+          rescue LoadError
+            false
+          end
+        end
+
+    end
+  end
+end

data/lib/vendor/thor/lib/thor/task.rb

@@ -1,24 +1,9 @@
 class Thor
-  class Task < Struct.new(:name, :description, :usage, :options)
+  class Task < Struct.new(:name, :description, :long_description, :usage, :options)
     FILE_REGEXP = /^#{Regexp.escape(File.dirname(__FILE__))}/
 
-    # A dynamic task that handles method missing scenarios.
-    class Dynamic < Task
-      def initialize(name, options=nil)
-        super(name.to_s, "A dynamically-generated task", name.to_s, options)
-      end
-
-      def run(instance, args=[])
-        if (instance.methods & [name.to_s, name.to_sym]).empty?
-          super
-        else
-          instance.class.handle_no_task_error(name)
-        end
-      end
-    end
-
-    def initialize(name, description, usage, options=nil)
-      super(name.to_s, description, usage, options || {})
+    def initialize(name, description, long_description, usage, options=nil)
+      super(name.to_s, description, long_description, usage, options || {})
     end
 
     def initialize_copy(other) #:nodoc:
@@ -26,30 +11,43 @@ class Thor
       self.options = other.options.dup if other.options
     end
 
+    def hidden?
+      false
+    end
+
     # By default, a task invokes a method in the thor class. You can change this
     # implementation to create custom tasks.
     def run(instance, args=[])
-      public_method?(instance) ?
-        instance.send(name, *args) : instance.class.handle_no_task_error(name)
+      arity = nil
+
+      if private_method?(instance)
+        instance.class.handle_no_task_error(name)
+      elsif public_method?(instance)
+        arity = instance.method(name).arity
+        instance.send(name, *args)
+      elsif local_method?(instance, :method_missing)
+        instance.send(:method_missing, name.to_sym, *args)
+      else
+        instance.class.handle_no_task_error(name)
+      end
     rescue ArgumentError => e
       handle_argument_error?(instance, e, caller) ?
-        instance.class.handle_argument_error(self, e) : (raise e)
+        instance.class.handle_argument_error(self, e, arity) : (raise e)
     rescue NoMethodError => e
       handle_no_method_error?(instance, e, caller) ?
         instance.class.handle_no_task_error(name) : (raise e)
     end
 
-    # Returns the formatted usage by injecting given required arguments 
+    # Returns the formatted usage by injecting given required arguments
     # and required options into the given usage.
-    def formatted_usage(klass, namespace=true)
-      namespace = klass.namespace unless namespace == false
-
-      # Add namespace
-      formatted = if namespace
-        "#{namespace.gsub(/^(default|thor:runner:)/,'')}:"
-      else
-        ""
+    def formatted_usage(klass, namespace = true, subcommand = false)
+      if namespace
+        namespace = klass.namespace
+        formatted = "#{namespace.gsub(/^(default)/,'')}:"
       end
+      formatted = "#{klass.namespace.split(':').last} " if subcommand
+
+      formatted ||= ""
 
       # Add usage with required arguments
       formatted << if klass && !klass.arguments.empty?
@@ -67,36 +65,68 @@ class Thor
       formatted.strip
     end
 
-    protected
+  protected
 
-      def not_debugging?(instance)
-        !(instance.class.respond_to?(:debugging) && instance.class.debugging)
-      end
+    def not_debugging?(instance)
+      !(instance.class.respond_to?(:debugging) && instance.class.debugging)
+    end
 
-      def required_options
-        @required_options ||= options.map{ |_, o| o.usage if o.required? }.compact.sort.join(" ")
-      end
+    def required_options
+      @required_options ||= options.map{ |_, o| o.usage if o.required? }.compact.sort.join(" ")
+    end
 
-      # Given a target, checks if this class name is not a private/protected method.
-      def public_method?(instance) #:nodoc:
-        collection = instance.private_methods + instance.protected_methods
-        (collection & [name.to_s, name.to_sym]).empty?
-      end
+    # Given a target, checks if this class name is a public method.
+    def public_method?(instance) #:nodoc:
+      !(instance.public_methods & [name.to_s, name.to_sym]).empty?
+    end
 
-      def sans_backtrace(backtrace, caller) #:nodoc:
-        saned  = backtrace.reject { |frame| frame =~ FILE_REGEXP }
-        saned -= caller
-      end
+    def private_method?(instance)
+      !(instance.private_methods & [name.to_s, name.to_sym]).empty?
+    end
 
-      def handle_argument_error?(instance, error, caller)
-        not_debugging?(instance) && error.message =~ /wrong number of arguments/ &&
-          sans_backtrace(error.backtrace, caller).empty?
-      end
+    def local_method?(instance, name)
+      methods = instance.public_methods(false) + instance.private_methods(false) + instance.protected_methods(false)
+      !(methods & [name.to_s, name.to_sym]).empty?
+    end
+
+    def sans_backtrace(backtrace, caller) #:nodoc:
+      saned  = backtrace.reject { |frame| frame =~ FILE_REGEXP || (frame =~ /\.java:/ && RUBY_PLATFORM =~ /java/) }
+      saned -= caller
+    end
 
-      def handle_no_method_error?(instance, error, caller)
-        not_debugging?(instance) &&
-          error.message =~ /^undefined method `#{name}' for #{Regexp.escape(instance.to_s)}$/
+    def handle_argument_error?(instance, error, caller)
+      not_debugging?(instance) && error.message =~ /wrong number of arguments/ && begin
+        saned = sans_backtrace(error.backtrace, caller)
+        # Ruby 1.9 always include the called method in the backtrace
+        saned.empty? || (saned.size == 1 && RUBY_VERSION >= "1.9")
       end
+    end
+
+    def handle_no_method_error?(instance, error, caller)
+      not_debugging?(instance) &&
+        error.message =~ /^undefined method `#{name}' for #{Regexp.escape(instance.to_s)}$/
+    end
+  end
 
+  # A task that is hidden in help messages but still invocable.
+  class HiddenTask < Task
+    def hidden?
+      true
+    end
+  end
+
+  # A dynamic task that handles method missing scenarios.
+  class DynamicTask < Task
+    def initialize(name, options=nil)
+      super(name.to_s, "A dynamically-generated task", name.to_s, name.to_s, options)
+    end
+
+    def run(instance, args=[])
+      if (instance.methods & [name.to_s, name.to_sym]).empty?
+        super
+      else
+        instance.class.handle_no_task_error(name)
+      end
+    end
   end
 end

data/lib/vendor/thor/lib/thor/util.rb

@@ -8,11 +8,11 @@ class Thor
   #
   # 1) Methods to convert thor namespaces to constants and vice-versa.
   #
-  #   Thor::Utils.namespace_from_thor_class(Foo::Bar::Baz) #=> "foo:bar:baz"
+  #   Thor::Util.namespace_from_thor_class(Foo::Bar::Baz) #=> "foo:bar:baz"
   #
   # 2) Loading thor files and sandboxing:
   #
-  #   Thor::Utils.load_thorfile("~/.thor/foo")
+  #   Thor::Util.load_thorfile("~/.thor/foo")
   #
   module Util
 
@@ -128,38 +128,37 @@ class Thor
     # ==== Parameters
     # namespace<String>
     #
-    def self.find_class_and_task_by_namespace(namespace)
-      if namespace.include?(?:)
+    def self.find_class_and_task_by_namespace(namespace, fallback = true)
+      if namespace.include?(?:) # look for a namespaced task
         pieces = namespace.split(":")
         task   = pieces.pop
         klass  = Thor::Util.find_by_namespace(pieces.join(":"))
       end
-
-      unless klass
+      unless klass # look for a Thor::Group with the right name
         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
+      if !klass && fallback # try a task in the default namespace
+        task = namespace
+        klass = Thor::Util.find_by_namespace('')
+      end
       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)
+    def self.load_thorfile(path, content=nil, debug=false)
       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}"
+        $stderr.puts("WARNING: unable to load thorfile #{path.inspect}: #{e.message}")
+        if debug
+          $stderr.puts(*e.backtrace)
+        else
+          $stderr.puts(e.backtrace.first)
+        end
       end
     end
 
@@ -185,7 +184,7 @@ class Thor
       end
     end
 
-    # Returns the root where thor files are located, dependending on the OS.
+    # Returns the root where thor files are located, depending on the OS.
     #
     def self.thor_root
       File.join(user_home, ".thor").gsub(/\\/, '/')
@@ -199,7 +198,7 @@ class Thor
     # If we don't #gsub the \ character, Dir.glob will fail.
     #
     def self.thor_root_glob
-      files = Dir["#{thor_root}/*"]
+      files = Dir["#{escape_globs(thor_root)}/*"]
 
       files.map! do |file|
         File.directory?(file) ? File.join(file, "main.thor") : file
@@ -209,6 +208,7 @@ class Thor
     # Where to look for Thor files.
     #
     def self.globs_for(path)
+      path = escape_globs(path)
       ["#{path}/Thorfile", "#{path}/*.thor", "#{path}/tasks/*.thor", "#{path}/lib/tasks/*.thor"]
     end
 
@@ -217,8 +217,27 @@ class Thor
     #
     def self.ruby_command
       @ruby_command ||= begin
-        ruby = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
-        ruby << Config::CONFIG['EXEEXT']
+        ruby_name = RbConfig::CONFIG['ruby_install_name']
+        ruby = File.join(RbConfig::CONFIG['bindir'], ruby_name)
+        ruby << RbConfig::CONFIG['EXEEXT']
+
+        # avoid using different name than ruby (on platforms supporting links)
+        if ruby_name != 'ruby' && File.respond_to?(:readlink)
+          begin
+            alternate_ruby = File.join(RbConfig::CONFIG['bindir'], 'ruby')
+            alternate_ruby << RbConfig::CONFIG['EXEEXT']
+
+            # ruby is a symlink
+            if File.symlink? alternate_ruby
+              linked_ruby = File.readlink alternate_ruby
+
+              # symlink points to 'ruby_install_name'
+              ruby = alternate_ruby if linked_ruby == ruby_name || linked_ruby == ruby
+            end
+          rescue NotImplementedError
+            # just ignore on windows
+          end
+        end
 
         # escape string in case path to ruby executable contain spaces.
         ruby.sub!(/.*\s.*/m, '"\&"')
@@ -226,5 +245,22 @@ class Thor
       end
     end
 
+    # Returns a string that has had any glob characters escaped.
+    # The glob characters are `* ? { } [ ]`.
+    #
+    # ==== Examples
+    #
+    #   Thor::Util.escape_globs('[apps]')   # => '\[apps\]'
+    #
+    # ==== Parameters
+    # String
+    #
+    # ==== Returns
+    # String
+    #
+    def self.escape_globs(path)
+      path.to_s.gsub(/[*?{}\[\]]/, '\\\\\\&')
+    end
+
   end
 end