prick 0.2.0

data/doc/sh.prick

@@ -0,0 +1,316 @@
+#!/usr/bin/bash
+
+# Name
+#   prick - Database project tool
+#
+# Usage
+#   prick prepare|migrate|release
+#
+# Commands
+#   prepare NEW-RELEASE
+#       Stamps NEW-RELEASE into the database
+#   migrate [OLD-RELEASE]
+#       Create a migration from OLD-RELEASE to the prepared release.
+#       OLD-RELEASE defaults to the last registered release
+#   release
+#       Release the prepared release
+#
+# Files
+#   prick use the following sub-directories:
+#
+#       releases/
+#           <database>-<release>.dump.gz
+#           ...
+#       migrations/
+#           migrate-<from>-<to>[.sql]
+#           ...
+#
+#   The releases directory contains schema backups that makes it easy to
+#   restore a earlier release used to generated migrations. The migrations directory
+#   contains migrations from one release to another. 'prick migrate' generates
+#   a SQL migration file but you can replace it with an executable if needed
+#
+
+# TODO: Schema-only dump of database
+# pg_dump --no-owner --no-privileges --schema-only name_of_database -f schema.dump.sql
+
+
+set -e
+
+. bash.include
+
+USAGE="prepare NEW-RELEASE
+             migrate OLD-RELEASE
+             release"
+
+DB=mikras
+
+function inoa() {
+    error "Illegal number of arguments"
+}
+
+[ $# -ge 1 ] || inoa
+CMD=$1
+shift
+
+trap 'eval rm -rf $ERRFILE $TMPFILE $TMPDIR' EXIT
+ERRFILE=$(mktemp --tmpdir $PROGRAM.XXXXXXXXXX)
+TMPFILE=$(mktemp --tmpdir $PROGRAM.XXXXXXXXXX)
+TMPDIR=$(mktemp --tmpdir --directory $PROGRAM.XXXXXXXXXX)
+#echo $TMPFILE
+#echo $TMPDIR
+
+function last_release() {
+    local path=$(ls releases/$DB-*.*.*.dump.gz 2>/dev/null | tail -1)
+    local release=$(echo $path | sed -e "s/releases\/$DB-//" -e 's/\.dump\.gz$//')
+    echo ${release:-0.0.0}
+}
+
+function current_release() {
+    psql -qtAX -d $DB -c "select major || '.' || minor || '.' || patch from meta.versions"
+}
+
+function set_current_release() {
+    set -- $(echo $1 | sed 's/\./ /g')
+    local major=$1
+    local minor=$2
+    local patch=$3
+
+    psql -qtAX -d $DB -c "update meta.versions set major = $major, minor = $minor, patch = $patch"
+}
+
+function has_release() {
+    local release=$1
+    local db=$DB-$release
+    psql -qtAX -d $DB -l | grep -q "^$db|" &>/dev/null
+}
+
+function database_load() {
+    local release=$1
+    local db=$DB-$release
+    local dump=releases/$db.dump.gz
+    [ -f $dump ] || error "Can't find release dump $dump"
+    [ ! has_release ] || error "Release $release is already loaded"
+    createdb $db
+    gzip --to-stdout $dump | psql -d $db
+}
+
+function redatabase_load() {
+    local release=$1
+    local db=$DB-$release
+    local dump=releases/$db.dump.gz
+    [ -f $dump ] || error "Can't find release dump $dump"
+    [ ! has_release ] || dropdb $db
+    createdb $db
+    gzip --to-stdout $dump | psql -d $db
+}
+
+
+function prepare() {
+    local new_release=$1
+    mesg "Preparing $new_release"
+
+    [ ! -f $new_release ] || error "New release already exists: $new_release_dump"
+    set_current_release $new_release
+}
+
+function migrate() {
+    local old_release=$1
+    local new_release=$(current_release)
+    local old_release_dump=releases/$DB-$old_release.dump.gz
+    local new_release_dump=releases/$DB-$new_release_dump.gz
+    local migration=migrations/migrate-$old_release-$new_release.sql
+
+    mesg "Migrating $old_release to $new_release"
+
+    [ -f $old_release_dump ] || error "Can't find old release: $old_release_dump"
+    [ ! -f $new_release_dump ] || error "New release already exists: $new_release_dump"
+    [ "$old_release" != "$new_release" ] || 
+        error "Can't migrate $old_release to itself (did you forget to prepare the release?)"
+    [ ! -f $migration ] || error "Won't overwrite migration $migration"
+
+    has_release $old_release || database_load $old_release
+#   migra --unsafe postgresql:///$DB-$old_release postgresql:///$DB || true #>$migration 
+    migra --unsafe postgresql:///$DB-$old_release postgresql:///$DB >$migration || {
+        case $? in
+            0)
+                mesg "No changes"
+                ;;
+            2)
+                mesg "Generated $migration"
+                ;;
+            *)
+                rm -f $migration
+                fail "migra failed"
+                ;;
+        esac
+    }
+}
+
+function database() {
+    local release=$1
+    echo "$DB-$release"
+}
+
+function dumpfile() {
+    local release=$1
+    echo "releases/$DB-$release.dump.gz"
+}
+
+###
+### R E L E A S E
+###
+
+function release_default() {
+    psql -qtAX -d $DB -c "select major || '.' || minor || '.' || patch from meta.versions"
+}
+
+function release_exist() {
+    local release=$1
+    local dump=$(dumpfile $release)
+    [ -f $dump ]
+}
+
+###
+### M I G R A T I O N S
+###
+
+function migration_create() {
+    local old_release=$1
+    local new_release=$(release_default)
+}
+
+function migration_apply() {
+    echo niy
+}
+
+
+###
+### D A T A B A S E
+###
+
+function database_loaded() {
+    local release=$1
+    local db=$(database $release)
+    psql -qtAX -d $DB -l | grep -q "^$db|" &>/dev/null
+}
+
+function database_build() {
+    local release=$1
+    local db=$(database $release)
+    ! database_loaded $release || fail "Database $db is already loaded"
+    mesg "Checking out release $release"
+    git archive --format=tar $release >$TMPFILE
+    (
+        cd $TMPDIR
+        tar xf $TMPFILE
+
+        # No git access so set spec.files to []
+        sed -i -e '/^ *spec.files/,+2d' mikras_db.gemspec -e 's/spec.files/[]/' mikras_db.gemspec
+
+        mesg "Running bundle"
+        bundle &>$ERRFILE || {
+            cat $ERRFILE >&2
+            fail "bundle failed"
+        }
+
+        # Set databse name
+        sed -i "s/^DB=.*/DB=$(database $release)/" exe/build
+
+        # Quote variables properly
+        perl -pi -e 's/:(\w+)/:"\1"/g' schemas/db.sql
+
+        # Replace schemas/skuffejern/users.sql - it is not possible to drop users because we
+        # run several versions of the database
+        for file in $(ls schemas/*/users.sql 2>/dev/null); do
+            {
+                psql -qtAX -d template1 \
+                    -c "select 1 from pg_user where pg_user.usename = 'anonymous'" \
+                | grep -q 1 || psql -qtAX -d template1 -c "create user anonymous"
+                    
+                psql -qtAX -d template1 \
+                    -c "select 1 from pg_roles where pg_roles.rolname = 'skuffejern_access'" \
+                | grep -q 1 || psql -qtAX -d template1 -c "create role skuffejern_access"
+            } >$file
+        done
+            
+        mesg "Running rebuild"
+        ./rebuild &>$ERRFILE || {
+            cat $ERRFILE >&2
+            fail "rebuild failed"
+        }
+    )
+}
+
+function database_save() {
+    local release=$1
+    local db=$(database $release)
+    local dump=releases/$db.dump.gz
+    [ ! -f $dump ] || fail "Won't overwrite release file $dump"
+    # pg_dump --no-owner --no-privileges --schema-only name_of_database -f schema.dump.sql
+    pg_dump --no-owner --schema-only $db | gzip --to-stdout >$dump
+}
+
+function database_load() {
+    local release=$1
+    local db=$(database $release)
+    local dump=releases/$db.dump.gz
+    ! database_loaded $db || fail "Database $db is already loaded"
+    [ -f $dump ] || fail "Can't find release file $dump"
+    createdb $db
+    gunzip --to-stdout $dump | psql -d $db &>$ERRFILE || {
+        cat $ERRFILE
+        fail "psql failed"
+    }
+}
+
+function database_drop() {
+    local release=$1
+    local db=$(database $release)
+    dropdb $db
+}
+
+
+case $CMD in    
+    list)
+        [ $# = 0 ] || inoa
+        psql -qtAX -d template1 -l | sed -n "/mikras[-0-9.]*|/s/|.*//p"
+        ;;
+    build)
+        [ $# = 1 ] || inoa
+        database_build $1
+        ;;
+    save)
+        [ $# = 1 ] || inoa
+        database_save $1
+        ;;
+    load)
+        [ $# = 1 ] || inoa
+        database_load $1
+        ;;
+    reload)
+        [ $# = 1 ] || inoa
+        ! database_loaded $1 || database_drop $1
+        database_load $1
+        ;;
+    drop)
+        [ $# = 1 ] || inoa
+        database_drop $1
+        ;;
+    prepare)
+        [ $# = 1 ] || inoa
+        prepare $1
+        ;;
+    migrate) # TODO: prick migrate from-release to-release
+        [ $# -le 1 ] || inoa
+        migrate ${1:-$(last_release)}
+        ;;
+    release)
+        mesg "Releasing"
+        ;;
+    *)
+        error "Illegal command: '$CMD'"
+        ;;
+esac
+
+

data/exe/prick

@@ -0,0 +1,467 @@
+#!/usr/bin/env ruby
+
+require 'prick.rb'
+
+require 'shellopts'
+require 'indented_io'
+require 'tempfile'
+require 'ext/algorithm.rb'
+
+include ShellOpts
+
+# 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
+      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
+
+    -h, --help
+      Print this page
+
+    -v, --verbose
+      Be verbose
+
+    --version
+      Print prick version
+
+  COMMANDS
+    INFO COMMANDS
+      init [DIR]
+        Initialize a project directory
+
+      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
+
+        (need some thought)
+
+      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
+
+      include FEATURE
+        Merge a feature branch into the prepared release
+
+      prerelease
+        Bumps the pre-release serial and create a new branch
+
+      release [VERSION]
+        Create a new release. The version is not used if the release was prepared
+
+
+    MANIPULATING DATABASES AND RELEASES
+      list [databases|releases|prereleases]
+        Output a list of databases, releases, or prereleases. List databases by
+        default
+
+      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
+
+      load
+        Load the current cache into the project database
+
+      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
+
+      unload [VERSION]
+        Delete the versioned database. Default is to delete all project related
+        databases
+
+      clean [VERSION]
+        Delete the cached release. Default is to delete all cached releases
+
+
+)
+
+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)
+
+# 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
+  exit
+end
+
+# Handle --version
+if opts.version?
+  puts "prick-#{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}'" 
+    end
+  end
+
+  name = opts.name || ENV["PRICK_PROJECT"] || File.basename(Dir.getwd)
+  verbose = opts.verbose?
+
+  # :init! is processed separately because the project object can't be
+  # constructed before the directory has been initialized
+  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
+
+      # INFO COMMANDS #########################################################
+      #
+      when :info
+        args.expect(0)
+
+        puts "Current branch"
+        puts "   #{project.release&.version || 'nil'}"
+
+        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
+          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}"
+        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
+  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
+
+