prick 0.4.0 → 0.5.0

data/lib/prick/database.rb

@@ -7,20 +7,25 @@ module Prick
     attr_reader :user
 
     def initialize(name, user)
+      name != "" or raise "Illegal database name" 
       @name = name
       @user = user
       @version = nil
     end
 
-    def version
-      @version ||= begin
-          version = 
-              if exist? && Rdbms.exist_table?(name, "prick", "versions")
-                Rdbms.select(name, "select version from prick.versions")&.first&.first
-              else
-                nil
-              end
-          version && Version.new(version)
+    def version(cache: true)
+      if cache && @version
+        @version
+      else
+        @version = begin
+            version = 
+                if exist? && Rdbms.exist_table?(name, "prick", "versions")
+                  Rdbms.select(name, "select version from prick.versions")&.first&.first
+                else
+                  nil
+                end
+            version && Version.new(version)
+        end
       end
     end
 
@@ -43,18 +48,21 @@ module Prick
     def drop() Rdbms.drop_database(name, fail: false); @version = nil end
 
     def loaded?() !version.nil? end
-    def load(file) Rdbms.load(name, file, user: user); @version = nil end
 
-    def save(file) Rdbms.save(name, file); @version = nil end
+    def load(file) 
+      !loaded? or raise Internal, "Database #{name} is already loaded"
+      Rdbms.load(name, file, user: user)
+      version # Provoke load of version
+    end
 
-    def to_s() name end
+    def save(file) 
+      loaded? or raise Internal, "Database #{name} is not loaded"
+      Rdbms.save(name, file)
+      @version = nil 
+    end
 
-#   include Ensure
+    def clean() recreate end # TODO: Find solution that doesn't involve dropping the database
 
-  private
-    @states = {
-      exist: [:create, :drop],
-      loaded: [:exist, :load, :recreate]
-    }
+    def to_s() name end
   end
 end

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
+