origen 0.0.1 → 0.0.2

data/lib/origen/commands/target.rb

@@ -0,0 +1,27 @@
+module Origen
+  # === Task: $ origen -t [target]
+  # Sets or displays the default target.<br>
+  # The default target is the one that will be
+  # be used anytime you run an origen task without supplying a target via the -t option.
+  # ==== Supplying a target name
+  # The target argument can be any of the following:
+  # * A path to a file in the target directory, e.g. origen -t target/p2_production.rb
+  # * The name of a target, e.g. origen -t p2_production.rb
+  # * A fragment of a name. If this is enough to uniquely identify a target in from the
+  #   the target directory then this will be used, otherwise the list of possible matches
+  #   will be displayed. e.g. origen -t p2
+  # * A MOO number. The mapping of the MOO number to a target must be defined in
+  #   the production_targets attribute of Project. e.g. origen -t 1m79x
+  #
+  Origen.load_application
+
+  target = ARGV.shift
+  if target
+    Origen.app.target.default = target
+    puts "Target now set to: #{Origen.app.target.file.basename}"
+  else
+    Origen.app.target.describe
+  end
+
+  exit 0
+end

data/lib/origen/commands/time.rb

@@ -0,0 +1,127 @@
+require 'optparse'
+require 'pathname'
+
+options = {}
+
+ARGV << '-h' if ARGV.empty?
+
+# App options are options that the application can supply to extend this command
+app_options = @application_options || []
+opt_parser = OptionParser.new do |opts|
+  opts.banner = <<-STOP
+Origen test time profiling and forecasting tools.
+
+Usage: origen time CMD [args] [options]
+  CMD - The command to run, the following commands exist:
+
+        import FILE - Import a reference test time from the given detailed execution time file
+
+        forecast - Forecast the test time for the current target for the given flow and library
+
+        new rules   - Create a new rules file (use this to specify how tests should scale between targets)
+        new filter  - Create a new filter (use this to filter imports, by default all tests are imported)
+
+  STOP
+  opts.on('-n', '--name FILE', String, 'Use the given named reference instead of the default') { |o| options[:ref_name] = o }
+  opts.on('-s', '--summary', 'Output flow summary results only (instead of details for each test)') {  options[:summary] = true }
+  opts.on('-t', '--target NAME1,NAME2,NAME3', Array, 'Override the default target, NAME can be a full path or a fragment of a target file name') { |t| options[:target] = t }
+  opts.on('-d', '--debugger', 'Enable the debugger') {  options[:debugger] = true }
+  opts.on('-m', '--mode MODE', Origen::Mode::MODES, 'Force the Origen operating mode:', '  ' + Origen::Mode::MODES.join(', ')) { |_m| }
+  opts.on('-f', '--file FILE', String, 'Override the default log file') { |o| options[:log_file] = o }
+  app_options.each do |app_option|
+    opts.on(*app_option) {}
+  end
+  opts.separator ''
+  opts.on('-h', '--help', 'Show this message') { puts opts; exit }
+end
+opt_parser.parse! ARGV
+
+cmd = ARGV[0] || 'missing'
+case cmd.downcase
+when 'forecast'
+  Origen.target.loop(options) do |options|
+    Origen.app.runner.launch(action:   :forecast_test_time,
+                             summary:  options[:summary],
+                             ref_name: options[:ref_name])
+  end
+
+when 'import'
+  if !ARGV[1] || !File.exist?(ARGV[1])
+    puts 'A valid file to import must be supplied, e.g.'
+    puts '  origen time import exec_times/p2_sort1.txt'
+    exit 1
+  end
+  if options[:target] && [options[:target]].flatten.size > 1
+    puts "When importing it doesn't make sense to select multiple targets,"
+    puts 'select only the single target that matches the setup from which'
+    puts 'the detailed execution time has been generated!'
+    exit 1
+  end
+  Origen.target.loop(options) do |options|
+    # This step seems redundant, the flow should be imported at the
+    # same time as extracting the test times
+    Origen.app.runner.launch(action:   :import_test_flow,
+                             file:     ARGV[1],
+                             ref_name: options[:ref_name])
+
+    Origen.app.runner.launch(action:   :import_test_time,
+                             file:     ARGV[1],
+                             ref_name: options[:ref_name])
+  end
+
+when 'new'
+  if ARGV[1] == 'rules'
+    Origen.app.runner.launch(action:            :compile,
+                             file:              "#{Origen.top}/templates/time/rules.rb.erb",
+                             output:            "#{Origen.root}/config/test_time",
+                             quiet:             true,
+                             check_for_changes: false
+                            )
+    # Add this to the environment if not already present...
+    env = "#{Origen.root}/config/environment.rb"
+    unless File.readlines(env).any? { |l| l =~ /config\/test_time\/rules/ }
+      # The 'b' here invokes binary format and stops Ruby from substituting the \n for a
+      # windows carriage return when running on windows
+      File.open(env, 'ab') { |f| f.print "require \"\#{Origen.root}/config/test_time/rules\"\n" }
+      env = false
+    end
+    puts ''
+    puts 'New rules created at: config/test_time/rules.rb'
+    puts ''
+    unless env
+      puts 'This file has been added to your environment.rb'
+      puts ''
+    end
+    puts 'To check this in run:'
+    puts "  dssc ci -new -keep -com \"Initial\" #{Origen.root}/config/test_time/rules.rb"
+  elsif ARGV[1] == 'filter'
+    Origen.app.runner.launch(action:            :compile,
+                             file:              "#{Origen.top}/templates/time/filter.rb.erb",
+                             output:            "#{Origen.root}/config/test_time",
+                             quiet:             true,
+                             check_for_changes: false
+                            )
+    # Add this to the environment if not already present...
+    env = "#{Origen.root}/config/environment.rb"
+    unless File.readlines(env).any? { |l| l =~ /config\/test_time\/filter/ }
+      File.open(env, 'ab') { |f| f.print "require \"\#{Origen.root}/config/test_time/filter\"\n" }
+      env = false
+    end
+    puts ''
+    puts 'New filter created at: config/test_time/filter.rb'
+    puts ''
+    unless env
+      puts 'This file has been added to your environment.rb'
+      puts ''
+    end
+    puts 'To check this in run:'
+    puts "  dssc ci -new -keep -com \"Initial\" #{Origen.root}/config/test_time/filter.rb"
+
+  else
+    puts 'A valid identifier for the kind of file to create must be supplied, e.g.'
+    puts '  origen time new rules'
+    exit 1
+  end
+else
+  puts "Unknown command, see 'origen time -h' for a list of commands"
+end

data/lib/origen/commands/version.rb

@@ -0,0 +1,17 @@
+if Origen.app_loaded?
+  puts "Application: #{Origen.app.version}"
+  if Origen.config.required_origen_version && (Origen.config.required_origen_version != Origen.version)
+    puts "     Origen: #{Origen.version} (App requires #{Origen.config.required_origen_version})"
+  elsif Origen.config.min_required_origen_version &&
+        Origen.version.less_than?(Origen.config.min_required_origen_version)
+    puts "     Origen: #{Origen.version} (App requires >= #{Origen.config.min_required_origen_version})"
+  elsif Origen.config.max_required_origen_version &&
+        Origen.version.greater_than?(Origen.config.max_required_origen_version)
+    puts "     Origen: #{Origen.version} (App requires <= #{Origen.config.max_required_origen_version})"
+  else
+    puts "     Origen: #{Origen.version}"
+  end
+else
+  puts "     Origen: #{Origen.version}"
+end
+exit 0

data/lib/origen/commands/web.rb

@@ -0,0 +1,221 @@
+require 'optparse'
+require 'pathname'
+
+module Origen
+  options = {}
+
+  # App options are options that the application can supply to extend this command
+  app_options = @application_options || []
+  opt_parser = OptionParser.new do |opts|
+    opts.banner = <<-END
+Usage: origen web CMD [options]
+
+The following commands are available:
+  new             Create a fresh web directory (this will delete any existing compiled files!).
+                  A new directory will automatically be created if you don't have one when you run the compile
+                  command, however if for some reason you want to start fresh you can run this command to do so.
+
+  serve           Start a webserver from the current directory
+
+  compile [FILE]  Compile all web templates and start a server to view them, optionally supply a
+                  file argument to only update a single page e.g. 'origen web compile templates/web/index.md.erb'
+                  Use the --remote option to copy the compiled files to a remote web server directory (the
+                  location of which should be specified via Origen.config.web_directory). In this case when no
+                  FILE argument is specified the entire site will be copied over to a fresh web server
+                  directory and the live site will be switched over when complete.
+                  When a FILE argument is present the specified file(s) will be compiled directly to the live
+                  production site.
+
+  deploy [FILE]   Same as compile with --remote except that the actual compilation step will be skipped - i.e.
+                  use this in cases where you already have long-running templates pre-compiled.
+                  The api generation step will also be skipped if the --api option is supplied.
+
+  archive ID      Archive the current contents of your live website under the given ID. This is normally used
+                  to archive the documents for a specific production release, so "origen web archive Rel20120112"
+                  would be viewable at <your_domain>/Rel20120112.
+
+The following options are available:
+    END
+    opts.on('-e', '--environment NAME', String, 'Override the default environment, NAME can be a full path or a fragment of an environment file name') { |e| options[:environment] = e }
+    opts.on('-t', '--target NAME', String, 'Override the default target, NAME can be a full path or a fragment of a target file name') { |t| options[:target] = t }
+    opts.on('-r', '--remote', 'Use in conjunction with the compile command to deploy files to a remote web server') {  options[:remote] = true }
+    opts.on('-a', '--api', 'Generate API documentation after compiling') {  options[:api] = true }
+    opts.on('--archive ID', String, 'Archive the documents after compiling or deploying remotely') {  |id| options[:archive] = id }
+    opts.on('-d', '--debugger', 'Enable the debugger') {  options[:debugger] = true }
+    opts.on('-m', '--mode MODE', Origen::Mode::MODES, 'Force the Origen operating mode:', '  ' + Origen::Mode::MODES.join(', ')) { |_m| }
+    app_options.each do |app_option|
+      opts.on(*app_option) {}
+    end
+    opts.separator ''
+    opts.on('-h', '--help', 'Show this message') { puts opts; exit }
+  end
+  opt_parser.parse! ARGV
+
+  Origen.load_application
+  Origen.environment.temporary = options[:environment] if options[:environment]
+  Origen.target.temporary = options[:target] if options[:target]
+
+  def self._require_web_directory
+    unless Origen.config.web_directory
+      puts 'To run that command you must specify the location of your webserver, for example:'
+      puts ''
+      puts '# config/application.rb'
+      puts 'config.web_directory = "/proj/.web_origen/html/origen"'
+      exit 1
+    end
+  end
+
+  def self._start_server
+    # Get the current host
+    host = `hostname`.strip.downcase
+    if Origen.running_on_windows?
+      domain = 'fsl.freescale.net'
+    else
+      domain = `dnsdomainname`.strip
+    end
+    # Get a free port
+    require 'socket'
+    port = 8000 # preferred port
+    begin
+      server = TCPServer.new('127.0.0.1', port)
+    rescue Errno::EADDRINUSE
+      # port = rand(65000 - 1024) + 1024
+      port += 1
+      retry
+    end
+    server.close
+    # Start the server
+    puts ''
+    puts "Point your browser to this address:  http://#{host}#{domain.empty? ? '' : '.' + domain}:#{port}"
+    puts ''
+    puts 'To shut down the server use CTRL-C'
+    puts ''
+    system "ruby -run -e httpd . -p #{port}"
+  end
+
+  def self._build_web_dir
+    _deployer.create_web_server_dir
+
+    dir = Pathname.new(_deployer.web_server_dir).relative_path_from(Pathname.pwd)
+
+    puts "Web server directory created at: #{dir}"
+    puts ''
+    puts "Compile any files you want to test into the #{dir}/content directory, e.g.:"
+    puts "  origen c templates/file.md.erb -o #{dir}/content"
+    puts ''
+    puts 'To turn them into web pages:'
+    puts "  cd #{dir}"
+    if Origen.running_on_windows?
+      puts '  nanoc'
+    else
+      puts '  env LANG=en_US.UTF-8 nanoc'
+    end
+    puts ''
+    puts 'To start a web server for remote viewing:'
+    puts "  cd #{dir}/output"
+    puts '  origen web serve'
+  end
+
+  def self._deployer
+    @_deployer ||= Origen.app.deployer
+    @_deployer.test = true
+    @_deployer
+  end
+
+  if ARGV[0]
+    case ARGV.shift
+    when 'serve'
+      _start_server
+    when 'new'
+      _build_web_dir
+    when 'compile'
+      Origen.app.load_target!
+      if options[:remote]
+        _require_web_directory
+        _deployer.require_remote_directories
+        # If the whole site has been requested that start from a clean slate
+        _build_web_dir if ARGV.empty?
+      else
+        Origen.set_development_mode
+      end
+      if ARGV.empty?
+        _build_web_dir
+        Dir.chdir Origen.root do
+          Origen.app.listeners_for(:before_web_compile).each do |listener|
+            listener.before_web_compile(options)
+          end
+          Origen.app.runner.launch action: :compile,
+                                   files:  'templates/web',
+                                   output: 'web/content'
+          Origen.app.listeners_for(:after_web_compile).each do |listener|
+            listener.after_web_compile(options)
+          end
+        end
+
+      else
+        _build_web_dir unless File.exist?("#{Origen.root}/web")
+        Origen.app.listeners_for(:before_web_compile).each do |listener|
+          listener.before_web_compile(options)
+        end
+        ARGV.each do |file|
+          output = Origen.file_handler.sub_dir_of(Origen.file_handler.clean_path_to(file), "#{Origen.root}/templates/web")
+          Origen.app.runner.launch action: :compile,
+                                   files:  file,
+                                   output: "#{Origen.root}/web/content/#{output}"
+        end
+        Origen.app.listeners_for(:after_web_compile).each do |listener|
+          listener.after_web_compile(options)
+        end
+      end
+      Dir.chdir "#{Origen.root}/web" do
+        system "#{Origen.root}/lbin/nanoc"
+      end
+      if options[:api]
+        _deployer.generate_api
+      end
+      if options[:remote]
+        if ARGV.empty?
+          _deployer.deploy_site
+        else
+          ARGV.each do |files|
+            Origen.file_handler.resolve_files(files) do |file|
+              _deployer.deploy_file(file)
+            end
+          end
+        end
+        _deployer.deploy_archive(options[:archive]) if options[:archive]
+      else
+        Dir.chdir "#{Origen.root}/web/output" do
+          _start_server
+        end
+      end
+
+    when 'deploy'
+      Origen.app.load_target!
+      _require_web_directory
+      if ARGV.empty?
+        _deployer.deploy_site
+      else
+        ARGV.each do |files|
+          Origen.file_handler.resolve_files(files) do |file|
+            _deployer.deploy_file(file)
+          end
+        end
+      end
+      _deployer.deploy_archive(options[:archive]) if options[:archive]
+
+    when 'archive'
+      Origen.app.load_target!
+      _require_web_directory
+      unless ARGV[0]
+        puts 'You must supply an ID argument to create an archive'
+      end
+      _deployer.deploy_archive(ARGV[0])
+
+    else
+      puts "Unknown command, see 'origen web -h' for a list of commands"
+    end
+  else
+    puts "You must supply a command, see 'origen web -h' for a list of commands"
+  end
+end

data/lib/origen/commands.rb

@@ -0,0 +1,272 @@
+# Main entry point for all Origen commands, some global option handling
+# is done here (i.e. options that apply to all commands) before handing
+# over to the specific command handlers
+require 'optparse'
+
+ARGV << '--help' if ARGV.empty?
+
+ORIGEN_COMMAND_ALIASES = {
+  'g'         => 'generate',
+  'p'         => 'program',
+  't'         => 'target',
+  '-t'        => 'target',          # For legacy reasons
+  'e'         => 'environment',
+  '-e'        => 'environment',
+  'mods'      => 'modifications',
+  '-o'        => 'modifications',   # Legacy
+  'l'         => 'lsf',
+  'i'         => 'interactive',
+  'c'         => 'compile',
+  'pl'        => 'plugin',
+  '-v'        => 'version',
+  '--version' => 'version'
+}
+
+@command = ARGV.shift
+@command = ORIGEN_COMMAND_ALIASES[@command] || @command
+
+# Don't log to file during the save command since we need to preserve the last log,
+# this is done as early in the process as possible so any deprecation warnings during
+# load don't trigger a new log
+Origen::Log.console_only = (%w(save target environment version).include?(@command) || ARGV.include?('--exec_remote'))
+
+if ARGV.delete('--coverage') ||
+   ((@command == 'specs' || @command == 'examples') && (ARGV.delete('-c') || ARGV.delete('--coverage')))
+  require 'simplecov'
+  SimpleCov.start
+  Origen.log.info 'Started code coverage'
+  SimpleCov.configure do
+    filters.clear # This will remove the :root_filter that comes via simplecov's defaults
+    add_filter do |src|
+      !(src.filename =~ /^#{Origen.root}\/lib/)
+    end
+
+    # Results from commands run in succession will be merged by default
+    use_merging(!ARGV.delete('--no_merge'))
+
+    # Try and make a guess about which directory contains the bulk of the application's code
+    # and create groups to match the main folders
+    d1 = "#{Origen.root}/lib/#{Origen.app.name.to_s.underscore}"
+    d2 = "#{Origen.root}/lib/#{Origen.app.namespace.to_s.underscore}"
+    d3 = "#{Origen.root}/lib"
+    if File.exist?(d1) && File.directory?(d1)
+      dir = d1
+    elsif File.exist?(d2) && File.directory?(d2)
+      dir = d2
+    else
+      dir = d3
+    end
+
+    Dir.glob("#{dir}/*").each do |d|
+      d = Pathname.new(d)
+      if d.directory?
+        add_group d.basename.to_s.camelcase, d.to_s
+      end
+    end
+
+    command_name @command
+
+    path_to_coverage_report = Pathname.new("#{Origen.root}/coverage/index.html").relative_path_from(Pathname.pwd)
+
+    at_exit do
+      SimpleCov.result.format!
+      puts ''
+      puts 'To view coverage report:'
+      puts "  firefox #{path_to_coverage_report} &"
+      puts ''
+    end
+  end
+end
+
+require 'origen/global_methods'
+include Origen::GlobalMethods
+
+Origen.lsf.current_command = @command
+Origen.send :current_command=, @command
+
+if ARGV.delete('-d') || ARGV.delete('--debug')
+  begin
+    if RUBY_VERSION >= '2.0.0'
+      require 'byebug'
+    else
+      require 'rubygems'
+      require 'ruby-debug'
+    end
+  rescue LoadError
+    def debugger
+      caller[0] =~ /.*\/(\w+\.rb):(\d+).*/
+      puts 'The debugger gem is not installed, add the following to your Gemfile:'
+      puts
+      puts "if RUBY_VERSION >= '2.0.0'"
+      puts "  gem 'byebug', '~>3.5'"
+      puts 'else'
+      puts "  gem 'debugger', '~>1.6'"
+      puts 'end'
+      puts
+    end
+  end
+  Origen.enable_debugger
+else
+  def debugger
+    caller[0] =~ /.*\/(\w+\.rb):(\d+).*/
+    puts "#{Regexp.last_match[1]}:#{Regexp.last_match[2]} - debugger statement ignored, run again with '-d' to enable it"
+  end
+end
+
+if ARGV.include?('-verbose') || ARGV.include?('--verbose')
+  options ||= {}
+  Origen.log.level = :verbose
+  ARGV.delete('-verbose')
+  ARGV.delete('--verbose')
+end
+
+if ARGV.include?('-silent') || ARGV.include?('--silent')
+  options ||= {}
+  Origen.log.level = :silent
+  ARGV.delete('-silent')
+  ARGV.delete('--silent')
+end
+
+# If the current command is an LSF execution request (that is a request to
+# execute a non-Origen command remotely)
+if (@command == 'lsf' || @command == 'l') && (ARGV.include?('-e') || ARGV.include?('--execute'))
+  # Don't apply these global options yet, pass them through to the underlying command
+else
+  if ARGV.delete('--profile')
+    # This means that as well as applying to the current thread, this option will also
+    # be applied to any remote jobs triggered by this thread
+    Origen.app.lsf_manager.add_command_option('--profile')
+    Origen.enable_profiling
+  end
+  if ARGV.delete('--exec_remote') && @command != 'lsf' && @command != 'l'
+    Origen.running_remotely = true
+  end
+  # Set the Origen operating mode if supplied
+  ix = ARGV.index('-m') || ARGV.index('--mode')
+  if ix
+    ARGV.delete_at(ix)
+    mode = ARGV[ix]
+    ARGV.delete_at(ix)
+    Origen.app.lsf_manager.add_command_option('--mode', mode)
+    Origen.mode = mode
+    # Make sure this sticks for the remainder of this thread
+    Origen.mode.freeze
+  end
+end
+
+# Give application commands the first shot at executing the given command,
+# the application file must exit upon servicing the command if it wants to
+# prevent Origen from then having a go.
+# This order is preferable to allowing Origen to go first since it allows
+# overloading of Origen commands by the application.
+if File.exist? "#{Origen.root}/config/commands.rb"
+  require "#{Origen.root}/config/commands"
+end
+
+shared_commands = Origen.import_manager.command_launcher
+@plugin_commands ||= []
+if shared_commands && shared_commands.size != 0
+  shared_commands.each do |file|
+    require file
+  end
+end
+
+case @command
+when 'generate', 'program', 'compile', 'merge', 'interactive', 'target', 'environment',
+     'ctags', 'save', 'lsf', 'web', 'time', 'dispatch', 'rc', 'lint', 'plugin' # , 'add'
+
+  require "origen/commands/#{@command}"
+  exit 0 unless @command == 'interactive'
+
+when 'upgrade_app'
+  Origen::CodeGenerators.invoke 'bundler', [], config: { type: :application }
+  Origen::CodeGenerators.invoke 'rake', []
+  Origen::CodeGenerators.invoke 'r_spec', ['-f']
+  exit 0
+
+when 'upgrade_plugin'
+  unless Origen.app.version.semantic?
+    puts 'To upgrade to a gem your plugin must switch to semantic (1.2.3) style versioning.'
+    puts
+  end
+  Origen::CodeGenerators.invoke 'semver', []
+  Origen::CodeGenerators.invoke 'gem_setup', []
+  Origen::CodeGenerators.invoke 'bundler', []
+  Origen::CodeGenerators.invoke 'rake', []
+  Origen::CodeGenerators.invoke 'r_spec', ['-f']
+  exit 0
+
+when 'version'
+  Origen.disable_origen_version_check do
+    Origen.load_application(false)
+    require 'origen/commands/version'
+  end
+
+when 'serve'
+  puts '***************************************************************'
+  puts "'origen serve' is deprecated, please use 'origen web serve' instead"
+  puts '***************************************************************'
+  ARGV.unshift 'serve'
+  load 'origen/commands/web.rb'
+
+when 'tag'
+  puts '***************************************************************'
+  puts "'origen tag' is deprecated, please use 'origen rc tag' instead"
+  puts '***************************************************************'
+  ARGV.unshift 'tag'
+  load 'origen/commands/rc.rb'
+
+when 'modifications'
+  puts '***************************************************************'
+  puts "'origen mods' is deprecated, please use 'origen rc mods' instead"
+  puts '***************************************************************'
+  ARGV.unshift 'modifications'
+  load 'origen/commands/rc.rb'
+
+else
+  puts "Error: Command not recognized: #{@command}" unless ['-h', '--help'].include?(@command)
+  puts <<-EOT
+Usage: origen COMMAND [ARGS]
+
+The core origen commands are:
+ environment  Display or set the default environment (short-cut alias: "e")
+ target       Display or set the default target (short-cut alias: "t")
+ generate     Generate a test pattern (short-cut alias: "g")
+ program      Generate a test program (short-cut alias: "p")
+ interactive  Start an interactive Origen console (short-cut alias: "i")
+ compile      Compile a template file or directory (short-cut alias: "c")
+ rc           Revision control commands, see -h for details
+ ctags        Generate ctags file (can be used for code navigation)
+ save         Save the new or changed files from the last run or a given log file
+ lsf          Monitor and manage LSF jobs (short-cut alias: "l")
+ web          Web page tools, see -h for details
+ time         Tools for test time analysis and forecasting
+ lint         Lint and style check (and correct) your application code
+ plugin       Manage Origen plugins (short-cut alias: "pl")
+
+  EOT
+  if @application_commands && !@application_commands.empty?
+    puts <<-EOT
+In addition to these the application has added:
+#{@application_commands}
+EOT
+  end
+
+  if @plugin_commands && !@plugin_commands.empty?
+    puts 'The following commands are provided by plugins:'
+    @plugin_commands.each do |str|
+      puts str
+    end
+  end
+
+  puts <<-EOT
+
+All commands can be run with -d (or --debugger) to enable the debugger.
+All commands can be run with --coverage to enable code coverage.
+Many commands can be run with -h (or --help) for more information.
+
+  EOT
+
+  # dispatch     Dispatch an Origen command to a worker farm
+  exit(1)
+end