prick 0.2.0 → 0.7.0

data/lib/prick/project.rb

@@ -1,442 +1,614 @@
+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
     attr_reader :name
+    attr_reader :user # Database user
+    attr_reader :head # Current branch/tag
+    attr_reader :schema
 
-    # Name of Postgresql user that own the database(s). Defaults to #name
-    attr_reader :user
+    # Return the versioned database or the project database if `version` is nil
+    def database(version = nil)
+      version ? Database.new("#{name}-#{version}", user) : @database
+    end
 
-    # 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
-
-    # 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
-
-    # Hash from base-release name to feature. Note that this doesn't follow release history
-    attr_reader :features
-
-    # 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
-
-    # True if we're on a release branch
-    def release?() release && release.version.pre.nil? && !feature? end
-
-    # True if we're on a pre-release branch
-    def prerelease?() release && !release.version.pre.nil? && !feature? end
-
-    # True if we're on a feature branch
-    def feature?() release && !release.version.feature.nil? end
-
-    # 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
+    attr_reader :cache
+
+    def initialize(name, user, head)
+      @name = name
+      @user = user || ENV['USER']
+      @head = head
+      @schema = Schema.new
+      @database = Database.new(name, user)
+      @cache = Cache.new
     end
 
-    # `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)
+    forward_methods :version, :base_version, :@head
+    forward_methods :clean?, :@head
+    forward_methods :tag?, :release_tag?, :migration_tag?, :@head
+    forward_methods :branch?, :release_branch?, :prerelease_branch?, :feature_branch?, :migration_branch?, :@head
 
-      @builds_by_name = {}
-      @builds_by_version = {}
+    def self.exist?(directory) 
+      File.directory?(directory) && Dir.chdir(directory) { ProjectState.new.exist? } 
+    end
 
-      @releases = []
-      @prereleases = []
-      @features = {}
+    def self.create(name, user, directory)
+      user ||= ENV['USER']
 
-      @ignored_feature_nodes = []
-      @ignored_release_nodes = []
+      FileUtils.mkdir(directory) if directory != "."
 
-      @orphan_feature_nodes = []
-      @orphan_release_nodes = [] # Includes prereleases
+      Dir.chdir(directory) {
+        # Initialize git instance
+        Git.init
 
-      @orphan_git_branches = []
+        # Create prick version file
+        PrickVersion.new.write(VERSION)
 
-      load_project
+        # Create project state file
+        ProjectState.new(name: name, user: user).write
+
+        # Directories
+        FileUtils.mkdir_p(DIRS)
+        DIRS.each { |dir| FileUtils.touch("#{dir}/.keep") }
+
+        # Copy default gitignore and schema files
+        Share.cp("gitignore", ".gitignore")
+        Share.cp("schema/schema", ".")
+
+        # Add .prick-migration file
+        MigrationState.new(version: Version.zero).create
+
+        # Add everything so far
+        Git.add(".")
+        Git.commit("Initial import")
+
+        # Rename branch "master"/"main" to "0.0.0_initial"
+        from_branch = Git.branch?("master") ? "master" : "main"
+        Git.rename_branch(from_branch, "0.0.0_initial")
+
+        # Create schema
+        schema = Schema.new
+        schema.version = Version.zero
+        Git.add schema.version_file
+
+        # Create release
+        Git.commit "Created release v0.0.0"
+        Git.create_tag(Version.zero)
+        Git.checkout_tag(Version.zero)
+      }
     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
+    # Initialize from disk
+    #
+    # TODO Handle migrations
+    def self.load
+      if Git.detached?
+        name = "v#{Git.current_tag}"
       else
-        raise Internal, "Expected String or Version index, got #{name_or_version.class}"
+        name = Git.current_branch
+      end
+      begin
+        branch = Head.load(name)
+      rescue Version::FormatError
+        raise Fail, "Illegal branch name: #{name}"
       end
+      state = ProjectState.new.read
+      Project.new(state.name, state.user, branch)
     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
+    def build(database = self.database, version: nil)
+      database.clean
+      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.head.build(database)
+          }
+        }
       else
-        raise Internal, "Expected String or Version index, got #{name_or_version.class}"
+        head.build(database)
       end
-      @builds_by_name[name] = @builds_by_version[version] = branch
+      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
+    def load(database = self.database, version: nil, file: nil)
+      version.nil? ^ file.nil? or raise Internal, "Need exactly one of :file and :version to be defined"
+      database.clean
+      if version
+        cache.exist?(version) or raise Internal, "Can't find cache file for database #{database}"
+        cache.load(database, version)
       else
-        raise Internal, "Expected String or Version index, got #{name_or_version.class}"
+        database.load(file)
       end
+      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"
-        }
-
-        FileUtils.mkdir_p(DIRS)
-        DIRS.each { |dir| FileUtils.touch("#{dir}/.keep") }
-      }
+    def save(database = nil, file: nil)
+      !database.nil? || file or raise Internal, "Need a database when saving to file"
+      database ||= self.database
+      if file
+        database.save(file)
+      else
+        cache.save(database)
+      end
+      self
     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
+    # Create a schema diff between two database versions. to_version defaults to the
+    # current version. Returns the Diff object
+    def diff(from_version, to_version)
+      begin
+        from_db = Database.new("#{name}-base", user)
+        to_db = Database.new("#{name}-next", user)
+        from_version ||= version
+        build(from_db, version: from_version)
+        build(to_db, version: to_version)
+        Diff.new(from_db, to_db)
+      ensure
+        from_db&.drop
+        to_db&.drop
+      end
+    end
 
-      Git.delete_branch("master")
+    def prepare_release(fork = nil)
+      check_clean(:release_tag)
+      @head = ReleaseBranch.new(fork, version).create
+      submit "Prepared new release based on v#{version}", true
+      self
     end
 
-    # Returns the full path to the project directory (TODO: Test)
-    def path() File.expand_path(".") end
+    def prepare_diff(from_version = version)
+      begin
+        from_name = "#{name}-base"
+        from_db = Database.new(from_name, user)
+        build(from_db, version: from_version)
+
+        to_name = "#{name}-next"
+        to_db = Database.new(to_name, user)
+        build(to_db)
 
-    ### COMMON METHODS
+        if prerelease_branch?
+          head.migrate_features(from_db)
+        end
 
-    def checkout(name)
-      check_clean
-      Git.checkout_branch(name)
+        diff = Diff.new(from_db, to_db)
+        for path, lines, tables in [
+            [BEFORE_TABLES_DIFF_PATH, diff.before_table_changes, false], 
+            [TABLES_DIFF_PATH, diff.table_changes, true], 
+            [AFTER_TABLES_DIFF_PATH, diff.after_table_changes, false]]
+          if lines.empty?
+            if File.exist?(path)
+              if tables
+                Share.cp(File.join("diff", File.basename(path)), path)
+                Git.add(path)
+              else
+                Git.rm(path)
+              end
+            end
+          else
+            Share.cp(File.join("diff", File.basename(path)), path)
+            File.open(path, "a") { |f| f.puts lines }
+            Git.add(path) if !tables
+          end
+        end
+        self
+      ensure
+        from_db&.drop
+        to_db&.drop
+      end
     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 create_release(new_version) 
+      check_clean(:release_branch)
+      head = ReleaseTag.new(new_version, version)
+      check_migration(head.migration)
+      (@head = head).create
+      self
     end
 
-    ### DEVELOPER-LEVEL METHODS
+    def generate_schema
+      build = SchemaBuilder.new(database, SCHEMA_DIR).build(execute: false)
+      puts build.lines
+    end
 
-    # 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 generate_migration
+      build = MigrationBuilder.new(database, MIGRATION_DIR).build(execute: false)
+      puts build.lines
     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}"
+  private
+    def check(kind) self.send(:"#{kind}?") end
+    def check_clean(kind = nil)
+      clean? or raise Internal, "Dirty repository" 
+      kind.nil? || check(kind) or raise Internal, "Not on a #{kind} tag/branh"
     end
 
-    ### RELEASE MANAGER LEVEL METHODS
+    def check_branch() branch? or raise Internal, "Not on a branch" end
+    def check_tag() tag? or raise Internal, "Not on a tag" end
 
-    # 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
-
-    def prepare_migration
-      check_clean
-      prerelease? || feature? or raise Error, "Need to be on a prerelease or feature branch to include features"
-
-      base_database = release.base_release.database
-      build(base_release.version) if !base_database.loaded?
-      build # if !database.loaded?
-
-      diff_sql = release.migration.diff_sql
-      Migra.migrate(base_database.name, database.name, diff_sql)
-    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
+    # FIXME: Use Cache::file
+    def cache_file(version) File.join(CACHE_DIR, "#{database(version)}.sql.gz") end
+
+    def submit(msg, commit = true)
+      Git.commit msg if commit
+      @message = msg
+    end
+
+    def clean(database) # FIXME: Use Database#clean
+      if database.exist?
+        database.recreate if database.loaded?
       else
-        raise Error, "Need to be on a release or pre-prelease branch to create a new release"
+        database.create
       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 check_migration(migration)
+      begin
+        from_version = migration.base_version
+        from_db = Database.new("#{name}-base", user)
+        to_db = Database.new("#{name}-next", user)
+        build(from_db, version: from_version)
+        build(to_db)
+        migration.migrate(from_db)
+        Diff.new(from_db, to_db).same? or raise Error, "Schema/migration mismatch"
+      ensure
+        from_db&.drop
+        to_db&.drop
+      end
     end
+  end
+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
-    end
+__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
-    end
+module Prick
+  class Project
+    # Name of project. Persisted in the project state file
+    attr_reader :name
 
-    # 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])
-    end
+    # 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
 
-    def commit_feature
-      msg = File.readlines(".git/MERGE_MSG").first.chomp
-      Git.commit msg
-#     Command.command "git commit -F .git/MERGE_MSG"
+    # Version of the current branch. If is defined as #branch.version
+    def version() branch.version end
+
+    # Project (default) database
+    def database(version = nil)
+      version ? Database.new("#{name}-#{version.truncate(:pre)}", user) : @database
     end
 
-    def create_migration
+    # 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
 
-    # Build the current database from the content of schema
-    def build(version = nil)
-      if version.nil?
-        database.recreate
-        schema.build 
+    def self.load
+      name = Git.current_branch || Git.current_tag
+      if name =~ MIGRATION_RE
+        branch = MigrationRelease.load(name)
       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}"
+        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
-        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
+      state = ProjectState.new.read
+      Project.new(state.name, state.user, 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 self.initialized?(directory) 
+      File.directory?(directory) && Dir.chdir(directory) { ProjectState.new.exist? } 
     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 self.initialize_directory(name, user, directory)
+      FileUtils.mkdir_p(directory)
+      Dir.chdir(directory) {
+        # Initialize git instance
+        Git.init
+
+        # Create prick version file
+        PrickVersion.new.write(VERSION)
+
+        # Create project state file
+        ProjectState.new(name: name, user: user).write
+
+        # 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") }
+
+        # Copy default gitignore and schema files
+        Share.cp("gitignore", ".gitignore")
+        Share.cp("schemas", ".")
+
+        # Add everything so far
+        Git.add(".")
+        Git.commit("Initial import")
+
+        # Create initial release
+        release = Release.new(Version.zero, nil)
+        release.create
+
+        schema = Schema.new(SCHEMAS_DIR)
+        schema.version = release.version
+        Git.add schema.version_file
+
+        Git.commit "Release 0.0.0"
+        release.tag!
+
+        # Kill master branch
+        Git.delete_branch("master")
+      }
     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)
+    def build(database: self.database, version: nil)
+      clean(database)
       if version
-        release = self[version]
-        release.archive.delete
-        release.database.drop
+        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
-        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)
+        branch.build(database)
       end
+      self
     end
 
-  private
-    def check_clean()
-      !dirty? or raise "Repository is dirty. Commit your changes and try again"
+    def load(file, database: self.database)
+      clean(database)
+      database.load(file)
+      self
     end
 
-    # For debug
-    def dump_deps(deps)
-      deps.each { |k,v|
-        puts "  #{k} -> #{v || 'nil'}"
-      }
+    def save(file, database: self.database)
+      database.save(file)
+      self
     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
+    def cache_file(version) File.join(CACHE_DIR, "#{database(version)}.sql.gz") end
+
+    def make(database, subject)
+      Schema.built? or raise Error, "Schema is not built into project database"
+      Schema.make(database, subject)
+    end
+
+    def backup(path = nil)
+      save path || File.join(SPOOL_DIR, "#{name}-#{Time.now.utc.strftime("%Y%m%d-%H%M%S")}.sql.gz")
+    end
+
+    def restore(path = nil)
+      load path || Dir.glob(File.join(SPOOL_DIR, "#{name}-*.sql.gz")).sort.last
+    end
+
+    def prepare_release(commit: true)
+      release = ReleaseMigration.new(nil, branch.version).create
+      submit "Prepared new release based on #{version}", commit
+      release
+    end
+
+    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 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)
+
+        to_name = "#{name}-next"
+        to_database = Database.new(to_name, user)
+        build(database: to_database)
+
+        # Helpful double-check
+        Diff.same?(to_database.name, database.name) or 
+            raise Error, "Schema and project database are not synchronized"
+
+        if release?
+          dir = branch.migration.migration_dir
         else
-          @orphan_git_branches << branch
+          dir = branch.migration.features_dir
         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
+#       dir = branch.migration.features_dir || branch.migration.migration_dir
+        to_file = File.join(dir, DIFF_FILE)
+
+        if prerelease?
+          branch.migrate_features(from_database)
         end
+
+        Diff.new(from_name, to_name).write(to_file)
+      ensure
+        from_database&.drop
+        to_database&.drop
+      end
+    end
+
+    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 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 cancel_release(version, commit: true)
+      Git.cancel_tag(version)
+    end
+
+    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 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 increment_prerelease(commit: true)
+      prerelease = branch.increment
+      prerelease.create
+      submit "Created pre-release #{prerelease.version}", commit
+      build
+      prerelease
+    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
+
+    def create_feature(name, commit: true)
+      feature = Feature.new(name, version)
+      feature.create
+      submit "Created feature #{name}", commit
+    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
+
+    # 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
+
+    # 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
 
-      releases.sort_by { |k,v| k }.each { |release, base_release|
-        @releases << Release.new(self, self[base_release], release)
+    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)
       }
-      @releases.sort!
+    end
 
-      prereleases.each { |prerelease, base_release|
-        if base_release
-          @prereleases << Prerelease.new(self, self[base_release], prerelease)
-        else
-          @ignored_release_nodes << prerelease
-        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)
       }
-      @prereleases.sort!
+    end
 
-      if !Git.detached?
-        features.each { |feature, base_release|
-#       if File.exist?(base_release_file)
-#         recursive include of dependent releases
+    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
 
-          if base_release
-            (@features[base_release] ||= []) << Feature.new(self, self[base_release], feature.feature)
-          else
-            @ignored_release_nodes << release
-          end
-        }
+  private
+    def submit(msg, commit = true)
+      Git.commit msg if commit
+      @message = msg
+    end
+
+    def clean(database)
+      if database.exist?
+        database.recreate if database.loaded?
+      else
+        database.create
       end
     end
   end