Class: Thor::Runner

Inherits:
Thor
  • Object
show all
Defined in:
lib/thor/runner.rb

Overview

:nodoc:

Constant Summary

Constant Summary

Constants inherited from Thor

HELP_MAPPINGS, THOR_RESERVED_WORDS, VERSION

Instance Attribute Summary

Attributes included from Base

#args, #options, #parent_options

Instance Method Summary (collapse)

Methods inherited from Thor

check_unknown_options!, check_unknown_options?, default_task, desc, help, long_desc, map, method_option, method_options, printable_tasks, register, stop_on_unknown_option!, stop_on_unknown_option?, subcommand, subcommands, task_help

Methods included from Base

included, #initialize, register_klass_file, shell, shell=, subclass_files, subclasses

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

- (Object) method_missing(meth, *args)

If a task is not found on Thor::Runner, method missing is invoked and Thor::Runner is then responsible for finding the task in all classes.



30
31
32
33
34
35
36
37
 
# File 'lib/thor/runner.rb', line 30

def method_missing(meth, *args)
  meth = meth.to_s
  initialize_thorfiles(meth)
  klass, task = Thor::Util.find_class_and_task_by_namespace(meth)
  self.class.handle_no_task_error(task, false) if klass.nil?
  args.unshift(task) if task
  klass.start(args, :shell => self.shell)
end

Instance Method Details

- (Object) help(meth = nil)

Override Thor#help so it can give information about any class and any method.



16
17
18
19
20
21
22
23
24
25
 
# File 'lib/thor/runner.rb', line 16

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

- (Object) install(name) 



41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/thor/runner.rb', line 41

def install(name)
  initialize_thorfiles

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

  say "Your 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 =~ /^https?:\/\//
    name
  else
    File.expand_path(name)
  end

  thor_yaml[as] = {
    :filename   => Digest::MD5.hexdigest(name + as),
    :location   => location,
    :namespaces => 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
    FileUtils.cp_r(name, destination)
  end

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

- (Object) installed 



148
149
150
151
 
# File 'lib/thor/runner.rb', line 148

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

- (Object) list(search = "") 



155
156
157
158
159
160
161
162
163
164
165
166
167
 
# File 'lib/thor/runner.rb', line 155

def list(search="")
  initialize_thorfiles

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

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

  display_klasses(false, false, klasses)
end

- (Object) uninstall(name)

Raises:



110
111
112
113
114
115
116
117
118
119
 
# File 'lib/thor/runner.rb', line 110

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

  thor_yaml.delete(name)
  save_yaml(thor_yaml)

  puts "Done."
end

- (Object) update(name)

Raises:



122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'lib/thor/runner.rb', line 122

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 = self.options.merge("as" => name)

  if File.directory? File.expand_path(name)
    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

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

- (Object) version 



104
105
106
107
 
# File 'lib/thor/runner.rb', line 104

def version
  require 'thor/version'
  say "Thor #{Thor::VERSION}"
end