prick 0.4.0 → 0.9.0

data/lib/prick/program.rb

@@ -3,6 +3,261 @@ require "prick.rb"
 
 module Prick
   # Implements the command line commands
+  class Program
+    # Lazy-constructed because Project can only be initialized when the
+    # directory structure is present
+    def project() @project ||= Project.load end
+
+    attr_accessor :quiet
+    attr_accessor :verbose
+
+    def initialize(quiet: false, verbose: false)
+      @quiet = quiet
+      @verbose = verbose
+    end
+
+    # Check if the git repository is clean. Raise an error if not
+    def check_clean() 
+      Git.clean? or raise Error, "Repository is dirty - please commit your changes first" 
+    end
+
+    # Create project directory structure
+    def init(name, user, directory)
+      !Project.exist?(directory) or raise Error, "Directory #{directory} is already initialized"
+      Project.create(name, user, directory)
+      if name != directory
+        mesg "Initialized project #{name} in #{directory}"
+      else
+        mesg "Initialized project #{name}"
+      end
+    end
+
+    def info
+      if project.tag?
+        puts "At v#{project.version} tag"
+      else
+        puts "On branch #{project.head.name}, #{project.version}"
+      end
+      puts "  Git is " + (Git.clean? ? "clean" : "dirty")
+      bv = project.head.version
+      dv = project.database.version
+      sv = project.head.schema.version
+      puts "  Database version: #{dv}" + (dv != bv ? " (mismatch)" : "")
+      puts "  Schema version  : #{sv}" + (sv != bv ? " (mismatch)" : "")
+    end
+
+    def list_releases(migrations: false, cancelled: false)
+      raise NotYet
+    end
+
+    def list_migrations
+      raise NotYet
+    end
+
+    def list_upgrades(from = nil, to = nil)
+      raise NotYet
+    end
+
+    def list_cache
+      project.cache.list.each { |l| puts l }
+    end
+
+    def build(database, version, nocache)
+      into_mesg = database && "into #{database}"
+      version_mesg = version ? "v#{version}" : "current schema"
+      version &&= Version.new(version)
+      version.nil? || Git.tag?(version) or raise Error, "Can't find tag v#{version}"
+      database = database ? Database.new(database, project.user) : project.database(version)
+      project.build(database, version: version)
+      project.save(database) if version && !nocache
+      mesg "Built", version_mesg, into_mesg
+    end
+
+    def make(database, version, nocache)
+      version &&= Version.new(version)
+      version.nil? || Git.tag?(version) or raise Error, "Can't find tag v#{version}"
+      if !nocache && version && project.cache.exist?(version)
+        load(database, version)
+      else
+        build(database, version, nocache)
+      end
+    end
+
+    def make_clean(all)
+      project.cache.clean.each { |file| mesg "Removed cache file #{File.basename(file)}" }
+      drop(nil, all)
+    end
+
+    def load(database, file_or_version)
+      check_owned(database) if database
+      into_mesg = database && "into #{database}"
+      if version = Version.try(file_or_version)
+        database = database ? Database.new(database, project.user) : project.database(version)
+        project.load(database, version: version)
+        mesg "Loaded v#{version}", into_mesg, "from cache"
+      else file = file_or_version
+        project.load(database, file: file)
+        mesg "Loaded #{File.basename(file)}", into_mesg
+      end
+    end
+
+    def save(version, file)
+      database = project.database(version)
+      database.exist? or raise "Can't find database '#{database}'"
+      subj_mesg = file ? file : "cache"
+      project.save(database, file: file)
+      mesg "Saved #{database} to #{subj_mesg}"
+    end
+
+    def drop(database, all)
+      database.nil? || !all or raise Error, "Can't use --all when database is given"
+      if database
+        check_owned(database)
+        dbs = [database]
+      else
+        dbs = Rdbms.list_databases(Prick.database_re(project.name))
+        dbs << project.name if all && project.database.exist?
+      end
+      dbs += Rdbms.list_databases(Prick.tmp_databases_re(project.name)) # FIXME: Only used in dev
+      dbs.each { |db|
+        Rdbms.drop_database(db)
+        mesg "Dropped database #{db}"
+      }
+    end
+
+    # `select` is a tri-state variable that can be :tables, :no_tables, or :all
+    # (or any other value)
+    def diff(from, to, mark, select)
+      diff = project.diff(from && Version.new(from), to && Version.new(to))
+      if !diff.same?
+        if select != :tables && !diff.before_table_changes.empty?
+          puts "-- BEFORE TABLE CHANGES" if mark
+          puts diff.before_table_changes
+        end
+        if select != :no_tables && !diff.table_changes.empty?
+          puts "-- TABLE CHANGES" if mark
+          puts diff.table_changes
+        end
+        if select != :tables && !diff.after_table_changes.empty?
+          puts "-- AFTER TABLE CHANGES" if mark
+          puts diff.after_table_changes
+        end
+      end
+    end
+
+    def migrate
+      raise NotYet
+    end
+
+    def prepare_release(fork)
+      project.prepare_release(fork)
+    end
+
+    def prepare_feature(name)
+      raise NotYet
+    end
+
+    def prepare_migration(from = nil)
+      raise NotYet
+    end
+
+    def prepare_schema(name)
+      project.prepare_schema(name)
+    end
+
+    def prepare_diff(version = nil)
+      # Helpful check to ensure the user has built the current version
+#     Diff.same?(to_db, database) or 
+#         raise Error, "Schema and project database are not synchronized"
+
+      project.prepare_diff(version || project.version)
+      if FileUtils.compare_file(TABLES_DIFF_PATH, TABLES_DIFF_SHARE_PATH)
+        mesg "Created diff. No table changes found, no manual migration updates needed"
+      else
+        mesg "Created diff. Please inspect #{TABLES_DIFF_PATH} and incorporate the"
+        mesg "changes in #{MIGRATION_DIR}/migrate.sql"
+      end
+    end
+
+    def include(name)
+      raise NotYet
+    end
+
+    def check
+      version ||= 
+          if project.prerelease? || project.migration?
+            project.branch.base_version
+          else
+            project.branch.version
+          end
+      project.check_migration(version)
+    end
+
+    def create_release(version = nil)
+      if project.prerelease_branch?
+        raise NotYet
+      elsif project.release_branch?
+        project.create_release(Version.new(version))
+      else
+        raise Error, "You need to be on a release or pre-release branch to create a new release"
+      end
+      mesg "Created release v#{project.head.version}"
+    end
+
+    def create_prerelease(version = nil)
+      raise NotYet
+    end
+
+    def create_feature(name)
+      raise NotYet
+    end 
+
+    def cancel(version)
+      raise NotYet
+    end
+
+    def generate_schema
+      project.generate_schema
+    end
+
+    def generate_migration
+      project.generate_migration
+    end
+
+    def upgrade
+      raise NotYet
+    end
+
+    # TODO: Create a Backup class and a Project#backup_store object
+    def backup(file = nil) 
+      file = file || File.join(SPOOL_DIR, "#{project.name}-#{Time.now.utc.strftime("%Y%m%d-%H%M%S")}.sql.gz")
+      project.save(file: file) 
+      mesg "Backed-up database to #{file}"
+    end
+
+    def restore(file_arg = nil)
+      file = file_arg || Dir.glob(File.join(SPOOL_DIR, "#{name}-*.sql.gz")).sort.last
+      File.exist?(file) or raise Error, "Can't find #{file_arg || "any backup file"}"
+      project.load(file: file)
+      mesg "Restored database from #{file}"
+    end
+
+  protected
+    def check_owned(database)
+      database =~ ALL_DATABASES_RE or raise Error, "Not a prick database: #{database}"
+      project_name = $1
+      project_name == project.name or raise Error, "Database not owned by this prick project: #{database}"
+    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
+  end
+end
+
+__END__
+
+
+module Prick
   class Program
     def project() @project ||= Project.load end
 

data/lib/prick/project.rb

@@ -2,6 +2,280 @@ 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
+        raise Fail, "Illegal branch name: #{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, SCHEMA_DIR).build(execute: false)
+      puts build.lines
+    end
+
+    def generate_migration
+      build = MigrationBuilder.new(database, 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