prick 0.2.0 → 0.3.0

data/lib/prick/program.rb

@@ -0,0 +1,238 @@
+
+require "prick.rb"
+
+module Prick
+  # Implements the command line commands
+  class Program
+    def project() @project ||= Project.load end
+
+    attr_accessor :quiet
+    attr_accessor :verbose
+
+    def initialize(quiet: false, verbose: false)
+      @quiet = quiet
+      @verbose = verbose
+    end
+
+    def mesg(*args) puts args.compact.grep(/\S/).join(' ') if !quiet end
+    def verb(*args) puts args.compact.grep(/\S/).join(' ') if verbose end
+    def check_clean() Git.clean? or raise Error, "Repository is dirty - please commit your changes first" end
+
+    def initialize_directory(project_name, database_user, directory)
+      !Project.initialized?(directory) or raise Error, "Directory #{directory} is already initialized"
+      Project.initialize_directory(project_name, database_user, directory)
+      if project_name != File.basename(directory)
+        mesg "Initialized project #{project_name} in #{directory}"
+      else
+        mesg "Initialized project #{project_name}"
+      end
+    end
+
+    def info
+      if project.tag?
+        puts "At v#{project.version} tag"
+      else
+        puts "On branch #{project.branch.name}"
+      end
+      puts "  Git is " + (Git.clean? ? "clean" : "dirty")
+      bv = project.branch.version
+      dv = project.database.version
+      sv = project.branch.schema.version
+      puts "  Database version: #{dv}" + (dv != bv ? " (mismatch)" : "")
+      puts "  Schema version  : #{sv}" + (sv != bv ? " (mismatch)" : "")
+    end
+
+    # TODO: Move to project to take advantage of cache
+    def build(database, version, no_cache)
+      version = version && Version.new(version)
+      into_mesg = database && "into #{database}" 
+      database = database ? Database.new(database, project.user) : project.database(version)
+      if version
+        Git.tag?(version) or raise Error, "Can't find tag v#{version}"
+        cache_file = project.cache_file(version)
+        if !no_cache && File.exist?(cache_file)
+          project.load(cache_file, database: database)
+          mesg "Loaded v#{version}", into_mesg, "from cache"
+        else
+          project.build(database: database, version: version)
+          project.save(cache_file, database: database)
+          mesg "Built v#{version}", into_mesg
+        end
+      else
+        project.build(database: database)
+        mesg "Built current schema", into_mesg
+      end
+    end
+
+    def load(database, file_or_version)
+      version = Version.try(file_or_version)
+      into_mesg = database && "into #{database}" 
+      database = database ? Database.new(database, project.user) : project.database(version)
+      if version
+        file = project.cache_file(version)
+        File.exist?(file) or raise Error, "Can't find #{file} - forgot to build?"
+        project.load(file, database: database)
+        mesg "Loaded v#{version}", into_mesg
+      else
+        file = file_or_version
+        project.load(file, database: database)
+        mesg "Loaded #{file}", into_mesg
+      end
+    end
+
+    def save(database, file)
+      file ||= "#{ENV['USER']}-#{name}-#{branch}.sql.gz"
+      subject_mesg = database ? "database #{database}" : "current database"
+      database = database ? Database.new(database, project.user) : project.database(version)
+      project.save(file, database: database)
+      mesg "Saved", subject_mesg, "to #{file}"
+    end
+
+    def make(subject)
+      project.database.exist? or raise Error, "Project database is not present"
+      project.make(project.database, subject)
+    end
+
+    def list_releases(migrations: false, cancelled: false)
+      puts (project.list_releases(all: cancelled) + (migrations ? project.list_migrations : [])).sort.map(&:name)
+    end
+
+    def list_migrations
+      puts project.list_migrations.sort.map(&:name)
+    end
+
+    def list_upgrades(from = nil, to = nil)
+      from = from ? Version.new(from) : project.database.version
+      to = to ? Version.new(to) : project.branch.version
+      branches = project.list_upgrades(from, to)
+      puts branches.map(&:name)
+    end
+
+    def prepare_schema(name)
+      project.prepare_schema(name)
+      mesg project.message
+    end
+
+    def prepare_diff(version = nil)
+      version ||= 
+          if project.prerelease? || project.migration? || project.feature?
+            project.branch.base_version
+          else
+            project.branch.version
+          end
+      project.prepare_diff(version)
+      mesg "Remember to update the associated SQL migration files"
+    end
+
+    def prepare_release
+      check_clean
+      project.version.release? or raise Error, "You need to be on a release branch to prepare a release"
+      project.prepare_release
+      mesg project.message
+    end
+
+    def check
+      version ||= 
+          if project.prerelease? || project.migration?
+            project.branch.base_version
+          else
+            project.branch.version
+          end
+      project.check_migration(version)
+    end
+
+    # `arg` can be a version numer of a relative increase (eg. 'minor')
+    def create_release(arg = nil)
+      check_clean
+      if project.release?
+        arg or raise Error, "Need a version argument"
+        version = compute_version(project.version, arg)
+        project.create_release(Version.new(version))
+        mesg project.message
+      elsif project.prerelease?
+        arg.nil? or raise Error, "Illegal number of arguments"
+        project.create_release_from_prerelease
+        mesg project.message
+      else
+        raise Error, "You need to be on a release or pre-release branch to create a new release"
+      end
+    end
+
+    def cancel_release(arg)
+      project.cancel_release(Version.new(arg))
+    end
+
+    def create_prerelease(arg)
+      check_clean
+      if project.release?
+        version = %w(major minor patch).include?(arg) ? project.version.increment(arg.to_sym) : Version.new(arg)
+        project.prepare_release(commit: false)
+        prerelease = project.create_prerelease(version)
+        mesg "Created pre-release #{prerelease.version}"
+      elsif project.prerelease?
+        arg.nil? or raise Error, "Illegal number of arguments"
+        prerelease = project.increment_prerelease
+        mesg "Created pre-release #{prerelease.prerelease_version}"
+      else
+        raise Error, "You need to be on a release branch to create a pre-release"
+      end
+    end
+
+    def prepare_migration(arg)
+      check_clean
+      version = Version.new(arg)
+      project.release? or raise "You need to be on a release or migration branch to prepare a migration"
+      project.prepare_migration(version)
+      mesg project.message
+    end
+
+    def create_feature(name)
+      check_clean
+      project.release? or raise "You ned to be on a release branch to create a feature"
+      project.create_feature(name)
+      mesg "Created feature '#{name}'"
+    end
+
+    def include_feature(name_or_version)
+      check_clean
+      project.prerelease? or raise Error, "You need to be on a pre-release branch to include a feature"
+      version = Version.try(name_or_version) || 
+          Version.new(project.branch.base_version, feature: name_or_version)
+      Git.branch?(version.to_s) or raise Error, "Can't find feature #{version}"
+      project.include_feature(version)
+      mesg "Included feature '#{name_or_version}'"
+      mesg "Please resolve eventual conflicts and then commit"
+    end
+
+    def upgrade
+      # TODO: Shutdown connections
+      project.database.version != project.version or raise Error, "Database already up to date"
+      project.backup
+      begin
+        project.upgrade
+      rescue RuntimeError
+        project.restore
+        raise Fail, "Failed upgrading database, rolled back to last version"
+      end
+    end
+
+    def backup(file = nil) project.backup(file) end
+
+    def restore(file = nil)
+      file.nil? || File.exist?(file) or raise Error, "Can't find #{file}"
+      project.restore(file)
+    end
+
+  private
+    def compute_version(version, arg)
+      if arg.nil?
+        nil
+      elsif %w(major minor patch).include?(arg)
+        version.increment(arg.to_sym)
+      else
+        Prick::Version.new(arg)
+      end
+    end
+  end
+end
+

data/lib/prick/project.rb

@@ -1,442 +1,350 @@
+require "prick/state.rb"
 
-require "prick/constants.rb"
-
-require "prick/archive.rb"
-require "prick/build.rb"
-require "prick/migration.rb"
-require "prick/database.rb"
-require "prick/schema.rb"
-require "prick/git.rb"
-require "prick/migra.rb"
-
-require 'fileutils'
+require "tmpdir"
 
 module Prick
   class Project
-    # Name of project. Used in database and release names. Defaults to the name
-    # of the current directory
+    # Name of project. Persisted in the project state file
     attr_reader :name
 
-    # Name of Postgresql user that own the database(s). Defaults to #name
+    # Name of Postgresql user that owns the databases. Defaults to #name.
+    # Persisted in the project state file. TODO: Make writable
     attr_reader :user
+  
+    # Current branch
+    attr :branch
 
-    # Schema. Represents the schema definition under the schemas/ directory
-    attr_reader :schema
-   
-    # The current release, prerelease or feature
-    def release() @builds_by_name[Git.current_branch] end
-
-    # The project database. The project database has the same name as the project
-    # and doesn't include a version. It does not have to exist
-    attr_reader :database
+    # Version of the current branch. If is defined as #branch.version
+    def version() branch.version end
 
-    # List of all builds
-    def builds() @builds_by_name.values end
-
-    # List of releases ordered from oldest to newest. Custom releases are sorted
-    # after regular releases and alphabetical between themselves
-    attr_reader :releases
-
-    # List of pre-releases
-    attr_reader :prereleases
+    # Project (default) database
+    def database(version = nil)
+      version ? Database.new("#{name}-#{version.truncate(:pre)}", user) : @database
+    end
 
-    # Hash from base-release name to feature. Note that this doesn't follow release history
-    attr_reader :features
+    # Last commit message. TODO: Move to git.rb
+    attr_reader :message
+
+    # True if we're on a tag
+    def tag?() Git.detached? end
+    def self.tag?() Git.detached? end
+    
+    # Classifiers
+    forward_methods :release?, :prerelease?, :feature?, :migration?, :@branch
+
+    def initialize(name, user, branch)
+      @name = name
+      @user = user
+      @branch = branch
+      @database = Database.new(name, user)
+    end
 
-    # Ignored and orphaned objects
-    attr_reader :ignored_feature_nodes
-    attr_reader :ignored_release_nodes
-    attr_reader :orphan_feature_nodes
-    attr_reader :orphan_release_nodes
-    attr_reader :orphan_git_branches
+    def self.load
+      name = Git.current_branch || Git.current_tag
+      if name =~ MIGRATION_RE
+        branch = MigrationRelease.load(name)
+      else
+        begin
+          version = Version.new(name)
+        rescue Version::FormatError
+          raise Fail, "Illegal branch name: #{name}"
+        end
+        if version.release?
+          branch = Release.load(name)
+        elsif version.pre?
+          branch = PreRelease.load(name, version)
+        elsif version.feature?
+          branch = Feature.load(name)
+        else
+          raise Oops
+        end
+      end
+      state = ProjectState.new.read
+      Project.new(state.name, state.user, branch)
+    end
 
-    # True if we're on a release branch
-    def release?() release && release.version.pre.nil? && !feature? end
+    def self.initialized?(directory) 
+      File.directory?(directory) && Dir.chdir(directory) { ProjectState.new.exist? } 
+    end
 
-    # True if we're on a pre-release branch
-    def prerelease?() release && !release.version.pre.nil? && !feature? end
+    def self.initialize_directory(name, user, directory)
+      FileUtils.mkdir_p(directory)
+      Dir.chdir(directory) {
+        # Initialize git instance
+        Git.init
 
-    # True if we're on a feature branch
-    def feature?() release && !release.version.feature.nil? end
+        # Create prick version file
+        PrickVersion.new.write(VERSION)
 
-    # Sorted list of databases associated with a release. Also include the
-    # project database if project. is true. If all: is true, also list
-    # databases that match the project but is without an associated release
-    def databases(all: false, project: true)
-      r = (project ? [database] : [])
-      if all
-        r + Rdbms.list_databases(Prick.database_re(name)).map { |name| Database.new(name, user) }
-      else
-        r + @releases.map(&:database)
-      end
-    end
+        # Create project state file
+        ProjectState.new(name: name, user: user).write
 
-    # `name` is the project name and `user` is the name of the Postgresql user.
-    # `name` defaults to the name of the current directory and `user` defaults
-    # to `name`
-    def initialize(name = nil, user = nil)
-      @name = name || File.basename(Dir.getwd)
-      @name =~ PROJECT_NAME_RE or raise Error, "Illegal project name: #@name"
-      @user = user || @name
-      @user =~ USER_NAME_RE or raise Error, "Illegal postgres user name: #@user"
-#     Rdbms.ensure_state(:user_exist, @user)
-      Rdbms.create_user(@user) if !Rdbms.exist_user?(@user) # FIXME
-      @schema = Schema.new(self)
-      @database = Database.new(@name, @user)
+        # Directories
+        DIRS.each { |dir|
+          !File.exist?(dir) or raise Fail, "Already initialized: Directory '#{dir}' exists"
+        }
+        FileUtils.mkdir_p(DIRS)
+        DIRS.each { |dir| FileUtils.touch("#{dir}/.keep") }
 
-      @builds_by_name = {}
-      @builds_by_version = {}
+        # Copy default gitignore and schema files
+        Share.cp("gitignore", ".gitignore")
+        Share.cp("schemas", ".")
 
-      @releases = []
-      @prereleases = []
-      @features = {}
+        # Add everything so far
+        Git.add(".")
+        Git.commit("Initial import")
 
-      @ignored_feature_nodes = []
-      @ignored_release_nodes = []
+        # Create initial release
+        release = Release.new(Version.zero, nil)
+        release.create
 
-      @orphan_feature_nodes = []
-      @orphan_release_nodes = [] # Includes prereleases
+        schema = Schema.new(SCHEMAS_DIR)
+        schema.version = release.version
+        Git.add schema.version_file
 
-      @orphan_git_branches = []
+        Git.commit "Release 0.0.0"
+        release.tag!
 
-      load_project
+        # Kill master branch
+        Git.delete_branch("master")
+      }
     end
 
-    def [](name_or_version) 
-      name = version = name_or_version
-      case name_or_version
-        when String; @builds_by_name[name]
-        when Version; @builds_by_version[version]
-        when NilClass; nil
+    def build(database: self.database, version: nil)
+      clean(database)
+      if version
+        FileUtils.mkdir_p(TMP_DIR)
+        Dir.mktmpdir("clone-", TMP_DIR) { |dir|
+          Command.command "git clone . #{dir}"
+          Dir.chdir(dir) {
+            Git.checkout_tag(version)
+            project = Project.load
+            project.branch.build(database)
+          }
+        }
       else
-        raise Internal, "Expected String or Version index, got #{name_or_version.class}"
+        branch.build(database)
       end
+      self
     end
 
-    def []=(name_or_version, branch)
-      case name_or_version
-        when String; 
-          name = name_or_version
-          version = Version.new(name)
-        when Version
-          version = name_or_version
-          name = version.to_s
-      else
-        raise Internal, "Expected String or Version index, got #{name_or_version.class}"
-      end
-      @builds_by_name[name] = @builds_by_version[version] = branch
+    def load(file, database: self.database)
+      clean(database)
+      database.load(file)
+      self
     end
 
-    def dirty?() !Git.clean? end
-
-    def build?(name_or_version) 
-      name = version = name_or_version
-      case name_or_version
-        when String; @builds_by_name.key?(name)
-        when Version; @builds_by_version.key?(version)
-        when NilClass; nil
-      else
-        raise Internal, "Expected String or Version index, got #{name_or_version.class}"
-      end
+    def save(file, database: self.database)
+      database.save(file)
+      self
     end
 
-    # Initialize an on-disk prick instance
-    def self.initialize_directory(directory)
-      FileUtils.mkdir_p(directory)
-      Dir.chdir(directory) {
-        DIRS.each { |dir| 
-          !File.exist?(dir) or raise Fail, "Already initialized: Directory '#{dir}' exists"
-        }
+    def cache_file(version) File.join(CACHE_DIR, "#{database(version)}.sql.gz") end
 
-        FileUtils.mkdir_p(DIRS)
-        DIRS.each { |dir| FileUtils.touch("#{dir}/.keep") }
-      }
+    def make(database, subject)
+      Schema.built? or raise Error, "Schema is not built into project database"
+      Schema.make(database, subject)
     end
 
-    # Create an initial release 0.0.0. ::initialize_project expects to be executed
-    # in the project directory
-    def self.initialize_project(name = File.basename(Dir.getwd), user = name || ENV['USER'])
-      FileUtils.cp("#{SHARE_PATH}/gitignore", ".gitignore")
-      FileUtils.cp("#{SHARE_PATH}/schemas/prick/schema.sql", "schemas/prick")
-      FileUtils.cp("#{SHARE_PATH}/schemas/prick/data.sql", "schemas/prick")
-      Git.init
-      Git.add(".")
-      Git.commit("Initial import")
-      project = Project.new(name, user)
-      release = Release.new(project, nil, Version.new("0.0.0"))
-      release.create
-
-      Git.delete_branch("master")
+    def backup(path = nil)
+      save path || File.join(SPOOL_DIR, "#{name}-#{Time.now.utc.strftime("%Y%m%d-%H%M%S")}.sql.gz")
     end
 
-    # Returns the full path to the project directory (TODO: Test)
-    def path() File.expand_path(".") end
-
-    ### COMMON METHODS
-
-    def checkout(name)
-      check_clean
-      Git.checkout_branch(name)
+    def restore(path = nil)
+      load path || Dir.glob(File.join(SPOOL_DIR, "#{name}-*.sql.gz")).sort.last
     end
 
-    # Migrate the database from its current version to the current release on disk
-    def migrate
-      check_clean
-      database.exist? or raise "Project database not found"
-      history = release.history.keys.reverse.drop(1)
-      history.select! { |release| release.version >= database.version }
-      history.each { |release| release.migration.migrate(database.name) }
-      database.version = release.version
+    def prepare_release(commit: true)
+      release = ReleaseMigration.new(nil, branch.version).create
+      submit "Prepared new release based on #{version}", commit
+      release
     end
 
-    ### DEVELOPER-LEVEL METHODS
-
-    # Create and switch to feature branch
-    def feature(name)
-      check_clean
-      release? or raise Error, "Need to be on a release branch to create a feature"
-      feature = Feature.new(self, release, name).ensure(:active)
-      Git.commit "Created feature #{name}"
+    def prepare_schema(name, commit: true)
+      path = File.join(SCHEMAS_DIR, name)
+      FileUtils.mkdir_p(path)
+      Git.add Share.cp("schema/*", path, clobber: false, templates: { 'SCHEMA' => name })
+      File.open(branch.schema.yml_file, "a") { |f| f.write("- #{name}\n") }
+      Git.add(branch.schema.yml_file)
+      submit "Added schema #{name}", commit
     end
 
-    def rebase(version)
-      check_clean
-      feature? or raise Error, "Need to be on a feature branch to rebase"
-      release.rebase(version)
-      Git.commit "Rebased to #{version}"
-    end
+    def prepare_diff(from_version)
+      to_database = nil
+      begin
+        from_name = "#{name}-base"
+        from_database = Database.new(from_name, user)
+        build(database: from_database, version: from_version)
 
-    ### RELEASE MANAGER LEVEL METHODS
+        to_name = "#{name}-next"
+        to_database = Database.new(to_name, user)
+        build(database: to_database)
 
-    # Create the first prerelease
-    #
-    # TODO Make it just copy files and commit them. Supports a single-user
-    # workflow. Requires a :prepared state
-    def prepare_release
-      check_clean
-      release? or raise Error, "Need to be on a release branch to prepare a new release"
-      release.prepare
-    end
+        # Helpful double-check
+        Diff.same?(to_database.name, database.name) or 
+            raise Error, "Schema and project database are not synchronized"
 
-    def prepare_migration
-      check_clean
-      prerelease? || feature? or raise Error, "Need to be on a prerelease or feature branch to include features"
+        if release?
+          dir = branch.migration.migration_dir
+        else
+          dir = branch.migration.features_dir
+        end
 
-      base_database = release.base_release.database
-      build(base_release.version) if !base_database.loaded?
-      build # if !database.loaded?
+#       dir = branch.migration.features_dir || branch.migration.migration_dir
+        to_file = File.join(dir, DIFF_FILE)
 
-      diff_sql = release.migration.diff_sql
-      Migra.migrate(base_database.name, database.name, diff_sql)
-    end
+        if prerelease?
+          branch.migrate_features(from_database)
+        end
 
-    def create_release(version = nil)
-      check_clean
-      if release?
-        !version.nil? or raise Error, "Need version argument when on a release branch"
-        new_release = Release.new(self, release, version)
-      elsif prerelease?
-        version.nil? or raise Error, "Can't use version argument when on a pre-release branch"
-        new_release = release.target_release
-      else
-        raise Error, "Need to be on a release or pre-prelease branch to create a new release"
+        Diff.new(from_name, to_name).write(to_file)
+      ensure
+        from_database&.drop
+        to_database&.drop
       end
-      new_release.create
-      new_release
     end
 
-    def create_prerelease(target_version)
-      check_clean
-      release? or raise Error, "Need to be on a release branch to create a pre-release"
-      prerelease = Prerelease.new(self, release, target_version.increment(:pre, 0), target_version)
-      prerelease.create
+    def prepare_migration(from, commit: true)
+      to = branch.version
+      migration_release = MigrationRelease.new(to, from)
+      migration_release.create
+      submit "Prepared migration from #{from} to #{to}", commit
+      migration_release
     end
 
-    def increment_prerelease
-      check_clean
-      prerelease? or raise Error, "Need to be on a pre-release branch to make an incremental pre-release"
-      prerelease = Prerelease.new(self, release.base_release, release.version.increment(:pre))
-      prerelease.create
+    def create_release(version, commit: true)
+      check_migration(branch.version) or raise Error, "Schema/migration mismatch"
+      release = Release.new(version, branch.version)
+      release.create
+      submit "Created release #{version}", commit
+      release.tag!
+      build
+      release
     end
 
-    def create_feature(name)
-      check_clean
-      release? or raise Error, "Need to be on a release branch to create a feature"
-      feature = Feature.new(self, release, name)
-      feature.create
+    def cancel_release(version, commit: true)
+      Git.cancel_tag(version)
     end
 
-    # Note: Does not commit
-    def include_feature(feature_version)
-      check_clean
-      prerelease? || feature? or raise Error, "Need to be on a prerelease or feature branch to include features"
-      Git.branch?(feature_version) or raise Error, "Can't find branch #{feature_version}"
-      release.include_feature(self[feature_version])
+    def create_release_from_prerelease(commit: true)
+      check_migration(branch.base_version) or raise Error, "Schema/migration mismatch"
+      release = Release.new(branch.version.truncate(:pre), branch.base_version)
+      release.create
+      submit "Released #{release.version}", commit
+      release.tag!
+      build
+      release
     end
 
-    def commit_feature
-      msg = File.readlines(".git/MERGE_MSG").first.chomp
-      Git.commit msg
-#     Command.command "git commit -F .git/MERGE_MSG"
+    def create_prerelease(version, commit: true)
+      prerelease = PreRelease.new(version.increment(:pre), branch.version)
+      prerelease.create
+      submit "Created pre-release #{prerelease.version}", commit
+      build
+      prerelease
     end
 
-    def create_migration
+    def increment_prerelease(commit: true)
+      prerelease = branch.increment
+      prerelease.create
+      submit "Created pre-release #{prerelease.version}", commit
+      build
+      prerelease
     end
 
-    # Build the current database from the content of schema
-    def build(version = nil)
-      if version.nil?
-        database.recreate
-        schema.build 
-      else
-        release = self[version] or raise Error, "Can't find release #{version}"
-        release.database.recreate
-        FileUtils.mkdir_p(CACHE_DIR)
-        if !File.directory?(File.join(CLONE_DIR, ".git"))
-          FileUtils.rm_rf(CLONE_DIR)
-          Command.command "git clone . #{CLONE_DIR}"
-        end
-        Dir.chdir(CLONE_DIR) {
-          Git.checkout_tag(version.to_s)
-          project = Project.new(name, user)
-          release.database.recreate
-          project.schema.build(release.database)
-        }
-        release.cache
-      end
-    end
+#   # Turned out to be a bad idea
+#   def retarget_migration(version, commit: true)
+#     branch.retarget(version)
+#     commit "Retargeted to #{version}" if commit
+#     branch
+#   end
 
-    # Load file into current database
-    def use_database(file = nil)
-      check_clean
-      File.file?(file) or raise Error, "Can't find #{file}"
-      database.recreate
-      database.load(file)
+    def create_feature(name, commit: true)
+      feature = Feature.new(name, version)
+      feature.create
+      submit "Created feature #{name}", commit
     end
 
-    # Load file into the given database version. If version is nil the current
-    # database is used. If file is nil, the database associated with the given
-    # version is used. Not both version and file can be nil
-    def load_database(version, file = nil)
-      check_clean
-      !version.nil? || !file.nil? or raise Fail, "Not both version and file can be nil"
-      if version
-        release = self[version]
-        file ||= release.archive.path
-        File.file?(file) or raise Error, "Can't find #{file}"
-        release.database.recreate
-        release.database.load(file)
-      else
-        database.recreate
-        database.load(file)
-      end
+    def include_feature(feature_version, commit: false)
+      Git.merge_branch(feature_version, exclude_files: [branch.schema.version_file], fail: true)
+      branch.include(feature_version)
     end
 
-#   def reload_release(version, *file) 
-#     lookup(version).reload(*file) 
-#   end
-#
-#   def unload(version = nil) 
-#     if version
-#       lookup(version).database.drop
-#     else
-#       databases.each(&:drop) 
-#     end
-#   end
-#
-    # Remove temporary files and databases
-    def cleanup(version = nil, project: false)
-      if version
-        release = self[version]
-        release.archive.delete
-        release.database.drop
-      else
-        FileUtils::rm_rf CLONE_DIR
-        FileUtils::rm_f Dir.glob(File.join(CACHE_DIR, Prick.dump_glob(name)))
-        databases(all: true, project: project).each(&:drop)
+    # Checks that the migration of the current branch takes the database from
+    # the base version to the content of the schema
+    def check_migration(from_version)
+      begin
+        from_db = Database.new("#{name}-base", user)
+        to_db = Database.new("#{name}-next", user)
+        build(database: from_db, version: from_version)
+        build(database: to_db)
+        migration = # FIXME: This may be a repeated pattern
+            if migration?
+              branch.migration
+            elsif prerelease?
+              branch.migration
+            else
+              Migration.new(nil, branch.directory)
+            end
+        migration.migrate(from_db)
+        Diff.new(from_db, to_db).same?
+      ensure
+        from_db&.drop
+        to_db&.drop
       end
     end
 
-  private
-    def check_clean()
-      !dirty? or raise "Repository is dirty. Commit your changes and try again"
+    # TODO: Make production-only and add a to-argument
+    def upgrade
+      branches = list_upgrades(database.version, branch.version)
+      FileUtils.mkdir_p(TMP_DIR)
+      Dir.mktmpdir("clone-", TMP_DIR) { |dir|
+        Command.command "git clone . #{dir}"
+        Dir.chdir(dir) {
+          branches.each { |branch|
+            branch.checkout_release
+            project = Project.load
+            project.branch.migrate(project.database)
+          }
+        }
+      }
     end
 
-    # For debug
-    def dump_deps(deps)
-      deps.each { |k,v|
-        puts "  #{k} -> #{v || 'nil'}"
+    def list_releases(all: false)
+      Git.list_tags(include_cancelled: all).grep(RELEASE_RE) { |tag|
+        version = $2
+        dir = File.join(RELEASES_DIR, version)
+        migration_state = MigrationState.new(dir).read(tag: tag)
+        Release.new(migration_state.version, migration_state.base_version)
       }
     end
 
-    def load_project
-      # Maps from version to base release version
-      releases = { Version.zero => nil }
-      prereleases = {}
-      features = {}
-
-      # Collect branches from git
-      Git.list_branches.each { |branch|
-        if Version.version?(branch)
-          version = Version.new(branch)
-          if version.feature?
-            features[version] = version.truncate(:feature)
-          elsif version.pre?
-            prereleases[version] = nil
-          elsif version.release?
-            releases[version] = nil
-          else
-            raise Internal, "Unexpected state for #{version}"
-          end
-        else
-          @orphan_git_branches << branch
-        end
+    # TODO
+    # list_migrations(all: false)
+    def list_migrations
+      Git.list_branches.grep(MIGRATION_RE) { |branch|
+        from_version = Version.new($1)
+        to_version = Version.new($4)
+        MigrationRelease.new(to_version, from_version)
       }
+    end
 
-      # Find base release for present releases and prereleases
-      Dir.each_child(RELEASE_DIR) { |node|
-        next if node.start_with?(".")
-        if Version.version?(node)
-          version = Version.new(node)
-          if releases.key?(version)
-            base_release = Build.deref_node_file(File.join(RELEASE_DIR, node))
-            releases[version] = base_release
-          elsif prereleases.key?(version)
-            base_release = Build.deref_node_file(File.join(RELEASE_DIR, node))
-            prereleases[version] = base_release
-          else
-            @orphan_release_nodes << node
-          end
-        else !prerelease_deps.key?(node)
-          @ignored_release_nodes << node
-        end
-      }
+    def list_upgrades(from, to)
+      edges = (list_releases + list_migrations).map { |branch| [branch.base_version, branch.version, branch] }
+      (Algorithm.shortest_path(edges, from, to) || []).map(&:last)
+    end
 
-      releases.sort_by { |k,v| k }.each { |release, base_release|
-        @releases << Release.new(self, self[base_release], release)
-      }
-      @releases.sort!
+  private
+    def submit(msg, commit = true)
+      Git.commit msg if commit
+      @message = msg
+    end
 
-      prereleases.each { |prerelease, base_release|
-        if base_release
-          @prereleases << Prerelease.new(self, self[base_release], prerelease)
-        else
-          @ignored_release_nodes << prerelease
-        end
-      }
-      @prereleases.sort!
-
-      if !Git.detached?
-        features.each { |feature, base_release|
-#       if File.exist?(base_release_file)
-#         recursive include of dependent releases
-
-          if base_release
-            (@features[base_release] ||= []) << Feature.new(self, self[base_release], feature.feature)
-          else
-            @ignored_release_nodes << release
-          end
-        }
+    def clean(database)
+      if database.exist?
+        database.recreate if database.loaded?
+      else
+        database.create
       end
     end
   end