pg_migrate 0.1.11 → 0.1.12

data/lib/pg_migrate/manifest_reader.rb

@@ -1,103 +1,103 @@
-require 'pathname'
-
-module PgMigrate
-  class ManifestReader
-
-    def initialize
-      @log = Logging.logger[self]
-    end
-
-    # returns array of migration paths
-    def load_input_manifest(manifest_path)
-      manifest, version = load_manifest(manifest_path, false)
-      return manifest
-    end
-
-    # returns [array of migration paths, version]
-    def load_output_manifest(manifest_path)
-      return load_manifest(manifest_path, true)
-    end
-
-
-    # verify that the migration files exist
-    def validate_migration_paths(manifest_path, manifest)
-      # each item in the manifest should be a valid file
-      manifest.each do |item|
-        item_path = build_migration_path(manifest_path, item.name)
-        if !Pathname.new(item_path).exist?
-          raise "manifest reference #{item.name} does not exist at path #{item_path}"
-        end
-      end
-    end
-
-    # construct a migration file path location based on the manifest basedir and the name of the migration
-    def build_migration_path(manifest_path, migration_name)
-      File.join(manifest_path, UP_DIRNAME, "#{migration_name}")
-    end
-
-    def hash_loaded_manifest(loaded_manifest)
-      hash = {}
-      loaded_manifest.each do |manifest|
-        hash[manifest.name] = manifest
-      end
-      return hash
-    end
-
-    # read in the manifest, saving each migration declaration in order as they are found
-    private
-    def load_manifest(manifest_path, is_output)
-
-      manifest = []
-      version = nil
-
-      manifest_filepath = File.join(manifest_path, MANIFEST_FILENAME)
-
-      @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_filepath}"
-      end
-
-      manifest_lines = IO.readlines(manifest_filepath)
-
-      ordinal = 0
-      manifest_lines.each_with_index do |line, index|
-        migration_name = line.strip
-
-        @log.debug "processing line:#{index} #{line}"
-
-        # output files must have a version header as 1st line o file
-        if is_output
-          if index == 0
-            # the first line must be the version comment. if not, error out.
-            if migration_name.index(BUILDER_VERSION_HEADER) == 0 && migration_name.length > BUILDER_VERSION_HEADER.length
-              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_filepath}'"
-            end
-          end
-        end
-
-        # ignore comments
-        if migration_name.empty? or migration_name.start_with?('#')
-          # ignored!
-        else
-          @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
-
-        # the logic above wouldn't get upset with an empty manifest
-        if is_output
-          if version.nil?
-            raise "manifest invalid: empty"
-          end
-        end
-      end
-      return manifest, version
-    end
-
-  end
+require 'pathname'
+
+module PgMigrate
+  class ManifestReader
+
+    def initialize
+      @log = Logging.logger[self]
+    end
+
+    # returns array of migration paths
+    def load_input_manifest(manifest_path)
+      manifest, version = load_manifest(manifest_path, false)
+      return manifest
+    end
+
+    # returns [array of migration paths, version]
+    def load_output_manifest(manifest_path)
+      return load_manifest(manifest_path, true)
+    end
+
+
+    # verify that the migration files exist
+    def validate_migration_paths(manifest_path, manifest)
+      # each item in the manifest should be a valid file
+      manifest.each do |item|
+        item_path = build_migration_path(manifest_path, item.name)
+        if !Pathname.new(item_path).exist?
+          raise "manifest reference #{item.name} does not exist at path #{item_path}"
+        end
+      end
+    end
+
+    # construct a migration file path location based on the manifest basedir and the name of the migration
+    def build_migration_path(manifest_path, migration_name)
+      File.join(manifest_path, UP_DIRNAME, "#{migration_name}")
+    end
+
+    def hash_loaded_manifest(loaded_manifest)
+      hash = {}
+      loaded_manifest.each do |manifest|
+        hash[manifest.name] = manifest
+      end
+      return hash
+    end
+
+    # read in the manifest, saving each migration declaration in order as they are found
+    private
+    def load_manifest(manifest_path, is_output)
+
+      manifest = []
+      version = nil
+
+      manifest_filepath = File.join(manifest_path, MANIFEST_FILENAME)
+
+      @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_filepath}"
+      end
+
+      manifest_lines = IO.readlines(manifest_filepath)
+
+      ordinal = 0
+      manifest_lines.each_with_index do |line, index|
+        migration_name = line.strip
+
+        @log.debug "processing line:#{index} #{line}"
+
+        # output files must have a version header as 1st line o file
+        if is_output
+          if index == 0
+            # the first line must be the version comment. if not, error out.
+            if migration_name.index(BUILDER_VERSION_HEADER) == 0 && migration_name.length > BUILDER_VERSION_HEADER.length
+              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_filepath}'"
+            end
+          end
+        end
+
+        # ignore comments
+        if migration_name.empty? or migration_name.start_with?('#')
+          # ignored!
+        else
+          @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
+
+        # the logic above wouldn't get upset with an empty manifest
+        if is_output
+          if version.nil?
+            raise "manifest invalid: empty"
+          end
+        end
+      end
+      return manifest, version
+    end
+
+  end
 end

data/lib/pg_migrate/migration.rb

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

data/lib/pg_migrate/migrator.rb

@@ -1,94 +1,94 @@
-module PgMigrate
-
-  class Migrator
-
-    attr_accessor :conn, :connection_hash, :manifest_path, :manifest, :manifest_reader, :sql_reader
-
-    # options = gem 'pg' connection_hash options, or connstring => dbname=test port=5432, or pgconn => PG::Connection object
-    def initialize(manifest_reader, sql_reader, options = {})
-      @log = Logging.logger[self]
-      @connection_hash = options
-      @manifest = nil
-      @builder_version = nil
-      @manifest_reader = manifest_reader
-      @sql_reader = sql_reader
-    end
-
-    # 'migrate' attempt to migrate your database based on the contents of your built manifest
-    # The manifest_path argument should point to your manifest
-    # manifest_path = the directory containing your 'manifest' file, 'up' directory, 'down' directory, 'test' directory
-    # this method will throw an exception if anything goes wrong (such as bad SQL in the migrations themselves)
-    def migrate(manifest_path)
-      @manifest_path = manifest_path
-
-      @conn = Util::get_conn(@connection_hash)
-
-      # this is used to record the version of the 'migrator' in the pg_migrate table
-      @conn.exec("SET application_name = 'pg_migrate_ruby-#{PgMigrate::VERSION}'")
-
-      # load the manifest, and version of the builder that made it
-      process_manifest()
-
-      # execute the migrations
-      run_migrations(@manifest)
-    end
-
-
-    # load the manifest's migration declarations, and validate that each migration points to a real file
-    def process_manifest
-      @manifest, @builder_version = @manifest_reader.load_output_manifest(@manifest_path)
-      @manifest_reader.validate_migration_paths(@manifest_path, @manifest)
-    end
-
-    # run all necessary migrations
-    def run_migrations(manifest)
-
-      # run bootstrap before user migrations to prepare database
-      run_bootstrap
-
-      # loop through the manifest, executing migrations in turn
-      manifest.each_with_index do |migration, index|
-        execute_migration(migration.name, migration.filepath)
-      end
-
-    end
-
-    # executes the bootstrap method
-    def run_bootstrap
-      bootstrap = File.join(@manifest_path, UP_DIRNAME, BOOTSTRAP_FILENAME)
-      execute_migration('bootstrap.sql', bootstrap)
-    end
-
-    # execute a single migration by loading it's statements from file, and then executing each
-    def execute_migration(name, filepath)
-      @log.info "executing migration #{filepath}"
-
-      statements = @sql_reader.load_migration(filepath)
-      if statements.length == 0
-        raise 'no statements found in migration #{filepath}'
-      end
-      run_migration(name, statements)
-    end
-
-    # execute all the statements of a single migration
-    def run_migration(name, statements)
-
-      begin
-        statements.each do |statement|
-          conn.exec(statement).clear
-        end
-      rescue Exception => e
-        # we make a special allowance for one exception; it just means this migration
-        # 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
-        else
-          conn.exec("ROLLBACK")
-          @log.info "migration #{name} already run"
-        end
-      end
-    end
-  end
-end
-
+module PgMigrate
+
+  class Migrator
+
+    attr_accessor :conn, :connection_hash, :manifest_path, :manifest, :manifest_reader, :sql_reader
+
+    # options = gem 'pg' connection_hash options, or connstring => dbname=test port=5432, or pgconn => PG::Connection object
+    def initialize(manifest_reader, sql_reader, options = {})
+      @log = Logging.logger[self]
+      @connection_hash = options
+      @manifest = nil
+      @builder_version = nil
+      @manifest_reader = manifest_reader
+      @sql_reader = sql_reader
+    end
+
+    # 'migrate' attempt to migrate your database based on the contents of your built manifest
+    # The manifest_path argument should point to your manifest
+    # manifest_path = the directory containing your 'manifest' file, 'up' directory, 'down' directory, 'test' directory
+    # this method will throw an exception if anything goes wrong (such as bad SQL in the migrations themselves)
+    def migrate(manifest_path)
+      @manifest_path = manifest_path
+
+      @conn = Util::get_conn(@connection_hash)
+
+      # this is used to record the version of the 'migrator' in the pg_migrate table
+      @conn.exec("SET application_name = 'pg_migrate_ruby-#{PgMigrate::VERSION}'")
+
+      # load the manifest, and version of the builder that made it
+      process_manifest()
+
+      # execute the migrations
+      run_migrations(@manifest)
+    end
+
+
+    # load the manifest's migration declarations, and validate that each migration points to a real file
+    def process_manifest
+      @manifest, @builder_version = @manifest_reader.load_output_manifest(@manifest_path)
+      @manifest_reader.validate_migration_paths(@manifest_path, @manifest)
+    end
+
+    # run all necessary migrations
+    def run_migrations(manifest)
+
+      # run bootstrap before user migrations to prepare database
+      run_bootstrap
+
+      # loop through the manifest, executing migrations in turn
+      manifest.each_with_index do |migration, index|
+        execute_migration(migration.name, migration.filepath)
+      end
+
+    end
+
+    # executes the bootstrap method
+    def run_bootstrap
+      bootstrap = File.join(@manifest_path, UP_DIRNAME, BOOTSTRAP_FILENAME)
+      execute_migration('bootstrap.sql', bootstrap)
+    end
+
+    # execute a single migration by loading it's statements from file, and then executing each
+    def execute_migration(name, filepath)
+      @log.info "executing migration #{filepath}"
+
+      statements = @sql_reader.load_migration(filepath)
+      if statements.length == 0
+        raise 'no statements found in migration #{filepath}'
+      end
+      run_migration(name, statements)
+    end
+
+    # execute all the statements of a single migration
+    def run_migration(name, statements)
+
+      begin
+        statements.each do |statement|
+          conn.exec(statement).clear
+        end
+      rescue Exception => e
+        # we make a special allowance for one exception; it just means this migration
+        # 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
+        else
+          conn.exec("ROLLBACK")
+          @log.info "migration #{name} already run"
+        end
+      end
+    end
+  end
+end
+