prick 0.19.0 → 0.20.1

data/lib/prick/project.rb

@@ -1,626 +0,0 @@
-require "prick/state.rb"
-
-require "tmpdir"
-
-module Prick
-  class Project
-    attr_reader :name
-    attr_reader :user # Database user
-    attr_reader :head # Current branch/tag
-    attr_reader :schema
-
-    # Return the versioned database or the project database if `version` is nil
-    def database(version = nil)
-      version ? Database.new("#{name}-#{version}", user) : @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
-
-    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
-
-    def self.exist?(directory) 
-      File.directory?(directory) && Dir.chdir(directory) { ProjectState.new.exist? } 
-    end
-
-    def self.create(name, user, directory)
-      user ||= ENV['USER']
-
-      FileUtils.mkdir(directory) if 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
-        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
-
-    # Initialize from disk
-    #
-    # TODO Handle migrations
-    def self.load
-      if Git.detached?
-        name = "v#{Git.current_tag}"
-      else
-        name = Git.current_branch
-      end
-      begin
-        branch = Head.load(name)
-      rescue Version::FormatError
-        branch = Prick::UserBranch.new(name)
-      end
-      state = ProjectState.new.read
-      Project.new(state.name, state.user, branch)
-    end
-
-    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
-        head.build(database)
-      end
-      self
-    end
-
-    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
-        database.load(file)
-      end
-      self
-    end
-
-    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 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
-
-    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
-
-    def prepare_schema(name, commit: true)
-      path = File.join(SCHEMA_DIR, name)
-      FileUtils.mkdir_p(path)
-      Git.add Share.cp("schema/schema.sql", path, clobber: false, templates: { 'SCHEMA' => name })
-      Git.add Share.cp("schema/build.yml", path, clobber: false)
-      File.open(Schema.yml_file, "a") { |f| f.write("- #{name}\n") }
-      Git.add(Schema.yml_file)
-      submit "Added schema #{name}", commit
-    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)
-
-        if prerelease_branch?
-          head.migrate_features(from_db)
-        end
-
-        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
-
-    def create_release(new_version) 
-      check_clean(:release_branch)
-      head = ReleaseTag.new(new_version, version)
-      check_migration(head.migration)
-      (@head = head).create
-      self
-    end
-
-    def generate_schema
-      build = SchemaBuilder.new(database, state_file, SCHEMA_DIR).build(execute: false)
-      puts build.lines
-    end
-
-    def generate_migration
-      build = MigrationBuilder.new(database, state_file, MIGRATION_DIR).build(execute: false)
-      puts build.lines
-    end
-
-  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
-
-    def check_branch() branch? or raise Internal, "Not on a branch" end
-    def check_tag() tag? or raise Internal, "Not on a tag" end
-
-    # 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
-        database.create
-      end
-    end
-
-    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
-
-__END__
-
-module Prick
-  class Project
-    # Name of project. Persisted in the project state file
-    attr_reader :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
-
-    # 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
-
-    # 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
-
-    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
-
-    def self.initialized?(directory) 
-      File.directory?(directory) && Dir.chdir(directory) { ProjectState.new.exist? } 
-    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 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
-        branch.build(database)
-      end
-      self
-    end
-
-    def load(file, database: self.database)
-      clean(database)
-      database.load(file)
-      self
-    end
-
-    def save(file, database: self.database)
-      database.save(file)
-      self
-    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
-          dir = branch.migration.features_dir
-        end
-
-#       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
-
-    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
-
-    # 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
-
-    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
-
-  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
-end
-