-
Notifications
You must be signed in to change notification settings - Fork 573
/
Commands.pm
352 lines (233 loc) · 7.54 KB
/
Commands.pm
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
package Mojolicious::Commands;
use Mojo::Base 'Mojo::Base';
use Getopt::Long
qw/GetOptions :config no_auto_abbrev no_ignore_case pass_through/;
use Mojo::Loader;
use Mojo::Server;
# "One day a man has everything, the next day he blows up a $400 billion
# space station, and the next day he has nothing. It makes you think."
has hint => <<"EOF";
These options are available for all commands:
-h, --help Get more information on a specific command.
--home <path> Path to your applications home directory, defaults to
the value of MOJO_HOME or auto detection.
-m, --mode <name> Run mode of your application, defaults to the value
of MOJO_MODE or "development".
See '$0 help COMMAND' for more information on a specific command.
EOF
has message => <<"EOF";
usage: $0 COMMAND [OPTIONS]
Tip: CGI and PSGI environments can be automatically detected very often and
work without commands.
These commands are currently available:
EOF
has namespaces => sub { [qw/Mojolicious::Command Mojo::Command/] };
sub detect {
my ($self, $guess) = @_;
# PSGI (Plack only for now)
return 'psgi' if defined $ENV{PLACK_ENV};
# CGI
return 'cgi'
if defined $ENV{PATH_INFO} || defined $ENV{GATEWAY_INTERFACE};
# Nothing
return $guess;
}
# Command line options for MOJO_HELP, MOJO_HOME and MOJO_MODE
BEGIN {
GetOptions(
'h|help' => sub { $ENV{MOJO_HELP} = 1 },
'home=s' => sub { $ENV{MOJO_HOME} = $_[1] },
'm|mode=s' => sub { $ENV{MOJO_MODE} = $_[1] }
) unless __PACKAGE__->detect;
}
sub run {
my ($self, $name, @args) = @_;
# Application loader
return Mojo::Server->new->app if defined $ENV{MOJO_APP_LOADER};
# Try to detect environment
$name = $self->detect($name) unless $ENV{MOJO_NO_DETECT};
# Run command
if ($name && $name =~ /^\w+$/ && ($name ne 'help' || $args[0])) {
# Help
my $help = $name eq 'help';
$name = shift @args if $help;
$help = 1 if $ENV{MOJO_HELP};
# Try all namespaces
my $module;
$module = _command("${_}::$name") and last for @{$self->namespaces};
# Command missing
die qq/Command "$name" missing, maybe you need to install it?\n/
unless $module;
# Run
return $help ? $module->new->help : $module->new->run(@args);
}
# Test
return 1 if $ENV{HARNESS_ACTIVE};
# Try all namespaces
my $commands = [];
my $seen = {};
for my $namespace (@{$self->namespaces}) {
for my $module (@{Mojo::Loader->search($namespace)}) {
next unless my $command = _command($module);
$command =~ s/^$namespace\:\://;
push @$commands, [$command => $module] unless $seen->{$command}++;
}
}
# Print overview
print $self->message;
# Make list
my $list = [];
my $max = 0;
foreach my $command (@$commands) {
my $len = length $command->[0];
$max = $len if $len > $max;
push @$list, [$command->[0], $command->[1]->new->description];
}
# Print list
foreach my $command (@$list) {
my ($name, $description) = @$command;
print " $name" . (' ' x ($max - length $name)) . " $description";
}
print $self->hint;
return 1;
}
sub start {
my $self = shift;
# Executable
$ENV{MOJO_EXE} ||= (caller)[1] if $ENV{MOJO_APP};
# Run
my @args = @_ ? @_ : @ARGV;
ref $self ? $self->run(@args) : $self->new->run(@args);
}
sub start_app {
my $self = shift;
$ENV{MOJO_APP} = shift;
$self->start(@_);
}
sub _command {
my $module = shift;
if (my $e = Mojo::Loader->load($module)) {
return unless ref $e;
die $e;
}
return $module->isa('Mojo::Command') ? $module : undef;
}
1;
__END__
=head1 NAME
Mojolicious::Commands - Commands
=head1 SYNOPSIS
use Mojolicious::Commands;
# Command line interface
my $commands = Mojolicious::Commands->new;
$commands->run(@ARGV);
=head1 DESCRIPTION
L<Mojolicious::Commands> is the interactive command line interface to the
L<Mojolicious> framework. It will automatically detect available commands in
the C<Mojolicious::Command> namespace.
=head1 COMMANDS
These commands are available by default.
=head2 C<help>
$ mojo
$ mojo help
$ ./myapp.pl help
List available commands with short descriptions.
$ mojo help <command>
$ ./myapp.pl help <command>
List available options for the command with short descriptions.
=head2 C<cgi>
$ ./myapp.pl cgi
Start application with CGI backend.
=head2 C<cpanify>
$ mojo cpanify -u sri -p secr3t Mojolicious-Plugin-Fun-0.1.tar.gz
Upload files to CPAN.
=head2 C<daemon>
$ ./myapp.pl daemon
Start application with standalone HTTP 1.1 server backend.
=head2 C<eval>
$ ./myapp.pl eval 'say app->home'
Run code against application.
=head2 C<generate>
$ mojo generate
$ mojo generate help
$ ./myapp.pl generate help
List available generator commands with short descriptions.
$ mojo generate help <generator>
$ ./myapp.pl generate help <generator>
List available options for generator command with short descriptions.
=head2 C<generate app>
$ mojo generate app <AppName>
Generate application directory structure for a fully functional
L<Mojolicious> application.
=head2 C<generate lite_app>
$ mojo generate lite_app
Generate a fully functional L<Mojolicious::Lite> application.
=head2 C<generate makefile>
$ mojo generate makefile
$ ./myapp.pl generate makefile
Generate C<Makefile.PL> file for application.
=head2 C<generate plugin>
$ mojo generate plugin <PluginName>
Generate directory structure for a fully functional L<Mojolicious> plugin.
=head2 C<get>
$ mojo get http://mojolicio.us
$ ./myapp.pl get /foo
Perform requests to remote host or local application.
=head2 C<inflate>
$ ./myapp.pl inflate
Turn templates and static files embedded in the C<DATA> sections of your
application into real files.
=head2 C<psgi>
$ ./myapp.pl psgi
Start application with PSGI backend.
=head2 C<routes>
$ ./myapp.pl routes
List application routes.
=head2 C<test>
$ mojo test
$ ./myapp.pl test
$ ./myapp.pl test t/fun.t
Runs application tests from the C<t> directory.
=head2 C<version>
$ mojo version
$ ./myapp.pl version
Show version information for installed core and optional modules, very useful
for debugging.
=head1 ATTRIBUTES
L<Mojolicious::Commands> implements the following attributes.
=head2 C<hint>
my $hint = $commands->hint;
$commands = $commands->hint('Foo!');
Short hint shown after listing available commands.
=head2 C<message>
my $message = $commands->message;
$commands = $commands->message('Hello World!');
Short usage message shown before listing available commands.
=head2 C<namespaces>
my $namespaces = $commands->namespaces;
$commands = $commands->namespaces(['Mojolicious::Commands']);
Namespaces to search for available commands, defaults to
C<Mojolicious::Command> and C<Mojo::Command>.
=head1 METHODS
L<Mojolicious::Commands> inherits all methods from L<Mojo::Base> and
implements the following new ones.
=head2 C<detect>
my $env = $commands->detect;
my $env = $commands->detect($guess);
Try to detect environment.
=head2 C<run>
$commands->run;
$commands->run(@ARGV);
Load and run commands. Automatic deployment environment detection can be
disabled with the C<MOJO_NO_DETECT> environment variable.
=head2 C<start>
Mojolicious::Commands->start;
Mojolicious::Commands->start(@ARGV);
Start the command line interface.
=head2 C<start_app>
Mojolicious::Commands->start_app('MyApp');
Mojolicious::Commands->start_app(MyApp => @ARGV);
Start the command line interface for application.
=head1 SEE ALSO
L<Mojolicious>, L<Mojolicious::Guides>, L<http://mojolicio.us>.
=cut