fig 0.1.39-java → 0.1.41-java

data/Changes

@@ -0,0 +1,45 @@
+v0.1.41
+
+  - Release cleanup
+
+v0.1.40
+
+  - Supports configuration via rc files in JSON format.  These can be (in
+    ascending order of priority of values):
+      - in the repository under "_meta/figrc"
+      - in your home directory in ".figrc"
+      - specified on the command-line via the "--figrc" option
+
+    Note that values from all the above locations will be merged into a
+    single, net application configuration.  E.g. if
+    <repository>/_meta/figrc contains
+
+      {"a" => 5, "b" => 7"}
+
+    and ~/.figrc contains
+
+      {"a" => 37}
+
+    then Fig will see a value for "a" of 37 and a value for "b" of 7.
+
+    Processing of ~/.figrc can be suppressed via the "--no-figrc" option.
+
+  - Supports logging via log4r. Configure via "log configuration" in the rc
+    files or via the "--log-config" and "--log-level" command-line options.
+    The configuration files must be in XML or YAML format in a way supported
+    by log4r and contain configuration for a "fig" logger.  The "--log-level"
+    will override any value found in the configuration files.
+
+  - Added additional messages about activity including file download source
+    and destination.  Try "--log-level debug".  Suggestions about changes to
+    levels that are supported, which levels messages are emitted at, and any
+    additional desired logging are welcome.
+
+  - Supports "-v/--version" to emit the Fig version.
+
+  - No longer silently does nothing when no arguments are specified.
+
+  - Start of support for restricting URLs in package.fig files via a URL
+    whitelist; not complete yet and will likely change.
+
+  - RSpec usage has been upgraded to v2.

data/LICENSE

@@ -11,8 +11,8 @@ modification, are permitted provided that the following conditions are met:
       notice, this list of conditions and the following disclaimer in the
       documentation and/or other materials provided with the distribution.
 
-    * The names of the contributors may not be used to endorse or promote 
-      products derived from this software without specific prior written 
+    * The names of the contributors may not be used to endorse or promote
+      products derived from this software without specific prior written
       permission.
 
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

data/README.md

@@ -1,94 +1,116 @@
 Description
 ===========
 
-Fig is a utility for configuring environments and managing dependencies across a team of developers. Fig takes a list of packages and a shell command to run, creates an environment that includes those packages, then executes the shell command in that environment. The caller's environment is not affected. 
-
-An "environment" in fig is just a set of environment variables. A "package" is a collection of files, plus some metadata describing what environment variables should be modified when the package is included. 
-
-Developers can use package files to specify the list of dependencies to use for different tasks. This file will typically be versioned along with the rest of the source files, ensuring that all developers on a team are using the same environemnts. 
-
-Packages exist in two places: a "local" repository in the user's home directory, and a "remote" repository on a shared server. Fig will automatically download packages from the remote repository and install them in the local repository as needed. 
-
-Fig is similar to a lot of other package/dependency managment tools. In particular, it steals a lot of ideas from Apache Ivy and Debian APT. However, unlike Ivy, fig is meant to be lightweight (no XML, no JVM startup time), language agnostic (Java doesn't get preferential treatment), and work with executables as well as libraries. And unlike APT, fig is cross platform and project-oriented.
+Fig is a utility for configuring environments and managing dependencies across a team of developers.
+
+An "environment" in fig is a set of environment variables.  A "package" is a
+collection of files, along with some metadata describing which environment variables
+should be modified when the package is included.  For instance, each dependency
+may prepend its corresponding jar to CLASSPATH.  The metadata may also list
+that package's lower-level Fig package dependencies. 
+
+Fig recursively builds an environment consisting of package dependencies
+(typically specified via command-line options or a package.fig file), each of
+which as noted above may have its own dependencies, and optionally executes a
+shell command in that environment.  The caller's environment is not affected.
+
+Developers can use package.fig files to specify the list of dependencies to use for
+different tasks. This file will typically be versioned along with the rest of
+the source files, ensuring that all developers on a team are using the same
+environemnts.
+
+Packages exist in two places: a "local" repository cache in the user's home
+directory--also called the fig-home--and a "remote" repository on a shared
+server. Fig will automatically download packages from the remote repository and
+install them in the fig-home as needed.  Fig does not contact the remote
+repository unless it needs to.  The fig-home is $HOME/.fighome, but may be
+changed by setting the $FIG_HOME environment variable.
+
+Fig is similar to a lot of other package/dependency-management tools. In
+particular, it steals a lot of ideas from Apache Ivy and Debian APT. However,
+unlike Ivy, fig is meant to be lightweight (no XML, no JVM startup time),
+language agnostic (Java doesn't get preferential treatment), and work with
+executables as well as libraries. And unlike APT, fig is cross platform and
+project-oriented.
 
 Installation
 ============
 
-Fig can be installed via rubygems. The gems are hosted at [Gemcutter](http://gemcutter.org), so you'll need to set that up first:
-
-    $ gem install gemcutter
-    $ gem tumble
-
-Fig also depends on a third-party library named
-[libarchive](http://libarchive.rubyforge.org/). Libarchive is easily available
-via most package management systems on Linux, FreeBSD, and OS X.  Libarchive
-versions greater than 2.6.0 are preferred.  If you are on Windows (not Cygwin Ruby), the gem will
-install the libarchive binaries for you.
-
-    [Linux - Debian / Ubuntu]
-    apt-get libarchive-dev
-
-    [Linux - Red Hat / CentOS]
-    yum install libarchive-devel
+     $ gem install fig
 
-    [OS X - MacPorts]
-    port install libarchive
+Or, if running Ruby 1.8.x...
 
-Then you can install fig:
-
-     $ gem install fig
+     $ gem install fig18
 
 Usage
 =====
 
-Fig recognizes the following options (not all are implemented yet):
+Fig recognizes the following options:
 
 ### Flags ###
 
-    -d, --debug              Print debug info
-        --force              Download/install packages from remote repository, even if up-to-date
-    -u, --update             Download/install packages from remote repository, if out-of-date
-    -m, --update-if-missing  Download/install packages from remote repository, if not already installed
-    -l, --login              Authenticate with remote server using username/password (default is anonymous)
-
-If the `--login` option is supplied, fig will look for credentials.  If
-environment variables `FIG_REMOTE_USER` and/or `FIG_REMOTE_PASSWORD` are
-defined, fig will use them instead of prompting the user.  If ~/.netrc exists,
-with an entry corresponding to the host parsed from `FIG_REMOTE_URL`, that
-entry will take precedence over `FIG_REMOTE_USER` and `FIG_REMOTE_PASSWORD`.
-If sufficient credentials are still not found, fig will prompt for whatever is
-still missing, and use the accumulated credentials to authenticate against the
-remote server.  Even if both environment variables are defined, fig will only
-use them if `--login` is given.
-
-### Environment Modifiers ###
-
-The following otpions modify the environment generated by fig:
-
-    -i, --include DESCRIPTOR  Include package in environment (recursive)
-    -p, --append  VAR=VALUE   Append value to environment variable using platform-specific separator
-    -s, --set     VAR=VALUE   Set environment variable
-
-### Environment Commands ###
-
-The following commands will be run in the environment created by fig:
-
-    -g, --get VARIABLE    Get value of environment variable
-    -- COMMAND [ARGS...]  Execute arbitrary shell command
-
-### Other Commands ###
-
-Fig also supports the following options, which don't require a fig environment. Any modifiers will be ignored:
-
-    -?, -h, --help   Display this help text
-    --publish        Upload package to the remote repository (also installs in local repository)
-    --publish-local  Install package in local repository only
-    --list           List packages in local repository   
-    --list-remote    List packages in remote repository
-
-When using the `--list-remote` command against an FTP server, fig uses a pool of FTP sessions to improve
-performance. By default it opens 16 connections, but that number can be overridden by setting the
-`FIG_FTP_THREADS` environment variable.
+    -?, -h, --help                   display this help text
+    -v, --version                    Print fig version
+    -p, --append VAR=VAL             append (actually, prepend) VAL to environment var VAR, delimited by separator
+        --archive FULLPATH           include FULLPATH archive in package (when using --publish)
+        --clean PKG                  remove package from $FIG_HOME
+    -c, --config CFG                 apply configuration CFG, default is 'default'
+    -d, --debug                      print debug info
+        --file FILE                  read fig file FILE. Use '-' for stdin. See also --no-file
+        --force                      force-overwrite existing version of a package to the remote repo
+    -g, --get VAR                    print value of environment variable VAR
+    -i, --include PKG                include PKG (with any variable prepends) in environment
+        --list                       list packages in $FIG_HOME
+        --list-configs PKG           list configurations in package
+        --list-remote                list packages in remote repo
+    -l, --login                      login to remote repo as a non-anonymous user
+        --no-file                    ignore package.fig file in current directory
+        --publish PKG                install PKG in $FIG_HOME and in remote repo
+        --publish-local PKG          install package only in $FIG_HOME
+        --resource FULLPATH          include FULLPATH resource in package (when using --publish)
+    -s, --set VAR=VAL                set environment variable VAR to VAL
+    -u, --update                     check remote repo for updates and download to $FIG_HOME as necessary
+    -m, --update-if-missing          check remote repo for updates only if package missing from $FIG_HOME
+        --figrc PATH                 use PATH file as .rc file for Fig
+        --no-figrc                   ignore ~/.figrc
+        --log-config PATH            use PATH file as configuration for Log4r
+        --log-level LEVEL            set logging level to LEVEL
+                                       (off, fatal, error, warn, info, debug, all)
+
+    --  end of fig options; everything following is a command to run in the fig environment.
+
+Some of these options may also be expressed as statements in a package.fig file.  For instance,
+`--append`, `--archive`, `--resource`, `include`.
+
+One point of frequent confusion revolves around which statements are concerned with publishing packages, and
+which are for downloading packages and otherwise modifying the Fig environment.  The same Fig file
+can contain both publish (e.g., `append`, `resource`) and download (e.g., `include`) statements,
+but you may not want to use the same
+dependency file for both publishing a package and specifying that same package's dependencies,
+since for example its "build-time" dependencies may differ from its "include-time" dependencies.
+Multiple config sections may be helpful in organizing these concerns.
+
+### Environment Variables Influencing Fig's Behavior ###
+
+    `FIG_FTP_THREADS`     Optional - Size of FTP session pool. Defaults to 16.
+    `FIG_HOME`            Optional - Location of local repo cache. Defaults to $HOME/.fighome.
+    `FIG_REMOTE_LOGIN`    Required for --login, unless $HOME/.netrc is configured.
+    `FIG_REMOTE_URL`      Require for operations involving the remote repository.
+    `FIG_REMOTE_USER`     Required for --login, unless $HOME/.netrc is configured.
+
+[--list-remote] When using the `--list-remote` command against an FTP server, fig uses a pool of FTP sessions to improve
+ performance. By default it opens 16 connections, but that number can be overridden by setting the
+ `FIG_FTP_THREADS` environment variable.
+
+[--login]   If the `--login` option is supplied, fig will look for credentials.  If
+ environment variables `FIG_REMOTE_USER` and/or `FIG_REMOTE_PASSWORD` are
+ defined, fig will use them instead of prompting the user.  If ~/.netrc exists,
+ with an entry corresponding to the host parsed from `FIG_REMOTE_URL`, that
+ entry will take precedence over `FIG_REMOTE_USER` and `FIG_REMOTE_PASSWORD`.
+ If sufficient credentials are still not found, fig will prompt for whatever is
+ still missing, and use the accumulated credentials to authenticate against the
+ remote server.  Even if both environment variables are defined, fig will only
+ use them if `--login` is given.
 
 Examples
 ========
@@ -101,43 +123,51 @@ Fig lets you configure environments three different ways:
 
 ### Command Line ###
 
-So to get started, let's trying defining an environment variable via the command line and executing a command in the newenvironment. We'll set the "GREETING" variable to "Hello", then run a command that uses that variable:
+To get started, let's define an environment variable via the command line and
+execute a command in the new environment. We'll set the "GREETING" variable to
+"Hello", then run a command that uses that variable:
 
-    $ fig -s GREETING=Hello -- echo "\$GREETING, World"
+    $ fig -s GREETING=Hello -- echo '$GREETING, World'
     Hello, World
 
-Note that you need to put a slash before the dollar sign, otherwise the shell will evaluate the environment variable before it ever gets to fig.
-
 Also note that when running fig, the original environment isn't affected:
 
      $ echo $GREETING
      <nothing>
 
-Fig also lets you append environment variables, using the system-specified path separator (e.g. colon on unix, semicolon on windows). This is useful for adding directories to the PATH, LD_LIBRARY_PATH, CLASSPATH, etc. For example, let's create a "bin" directory, add a shell script to it, then include it in the PATH:
+Fig also lets you append environment variables using the system-specified path separator (e.g. colon on unix, semicolon on windows). This is useful for adding directories to the PATH, LD_LIBRARY_PATH, CLASSPATH, etc. For example, let's create a "bin" directory, add a shell script to it, then include it in the PATH:
 
     $ mkdir bin
-    $ echo "echo \$GREETING, World" > bin/hello
+    $ echo 'echo $GREETING, World' > bin/hello
     $ chmod +x bin/hello
     $ fig -s GREETING=Hello -p PATH=bin -- hello
     Hello, World
 
 ### Fig Files ###
 
-You can also specify environment modifiers in files. Fig looks for a file called "package.fig" in the current directory, and automatically processes it. So we can implement the previous example by creating a "package.fig" file that looks like:
-        
+You can also specify environment modifiers in files. Fig looks for a file called "package.fig" in the current directory and automatically processes it.
+This "package.fig" file implements the previous example:
+
     config default
       set GREETING=Hello
       append PATH=@/bin
     end
-    
-The '@' symbol represents the directory that the "package.fig" file is in (this example would still work if we just used "bin", but later on when we publish our project to the shared repository we'll definitely need the '@'). Then we can just run:
+
+Then we can just run:
 
     $ fig -- hello
     Hello, World
 
-A single fig file can have multiple configurations:
+NOTE: The '@' symbol in a given package.fig file (or in a published dependency's .fig
+file) represents the full path to that file's directory.  The 
+above example would
+still work if we just used "bin", but later on when we publish our project to
+the shared repository we'll definitely need the '@', since the project directories will
+live in the fig-home rather than under our current directory).
+
+A single fig file may have multiple configurations:
 
-    config default 
+    config default
       set GREETING=Hello
       append PATH=@/bin
     end
@@ -147,14 +177,30 @@ A single fig file can have multiple configurations:
       append PATH=@/bin
     end
 
+### Config Sections ###
+
 Configurations other than "default" can be specified using the "-c" option:
 
     $ fig -c french -- hello
     Bonjour, World
-     
+
+A config section can be included in another config section:
+
+    config default
+      include :spanish
+    end
+
+    config spanish
+      set GREETING="Buenas Dias"
+      append PATH=@/bin
+    end
+
 ### Packages ###
 
-Now let's say we want to share our little script with the rest of the team by bundling it into a package. The first thing we need to do is specify the location of the remote repository by defining the `FIG_REMOTE_URL` environment variable. If you just want to play around with fig, you can have it point to localhost:
+Let's share our little script with the rest of the team by bundling it into a
+package and publishing it. First, point the `FIG_REMOTE_URL` environment
+variable to the remote repository. If you just want to play around with fig,
+you can have it point to localhost:
 
     $ export FIG_REMOTE_URL=ssh://localhost$(pwd)/remote
 
@@ -164,51 +210,59 @@ Before we publish our package, we'll need to tell fig which files we want to inc
 
     config default...
 
-Now we can share the package with the rest of the team by using the "--publish" option:
+Now we can share the package with the rest of the team by using the `--publish` option:
 
     $ fig --publish hello/1.0.0
 
-The "hello/1.0.0" string represents the name of the package and the version number. Once the package has been published, we can include it in other environments by using the "-i" or "--include" option (I'm going to move the "package.fig" file out of the way first, so that fig doesn't automatically process it.):
+Once the package has been published, we can include it in other environments 
+with the `-i` or `--include` option.  (For the purpose of this example, let's
+first move the "package.fig" file out of the way, so that it doesn't confuse
+fig or us.) The "hello/1.0.0" string represents the name of the package and the
+version number.
 
     $ mv package.fig package.bak
     $ fig -u -i hello/1.0.0 -- hello
     ...downloading files...
     Hello, World
-		
-The "-u" (or "--update") option tells fig to check the remote repository for packages if they aren't already installed locally (fig will never make any network connections unless this option is specified). Once the packages are downloaded, we can run the same command without the "-u" option:
+
+The `-u` (or `--update`) option tells fig to check the remote repository for packages if they aren't already installed locally (fig will never make any network connections unless this option is specified). Once the packages are downloaded, we can run the same command without the `-u` option:
 
     $ fig -i hello/1.0.0 -- hello
     Hello, World
 
-Also, when including a package, you can specify a particular configuration by appending it to the package name using a colon:
+When including a package, you can specify a particular configuration by appending it to the package name using a colon:
 
     $ fig -i hello/1.0.0:french -- hello
     Bonjour, World
 
 ### Retrieves ###
 
-By default, the resources associated with a package live in the fig home directory, which defaults to "~/.fighome". This doesn't always play nicely with IDE's however, so fig gives you a way to copy resources from the repository to the current directory. To do this you add "retrieve" statements to your "package.fig" file.
+By default, the resources associated with a package live in the fig home
+directory, which defaults to "$HOME/.fighome". This doesn't always play nicely with
+IDE's however, so fig provides a "retrieve" statement to copy resources from the repository to
+the current directory.
 
-For example, let's create a package that contains a library for the "foo" programming language. First we'll define a "package.fig" file:
+For example, let's create a package that contains a library for the "foo" programming language. Define a "package.fig" file:
 
     config default
-      append FOOPATH=lib/hello.foo
+      append FOOPATH=@/lib/hello.foo
     end
 
 Then:
 
     $ mkdir lib
     $ echo "print 'hello'" > lib/hello.foo
-    $ fig --publish hello-lib/3.2.1    
+    $ fig --publish hello-lib/3.2.1
 
-Now we'll move to a different directory (or delete the current "package.fig" file) and create a new "package.fig" file:
+Create a new "package.fig" file (first moving to a different directory or deleting the "package.fig" we just used for publishing):
 
     retrieve FOOPATH->lib/[package]
     config default
       include hello-lib/3.2.1
     end
 
-When we do an update, all resources in the FOOPATH will be copied into the lib directory, into a subdirectory that matches the package name:
+Upon a `fig --update`, each resource in FOOPATH will be copied into lib/[package], where [package] resolves to the resource's 
+package name (minus the version).
 
      $ fig -u
      ...downloading...

data/VERSION

@@ -0,0 +1 @@
+0.1.41

data/bin/fig

@@ -1,190 +1,12 @@
 #!/usr/bin/env ruby
 
-$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), %w< .. lib > ))
 
 require 'rubygems'
-require 'net/ftp'
 
-require 'fig/retriever'
-require 'fig/options'
-require 'fig/environment'
-require 'fig/repository'
-require 'fig/os'
-require 'fig/parser'
-require 'fig/windows'
+require 'fig'
 
 include Fig
 
-def parse_descriptor(descriptor)
-  # todo should use treetop for these:
-  package_name = descriptor =~ /^([^:\/]+)/ ? $1 : nil
-  config_name = descriptor =~ /:([^:\/]+)/ ? $1 : nil
-  version_name = descriptor =~ /\/([^:\/]+)/ ? $1 : nil  
-  return package_name, config_name, version_name
-end
-
-shell_command = nil
-ARGV.each_with_index do |arg, i|
-  if arg == "-"
-#    $stderr.puts "Use of single dash (-) is deprecated. Use double dash (--) instead"
-#    exit 1 
-  elsif arg == "--"
-    shell_command = ARGV[(i+1)..-1]
-    ARGV.slice!(i..-1)
-    break
-  end
-end
-
-options, argv = parse_options(ARGV)
-
-vars = {}
-ENV.each {|key,value| vars[key]=value }
-
-remote_url = nil
-if options[:update] || options[:publish] || options[:update_if_missing] || options[:list_remote]
-  remote_url = ENV['FIG_REMOTE_URL']
-  if remote_url.nil?
-    $stderr.puts "Please define the FIG_REMOTE_URL environment variable" 
-    exit 1
-  end
-end
-
-remote_user = nil
-if options[:publish]
-#  remote_user = ENV['FIG_REMOTE_USER']
-#  if remote_user.nil?
-#    $stderr.puts "Please define the FIG_REMOTE_USER environment variable" 
-#    exit 1
-#  end
-end
-
-os = OS.new(options[:login])
-repos = Repository.new(os, File.expand_path(File.join(options[:home], 'repos')), remote_url, remote_user, options[:update], options[:update_if_missing])
-retriever = Retriever.new(".")
-at_exit { retriever.save }
-env = Environment.new(os, repos, vars, retriever)
-
-options[:modifiers].each do |modifier|
-  env.apply_config_statement(nil, modifier, nil)
-end
-
-#if File.exist?(".fig")
-#  $stderr.puts "The '.fig' file is deprecated. Please rename to 'package.fig'"
-#  exit 1
-#end
-
-DEFAULT_FIG_FILE = 'package.fig'
-
-input = nil
-if options[:input] == :none
-  # ignore
-elsif options[:input] == '-'
-  input = $stdin.read
-elsif options[:input].nil?
-  input = os.read(DEFAULT_FIG_FILE) if os.exist?(DEFAULT_FIG_FILE)
-else
-  if os.exist?(options[:input])
-    input = os.read(options[:input])
-  else
-    $stderr.puts "File not found: #{options[:input]}"
-    exit 1
-  end
-end
-
-options[:cleans].each do |descriptor|
-  package_name, version_name = descriptor.split('/')
-  repos.clean(package_name, version_name)    
-end
-
-if options[:list]
-  repos.list_packages.sort.each do |item|
-    puts item
-  end
-  exit 0
-end
-
-if options[:list_remote]
-  repos.list_remote_packages.sort.each do |item|
-    puts item
-  end
-  exit 0
-end
-
-if not options[:list_configs].empty?
-  options[:list_configs].each do |descriptor|
-    package_name, version_name = descriptor.split('/')
-    repos.read_local_package(package_name, version_name).configs.each do |config|
-      puts config.name
-    end
-  end
-  exit 0
-end
-
-if input
-  package = Parser.new.parse_package(nil, nil, ".", input)
-  direct_retrieves=[]
-  if options[:retrieve]
-    package.retrieves.each do |var, path|
-      if var =~ /^@([^\/]+)(.*)/
-        direct_retrieves << [$1, $2, path]
-      else
-        env.add_retrieve(var, path)
-      end
-    end
-  end
-  unless options[:publish] || options[:list] || options[:publish_local]
-    env.register_package(package)
-    env.apply_config(package, options[:config], nil)
-    direct_retrieves.each do |info|
-      env.direct_retrieve(info[0], info[1], info[2])
-    end
-  end
-else
-  package = Package.new(nil, nil, ".", [])
-end
-
-if options[:publish] || options[:publish_local]
-  if !argv.empty?
-    $stderr.puts "Unexpected arguments: #{argv.join(' ')}"
-    exit 10
-  end
-  package_name, config_name, version_name = parse_descriptor(options[:publish] || options[:publish_local])
-  if package_name.nil? || version_name.nil?
-    $stderr.puts "Please specify a package name and a version name"
-    exit 10
-  end
-  if not options[:modifiers].empty?
-    publish_statements = options[:resources] + options[:archives] + [Configuration.new("default", options[:modifiers])]
-    publish_statements << Publish.new("default","default")
-  elsif not package.statements.empty?
-    publish_statements = package.statements
-  else
-    $stderr.puts "Nothing to publish"
-    exit 1
-  end
-  if options[:publish]
-    puts "Checking status of #{package_name}/#{version_name}..."
-    if repos.list_remote_packages.include?("#{package_name}/#{version_name}") 
-      puts "#{package_name}/#{version_name} has already been published"
-      if not options[:force]
-        puts "Use the --force option if you really want to overwrite, or us --publish-local for testing"
-        exit 1
-      else
-        puts "Overwriting..."
-      end
-    end
-  end
-  puts "Publishing #{package_name}/#{version_name}"
-  repos.publish_package(publish_statements, package_name, version_name, options[:publish_local])
-elsif options[:echo]
-  puts env[options[:echo]]
-elsif shell_command
-  argv.shift
-  env.execute_shell(shell_command) { |cmd| os.shell_exec cmd }
-elsif argv[0]
-  package_name, config_name, version_name = parse_descriptor(argv.shift)
-  env.include_config(package, package_name, config_name, version_name, {}, nil)
-  env.execute_config(package, package_name, config_name, nil, argv) { |cmd| os.shell_exec cmd }
-elsif input
-  env.execute_config(package, nil, options[:config], nil, argv) { |cmd| os.shell_exec cmd }
-end
+return_code = run_with_exception_handling(ARGV)
+exit return_code