NAME

       Mojolicious::Commands - Command line interface

SYNOPSIS

         Usage: APPLICATION COMMAND [OPTIONS]

           mojo version
           mojo generate lite_app
           ./myapp.pl daemon -m production -l http://*:8080
           ./myapp.pl get /foo
           ./myapp.pl routes -v

         Tip: CGI and PSGI environments can be automatically detected very often and
              work without commands.

         Options (for all commands):
           -h, --help          Get more information on a specific command
               --home <path>   Path to home directory of your application, defaults to
                               the value of MOJO_HOME or auto-detection
           -m, --mode <name>   Operating mode for your application, defaults to the
                               value of MOJO_MODE/PLACK_ENV or "development"

DESCRIPTION

       Mojolicious::Commands is the interactive command line interface for the Mojolicious
       framework. It will automatically detect available commands in the "Mojolicious::Command"
       namespace.

COMMANDS

       These commands are available by default.

   cgi
         $ ./myapp.pl cgi

       Use Mojolicious::Command::cgi to start application with CGI backend, usually auto
       detected.

   cpanify
         $ mojo cpanify -u sri -p secr3t Mojolicious-Plugin-Fun-0.1.tar.gz

       Use Mojolicious::Command::cpanify for uploading files to CPAN.

   daemon
         $ ./myapp.pl daemon

       Use Mojolicious::Command::daemon to start application with standalone HTTP and WebSocket
       server.

   eval
         $ ./myapp.pl eval 'say app->home'

       Use Mojolicious::Command::eval to run code against application.

   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.

   generate app
         $ mojo generate app <AppName>

       Use Mojolicious::Command::generate::app to generate application directory structure for a
       fully functional Mojolicious application.

   generate lite_app
         $ mojo generate lite_app

       Use Mojolicious::Command::generate::lite_app to generate a fully functional
       Mojolicious::Lite application.

   generate makefile
         $ mojo generate makefile
         $ ./myapp.pl generate makefile

       Use Mojolicious::Command::generate::makefile to generate "Makefile.PL" file for
       application.

   generate plugin
         $ mojo generate plugin <PluginName>

       Use Mojolicious::Command::generate::plugin to generate directory structure for a fully
       functional Mojolicious plugin.

   get
         $ mojo get http://mojolicious.org
         $ ./myapp.pl get /foo

       Use Mojolicious::Command::get to perform requests to remote host or local application.

   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.

   inflate
         $ ./myapp.pl inflate

       Use Mojolicious::Command::inflate to turn templates and static files embedded in the
       "DATA" sections of your application into real files.

   prefork
         $ ./myapp.pl prefork

       Use Mojolicious::Command::prefork to start application with standalone pre-forking HTTP
       and WebSocket server.

   psgi
         $ ./myapp.pl psgi

       Use Mojolicious::Command::psgi to start application with PSGI backend, usually auto
       detected.

   routes
         $ ./myapp.pl routes

       Use Mojolicious::Command::routes to list application routes.

   test
         $ ./myapp.pl test
         $ ./myapp.pl test t/fun.t

       Use Mojolicious::Command::test to run application tests from the "t" directory.

   version
         $ mojo version
         $ ./myapp.pl version

       Use Mojolicious::Command::version to show version information for available core and
       optional modules, very useful for debugging.

ATTRIBUTES

       Mojolicious::Commands inherits all attributes from Mojolicious::Command and implements the
       following new ones.

   hint
         my $hint  = $commands->hint;
         $commands = $commands->hint('Foo');

       Short hint shown after listing available commands.

   message
         my $msg   = $commands->message;
         $commands = $commands->message('Hello World!');

       Short usage message shown before listing available commands.

   namespaces
         my $namespaces = $commands->namespaces;
         $commands      = $commands->namespaces(['MyApp::Command']);

       Namespaces to load commands from, defaults to "Mojolicious::Command".

         # Add another namespace to load commands from
         push @{$commands->namespaces}, 'MyApp::Command';

METHODS

       Mojolicious::Commands inherits all methods from Mojolicious::Command and implements the
       following new ones.

   detect
         my $env = $commands->detect;

       Try to detect environment, or return "undef" if none could be detected.

   run
         $commands->run;
         $commands->run(@ARGV);

       Load and run commands. Automatic deployment environment detection can be disabled with the
       "MOJO_NO_DETECT" environment variable.

   start_app
         Mojolicious::Commands->start_app('MyApp');
         Mojolicious::Commands->start_app(MyApp => @ARGV);

       Load application from class and start the command line interface for it. Note that the
       options "-h"/"--help", "--home" and "-m"/"--mode", which are shared by all commands, will
       be parsed from @ARGV during compile time.

         # Always start daemon for application
         Mojolicious::Commands->start_app('MyApp', 'daemon', '-l', 'http://*:8080');

SEE ALSO

       Mojolicious, Mojolicious::Guides, <http://mojolicious.org>.