torquebox-console 0.2.5 → 0.3.0

data/vendor/bundle/ruby/1.8/gems/thor-0.17.0/lib/thor/shell/color.rb

@@ -1,144 +0,0 @@
-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 Color < Basic
-      # Embed in a String to clear all previous ANSI sequences.
-      CLEAR      = "\e[0m"
-      # The start of an ANSI bold sequence.
-      BOLD       = "\e[1m"
-
-      # Set the terminal's foreground ANSI color to black.
-      BLACK      = "\e[30m"
-      # Set the terminal's foreground ANSI color to red.
-      RED        = "\e[31m"
-      # Set the terminal's foreground ANSI color to green.
-      GREEN      = "\e[32m"
-      # Set the terminal's foreground ANSI color to yellow.
-      YELLOW     = "\e[33m"
-      # Set the terminal's foreground ANSI color to blue.
-      BLUE       = "\e[34m"
-      # Set the terminal's foreground ANSI color to magenta.
-      MAGENTA    = "\e[35m"
-      # Set the terminal's foreground ANSI color to cyan.
-      CYAN       = "\e[36m"
-      # Set the terminal's foreground ANSI color to white.
-      WHITE      = "\e[37m"
-
-      # Set the terminal's background ANSI color to black.
-      ON_BLACK   = "\e[40m"
-      # Set the terminal's background ANSI color to red.
-      ON_RED     = "\e[41m"
-      # Set the terminal's background ANSI color to green.
-      ON_GREEN   = "\e[42m"
-      # Set the terminal's background ANSI color to yellow.
-      ON_YELLOW  = "\e[43m"
-      # Set the terminal's background ANSI color to blue.
-      ON_BLUE    = "\e[44m"
-      # Set the terminal's background ANSI color to magenta.
-      ON_MAGENTA = "\e[45m"
-      # Set the terminal's background ANSI color to cyan.
-      ON_CYAN    = "\e[46m"
-      # Set the terminal's background ANSI color to white.
-      ON_WHITE   = "\e[47m"
-
-      # 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.
-      #
-      # 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
-
-        # 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/vendor/bundle/ruby/1.8/gems/thor-0.17.0/lib/thor/shell/html.rb

@@ -1,123 +0,0 @@
-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/vendor/bundle/ruby/1.8/gems/thor-0.17.0/lib/thor/task.rb

@@ -1,132 +0,0 @@
-class Thor
-  class Task < Struct.new(:name, :description, :long_description, :usage, :options)
-    FILE_REGEXP = /^#{Regexp.escape(File.dirname(__FILE__))}/
-
-    def initialize(name, description, long_description, usage, options=nil)
-      super(name.to_s, description, long_description, usage, options || {})
-    end
-
-    def initialize_copy(other) #:nodoc:
-      super(other)
-      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=[])
-      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, 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
-    # and required options into the given usage.
-    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?
-        usage.to_s.gsub(/^#{name}/) do |match|
-          match << " " << klass.arguments.map{ |a| a.usage }.compact.join(' ')
-        end
-      else
-        usage.to_s
-      end
-
-      # Add required options
-      formatted << " #{required_options}"
-
-      # Strip and go!
-      formatted.strip
-    end
-
-  protected
-
-    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
-
-    # 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 private_method?(instance)
-      !(instance.private_methods & [name.to_s, name.to_sym]).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_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/vendor/bundle/ruby/1.8/gems/thor-0.17.0/lib/thor/util.rb

@@ -1,266 +0,0 @@
-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::Util.namespace_from_thor_class(Foo::Bar::Baz) #=> "foo:bar:baz"
-  #
-  # 2) Loading thor files and sandboxing:
-  #
-  #   Thor::Util.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, 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 # look for a Thor::Group with the right name
-        klass, task = Thor::Util.find_by_namespace(namespace), nil
-      end
-      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, 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}")
-        if debug
-          $stderr.puts(*e.backtrace)
-        else
-          $stderr.puts(e.backtrace.first)
-        end
-      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, depending 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["#{escape_globs(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 = escape_globs(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_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, '"\&"')
-        ruby
-      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