Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   package de.saumya.mojo.rails3;
   
   import java.util.ArrayList;
   import java.util.Iterator;
   import java.util.List;
   
Display help information on rails3-maven-plugin.
Call
  mvn rails3:help -Ddetail=true -Dgoal=<goal-name>
to display parameter details.

Author(s):
org.apache.maven.tools.plugin.generator.PluginHelpGenerator (version 2.5.1)
Version:
generated on Wed Jun 01 16:06:41 EDT 2011
Goal:
help
RequiresProject:
false
  
  public class HelpMojo
      extends AbstractMojo
  {
    
If true, display all settable properties for each goal.

Parameter:
expression="${detail}" default-value="false"
  
      private boolean detail;

    
The name of the goal for which to show help. If unspecified, all goals will be displayed.

Parameter:
expression="${goal}"
  
      private java.lang.String goal;

    
The maximum length of a display line, should be positive.

Parameter:
expression="${lineLength}" default-value="80"
  
      private int lineLength;

    
The number of spaces per indentation level, should be positive.

Parameter:
expression="${indentSize}" default-value="2"
  
      private int indentSize;


    
  
      public void execute()
          throws MojoExecutionException
      {
          if (  <= 0 )
          {
              getLog().warn"The parameter 'lineLength' should be positive, using '80' as default." );
               = 80;
          }
          if (  <= 0 )
          {
              getLog().warn"The parameter 'indentSize' should be positive, using '2' as default." );
               = 2;
          }
  
          StringBuffer sb = new StringBuffer();
  
          appendsb"de.saumya.mojo:rails3-maven-plugin:0.27.0", 0 );
          appendsb"", 0 );
  
          appendsb"Rails3 Maven Mojo", 0 );
          appendsb"shared dependencies and plugins for the mojos", 1 );
          appendsb"", 0 );
  
          if (  == null || .length() <= 0 )
          {
              appendsb"This plugin has 9 goals:", 0 );
              appendsb"", 0 );
          }
  
          if (  == null || .length() <= 0 || "console".equals ) )
          {
              appendsb"rails3:console", 0 );
              appendsb"goal to run the rails console. it will ignore the fork parameter since forking does not work with a console.", 1 );
              appendsb"", 0 );
              if (  )
              {
                  appendsb"Available parameters:", 1 );
                  appendsb"", 0 );
  
                  appendsb"args", 2 );
                  appendsb"common arguments\nCommand line -Dargs=...", 3 );
                  appendsb"", 0 );
  
                  appendsb"binDirectory", 2 );
                  appendsb"directory of JRuby bin path to use when forking JRuby.", 3 );
                  appendsb"", 0 );
  
                  appendsb"consoleArgs (Default: ${console.args})", 2 );
                  appendsb"arguments for the console command", 3 );
                 appendsb"", 0 );
 
                 appendsb"env", 2 );
                 appendsb"either development or test or production or whatever else is possible with your config", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemArgs (Default: ${gem.args})", 2 );
                 appendsb"arguments for the gem command.", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemHome (Default: ${project.build.directory}/rubygems)", 2 );
                 appendsb"directory of gem home to use when forking JRuby.", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemPath (Default: ${project.build.directory}/rubygems)", 2 );
                 appendsb"directory of JRuby path to use when forking JRuby.", 3 );
                 appendsb"", 0 );
 
                 appendsb"includeOpenSSL (Default: true)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"installRDoc (Default: false)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"installRI (Default: false)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyFork (Default: true)", 2 );
                 appendsb"fork the JRuby execution.\nCommand line -Djruby.fork=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyJvmArgs", 2 );
                 appendsb"arguments for the jruby command.\nCommand line -Djruby.jvmargs=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubySwitches", 2 );
                 appendsb"switches for the jruby command, like \'--1.9\'\nCommand line -Djruby.switches=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyVerbose (Default: false)", 2 );
                 appendsb"verbose jruby related output\nCommand line -Djruby.verbose=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyVersion", 2 );
                 appendsb"if the pom.xml has no runtime dependency to a jruby-complete.jar then this version is used to resolve the jruby-complete dependency from the local/remote maven repository. it overwrites the jruby version from the dependencies if any. i.e. you can easily switch jruby version from the commandline !\ndefault: 1.6.1\nCommand line -Djruby.version=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"launchDirectory (Default: ${project.basedir})", 2 );
                 appendsb"the launch directory for the JRuby execution.\nCommand line -Djruby.launchDirectory=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"plugin", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"project", 2 );
                 appendsb"reference to maven project for internal use.", 3 );
                 appendsb"", 0 );
 
                 appendsb"railsDir (Default: ${project.basedir}/src/main/rails)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"rubySourceDirectory (Default: src/main/ruby)", 2 );
                 appendsb"the launch directory for the JRuby execution.\nCommand line -Djruby.sourceDirectory=...", 3 );
                 appendsb"", 0 );
             }
         }
 
         if (  == null || .length() <= 0 || "dbconsole".equals ) )
         {
             appendsb"rails3:dbconsole", 0 );
             appendsb"goal to run the rails database console", 1 );
             appendsb"", 0 );
             if (  )
             {
                 appendsb"Available parameters:", 1 );
                 appendsb"", 0 );
 
                 appendsb"args", 2 );
                 appendsb"common arguments\nCommand line -Dargs=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"binDirectory", 2 );
                 appendsb"directory of JRuby bin path to use when forking JRuby.", 3 );
                 appendsb"", 0 );
 
                 appendsb"dbconsoleArgs (Default: ${dbconsole.args})", 2 );
                 appendsb"arguments for the database console command", 3 );
                 appendsb"", 0 );
 
                 appendsb"env", 2 );
                 appendsb"either development or test or production or whatever else is possible with your config", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemArgs (Default: ${gem.args})", 2 );
                 appendsb"arguments for the gem command.", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemHome (Default: ${project.build.directory}/rubygems)", 2 );
                 appendsb"directory of gem home to use when forking JRuby.", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemPath (Default: ${project.build.directory}/rubygems)", 2 );
                 appendsb"directory of JRuby path to use when forking JRuby.", 3 );
                 appendsb"", 0 );
 
                 appendsb"includeOpenSSL (Default: true)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"installRDoc (Default: false)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"installRI (Default: false)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyFork (Default: true)", 2 );
                 appendsb"fork the JRuby execution.\nCommand line -Djruby.fork=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyJvmArgs", 2 );
                 appendsb"arguments for the jruby command.\nCommand line -Djruby.jvmargs=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubySwitches", 2 );
                 appendsb"switches for the jruby command, like \'--1.9\'\nCommand line -Djruby.switches=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyVerbose (Default: false)", 2 );
                 appendsb"verbose jruby related output\nCommand line -Djruby.verbose=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyVersion", 2 );
                 appendsb"if the pom.xml has no runtime dependency to a jruby-complete.jar then this version is used to resolve the jruby-complete dependency from the local/remote maven repository. it overwrites the jruby version from the dependencies if any. i.e. you can easily switch jruby version from the commandline !\ndefault: 1.6.1\nCommand line -Djruby.version=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"launchDirectory (Default: ${project.basedir})", 2 );
                 appendsb"the launch directory for the JRuby execution.\nCommand line -Djruby.launchDirectory=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"plugin", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"project", 2 );
                 appendsb"reference to maven project for internal use.", 3 );
                 appendsb"", 0 );
 
                 appendsb"railsDir (Default: ${project.basedir}/src/main/rails)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"rubySourceDirectory (Default: src/main/ruby)", 2 );
                 appendsb"the launch directory for the JRuby execution.\nCommand line -Djruby.sourceDirectory=...", 3 );
                 appendsb"", 0 );
             }
         }
 
         if (  == null || .length() <= 0 || "generate".equals ) )
         {
             appendsb"rails3:generate", 0 );
             appendsb"goal to run a generator", 1 );
             appendsb"", 0 );
             if (  )
             {
                 appendsb"Available parameters:", 1 );
                 appendsb"", 0 );
 
                 appendsb"args", 2 );
                 appendsb"common arguments\nCommand line -Dargs=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"binDirectory", 2 );
                 appendsb"directory of JRuby bin path to use when forking JRuby.", 3 );
                 appendsb"", 0 );
 
                 appendsb"env", 2 );
                 appendsb"either development or test or production or whatever else is possible with your config", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemArgs (Default: ${gem.args})", 2 );
                 appendsb"arguments for the gem command.", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemHome (Default: ${project.build.directory}/rubygems)", 2 );
                 appendsb"directory of gem home to use when forking JRuby.", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemPath (Default: ${project.build.directory}/rubygems)", 2 );
                 appendsb"directory of JRuby path to use when forking JRuby.", 3 );
                 appendsb"", 0 );
 
                 appendsb"generateArgs (Default: ${generate.args})", 2 );
                 appendsb"arguments for the generate command", 3 );
                 appendsb"", 0 );
 
                 appendsb"generator (Default: ${generator})", 2 );
                 appendsb"the name of the generator", 3 );
                 appendsb"", 0 );
 
                 appendsb"includeOpenSSL (Default: true)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"installRDoc (Default: false)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"installRI (Default: false)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyFork (Default: true)", 2 );
                 appendsb"fork the JRuby execution.\nCommand line -Djruby.fork=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyJvmArgs", 2 );
                 appendsb"arguments for the jruby command.\nCommand line -Djruby.jvmargs=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubySwitches", 2 );
                 appendsb"switches for the jruby command, like \'--1.9\'\nCommand line -Djruby.switches=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyVerbose (Default: false)", 2 );
                 appendsb"verbose jruby related output\nCommand line -Djruby.verbose=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyVersion", 2 );
                 appendsb"if the pom.xml has no runtime dependency to a jruby-complete.jar then this version is used to resolve the jruby-complete dependency from the local/remote maven repository. it overwrites the jruby version from the dependencies if any. i.e. you can easily switch jruby version from the commandline !\ndefault: 1.6.1\nCommand line -Djruby.version=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"launchDirectory (Default: ${project.basedir})", 2 );
                 appendsb"the launch directory for the JRuby execution.\nCommand line -Djruby.launchDirectory=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"plugin", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"project", 2 );
                 appendsb"reference to maven project for internal use.", 3 );
                 appendsb"", 0 );
 
                 appendsb"railsDir (Default: ${project.basedir}/src/main/rails)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"rubySourceDirectory (Default: src/main/ruby)", 2 );
                 appendsb"the launch directory for the JRuby execution.\nCommand line -Djruby.sourceDirectory=...", 3 );
                 appendsb"", 0 );
             }
         }
 
         if (  == null || .length() <= 0 || "help".equals ) )
         {
             appendsb"rails3:help", 0 );
             appendsb"Display help information on rails3-maven-plugin.\nCall\n\u00a0\u00a0mvn\u00a0rails3:help\u00a0-Ddetail=true\u00a0-Dgoal=<goal-name>\nto display parameter details.", 1 );
             appendsb"", 0 );
             if (  )
             {
                 appendsb"Available parameters:", 1 );
                 appendsb"", 0 );
 
                 appendsb"detail (Default: false)", 2 );
                 appendsb"If true, display all settable properties for each goal.", 3 );
                 appendsb"", 0 );
 
                 appendsb"goal", 2 );
                 appendsb"The name of the goal for which to show help. If unspecified, all goals will be displayed.", 3 );
                 appendsb"", 0 );
 
                 appendsb"indentSize (Default: 2)", 2 );
                 appendsb"The number of spaces per indentation level, should be positive.", 3 );
                 appendsb"", 0 );
 
                 appendsb"lineLength (Default: 80)", 2 );
                 appendsb"The maximum length of a display line, should be positive.", 3 );
                 appendsb"", 0 );
             }
         }
 
         if (  == null || .length() <= 0 || "initialize".equals ) )
         {
             appendsb"rails3:initialize", 0 );
             appendsb"(no description available)", 1 );
             appendsb"", 0 );
             if (  )
             {
                 appendsb"Available parameters:", 1 );
                 appendsb"", 0 );
 
                 appendsb"args", 2 );
                 appendsb"common arguments\nCommand line -Dargs=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"binDirectory", 2 );
                 appendsb"directory of JRuby bin path to use when forking JRuby.", 3 );
                 appendsb"", 0 );
 
                 appendsb"env", 2 );
                 appendsb"either development or test or production or whatever else is possible with your config", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemArgs (Default: ${gem.args})", 2 );
                 appendsb"arguments for the gem command.", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemHome (Default: ${project.build.directory}/rubygems)", 2 );
                 appendsb"directory of gem home to use when forking JRuby.", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemPath (Default: ${project.build.directory}/rubygems)", 2 );
                 appendsb"directory of JRuby path to use when forking JRuby.", 3 );
                 appendsb"", 0 );
 
                 appendsb"includeOpenSSL (Default: true)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"installRDoc (Default: false)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"installRI (Default: false)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyFork (Default: true)", 2 );
                 appendsb"fork the JRuby execution.\nCommand line -Djruby.fork=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyJvmArgs", 2 );
                 appendsb"arguments for the jruby command.\nCommand line -Djruby.jvmargs=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubySwitches", 2 );
                 appendsb"switches for the jruby command, like \'--1.9\'\nCommand line -Djruby.switches=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyVerbose (Default: false)", 2 );
                 appendsb"verbose jruby related output\nCommand line -Djruby.verbose=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyVersion", 2 );
                 appendsb"if the pom.xml has no runtime dependency to a jruby-complete.jar then this version is used to resolve the jruby-complete dependency from the local/remote maven repository. it overwrites the jruby version from the dependencies if any. i.e. you can easily switch jruby version from the commandline !\ndefault: 1.6.1\nCommand line -Djruby.version=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"launchDirectory (Default: ${project.basedir})", 2 );
                 appendsb"the launch directory for the JRuby execution.\nCommand line -Djruby.launchDirectory=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"plugin", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"project", 2 );
                 appendsb"reference to maven project for internal use.", 3 );
                 appendsb"", 0 );
 
                 appendsb"railsDir (Default: ${project.basedir}/src/main/rails)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"rubySourceDirectory (Default: src/main/ruby)", 2 );
                 appendsb"the launch directory for the JRuby execution.\nCommand line -Djruby.sourceDirectory=...", 3 );
                 appendsb"", 0 );
             }
         }
 
         if (  == null || .length() <= 0 || "new".equals ) )
         {
             appendsb"rails3:new", 0 );
             appendsb"goal to run rails command with the given arguments. either to generate a fresh rails application or to run the rails script from within a rails application.", 1 );
             appendsb"", 0 );
             if (  )
             {
                 appendsb"Available parameters:", 1 );
                 appendsb"", 0 );
 
                 appendsb"appPath (Default: ${app_path})", 2 );
                 appendsb"the path to the application to be generated", 3 );
                 appendsb"", 0 );
 
                 appendsb"args", 2 );
                 appendsb"common arguments\nCommand line -Dargs=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"artifactVersion (Default: 1.0-SNAPSHOT)", 2 );
                 appendsb"the version of the new pom", 3 );
                 appendsb"", 0 );
 
                 appendsb"binDirectory", 2 );
                 appendsb"directory of JRuby bin path to use when forking JRuby.", 3 );
                 appendsb"", 0 );
 
                 appendsb"database (Default: ${database})", 2 );
                 appendsb"the database to use. DEFAULT: sqlite3", 3 );
                 appendsb"", 0 );
 
                 appendsb"env", 2 );
                 appendsb"either development or test or production or whatever else is possible with your config", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemArgs (Default: ${gem.args})", 2 );
                 appendsb"arguments for the gem command.", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemHome (Default: ${project.build.directory}/rubygems)", 2 );
                 appendsb"directory of gem home to use when forking JRuby.", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemPath (Default: ${project.build.directory}/rubygems)", 2 );
                 appendsb"directory of JRuby path to use when forking JRuby.", 3 );
                 appendsb"", 0 );
 
                 appendsb"groupId (Default: rails)", 2 );
                 appendsb"the groupId of the new pom", 3 );
                 appendsb"", 0 );
 
                 appendsb"includeOpenSSL (Default: true)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"installRDoc (Default: false)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"installRI (Default: false)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyFork (Default: true)", 2 );
                 appendsb"fork the JRuby execution.\nCommand line -Djruby.fork=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyJvmArgs", 2 );
                 appendsb"arguments for the jruby command.\nCommand line -Djruby.jvmargs=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubySwitches", 2 );
                 appendsb"switches for the jruby command, like \'--1.9\'\nCommand line -Djruby.switches=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyVerbose (Default: false)", 2 );
                 appendsb"verbose jruby related output\nCommand line -Djruby.verbose=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyVersion", 2 );
                 appendsb"if the pom.xml has no runtime dependency to a jruby-complete.jar then this version is used to resolve the jruby-complete dependency from the local/remote maven repository. it overwrites the jruby version from the dependencies if any. i.e. you can easily switch jruby version from the commandline !\ndefault: 1.6.1\nCommand line -Djruby.version=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"launchDirectory (Default: ${project.basedir})", 2 );
                 appendsb"the launch directory for the JRuby execution.\nCommand line -Djruby.launchDirectory=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"plugin", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"project", 2 );
                 appendsb"reference to maven project for internal use.", 3 );
                 appendsb"", 0 );
 
                 appendsb"railsArgs (Default: ${rails.args})", 2 );
                 appendsb"arguments for the rails command", 3 );
                 appendsb"", 0 );
 
                 appendsb"railsDir (Default: ${project.basedir}/src/main/rails)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"railsVersion", 2 );
                 appendsb"the rails version to use", 3 );
                 appendsb"", 0 );
 
                 appendsb"rubySourceDirectory (Default: src/main/ruby)", 2 );
                 appendsb"the launch directory for the JRuby execution.\nCommand line -Djruby.sourceDirectory=...", 3 );
                 appendsb"", 0 );
             }
         }
 
         if (  == null || .length() <= 0 || "pom".equals ) )
         {
             appendsb"rails3:pom", 0 );
             appendsb"(no description available)", 1 );
             appendsb"", 0 );
             if (  )
             {
                 appendsb"Available parameters:", 1 );
                 appendsb"", 0 );
 
                 appendsb"args", 2 );
                 appendsb"common arguments\nCommand line -Dargs=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"binDirectory", 2 );
                 appendsb"directory of JRuby bin path to use when forking JRuby.", 3 );
                 appendsb"", 0 );
 
                 appendsb"env", 2 );
                 appendsb"either development or test or production or whatever else is possible with your config", 3 );
                 appendsb"", 0 );
 
                 appendsb"force (Default: false)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemArgs (Default: ${gem.args})", 2 );
                 appendsb"arguments for the gem command.", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemfile (Default: ${basedir}/Gemfile)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemHome (Default: ${project.build.directory}/rubygems)", 2 );
                 appendsb"directory of gem home to use when forking JRuby.", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemPath (Default: ${project.build.directory}/rubygems)", 2 );
                 appendsb"directory of JRuby path to use when forking JRuby.", 3 );
                 appendsb"", 0 );
 
                 appendsb"includeOpenSSL (Default: true)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"installRDoc (Default: false)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"installRI (Default: false)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyFork (Default: true)", 2 );
                 appendsb"fork the JRuby execution.\nCommand line -Djruby.fork=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyJvmArgs", 2 );
                 appendsb"arguments for the jruby command.\nCommand line -Djruby.jvmargs=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubySwitches", 2 );
                 appendsb"switches for the jruby command, like \'--1.9\'\nCommand line -Djruby.switches=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyVerbose (Default: false)", 2 );
                 appendsb"verbose jruby related output\nCommand line -Djruby.verbose=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyVersion", 2 );
                 appendsb"if the pom.xml has no runtime dependency to a jruby-complete.jar then this version is used to resolve the jruby-complete dependency from the local/remote maven repository. it overwrites the jruby version from the dependencies if any. i.e. you can easily switch jruby version from the commandline !\ndefault: 1.6.1\nCommand line -Djruby.version=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"launchDirectory (Default: ${project.basedir})", 2 );
                 appendsb"the launch directory for the JRuby execution.\nCommand line -Djruby.launchDirectory=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"plugin", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"pom (Default: pom.xml)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"project", 2 );
                 appendsb"reference to maven project for internal use.", 3 );
                 appendsb"", 0 );
 
                 appendsb"railsDir (Default: ${project.basedir}/src/main/rails)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"rubySourceDirectory (Default: src/main/ruby)", 2 );
                 appendsb"the launch directory for the JRuby execution.\nCommand line -Djruby.sourceDirectory=...", 3 );
                 appendsb"", 0 );
             }
         }
 
         if (  == null || .length() <= 0 || "rake".equals ) )
         {
             appendsb"rails3:rake", 0 );
             appendsb"goal to run rails rake with the given arguments.", 1 );
             appendsb"", 0 );
             if (  )
             {
                 appendsb"Available parameters:", 1 );
                 appendsb"", 0 );
 
                 appendsb"args", 2 );
                 appendsb"common arguments\nCommand line -Dargs=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"binDirectory", 2 );
                 appendsb"directory of JRuby bin path to use when forking JRuby.", 3 );
                 appendsb"", 0 );
 
                 appendsb"env", 2 );
                 appendsb"either development or test or production or whatever else is possible with your config", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemArgs (Default: ${gem.args})", 2 );
                 appendsb"arguments for the gem command.", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemHome (Default: ${project.build.directory}/rubygems)", 2 );
                 appendsb"directory of gem home to use when forking JRuby.", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemPath (Default: ${project.build.directory}/rubygems)", 2 );
                 appendsb"directory of JRuby path to use when forking JRuby.", 3 );
                 appendsb"", 0 );
 
                 appendsb"includeOpenSSL (Default: true)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"installRDoc (Default: false)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"installRI (Default: false)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyFork (Default: true)", 2 );
                 appendsb"fork the JRuby execution.\nCommand line -Djruby.fork=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyJvmArgs", 2 );
                 appendsb"arguments for the jruby command.\nCommand line -Djruby.jvmargs=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubySwitches", 2 );
                 appendsb"switches for the jruby command, like \'--1.9\'\nCommand line -Djruby.switches=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyVerbose (Default: false)", 2 );
                 appendsb"verbose jruby related output\nCommand line -Djruby.verbose=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyVersion", 2 );
                 appendsb"if the pom.xml has no runtime dependency to a jruby-complete.jar then this version is used to resolve the jruby-complete dependency from the local/remote maven repository. it overwrites the jruby version from the dependencies if any. i.e. you can easily switch jruby version from the commandline !\ndefault: 1.6.1\nCommand line -Djruby.version=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"launchDirectory (Default: ${project.basedir})", 2 );
                 appendsb"the launch directory for the JRuby execution.\nCommand line -Djruby.launchDirectory=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"plugin", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"project", 2 );
                 appendsb"reference to maven project for internal use.", 3 );
                 appendsb"", 0 );
 
                 appendsb"railsDir (Default: ${project.basedir}/src/main/rails)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"rakeArgs (Default: ${rake.args})", 2 );
                 appendsb"arguments for the generate command", 3 );
                 appendsb"", 0 );
 
                 appendsb"rubySourceDirectory (Default: src/main/ruby)", 2 );
                 appendsb"the launch directory for the JRuby execution.\nCommand line -Djruby.sourceDirectory=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"task (Default: ${task})", 2 );
                 appendsb"the path to the application to be generated", 3 );
                 appendsb"", 0 );
             }
         }
 
         if (  == null || .length() <= 0 || "server".equals ) )
         {
             appendsb"rails3:server", 0 );
             appendsb"goal to run the rails server.", 1 );
             appendsb"", 0 );
             if (  )
             {
                 appendsb"Available parameters:", 1 );
                 appendsb"", 0 );
 
                 appendsb"args", 2 );
                 appendsb"common arguments\nCommand line -Dargs=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"binDirectory", 2 );
                 appendsb"directory of JRuby bin path to use when forking JRuby.", 3 );
                 appendsb"", 0 );
 
                 appendsb"env", 2 );
                 appendsb"either development or test or production or whatever else is possible with your config", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemArgs (Default: ${gem.args})", 2 );
                 appendsb"arguments for the gem command.", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemHome (Default: ${project.build.directory}/rubygems)", 2 );
                 appendsb"directory of gem home to use when forking JRuby.", 3 );
                 appendsb"", 0 );
 
                 appendsb"gemPath (Default: ${project.build.directory}/rubygems)", 2 );
                 appendsb"directory of JRuby path to use when forking JRuby.", 3 );
                 appendsb"", 0 );
 
                 appendsb"includeOpenSSL (Default: true)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"installRDoc (Default: false)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"installRI (Default: false)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyFork (Default: true)", 2 );
                 appendsb"fork the JRuby execution.\nCommand line -Djruby.fork=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyJvmArgs", 2 );
                 appendsb"arguments for the jruby command.\nCommand line -Djruby.jvmargs=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubySwitches", 2 );
                 appendsb"switches for the jruby command, like \'--1.9\'\nCommand line -Djruby.switches=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyVerbose (Default: false)", 2 );
                 appendsb"verbose jruby related output\nCommand line -Djruby.verbose=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"jrubyVersion", 2 );
                 appendsb"if the pom.xml has no runtime dependency to a jruby-complete.jar then this version is used to resolve the jruby-complete dependency from the local/remote maven repository. it overwrites the jruby version from the dependencies if any. i.e. you can easily switch jruby version from the commandline !\ndefault: 1.6.1\nCommand line -Djruby.version=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"launchDirectory (Default: ${project.basedir})", 2 );
                 appendsb"the launch directory for the JRuby execution.\nCommand line -Djruby.launchDirectory=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"plugin", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"project", 2 );
                 appendsb"reference to maven project for internal use.", 3 );
                 appendsb"", 0 );
 
                 appendsb"railsDir (Default: ${project.basedir}/src/main/rails)", 2 );
                 appendsb"(no description available)", 3 );
                 appendsb"", 0 );
 
                 appendsb"rubySourceDirectory (Default: src/main/ruby)", 2 );
                 appendsb"the launch directory for the JRuby execution.\nCommand line -Djruby.sourceDirectory=...", 3 );
                 appendsb"", 0 );
 
                 appendsb"serverArgs (Default: ${server.args})", 2 );
                 appendsb"arguments for the generate command", 3 );
                 appendsb"", 0 );
             }
         }
 
         if ( getLog().isInfoEnabled() )
         {
             getLog().infosb.toString() );
         }
     }

    

Repeat a String n times to form a new string.

Parameters:
str String to repeat
repeat number of times to repeat str
Returns:
String with repeated String
Throws:
java.lang.NegativeArraySizeException if repeat < 0
java.lang.NullPointerException if str is null
 
     private static String repeatString strint repeat )
     {
         StringBuffer buffer = new StringBufferrepeat * str.length() );
 
         for ( int i = 0; i < repeati++ )
         {
             buffer.appendstr );
         }
 
         return buffer.toString();
     }

    
Append a description to the buffer by respecting the indentSize and lineLength parameters. Note: The last character is always a new line.

Parameters:
sb The buffer to append the description, not null.
description The description, not null.
indent The base indentation level of each line, must not be negative.
 
     private void appendStringBuffer sbString descriptionint indent )
     {
         for ( Iterator it = toLinesdescriptionindent ).iterator(); it.hasNext(); )
         {
             sb.appendit.next().toString() ).append'\n' );
         }
     }

    
Splits the specified text into lines of convenient display length.

Parameters:
text The text to split into lines, must not be null.
indent The base indentation level of each line, must not be negative.
indentSize The size of each indentation, must not be negative.
lineLength The length of the line, must not be negative.
Returns:
The sequence of display lines, never null.
Throws:
java.lang.NegativeArraySizeException if indent < 0
 
     private static List toLinesString textint indentint indentSizeint lineLength )
     {
         List lines = new ArrayList();
 
         String ind = repeat"\t"indent );
         String[] plainLines = text.split"(\r\n)|(\r)|(\n)" );
         for ( int i = 0; i < plainLines.lengthi++ )
         {
             toLineslinesind + plainLines[i], indentSizelineLength );
         }
 
         return lines;
     }

    
Adds the specified line to the output sequence, performing line wrapping if necessary.

Parameters:
lines The sequence of display lines, must not be null.
line The line to add, must not be null.
indentSize The size of each indentation, must not be negative.
lineLength The length of the line, must not be negative.
 
     private static void toLinesList linesString lineint indentSizeint lineLength )
     {
         int lineIndent = getIndentLevelline );
         StringBuffer buf = new StringBuffer( 256 );
         String[] tokens = line.split" +" );
         for ( int i = 0; i < tokens.lengthi++ )
         {
             String token = tokens[i];
             if ( i > 0 )
             {
                 if ( buf.length() + token.length() >= lineLength )
                 {
                     lines.addbuf.toString() );
                     buf.setLength( 0 );
                     buf.appendrepeat" "lineIndent * indentSize ) );
                 }
                 else
                 {
                     buf.append' ' );
                 }
             }
             for ( int j = 0; j < token.length(); j++ )
             {
                 char c = token.charAtj );
                 if ( c == '\t' )
                 {
                     buf.appendrepeat" "indentSize - buf.length() % indentSize ) );
                 }
                 else if ( c == '\u00A0' )
                 {
                     buf.append' ' );
                 }
                 else
                 {
                     buf.appendc );
                 }
             }
         }
         lines.addbuf.toString() );
     }

    
Gets the indentation level of the specified line.

Parameters:
line The line whose indentation level should be retrieved, must not be null.
Returns:
The indentation level of the line.
 
     private static int getIndentLevelString line )
     {
        int level = 0;
        for ( int i = 0; i < line.length() && line.charAti ) == '\t'i++ )
        {
            level++;
        }
        for ( int i = level + 1; i <= level + 4 && i < line.length(); i++ )
        {
            if ( line.charAti ) == '\t' )
            {
                level++;
                break;
            }
        }
        return level;
    }