wycats-thor 0.9.8 → 0.10.26

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

@@ -1,18 +1,31 @@
-require "thor/task"
+require "fileutils"
 
-class Thor::PackageTask < Thor::Task
-  attr_accessor :spec
-  attr_accessor :opts
-
-  def initialize(gemspec, opts = {})
-    super(:package, "build a gem package")
-    @spec = gemspec
-    @opts = {:dir => File.join(Dir.pwd, "pkg")}.merge(opts)
+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
 
-  def run
-    FileUtils.mkdir_p(@opts[:dir])
-    Gem::Builder.new(spec).build
-    FileUtils.mv(spec.file_name, File.join(@opts[:dir], spec.file_name))
+  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/tasks.rb

@@ -1,77 +1,4 @@
-require "thor"
-require "fileutils"
-
-class Thor
-  def self.package_task(spec)
-    desc "package", "package up the gem"
-    define_method :package do
-      FileUtils.mkdir_p(File.join(Dir.pwd, "pkg"))
-      Gem::Builder.new(spec).build
-      FileUtils.mv(spec.file_name, File.join(Dir.pwd, "pkg", spec.file_name))
-    end
-  end
-  
-  def self.install_task(spec)
-    package_task spec
-
-    null, sudo, gem = RUBY_PLATFORM =~ /w(in)?32$/ ? ['NUL', '', 'gem.bat'] :
-                                                     ['/dev/null', 'sudo', 'gem']
-    
-    desc "install", "install the gem"
-    define_method :install do
-      old_stderr, $stderr = $stderr.dup, File.open(null, "w")
-      package
-      $stderr = old_stderr
-      system %{#{sudo} #{gem} install pkg/#{spec.name}-#{spec.version} --no-rdoc --no-ri --no-update-sources}
-    end
-  end
-  
-  def self.spec_task(file_list, opts = {})
-    name = opts.delete(:name) || "spec"
-    rcov_dir = opts.delete(:rcov_dir) || "coverage"
-    file_list = file_list.map {|f| %["#{f}"]}.join(" ")
-    verbose = opts.delete(:verbose)
-    opts = {:format => "specdoc", :color => true}.merge(opts)
-    
-    rcov_opts = convert_task_options(opts.delete(:rcov) || {})
-    rcov = !rcov_opts.empty?
-    options = convert_task_options(opts)
-    
-    if rcov
-      FileUtils.rm_rf(File.join(Dir.pwd, rcov_dir))
-    end
-    
-    desc(name, "spec task")
-    define_method(name) do
-      cmd = "ruby "
-      if rcov
-        cmd << "-S rcov -o #{rcov_dir} #{rcov_opts} "
-      end
-      cmd << `which spec`.chomp
-      cmd << " -- " if rcov
-      cmd << " "
-      cmd << file_list
-      cmd << " "
-      cmd << options
-      puts cmd if verbose
-      system(cmd)
-      exit($?.exitstatus)
-    end
-  end
-  
-  private
-  def self.convert_task_options(opts)
-    opts.map do |key, value|
-      case value
-      when true
-        "--#{key}"
-      when Array
-        value.map {|v| "--#{key} #{v.inspect}"}.join(" ")
-      when nil, false
-        ""
-      else
-        "--#{key} #{value.inspect}"
-      end
-    end.join(" ")    
-  end  
+# This only loads all tasks inside tasks.
+Dir[File.join(File.dirname(__FILE__), "tasks", "*.rb")].each do |task|
+  require task
 end

data/lib/thor/util.rb

@@ -1,57 +1,229 @@
-require 'thor/error'
-
-module ObjectSpace
-  
-  class << self
-
-    # @return <Array[Class]> All the classes in the object space.
-    def classes
-      klasses = []
-      ObjectSpace.each_object(Class) {|o| klasses << o}
-      klasses
-    end
-  end
-  
-end
+require 'rbconfig'
 
 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
-    
-    def self.constant_to_thor_path(str, remove_default = true)
-      str = snake_case(str.to_s).squeeze(":")
-      str.gsub!(/^default/, '') if remove_default
-      str
-    end
 
-    def self.constant_from_thor_path(str)
-      make_constant(to_constant(str))
-    rescue NameError => e
-      raise e unless e.message =~ /^uninitialized constant (.*)$/
-      raise Error, "There was no available namespace `#{str}'."
-    end
+    # 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?
 
-    def self.to_constant(str)
-      str = 'default' if str.empty?
-      str.gsub(/:(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+      Thor::Base.subclasses.find do |klass|
+        klass.namespace == namespace
+      end
     end
 
-    def self.constants_in_contents(str)
-      klasses = ObjectSpace.classes.dup
-      Module.new.class_eval(str)
-      klasses = ObjectSpace.classes - klasses
-      klasses = klasses.select {|k| k < Thor }
-      klasses.map! {|k| k.to_s.gsub(/#<Module:\w+>::/, '')}
+    # 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.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
 
-    def self.make_constant(str)
-      list = str.split("::").inject(Object) {|obj, x| obj.const_get(x)}
+    # 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  
-    
+    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, raise_if_nil=true)
+      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}'" if raise_if_nil && klass.nil?
+
+      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
+
+    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")
+    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
+
+    # Return the path to the ruby interpreter taking into account multiple
+    # installations and windows extensions.
+    #
+    def self.ruby_command #:nodoc:
+      @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