prick 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a41038c7beeb2bb1503ccb199cc45622d6fbe28e113003b98e8e78e10658a37
-  data.tar.gz: 59cb5055863ce2cd63ad9db5a2adf9a0de33d4386bca210dd8e9f25f602bb5e1
+  metadata.gz: cb7c2d20ea8aa16ba957f5139e00b02eec90d92a16316d9a468b97df7f83bc93
+  data.tar.gz: 6c2a0acd245344a1bb302aede789bb964757462786aebdc5fec14ea33f43e42f
 SHA512:
-  metadata.gz: 0b19d6f150e840101f60aa9337583257a0f72e36e2eb7a84b1403063b274099e7a27716aecd2ccaaaf09484a4f5d4b1f9da6eebde340fe9b69da8bab8342528e
-  data.tar.gz: 7b71790136d8de6e2f3c77a58fb5d1e432bbbe6f0c910ada86608e05f759c8ea68d255f1cc038ce2b5efebfb7e379f0bb2f607a94cfd99b5f26cf3665f135130
+  metadata.gz: 4d350899a5591bc2c6b8d2b6f88948ddf39a6146a535411c1affccf3f5f32dcee4ccb8b30ea0e19060d7bc6a6d1c21064ae10dacf9f19aa3997d04fd2466c892
+  data.tar.gz: fad2bbb8a50f18c779160bc17308072a94fd4ca98b1db76c3c16724eafe1c4128c4df4b0485051a136a19cf0315daff9b19dd4035dfe54cdbf624376c7c3c4c4

data/.gitignore

@@ -19,10 +19,8 @@
 
 # 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

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,3 @@
+
+o Make it possible to execute prick in any subdirecty instead of only in the root
+

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,15 +1,18 @@
 #!/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
+
+PROGRAM = File.basename($0)
 
-# TODO: Backup & restore
 SPEC = %(
   n,name=NAME
   C,directory=DIR
@@ -18,37 +21,30 @@ SPEC = %(
   q,quiet
   version
 
-  init! 
-  info!
-  status!
-  history!
-
-  checkout!
+  init! u,user=USER
 
-  feature!
-  rebase!
+  info!
+  list! list.releases! m,migrations c,cancelled list.migrations! list.upgrades! a,all
 
-  create! create.release! create.prerelease! create.feature! create.migration!
-  increment! increment.prerelease!
+  build! d,database=DATABASE C,nocache
+  make!
+  load! d,database=DATABASE
+  save! d,database=DATABASE
+  migrate!
 
-  prepare! prepare.release! prepare.prerelease! prepare.feature! prepare.migration!
-  include!
-  commit!
-  prerelease!
-  release!
+  prepare! prepare.release! prepare.migration! prepare.schema! prepare.diff!
+  include! include.feature!
+  check!
 
-  list! list.databases! list.releases! list.prereleases!
-  build!
-  use! f,file=FILE
-  load! f,file=FILE
-  reload! f,file=FILE
-  unload!
-  clean!
+  create! create.release! create.prerelease! create.feature!
+  cancel! cancel.release!
 
-  migrate!
+  upgrade!
+  backup!
+  restore!
 )
 
-USAGE = "-h -v -n NAME -C DIR COMMAND"
+USAGE = "Usage: #{PROGRAM} -h -v -n NAME -C DIR COMMAND" # FIXME: Why doesn't shellopts include PROGRAM?
 
 HELP = %(
   NAME
@@ -75,387 +71,246 @@ HELP = %(
       Print prick version
 
   COMMANDS
-    INFO COMMANDS
-      init [DIR]
-        Initialize a project directory
+    INITIALIZATION
+      init [DIR] --user=USER
+        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
 
+    INFO COMMANDS
       info
-        Print project information
 
-      status
-        Short status
-
-    GENERAL COMMANDS
-      checkout
-        As git checkout but does some extra work behind the scenes
+      list releases --migrations --cancelled
+      list migrations
+      list upgrades --all
+        List releases/migrations/upgrades
+
+    BUILDING
+      build -d database -C --nocache [version]
+        Builds the current database from the content in the schemas/ directory.
+        With an explicit version the given version is built or loaded from cache
+        into the associated versioned database. The -C argument force a build even
+        if a cache file is present. The -d option overrides the database
+
+      make
+        Not yet implemented
+  
+      load -d database file|version
+        Load a version or file into a database. If the argument is a version the
+        assocated versioned database will be loaded from cache. If the argument is
+        a file the project database is loaded. The -d option overrides what
+        database is used. This is often used to load a specific version into the
+        project database ('prick load -d <project-name> <version>') or to load into
+        an unrelated database not controlled by prick
+
+      save -d database [file]
+        Save the project database to the given file. Default file name is the
+        username suffixed with project name, custom name, and branch
 
       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
+        Not yet implemented
 
-      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>
+    PREPARING RELEASES
+      prepare release
+        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
 
-    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
+      prepare migration FROM
+        Create and populate a migration directory
 
-        (need some thought)
+      prepare schema NAME
+        Create and populate a new schema directory. Existing files and
+        directories are kept
 
-      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
+      prepare diff [VERSION]
 
-      include FEATURE
-        Merge a feature branch into the prepared release
+      include feature FEATURE
+        Include the given feature in the current pre-release
 
-      prerelease
-        Bumps the pre-release serial and create a new branch
+      check
+        Check that the current migration applied to the base version yields the
+        same result as loading the current schema
 
-      release [VERSION]
-        Create a new release. The version is not used if the release was prepared
+    CREATING RELEASES
+      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
 
-
-    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
+      create prerelease RELEASE
+        Prepare a release and create release directory and migration file
+        before branching to a prerelease branch
         
-      reload [VERSION]
-        Clear the versioned database and reload the release from the cache
+      create feature NAME
+        Prepare a feature before branching to a feature branch
 
-      unload [VERSION]
-        Delete the versioned database. Default is to delete all project related
-        databases
+      cancel release 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
 
-      clean [VERSION]
-        Delete the cached release. Default is to delete all cached releases
+    DEPLOYING RELEASES
+      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)
 
 # 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
+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
+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 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
+    directory = args.expect(0..1)
+    name = opts.name || directory || File.basename(Dir.getwd)
+    user = opts.init.user || name
+    program.initialize_directory(name, user, directory || ".")
+    exit 0
+  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}"
+
+  # Expect a sub-command
+  opts.subcommand? or raise Prick::Error, "Subcomand expected"
+
+  case opts.subcommand
+    when :info
+      args.expect(0)
+      program.info
+
+    when :build
+      version = args.expect(0..1)
+      program.build(opts.build.database, version, opts.build.nocache)
+
+    when :save
+      file_or_version = args.expect(0..1)
+      program.save(opts.save.database, file_or_version)
+
+    when :load
+      file_or_version = args.expect(1)
+      program.load(opts.load.database, file_or_version)
+
+    when :make
+      raise NotYet
+
+    when :migrate
+      raise NotYet
+
+    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 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 :prepare
+      cmd = opts.prepare.subcommand || :release
+      case cmd
+        when :release; args.expect(0); program.prepare_release
+        when :feature; raise NotYet
+        when :migration; program.prepare_migration(args.expect(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 require a release 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
-    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
+    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 +319,3 @@ rescue Prick::Error => ex
   ShellOpts.error(ex.message)
 end
 
-