prick 0.4.0 → 0.5.0

data/lib/prick/migration.rb

@@ -1,210 +1,70 @@
 
 module Prick
-  # A Migration consists of a .prick-features file, a .prick-migration file, and a
-  # set of SQL migration files. Features can be include as subdirectories
-  #
   class Migration
-    # Directory of the .prick_migration file. It is nil in CurrentRelease
-    # objects that supports the single-developer workflow
-    def migration_dir() @migration_state && File.dirname(@migration_state.path) end
+    attr_reader :version
+    attr_reader :base_version
 
-    # Directory of the .prick_features file. nil for the initial 0.0.0
-    # migration. Note that the feature and the migration directories can be the
-    # same. The features directory also contains the auto-generated files
-    # diff.sql, features.sql, features.yml, and the user-defined migrations.sql file
-    def features_dir() @features_state && File.dirname(@features_state.path) end
-
-    # Directory of the migration. Alias for #features_dir. It should be used in
-    # derived classes when the features and migration directory are the same
-    def dir() features_dir end
-
-    # Migration file
-    def migrations_file() File.join(dir, MIGRATIONS_FILE) end
-
-    # Version of the result of running this migration. `version` is nil for the
-    # current release and features that are not part of a pre-release. Needs to
-    # be redefined in subclasses where migration_dir is nil
-    forward_method :version, :version=, :@migration_state
-
-    # Base version of the migration. `base_version` is nil for the initial
-    # 0.0.0 migration. Needs to be redefined in subclasses where migration_dir
-    # is nil
-    forward_method :base_version, :base_version=, :@migration_state
-
-    # List of features in this migration. The features ordered in the same
-    # order as they're included
-    forward_method :features, :@features_state
-
-    # Note that migration_dir can be nil
-    def initialize(migration_dir, features_dir)
-      @migration_state = migration_dir && MigrationState.new(migration_dir)
-      @features_state = features_dir && FeaturesState.new(features_dir)
+    def initialize(version, base_version) 
+      @version = version
+      @base_version = base_version
     end
 
-    def dump
-      puts "#{self.class}"
-      indent {
-        puts "migration_dir: #{migration_dir}"
-        puts "features_dir: #{features_dir}"
-        puts "version: #{version}"
-        puts "base_version: #{base_version}"
-      }
+    def self.load
+      state = MigrationState.load
+      Migration.new(state.version, state.base_version)
     end
 
-    # Needs to be redefined in ReleaseMigration. This default implementation
-    # assumes #migration_dir is equal to #features_dir
-    def self.load(directory) self.new(directory, directory).load end
-
-    def load
-      @migration_state&.read
-      @features_state.read
-      self
+    # Remove content of the migration/ directory
+    def self.clear
+      FileUtils.empty!(MIGRATION_DIR)
     end
 
-    def save
-      @migration_state&.write
-      @features_state.write
-      Git.add(@migration_state.path) if @migration_state
-      Git.add(@features_state.path)
-      self
-    end
+    def exist?() MigrationState.exist?  end
 
-    # Return true if this is the initial 0.0.0 migration
-    def initial?() version&.zero? end
-
-    def exist?() 
-      (@migration_state.nil? || @migration_state.exist?) && (initial? || @features_state.exist?) 
-    end
-
-    def create(templates_pattern = nil)
-      if @migration_state && !@migration_state.exist?
-        FileUtils.mkdir_p(migration_dir) if migration_dir
-        @migration_state.create
-        Git.add(@migration_state.path)
-      end
-      if !initial? && !@features_state.exist?
-        FileUtils.mkdir_p(features_dir)
-        @features_state.create
-        Git.add(@features_state.path)
-      end
-      if !initial? && templates_pattern
-        files = Share.cp(templates_pattern, features_dir, clobber: false)
-        Git.add files
-      end
+    def create() 
+      files = Share.cp "migration/*", MIGRATION_DIR
+      state = MigrationState.new.write(version: version, base_version: base_version)
+      Git.add files, state.path
       self
     end
 
-    def insert_feature(version)
-      features.unshift(version.to_s)
-      @features_state.write
-      Git.add(@features_state.path)
-      generate_features_yml
+    def update(version)
+      state = MigrationState.new.read
+      @version = state.version = version
+      state.write
+      Git.add state.path
       self
     end
 
-    def append_feature(version) 
-      features.push(version.to_s)
-      @features_state.write
-      Git.add(@features_state.path)
-      generate_features_yml
-      self
-    end
-
-    def generate_features_yml
-      features_yml_file = File.join(features_dir, "features.yml")
-      Share.cp("release_migration/features.yml", features_yml_file)
-      file = File.open(features_yml_file, "a")
-      features.each { |feature|
-        version = Version.new(feature)
-        if base_version == version.truncate(:pre)
-          file.puts "- #{version.feature}"
-        else
-          file.puts "- ../#{version.truncate(:pre)}/#{version.feature}"
-        end
-      }
-    end
-
-    def migrate(database)
-      MigrationBuilder.new(database, features_dir).build
-      Rdbms.exec_sql(database.name, "delete from prick.versions", user: database.user)
-      Rdbms.exec_file(database.name, File.join(PRICK_DIR, "data.sql"), user: database.user)
-    end
-
-    # This only migrates included features. It is used in pre-releases to migrate included features
-    # before creating a diff, so the diff only contains changes not defined in the features
-    def migrate_features(database)
-      MigrationBuilder.new(database, features_dir).build("features.yml")
+    def migrate(database) 
+      base_version or raise Internal, "Can't migrate from nil to #{version}"
+      version or raise Internal, "Can't migrate from #{base_version} to nil"
+      MigrationBuilder.new(database, MIGRATION_DIR).build
     end
   end
 
-  class ReleaseMigration < Migration
-    def version() @migration_state&.version end
-    def version=(v)
-      @migration_state ||= MigrationState.new(ReleaseMigration.migration_dir(v))
-      @migration_state.version = v
-    end
+  class FeatureMigration < Migration
+    attr_reader :feature
 
-    def base_version() @migration_state&.base_version end # || @migration_state.version end
-    def base_version=(v)
-      @migration_state or raise Internal, "Can't set base version when version is undefined"
-      @migration_state.base_version = v
+    def initialize(feature, base_version)
+      super(base_version, base_version)
+      @feature = feature
     end
 
-    # Note that `version` can be nil
-    def initialize(version, base_version)
-      migration_dir = version && ReleaseMigration.migration_dir(version)
-      features_dir = ReleaseMigration.features_dir(base_version)
-      super(migration_dir, features_dir)
-      if version
-        self.version = version
-        self.base_version = base_version
-      else
-        @base_migration_state = MigrationState.new(features_dir)
-      end
+    def self.load
+      migration_state = MigrationState.load
+      feature_state = FeatureState.load
+      FeatureMigration.new(feature_state.feature, migration_state.base_version)
     end
 
-    def create() super("release_migration/*") end
-
-    def self.load(migration_dir, features_dir = nil)
-      !migration_dir.nil? or raise "Parameter migration_dir can't be nil"
-      migration_state = MigrationState.new(migration_dir).read
-      if features_dir.nil?
-        features_dir = ReleaseMigration.features_dir(migration_state.base_version)
-      end
-      self.new(migration_state.version, migration_state.base_version)
-    end
-      
-    def self.migration_dir(version) version && File.join(RELEASES_DIR, version.to_s) end
-    def self.features_dir(base_version) migration_dir(base_version) end
-
-
-  end
-
-  class MigrationMigration < Migration
-    attr_reader :name
-
-    def initialize(version, base_version)
-      @name = "#{base_version}_#{version}"
-      dir = File.join(MIGRATIONS_DIR, name)
-      super(dir, dir)
-      self.version = version
-      self.base_version = base_version
+    def create()
+      super
+      files = Share.cp "migration", File.join(MIGRATION_DIR, feature)
+      state = FeatureState.write(feature: feature)
+      Git.add files, state.path
+      self
     end
-
-    def create() super("release_migration/*") end
   end
+end
 
-  class FeatureMigration < Migration
-    attr_reader :name
-
-    def initialize(name, base_version)
-      @name = name
-      dir = File.join(RELEASES_DIR, base_version.to_s, name)
-      super(dir, dir)
-      self.version = Version.new(base_version, feature: name)
-      self.base_version = base_version
-    end
 
-    def create() super("feature_migration/*") end
-  end
-end

data/lib/prick/program.rb

@@ -3,6 +3,205 @@ 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 != File.basename(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_cache
+      project.cache.list.each { |l| puts l }
+    end
+
+    def build(database, version, nocache)
+      check_owned(database) if database
+      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)
+      check_owned(database) if database
+      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| puts "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 prepare_release(fork)
+      project.prepare_release(fork)
+    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 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 generate_schema
+      project.generate_schema
+    end
+
+    def generate_migration
+      project.generate_migration
+    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