rango 0.1.pre → 0.1.0

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

@@ -1,78 +0,0 @@
-require 'rbconfig'
-require 'thor/shell/color'
-
-class Thor
-  module Base
-    # Returns the shell used in all Thor classes. If you are in a Unix platform
-    # it will use a colored log, otherwise it will use a basic one without color.
-    #
-    def self.shell
-      @shell ||= if Config::CONFIG['host_os'] =~ /mswin|mingw/
-        Thor::Shell::Basic
-      else
-        Thor::Shell::Color
-      end
-    end
-
-    # Sets the shell used in all Thor classes.
-    #
-    def self.shell=(klass)
-      @shell = klass
-    end
-  end
-
-  module Shell
-    SHELL_DELEGATED_METHODS = [:ask, :yes?, :no?, :say, :say_status, :print_list, :print_table]
-
-    # Add shell to initialize config values.
-    #
-    # ==== Configuration
-    # shell<Object>:: An instance of the shell to be used.
-    #
-    # ==== Examples
-    #
-    #   class MyScript < Thor
-    #     argument :first, :type => :numeric
-    #   end
-    #
-    #   MyScript.new [1.0], { :foo => :bar }, :shell => Thor::Shell::Basic.new
-    #
-    def initialize(args=[], options={}, config={})
-      super
-      self.shell = config[:shell]
-      self.shell.base ||= self if self.shell.respond_to?(:base)
-    end
-
-    # Holds the shell for the given Thor instance. If no shell is given,
-    # it gets a default shell from Thor::Base.shell.
-    #
-    def shell
-      @shell ||= Thor::Base.shell.new
-    end
-
-    # Sets the shell for this thor class.
-    #
-    def shell=(shell)
-      @shell = shell
-    end
-
-    # Common methods that are delegated to the shell.
-    #
-    SHELL_DELEGATED_METHODS.each do |method|
-      module_eval <<-METHOD, __FILE__, __LINE__
-        def #{method}(*args)
-          shell.#{method}(*args)
-        end
-      METHOD
-    end
-
-    protected
-
-      # Allow shell to be shared between invocations.
-      #
-      def _shared_configuration #:nodoc:
-        super.merge!(:shell => self.shell)
-      end
-
-  end
-end

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

@@ -1,219 +0,0 @@
-require 'tempfile'
-
-class Thor
-  module Shell
-    class Basic
-      attr_accessor :base, :padding
-
-      # Initialize base and padding to nil.
-      #
-      def initialize #:nodoc:
-        @base, @padding = nil, 0
-      end
-
-      # Sets the output padding, not allowing less than zero values.
-      #
-      def padding=(value)
-        @padding = [0, value].max
-      end
-
-      # Ask something to the user and receives a response.
-      #
-      # ==== Example
-      # ask("What is your name?")
-      #
-      def ask(statement, color=nil)
-        say("#{statement} ", color)
-        $stdin.gets.strip
-      end
-
-      # Say (print) something to the user. If the sentence ends with a whitespace
-      # or tab character, a new line is not appended (print + flush). Otherwise
-      # are passed straight to puts (behavior got from Highline).
-      #
-      # ==== Example
-      # say("I know you knew that.")
-      #
-      def say(message="", color=nil, force_new_line=(message.to_s !~ /( |\t)$/))
-        message  = message.to_s
-        message  = set_color(message, color) if color
-
-        if force_new_line
-          $stdout.puts(message)
-        else
-          $stdout.print(message)
-          $stdout.flush
-        end
-      end
-
-      # Say a status with the given color and appends the message. Since this
-      # method is used frequently by actions, it allows nil or false to be given
-      # in log_status, avoiding the message from being shown. If a Symbol is
-      # given in log_status, it's used as the color.
-      #
-      def say_status(status, message, log_status=true)
-        return if quiet? || log_status == false
-        spaces = "  " * (padding + 1)
-        color  = log_status.is_a?(Symbol) ? log_status : :green
-
-        status = status.to_s.rjust(12)
-        status = set_color status, color, true if color
-        say "#{status}#{spaces}#{message}", nil, true
-      end
-
-      # Make a question the to user and returns true if the user replies "y" or
-      # "yes".
-      #
-      def yes?(statement, color=nil)
-        ask(statement, color) =~ is?(:yes)
-      end
-
-      # Make a question the to user and returns true if the user replies "n" or
-      # "no".
-      #
-      def no?(statement, color=nil)
-        !yes?(statement, color)
-      end
-
-      # Prints a list of items.
-      #
-      # ==== Parameters
-      # list<Array[String, String, ...]>
-      #
-      # ==== Options
-      # mode:: Can be :rows or :inline. Defaults to :rows.
-      # ident:: Ident each item with the value given.
-      #
-      def print_list(list, options={})
-        return if list.empty?
-
-        ident   = " " * (options[:ident] || 0)
-        content = case options[:mode]
-          when :inline
-            last = list.pop
-            "#{list.join(", ")}, and #{last}"
-          else # rows
-            ident + list.join("\n#{ident}")
-        end
-
-        $stdout.puts content
-      end
-
-      # Prints a table.
-      #
-      # ==== Parameters
-      # Array[Array[String, String, ...]]
-      #
-      # ==== Options
-      # ident<Integer>:: Ident the first column by ident value.
-      #
-      def print_table(table, options={})
-        return if table.empty?
-
-        formats = []
-        0.upto(table.first.length - 2) do |i|
-          maxima = table.max{ |a,b| a[i].size <=> b[i].size }[i].size
-          formats << "%-#{maxima + 2}s"
-        end
-
-        formats[0] = formats[0].insert(0, " " * options[:ident]) if options[:ident]
-        formats << "%s"
-
-        table.each do |row|
-          row.each_with_index do |column, i|
-            $stdout.print formats[i] % column.to_s
-          end
-          $stdout.puts
-        end
-      end
-
-      # Deals with file collision and returns true if the file should be
-      # overwriten and false otherwise. If a block is given, it uses the block
-      # response as the content for the diff.
-      #
-      # ==== Parameters
-      # destination<String>:: the destination file to solve conflicts
-      # block<Proc>:: an optional block that returns the value to be used in diff
-      #
-      def file_collision(destination)
-        return true if @always_force
-        options = block_given? ? "[Ynaqdh]" : "[Ynaqh]"
-
-        while true
-          answer = ask %[Overwrite #{destination}? (enter "h" for help) #{options}]
-
-          case answer
-            when is?(:yes), is?(:force)
-              return true
-            when is?(:no), is?(:skip)
-              return false
-            when is?(:always)
-              return @always_force = true
-            when is?(:quit)
-              say 'Aborting...'
-              raise SystemExit
-            when is?(:diff)
-              show_diff(destination, yield) if block_given?
-              say 'Retrying...'
-            else
-              say file_collision_help
-          end
-        end
-      end
-
-      # Called if something goes wrong during the execution. This is used by Thor
-      # internally and should not be used inside your scripts. If someone went
-      # wrong, you can always raise an exception. If you raise a Thor::Error, it
-      # will be rescued and wrapped in the method below.
-      #
-      def error(statement)
-        $stderr.puts statement
-      end
-
-      # Apply color to the given string with optional bold. Disabled in the
-      # Thor::Shell::Basic class.
-      #
-      def set_color(string, color, bold=false) #:nodoc:
-        string
-      end
-
-      protected
-
-        def is?(value) #:nodoc:
-          value = value.to_s
-
-          if value.size == 1
-            /\A#{value}\z/i
-          else
-            /\A(#{value}|#{value[0,1]})\z/i
-          end
-        end
-
-        def file_collision_help #:nodoc:
-<<HELP
-Y - yes, overwrite
-n - no, do not overwrite
-a - all, overwrite this and all others
-q - quit, abort
-d - diff, show the differences between the old and the new
-h - help, show this help
-HELP
-        end
-
-        def show_diff(destination, content) #:nodoc:
-          diff_cmd = ENV['THOR_DIFF'] || ENV['RAILS_DIFF'] || 'diff -u'
-
-          Tempfile.open(File.basename(destination), File.dirname(destination)) do |temp|
-            temp.write content
-            temp.rewind
-            system %(#{diff_cmd} "#{destination}" "#{temp.path}")
-          end
-        end
-
-        def quiet? #:nodoc:
-          base && base.options[:quiet]
-        end
-
-    end
-  end
-end

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

@@ -1,108 +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.
-      #
-      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}"
-      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.read(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/thor/lib/thor/task.rb

@@ -1,122 +0,0 @@
-class Thor
-  class Task < Struct.new(:name, :description, :usage, :options)
-
-    # A dynamic task that handles method missing scenarios.
-    #
-    class Dynamic < Task
-      def initialize(name)
-        super(name.to_s, "A dynamically-generated task", name.to_s)
-      end
-
-      def run(instance, args=[])
-        unless (instance.methods & [name.to_s, name.to_sym]).empty?
-          raise Error, "could not find Thor class or task '#{name}'"
-        end
-        super
-      end
-    end
-
-    def initialize(name, description, usage, options=nil)
-      super(name.to_s, description, usage, options || {})
-    end
-
-    def initialize_copy(other) #:nodoc:
-      super(other)
-      self.options = other.options.dup if other.options
-    end
-
-    def short_description
-      description.split("\n").first if description
-    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=[])
-      raise UndefinedTaskError, "the '#{name}' task of #{instance.class} is private" unless public_method?(instance)
-      instance.send(name, *args)
-    rescue ArgumentError => e
-      parse_argument_error(instance, e, caller)
-    rescue NoMethodError => e
-      parse_no_method_error(instance, e)
-    end
-
-    # Returns the formatted usage. If a class is given, the class arguments are
-    # injected in the usage.
-    #
-    def formatted_usage(klass=nil, namespace=false, show_options=true)
-      formatted = if namespace.is_a?(String)
-        "#{namespace}:"
-      elsif klass && namespace
-        "#{klass.namespace.gsub(/^default/,'')}:"
-      else
-        ""
-      end
-
-      formatted << formatted_arguments(klass)
-      formatted << " #{formatted_options}" if show_options
-      formatted.strip!
-      formatted
-    end
-
-    # Injects the class arguments into the task usage.
-    #
-    def formatted_arguments(klass)
-      if klass && !klass.arguments.empty?
-        usage.to_s.gsub(/^#{name}/) do |match|
-          match << " " << klass.arguments.map{ |a| a.usage }.join(' ')
-        end
-      else
-        usage.to_s
-      end
-    end
-
-    # Returns the options usage for this task.
-    #
-    def formatted_options
-      @formatted_options ||= options.map{ |_, o| o.usage }.sort.join(" ")
-    end
-
-    protected
-
-      # 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
-
-      # Clean everything that comes from the Thor gempath and remove the caller.
-      #
-      def sans_backtrace(backtrace, caller) #:nodoc:
-        dirname = /^#{Regexp.escape(File.dirname(__FILE__))}/
-        saned  = backtrace.reject { |frame| frame =~ dirname }
-        saned -= caller
-      end
-
-      def parse_argument_error(instance, e, caller) #:nodoc:
-        backtrace = sans_backtrace(e.backtrace, caller)
-
-        if backtrace.empty? && e.message =~ /wrong number of arguments/
-          if instance.is_a?(Thor::Group)
-            raise e, "'#{name}' was called incorrectly. Are you sure it has arity equals to 0?"
-          else
-            raise InvocationError, "'#{name}' was called incorrectly. Call as " <<
-                                   "'#{formatted_usage(instance.class, true)}'"
-          end
-        else
-          raise e
-        end
-      end
-
-      def parse_no_method_error(instance, e) #:nodoc:
-        if e.message =~ /^undefined method `#{name}' for #{Regexp.escape(instance.to_s)}$/
-          raise UndefinedTaskError, "The #{instance.class.namespace} namespace " <<
-                                    "doesn't have a '#{name}' task"
-        else
-          raise e
-        end
-      end
-
-  end
-end