Class: Bundler::Thor::Runner

# File 'lib/bundler/vendor/thor/lib/thor/runner.rb', line 278

def display_klasses(with_modules = false, show_internal = false, klasses = Bundler::Thor::Base.subclasses)
  klasses -= [Bundler::Thor, Bundler::Thor::Runner, Bundler::Thor::Group] unless show_internal

  raise Error, "No Bundler::Thor commands available" if klasses.empty?
  show_modules if with_modules && !thor_yaml.empty?

  list = Hash.new { |h, k| h[k] = [] }
  groups = klasses.select { |k| k.ancestors.include?(Bundler::Thor::Group) }

  # Get classes which inherit from Bundler::Thor
  (klasses - groups).each { |k| list[k.namespace.split(":").first] += k.printable_commands(false) }

  # Get classes which inherit from Bundler::Thor::Base
  groups.map! { |k| k.printable_commands(false).first }
  list["root"] = groups

  # Order namespaces with default coming first
  list = list.sort { |a, b| a[0].sub(/^default/, "") <=> b[0].sub(/^default/, "") }
  list.each { |n, commands| display_commands(n, commands) unless commands.empty? }
end

# File 'lib/bundler/vendor/thor/lib/thor/runner.rb', line 308

alias_method :display_tasks, :display_commands

# File 'lib/bundler/vendor/thor/lib/thor/runner.rb', line 22

def help(meth = nil)
  if meth && !respond_to?(meth)
    initialize_thorfiles(meth)
    klass, command = Bundler::Thor::Util.find_class_and_command_by_namespace(meth)
    self.class.handle_no_command_error(command, false) if klass.nil?
    klass.start(["-h", command].compact, :shell => shell)
  else
    super
  end
end

# File 'lib/bundler/vendor/thor/lib/thor/runner.rb', line 214

def initialize_thorfiles(relevant_to = nil, skip_lookup = false)
  thorfiles(relevant_to, skip_lookup).each do |f|
    Bundler::Thor::Util.load_thorfile(f, nil, options[:debug]) unless Bundler::Thor::Base.subclass_files.keys.include?(File.expand_path(f))
  end
end

# File 'lib/bundler/vendor/thor/lib/thor/runner.rb', line 47

def install(name) # rubocop:disable MethodLength
  initialize_thorfiles

  # If a directory name is provided as the argument, look for a 'main.thor'
  # command in said directory.
  begin
    if File.directory?(File.expand_path(name))
      base = File.join(name, "main.thor")
      package = :directory
      contents = open(base, &:read)
    else
      base = name
      package = :file
      contents = open(name, &:read)
    end
  rescue OpenURI::HTTPError
    raise Error, "Error opening URI '#{name}'"
  rescue Errno::ENOENT
    raise Error, "Error opening file '#{name}'"
  end

  say "Your Bundler::Thorfile contains:"
  say contents

  unless options["force"]
    return false if no?("Do you wish to continue [y/N]?")
  end

  as = options["as"] || begin
    first_line = contents.split("\n")[0]
    (match = first_line.match(/\s*#\s*module:\s*([^\n]*)/)) ? match[1].strip : nil
  end

  unless as
    basename = File.basename(name)
    as = ask("Please specify a name for #{name} in the system repository [#{basename}]:")
    as = basename if as.empty?
  end

  location = if options[:relative] || name =~ %r{^https?://}
    name
  else
    File.expand_path(name)
  end

  thor_yaml[as] = {
    :filename   => Digest(:MD5).hexdigest(name + as),
    :location   => location,
    :namespaces => Bundler::Thor::Util.namespaces_in_content(contents, base)
  }

  save_yaml(thor_yaml)
  say "Storing thor file in your system repository"
  destination = File.join(thor_root, thor_yaml[as][:filename])

  if package == :file
    File.open(destination, "w") { |f| f.puts contents }
  else
    require "fileutils"
    FileUtils.cp_r(name, destination)
  end

  thor_yaml[as][:filename] # Indicate success
end

# File 'lib/bundler/vendor/thor/lib/thor/runner.rb', line 157

def installed
  initialize_thorfiles(nil, true)
  display_klasses(true, options["internal"])
end

# File 'lib/bundler/vendor/thor/lib/thor/runner.rb', line 164

def list(search = "")
  initialize_thorfiles

  search = ".*#{search}" if options["substring"]
  search = /^#{search}.*/i
  group  = options[:group] || "standard"

  klasses = Bundler::Thor::Base.subclasses.select do |k|
    (options[:all] || k.group == group) && k.namespace =~ search
  end

  display_klasses(false, false, klasses)
end

# File 'lib/bundler/vendor/thor/lib/thor/runner.rb', line 194

def save_yaml(yaml)
  yaml_file = File.join(thor_root, "thor.yml")

  unless File.exist?(yaml_file)
    require "fileutils"
    FileUtils.mkdir_p(thor_root)
    yaml_file = File.join(thor_root, "thor.yml")
    FileUtils.touch(yaml_file)
  end

  File.open(yaml_file, "w") { |f| f.puts yaml.to_yaml }
end

# File 'lib/bundler/vendor/thor/lib/thor/runner.rb', line 310

def show_modules #:nodoc:
  info = []
  labels = %w(Modules Namespaces)

  info << labels
  info << ["-" * labels[0].size, "-" * labels[1].size]

  thor_yaml.each do |name, hash|
    info << [name, hash[:namespaces].join(", ")]
  end

  print_table info
  say ""
end

# File 'lib/bundler/vendor/thor/lib/thor/runner.rb', line 180

def thor_root
  Bundler::Thor::Util.thor_root
end

# File 'lib/bundler/vendor/thor/lib/thor/runner.rb', line 184

def thor_yaml
  @thor_yaml ||= begin
    yaml_file = File.join(thor_root, "thor.yml")
    yaml = YAML.load_file(yaml_file) if File.exist?(yaml_file)
    yaml || {}
  end
end

# File 'lib/bundler/vendor/thor/lib/thor/runner.rb', line 242

def thorfiles(relevant_to = nil, skip_lookup = false)
  thorfiles = []

  unless skip_lookup
    Pathname.pwd.ascend do |path|
      thorfiles = Bundler::Thor::Util.globs_for(path).map { |g| Dir[g] }.flatten
      break unless thorfiles.empty?
    end
  end

  files  = (relevant_to ? thorfiles_relevant_to(relevant_to) : Bundler::Thor::Util.thor_root_glob)
  files += thorfiles
  files -= ["#{thor_root}/thor.yml"]

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

# File 'lib/bundler/vendor/thor/lib/thor/runner.rb', line 265

def thorfiles_relevant_to(meth)
  lookup = [meth, meth.split(":")[0...-1].join(":")]

  files = thor_yaml.select do |_, v|
    v[:namespaces] && !(v[:namespaces] & lookup).empty?
  end

  files.map { |_, v| File.join(thor_root, (v[:filename]).to_s) }
end

# File 'lib/bundler/vendor/thor/lib/thor/runner.rb', line 119

def uninstall(name)
  raise Error, "Can't find module '#{name}'" unless thor_yaml[name]
  say "Uninstalling #{name}."
  require "fileutils"
  FileUtils.rm_rf(File.join(thor_root, (thor_yaml[name][:filename]).to_s))

  thor_yaml.delete(name)
  save_yaml(thor_yaml)

  puts "Done."
end

# File 'lib/bundler/vendor/thor/lib/thor/runner.rb', line 132

def update(name)
  raise Error, "Can't find module '#{name}'" if !thor_yaml[name] || !thor_yaml[name][:location]

  say "Updating '#{name}' from #{thor_yaml[name][:location]}"

  old_filename = thor_yaml[name][:filename]
  self.options = options.merge("as" => name)

  if File.directory? File.expand_path(name)
    require "fileutils"
    FileUtils.rm_rf(File.join(thor_root, old_filename))

    thor_yaml.delete(old_filename)
    save_yaml(thor_yaml)

    filename = install(name)
  else
    filename = install(thor_yaml[name][:location])
  end

  File.delete(File.join(thor_root, old_filename)) unless filename == old_filename
end

# File 'lib/bundler/vendor/thor/lib/thor/runner.rb', line 113

def version
  require "bundler/vendor/thor/lib/thor/version"
  say "Bundler::Thor #{Bundler::Thor::VERSION}"
end