prick 0.2.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a41038c7beeb2bb1503ccb199cc45622d6fbe28e113003b98e8e78e10658a37
-  data.tar.gz: 59cb5055863ce2cd63ad9db5a2adf9a0de33d4386bca210dd8e9f25f602bb5e1
+  metadata.gz: dd62ad39d6f79354d9eb4e68e102cbe2fa45c3c83f3bb670bb67cc91faab2b6c
+  data.tar.gz: 1802956bd55eafd32b16ff2d473e7b8c4f22ffaa2526ab83afb1c8d271b3fe37
 SHA512:
-  metadata.gz: 0b19d6f150e840101f60aa9337583257a0f72e36e2eb7a84b1403063b274099e7a27716aecd2ccaaaf09484a4f5d4b1f9da6eebde340fe9b69da8bab8342528e
-  data.tar.gz: 7b71790136d8de6e2f3c77a58fb5d1e432bbbe6f0c910ada86608e05f759c8ea68d255f1cc038ce2b5efebfb7e379f0bb2f607a94cfd99b5f26cf3665f135130
+  metadata.gz: c8b1553cba9e5afe792b1f3119ffb9b85e23626d830b752dc98ee5bd28e4c7eeaf8e7b50acb52cfe9e32dcf935d8dcd99694bf2d1d29ebd830c1a9abcb852f38
+  data.tar.gz: 3a189a2dff6750afc58f01189dc86fd671b605f5281e17d725607483e0d2f24603f54cc9071145dcfa681109d971da8736a5e81be454b3b1d3d3ee055060f92f

data/.gitignore

@@ -19,10 +19,11 @@
 
 # Put your personal ignore files in /home/clr/.config/git/ignore
 
-# Temporary ignores
-/releases/
-/migrations/
-/prick.sh
-
 # Ignore bundle binstubs
 /bin/prick
+
+# Ignore development testing dir
+/dir
+
+# Ignore stove-away directory
+/hold

data/Gemfile

@@ -1,6 +1,9 @@
 source "https://rubygems.org"
 
-git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+git_source(:github) {|repo_name| "https://github.com/clrgit/#{repo_name}" }
 
 # Specify your gem's dependencies in prick.gemspec
 gemspec
+
+gem "rake", "~> 12.0"
+gem "rspec", "~> 3.0"

data/TODO

@@ -0,0 +1,10 @@
+
+o Check for commits to tags
+o Accumulate version history in prick.versions instead of just having the newest
+o Using rc's in migration syntax: fork-version-fork-version.rc1 ?
+o Make it possible to execute prick in any subdirecty instead of only in the root
+o Hack migra to create separate file(s) for table changes
+o Also execute subject/ directory if only a subject.sql is found. subject.yml
+  should still override everything
+o Track included files - this will make dependency checks much easier
+

data/doc/prick.txt

@@ -0,0 +1,114 @@
+
+
+MIGRATION STATE FILES
+  .prick-migration (State file)
+      version: Version
+        The target version. The result of running the migration on the base
+        release
+      base_version: Version
+        Base version. Running the migration on a base release yields a release
+        of with the same version as the `version` property
+
+      The 0.0.0 version has base_version equal to nil. A Feature has version
+      equal to its base version. 
+      
+      Note that while a release's .prick-migration file lives in the release
+      directory, it's .prick-features file and the migrations lives in the
+      directory of the base release.  This separation supports the
+      single-developer workflow where the next release is not known beforehand
+
+  .prick-features (State file)
+      features: Array
+        A list of features versions
+
+MIGRATION FILES
+  migrate.sql
+  features.sql
+  diff.sql
+
+
+MIGRATION FILE STRUCTURE
+  releases/
+    0.0.0/
+      .prick-migration -> version: 0.0.0, base_version: nil
+      .prick-features -> [feature_a]
+      feature_a/
+        .prick-migration -> version: nil, base_version: 0.0.0
+        .prick-features -> []        
+      feature_b/ (rebased)
+        .prick-migration -> version: 0.2.0, base_version: 0.2.0-pre.1
+        .prick-features -> []
+
+    0.1.0/
+      .prick-migration -> version: 0.1.0, base_version: 0.0.0
+      feature_b/ symlinks to ../0.0.0/feature_b/
+
+    0.1.0/ (wip - single developer work flow)
+      .prick-migration -> version: 0.1.0, base_version: 0.0.0
+      .prick-features -> [feature_c]
+      feature_c/
+        ...
+
+    0.2.0/ (doing a pre-release)
+      .prick-migration -> version: 0.2.0-pre.1, base_version: 0.1.0
+
+  migrations/
+    0.0.0_0.1.0/
+      .prick-migration -> version: 0.1.0, base_version: 0.0.0
+      .prick-features -> []
+
+
+NOTES
+#
+#   Distinguish between running a migration 0.1.0 -> 0.2.0 and running the
+#   migration in the 0.2.0 directory in the single-developer workflow
+#
+#     prick migrate
+#       On a tag: Migrate to that tag
+#       On a branch: Run migrations in the release directory
+#
+#     prick migrate 0.2.0 <- the version number reflects where to find the migration
+#       Runs the migration files in the release directory
+#
+#     prick migrate 0.1.0
+#       Runs the migration files in the base release directory
+#
+#
+#     prick build 
+#       Builds the current schema into the project database
+#
+#     prick build 0.1.0
+#       Builds the given schema into a versioned database
+
+
+
+
+
+
+
+
+
+
+
+
+
+######################
+
+PRICK FILES
+  ./prick-version
+    Contains just one line with the version of the prick command that should be
+    used with this project (eg. 'prick-0.1.0'). Prick checks this file at
+    startup and fails if the required version doesn't match the current command
+
+  ./prick
+      project_name
+        Name of the project
+      
+  ./releases/*/.prick
+      base_version
+        The base version of this release. nil for release 0.0.0
+      features
+        List of features in a release based on this release. Initially empty
+        but filled in when the directory is prepared for a subsequent release.
+        To find the set of features in the current release, inspect the prick
+        file of the base_version in this branch

data/exe/prick

@@ -1,461 +1,335 @@
 #!/usr/bin/env ruby
 
 require 'prick.rb'
+require 'prick/program.rb'
 
 require 'shellopts'
-require 'indented_io'
+
 require 'tempfile'
-require 'ext/algorithm.rb'
 
 include ShellOpts
+include Prick
 
-# TODO: Backup & restore
 SPEC = %(
-  n,name=NAME
-  C,directory=DIR
-  h,help
-  v,verbose
-  q,quiet
-  version
-
-  init! 
-  info!
-  status!
-  history!
-
-  checkout!
-
-  feature!
-  rebase!
-
-  create! create.release! create.prerelease! create.feature! create.migration!
-  increment! increment.prerelease!
-
-  prepare! prepare.release! prepare.prerelease! prepare.feature! prepare.migration!
-  include!
-  commit!
-  prerelease!
-  release!
-
-  list! list.databases! list.releases! list.prereleases!
-  build!
-  use! f,file=FILE
-  load! f,file=FILE
-  reload! f,file=FILE
-  unload!
-  clean!
-
-  migrate!
-)
-
-USAGE = "-h -v -n NAME -C DIR COMMAND"
-
-HELP = %(
-  NAME
-    prick - Database version management
-
-  USAGE
-    prick -v -n NAME -C DIR -h <command>
-
-  OPTIONS
-    -n, --name=NAME
+  -n,name=NAME
       Name of project. Defauls to the environment variable `PRICK_PROJECT` if
       set and else the name of the current directory
 
-    -C, --directory=DIR
-      Change to directory DIR before anything else
+  -C,directory=DIR
+      Change to directory DIR before doing anything else
 
-    -h, --help
+  -h,help COMMAND...
       Print this page
 
-    -v, --verbose
-      Be verbose
+  +v,verbose
+      Be verbose. Repeated --verbose options increase the verbosity level
 
-    --version
-      Print prick version
-
-  COMMANDS
-    INFO COMMANDS
-      init [DIR]
-        Initialize a project directory
+  -q,quiet
+      Be quiet
 
-      info
-        Print project information
-
-      status
-        Short status
-
-    GENERAL COMMANDS
-      checkout
-        As git checkout but does some extra work behind the scenes
-
-      migrate
-        Migrate from the current branch in the database to the current branch
-
-
-    DEVELOPER COMMANDS
-      create feature FEATURE
-        Create a new feature branch and a feature directory under
-        features/<base-version>. Note that the base version is the base version 
-        of the pre-release
-        
-        Features are named <feature>-<base-version>
-
-      prepare migration
-        Create migration files from the base release to the current schema. It
-        does not overwrite existing migration files
-
-      rebase VERSION
-        Rebase the feature to HEAD of the release. The rebased feature lives on
-        a branch of its own and have a symlink from the new base release to the
-        feature implementation in the original release.  Rebased features are
-        named <feature>-<rebase-version>
-
-
-    RELEASE MANAGER COMMANDS
-      migrate VERSION|patch|minor|major
-        Prepare migration from current release to the given version. The branch
-        will be named <old-version>_<new-version>. Note that the generated
-        files don't include data migrations so it may be easier to first create a 
-        prerelease and include missing features and then use that release as base
-        for an empty migration release that just changes the version number
+  --version
+      Print prick version
 
-        (need some thought)
+  init! -u,user=USER [DIR]
+      Initialize a project in the given directory. DIR defaults to the current
+      directory. The USER is the postgres user, it defaults to the project name
 
-      prepare VERSION|patch|minor|major
-        Prepare a new release by branching to <version>.pre.0 and creating a
-        features directory for the _base_ version. If version is one of the
-        names patch, minor, or major then the version is constructed by
-        incrementing the given part of the base release's version
+  info!
+      Print project information
 
-      include FEATURE
-        Merge a feature branch into the prepared release
+  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
 
-      prerelease
-        Bumps the pre-release serial and create a new branch
+  list.migrations! 
+      List migrations
 
-      release [VERSION]
-        Create a new release. The version is not used if the release was prepared
+  list.upgrades! [FROM [TO]]
+      List available upgrades
 
+  list.cache!
+      List cache files
 
-    MANIPULATING DATABASES AND RELEASES
-      list [databases|releases|prereleases]
-        Output a list of databases, releases, or prereleases. List databases by
-        default
+  build! -d,database=DATABASE -C,no-cache [TAG]
+      Build 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
 
-      build [VERSION]
-        Build the schema in the project database. If a version is given, the
-        version is built into the versioned database and the release cached
-        on disk
+  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
 
-      load
-        Load the current cache into the project 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 -f FILE [VERSION]
-        Load the cached release into its versioned database. It is an error if
-        the release isn't cached - use build to create it
-        
-      reload [VERSION]
-        Clear the versioned database and reload the release from the cache
+  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
 
-      unload [VERSION]
-        Delete the versioned database. Default is to delete all project related
-        databases
+  save! VERSION [FILE]
+      Save the versioned database associated with version to the cache or the
+      given file
 
-      clean [VERSION]
-        Delete the cached release. Default is to delete all cached releases
+  drop! -a,all [DATABASE]
+      Drop the given database or all versioned databases. The --all option also
+      drops the project database
 
+  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
 )
 
-INFO_PARAMS = {
-  "Releases": :releases,
-  "Pre-releases": :prereleases,
-  "Features": :features,
-  "Ignored releases": :ignored_release_nodes,
-  "Ignored features": :ignored_feature_nodes,
-  "Orphan disk features": :orphan_feature_nodes,
-  "Orphan disk releases": :orphan_release_nodes,
-  "Orphan git branches": :orphan_git_branches
-}
-
-def info(project)
-  for header, member in INFO_PARAMS
-    elements = project.send(member)
-    puts header
-    if elements.empty? 
-      puts "  [none]"
-    else
-      if member == :features
-        project.features.each { |release, features|
-          puts "  #{release}"
-          features.each { |feature| puts "    #{feature.feature}" }
-        } 
-      else
-        elements.sort.each { |element| puts "  #{element}" }
-      end
-    end
-  end
-end
 
-def compute_version(project, arg)
-  if arg.nil?
-    nil
-  elsif %w(major minor patch).include?(arg)
-    project.release.version.increment(arg.to_sym)
-  else
-    Prick::Version.new(arg)
-  end
-end
 
-opts, args = ShellOpts.as_struct(SPEC, ARGV)
+opts, args = ShellOpts.process(SPEC, ARGV)
 
 # Handle --help
 if opts.help?
-  begin
-    file = Tempfile.new("prick")
-    file.puts HELP.split("\n").map { |l| l.sub(/^  /, "") }
-    file.flush
-    system "less #{file.path}"
-  ensure
-    file.close
-  end
+  ShellOpts.help
   exit
-end
+end 
 
 # Handle --version
-if opts.version?
-  puts "prick-#{Prick::VERSION}"
-  exit
+if opts.version? 
+  puts "prick-#{VERSION}" 
+  exit 
 end
 
 begin
   # Honor -C option
-  if opts.directory
-    begin
-      Dir.chdir(opts.directory)
-    rescue Errno::ENOENT
-      raise Prick::Error, "Can't cd to '#{directory}'" 
+  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
 
-  name = opts.name || ENV["PRICK_PROJECT"] || File.basename(Dir.getwd)
-  verbose = opts.verbose?
+  # Create program object
+  program = Program.new(quiet: opts.quiet?, verbose: opts.verbose?)
 
-  # :init! is processed separately because the project object can't be
-  # constructed before the directory has been initialized
+  # Handle init command
   if opts.subcommand == :init
-    dir = args.expect(1)
-    Prick::Project.initialize_directory(dir)
-    Dir.chdir(dir) { 
-      Prick::Project.initialize_project(name) 
-    }
-    if File.basename(dir) != name
-      puts "Initialized project #{name} in #{dir}" if !opts.quiet?
-    else
-      puts "Initialized project #{name}" if !opts.quiet?
-    end
-  else
-    project = Prick::Project.new(name)
-
-    case cmd = opts.subcommand
+    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
 
-      # INFO COMMANDS #########################################################
-      #
-      when :info
-        args.expect(0)
+  # 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
 
-        puts "Current branch"
-        puts "   #{project.release&.version || 'nil'}"
+    when :build
+      version = args.expect(0..1)
+      program.build(opts.build!.database, version, opts.build!.no_cache?)
 
-        puts "Project database"
-        db = project.database
-        if db.exist?
-          print "   #{project.database.name}" 
-          print " (present)" if project.database.exist? && !project.database.loaded?
-          print " (using #{project.database.version})" if project.database.loaded?
-        else
-          print " [missing]" if !project.database.exist?
-        end
-        puts
-
-        puts "Releases"
-        project.releases.each { |release|
-          print "   #{release}"
-          if release.database.exist?
-            if release.database.version
-              print " loaded"
-            else
-              print " (empty database)"
-            end
-          end
-          if release.cached?
-            print ", cached"
-          end
-          print " <#{release.database.name}>"
-          print "\n"
-        }
-        puts
-        info(project)
-
-      when :status
-        args.expect(0)
-        puts "On branch #{project.release}" + (project.dirty? ? " (dirty)" : "")
-
-      when :history
-        args.expect(0)
-        history = project.release.history
-        history.each { |release, features|
-          puts release.to_s
-          indent {
-            features.map { |feature|
-              puts "#{feature}, base release: #{feature.base_release}"
-            }
-          }
-        }
-
-
-      # GENERAL COMMANDS ######################################################
-      # 
-      when :checkout
-        version = args.expect(1)
-        project.checkout(version)
-        puts "Checked out #{version}"
-
-      when :migrate
-        project.migrate
-
-
-      # DEVELOPER COMMANDS ####################################################
-      # 
-      when :feature # Shorthand for 'create feature'
-
-      when :rebase
-
-      when :prepare
-        args.expect(0)
-        if object = opts.prepare.subcommand!
-          case object
-            when :migration
-              project.prepare_migration
-              puts "Prepared migration"
-          else
-            raise "Oops: subcommand #{opts.subcommand.inspect} not matched"
-          end
-        else
+    when :make
+      command = opts.make!
+      case command.subcommand
+        when :clean
           args.expect(0)
-          project.prepare_release
-          puts "Prepared new release" if !opts.quiet?
-        end
-
-
-      # RELEASE MANAGER COMMANDS ##############################################
-      #
-      when :create
-        object = opts.create.subcommand!
-        release = 
-            case object
-              when :release
-                version = compute_version(project, args.expect(0..1))
-                project.create_release(version)
-              when :prerelease
-                version = compute_version(project, args.expect(1))
-                project.create_prerelease(version)
-              when :feature
-                project.create_feature(args.expect(1))
-            else
-              raise "Oops: subcommand #{opts.subcommand.inspect} not matched"
-            end
-        puts "Created #{object} #{release.version}" if !opts.quiet?
-
-      when :increment # and 'increment prerelease'
-        args.expect(0)
-        release = project.increment_prerelease
-        puts "Created prerelease #{release.version}" if !opts.quiet?
-
-      when :release # Shorthand for 'create release'
-        version = compute_version(project, args.expect(0..1))
-        release = project.create_release(version)
-        puts "Created release #{release.version}" if !opts.quiet?
-
-      when :prerelease # Shorthand for 'create prerelease' and 'increment'
-        release = 
-            if project.release?
-              version = compute_version(project, args.expect(1))
-              project.create_prerelease(version) 
-            elsif project.prerelease?
-              args.expect(0)
-              project.increment_prerelease
-            end
-        puts "Created prerelease #{release.version}" if !opts.quiet?
-
-      when :include
-        name = args.expect(1)
-        project.include_feature(name)
-        puts "Included feature #{name}" if !opts.quiet?
-        puts "Please check changed files and then commit using 'prick commit'"
-
-      when :commit
-        msg = project.commit_feature
-        puts msg if !opts.quiet?
-        puts "Committed changes" if !opts.quiet?
-
-
-      # MANIPULATING DATABASES AND RELEASES ###################################
-      #
-      when :list
-        # TODO: Mark cached releases as such
-        args.expect(0)
-        case opts.list.subcommand
-          when :databases, nil; project.databases.map(&:name)
-          when :releases; project.releases.map(&:name)
-          when :prereleases; project.prereleases.map(&:version)
-        else
-          ShellOpts.error "Illegal list type: '#{opts.list.subcommand}"
-        end.each { |e| puts e }
-
-      when :build
-        version = args.expect(0..1)
-        project.build(version)
-        if version
-          puts "Built #{version}"
+          program.make_clean(command.clean!.all?)
         else
-          puts "Built current version"
-        end
-
-      when :use
-        file = opts.use.file
-        version = args.expect(0..1)
-        file || version or raise Error, "Need either a version or a -f FILE argument"
-        file.nil? != version.nil? or raise Error, "Not both version and -f FILE arguments can be specified"
-        file ||= project[version].archive.path
-        project.load_database(nil, file)
-
-      when :load
-        file = opts.load.file
-        version = args.expect(1)
-        project.load_database(version, file)
-
-      when :reload
-        file = opts.reload.file
-        version = args.expect(1)
-        project.reload(version, file)
-
-      when :unload
-        version = args.expect(0..1)
-        project.unload(version)
-
-      when :clean
-        version = args.expect(0..1)
-        project.clean(version, project: true)
-
-      when NilClass
-        if args.size > 0
-          ShellOpts.error "#{args.first} is not a command"
-        end
-    else
-      raise "Oops: subcommand #{opts.subcommand.inspect} not matched"
-    end
+          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
+      program.drop(args.expect(0..1), opts.drop!.all)
+
+    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
@@ -464,4 +338,56 @@ 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]
+)