pg_migrate 0.0.1

data/lib/pg_migrate/sql_reader.rb

@@ -0,0 +1,51 @@
+module PgMigrate
+
+  class SqlReader
+
+    def initialize
+
+    end
+
+
+    # read in a migration file,
+    # converting lines of text into SQL statements that can be executed with our database connection
+    def load_migration(migration_path)
+      statements = []
+
+      current_statement = ""
+
+      migration_lines = IO.readlines(migration_path)
+      migration_lines.each_with_index do |line, index|
+        line_stripped = line.strip
+
+        if line_stripped.empty? || line_stripped.start_with?('--')
+          # it's a comment; ignore
+        elsif line_stripped.start_with?("\\")
+          # it's a psql command; ignore
+        else
+          current_statement += " " + line_stripped;
+
+          if line_stripped.end_with?(";")
+            if current_statement =~ /^\s*CREATE\s+(OR\s+REPLACE\s+)?FUNCTION/i
+              # if we are in a function, a ';' isn't enough to end.  We need to see if the last word was one of
+              # pltcl, plperl, plpgsql, plpythonu, sql.
+              # you can extend languages in postgresql; detecting these isn't supported yet.
+
+              if current_statement =~ /(plpgsql|plperl|plpythonu|pltcl|sql)\s*;$/i
+                statements.push(current_statement[0...-1]) # strip off last ;
+                current_statement = ""
+              end
+
+            else
+              statements.push(current_statement[0...-1]) # strip off last ;
+              current_statement = ""
+            end
+          end
+        end
+      end
+
+      return statements
+
+    end
+  end
+end

data/lib/pg_migrate/templates/bootstrap.erb

@@ -0,0 +1,145 @@
+-- pg_migrate bootstrap
+-- purpose: responsible for creating or updating pg_migration internal tables
+-- when:    this script should be called before every migration attempt, to be safe.
+--  except:  if you know you have not updated the pg_migrate tool itself,
+--           and you know you have run this file at least once before on the current database,
+--           then you don't have to run this again.
+
+\set ON_ERROR_STOP 1
+
+BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE;
+
+CREATE OR REPLACE FUNCTION bootstrap_pg_migrate() RETURNS void AS $$
+DECLARE
+    found_pg_migrate information_schema.tables;
+    found_pg_migrations information_schema.tables;
+
+BEGIN
+    BEGIN
+        SELECT * INTO STRICT found_pg_migrate FROM information_schema.tables WHERE table_name = 'pg_migrate';
+
+        EXCEPTION
+            WHEN NO_DATA_FOUND THEN
+                CREATE TABLE pg_migrate (id BIGSERIAL PRIMARY KEY, template_version VARCHAR(255), builder_version VARCHAR(255), migrator_version VARCHAR(255), database_version VARCHAR(1024));
+                CREATE INDEX pg_migrate_unique_index ON pg_migrate (template_version, builder_version, migrator_version, database_version);
+
+            WHEN TOO_MANY_ROWS THEN
+                RAISE EXCEPTION 'Multiple pg_migrate tables.  Unique key on information_schema.tables should have prevented this.';
+    END;
+
+    BEGIN
+        SELECT * INTO STRICT found_pg_migrations FROM information_schema.tables WHERE table_name = 'pg_migrations';
+
+        EXCEPTION
+            WHEN NO_DATA_FOUND THEN
+                CREATE TABLE pg_migrations(
+                    name VARCHAR(255) PRIMARY KEY,
+                    ordinal INTEGER NOT NULL,
+                    created TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    finalized SMALLINT DEFAULT 1,
+                    pg_migrate_id BIGINT NOT NULL REFERENCES pg_migrate(id));
+            WHEN TOO_MANY_ROWS THEN
+                RAISE EXCEPTION 'Multiple pg_migrations tables.  Unique key on information_schema.tables should have prevented this.';
+    END;
+
+END;
+$$ LANGUAGE plpgsql;
+
+
+SELECT bootstrap_pg_migrate();
+
+-- verifies that the specified migration name has the expected ordinal.  No exception is thrown if no migration
+-- of this name exists, and no exception is thrown if the migration + ordinal pair is found on a single row.
+-- Only if the migrtion is found with the wrong row is an exception thrown.
+CREATE OR REPLACE FUNCTION verify_against_existing_migrations(migration varchar(255), ordinal integer) RETURNS VOID AS $$
+DECLARE
+ found_migration pg_migrations;
+BEGIN
+  BEGIN
+   EXECUTE 'SELECT * FROM pg_migrations WHERE name=$1' INTO STRICT found_migration USING migration;
+   EXCEPTION
+     WHEN NO_DATA_FOUND THEN
+        -- if no data, then this migration is unrun.  One more check remains...
+        -- if the last run migration's ordinal is 1 less than this one, we are ready to go.
+        IF coalesce((SELECT MAX(p.ordinal) FROM pg_migrations as p), -1) <> ordinal - 1 THEN
+            RAISE EXCEPTION 'pg_migrate: code=missing_migration, migration=%, ordinal=%, last_ordinal=%', migration, ordinal, (SELECT MAX(p.ordinal) FROM pg_migrations as p);
+        END IF;
+
+        RETURN;
+     WHEN TOO_MANY_ROWS THEN
+        -- this is certainly an odd scenario, because how could this happen unless the user dropped unique key on 'name' column?
+        RAISE EXCEPTION 'pg_migrate: code=pg_migrations_uniqueness_error, migration=%', migration;
+  END;
+
+  -- one row has been found; verify ordinal is correct
+  IF found_migration.ordinal <> ordinal THEN
+    RAISE EXCEPTION 'pg_migrate: code=incorrect_ordinal, migration=%, expected_ordinal=%, actual_ordinal', migration, ordinal, found_migration.ordinal;
+  END IF;
+
+END;
+$$ LANGUAGE plpgsql;
+
+
+-- checks if the current script has been executed or not, and throws an exception if so
+-- callers should check for 'pg_migrate: code=migration_exists' to know whether they should quietly ignore exception.
+-- psql can only do this by calling \set ON_ERROR_STOP 1 (which is done by templates already)
+CREATE OR REPLACE FUNCTION bypass_existing_migration(migration varchar(255)) RETURNS VOID AS $$
+DECLARE
+ found_migration pg_migrations;
+BEGIN
+  BEGIN
+   EXECUTE 'SELECT * FROM pg_migrations WHERE name=$1' INTO STRICT found_migration USING migration ;
+   EXCEPTION
+     WHEN NO_DATA_FOUND THEN
+        -- if no data, then success.  just return with no exception thrown
+        RETURN;
+     WHEN TOO_MANY_ROWS THEN
+        -- this path should never happen because this same condition is already checked via 'verify_against_existing_migrations'
+        RAISE EXCEPTION 'pg_migrate: code=pg_migrations_uniqueness_error, migration=%', migration;
+  END;
+
+  RAISE EXCEPTION 'pg_migrate: code=migration_exists, migration=%', migration;
+END;
+$$ LANGUAGE plpgsql;
+
+
+-- used to mark a migration as finished
+CREATE OR REPLACE FUNCTION record_migration(migration varchar(255), ordinal INTEGER, template_version VARCHAR(255), builder_version VARCHAR(255)) RETURNS VOID AS $$
+DECLARE
+    found_pg_migrate_id BIGINT;
+    migrator_version VARCHAR(255);
+BEGIN
+
+    EXECUTE 'SELECT current_setting(''application_name'')' INTO migrator_version;
+
+    BEGIN
+        -- first look for existing pg_migrate row satisfying version columns
+        -- but if not found, create that row
+        -- in either case, found_pg_migrate_id will have the row id
+        EXECUTE 'SELECT id FROM pg_migrate WHERE
+                    template_version=$1 and builder_version=$2 and migrator_version=$3 and database_version=$4'
+                INTO found_pg_migrate_id USING template_version, builder_version, migrator_version, (select version());
+        EXCEPTION
+            WHEN NO_DATA_FOUND THEN
+                found_pg_migrate_id = NULL;
+            WHEN TOO_MANY_ROWS THEN
+                -- this path should never occur because of the multi-column index on pg_migrate
+                RAISE EXCEPTION 'pg_migrate: code=pg_migrate_uniqueness_error, migration=%, ordinal=%, template_version=%, builder_version=%, migrator_version=%, database_version', migration, ordinal, template_version, builder_version, migrator_version, (select version());
+    END;
+
+    IF found_pg_migrate_id IS NULL THEN
+        INSERT INTO pg_migrate(id, template_version, builder_version, migrator_version, database_version)
+            VALUES (default, template_version, builder_version, migrator_version, (select version())) RETURNING id INTO found_pg_migrate_id;
+    END IF;
+
+    -- create a new record in pg_migrations table, ensuring this migration won't be run again
+    EXECUTE 'INSERT INTO pg_migrations(name, ordinal, created, finalized, pg_migrate_id)
+        VALUES ($1, $2, CURRENT_TIMESTAMP, 1, $3)' USING migration, ordinal, found_pg_migrate_id;
+
+END;
+$$ LANGUAGE plpgsql;
+
+COMMIT;
+
+
+

data/lib/pg_migrate/templates/up.erb

@@ -0,0 +1,28 @@
+-- beginning pg_migrate header, migration=<%= migration_def.name %>
+\set ON_ERROR_STOP 1
+
+BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE;
+
+-- we want to ensure no one else is running this migration concurrently
+LOCK TABLE pg_migrations IN ACCESS EXCLUSIVE MODE;
+
+SELECT verify_against_existing_migrations('<%= migration_def.name %>', <%= migration_def.ordinal %>);
+
+-- to allow exception in CHECK_IF_MIGRATED to cause rollback, not failure
+\set ON_ERROR_STOP 0
+
+SELECT bypass_existing_migration('<%= migration_def.name %>');
+
+-- if the content of the migration is bad, we want psql to stop.
+\set ON_ERROR_STOP 1
+
+-- beginning user sql, migration=<%= migration_def.name %>
+
+<%= migration_content %>
+
+-- beginning pg_migrate footer, migration=<%= migration_def.name %>
+
+SELECT record_migration('<%= migration_def.name %>', <%= migration_def.ordinal %>, '0.0.1', '<%= builder_version %>');
+
+COMMIT;
+-- end pg_migrate migration, migration=<%= migration_def.name %>

data/lib/pg_migrate/version.rb

@@ -0,0 +1,3 @@
+module PgMigrate
+  VERSION = "0.0.1"
+end

data/lib/pg_migrate.rb

@@ -0,0 +1,35 @@
+require 'logging'
+require 'pg'
+require 'thor'
+require "pg_migrate/version"
+require "pg_migrate/migration"
+require "pg_migrate/sql_reader"
+require "pg_migrate/manifest_reader"
+require "pg_migrate/migrator"
+require "pg_migrate/config_parser"
+require "pg_migrate/builder"
+require "pg_migrate/command_line"
+
+# name of the manifest file
+MANIFEST_FILENAME = 'manifest'
+# name of the 'forward' migration folder
+UP_DIRNAME = 'up'
+# name of the 'backwards' migration folder
+DOWN_DIRNAME = 'down'
+# name of the 'test' migration folder
+TESTDIRNAME = 'test'
+# name of the bootstrap.sql file
+BOOTSTRAP_FILENAME = "bootstrap.sql"
+# built manifest version header
+BUILDER_VERSION_HEADER="# pg_migrate-"
+
+
+### SQL CONSTANTS ###
+PG_MIGRATE_TABLE = "pg_migrate"
+PG_MIGRATIONS_TABLE = "pg_migrations"
+
+
+
+module PgMigrate
+  # Your code goes here...
+end

data/pg_migrate.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/pg_migrate/version', __FILE__)
+lib=File.expand_path('../lib', __FILE__)
+
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Seth Call"]
+  gem.email         = ["sethcall@gmail.com"]
+  gem.description   = %q{Simple migration tool focused on Postgresql}
+  gem.summary       = %q{Create migration scripts in raw SQL that work regardless if they are run from the pg_migrate command-line, psql, or native code integration.  More documentation exists on the project homepage.)}
+  gem.homepage      = "https://github.com/sethcall/pg_migrate"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.files         += `cd #{lib}/pg_migrate/templates; git ls-files *.erb`.split($\).map {|f| "lib/pg_migrate/templates/#{f}"}
+  puts gem.files
+  gem.files.delete("lib/pg_migrate/templates")
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "pg_migrate"
+  gem.require_paths = ["lib"]
+  gem.version       = PgMigrate::VERSION
+
+  gem.add_dependency('logging', '1.7.2')
+  
+  gem.add_dependency('pg', '0.14.0')
+  gem.add_dependency('thor', '0.15.4')
+end
+

data/spec/database.yml

@@ -0,0 +1,9 @@
+test:
+  adapter: postgresql
+  encoding: unicode
+  database: pg_migrate_test
+  pool: 5
+  username: postgres
+  password: postgres
+  host: localhost
+  port: 5432

data/spec/pg_migrate/builder_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe Builder do
+
+  before(:all) do
+    @manifest_reader = ManifestReader.new
+    @sql_reader = SqlReader.new
+    @standard_builder = Builder.new(@manifest_reader, @sql_reader)
+    @dbutil = DbUtility.new
+  end
+
+  it "create bootstrap.sql" do
+    standard_builder = @standard_builder
+    target = Files.create :path => "target/bootstrap_test", :timestamp => false do
+      standard_builder.create_bootstrap_script(Dir.pwd)
+
+      # the .sql file should exist after
+      FileTest::exists?(BOOTSTRAP_FILENAME).should == true
+
+      content = nil
+
+      # dynamic content should be in the file
+      File.open(BOOTSTRAP_FILENAME, 'r') { |reader| content = reader.read }
+
+      content.start_with?('-- pg_migrate bootstrap').should == true
+    end
+
+  end
+
+  it "creates indempotent migrations" do
+
+    def run_bootstrap(output_dir)
+      run_migration(BOOTSTRAP_FILENAME, output_dir)
+    end
+
+    def run_migration(migration_path, output_dir)
+      @dbutil.connect_test_database() do |conn|
+        statements = @sql_reader.load_migration(File.join(output_dir, UP_DIRNAME, migration_path))
+
+        statements.each do |statement|
+          conn.exec(statement)
+        end
+      end
+    end
+
+    def verify_bootstrap()
+      # come back in, and verify that the bootstrap tables are there
+      @dbutil.connect_test_database() do |conn|
+        conn.exec("SELECT table_name FROM information_schema.tables WHERE table_name = $1", [PG_MIGRATE_TABLE]) do |result|
+          result.ntuples.should == 1
+          result.getvalue(0, 0).should == PG_MIGRATE_TABLE
+        end
+
+        conn.exec("SELECT table_name FROM information_schema.tables WHERE table_name = $1", [PG_MIGRATIONS_TABLE]) do |result|
+          result.ntuples.should == 1
+          result.getvalue(0, 0).should == PG_MIGRATIONS_TABLE
+        end
+
+      end
+    end
+
+    single_manifest=File.expand_path('spec/pg_migrate/input_manifests/single_manifest')
+    single_manifest = File.join(single_manifest, '.')
+
+    input_dir = nil
+    target = Files.create :path => "target", :timestamp => false do
+      input_dir = dir "input_single_manifest", :src => single_manifest do
+
+      end
+    end
+
+    output_dir = File.join('target', 'output_single_manifest')
+
+    @standard_builder.build(input_dir, output_dir)
+
+    @dbutil.create_new_test_database()
+
+    # run bootstrap once, and verify the tables now exist
+    run_bootstrap(output_dir)
+    verify_bootstrap()
+
+    # run bootstrap again, and verify no error (implicitly), and that the tables now exist
+    run_bootstrap(output_dir)
+    verify_bootstrap()
+
+    # now run single1.sql
+    run_migration('single1.sql', output_dir)
+
+    @dbutil.connect_test_database() do |conn|
+      conn.exec("SELECT table_name FROM information_schema.tables WHERE table_name = $1", ["emp"]) do |result|
+        result.ntuples.should == 1
+        result.getvalue(0, 0).should == "emp"
+      end
+    end
+
+    # run it again.  a very certain exception should occur... 'pg_migrate: code=migration_exists'
+    begin
+      run_migration('single1.sql', output_dir)
+      false.should == true
+    rescue Exception => e
+      e.message.index('pg_migrate: code=migration_exists').should_not == nil
+    end
+
+    @dbutil.connect_test_database() do |conn|
+      conn.exec("SELECT table_name FROM information_schema.tables WHERE table_name = $1", ["emp"]) do |result|
+        result.ntuples.should == 1
+        result.getvalue(0, 0).should == "emp"
+      end
+    end
+
+  end
+end

data/spec/pg_migrate/config_parser_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe ConfigParser do
+  it "parse my test database.yml file" do
+    config = ConfigParser.rails("spec/database.yml", "test")
+    config.should == {
+            :dbname => "pg_migrate_test",
+            :user => "postgres",
+            :password => "postgres",
+            :host => "localhost",
+            :port => 5432
+    }
+  end
+  
+  it "run single migration" do
+    config = ConfigParser.rails("spec/database.yml", "test")
+  end
+
+end

data/spec/pg_migrate/db_utility.rb

@@ -0,0 +1,73 @@
+module PgMigrate
+
+  class DbUtility
+
+    DEFAULT_OPTIONS = {
+            :dbtestname => "pg_migrate_test",
+            :dbsuperuser => "postgres",
+            :dbsuperpass => "postgres",
+            :dbhost => "localhost",
+            :dbport => 5432
+    }
+
+    def initialize(options=DEFAULT_OPTIONS)
+
+      options = DEFAULT_OPTIONS.merge(options)
+
+      @dbtestname = options[:dbtestname]
+      @dbsuperuser = options[:dbsuperuser]
+      @dbsuperpass = options[:dbsuperpass]
+      @dbhost = options[:dbhost]
+      @dbport = options[:dbport]
+    end
+
+    def pg_connection_hasher()
+      return {
+              :port => @dbport,
+              :user => @dbsuperuser,
+              :password => @dbsuperpass,
+              :host => @dbhost
+      }
+    end
+
+
+    def create_new_test_database()
+
+      # this will presumably do the right default thing,
+      # to get us into a 'default' database where we can execute 'create database' from
+      conn_properties = pg_connection_hasher
+
+      conn_properties.delete(:dbname)
+
+      conn = PG::Connection.new(conn_properties)
+
+      conn.exec("DROP DATABASE IF EXISTS #{@dbtestname}").clear
+      conn.exec("CREATE DATABASE #{@dbtestname}").clear
+
+      conn.close
+
+    end
+
+    def connect_test_database(&block)
+      conn = nil
+
+      begin
+        conn_properties = pg_connection_hasher
+
+        conn_properties[:dbname] = @dbtestname
+        conn = PG::Connection.open(conn_properties)
+
+        yield conn
+
+      ensure
+        if !conn.nil?
+          conn.close
+        end
+      end
+
+
+    end
+
+  end
+
+end

data/spec/pg_migrate/input_manifests/single_manifest/manifest

@@ -0,0 +1,4 @@
+# name=single
+# this is a comment
+
+single1.sql

data/spec/pg_migrate/input_manifests/single_manifest/up/single1.sql

@@ -0,0 +1,29 @@
+-- this is a SQL comment
+
+select 1;
+
+select 2;
+
+select
+3;
+
+create table emp(id BIGSERIAL PRIMARY KEY, name varchar(255));
+
+-- a sql function
+CREATE FUNCTION clean_emp() RETURNS void AS '
+    DELETE FROM emp;
+' LANGUAGE SQL;
+
+-- a sql function on one line
+CREATE FUNCTION clean_emp2() RETURNS void AS 'DELETE FROM emp;' LANGUAGE SQL;
+
+CREATE FUNCTION populate() RETURNS integer AS $$
+DECLARE
+    -- declarations
+BEGIN
+    PERFORM clean_emp2();
+END;
+$$ LANGUAGE plpgsql;
+
+
+

data/spec/pg_migrate/manifest_reader_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe ManifestReader do
+
+  before(:all) do
+    @manifest_reader = ManifestReader.new
+  end
+
+  it "load single manifest" do
+    manifest = @manifest_reader.load_input_manifest("spec/pg_migrate/input_manifests/single_manifest")
+
+    manifest.length.should == 1
+    manifest[0].name.should == "single1.sql"
+  end
+
+  it "fail on bad manifest reference" do
+    expect { @manifest_reader.validate_migration_paths('absolutely_nowhere_real', ["migration1"]) }.to raise_exception
+  end
+
+end

data/spec/pg_migrate/migrator_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Migrator do
+
+  before(:all) do
+    @manifest_reader = ManifestReader.new
+    @sql_reader = SqlReader.new
+    @standard_builder = Builder.new(@manifest_reader, @sql_reader)
+    @standard_migrator = Migrator.new(@manifest_reader, @sql_reader)
+    @dbutil = DbUtility.new
+  end
+
+  it "migrate single_manifest" do
+
+    def migrate_it(output_dir)
+      @dbutil.connect_test_database do |conn|
+
+        standard_migrator = Migrator.new(@manifest_reader, @sql_reader, :pgconn=>conn)
+        standard_migrator.migrate(output_dir)
+
+        conn.transaction do |transaction|
+          transaction.exec("SELECT table_name FROM information_schema.tables WHERE table_name = $1", ["emp"]) do |result|
+            result.ntuples.should == 1
+            result.getvalue(0, 0).should == "emp"
+          end
+
+          pg_migration_id = nil
+          transaction.exec("SELECT * FROM pg_migrations") do |result|
+            result.ntuples.should == 1
+            result[0]["name"].should == "single1.sql"
+            result[0]["ordinal"].should == "0"
+            pg_migration_id = result[0]["pg_migrate_id"]
+          end
+          pg_migration_id.should_not == nil
+
+          # verify that a database row in pg_migrate was created as side-effect
+          transaction.exec("SELECT * FROM pg_migrate WHERE id = $1", [pg_migration_id]) do |result|
+            result.ntuples.should == 1
+            result[0]["template_version"].should == "0.0.1"
+            result[0]["builder_version"].should == "pg_migrate_ruby-#{PgMigrate::VERSION}"
+            result[0]["migrator_version"].should == "pg_migrate_ruby-#{PgMigrate::VERSION}"
+            result[0]["database_version"].should_not be nil
+          end
+        end
+      end
+    end
+
+    single_manifest=File.expand_path('spec/pg_migrate/input_manifests/single_manifest')
+    single_manifest = File.join(single_manifest, '.')
+
+    input_dir = nil
+    target = Files.create :path => "target", :timestamp => false do
+      input_dir = dir "input_single_manifest", :src => single_manifest do
+
+      end
+    end
+
+    output_dir = File.join('target', 'output_single_manifest')
+
+    @standard_builder.build(input_dir, output_dir, :force => true)
+
+    @dbutil.create_new_test_database
+
+    migrate_it(output_dir)
+    migrate_it(output_dir)
+  end
+end
+

data/spec/pg_migrate/sql_reader_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe SqlReader do
+
+  before(:all) do
+    @sql_reader = SqlReader.new
+  end
+
+  it "load single migration" do
+    migrations = @sql_reader.load_migration("spec/pg_migrate/input_manifests/single_manifest/up/single1.sql")
+
+    migrations.length.should == 7
+    migrations[0] = "select 1"
+    migrations[1] = "select 2"
+    migrations[2] = "select 3"
+    migrations[3] = "create table emp()"
+    migrations[4] = "CREATE FUNCTION clean_emp() RETURNS void AS ' DELETE FROM emp; ' LANGUAGE SQL"
+    migrations[5] = "CREATE FUNCTION clean_emp2() RETURNS void AS 'DELETE FROM emp;' LANGUAGE SQL"
+    migrations[6] = "CREATE FUNCTION populate() RETURNS integer AS $$ DECLARE BEGIN PERFORM select 1; END; $$ LANGUAGE plpgsql"
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'logging'
+
+# bootstrap logger
+Logging.logger.root.level = :debug
+Logging.logger.root.appenders = Logging.appenders.stdout
+
+require 'pg_migrate'
+require 'pg_migrate/db_utility'
+require 'files'
+require 'fileutils'
+
+target = File.join(File.dirname(__FILE__), '..', 'target')
+FileUtils::rm_r(target, :force => true)
+
+include PgMigrate