prick 0.4.0 → 0.9.0

data/lib/prick/diff.rb

@@ -1,47 +1,125 @@
 module Prick
   class Diff
+    # Diff as a list of lines
+    attr_reader :diff
+
+    # Subject of the diff
+    attr_reader :before_table_changes
+    attr_reader :table_changes
+    attr_reader :after_table_changes
+
     def initialize(db1, db2)
       @db1, @db2 = db1, db2
-      @diffed = false
-      @diff = nil
-      @result = nil
+      do_diff
+      split_on_table_changes
     end
 
     def self.same?(db1, db2) Diff.new(db1, db2).same? end
 
     # Return true if the two databases are equal. Named #same? to avoid name
     # collision with the built in #equal?
-    def same?
-      do_diff if @result.nil?
-      @result
-    end
+    def same?() diff.empty? end
 
-    # Return the diff between the two databases or nil if they're equal
-    def read
-      @diffed ? @diff : do_diff
+    # Write the diff between the databases to the given file(s). Return true if
+    # the databases are equal
+    def write_segments(file1, file2 = nil, file3 = nil, mark: true)
+      if file2.nil? && file3.nil?
+        file2 = file3 = file1
+      elsif file2.nil? ^ !file3.nil?
+        raise Internal, "Either none or both of `file2` and `file3` should be nil"
+      end
+      write_segment(file1, :before_table_changes, mark: mark)
+      write_segment(file2, :table_changes, mark: mark)
+      write_segment(file3, :after_table_changes, mark: mark)
     end
 
-    # Write the diff between the databases to the given file. Return true if
-    # the databases are equal
-    def write(file)
-      if @diffed
-        IO.write(file, @diff)
+    def write_segment(file, segment, mark: true)
+      lines = self.send(segment)
+      if lines.empty?
+        FileUtils.rm_f(file) if file != "/dev/stdout"
       else
-        do_diff(file)
+        File.open(file, "w") { |f|
+          f.puts "--" + segment.to_s.gsub("_", " ").upcase if mark
+          f.puts lines
+        }
       end
-      @result
     end
 
   private
     def do_diff(file = nil)
-      file_arg = file ? ">#{file}" : ""
-      command = "migra --unsafe postgres:///#{@db1} postgres:///#{@db2} #{file_arg}"
-      stdout = Command.command command, fail: false
-      [0,2].include? Command.status or 
-          raise Fail, "migra command failed with status #{Command.status}: #{command}"
-      @result = Command.status == 0
-      @diffed = !file
-      @diff = @diffed && !@result ? stdout : nil
+      command = "migra --unsafe --with-privileges postgres:///#{@db1} postgres:///#{@db2}"
+      @diff = Command.command(command, fail: false)
+      [0,2].include?(Command.status) or
+        raise Internal, "migrate command failed with status #{Command.status}: #{command}"
+    end
+
+    # Initialize table change variables
+    def split_on_table_changes
+      @before_table_changes = []
+      @table_changes = []
+      @after_table_changes = []
+
+      before = true
+      tables = false
+      after = false
+
+      in_table = false
+
+      diff.each { |l|
+        if before
+          if l =~ /^alter table/
+            @table_changes << l
+            before = false
+            tables = true
+          elsif l =~ /^create table/
+            @table_changes << l
+            before = false
+            tables = true
+            in_table = true
+          elsif l =~ /^drop table/
+            @table_changes << l
+            before = false
+            tables = true
+          else
+            @before_table_changes << l
+          end
+        elsif tables
+          if in_table
+            if l =~ /^\)/
+              @table_changes << l
+              in_table = false
+            else
+              @table_changes << l
+            end
+          elsif l =~ /^alter table/
+            @table_changes << l
+          elsif l =~ /^create table/
+            @table_changes << l
+            in_table = true
+          elsif l =~ /^drop table/
+            @table_changes << l
+          elsif l =~ /^\s*$/
+            @table_changes << l
+          else
+            @after_table_changes << l
+            tables = false
+            after = true
+          end
+        else
+          @after_table_changes << l
+        end
+      }
     end
   end
 end
+
+
+
+
+
+
+
+
+
+
+

data/lib/prick/git.rb

@@ -88,6 +88,11 @@ module Prick
       Command.command "git branch #{name}"
     end
 
+    # Rename a branch
+    def self.rename_branch(from, to)
+      Command.command "git branch -m #{from} #{to}"
+    end
+
     # Destroy branch
     def self.delete_branch(name)
       Command.command "git branch -D #{name}", fail: false
@@ -127,9 +132,13 @@ module Prick
       merge_branch(name, exclude_files: exclude_files, fail: fail)
     end
 
-    # List branches
-    def self.list_branches
-      Command.command "git branch --format='%(refname:short)'"
+    # List branches. Detached head "branches" are ignored unless :detached_head is true
+    def self.list_branches(detached_head: false)
+      if detached_head
+        Command.command "git branch --format='%(refname:short)'"
+      else
+        Command.command "git for-each-ref --format='%(refname:short)' refs/heads/*"
+      end
     end
 
     # Add a file to the index of the current branch
@@ -141,6 +150,14 @@ module Prick
       }
     end
 
+    def self.changed?(file)
+      Command.command("git status --porcelain").any? { |l| l =~ /^.M #{file}$/ }
+    end
+
+    def self.added?(file)
+      Command.command("git status --porcelain").any? { |l| l =~ /^A. #{file}$/ }
+    end
+
     # Return content of file in the given tag or branch. Defaults to HEAD
     def self.readlines(file, tag: nil, branch: nil)
       !(tag && branch) or raise Internal, "Can't use both tag: and branch: options"
@@ -163,15 +180,20 @@ module Prick
       end.join("\n") + "\n"
     end
 
-    def self.rm(file)
-      Dir.chdir(File.dirname(file)) {
-        Command.command "git rm -f '#{File.basename(file)}'", fail: false
+    def self.rm(*files)
+      Array(files).flatten.each { |file|
+        Dir.chdir(File.dirname(file)) {
+          Command.command "git rm -f '#{File.basename(file)}'", fail: false
+        }
       }
     end
 
-    def self.rm_rf(file)
-      Dir.chdir(File.dirname(file)) {
-        Command.command "git rm -rf '#{File.basename(file)}'", fail: false
+    def self.rm_rf(*files)
+      Array(files).flatten.each { |file|
+        Dir.chdir(File.dirname(file)) {
+          next if file == ".keep"
+          Command.command "git rm -rf '#{File.basename(file)}'", fail: false
+        }
       }
     end
 

data/lib/prick/head.rb

@@ -0,0 +1,183 @@
+
+module Prick
+  class Head
+    def project_name() Prick.project.name end
+
+    # Usually equal to #version.to_s
+    attr_reader :name
+
+    # Version. This should be equal to schema.version
+    attr_reader :version
+
+    def base_version() @migration.base_version end
+
+    attr_reader :schema
+
+    attr_reader :migration
+
+    def clean?() Git::clean? end
+
+    def tag?() false end
+    def release_tag?() false end
+    def migration_tag?() false end
+
+    def branch?() false end
+    def release_branch?() false end
+    def prerelease_branch?() false end
+    def feature_branch?() false end
+    def migration_branch?() false end
+
+    def initialize(name, version, migration)
+      @name = name
+      @version = version
+      @schema = Schema.new
+      @migration = migration
+    end
+
+    # TODO: Handle migrations
+    def self.load(name)
+      version, tag = Version.parse(name)
+      if tag
+        ReleaseTag.load
+      else
+        if version.release?
+          ReleaseBranch.load
+        elsif version.prerelease?
+          PrereleaseBranch.load(version)
+        elsif version.feature?
+          FeatureBranch.load(version)
+        else
+          raise NotHere
+        end
+      end
+    end
+
+    def create() 
+      raise NotThis
+    end
+
+    def build(database)
+      schema.build(database)
+    end
+
+    def self.database_name(version)
+      version.truncate(:pre).to_s
+    end
+  end
+
+  class Tag < Head
+    def tag?() true end
+
+    def initialize(version, base_version, migration = nil)
+      migration ||= Migration.new(version, base_version)
+      super(version.to_s, version, migration)
+    end
+
+    def self.load
+      state = Migration.load
+      self.new(state.version, state.base_version)
+    end
+
+    def create
+      initial_branch_name = "#{version}_initial"
+      clean? or raise Internal, "Repository is not clean"
+      !Git.detached? or raise Internal, "Not on a branch"
+      Git.create_branch(initial_branch_name)
+      Git.checkout_branch(initial_branch_name)
+      migration.update(version)
+      schema.version = version
+      Git.commit "Created release v#{version}"
+      Git.create_tag(version)
+      Git.checkout_tag(version)
+      self
+    end
+  end
+
+  class ReleaseTag < Tag
+    def release_tag?() true end
+  end
+
+  # TODO
+  class PrereleaseTag < Tag
+  end
+
+  class MigrationTag < Tag
+    def migration_tag?() true end
+  end
+
+  class Branch < Head
+    def branch?() true end
+
+    def initialize(name, version, migration)
+      super(name, version, migration)
+    end
+
+    def create() 
+      Git.create_branch(version)
+      Git.checkout_branch(version)
+      migration.create
+      self
+    end
+  end
+
+  class ReleaseBranch < Branch
+    def release_branch?() true end
+
+    def initialize(fork = nil, base_version)
+      if fork
+        version = Version.new(base_version, fork: fork)
+      else
+        version = base_version
+      end
+      super(version.to_s, version, Migration.new(nil, base_version))
+    end
+
+    def self.load
+      state = MigrationState.load
+      ReleaseBranch.new(nil, state.base_version)
+    end
+  end
+
+  class PrereleaseBranch < Branch
+    def prerelease_branch?() true end
+
+    def initialize(version, base_version)
+      target_version = version.truncate(:pre)
+      super(version.to_s, target_version, Migration.new(target_version, base_version))
+    end
+
+    def self.load
+      state = MigrationState.load
+      PrereleaseBranch.new(state.version, state.base_version)
+    end
+  end
+
+  class FeatureBranch < Branch
+    def feature_branch?() true end
+
+    def initialize(feature_name, base_version)
+      name = Version.new(base_version, feature: feature_name).to_s
+      super(name, base_version, FeatureMigration.new(feature_name, base_version))
+    end
+
+    def self.load
+      state = MigrationState.load
+      FeatureBranch.new(state.version.feature)
+    end
+  end
+
+  # TODO: Versioned migrations (or maybe not)
+  class MigrationBranch < Branch
+    def migrationn_branch?() true end
+
+    def initialize(version, base_version)
+      if (version.fork || "") == (base_version.fork || "")
+        name = version.to_s + "-" + base_version.semver.to_s
+      else
+        name = version.to_s + "-" + base_version.to_s
+      end
+      super(name, version, Migration.new(version, base_version))
+    end
+  end
+end
+

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