pg_migrate 0.0.1 → 0.1.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    pg_migrate (0.0.1)
+    pg_migrate (0.1.0)
       logging (= 1.7.2)
       pg (= 0.14.0)
       thor (= 0.15.4)

data/lib/pg_migrate/builder.rb

@@ -8,10 +8,8 @@ module PgMigrate
   # takes a unprocessed manifest directory, and adds before/after headers to each file
   class Builder
 
-
     attr_accessor :manifest_reader, :sql_reader
 
-
     def initialize(manifest_reader, sql_reader)
       @log = Logging.logger[self]
       @manifest_reader = manifest_reader
@@ -26,7 +24,7 @@ module PgMigrate
     def build(input_dir, output_dir, options={:force=>true})
       input_dir = File.expand_path(input_dir)
       output_dir = File.expand_path(output_dir)
-                                                      
+
       if input_dir == output_dir
         raise 'input_dir can not be same as output_dir: #{input_dir}'
       end
@@ -36,7 +34,7 @@ module PgMigrate
       output = Pathname.new(output_dir)
       if !output.exist?
         if !options[:force]
-          raise "Output directory '#{output_dir}' does not exist.  Create it or specify create_output_dir=true"
+          raise "Output directory '#{output_dir}' does not exist.  Create it or specify force=true"
         else
           output.mkpath
         end
@@ -64,6 +62,18 @@ module PgMigrate
         end
       end
 
+      # if .pg_migrate file exists, copy it
+      input_pg_config = File.join(input_dir, PG_CONFIG)
+      if FileTest::exist? input_pg_config
+        output_pg_config = File.join(output_dir, PG_CONFIG)
+
+        File.open(output_pg_config, 'w') do |fout|
+          IO.readlines(input_pg_config).each do |input|
+            fout.puts input
+          end
+        end
+      end
+
       # in order array of manifest declarations
       loaded_manifest = @manifest_reader.load_input_manifest(input_dir)
       # hashed on migration name hash of manifest
@@ -71,13 +81,17 @@ module PgMigrate
       loaded_manifest_hash = @manifest_reader.hash_loaded_manifest(loaded_manifest)
       @manifest_reader.validate_migration_paths(input_dir, loaded_manifest)
 
-      build_up(input_dir, output_dir, loaded_manifest_hash)
+      build_up(input_dir, output_dir, loaded_manifest_hash, loaded_manifest)
     end
 
-    def build_up(input_dir, output_dir, loaded_manifest_hash)
+    def build_up(input_dir, output_dir, loaded_manifest_hash, loaded_manifest)
       migrations_input = File.join(input_dir, UP_DIRNAME)
       migrations_output = File.join(output_dir, UP_DIRNAME)
 
+      if(!FileTest::exist? migrations_input)
+        raise "'up' directory must exist at #{migrations_input}"
+      end
+
       # iterate through files in input migrations path, wrapping files with transactions and other required bits
 
       Find.find(migrations_input) do |path|
@@ -95,7 +109,7 @@ module PgMigrate
           # create the filename correct for the output directory, for this file
           migration_out_path = File.join(migrations_output, relative_path)
 
-          process_and_copy_up(migration_in_path, migration_out_path, relative_path, loaded_manifest_hash)
+          process_and_copy_up(migration_in_path, migration_out_path, relative_path, loaded_manifest_hash, loaded_manifest)
         end
       end
 
@@ -107,10 +121,11 @@ module PgMigrate
       run_template("bootstrap.erb", binding, File.join(migration_out_path, BOOTSTRAP_FILENAME))
     end
 
-    def create_wrapped_up_migration(migration_in_filepath, migration_out_filepath, migration_def)
-    builder_version="pg_migrate_ruby-#{PgMigrate::VERSION}"
+    def create_wrapped_up_migration(migration_in_filepath, migration_out_filepath, migration_def, loaded_manifest)
+      builder_version="pg_migrate_ruby-#{PgMigrate::VERSION}"
+      manifest_version=loaded_manifest[-1].ordinal
       migration_content = nil
-      File.open(migration_in_filepath, 'r') {|reader| migration_content = reader.read }
+      File.open(migration_in_filepath, 'r') { |reader| migration_content = reader.read }
       run_template("up.erb", binding, File.join(migration_out_filepath))
     end
 
@@ -129,7 +144,7 @@ module PgMigrate
       end
     end
 
-    def process_and_copy_up(migration_in_path, migration_out_path, relative_path, loaded_manifest_hash)
+    def process_and_copy_up(migration_in_path, migration_out_path, relative_path, loaded_manifest_hash, loaded_manifest)
 
       if FileTest.directory?(migration_in_path)
         # copy over directories
@@ -147,7 +162,7 @@ module PgMigrate
 
           migration_def = loaded_manifest_hash[manifest_name]
 
-          create_wrapped_up_migration(migration_in_path, migration_out_path, migration_def)
+          create_wrapped_up_migration(migration_in_path, migration_out_path, migration_def, loaded_manifest)
         else
           # if not a .sql file, just copy it over
           FileUtils.cp(migration_in_path, migration_out_path)

data/lib/pg_migrate/command_line.rb

@@ -1,31 +1,56 @@
 module PgMigrate
   class CommandLine < Thor
 
+    @@packaged_source = '.'
+
+    def initialize(*args)
+      super
+    end
+
+    def self.packaged_source
+      @@packaged_source
+    end
+
+    def self.packaged_source=(value)
+      @@packaged_source = value
+    end
+
+
     desc "up", "migrates the database forwards, applying migrations found in the source directory"
-    method_option :source, :aliases => "-s", :default => '.', :lazy_default => '.', :banner => 'input directory', :desc => "a pg_migrate built manifest. Should contain your processed manifest and up|down|test folders"
-    method_option :connopts, :aliases => "-o", :type => :hash, :required => true, :banner => "connection options", :desc => "database connection options used by gem 'pg': dbname|host|hostaddr|port|user|password|connection_timeout|options|sslmode|krbsrvname|gsslib|service"
-    method_option :verbose, :aliases => "-v", :type => :boolean, :default => false, :banner => "verbose", :desc=> "set to raise verbosity"
+    method_option :source, :aliases => "-s", :default => nil, :banner => 'input directory', :desc => "a pg_migrate built manifest. Should contain your processed manifest and up|down|test folders"
+    method_option :connopts, :aliases => "-c", :type => :hash, :required => true, :banner => "connection options", :desc => "database connection options used by gem 'pg': dbname|host|hostaddr|port|user|password|connection_timeout|options|sslmode|krbsrvname|gsslib|service"
+    method_option :verbose, :aliases => "-v", :type => :boolean, :banner => "verbose", :desc=> "set to raise verbosity"
 
     def up
-      bootstrap_logger(options[:verbose])
+      source = options[:source]
+
+      if source.nil?
+        source = @@packaged_source
+      end
+
+      method_defaults = {"verbose" => false}
+      local_options = set_defaults_from_file(method_defaults, "up", source)
+      local_options = local_options.merge(options)
+
+      bootstrap_logger(local_options["verbose"])
 
       manifest_reader = ManifestReader.new
       sql_reader = SqlReader.new
 
-      connopts = options[:connopts]
-      if !connopts[:port].nil?
+      connopts = local_options["connopts"]
+      if !connopts["port"].nil?
         connopts[:port] = connopts[:port].to_i
       end
 
       migrator = Migrator.new(manifest_reader, sql_reader, connopts)
 
       begin
-        migrator.migrate(options[:source])
+        migrator.migrate(source)
       rescue Exception => e
-        if !options[:verbose]
+        if !local_options["verbose"]
           # catch common exceptions and make pretty on command-line
           if !e.message.index("ManifestReader: code=unloadable_manifest").nil?
-            puts "Unable to load manifest in source directory '#{options[:source]}' .  Check -s|--source option and run again."
+            puts "Unable to load manifest in source directory '#{source}' .  Check -s|--source option and run again."
             exit 1
           else
             raise e
@@ -41,25 +66,81 @@ module PgMigrate
     desc "down", "not implemented"
 
     def down
+      local_options = options
+      options = set_defaults_from_file(location_options)
       bootstrap_logger(options[:verbose])
 
       raise 'Not implemented'
     end
 
     desc "build", "processes a pg_migrate source directory and places the result in the specified output directory"
-    method_option :source, :aliases => "-s", :default => '.', :lazy_default => '.', :banner => 'input directory', :desc => "the input directory containing a manifest file and up|down|test folders"
-    method_option :out, :aliases => "-o", :required => true, :banner => "output directory", :desc => "where the processed migrations will be placed"
-    method_option :force, :aliases => "-f", :default => false, :type => :boolean, :banner => "overwrite out", :desc => "if specified, the out directory will be created before processing occurs, replacing any existing directory"
-    method_option :verbose, :aliases => "-v", :type => :boolean, :default => false, :banner => "verbose", :desc=> "set to raise verbosity"
+    method_option :source, :aliases => "-s", :default => nil, :banner => 'input directory', :desc => "the input directory containing a manifest file and up|down|test folders"
+    method_option :out, :aliases => "-o", :banner => "output directory", :desc => "where the processed migrations will be placed"
+    method_option :force, :aliases => "-f", :type => :boolean, :banner => "overwrite out", :desc => "if specified, the out directory will be created before processing occurs, replacing any existing directory"
+    method_option :verbose, :aliases => "-v", :type => :boolean, :banner => "verbose", :desc=> "set to raise verbosity"
 
     def build
+      source = options[:source]
 
-      bootstrap_logger(options[:verbose])
+      if source.nil?
+        source = @@packaged_source
+      end
+
+      method_defaults = {"force" => false, "verbose" => false}
+      local_options = set_defaults_from_file(method_defaults, "build", source)
+      local_options = local_options.merge(options)
+
+      bootstrap_logger(local_options["verbose"])
+
+      if !local_options["out"]
+        puts "error: --out not specified"
+        exit 1
+      end
 
       manifest_reader = ManifestReader.new
       sql_reader = SqlReader.new
       builder = Builder.new(manifest_reader, sql_reader)
-      builder.build(options[:source], options[:out], :force => options[:force])
+      builder.build(source, local_options["out"], :force => local_options["force"])
+    end
+
+
+    desc "package", "packages a built pg_migrate project into a custom gem containing schemas and simpler migration interface"
+    method_option :source, :aliases => "-s", :default => nil, :banner => 'input directory', :desc => "the input directory containing a manifest file and up|down|test folders that has been previously built by pg_migrate build"
+    method_option :out, :aliases => "-o", :banner => "output directory", :desc => "where the gem will be placed (as well as the exploded gem's contents)"
+    method_option :name, :aliases => "-n", :banner => "the name of the schema gem", :desc => "the name of the gem"
+    method_option :version, :aliases => "-e", :banner => "the version of the schema gem", :desc => "the version of the gem"
+    method_option :force, :aliases => "-f", :type => :boolean, :banner => "overwrite out", :desc => "if specified, the out directory will be created before processing occurs, replacing any existing directory"
+    method_option :verbose, :aliases => "-v", :type => :boolean, :banner => "verbose", :desc=> "set to raise verbosity"
+
+    def package
+      source = options[:source]
+
+      if source.nil?
+        source = @@packaged_source
+      end
+
+      method_defaults = {"force" => false, "verbose" => false}
+      local_options = set_defaults_from_file(method_defaults, "package", source)
+      local_options = local_options.merge(options)
+
+      if !local_options["out"]
+        puts "error: --out not specified"
+        exit 1
+      end
+      if !local_options["name"]
+        puts "error: --version not specified"
+        exit 1
+      end
+      if !local_options["version"]
+        puts "error: --version not specified"
+        exit 1
+      end
+
+      bootstrap_logger(local_options["verbose"])
+
+      manifest_reader = ManifestReader.new
+      builder = Package.new(manifest_reader)
+      builder.package(source, local_options["out"], local_options["name"], local_options["version"], :force => local_options["force"])
     end
 
     no_tasks do
@@ -73,6 +154,40 @@ module PgMigrate
 
         Logging.logger.root.appenders = Logging.appenders.stdout
       end
+
+
+      def set_defaults_from_file(default_options, context, source)
+        @file_defaults = @file_defaults ||= load_file(context, source)
+        merged = default_options.merge(@file_defaults)
+      end
+
+      def load_file(context, source)
+
+        defaults = nil
+        config = File.join(source, PG_CONFIG)
+        if FileTest::exist? (config)
+          puts "found #{PG_CONFIG}"
+          defaults = Properties.new(config)
+        else
+          defaults = Properties.new
+        end
+
+        map = {}
+        defaults.each_pair do |k, v|
+          map[k.upcase] = v
+
+          # make a context-removed version of a key, if it starts with 'context.'
+          prefix = "#{context}."
+          if k.start_with? prefix
+            map[k[prefix.length..-1]] = v
+          end
+        end
+
+        return map
+
+      end
     end
+
+
   end
 end

data/lib/pg_migrate/manifest_reader.rb

@@ -52,18 +52,17 @@ module PgMigrate
 
       manifest_filepath = File.join(manifest_path, MANIFEST_FILENAME)
 
-      @log.debug "loading manifest from #{manifest_path}"
+      @log.debug "loading manifest from #{manifest_filepath}"
 
+      # there should be a file called 'manifest' at this location
       if !FileTest::exist?(manifest_filepath)
-        raise "ManifestReader: code=unloadable_manifest: manifest not found at #{manifest_path}"
+        raise "ManifestReader: code=unloadable_manifest: manifest not found at #{manifest_filepath}"
       end
 
-      # there should be a file called 'manifest' at this location
       manifest_lines = IO.readlines(manifest_filepath)
 
       ordinal = 0
       manifest_lines.each_with_index do |line, index|
-        # ignore comments
         migration_name = line.strip
 
         @log.debug "processing line:#{index} #{line}"
@@ -76,15 +75,16 @@ module PgMigrate
               version = migration_name[BUILDER_VERSION_HEADER.length..-1]
               @log.debug "manifest has builder_version #{version}"
             else
-              raise "manifest invalid: missing/malformed version.  expecting '# pg_migrate-VERSION' to begin first line '#{line}' of manifest file: '#{manifest_path}'"
+              raise "manifest invalid: missing/malformed version.  expecting '# pg_migrate-VERSION' to begin first line '#{line}' of manifest file: '#{manifest_filepath}'"
             end
           end
         end
 
+        # ignore comments
         if migration_name.empty? or migration_name.start_with?('#')
           # ignored!
         else
-          @log.debug "adding manifest #{migration_name} with ordinal #{ordinal}"
+          @log.debug "adding migration #{migration_name} with ordinal #{ordinal}"
           manifest.push(Migration.new(migration_name, ordinal, build_migration_path(manifest_path, migration_name)))
           ordinal += 1
         end

data/lib/pg_migrate/migration.rb

@@ -1,6 +1,6 @@
 module PgMigrate
   class Migration
-    attr_accessor :name, :ordinal, :md5, :created, :production, :filepath
+    attr_accessor :name, :ordinal, :created, :production, :filepath
 
     def initialize(name, ordinal, filepath)
       @name = name

data/lib/pg_migrate/migrator.rb

@@ -72,7 +72,7 @@ module PgMigrate
 
       statements = @sql_reader.load_migration(filepath)
       if statements.length == 0
-        raise 'no statements found in migration #{migration_path}'
+        raise 'no statements found in migration #{filepath}'
       end
       run_migration(name, statements)
     end
@@ -86,7 +86,7 @@ module PgMigrate
         end
       rescue Exception => e
         # we make a special allowance for one exception; it just means this migration
-        # has already occured, and we should just treat it like a continue
+        # has already occurred, and we should just treat it like a continue
         if e.message.index('pg_migrate: code=migration_exists').nil?
           conn.exec("ROLLBACK")
           raise e

data/lib/pg_migrate/package.rb

@@ -0,0 +1,142 @@
+require 'erb'
+require 'fileutils'
+require 'rubygems'
+require 'rubygems/builder'
+#require 'rubygems/package'
+
+module PgMigrate
+  class Package
+
+    attr_accessor :manifest_reader
+
+    def initialize(manifest_reader)
+      @log = Logging.logger[self]
+      @manifest_reader = manifest_reader
+      @template_dir = File.join(File.dirname(__FILE__), 'package_templates')
+    end
+
+    def package(built_migration_path, output_dir, name, version, options={:force=>true})
+      gemspec = create_gem(built_migration_path, output_dir, name, version, options[:force])
+      build_gem(gemspec, output_dir)
+    end
+
+    def create_gem (built_migration_path, output_dir, name, version, force)
+      # validate that manifest is valid
+      @log.debug "validating output dir is manifest"
+
+      if !FileTest::exist?(built_migration_path)
+        raise "built manifest path does not exist #{built_migration_path}"
+      end
+
+      if built_migration_path == output_dir
+        raise "source and destination can not be the same path"
+      end
+
+      loaded_manifest = @manifest_reader.load_input_manifest(built_migration_path)
+      @manifest_reader.validate_migration_paths(built_migration_path, loaded_manifest)
+
+      @log.debug "preparing to build gem"
+
+      target = File.join(output_dir, name)
+
+      # stolen almost verbatim from bundler: https://github.com/carlhuda/bundler/blob/master/lib/bundler/cli.rb
+      constant_name = name.split('_').map { |p| p[0..0].upcase + p[1..-1] }.join
+      constant_name = constant_name.split('-').map { |q| q[0..0].upcase + q[1..-1] }.join('::') if constant_name =~ /-/
+      constant_array = constant_name.split('::')
+      # end stolen
+
+      author = "pgmigrate"
+      email = "pgmigrate@pgmigrate.io"
+      pg_migrate_version = PgMigrate::VERSION
+      gemfiles = ["Gemfile", "#{name}.gemspec", "lib/#{name}.rb", "lib/#{name}/version.rb", "bin/#{name}"]
+      gemfiles += userfiles(built_migration_path, name)
+      gemspec_path = File.join(output_dir, "#{name}.gemspec")
+
+      @log.debug "building gem"
+
+      output = Pathname.new(output_dir)
+      if !output.exist?
+        if !force
+          raise "Output directory '#{output_dir}' does not exist.  Create it or specify force=true"
+        else
+          output.mkpath
+        end
+      else
+        # verify that it's is a directory
+        if !output.directory?
+          raise "output_dir #{output_dir} is a file; not a directory."
+        else
+          @log.debug("deleting & recreating existing output_dir #{output_dir}")
+          output.rmtree
+          output.mkpath
+        end
+      end
+
+      FileUtils.mkdir_p(output_dir)
+      FileUtils.mkdir_p(File.join(output_dir, "bin"))
+      FileUtils.mkdir_p(File.join(output_dir, "lib", name))
+      run_template("Gemfile.erb", binding, File.join(output_dir, "Gemfile"))
+      run_template("gemspec.erb", binding, gemspec_path)
+      run_template("lib/gem.rb", binding, File.join(output_dir, "lib", "#{name}.rb"))
+      run_template("lib/gem/version.rb", binding, File.join(output_dir, "lib", name, "version.rb"))
+      run_template("bin/migrate.rb", binding, File.join(output_dir, "bin", "#{name}"))
+      copy_schema(built_migration_path, File.join(output_dir, "lib", name, "schemas"))
+
+      return gemspec_path
+    end
+
+    def copy_schema(built_migration_path, output_dir)
+      FileUtils.cp_r(File.join(built_migration_path, '.'), output_dir)
+    end
+    
+    def build_gem(gemspec_path, output_dir)
+      @log.debug "building gem"
+
+      @log.debug "loading gem specification #{gemspec_path}"
+      spec = Gem::Specification.load(gemspec_path)
+
+      if spec.nil?
+        raise 'unable to build gem from specification'
+      end
+      
+      @log.debug "packaging gem"
+      Dir.chdir(output_dir) do
+        Gem::Builder.new(spec).build
+      end
+      #Gem::Package.build spec, false
+    end
+
+    def userfiles(built_migration_path, name)
+
+      gempaths = []
+      Find.find(built_migration_path) do |path|
+        if path == ".."
+          Find.prune
+        else
+          # make relative
+
+          relative = path[built_migration_path.length..-1]
+          gempath = File.join("lib", name, "schemas", relative)
+          gempaths.push(gempath)
+        end
+      end
+
+      return gempaths
+    end
+
+    # given an input template and binding, writes to an output file
+    def run_template(template, opt, output_filepath)
+      bootstrap_template = nil
+      File.open(File.join(@template_dir, template), 'r') do |reader|
+        bootstrap_template   = reader.read
+      end
+
+
+      template = ERB.new(bootstrap_template, 0, "%<>")
+      content = template.result(opt)
+      File.open(output_filepath, 'w') do |writer|
+        writer.syswrite(content)
+      end
+    end
+  end
+end

data/lib/pg_migrate/package_templates/Gemfile.erb

@@ -0,0 +1,4 @@
+# A sample Gemfile
+source "https://rubygems.org"
+
+gemspec

data/lib/pg_migrate/package_templates/bin/migrate.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'pg_migrate'
+require '<%= name %>'
+
+include PgMigrate
+
+CommandLine.packaged_source = File.expand_path('../../lib/<%= name %>/schemas', __FILE__)
+
+CommandLine.start

data/lib/pg_migrate/package_templates/gemspec.erb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/<%= name %>/version', __FILE__)
+lib=File.expand_path('../lib', __FILE__)
+
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["<%= author %>"]
+  gem.email         = ["<%= email %> "]
+  gem.description   = %q{A pg_migrate bundle for <%= name %>}
+  gem.summary       = %q{A pg_migrate bundle built by pg_migrate, containing the schemas of <%= name  %>)}
+  gem.homepage      = "https://github.com/sethcall/pg_migrate"
+
+  gem.files         = <%= gemfiles %>
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "<%= name %>"
+  gem.require_paths = ["lib"]
+  gem.version       = <%= constant_name %>::VERSION
+
+  gem.add_dependency('pg_migrate', '<%= pg_migrate_version %>')
+end

data/lib/pg_migrate/package_templates/lib/gem/version.rb

@@ -0,0 +1,3 @@
+module <%= constant_name %>
+  VERSION = "<%= version %>"
+end

data/lib/pg_migrate/package_templates/lib/gem.rb

@@ -0,0 +1,12 @@
+require '<%= name %>/version'
+require 'pg_migrate'
+
+module <%= constant_name %>
+
+  class Migrator
+    def migrate options={}
+      pgMigrator = PgMigrate::Migrator.new(PgMigrate::ManifestReader.new, PgMigrate::SqlReader.new, options)
+      pgMigrator.migrate(File.expand_path('../<%= name %>/schemas', __FILE__))
+    end
+  end
+end

data/lib/pg_migrate/props.rb

@@ -0,0 +1,19 @@
+# from comment at http://devender.wordpress.com/2006/05/01/reading-and-writing-java-property-files-with-ruby/
+
+module PgMigrate
+  class Properties < Hash
+    def initialize(filename = nil)
+      if (filename) then
+        File.open(filename).select { |line| not line=~/^[ \t]*(#.+)*$/ }.# ignore comments and blank lines
+        each { |line|
+          (k, v) = line.chomp.split('=', 2)
+          self[k.strip] = v.strip
+        }
+      end
+    end
+
+    def to_s
+      self.map { |k, v| " #{k}=#{v}" }.join("\n")
+    end
+  end
+end

data/lib/pg_migrate/sql_reader.rb

@@ -26,12 +26,13 @@ module PgMigrate
           current_statement += " " + line_stripped;
 
           if line_stripped.end_with?(";")
-            if current_statement =~ /^\s*CREATE\s+(OR\s+REPLACE\s+)?FUNCTION/i
+            if current_statement =~ /^\s*CREATE\s+(OR\s+REPLACE\s+)?FUNCTION/i || current_statement =~ /^\s*DO\s+/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.
+              # 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
+              # we also detect anonymous functions (DO) and their ending sequence.
+              if current_statement =~ /(plpgsql|plperl|plpythonu|pltcl|sql)\s*;$/i || current_statement =~ /END\s*\$\$\s+(LANGUAGE\s+(plpgsql|plperl|plpythonu|pltcl|sql))?\s*;$/i
                 statements.push(current_statement[0...-1]) # strip off last ;
                 current_statement = ""
               end

data/lib/pg_migrate/templates/bootstrap.erb

@@ -9,35 +9,48 @@
 
 BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE;
 
-CREATE OR REPLACE FUNCTION bootstrap_pg_migrate() RETURNS void AS $$
+-- bootstrap in the pgmigrate schema namespace, if it doesn't exist
+DO $$DECLARE already_exists boolean;
+BEGIN
+
+    SELECT exists INTO STRICT already_exists (select * from pg_catalog.pg_namespace where nspname = 'pgmigrate');
+
+    IF NOT already_exists THEN
+        create schema pgmigrate;
+    END IF;
+
+END$$;
+
+
+CREATE OR REPLACE FUNCTION pgmigrate.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';
+        SELECT * INTO STRICT found_pg_migrate FROM information_schema.tables WHERE table_name = 'pg_migrate' and table_schema = 'pgmigrate';
 
         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);
+                CREATE TABLE pgmigrate.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 pgmigrate.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';
+        SELECT * INTO STRICT found_pg_migrations FROM information_schema.tables WHERE table_name = 'pg_migrations' and table_schema = 'pgmigrate';
 
         EXCEPTION
             WHEN NO_DATA_FOUND THEN
-                CREATE TABLE pg_migrations(
+                CREATE TABLE pgmigrate.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));
+                    pg_migrate_id BIGINT NOT NULL REFERENCES pgmigrate.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;
@@ -46,23 +59,23 @@ END;
 $$ LANGUAGE plpgsql;
 
 
-SELECT bootstrap_pg_migrate();
+SELECT pgmigrate.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 $$
+CREATE OR REPLACE FUNCTION pgmigrate.verify_against_existing_migrations(migration varchar(255), ordinal integer) RETURNS VOID AS $$
 DECLARE
- found_migration pg_migrations;
+ found_migration pgmigrate.pg_migrations;
 BEGIN
   BEGIN
-   EXECUTE 'SELECT * FROM pg_migrations WHERE name=$1' INTO STRICT found_migration USING migration;
+   EXECUTE 'SELECT * FROM pgmigrate.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);
+        IF coalesce((SELECT MAX(p.ordinal) FROM pgmigrate.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 pgmigrate.pg_migrations as p);
         END IF;
 
         RETURN;
@@ -83,12 +96,12 @@ $$ 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 $$
+CREATE OR REPLACE FUNCTION pgmigrate.bypass_existing_migration(migration varchar(255)) RETURNS VOID AS $$
 DECLARE
- found_migration pg_migrations;
+ found_migration pgmigrate.pg_migrations;
 BEGIN
   BEGIN
-   EXECUTE 'SELECT * FROM pg_migrations WHERE name=$1' INTO STRICT found_migration USING migration ;
+   EXECUTE 'SELECT * FROM pgmigrate.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
@@ -103,8 +116,25 @@ END;
 $$ LANGUAGE plpgsql;
 
 
+-- used to verify that the migration being applied is the same as this set or newer.  While the parameter
+-- today is called 'manifest_version', in reality this is just the highest ordinal from the manifest.
+-- so if we find that the database has a higher ordinal than the manifest that built this migration,
+-- then we can kick this out
+CREATE OR REPLACE FUNCTION pgmigrate.verify_manifest_is_not_old(manifest_version INTEGER) RETURNS VOID AS $$
+DECLARE
+    max_ordinal INTEGER;
+BEGIN
+    EXECUTE 'SELECT max(ordinal) FROM pgmigrate.pg_migrations' INTO max_ordinal;
+
+    IF max_ordinal > manifest_version THEN
+        RAISE EXCEPTION 'pg_migrate: code=old_manifest, max_ordinal_in_db=%, manifest_version=%', max_ordinal, manifest_version;
+    END IF;
+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 $$
+CREATE OR REPLACE FUNCTION pgmigrate.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);
@@ -116,7 +146,7 @@ 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
+        EXECUTE 'SELECT id FROM pgmigrate.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
@@ -128,12 +158,12 @@ BEGIN
     END;
 
     IF found_pg_migrate_id IS NULL THEN
-        INSERT INTO pg_migrate(id, template_version, builder_version, migrator_version, database_version)
+        INSERT INTO pgmigrate.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)
+    EXECUTE 'INSERT INTO pgmigrate.pg_migrations(name, ordinal, created, finalized, pg_migrate_id)
         VALUES ($1, $2, CURRENT_TIMESTAMP, 1, $3)' USING migration, ordinal, found_pg_migrate_id;
 
 END;

data/lib/pg_migrate/templates/up.erb

@@ -4,14 +4,16 @@
 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;
+LOCK TABLE pgmigrate.pg_migrations IN ACCESS EXCLUSIVE MODE;
 
-SELECT verify_against_existing_migrations('<%= migration_def.name %>', <%= migration_def.ordinal %>);
+SELECT pgmigrate.verify_manifest_is_not_old(<%= manifest_version %>);
+
+SELECT pgmigrate.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 %>');
+SELECT pgmigrate.bypass_existing_migration('<%= migration_def.name %>');
 
 -- if the content of the migration is bad, we want psql to stop.
 \set ON_ERROR_STOP 1
@@ -22,7 +24,7 @@ SELECT bypass_existing_migration('<%= migration_def.name %>');
 
 -- beginning pg_migrate footer, migration=<%= migration_def.name %>
 
-SELECT record_migration('<%= migration_def.name %>', <%= migration_def.ordinal %>, '0.0.1', '<%= builder_version %>');
+SELECT pgmigrate.record_migration('<%= migration_def.name %>', <%= migration_def.ordinal %>, '0.1.0', '<%= builder_version %>');
 
 COMMIT;
 -- end pg_migrate migration, migration=<%= migration_def.name %>

data/lib/pg_migrate/version.rb

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

data/lib/pg_migrate.rb

@@ -2,12 +2,14 @@ require 'logging'
 require 'pg'
 require 'thor'
 require "pg_migrate/version"
+require "pg_migrate/props"
 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/package"
 require "pg_migrate/command_line"
 
 # name of the manifest file
@@ -21,7 +23,9 @@ TESTDIRNAME = 'test'
 # name of the bootstrap.sql file
 BOOTSTRAP_FILENAME = "bootstrap.sql"
 # built manifest version header
-BUILDER_VERSION_HEADER="# pg_migrate-"
+BUILDER_VERSION_HEADER ="# pg_migrate-"
+# name of project configuration defaults
+PG_CONFIG ='.pg_migrate'
 
 
 ### SQL CONSTANTS ###

data/pg_migrate.gemspec

@@ -12,7 +12,6 @@ Gem::Specification.new do |gem|
 
   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)/})
@@ -24,5 +23,6 @@ Gem::Specification.new do |gem|
   
   gem.add_dependency('pg', '0.14.0')
   gem.add_dependency('thor', '0.15.4')
+  #gem.add_dependency('rubygems', '1.8.24')
 end
 

data/spec/pg_migrate/builder_spec.rb

@@ -71,6 +71,8 @@ describe Builder do
 
     output_dir = File.join('target', 'output_single_manifest')
 
+    FileUtils.rm_rf(output_dir)
+
     @standard_builder.build(input_dir, output_dir)
 
     @dbutil.create_new_test_database()

data/spec/pg_migrate/command_line_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe CommandLine do
+
+  before(:all) do
+    @dbutil = DbUtility.new
+  end
+
+
+  it "build using config file" do
+
+    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')
+
+    FileUtils.rm_rf(output_dir)
+
+    # make a properties file on the fly, with the out parameter specified
+    props = Properties.new
+    props['build.out'] = output_dir
+    props['build.force'] = "true"
+    #props['up.connopts'] = "dbname:pg_migrate_test host:localhost port:5432 user:postgres password:postgres"
+
+    # and put that properties file in the input dir
+    File.open(File.join(input_dir, PG_CONFIG), 'w') { |f| f.write(props) }
+
+    # invoke pg_migrate build, with the hopes that the output dir is honored
+    result = `bundle exec pg_migrate build -s #{input_dir}`
+
+    puts "pg_migrate build output: #{result}"
+
+    $?.exitstatus.should == 0
+
+    FileTest::exist?(output_dir).should == true
+    FileTest::exist?(File.join(output_dir, MANIFEST_FILENAME)).should == true
+    FileTest::exist?(File.join(output_dir, PG_CONFIG)).should == true
+    FileTest::exist?(File.join(output_dir, UP_DIRNAME)).should == true
+    FileTest::exist?(File.join(output_dir, UP_DIRNAME, BOOTSTRAP_FILENAME)).should == true
+    FileTest::exist?(File.join(output_dir, UP_DIRNAME, "single1.sql")).should == true
+
+
+  end
+
+
+end

data/spec/pg_migrate/migrator_spec.rb

@@ -25,7 +25,7 @@ describe Migrator do
           end
 
           pg_migration_id = nil
-          transaction.exec("SELECT * FROM pg_migrations") do |result|
+          transaction.exec("SELECT * FROM pgmigrate.pg_migrations") do |result|
             result.ntuples.should == 1
             result[0]["name"].should == "single1.sql"
             result[0]["ordinal"].should == "0"
@@ -34,9 +34,9 @@ describe Migrator do
           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|
+          transaction.exec("SELECT * FROM pgmigrate.pg_migrate WHERE id = $1", [pg_migration_id]) do |result|
             result.ntuples.should == 1
-            result[0]["template_version"].should == "0.0.1"
+            result[0]["template_version"].should == "0.1.0"
             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

data/spec/pg_migrate/package_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Package do
+
+  before(:all) do
+    @manifest_reader = ManifestReader.new
+    @sql_reader = SqlReader.new
+    @builder = Builder.new(@manifest_reader, @sql_reader)
+    @packager = Package.new(@manifest_reader)
+    @dbutil = DbUtility.new
+  end
+
+  it "package single migration project" do
+    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
+
+    build_output_dir = File.join('target', 'output_single_manifest')
+    package_output_dir = File.join('target', 'package_single_manifest')
+
+    FileUtils.rm_rf(build_output_dir)
+
+
+    # build first
+    @builder.build(input_dir, build_output_dir)
+
+    # then attempt a package
+    @packager.package(build_output_dir, package_output_dir, "crazy_gem", "0.0.1")
+
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_migrate
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-19 00:00:00.000000000 Z
+date: 2012-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logging
@@ -82,17 +82,26 @@ files:
 - lib/pg_migrate/manifest_reader.rb
 - lib/pg_migrate/migration.rb
 - lib/pg_migrate/migrator.rb
+- lib/pg_migrate/package.rb
+- lib/pg_migrate/package_templates/Gemfile.erb
+- lib/pg_migrate/package_templates/bin/migrate.rb
+- lib/pg_migrate/package_templates/gemspec.erb
+- lib/pg_migrate/package_templates/lib/gem.rb
+- lib/pg_migrate/package_templates/lib/gem/version.rb
+- lib/pg_migrate/props.rb
 - lib/pg_migrate/sql_reader.rb
 - lib/pg_migrate/version.rb
 - pg_migrate.gemspec
 - spec/database.yml
 - spec/pg_migrate/builder_spec.rb
+- spec/pg_migrate/command_line_spec.rb
 - spec/pg_migrate/config_parser_spec.rb
 - spec/pg_migrate/db_utility.rb
 - spec/pg_migrate/input_manifests/single_manifest/manifest
 - spec/pg_migrate/input_manifests/single_manifest/up/single1.sql
 - spec/pg_migrate/manifest_reader_spec.rb
 - spec/pg_migrate/migrator_spec.rb
+- spec/pg_migrate/package_spec.rb
 - spec/pg_migrate/sql_reader_spec.rb
 - spec/spec_helper.rb
 - lib/pg_migrate/templates/bootstrap.erb
@@ -126,11 +135,13 @@ summary: Create migration scripts in raw SQL that work regardless if they are ru
 test_files:
 - spec/database.yml
 - spec/pg_migrate/builder_spec.rb
+- spec/pg_migrate/command_line_spec.rb
 - spec/pg_migrate/config_parser_spec.rb
 - spec/pg_migrate/db_utility.rb
 - spec/pg_migrate/input_manifests/single_manifest/manifest
 - spec/pg_migrate/input_manifests/single_manifest/up/single1.sql
 - spec/pg_migrate/manifest_reader_spec.rb
 - spec/pg_migrate/migrator_spec.rb
+- spec/pg_migrate/package_spec.rb
 - spec/pg_migrate/sql_reader_spec.rb
 - spec/spec_helper.rb