prick 0.2.0 → 0.3.0

data/lib/prick/command.rb

@@ -14,14 +14,13 @@ module Command
     end
   end
 
-  # Execute the shell command 'cmd' and return the output as an array of
-  # strings
-  #
-  # If :stderr is true, it returns return a tuple of [stdout, stderr] instead
-  #
-  # The shell command is executed with the `errexit` and `pipefail` bash
-  # options.  It raises a Command::Error exception if the command fails unless
-  # :fail is true. The exit status of the last command is stored in ::status
+  # Execute the shell command 'cmd' and return standard output as an array of
+  # strings while stderr is passed through unless stderr: is false. If stderr:
+  # is true, it returns a tuple of [stdout, stderr] instead. The shell command
+  # is executed with the `errexit` and `pipefail` bash options
+  # 
+  # It raises a Command::Error exception if the command fails unless :fail is
+  # true. The exit status of the last command is stored in ::status
   #
   def command(cmd, stderr: false, fail: true)
     cmd = "set -o errexit\nset -o pipefail\n#{cmd}"
@@ -62,10 +61,19 @@ module Command
     pr[0].close
     pe[0].close
 
+    result = 
+        case stderr
+          when true; [out, err]
+          when false; out
+          when NilClass; $stderr.puts err
+        else
+          raise Internal, "Unexpected value for :stderr - #{stderr.inspect}"
+        end
+
     if @status == 0 || fail == false
-      stderr ? [out, err] : out
-    else
-      raise Command::Error.new((out + err).join("\n") + "\n", status, out, err)
+      result
+    elsif fail
+      raise Command::Error.new("\n" + cmd + "\n" + (out + err).join("\n") + "\n", status, out, err)
     end
   end
 

data/lib/prick/constants.rb

@@ -1,28 +1,50 @@
 
 module Prick
+  ### DIRECTORIES AND FILE NAMES
+
+  # Path to the .prick-version file
+  PRICK_VERSION_FILE = ".prick-version"
+
+  # State files
+  PROJECT_STATE_FILE = ".prick-project"
+  FEATURES_STATE_FILE = ".prick-features"
+  MIGRATION_STATE_FILE = ".prick-migration"
+  MIGRATIONS_FILE = "migrations.sql"
+
+  # Diff file
+  DIFF_FILE = "diff.sql"
+
   # Shared files (part of the installation)
   SHARE_PATH = "#{File.dirname(File.dirname(__dir__))}/share"
+  LIBEXEC_PATH = "#{File.dirname(File.dirname(__dir__))}/libexec"
+
+  STRIP_COMMENTS_COMMAND = File.join(LIBEXEC_PATH, "strip-comments")
 
   # Project directories
   DIRS = [
-    RELEASE_DIR = "releases",
-    MIGRATION_DIR = "migrations",
-    FEATURE_DIR = "features",
-    SCHEMA_DIR = "schemas",
-    PRICK_DIR = "#{SCHEMA_DIR}/prick",
-    PUBLIC_DIR = "#{SCHEMA_DIR}/public",
+    MIGRATIONS_DIR = "migrations",
+    RELEASES_DIR = "releases",
+    SCHEMAS_DIR = "schemas",
+    PRICK_DIR = "#{SCHEMAS_DIR}/prick",
+    PUBLIC_DIR = "#{SCHEMAS_DIR}/public",
     VAR_DIR = "var",
     CACHE_DIR = "#{VAR_DIR}/cache",
+    SPOOL_DIR = "#{VAR_DIR}/spool",
     TMP_DIR = "tmp",
     CLONE_DIR = "tmp/clone",
     SPEC_DIR = "spec"
   ]
 
+  # Path to prick data file
+# PRICK_DATA_PATH = File.join(SCHEMAS_DIR, "prick", "data.sql")
+  SCHEMA_VERSION_PATH = File.join(SCHEMAS_DIR, "prick", "data.sql")
+
   # Dump files
   DUMP_EXT = "dump.gz"
   DUMP_GLOB = "*-[0-9]*.#{DUMP_EXT}"
   def self.dump_glob(project_name) "#{project_name}-*.#{DUMP_EXT}" end
 
+  ### REGULAR EXPRESSIONS
 
   # Matches an identifier. Identifiers consist of lower case letters, digits
   # and underscores but not dashes because they're used as separators
@@ -56,7 +78,7 @@ module Prick
   USER_NAME_SUB_RE = NAME_SUB_RE
   USER_NAME_RE = NAME_RE
 
-  # Matches a major.minor.patch version
+  # Matches a major.minor.patch ('MMP') version
   #
   # The *_SEMVER REs are derived from the canonical RE 
   #
@@ -119,19 +141,6 @@ module Prick
   /x
   RELEASE_RE = /^#{RELEASE_SUB_RE}$/
 
-  # Migration RE. The syntax is <version>_<version>
-  #
-  # The RE defines the following captures
-  #   $1 - from version
-  #   $2 - from custom name, can be nil
-  #   $3 - from semantic version
-  #   $4 - to version
-  #   $5 - to custom name, can be nil
-  #   $6 - to semantic version
-  #
-  MIGRATION_SUB_RE = /(#{RELEASE_SUB_RE})_(#{RELEASE_SUB_RE})/
-  MIGRATION_RE = /^#{MIGRATION_SUB_RE}$/
-
   # Matches a prerelease branch
   #
   # The RE defines the following captures:
@@ -154,6 +163,19 @@ module Prick
   FEATURE_SUB_RE = /#{ABSTRACT_RELEASE_SUB_RE}_(#{FEATURE_NAME_SUB_RE})/
   FEATURE_RE = /^#{FEATURE_SUB_RE}$/
 
+  # Migration RE. The syntax is <version>_<version>
+  #
+  # The RE defines the following captures
+  #   $1 - from version
+  #   $2 - from custom name, can be nil
+  #   $3 - from semantic version
+  #   $4 - to version
+  #   $5 - to custom name, can be nil
+  #   $6 - to semantic version
+  #
+  MIGRATION_SUB_RE = /(#{RELEASE_SUB_RE})_(#{RELEASE_SUB_RE})/
+  MIGRATION_RE = /^#{MIGRATION_SUB_RE}$/
+
   # Project release RE. The general syntax is '<project>-<custom>-<version>'
   #
   # The RE defines the following captures:

data/lib/prick/database.rb

@@ -1,5 +1,5 @@
 
-require "prick/ensure.rb"
+#require "prick/ensure.rb"
 
 module Prick
   class Database
@@ -42,12 +42,14 @@ module Prick
     def recreate() drop if exist?; create; @version = nil end
     def drop() Rdbms.drop_database(name, fail: false); @version = nil end
 
-    def loaded?() exist? && !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
 
-    include Ensure
+    def to_s() name end
+
+#   include Ensure
 
   private
     @states = {

data/lib/prick/diff.rb

@@ -0,0 +1,47 @@
+module Prick
+  class Diff
+    def initialize(db1, db2)
+      @db1, @db2 = db1, db2
+      @diffed = false
+      @diff = nil
+      @result = nil
+    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
+
+    # Return the diff between the two databases or nil if they're equal
+    def read
+      @diffed ? @diff : do_diff
+    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)
+      else
+        do_diff(file)
+      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
+    end
+  end
+end

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
@@ -94,12 +113,18 @@ 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
@@ -109,7 +134,7 @@ module Prick
 
     # 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)}'"
         }
@@ -127,7 +152,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,7 +160,7 @@ module Prick
       else
         branch ||= "HEAD"
         Command.command "git show #{branch}:#{file}"
-      end.join("\n")
+      end.join("\n") + "\n"
     end
 
     def self.rm(file)

data/lib/prick/migration.rb

@@ -1,230 +1,210 @@
 
-require 'yaml'
-
 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
-    KEEP_FILE = ".keep"
+    # 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 :path
+    # 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
 
-    def files() raise AbstractMethod end
-    def release_files() files 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
 
-    # Return versions of the features in this migration
-    def feature_versions() raise AbstractMethod end
+    # Migration file
+    def migrations_file() File.join(dir, MIGRATIONS_FILE) end
 
-    def initialize(path, template_dir)
-      @path = path
-      @template_dir = template_dir
-    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
 
-    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
+    # 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
 
-    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
+    # List of features in this migration. The features ordered in the same
+    # order as they're included
+    forward_method :features, :@features_state
 
-    def include_feature(feature) raise AbstractMethod end
+    # 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)
+    end
 
-    def migrate() raise AbstractMethod 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}"
+      }
+    end
 
-    def to_s() path end
-    def <=>(other) path <=> other.path 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 self.path(version)
-      if version.feature?
-        File.join(FEATURE_DIR, version.truncate(:feature).to_s, version.feature)
-      else
-        File.join(FEATURE_DIR, version)
-      end
+    def load
+      @migration_state&.read
+      @features_state.read
+      self
     end
 
-    def self.version(path)
-      Version.new(path.delete_prefix("#{FEATURE_DIR}/").sub("/", "_"))
+    def save
+      @migration_state&.write
+      @features_state.write
+      Git.add(@migration_state.path) if @migration_state
+      Git.add(@features_state.path)
+      self
     end
 
-    def self.feature?(path)
-      Version.new(path.delete_prefix("#{FEATURE_DIR}/").sub("/", "_")).feature?
+    # 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 self.files(path) raise AbstractMethod end
-    def self.release_files(path) files(path) 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
+      self
+    end
+
+    def insert_feature(version)
+      features.unshift(version.to_s)
+      @features_state.write
+      Git.add(@features_state.path)
+      generate_features_yml
+      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 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?
-#     }
+    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
 
-  protected
-    def template_file(path) File.join(SHARE_PATH, @template_dir, File.basename(path)) end
-    def keep_file() File.join(path, KEEP_FILE) 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")
+    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
-
-    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)
-    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 version() @migration_state&.version end
+    def version=(v)
+      @migration_state ||= MigrationState.new(ReleaseMigration.migration_dir(v))
+      @migration_state.version = v
+    end
+
+    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
+    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
     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}"
-        }
+    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
 
 
-    def self.files(path)
-      FILES.map { |file| File.join(path, file) }
-    end
+  end
 
-    def read_features_yml(branch = nil) YAML.load(File.read(features_yml)) || [] end
+  class MigrationMigration < Migration
+    attr_reader :name
 
-    def append_features_yml(paths, append: true)
-      write_features_yml(read_features_yml.insert(append ? -1 : 0, *paths))
+    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
     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)
-    end
+    def create() super("release_migration/*") end
   end
 
   class FeatureMigration < Migration
-    FEATURE_TMPL_DIR = "features/feature"
-    FILES = [
-      MIGRATE_SQL = "migrate.sql",
-      DIFF_SQL = "diff.sql"
-    ]
-
     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)
+    def initialize(name, base_version)
       @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)
-    end
-
-    def exist?() release_migration.exist? && super end
-    def create() 
-      release_migration.exist? || release_migration.create
-      super
-    end
-
-    def present?() release_migration.present? && super end
-    def prepare() 
-      release_migration.present? || release_migration.prepare
-      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) }
+      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 self.release_files(path)
-      ReleaseMigration.files(path)
-    end  
-
-    def dump
-      super {
-        puts "name: #{name}"
-        puts "release_migration: #{path}"
-      }
-    end
+    def create() super("feature_migration/*") end
   end
 end
-
-
-
-
-
-