prick 0.29.2 → 0.30.0

data/exe/prick

@@ -10,16 +10,14 @@ begin
     compile_cache_iseq:   true,                 # Compile Ruby code into ISeq cache, breaks coverage reporting.
     compile_cache_yaml:   true                  # Compile YAML into a cache
   )
-# Bootsnap.instrumentation = ->(event, path) { puts "#{event} #{path}" }
+  # Bootsnap.instrumentation = ->(event, path) { puts "#{event} #{path}" }
 end
 
 require 'shellopts'
-require_relative '../lib/prick.rb'
-
-include ShellOpts
-include Prick
 
-TIME = false
+# Start time of prick. Used in make and build to compute duration of the whole
+# build process
+TIME = Time.now
 
 SPEC = %(
   @ Prick project command
@@ -33,63 +31,91 @@ SPEC = %(
   -C,directory=EDIR
       Change to directory DIR before doing anything else
 
-  -d,database=DATABASE
-      Override database name. Default is read from .prick.context
+  -p,project-file=PRICK-FILE
+      Override project file. Default is 'prick.yml'
 
-  -U,username=USERNAME
-      Override username. Default is read from .prick.context
+  -e,environment-file=ENVIRONMENT-FILE
+      Override the environment file. Default is 'prick.environment.yml'
 
-  -e,environment=ENVIRONMENT
-      Override environment. Default is read from from .prick.context
+  -s,state-file=STATE-FILE
+      Override state file. Default is '.prick-state.yml'
 
-  -p,project=PRICK-FILE
-      Override default environment file ('prick.yml')
+  init! -n,name=NAME -t,title=TITLE DIRECTORY #@ Initialize new Prick project directory
+      Initializes a prick project and checks it into git. If a directory is
+      given the directory will be created and the project initialized in it.
+      Default name and title is derived from the directory name
 
-  -c,context=CONTEXT-FILE
-      Override default context file ('.prick.context')
+  setup! -- [OWNER@]DATABASE [ENVIRONMENT] @ Create and set current database
+      Create database and owner and set the current database
 
-  version!
-      Print project version
+  teardown! -- [DATABASE...] @ Remove database and owner
+      Drop database, database users, and database owner if possible and not the
+      current user. DATABASE defaults to the current database in which case the
+      state file is also removed
 
-  init! -n,name=NAME -t,title=TITLE [DIRECTORY]
-      Initializes a prick project
+  clean! -- [DATABASE] @ Empty database and remove users
+      Empty the database and drop related users except the database owner and
+      the prick schema. The public schema is recreated automatically
 
-  env! ENVIRONMENT
-      Set build environment in the prick context file. The environment is
-      accessible as $ENVIRONMENT in build.yml files and can be used to do
-      conditional builds. There are no built-in values for the environment but
-      'production' and 'development' will be typical choices. Defaults to
-      'development'
+  get.database!
+      Print the name of the current database
 
-  setup!
-      Create the database user (if necessary) and an empty database
+  get.username!
+      Print the name of the current database owner
 
-  teardown!
-      Drop the database and the database user. TODO: Also run teardown scripts
+  get.environment!
+      Print the current environment
 
-  clean!
-      Empties the database and drops related users except the database user
+  set! -- VARIABLE [VALUE [OPT]] @ Switch database/environment
+      Switch database and/or environment or assign a value to the corresponding
+      database variable Currently only 'database', 'environment', and
+      'duration' can be used as arguments. 'duration' not meant for the
+      end-user but for make scripts that enclose the prick command and that
+      would like to record the total time used.  Prints the value of the
+      variable if VALUE is absent
 
-  create.data!
-  create.schema!
-  create.database!
-  create.users!
-  create.all!
-      Create an object. Fails if migration exist unless the --force flag is given
+  create.database! -- [[OWNER@]DATABASE [ENVIRONMENT]] @ Create database
+      Create database and owner if needed. OWNER defaults to the database
+      name and DATABASE defaults to the project name. ENVIRONMENT defaults to
+      the current environment or to the prick default environment if there is
+      no current environment
 
-  create.migration! -f,force -o,file=FILE -- VERSION
+      It is an error if the database exists but not if the owner exists. Note
+      that you can have multiple databases and switch between them using the
+      'set database' subcommand
+
+  create.migration! -f,force -o,file=FILE -- VERSION @ Create migration
       Create a migration from VERSION to the current and write it to
       migration/VERSION. Fails if migration exist unless the --force flag is
       given. If --file is given, the migration is written to FILE instead of
-      the migration directory. This doesn't require you to be on a release
-      branch and can be used to create ad-hoc migration scripts
+      the migration directory
+
+  create.users!
+  create.schema!
+  create.data!
+  create.all!
+      TODO
+
+  drop.schema! -- [SCHEMA...]
+      @ Drop schemas
+
+      Drops the given schemas or all schemas if called without arguments
+
+  drop.users!
+      @ Drop database users
+
+      Drops all database users except the database owner
+
+  drop.data!
+      @ Drop data
+
+      TODO
 
-  drop! -- [KIND]
-      @ Drop objects
+  drop.owner!
+      Drop database owner
 
-      Kind can be 'users', 'data', 'schema', 'user', 'database' (the default),
-      or 'all'. It is not an error if the object doesn't exist. TODO 'data' and
-      'schema' is not implemented
+  drop.database!
+      Drop database
 
   build! -f,force -t,time --dump=KIND? -- [SCHEMA]
       Build the project. If SCHEMA is defined, later schemas are excluded.
@@ -112,6 +138,9 @@ SPEC = %(
 
       # TODO: A --clean option that resets data
 
+  version!
+      Print project version
+
   release! -- KIND
       Create a release of the given kind. KIND can be 'major', 'minor', or
       'patch'. Release checks that the current repo is clean and up to date
@@ -120,146 +149,277 @@ SPEC = %(
   migrate! -f,file=FILE
       Execute a migration
 
-  dump.type!
-  dump.data!
-  dump.schema!
-  dump.database!
-  dump.environment!
-      TODO
+  list.environments! -l,long
+      List available environments (environments with a comment field)
+
+  list.databases! -l,long
+      List Prick databases. The --long option creates a table-like output
+
+  list.users!
+      List database users in the current environment
+
+  list.owners! -l,long
+      List database owners
+
+  list.variables! -l,long -a,all
+      List variables for the current environment
 
   dump.migration! --force -- VERSION
+  
+  dump.type!
+      Dumps a PgGraph object
+
+  dump.variable! -x,export -l,local -- [VARIABLE...]
+      Dumps a bash source snippets that sets and optionally exports values from
+      the configuration, environment, and state. Environment is only dumped if
+      the current environment is defined in the state file. The state file may
+      be absent in which case the related variables are also left undefined
+
+  dump.value! -- VARIABLE...
+      Dumps values of the given variables. Multiple variables can be read into bash
+      variables using read: 
+        
+          read name title <<< $(prick dump value PRICK_NAME PRICK_TITLE)
+
+  dump.node!
+  dump.build!
+  dump.data! @ TODO
+  dump.schema! @ TODO
+  dump.database! @ TODO
+      TODO
 )
 
-opts, args = ShellOpts.process(SPEC, ARGV, exception: true)
+def require_db(database = Prick.state&.database, exist: true) 
+  database or raise ArgumentError
+  dba = State.connection
+  if exist
+    dba.rdbms.exist?(database) or Prick.error "Can't find database '#{database}'"
+    if Prick.state&.conn&.name == database
+      close_conn = false
+      conn = Prick.state.conn
+    else
+      close_conn = true
+      conn = PgConn.new(database)
+    end
+    conn.schema.exist?("prick") or Prick.error "Database '#{database}' is not a Prick database"
+    conn.close if close_conn # Close session explicitly so we can drop database if required
+  else
+    !dba.rdbms.exist?(database) or Prick.error "Database '#{database}' exists"
+  end
+end
+
+def parse_database_args(state, args)
+  arg, environment = args.expect(0..2)
+  if arg
+    if arg =~ /^(.*)@(.*)$/
+      username, database = $1, $2
+    else
+      database = arg
+      username = database
+    end
+  else
+    database = state.name
+    username = database
+  end
+  database or Prick.error "Database is undefined"
+  [username, database, environment]
+end
+
+begin
+  # Parse command line
+  opts, args = ShellOpts.process(SPEC, ARGV, exception: true)
+
+  # Honor -C option
+  begin
+    Dir.chdir(opts.directory) if opts.directory?
+  rescue Errno::ENOENT
+    raise ShellOpts::Error, "Can't cd to '#{opts.directory}'"
+  end
+rescue ShellOpts::Error => ex
+  ShellOpts.error(ex.message)
+end
+
+# Require prick only after -C directory option because some constants depends
+# on the current directory
+require_relative '../lib/prick.rb'
+include Prick
 
 begin
   # Handle verbose and quiet
   $verbose = opts.verbose?
   $quiet = opts.quiet?
 
-  # Honor -C option
-  if opts.directory?
-    if File.exist?(opts.directory)
-      begin
-        Dir.chdir(opts.directory)
-      rescue Errno::ENOENT
-        raise Prick::Error, "Can't cd to '#{opts.directory}'"
-      end
-    else
-      raise Prick::Error, "Can't find directory: #{opts.directory}"
-    end
-  end
+  # Expect a sub-command. TODO: Make this a built-in in ShellOpts#subcommand!
+  cmd = opts.subcommand! or Prick.error "Subcomand expected"
 
-  # Get subcommand
-  cmd = opts.subcommand!
+  # Handle -p, -e, and -c. TODO: Take -C into account for relative paths. Low-hanging fruit
+  project_file = opts.project_file || PRICK_PROJECT_PATH
+  environment_file = opts.environment_file || PRICK_ENVIRONMENT_PATH
+  state_file = opts.state_file || PRICK_STATE_PATH
 
-  # Process init command
-  if opts.subcommand == :init
-    dir, state = Prick::SubCommand.init(args.expect(0..1), cmd.name, cmd.title, opts.database, opts.username)
-    puts "Initialized prick project '#{state.name}' in #{dir}"
-    if opts.database.nil? || opts.username.nil?
-      puts
-      puts "Please check database/username in #{PRICK_CONTEXT_FILE}"
-    end
+  # Process init command and exit
+  if opts.subcommand == :init!    
+    dir, name = Prick::SubCommand.init(project_file, args.expect(0..1), cmd.name, cmd.title)
+    Prick.mesg "Initialized Prick project '#{name}' in #{File.absolute_path(dir)}/"
     exit
   end
 
-  # Check state
-  File.exist?(PRICK_PROJECT_FILE) or raise Prick::Error, "Not in a prick project directory"
-
-  # Handle -p and -c
-  project_file = opts.project || PRICK_PROJECT_PATH
-  context_file = opts.context || PRICK_CONTEXT_PATH
+  # Check for prick project
+  if ![:teardown!, :clean!].include?(opts.subcommand) || args.size == 0
+    # We test for the presense of the schema directory to verify we're in a
+    # prick directory. Checking for a configuration file doesn't work because
+    # they can be placed elsewhere. TODO: This require us to check for project file manually
+#   File.directory? "schema" or Prick.error "Not in a prick project directory"
+    File.directory?(SCHEMA_DIR) or Prick.error "Not in a prick project directory"
+    File.exist?(project_file) or Prick.error "Can't find project file '#{project_file}'"
+  end
 
   # Load state
-  state = Prick.state = State.load(project_file, context_file)
-
-  # Set database, username and environment
-  database = state.database = opts.database || state.database
-  username = state.username = opts.username || state.username
-  environment = state.environment = opts.environment || state.environment
+  state = Prick.state = State.new(project_file, environment_file, state_file)
 
-  # Expect a sub-command
-  cmd = opts.subcommand! or raise Prick::Error, "Subcomand expected"
+  # Lazyness
+  database = state.database
+  username = state.username
+  environment = state.environment
 
   # Process subcommands
   case opts.subcommand
     when :version!
       puts "#{Prick.state.name}-#{Prick.state.version}"
 
-    when :env!
-      env = args.expect(1)
-      Prick.state.environment = env
-      Prick.state.save
-
     when :setup!
-      Prick::SubCommand.setup(database, username)
+      state.project_loaded? or Prick.error "No #{project_file} found"
+      username, database, environment = parse_database_args(state, args)
+      require_db(database, exist: false)
+      Prick::SubCommand.setup(database, username, environment)
 
+    # FIXME Ensure that we never drop the current user
     when :teardown!
-      Prick::SubCommand.teardown(database, username)
+      if args.empty?
+        Prick::SubCommand.teardown(database, remove_state_file: true)
+      else
+        Prick::SubCommand.teardown(args)
+      end
+
+    when :get!
+      case cmd.subcommand
+        when :database!; puts database
+        when :username!; puts username
+        when :environment!; puts environment
+      else
+        raise ArgumentError
+      end
+
+    when :set!
+      variable, *args = args.expect(1..3)
+      require_db(database) if variable == "duration"
+      Prick::SubCommand.set(variable, *args) or error "Illegal variable name '#{variable}'"
 
     when :clean!
+      database = args.expect(0..1) || database
+      require_db(database)
       Prick::SubCommand.clean(database)
 
     when :create!
-      create_command = opts.create!
+      create_command = opts.create! # Because we need easy access to subcommand options
       case create_command.subcommand
-        when :migration
+        when :database!
+          database, username, environment = parse_database_args(state, args)
+          require_db(database, exist: false)
+          Prick::SubCommand.create_database(database, username, environment)
+        when :migration!
+          require_db
           arg = args.expect(1)
-          version = PrickVersion.try(arg) or raise Prick::Error, "Illegal version: #{arg}"
+          version = PrickVersion.try(arg) or Prick.error "Illegal version: #{arg}"
           Prick::SubCommand.create_migration(
               username, version, 
               force: create_command.subcommand!.force?, 
               file: create_command.subcommand!.file)
+        when :users, :schema, :data, :all
+          raise NotImplementedError
       else
-        raise NotImplementedError
+        raise ArgumentError
       end
 
     when :build!
+      require_db
       dump = cmd.dump? ? cmd.dump("batches")&.to_sym || :batches : nil
 #     exclude = cmd.exclude? ? cmd.exclude.split(",") : []
       Prick::SubCommand.build(
           database, username, args.expect(0..1), force: cmd.force?, timer: cmd.time?, dump: dump)
 
     when :make!
+      require_db
       dump = cmd.dump? ? cmd.dump("batches")&.to_sym || :batches : nil
       Prick::SubCommand.make(database, username, args.expect(0..1), timer: cmd.time?, dump: dump)
 
     when :fox!
+      require_db
       Prick::SubCommand.fox(database, username, args)
 
     when :drop!
-      case subject = args.expect(1).to_sym
-        when :all
-          Prick::SubCommand.drop_all(database)
-        when :users
+      require_db if cmd.subcommand != :owner!
+      if cmd.subcommand == :schema!
+        schemas = args.to_a
+      else
+        args.expect(0)
+      end
+      case cmd.subcommand
+        when :all!
+          Prick::SubCommand.drop_all(database, username)
+        when :users!
           Prick::SubCommand.drop_users(database)
-        when :user
-          Prick::SubCommand.drop_user(username)
-        when :database
+        when :owner!
+          Prick::SubCommand.drop_owner(username)
+        when :database!
           Prick::SubCommand.drop_database(database)
-        when :data, :schema
+        when :data!
           raise NotImplementedError
+        when :schema!
+          Prick::SubCommand.drop_schema(database, schemas)
       else
-        raise Prick::Error, "Unknown subject: #{subject}"
+        Prick.error "Unknown subject: #{subject}"
       end
 
     when :release!
       kind = args.expect(1).to_sym
       constrain? kind, :major, :minor, :patch or 
-          raise Prick::Fail, "Expected 'major', 'minor', or 'patch' argument, got '#{kind}'"
+          Prick.failure "Expected 'major', 'minor', or 'patch' argument, got '#{kind}'"
       Prick::SubCommand.release(kind)
 
     when :migrate!
+      require_db
       args.expect(0)
       Prick::SubCommand.migrate(database, username, file: cmd.file)
 
+    when :list!
+      format = (cmd.subcommand!.long? ? :long : :short) if cmd.subcommand != :users!
+      case cmd.subcommand
+        when :environments!; Prick::SubCommand.list_environments(format: format)
+        when :databases!; Prick::SubCommand.list_databases(format: format)
+        when :variables!; 
+          all = cmd.subcommand!.all?
+          Prick::SubCommand.list_variables(format: format, all: all)
+        when :users!; Prick::SubCommand.list_users
+        when :owners!; Prick::SubCommand.list_owners(format: format)
+      else
+        Prick.error "Unknown subcommand: #{cmd.subcommand}"
+      end
+
     when :dump!
       subject = cmd.subcommand!
       case cmd.subcommand
+        when :node!
+          conn = PgConn.new(database, username)
+          builder = Prick::Build::Builder.new(conn, Prick::SCHEMA_DIR)
+          builder.root.dump
+        when :build!
+          conn = PgConn.new(database, username)
+          builder = Prick::Build::Builder.new(conn, Prick::SCHEMA_DIR)
+          # FIXME Nothing happens here
         when :migration!
           arg = args.expect(1)
-          version = PrickVersion.try(arg) or raise "Illegal version number: #{arg}"
+          version = PrickVersion.try(arg) or Prick.error "Illegal version number: #{arg}"
           Prick::SubCommand.create_migration(username, version, force: subject.force?, file: "/dev/stdout")
         when :type!
           conn = PgConn.new(database, username)
@@ -269,15 +429,25 @@ begin
           graph.dump
         when :data!, :schema!, :database!
           raise NotImplementedError
-        when :environment!
-          puts state.bash_source
+        when :variable!
+          scope =
+              case [subject.export?, subject.local?] 
+                in [true, false]; :global
+                in [false, true]; :local
+                in [false, false]; nil
+              else
+                Prick.error "Conflicting options - --export and --local"
+              end
+          puts state.bash_source(args.first ? args : nil, scope: scope)
+          exit
+        when :value!
+          puts args.expect(1..).map { |var| Array(state.bash_environment[var]).join(' ') }
       else
-        raise Prick::Error, "Unknown dump object: #{cmd.subcommand!.__name__}"
+        object = args.extract(1) # Fails if object is absent
+        Prick.error "Unknown dump object: #{object}"
       end
-
-
     else
-      raise Prick::Fail, "Internal error: Unhandled command - #{opts.subcommand.inspect}"
+      Prick.failure "Internal error: Unhandled command - #{opts.subcommand.inspect}"
   end
 
 rescue Prick::Build::PostgresError => ex
@@ -295,409 +465,11 @@ rescue Prick::Build::PostgresError => ex
   end
   exit 1
 
-rescue RuntimeError, IOError, ShellOpts::Failure, Prick::Fail, Prick::Build::PostgresError => ex 
-  ShellOpts.failure(ex.message)
-
 rescue ShellOpts::Error, Prick::Error => ex
+  raise
   ShellOpts.error(ex.message)
-end
-
-
-__END__
-
-  -n,name=NAME
-      Name of project. Defauls to the environment variable `PRICK_PROJECT` if
-      set and else the name of the current directory
-
-  init! -u,user=USER [NAME]
-      Initialize a project in the given directory. The USER is the postgres
-      user and defaults to the project name
-
-  info!
-      Print project information
-
-  list.releases! -m,migrations -c,cancelled 
-      List releases. Include migration releases if the --migration option is
-      present and also include cancelled releases if the --cancelled option is
-      present
-
-  list.migrations! 
-      List migrations
-
-  list.upgrades! [FROM [TO]]
-      List available upgrades
-
-  list.cache!
-      List cache files
-
-  build! -d,database=DATABASE -s,state=FILE -C,no-cache [TAG]
-      Drop all users associated with the database before building the current
-      database from the content in the schemas/ directory.  With a tag the
-      version is built into the associated versioned database and the result is
-      saved to cache unless the -C option is given. The -d option overrides the
-      default database and the -s option overrides the default state file
-      (fox.state)
-
-  make! -d,database=DATABASE -C,no-cache [TAG]
-      Build the current database from the content in the schemas/ directory.
-      With a tag the associated versioned database is loaded from cache if
-      present. The -C option ignores the cache and the -d option overrides
-      the default database
-
-  make.clean! -a,all
-      Drop versioned databases and remove cached and other temporary files.
-      Also drop the project database if the -a option is given
-
-  load! -d,database=DATABASE VERSION|FILE
-      Load the cached version or the file into the associated versioned
-      database. It is an error if the version hasn't been cached. The --database 
-      argument overrides the database
-
-  save! VERSION [FILE]
-      Save the versioned database associated with version to the cache or the
-      given file
-
-  drop! -a,all [DATABASE]
-      Drop the given database or all versioned databases. Users with a username
-      on the form <database>__<username> are also dropped. The --all option
-      also drops the project database
-
-  drop.users! [DATABASE]
-      Drop users with a username on the form <database>__<username>
-
-  diff! -m,mark -t,tables -T,notables
-      diff [FROM-DATABASE|FROM-VERSION [TO-DATABASE|TO-VERSION]]
-      Create a schema diff between the given databases or versions. Default
-      to-version is the current schema and default from-version is the base
-      version of this branch/tag
-
-  migrate!
-      Not yet implemented
-
-  prepare! 
-      Prepare a release. Just a shorthand for 'prick prepare release'
-
-  prepare.release! [FORK]
-      Populate the current migration directory with migration files
-
-  prepare.feature! NAME
-      Create and populate a feature as a subdirectory of the current directory.
-      Also prepares the current release directory
 
-  prepare.migration! [FROM]
-      Create and populate a migration directory
-
-  prepare.schema! NAME
-      Create and populate a new schema directory. Existing files and
-      directories are kept
-    
-  prepare.diff! [VERSION]
-      Not yet implemented
-
-  include.feature! FEATURE
-      Include the given feature in the current pre-release
-
-  check!
-      Check that the current migration applied to the base version yields the
-      same result as loading the current schema
-
-  create.release! [RELEASE]
-      Prepare a release and create release directory and migration file before
-      tagging and branching to a release branch. The RELEASE argument can be
-      left out if the current branch is a prerelease branch
-
-  create.prerelease! RELEASE
-      Prepare a release and create release directory and migration file before
-      branching to a prerelease branch
-
-  create.feature! NAME
-      Prepare a feature before branching to a feature branch
-
-  cancel! 
-      Cancel a release. Just a shorthand for 'prick cancel release'
-  
-  cancel.release!
-      Cancel a release. Since tags are immutable, the release is cancelled by
-      added a special cancel-tag to the release that makes prick ignore it
-
-  generate.migration! 
-      Create a script to migrate the database
-
-  generate.schema!
-      Create a script to create the database
-
-  upgrade!
-      Migrate the database to match the current schema
-
-  backup! [FILE]
-      Saves a backup of the database to the given file or to the var/spool
-      directory
-    
-  restore! [FILE]
-      Restore the database from the given backup file or from the latest backup
-      in the var/spool directory
-)
-
-__END__
-  
-
-
-
-
-
-DEFAULT_STATE_FILE = "fox.state"
-
-opts, args = ShellOpts.process(SPEC, ARGV)
-
-# Handle --help
-if opts.help?
-  ShellOpts.help
-  exit
-end 
-
-# Handle --version
-if opts.version? 
-  puts "prick-#{VERSION}" 
-  exit 
-end
-
-begin
-  # Honor -C option
-  if opts.directory?
-    if File.exist?(opts.directory)
-      begin
-        Dir.chdir(opts.directory)
-      rescue Errno::ENOENT
-        raise Prick::Error, "Can't cd to '#{opts.directory}'"
-      end
-    else
-      raise Prick::Error, "Can't find directory: #{opts.directory}"
-    end
-  end
-
-  # Create program object
-  program = Program.new(quiet: opts.quiet?, verbose: opts.verbose?)
-  $verbose = opts.verbose? ? opts.verbose : nil
-
-  # Handle init command
-  if opts.subcommand == :init
-    directory = args.expect(0..1)
-    name = opts.name || (directory && File.basename(directory)) || File.basename(Dir.getwd)
-    user = opts.init!.user || name
-    program.init(name, user, directory || ".")
-    exit 0
-  end
-
-  # Change to parent directory containing the Prick version file if not found
-  # in the current directory
-  program.current_directory = Dir.getwd
-  while Dir.getwd != "/" && !File.exist?(PRICK_VERSION_FILE)
-    Dir.chdir("..")
-  end
-
-  # Check prick version
-  file = PrickVersion.new
-  file.exist? or raise Prick::Error, "Can't find prick version file '#{file.path}'"
-  VERSION == file.read.to_s or 
-      raise Prick::Fail, ".prick-version required prick-#{file.read} but you're using prick-#{VERSION}"
-
-  # TODO: Check for dirty detached head
-
-  # Expect a sub-command
-  opts.subcommand or raise Prick::Error, "Subcomand expected"
-
-  case opts.subcommand
-    when :info
-      args.expect(0)
-      program.info
-
-    when :list
-      command = opts.list!
-      case command.subcommand
-        when :releases;
-          obj = command.releases!
-          program.list_releases(migrations: obj.migrations?, cancelled: obj.cancelled?)
-        when :migrations; program.list_migrations
-        when :upgrades; program.list_upgrades(*args.expect(0..2).compact)
-        when :cache; 
-          args.expect(0)
-          program.list_cache
-        when NilClass; raise Prick::Error, "list requires a releases|migrations|upgrades sub-command"
-      else
-        raise Prick::Internal, "Subcommand #{opts.subcommand}.#{command.subcommand} is not matched"
-      end
-
-    when :build
-      version = args.expect(0..1)
-      state_file = File.expand_path(opts.build!.state || DEFAULT_STATE_FILE)
-      FileUtils.rm_f(state_file)
-      program.build(opts.build!.database, version, state_file, opts.build!.no_cache?)
-
-    when :make
-      command = opts.make!
-      case command.subcommand
-        when :clean
-          args.expect(0)
-          program.make_clean(command.clean!.all?)
-        else
-          version = args.expect(0..1)
-          program.make(opts.make!.database, version, opts.make!.no_cache?)
-      end
-
-    when :load
-      version_or_file = args.expect(1)
-      program.load(opts.load!.database, version_or_file)
-
-    when :save
-      version, file = args.expect(1..2)
-      program.save(version, file)
-
-    when :drop
-      command = opts.drop!
-      case command.subcommand
-        when :users
-          database = args.extract(0..1) || program.project.database.name
-          args.expect(0)
-          program.drop_users(database)
-        else
-          program.drop(args.expect(0..1), opts.drop!.all?)
-      end
-
-    when :diff
-      mark = opts.diff!.mark
-      tables = opts.diff!.tables
-      no_tables = opts.diff!.notables
-      tables.nil? && no_tables.nil? || tables ^ no_tables or
-          raise Error, "--tables and --no-tables options are exclusive"
-      select = tables ? :tables : (no_tables ? :no_tables : :all)
-      from, to = args.expect(0..2)
-      program.diff(from, to, mark, select)
-
-    when :migrate
-      raise NotYet
-
-    when :prepare
-      cmd = opts.prepare!.subcommand || :release
-      case cmd
-        when :release; program.prepare_release(args.expect(0..1))
-        when :feature; program.prepare_feature(args.expect(1))
-        when :migration; program.prepare_migration(args.expect(0..1))
-        when :schema; program.prepare_schema(args.expect(1))
-        when :diff; program.prepare_diff(args.expect(0..1))
-      else
-        raise Prick::Internal, "Subcommand #{opts.subcommand}.#{cmd} is not matched"
-      end
-
-    when :include
-      cmd = opts.include!.subcommand || :feature
-      case cmd
-        when :feature; program.include_feature(args.expect(1))
-      else
-        raise Prick::Internal, "Subcommand #{opts.subcommand}.#{cmd} is not matched"
-      end
-
-    when :check
-      args.expect(0)
-      program.check
-
-    when :create
-      cmd = opts.create!.subcommand || :release
-      case cmd
-        when :release; program.create_release(args.expect(0..1))
-        when :prerelease; program.create_prerelease(args.expect(0..1))
-        when :feature; program.create_feature(args.expect(1))
-      else
-        raise Prick::Internal, "Subcommand #{opts.subcommand}.#{cmd} is not matched"
-      end
-
-    when :cancel
-      cmd = opts.cancel!.subcommand
-      case cmd
-        when :release; program.cancel_release(args.expect(1))
-        when nil; raise Prick::Error, "'cancel' subcommand requires a release argument"
-      else
-        raise Prick::Internal, "Subcommand #{opts.subcommand}.#{cmd} is not matched"
-      end
-
-    when :generate
-      cmd = opts.generate!.subcommand
-      case cmd
-        when :schema; program.generate_schema
-        when :migration; program.generate_migration
-        when nil; raise Prick::Error, "'generate' subcommand requires a 'schema' or 'migration' argument"
-      else
-        raise Prick::Internal, "Subcommand #{opts.subcommand}.#{cmd} is not matched"
-      end
-
-    when :upgrade
-      args.expect(0)
-      program.upgrade
-
-    when :backup
-      program.backup(args.expect(0..1))
-    
-    when :restore
-      program.restore(args.expect(0..1))
-  else
-    raise Prick::Internal, "Subcommand #{opts.subcommand} is not matched"
-  end
-
-rescue Prick::Fail => ex # Handling of Fail has to come first because Fail < Error
-  ShellOpts.fail(ex.message)
-rescue Prick::Error => ex
-  ShellOpts.error(ex.message)
+rescue RuntimeError, IOError, ShellOpts::Failure, Prick::Failure, Prick::Build::PostgresError => ex 
+  ShellOpts.failure(ex.message)
 end
 
-__END__
-
-# Awaits support for sections in ShellOpts
-HELP = %(
-  OPTIONS
-    -n, --name=NAME
-    -C, --directory=DIR
-    -h, --help
-    -v, --verbose
-    --version
-
-  COMMANDS
-    INITIALIZATION
-      init --user=USER [DIR]
-
-    INFO COMMANDS
-      info
-      list releases --migrations --cancelled
-      list migrations
-      list upgrades --all
-
-    BUILDING
-      build -d DATABASE -C --nocache [TAG]
-      make -d DATABASE -C --nocache [TAG]
-      make clean -a
-      load -d DATABASE VERSION|FILE
-      save VERSION [FILE]
-      drop --all [DATABASE]
-      diff [FROM-DATABASE|FROM-VERSION [TO-DATABASE|TO-VERSION]]
-      migrate
-
-    PREPARING RELEASES
-      prepare release [FORK]
-      prepare feature NAME
-      prepare migration FROM
-      prepare schema NAME
-      prepare diff [VERSION]
-      include feature FEATURE
-      check
-
-    CREATING RELEASES
-      create release [RELEASE]
-      create prerelease RELEASE
-      create feature NAME
-      cancel release RELEASE
-
-    DEPLOYING RELEASES
-      generate migration
-      generate schema
-      upgrade
-      backup [FILE]
-      restore [FILE]
-)