Module: Thor::Util

### Home Classes Methods

### In Files

- lib/thor/util.rb

### Methods

- ::camel_case
- ::escape_globs
- ::find_by_namespace
- ::find_class_and_command_by_namespace
- ::find_class_and_task_by_namespace
- ::globs_for
- ::load_thorfile
- ::namespace_from_thor_class
- ::namespaces_in_content
- ::ruby_command
- ::snake_case
- ::thor_classes_in
- ::thor_root
- ::thor_root_glob
- ::user_home

### Class/Module Index

Quicksearch

- Thor
- Thor::Actions
- Thor::Actions::ClassMethods
- Thor::Base
- Thor::Base::ClassMethods
- Thor::Command
- Thor::DynamicCommand
- Thor::DynamicTask
- Thor::Error
- Thor::Group
- Thor::HiddenCommand
- Thor::HiddenTask
- Thor::InvocationError
- Thor::MalformattedArgumentError
- Thor::RakeCompat
- Thor::RequiredArgumentMissingError
- Thor::Shell
- Thor::Shell::Basic
- Thor::Shell::Color
- Thor::Shell::HTML
- Thor::Task
- Thor::UndefinedCommandError
- Thor::UndefinedTaskError
- Thor::UnknownArgumentError
- Thor::Util
- Object

No matching classes.

# Thor::Util

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")

### Public Class Methods

camel_case(str) click to toggle source

Receives a string and convert it to camel case. camel_case returns CamelCase.

#### Parameters

String

#### Returns

String

    # File lib/thor/util.rb, line 106
    def camel_case(str)
      return str if str !~ /_/ && str =~ /[A-Z]+.*/
      str.split('_').map { |i| i.capitalize }.join
    end

escape_globs(path) click to toggle source

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

    # File lib/thor/util.rb, line 264
    def escape_globs(path)
      path.to_s.gsub(/[*?{}\[\]]/, '\\\&')
    end

find_by_namespace(namespace) click to toggle source

Receives a namespace and search for it in the Thor::Base subclasses.

#### Parameters

namespace<String> | The namespace to search for.

    # File lib/thor/util.rb, line 26
    def find_by_namespace(namespace)
      namespace = "default#{namespace}" if namespace.empty? || namespace =~ /^:/
      Thor::Base.subclasses.find { |klass| klass.namespace == namespace }
    end

find_class_and_command_by_namespace(namespace, fallback = true) click to toggle source

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 command
    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>

    # File lib/thor/util.rb, line 133
    def find_class_and_command_by_namespace(namespace, fallback = true)
      if namespace.include?(::) # look for a namespaced command
        pieces  = namespace.split(":")
        command = pieces.pop
        klass   = Thor::Util.find_by_namespace(pieces.join(":"))
      end
      unless klass # look for a Thor::Group with the right name
        klass, command = Thor::Util.find_by_namespace(namespace), nil
      end
      if !klass && fallback # try a command in the default namespace
        command = namespace
        klass   = Thor::Util.find_by_namespace('')
      end
      return klass, command
    end

Also aliased as: find_class_and_task_by_namespace
find_class_and_task_by_namespace(namespace, fallback = true) click to toggle source
Alias for: find_class_and_command_by_namespace
globs_for(path) click to toggle source

Where to look for Thor files.

    # File lib/thor/util.rb, line 213
    def globs_for(path)
      path = escape_globs(path)
      ["#{path}/Thorfile", "#{path}/*.thor", "#{path}/tasks/*.thor", "#{path}/lib/tasks/*.thor"]
    end

load_thorfile(path, content=nil, debug=false) click to toggle source

Receives a path and load the thor file in the path. The file is evaluated inside the sandbox to avoid namespacing conflicts.

    # File lib/thor/util.rb, line 153
    def 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

namespace_from_thor_class(constant) click to toggle source

Receives a constant and converts it to a Thor namespace. Since Thor commands 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"

    # File lib/thor/util.rb, line 45
    def namespace_from_thor_class(constant)
      constant = constant.to_s.gsub(/^Thor::Sandbox::/, "")
      constant = snake_case(constant).squeeze(":")
      constant
    end

namespaces_in_content(contents, file=__FILE__) click to toggle source

Given the contents, evaluate it inside the sandbox and returns the namespaces defined in the sandbox.

#### Parameters

contents<String>

#### Returns

Array

    # File lib/thor/util.rb, line 60
    def 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

ruby_command() click to toggle source

Return the path to the ruby interpreter taking into account multiple installations and windows extensions.

    # File lib/thor/util.rb, line 221
    def 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.*/, '"\&"')
        ruby
      end
    end

snake_case(str) click to toggle source

Receives a string and convert it to snake case. SnakeCase returns snake_case.

#### Parameters

String

#### Returns

String

    # File lib/thor/util.rb, line 92
    def snake_case(str)
      return str.downcase if str =~ /^[A-Z_]+$/
      str.gsub(/\B[A-Z]/, '_\&').squeeze('_') =~ /_*(.*)/
      return $+.downcase
    end

thor_classes_in(klass) click to toggle source

Returns the thor classes declared inside the given class.

    # File lib/thor/util.rb, line 76
    def 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

thor_root() click to toggle source

Returns the root where thor files are located, depending on the OS.

    # File lib/thor/util.rb, line 192
    def thor_root
      File.join(user_home, ".thor").gsub(/\\/, '/')
    end

thor_root_glob() click to toggle source

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.

    # File lib/thor/util.rb, line 203
    def thor_root_glob
      files = Dir["#{escape_globs(thor_root)}/*"]

      files.map! do |file|
        File.directory?(file) ? File.join(file, "main.thor") : file
      end
    end

user_home() click to toggle source

    # File lib/thor/util.rb, line 168
    def 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

[Validate]

Generated with the Darkfish Rdoc Generator 2.