shellopts 2.0.18 → 2.0.19

data/main

@@ -1,1199 +1,29 @@
 #!/usr/bin/env ruby
 
-require 'bundler'
-Bundler.setup
+$LOAD_PATH.unshift "#{Dir.getwd}/lib"
 
 require 'shellopts'
 
-include ShellOpts
+#include ShellOpts::Message
+include ShellOpts::Verbose
+#include ShellOpts::Debug
 
-p ShellOpts::ShellOpts.default_version
-exit
-
-VERSION = "1.2.3"
-
-SPEC = %(
-  -a @ An option
-)
-opts, args = ShellOpts.process(SPEC, ARGV, version: VERSION)
-#ShellOpts::ShellOpts.help
-
-
-
-
-
-
-__END__
-
-
-#SPEC = %(
-# -a,alpha        @ Brief comment for -a and --alpha options
-#     Longer and more elaborate description of the --alpha option
-#
-# -b,beta=ARG
-#     @ Alternative style of brief comment
-#
-#     Longer and more elaborate description of the --beta option
-#)
-#
-#opts, args = ShellOpts.process(SPEC, ARGV)
-#puts "opts.alpha?: #{opts.alpha?.inspect}"
-#puts "opts.alpha: #{opts.alpha.inspect}"
-#puts "opts.beta?: #{opts.beta?.inspect}"
-#puts "opts.beta: #{opts.beta.inspect}"
-#exit
-#ShellOpts::ShellOpts.brief
-#exit
-
-
-
-
-
-
-
-# Standard options
-#   -h,help
-#   --version
-#
-#  Message options
-#   -q,quiet
-#   -v,verbose
-
-# ShellOpts.parse(spec, argv)
-# ShellOpts.stdopt(spec, argv)
-# ShellOpts.msgopt(spec, argv)
-
-
-
-SPEC = %(
-# Comment
-
-  @ Program brief
-  
-  This should end up in the DESCRIPTION section in the @help format. Bla bla
-  bla. Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod
-  tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
-  quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
-  consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
-  cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
-  proident, sunt in culpa qui officia deserunt mollit anim id est laborum
-
-  Here comes some code
-    
-    if this_is_printed_correctly?
-      puts "Success"
-    end
-
-  Here is a paragraph
-
-  Here is another paragraph
-
-  OPTIONS
-
-  This should be in the OPTIONS section (not supported for now - now it is!)
-
-  -a,all
-  -b,beta Brief inline comment     
-  +v,verbose -h,help -version @ Multi option line. Option group. 
-  -c
-    @ Alternative brief. 
-  -f,file=FILE   
-    Indented comment
-
-  Some free text not related to a single options. Eg. an introduction to the
-  next set of options and some more text to make this wrap
-
-  --multiple --options --on --one --line --with --brief 
-    @ Brief for multi-option line - aka. option group. Lorem ipsum dolor sit amet, consectetur adipiscing elit
-
-    Common comment for previous multi-option line. Lorem ipsum dolor sit amet,
-    consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et
-    dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
-    ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure
-    dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat
-    nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in
-    culpa qui officia deserunt mollit anim id est laborum
-
-    Here comes some more code:
-
-        if something
-          this
-        else
-          that
-        end
-
-    And some more text
-
-
-# --multiple
-# --options
-# --on
-# --multiple
-# --lines
-#   Common comment for previous multi-option lines (not doable, but this is how
-#   the previous multi-option line will be rendered in one of the formats).
-#   However, the same is not true for commands that can't have a common comment
-
-
-# A comment that should not be included in the source (useful to out-comment
-# sections of source)
-#
-# The following blank line should be ignored       
-
-  -l=MODE:short,long
-    Another indented comment. The following blank line should be included
-
-    But not if it is the last blank line. 
-    \\hep! initiates a line but is not a command because it is escaped
-
-      a_code_example()
-      if something == 42
-        # Something that looks like a command
-        doit!
-  
-        # Something that looks like a option
-        --i_miss_this
-      end
-
-  -- ARG1 ARG2 
-
-  cmd! @ Brief description of command
-    Description of command. 
-
-    Another paragraph.
-    Another line in paragraph
-
-      -c,copt @ Inline comment  
-      -d,dopt @ Brief and nested comment  
-        Even more nested comment
-      -a,all @ Duplicate 
-
-    Here is some text where 
-
-      the next line is indented (interpreted as code)
-
-    subcmd! -i,inc ++ SUB ARGS @ Brief description of sub-command
-      A description
-
-    This text should be included too  
-
-    ++ CMD_ARG1 CMD_ARG2
-
-      Longer indented text is not related to the previous
-      description of arguments but is considered code
-
-        is this code
-
-    ++ CMD_ARG_A CMD_ARG_B
-
-      with something that is not a a description
-
-# -- GLOBAL ARGS
-
-  --another-global-option
-
-  a regular paragraph
-)
-
-ONELINE = "-a,all -b,beta --verbose -h,help -v,version -c -f=FILE --multiple --options --on --one --line -l=MODE:short,long? cmd! -c,copt -d,dopt cmd.subcmd! -- GLOBAL ARGS"
-
-SPEC2 = %(
-  @ Program brief
-  
-  text text text
-
-  OPTIONS
-
-    Some option intro text
-
-    -a
-      Option brief 1. Help text
-
-    -b Option brief 2
-
-    -c @ Option brief 3
-
-    -d 
-      @ Option brief 4
-
-    text text text
-
-  COMMANDS
-
-    Some command intro text
-
-    cmd1! -- ARG1 ARG2 Command brief 1
-    cmd2! @ Command brief 2
-    cmd3!
-      First-line option brief. After the first dot
-
-)
-
-#        #{$stderr.puts "Oops"; "32"}
-
-SPEC3 = %q(
-  Description
-
-  -- ARG1 ARG2
-  -- ARG3 ARG4
-
-  OPTIONS
-    Some text
-
-      -a An option and not code
-
-    Some code
-
-      \\-b A code line # Because we escaped it
-      -c # this is not an option
-        this_is_more_code()
-
-    Another option
-
-      -d Another
-
-    More code
-
-      # A command
-      -e # is not an option
-
-  COMMANDS
-    Some commands text
-
-      cmd1! A command
-      cmd1! A dup
-
-    Some code
-
-      \\cmd2! A code line
-        cmd3! # this is not a command
-
-    Final
-)
-
-SPEC4 = %(
-  cmd!
-    A command
-
-    cmd.nested!
-      A nested command
-
-  cmd.subcmd!
-    A subcommand
-)
-
-SPEC5 = "cmd! cmd!"
-
-shellopts = ShellOpts::ShellOpts.new(exception: true)
-#shellopts.compile("cmd! cmd!")
-
-shellopts.compile(SPEC)
-#shellopts.compile(SPEC2)
-#shellopts.compile(SPEC3)
-#shellopts.compile(SPEC4)
-#shellopts.compile(SPEC5)
-
-#shellopts.tokens.each(&:dump)
-#exit
-
-#shellopts.usage
-#shellopts.brief
-shellopts.help
-#shellopts.help("cmd")
-#shellopts.help(ARGV.first)
-
-#p shellopts.tokens
-
-#
-#shellopts = ShellOpts::ShellOpts.new
-#shellopts.compile(SPEC4)
-#p shellopts.file
-#ShellOpts.process(SPEC4, [])
-#exit
-
-
-#argv = ARGV.empty? ? %w(-a cmd -c) : ARGV
-#prog, args = ShellOpts::ShellOpts.process SPEC2, argv
-
-#tokens = ShellOpts::Lexer.lex("main", SPEC4)
-#tokens.each(&:dump)
-#exit
-
-#ast = ShellOpts::Parser.parse(tokens)
-#ast.dump_ast
-#exit
-
-#idr = ShellOpts::Analyzer.analyze(ast) # @idr and @ast refer to the same object
-#idr.dump_idr
-#exit
-
-#puts "-" * 80
-#ShellOpts::Formatter.usage(idr)
-#puts "-" * 80
-#ShellOpts::Formatter.brief(idr)
-#puts "-" * 80
-#ShellOpts::Formatter.help(idr)
-#puts "-" * 80
-
-#ShellOpts.process(SPEC, [])
-#ShellOpts.error("Hej")
-
-
-
-
-
-
-
-
-__END__
-exit
-
-puts "prog.verbose: #{prog.verbose.inspect}"
-puts "prog.all?: #{prog.all?}"
-puts "prog.file: #{prog.file.inspect}"
-puts "prog.subcommand: #{prog.subcommand.inspect}"
-puts "prog[:cmd!]: #{prog[:cmd!].__ident__}"
-puts "prog[\"cmd\"]: #{prog["cmd"].__ident__}"
-puts "prog.subcommand!.subcommand: #{prog.subcommand!.subcommand.inspect}"
-#shellopts = ShellOpts::ShellOpts.new ONELINE, ARGV
-
-
-
-puts "---------------------"
-puts ShellOpts::Formatter.option_help(prog)
-
-#spec = %(
-#hej
-#med dig
-#)
-#shellopts = ShellOpts::ShellOpts.new spec, ARGV
-
-#shellopts.tokens.each(&:dump)
-
-
-__END__
-
-
-shellopts = ShellOpts::ShellOpts.new(SPEC, ARGV)
-opts, args = shellopts.result
-
-#opts, args = ShellOpts.make(SPEC, ARGV)
-
-#opts.help? # True if present
-#opts.file? # True if present
-#opts.file # Not nil if argument was given
-
-shellopts.mesg "This is a message"
-shellopts.quiet!
-shellopts.mesg "Not printed"
-
-shellopts.verb "Not printed"
-shellopts.verbose!
-shellopts.verb "Printed"
-
-
-#ShellOpts.failure "Something went wrong"
-#
-#
-#ShellOpts.mesg "This is a message"
-#ShellOpts.quiet!
-#ShellOpts.mesg "Not printed"
-#
-#ShellOpts.verb "Not printed"
-#ShellOpts.verbose!
-#ShellOpts.verb "Printed"
-#
-#
-#ShellOpts.failure "Something went wrong"
-
-#include ShellOpts::Include
-#
-#mesg "This is a message"
-#quiet!
-#mesg "Not printed"
-#
-#verb "Not printed"
-#verbose!
-#verb "Printed"
-#
-#
-#failure "Something went wrong"
-
-
-
-__END__
-
-  opts, args = ShellOpts.process(OPTIONS, ARGV, exception: true)
-
-  if opts.version?
-    puts "pg_graph-#{PgGraph::VERSION}"
-    exit
-  end
-
-  if opts.help?
-    puts "Name"
-    puts "  #{PROGRAM}"
-    puts
-    puts "Usage"
-    puts "  #{PROGRAM} #{USAGE}"
-    puts
-    print "Options"
-    puts OPTIONS
-    exit
-  end
-
-  timing = opts.time?
-  timer = Timer::Timer.new
-
-  # Process options
-  meta = opts.meta
-  reflections = opts.reflections
-
-  !opts.kind? || %w(meta type data).include?(opts.kind) or
-      raise "Unknown argument for --kind option - '#{opts.kind}'"
-  kind = opts.kind? ? opts.kind : "type"
-
-  !opts.format? || %w(sql exec psql yaml).include?(opts.format) or 
-      raise "Unknown argument for --format option - '#{opts.format}'"
-  format = opts.format? ? opts.format : "yaml"
-
-  case opts.subcommand || :dump
-    when :load
-      opts = opts.subcommand!
-      !opts.format? || %w(sql exec psql yaml).include?(opts.format) or 
-          raise "Unknown argument for --format option - '#{opts.format}'"
-
-      database = args.expect(-1)
-      file = args.expect(0..1) || "/dev/stdin"
-
-      if opts.format?
-        format = opts.format
-      else
-        format = 
-            case File.extname(file)
-              when ".sql"; "sql"
-              when ".yaml", ".yml"; "yaml"
-            else
-              "yaml"
-            end
-      end
-
-      case format
-        when "sql", "exec"; 
-          connection = timer.time("connect") { PgConn.new(database) }
-          timer.time("load file") {
-            connection.exec(IO.read(file))
-          }
-        when "psql"
-          timer.time("psql") {
-            system "psql -d #{database} < #{file} >/dev/null"
-          }
-        when "yaml"
-          connection, type = load_type(timer, opts, database)
-          tg = timer.group("read data")
-          data = tg.time("data") { PgGraph::Data.new(type, YAML.load(IO.read(file))) }
-          tg = timer.group("write data")
-          for label, sql in PgGraph::Data::SqlRender.new(data, :exec).to_h
-            tg.time(label) { connection.exec(sql.join) }
-          end
-      end
-
-    when :dump
-      if opts # When pg_graph is called without a subcommand
-        kind = "type"
-        format = "yaml"
-      else
-        !opts.kind? || %w(meta type data).include?(opts.kind) or
-            raise "Unknown argument for --kind option - '#{opts.kind}'"
-        kind = opts.kind? ? opts.kind : "type"
-
-        !opts.format? || %w(sql exec psql yaml).include?(opts.format) or 
-            raise "Unknown argument for --format option - '#{opts.format}'"
-        format = opts.format? ? opts.format : "yaml"
-      end
-
-      database = args.expect(1)
-
-      case kind
-        when "meta"
-          connection = timer.time("connect") { PgConn.new(database) if !opts.meta? }
-          meta = timer.time("meta") { opts.meta? ? PgMeta.load_file(opts.meta) : PgMeta.new(connection) }
-          meta.dump
-        when "type"
-          connection, type = load_type(timer, opts, database)
-          type.dump
-        when "data"
-          connection, type = load_type(timer, opts, database)
-          data = timer.time("instantiate") { type.instantiate(connection) }
-          timer.time("dump") {
-            case format
-              when "sql"; puts data.to_sql
-              when "exec"; puts data.to_exec_sql
-              when "psql"; puts data.to_psql_sql
-              when "yaml"; puts data.to_yaml.to_yaml
-            end
-          }
-      end
-
-    when :clean
-      opts = opts.subcommand!
-      database = args.expect(1)
-
-      tg = timer.group("initialization")
-      connection = tg.time("connect") { PgConn.new(database) }
-      meta = tg.time("meta") { opts.meta? ? PgMeta.new(opts.meta) : PgMeta.new(connection) }
-      type = tg.time("type") { PgGraph::Type.new(meta) }
-      data = tg.time("data") { type.instantiate }
-
-      tg = timer.group("clean data")
-      for label, sql in PgGraph::Data::SqlRender.new(data, :exec).to_h
-        tg.time(label) { connection.exec(sql.join) }
-      end
-  else
-    puts "else"
-  end
-
-  timer.dump($stderr) if timing
-
-rescue ShellOpts::Error => ex
-  $stderr.puts "#{PROGRAM}: #{ex.message}"
-  $stderr.puts "Usage: #{PROGRAM} #{USAGE}"
-  exit 1
-end
-
-include ShellOpts
-include Prick
-
-TIME = false
+#include ShellOpts::Messages
+#p ShellOpts::Messages.is_included?
 
 SPEC = %(
-  -h,help COMMAND...
-      Print this page
-
-  +v,verbose
-      Be verbose. Repeated -v options increase the verbosity level
-
-  -q,quiet
-      Be quiet
-
-  --version
-      Print prick version. Use 'prick version' to get the project version
-
-  -C,directory=EDIR
-      Change to directory DIR before doing anything else
-
-  -d,database=DATABASE
-      Override database name from prick.yml
-
-  -U,username=USERNAME
-      Override username from from prick.yml
-
-  !version
-      Print project version
-
-  !init -n,name=NAME -t,title=TITLE -- [DIRECTORY]
-      Initializes a prick project
-
-  !setup
-      Create the database user (if necessary) and an empty database
-
-  !teardown
-      Drop the database and the database user. TODO: Also run teardown scripts
-
-  !create.data
-  !create.schema
-  !create.database
-  !create.users
-  !create.all
-      Create an object. Fails if migration exist unless the --force flag is given
-
-  !create.migration -f,force -o,file=NFILE -- VERSION
-      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
-
-  !drop -- [KIND]
-      Kind can be 'users', 'data', 'schema', 'database' (the default), or 'all'. It is
-      not an error if the object doesn't exist. TODO Only 'users' is currently defined
-
-  !build -t,time --dump=KIND? -- [SCHEMA]
-      Build the project. If SCHEMA is defined, later schemas are excluded.
-      KIND can be 'nodes', 'allnodes' or 'batches' (the default)
-
-  !make -t,time --dump=KIND? -- [SCHEMA]
-      Checks file timestamps against the time of the last build and only
-      rebuild affected parts of the project. KIND can be 'nodes', 'allnodes' or
-      'batches'
-
-  !fox -- FILE...
-      Load fox file data. Data are reset to their initial state after build
-      before the fox data are loaded
-
-  !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
-      with the origin
-
-  !migrate -f,file=EFILE
-      Execute a migration
-
-  !dump.type
-  !dump.data
-  !dump.schema
-  !dump.database
-      TODO
-
-  dump.migration! --force VERSION
-)
-
-opts, args = ShellOpts.process(SPEC, ARGV)
-
-# Handle --help
-if opts.help?
-  puts "Name"
-  puts "  prick - Postgres project management tool"
-  puts
-  puts "Usage"
-  puts "  prick [GLOBAL-OPTIONS] command [COMMAND-OPTIONS] ARGUMENTS"
-  puts
-  puts "Options and commands"
-  puts SPEC.sub(/^\s*\n/, "")
-  exit
-end
-
-# Initial directory. Used to create relative paths in user messages
-#rundir = Dir.getwd
-
-begin
-  # Handle --version
-  if opts.version? 
-    puts "prick-#{VERSION}" 
-    exit 
-  end
-
-  # 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
-
-  # Get subcommand
-  cmd = opts.subcommand!
-
-  # 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
-    exit
-  end
-
-  # Load state
-  Prick.state = State.load
-
-  # Handle -d and -U options
-  database = opts.database || Prick.state.database
-  username = opts.username || Prick.state.username
-    
-  # Expect a sub-command
-  cmd = opts.subcommand! or raise Prick::Error, "Subcomand expected"
-
-  # Process subcommands
-  case opts.subcommand
-    when :version
-      puts "#{Prick.state.name}-#{Prick.state.version}"
-
-    when :setup
-      Prick::SubCommand.setup(database, username)
-
-    when :teardown
-      Prick::SubCommand.teardown(database, username)
-
-    when :create
-      create_command = opts.create!
-      case create_command.subcommand
-        when :migration
-          arg = args.expect(1)
-          version = PrickVersion.try(arg) or raise Prick::Error, "Illegal version: #{arg}"
-          Prick::SubCommand.create_migration(
-              username, version, 
-              force: create_command.subcommand!.force?, 
-              file: create_command.subcommand!.file)
-        else
-          raise NotImplementedError
-      end
-
-    when :build
-      dump = cmd.dump("batches")&.to_sym
-      Prick::SubCommand.build(database, username, args.expect(0..1), timer: cmd.time?, dump: dump)
-
-    when :make
-      dump = cmd.dump("batches")&.to_sym
-      Prick::SubCommand.make(database, username, args.expect(0..1), timer: cmd.time?, dump: dump)
-
-    when :fox
-      Prick::SubCommand.fox(database, username, args)
-
-    when :drop
-      case subject = args.expect(1).to_sym
-        when :all
-          Prick::SubCommand.drop_all(database)
-        when :users
-          Prick::SubCommand.drop_users(database)
-        when :database
-          Prick::SubCommand.drop_database(database)
-        when :data, :schema, :database, :all
-          raise NotImplementedError
-      else
-        raise 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::SubCommand.release(kind)
-
-    when :migrate
-      args.expect(0)
-      Prick::SubCommand.migrate(database, username, file: cmd.file)
-
-    when :dump
-      subject = cmd.subcommand!
-      case cmd.subcommand
-        when :migration
-          arg = args.expect(1)
-          version = PrickVersion.try(arg) or raise "Illegal version number: #{arg}"
-          Prick::SubCommand.create_migration(username, version, force: subject.force?, file: "/dev/stdout")
-        when :data, :schema, :database
-          raise NotImplementedError
-      else
-        raise Prick::Error, "Unknown subject: #{subject}"
-      end
-
-    else
-      raise Prick::Fail, "Internal error: Unhandled command - #{opts.subcommand.inspect}"
-  end
-
-rescue ShellOpts::Fail, Prick::Fail, Prick::Build::PostgresError => ex 
-  ShellOpts.fail(ex.message)
-
-rescue ShellOpts::Error, Prick::Error => ex
-  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
+  Test
 
-  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
+  -a
+    An option
 )
 
-__END__
-  
-
-
-
-
-
-DEFAULT_STATE_FILE = "fox.state"
-
-opts, args = ShellOpts.process(SPEC, ARGV)
+opts, args = ShellOpts.process(SPEC, ARGV, version: "--ver", version_number: "1.2.3", help: "-?,help")
 
-# Handle --help
-if opts.help?
-  ShellOpts.help
-  exit
-end 
+verb "Verbose default"
+(0..3).each { |i| verb i, "Verbose #{i}" }
+mesg "Message"
+notice "Notice"
+#debug "Debug"
 
-# 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)
-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]
-)