josevalim-thor 0.10.0

data/lib/thor/shell/basic.rb

@@ -0,0 +1,198 @@
+require 'tempfile'
+
+class Thor
+  module Shell
+    class Basic
+      attr_accessor :base
+
+      # 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(statement="", color=nil)
+        statement = statement.to_s
+
+        if statement[-1, 1] == " " || statement[-1, 1] == "\t"
+          $stdout.print(statement)
+          $stdout.flush
+        else
+          $stdout.puts(statement)
+        end
+      end
+
+      # Say a status with the given color and appends the message.
+      # It does not show the status if the base is set to quiet.
+      #
+      def say_status(status, message, color=nil)
+        return if base && base.options[:quiet]
+
+        status_flag = "[#{status.to_s.upcase}]".rjust(12)
+        say "#{status_flag} #{message}"
+      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, ...]>
+      # mode<Symbol>:: Can be :rows or :inline. Defaults to :rows.
+      #
+      def print_list(list, mode=:rows)
+        return if list.empty?
+
+        content = case mode
+          when :inline
+            last = list.pop
+            "#{list.join(", ")}, and #{last}"
+          else # rows
+            list.join("\n")
+        end
+
+        $stdout.puts content
+      end
+
+      # Prints a table.
+      #
+      # ==== Parameters
+      # Array[Array[String, String, ...]]
+      #
+      # ==== Options
+      # ident<Integer>:: Ident the first column by ident value.
+      # emphasize_last<Boolean>:: When true, add a different behavior to the last column.
+      #
+      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"
+
+        if options[:emphasize_last]
+          table.each do |row|
+            next if row[-1].empty?
+            row[-1] = "# #{row[-1]}"
+          end
+        end
+
+        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 proc that returns the value to be used in diff
+      #
+      def file_collision(destination)
+        return true if @always_force
+
+        options = block_given? ? "[Ynaqdh]" : "[Ynaqh]"
+        answer  = ask %[Overwrite #{destination}? (enter "h" for help) #{options}]
+
+        case answer
+          when is?(:yes), is?(:force)
+            true
+          when is?(:no), is?(:skip)
+            false
+          when is?(:always)
+            @always_force = true
+          when is?(:quit)
+            say 'Aborting...'
+            raise SystemExit
+          when is?(:diff)
+            show_diff(destination, yield) if block_given?
+            say 'Retrying...'
+            raise ScriptError
+          else
+            say file_collision_help
+            raise ScriptError
+        end
+      rescue ScriptError
+        retry
+      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) #:nodoc:
+        $stderr.puts statement
+      end
+
+      protected
+
+        def is?(value)
+          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
+<<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)
+          Tempfile.open(File.basename(destination), File.dirname(destination)) do |temp|
+            temp.write content
+            temp.rewind
+            say `#{diff_cmd} "#{destination}" "#{temp.path}"`
+          end
+        end
+
+        def diff_cmd
+          ENV['THOR_DIFF'] || ENV['RAILS_DIFF'] || 'diff -u'
+        end
+
+    end
+  end
+end

data/lib/thor/task.rb

@@ -0,0 +1,85 @@
+class Thor
+  class Task < Struct.new(:name, :description, :usage, :options)
+
+    # Creates a dynamic task. Dynamic tasks are created on demand to allow method
+    # missing calls (since a method missing does not have a task object for it).
+    #
+    def self.dynamic(name)
+      new(name, "A dynamically-generated task", name.to_s, nil)
+    end
+
+    def initialize(name, description, usage, options)
+      super(name, description, usage, options || {})
+    end
+
+    # Dup the options hash on clone.
+    #
+    def initialize_copy(other)
+      super(other)
+      self.options = other.options.dup if other.options
+    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
+      backtrace = sans_backtrace(e.backtrace, caller)
+
+      if instance.is_a?(Thor) && backtrace.empty?
+        raise InvocationError, "'#{name}' was called incorrectly. Call as '#{formatted_usage(instance.class)}'"
+      else
+        raise e
+      end
+    rescue NoMethodError => e
+      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
+
+    # Returns the first line of the given description.
+    #
+    def short_description
+      description.split("\n").first if description
+    end
+
+    # Returns the formatted usage. If a klass is given, the klass default options
+    # are merged with the task options providinf a full description.
+    #
+    def formatted_usage(klass=nil)
+      formatted = ''
+      formatted << "#{klass.namespace.gsub(/^default/,'')}:" if klass
+      formatted << usage.to_s
+      formatted << " #{formatted_options}"
+      formatted.strip!
+      formatted
+    end
+
+    # Returns the options usage for this task.
+    #
+    def formatted_options
+      @formatted_options ||= options.values.sort.map{ |o| o.usage }.join(" ")
+    end
+
+    protected
+
+      # Given a target, checks if this class name is not a private/protected method.
+      #
+      def public_method?(instance)
+        !(instance.private_methods + instance.protected_methods).include?(name.to_s)
+      end
+
+      # Clean everything that comes from the Thor gempath and remove the caller.
+      #
+      def sans_backtrace(backtrace, caller)
+        dirname = /^#{Regexp.escape(File.dirname(__FILE__))}/
+        saned  = backtrace.reject { |frame| frame =~ dirname }
+        saned -= caller
+      end
+
+  end
+end

data/lib/thor/tasks.rb

@@ -0,0 +1,3 @@
+Dir[File.join(File.dirname(__FILE__), "tasks", "*.rb")].each do |task|
+  require task
+end

data/lib/thor/tasks/install.rb

@@ -0,0 +1,35 @@
+class Thor
+  # Creates an install task.
+  #
+  # ==== Parameters
+  # spec<Gem::Specification>
+  #
+  # ==== Options
+  # :dir - The directory where the package is hold before installation. Defaults to ./pkg.
+  #
+  def self.install_task(spec, options={})
+    package_task(spec, options)
+    tasks['install'] = Thor::InstallTask.new(spec, options)
+  end
+
+  class InstallTask < Task
+    attr_accessor :spec, :config
+
+    def initialize(gemspec, config={})
+      super(:install, "Install the gem", "install", {})
+      @spec   = gemspec
+      @config = { :dir => File.join(Dir.pwd, "pkg") }.merge(config)
+    end
+
+    def run(instance, args=[])
+      null, sudo, gem = RUBY_PLATFORM =~ /mswin|mingw/ ? ['NUL', '', 'gem.bat'] :
+                                                         ['/dev/null', 'sudo', 'gem']
+
+      old_stderr, $stderr = $stderr.dup, File.open(null, "w")
+      instance.invoke(:package)
+      $stderr = old_stderr
+
+      system %{#{sudo} #{Gem.ruby} -S #{gem} install #{config[:dir]}/#{spec.name}-#{spec.version} --no-rdoc --no-ri --no-update-sources}
+    end
+  end
+end

data/lib/thor/tasks/package.rb

@@ -0,0 +1,31 @@
+require "fileutils"
+
+class Thor
+  # Creates a package task.
+  #
+  # ==== Parameters
+  # spec<Gem::Specification>
+  #
+  # ==== Options
+  # :dir - The package directory. Defaults to ./pkg.
+  #
+  def self.package_task(spec, options={})
+    tasks['package'] = Thor::PackageTask.new(spec, options)
+  end
+
+  class PackageTask < Task
+    attr_accessor :spec, :config
+
+    def initialize(gemspec, config={})
+      super(:package, "Build a gem package", "package", {})
+      @spec   = gemspec
+      @config = {:dir => File.join(Dir.pwd, "pkg")}.merge(config)
+    end
+
+    def run(instance, args=[])
+      FileUtils.mkdir_p(config[:dir])
+      Gem::Builder.new(spec).build
+      FileUtils.mv(spec.file_name, File.join(config[:dir], spec.file_name))
+    end
+  end
+end

data/lib/thor/tasks/spec.rb

@@ -0,0 +1,70 @@
+require "fileutils"
+
+class Thor
+  # Creates a spec task.
+  #
+  # ==== Parameters
+  # files<Array> - Array of files to spec
+  #
+  # ==== Options
+  # :name     - The name of the task. It can be rcov or spec. Spec is the default.
+  # :rcov     - A hash with rcov specific options.
+  # :rcov_dir - Where rcov reports should be printed.
+  # :verbose  - Sets the default value for verbose, although it can be specified
+  #             also through the command line.
+  #
+  # All other options are added to rspec.
+  #
+  def self.spec_task(files, options={})
+    name        = (options.delete(:name) || 'spec').to_s
+    tasks[name] = Thor::SpecTask.new(name, files, options)
+  end
+
+  class SpecTask < Task
+    attr_accessor :name, :files, :rcov_dir, :rcov_config, :spec_config
+
+    def initialize(name, files, config={})
+      options = { :verbose => Thor::Option.parse(:verbose, config.delete(:verbose) || false) }
+      super(name, "#{name.capitalize} task", name, options)
+
+      @name        = name
+      @files       = files.map{ |f| %["#{f}"] }.join(" ")
+      @rcov_dir    = config.delete(:rdoc_dir) || File.join(Dir.pwd, 'coverage')
+      @rcov_config = config.delete(:rcov) || {}
+      @spec_config = { :format => 'specdoc', :color => true }.merge(config)
+    end
+
+    def run(instance, args=[])
+      rcov_opts = Thor::Options.to_switches(rcov_config)
+      spec_opts = Thor::Options.to_switches(spec_config)
+
+      require 'rbconfig'
+      cmd  = RbConfig::CONFIG['ruby_install_name'] << " "
+
+      if rcov?
+        FileUtils.rm_rf(rcov_dir)
+        cmd << "-S #{where('rcov')} -o #{rcov_dir} #{rcov_opts} "
+      end
+
+      cmd << [where('spec'), rcov? ? " -- " : nil, files, spec_opts].join(" ")
+
+      puts cmd if instance.options.verbose?
+      system(cmd)
+      exit($?.exitstatus)
+    end
+
+    private
+
+      def rcov?
+        name == "rcov"
+      end
+
+      def where(file)
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+          file_with_path = File.join(path, file)
+          next unless File.exist?(file_with_path) && File.executable?(file_with_path)
+          return File.expand_path(file_with_path)
+        end
+      end
+  end
+end

data/lib/thor/util.rb

@@ -0,0 +1,209 @@
+class Thor
+  module Sandbox; end
+
+  # This module holds several utilities:
+  #
+  # 1) Methods to convert thor namespaces to constants and vice-versa.
+  #
+  #   Thor::Utils.constant_to_namespace(Foo::Bar::Baz) #=> "foo:bar:baz"
+  #   Thor::Utils.namespace_to_constant("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' if namespace.empty?
+
+      Thor::Base.subclasses.find do |klass|
+        klass.namespace == namespace
+      end
+    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.
+    #
+    # TODO Deprecate this method in the future.
+    #
+    # ==== 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.constant_to_namespace(constant, remove_default=true)
+      constant = constant.to_s.gsub(/^Thor::Sandbox::/, "")
+      constant = snake_case(constant).squeeze(":")
+      constant.gsub!(/^default/, '') if remove_default
+      constant
+    end
+
+    # Given the contents, evaluate it inside the sandbox and returns the thor
+    # classes defined in the sandbox.
+    #
+    # ==== Parameters
+    # contents<String>
+    #
+    # ==== Returns
+    # Array[Object]
+    #
+    def self.namespaces_in_contents(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
+
+    # 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 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>
+    #
+    # ==== Errors
+    # Thor::Error:: raised if the namespace cannot be found.
+    #
+    # Thor::Error:: raised if the namespace evals to a class which does not
+    #               inherit from Thor or Thor::Group.
+    #
+    def self.namespace_to_thor_class(namespace)
+      klass, task_name = Thor::Util.find_by_namespace(namespace), nil
+
+      if klass.nil? && namespace.include?(?:)
+        namespace = namespace.split(":")
+        task_name = namespace.pop
+        klass     = Thor::Util.find_by_namespace(namespace.join(":"))
+      end
+
+      raise Error, "could not find Thor class or task '#{namespace}'" unless klass
+
+      return klass, task_name
+    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.read(path)
+
+      begin
+        Thor::Sandbox.class_eval(content, path)
+      rescue Exception => e
+        $stderr.puts "WARNING: unable to load thorfile #{path.inspect}: #{e.message}"
+      end
+    end
+
+    # Receives a yaml (hash) and updates all constants entries to namespace.
+    # This was added to deal with deprecated versions of Thor.
+    #
+    # TODO Deprecate this method in the future.
+    #
+    # ==== Returns
+    # TrueClass|FalseClass:: Returns true if any change to the yaml file was made.
+    #
+    def self.convert_constants_to_namespaces(yaml)
+      yaml_changed = false
+
+      yaml.each do |k, v|
+        next unless v[:constants] && v[:namespaces].nil?
+        yaml_changed = true
+        yaml[k][:namespaces] = v[:constants].map{|c| Thor::Util.constant_to_namespace(c)}
+      end
+
+      yaml_changed
+    end
+
+    # Returns the root where thor files are located, dependending on the OS.
+    #
+    def self.thor_root
+      return File.join(ENV["HOME"], '.thor') if ENV["HOME"]
+
+      if ENV["HOMEDRIVE"] && ENV["HOMEPATH"]
+        return File.join(ENV["HOMEDRIVE"], ENV["HOMEPATH"], '.thor')
+      end
+
+      return File.join(ENV["APPDATA"], '.thor') if ENV["APPDATA"]
+
+      begin
+        File.expand_path("~")
+      rescue
+        if File::ALT_SEPARATOR
+          "C:/"
+        else
+          "/"
+        end
+      end
+    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.gsub(/\\/, '/')}/*"]
+
+      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
+
+  end
+end