prick 0.2.0 → 0.7.0

data/lib/prick/exceptions.rb

@@ -2,12 +2,24 @@
 module Prick
   class Error < RuntimeError; end
   class Fail < Error; end
+
   class NotYet < NotImplementedError
-    def initialize() super("Program error - Not yet implemented") end
+    def initialize() super("Internal error: Not yet implemented") end
+  end
+
+  class NotThis < ScriptError
+    def initialize() super("Internal error: Abstract method called") end
   end
-  class AbstractMethod < ScriptError
-    def initialize() super("Program error - Abstract method called") end
+
+  class Abstract < ScriptError
+    def initialize() super("Internal error: Abstract method called") end
   end
+
+  AbstractMethod = Abstract
+
   class Internal < ScriptError; end
+  class Oops < Internal
+    def initialize() super("Oops, this shouldn't happen") end
+  end
 end
 

data/lib/prick/git.rb

@@ -9,34 +9,41 @@ module Prick
       Command.command "git init"
     end
 
-    # Returns true if the repository has no modified files. Requires the
-    # repository to have at least one commit. Creating the repository using
-    # Project::initialize_directory guarantees that
+    # Returns true if the repository has no modified files or unresolved
+    # conflicts. Requires the repository to have at least one commit. Creating
+    # the repository using Project::initialize_directory guarantees that
     def self.clean?()
       Command.command("git status").find { |l| 
-        l =~ /Changes to be committed:/ || l =~ /^\s*modified:/ 
+        (l =~ /^Changes to be committed:/) || 
+        (l =~ /^Unmerged paths:/) ||
+        (l =~ /^Changes not staged for commit:/)
       }.nil?
     end
 
     # Returns true if the repository is on a detached branch
     def self.detached?
-      line = File.readlines(".git/HEAD").first.chomp
-      line =~ /^ref:/ ? false : true
+      Command.command? "git symbolic-ref -q HEAD", expect: 1
     end
 
     # The current tag. This is only defined if the repository is in "detached
     # head" mode
-    def self.current_tag() raise "Not yet implemented" end
-
+    def self.current_tag() 
+      self.detached? ? Command.command("git describe --tags").first.sub(/^v/, "") : nil
+    end
+    
     # Return true if `version` has an associated tag
     def self.tag?(version)
-      !list_tags.grep(version).empty?
+      !list_tags.grep(version.to_s).empty?
     end
 
-    # List tag versions
     # Create version tag
-    def self.create_tag(version)
-      Command.command "git tag -a 'v#{version}' -m 'Release #{version}'"
+    def self.create_tag(version, message: "Release #{version}", commit_id: nil)
+      Command.command "git tag -a 'v#{version}' -m '#{message}' #{commit_id}"
+    end
+
+    # Create a cancel-version tag
+    def self.cancel_tag(version)
+      create_tag("#{version}_cancelled", message: "Cancel #{version}", commit_id: tag_id(version))
     end
 
     def self.delete_tag(version, remote: false)
@@ -44,18 +51,30 @@ module Prick
       Command.command("git push --delete origin 'v#{version}'", fail: false) if remote
     end
 
+    def self.tag_id(version)
+      Command.command("git rev-parse 'v#{version}^{}'").first
+    end
+
     # Checkout a version tag as a detached head
     def self.checkout_tag(version)
         Command.command "git checkout 'v#{version}'"
     end
 
-    def self.list_tags
-      Command.command("git tag").map { |tag| tag.sub(/^v(#{VERSION_SUB_RE})/, '\1') }
+    def self.list_tags(include_cancelled: false)
+      tags = Command.command("git tag")
+      if !include_cancelled
+        cancelled = tags.select { |tag| tag =~ /_cancelled$/ }
+        for cancel_tag in cancelled
+          tags.delete(cancel_tag)
+          tags.delete(cancel_tag.sub(/_cancelled$/, ""))
+        end
+      end
+      tags.map { |tag| tag = tag[1..-1] }
     end
 
-    # Name of the current branch
+    # Name of the current branch. This is nil if on a tag ("detached HEAD")
     def self.current_branch()
-      Command.command("git rev-parse --abbrev-ref HEAD").first
+      self.detached? ? nil : Command.command("git rev-parse --abbrev-ref HEAD").first
     end
 
     # Check if branch exist
@@ -69,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
@@ -94,28 +118,46 @@ module Prick
 
       Command.command "git merge --no-commit #{name}", fail: false
 
-      # Reinstate included files
-      files.each { |path, content| 
+      # Restore excluded files
+      files.each { |path, content|
         File.open(path, "w") { |file| file.puts(content) }
         # Resolve git unmerged status
         Git.add(path)
       }
+
+      # TODO Detect outstanding merges
+    end
+
+    def self.merge_tag(name, exclude_files: [], fail: false)
+      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
     def self.add(*files)
-      Array(files).each { |file|
+      Array(files).flatten.each { |file|
         Dir.chdir(File.dirname(file)) {
           Command.command "git add '#{File.basename(file)}'"
         }
       }
     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"
@@ -127,7 +169,7 @@ module Prick
       end.map { |l| "#{l}\n" }
     end
 
-    # Return content of file
+    # Return content of file as a String
     def self.read(file, tag: nil, branch: nil)
       !(tag && branch) or raise Internal, "Can't use both tag: and branch: options"
       if tag
@@ -135,18 +177,23 @@ module Prick
       else
         branch ||= "HEAD"
         Command.command "git show #{branch}:#{file}"
-      end.join("\n")
+      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,230 +1,70 @@
 
-require 'yaml'
-
 module Prick
   class Migration
-    KEEP_FILE = ".keep"
-
-    attr_reader :path
-
-    def files() raise AbstractMethod end
-    def release_files() files end
-
-    # Return versions of the features in this migration
-    def feature_versions() raise AbstractMethod end
-
-    def initialize(path, template_dir)
-      @path = path
-      @template_dir = template_dir
-    end
-
-    def exist?() File.exist?(keep_file) end
-    def create() FileUtils.touch_p(keep_file); Git.add(keep_file) end
-    def destroy() Git.rm_rf(path) end
-
-    def present?() exist? && files.all? { |f| File.exist?(f) } end
-    def prepare() files.each { |f| FileUtils.cp(template_file(f), path) }; Git.add(path) end
-
-    def include_feature(feature) raise AbstractMethod end
-
-    def migrate() raise AbstractMethod end
-
-    def to_s() path end
-    def <=>(other) path <=> other.path end
-
-    def self.path(version)
-      if version.feature?
-        File.join(FEATURE_DIR, version.truncate(:feature).to_s, version.feature)
-      else
-        File.join(FEATURE_DIR, version)
-      end
-    end
-
-    def self.version(path)
-      Version.new(path.delete_prefix("#{FEATURE_DIR}/").sub("/", "_"))
-    end
-
-    def self.feature?(path)
-      Version.new(path.delete_prefix("#{FEATURE_DIR}/").sub("/", "_")).feature?
-    end
-
-    def self.files(path) raise AbstractMethod end
-    def self.release_files(path) files(path) end
-
-    def dump(&block)
-#     puts self.class
-#     indent {
-#       puts "path : #{path}"
-#       puts "files: #{files.inspect}"
-#       puts "release_files: #{release_files.inspect}"
-#       puts "feature_versions: #{feature_versions.map(&:to_s).inspect}"
-#       puts "keep_file: #{keep_file}"
-#       yield if block_given?
-#     }
-    end
-
-  protected
-    def template_file(path) File.join(SHARE_PATH, @template_dir, File.basename(path)) end
-    def keep_file() File.join(path, KEEP_FILE) end
-  end
-
-  class ReleaseMigration < Migration
-    FEATURES_TMPL_DIR = "features"
-    FILES = [
-      FEATURES_SQL = "features.sql",
-      FEATURES_YML = "features.yml",
-      MIGRATIONS_SQL = "migrations.sql",
-      DIFF_SQL = "diff.sql"
-    ]
-
-    attr_reader :features_yml
-    attr_reader :features_sql
-    attr_reader :migrations_sql
-    attr_reader :diff_sql
-
-    def files() [features_yml, features_sql, migrations_sql, diff_sql] end
+    attr_reader :version
+    attr_reader :base_version
 
-    def initialize(path)
-      super(path, FEATURES_TMPL_DIR)
-      @features_yml = File.join(path, FEATURES_YML)
-      @features_sql = File.join(path, FEATURES_SQL)
-      @migrations_sql = File.join(path, MIGRATIONS_SQL)
-      @diff_sql = File.join(path, DIFF_SQL)
+    def initialize(version, base_version) 
+      @version = version
+      @base_version = base_version
     end
 
-    def feature_versions() read_features_yml.map { |path| Migration.version(path) } end
-    def feature_paths() read_features_yml end
-
-    # `feature` is a Feature object
-    def include_feature(migration, append: true)
-      migration.is_a?(FeatureMigration) or raise "Expected FeatureMigration object, got #{migration.class}"
-      !feature_paths.include?(migration.path) or raise Error, "Feature #{migration.version} is already included"
-      exclude_files = [Schema.data_file] + 
-          migration.release_files + 
-          migration.feature_paths.map { |path| FeatureMigration.release_files(path) }.flatten
-
-      Git.merge_branch(migration.version, exclude_files: exclude_files)
-      
-      feature_paths = YAML.load(Git.read(migration.features_yml, branch: migration.version))
-      append_features_yml(feature_paths, append: append)
-
-      feature_paths.each { |feature_path|
-        if path != File.dirname(feature_path)
-          FileUtils.ln_s(File.join("../..", feature_path), path)
-          Git.add(File.join(path, File.basename(feature_path)))
-        end
-      }
+    def self.load
+      state = MigrationState.load
+      Migration.new(state.version, state.base_version)
     end
 
-    def migrate(database_name)
-      puts "ReleaseMigration#migrate"
-      if File.exist?(migrations_sql)
-        Dir.chdir(path) {
-          puts "  cd #{path}"
-          puts "  psql -d #{database_name} < #{MIGRATIONS_SQL}"
-          Command.command "psql -d #{database_name} < #{MIGRATIONS_SQL}"
-        }
-      end
+    # Remove content of the migration/ directory
+    def self.clear
+      FileUtils.empty!(MIGRATION_DIR)
     end
 
+    def exist?() MigrationState.exist?  end
 
-    def self.files(path)
-      FILES.map { |file| File.join(path, file) }
+    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 read_features_yml(branch = nil) YAML.load(File.read(features_yml)) || [] end
-
-    def append_features_yml(paths, append: true)
-      write_features_yml(read_features_yml.insert(append ? -1 : 0, *paths))
+    def update(version)
+      state = MigrationState.new.read
+      @version = state.version = version
+      state.write
+      Git.add state.path
+      self
     end
 
-    def write_features_yml(paths)
-      FileUtils.cp(template_file(features_yml), features_yml)
-      File.open(features_yml, "a") { |f| f.write(paths.to_yaml) }
-      FileUtils.cp(template_file(features_sql), features_sql)
-      File.open(features_sql, "a") { |f|
-        paths.map { |path|
-          f.puts "\\cd #{File.basename(path)}"
-          f.puts "\\i migrate.sql" }
-          f.puts "\\cd .."
-          f.puts
-      }
-      Git.add(features_yml)
-      Git.add(features_sql)
+    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 FeatureMigration < Migration
-    FEATURE_TMPL_DIR = "features/feature"
-    FILES = [
-      MIGRATE_SQL = "migrate.sql",
-      DIFF_SQL = "diff.sql"
-    ]
+    attr_reader :feature
 
-    attr_reader :name
-    attr_reader :version
-    attr_reader :release_migration # The enclosing release migration
-
-    attr_reader :migrate_sql
-    attr_reader :diff_sql
-
-    def features_yml() release_migration.features_yml end
-    def features_sql() release_migration.features_sql end
-    def migrations_sql() release_migration.migrations_sql end
-    def release_diff_sql() release_migration.diff_sql end
-
-    def files() [migrate_sql, diff_sql] end
-    def release_files() release_migration.files end
-
-    def feature_versions() release_migration.feature_versions end
-    def feature_paths() release_migration.feature_paths end
-
-    def initialize(path, name: File.basename(path))
-      Migration.feature?(path) or raise "Expected a feature path, got #{path}"
-      super(path, FEATURE_TMPL_DIR)
-      @name = name
-      @version = Migration.version(path)
-      @release_migration = ReleaseMigration.new(File.dirname(path))
-      @migrate_sql = File.join(path, MIGRATE_SQL)
-      @diff_sql = File.join(path, DIFF_SQL)
+    def initialize(feature, base_version)
+      super(base_version, base_version)
+      @feature = feature
     end
 
-    def exist?() release_migration.exist? && super end
-    def create() 
-      release_migration.exist? || release_migration.create
-      super
+    def self.load
+      migration_state = MigrationState.load
+      feature_state = FeatureState.load
+      FeatureMigration.new(feature_state.feature, migration_state.base_version)
     end
 
-    def present?() release_migration.present? && super end
-    def prepare() 
-      release_migration.present? || release_migration.prepare
+    def create()
       super
-      release_migration.append_features_yml([path])
-    end
-
-    def include_feature(migration)
-      release_migration.include_feature(migration, append: false)
-    end
-
-    def self.files(path)
-      release_files + FILES.map { |file| File.join(path, file) }
-    end
-
-    def self.release_files(path)
-      ReleaseMigration.files(path)
-    end  
-
-    def dump
-      super {
-        puts "name: #{name}"
-        puts "release_migration: #{path}"
-      }
+      files = Share.cp "migration", File.join(MIGRATION_DIR, feature)
+      state = FeatureState.write(feature: feature)
+      Git.add files, state.path
+      self
     end
   end
 end
 
 
-
-
-
-