ardb 0.27.3 → 0.29.0

data/lib/ardb/adapter/base.rb

@@ -1,18 +1,26 @@
-module Ardb; end
-class Ardb::Adapter
+require "ardb"
 
+module Ardb; end
+module Ardb::Adapter
   class Base
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+      validate!
+    end
+
+    def connect_hash;    self.config.activerecord_connect_hash; end
+    def database;        self.config.database;                  end
+    def migrations_path; self.config.migrations_path;           end
+    def schema_format;   self.config.schema_format;             end
 
-    attr_reader :config_settings, :database
-    attr_reader :schema_format, :ruby_schema_path, :sql_schema_path
+    def ruby_schema_path
+      @ruby_schema_path ||= "#{self.config.schema_path}.rb"
+    end
 
-    def initialize
-      @config_settings = Ardb.config.db_settings
-      @database = Ardb.config.db.database
-      @schema_format = Ardb.config.schema_format
-      schema_path = Ardb.config.schema_path
-      @ruby_schema_path = "#{schema_path}.rb"
-      @sql_schema_path  = "#{schema_path}.sql"
+    def sql_schema_path
+      @sql_schema_path ||= "#{self.config.schema_path}.sql"
     end
 
     def escape_like_pattern(pattern, escape_char = nil)
@@ -21,50 +29,51 @@ class Ardb::Adapter
       pattern.gsub!(escape_char){ escape_char * 2 }
       # don't allow custom wildcards
       pattern.gsub!(/%|_/){ |wildcard_char| "#{escape_char}#{wildcard_char}" }
+      pattern
     end
 
-    def foreign_key_add_sql(*args);  raise NotImplementedError; end
-    def foreign_key_drop_sql(*args); raise NotImplementedError; end
-
     def create_db(*args); raise NotImplementedError; end
     def drop_db(*args);   raise NotImplementedError; end
 
+    def drop_tables(*args); raise NotImplementedError; end
+
     def connect_db
-      ActiveRecord::Base.connection
+      ActiveRecord::Base.establish_connection(self.connect_hash)
+      # checkout a connection to ensure we can connect to the DB, we don"t do
+      # anything with the connection and immediately check it back in
+      ActiveRecord::Base.connection_pool.with_connection{ }
     end
 
     def migrate_db
-      verbose = ENV["MIGRATE_QUIET"].nil?
-      version = ENV["MIGRATE_VERSION"] ? ENV["MIGRATE_VERSION"].to_i : nil
-      migrations_path = Ardb.config.migrations_path
-
-      if defined?(ActiveRecord::Migration::CommandRecorder)
-        require 'ardb/migration_helpers'
-        ActiveRecord::Migration::CommandRecorder.class_eval do
-          include Ardb::MigrationHelpers::RecorderMixin
-        end
-      end
+      migrate_db_up
+    end
 
-      ActiveRecord::Migrator.migrations_path = migrations_path
-      ActiveRecord::Migration.verbose = verbose
-      ActiveRecord::Migrator.migrate(migrations_path, version) do |migration|
-        ENV["MIGRATE_SCOPE"].blank? || (ENV["MIGRATE_SCOPE"] == migration.scope)
-      end
+    def migrate_db_up(target_version = nil)
+      migration_context.up(target_version)
     end
 
-    def drop_tables(*args); raise NotImplementedError; end
+    def migrate_db_down(target_version = nil)
+      migration_context.down(target_version)
+    end
+
+    def migrate_db_forward(steps = 1)
+      migration_context.forward(steps)
+    end
+
+    def migrate_db_backward(steps = 1)
+      migration_context.rollback(steps)
+    end
 
     def load_schema
-      # silence STDOUT
-      current_stdout = $stdout.dup
-      $stdout = File.new('/dev/null', 'w')
-      load_ruby_schema if @schema_format == :ruby
-      load_sql_schema  if @schema_format == :sql
+      current_stdout = $stdout.dup # silence STDOUT
+      $stdout = File.new("/dev/null", "w")
+      load_ruby_schema if self.schema_format == Ardb::Config::RUBY_SCHEMA_FORMAT
+      load_sql_schema  if self.schema_format == Ardb::Config::SQL_SCHEMA_FORMAT
       $stdout = current_stdout
     end
 
     def load_ruby_schema
-      load @ruby_schema_path
+      load self.ruby_schema_path
     end
 
     def load_sql_schema
@@ -72,18 +81,17 @@ class Ardb::Adapter
     end
 
     def dump_schema
-      # silence STDOUT
-      current_stdout = $stdout.dup
-      $stdout = File.new('/dev/null', 'w')
+      current_stdout = $stdout.dup # silence STDOUT
+      $stdout = File.new("/dev/null", "w")
       dump_ruby_schema
-      dump_sql_schema if @schema_format == :sql
+      dump_sql_schema if self.schema_format == Ardb::Config::SQL_SCHEMA_FORMAT
       $stdout = current_stdout
     end
 
     def dump_ruby_schema
-      require 'active_record/schema_dumper'
-      FileUtils.mkdir_p File.dirname(@ruby_schema_path)
-      File.open(@ruby_schema_path, 'w:utf-8') do |file|
+      require "active_record/schema_dumper"
+      FileUtils.mkdir_p File.dirname(self.ruby_schema_path)
+      File.open(self.ruby_schema_path, "w:utf-8") do |file|
         ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
       end
     end
@@ -92,10 +100,22 @@ class Ardb::Adapter
       raise NotImplementedError
     end
 
-    def ==(other_adapter)
-      self.class == other_adapter.class
+    def ==(other)
+      if other.kind_of?(self.class)
+        self.config == other.config
+      else
+        super
+      end
     end
 
-  end
+    private
+
+    def validate!
+      # override as needed
+    end
 
+    def migration_context
+      ActiveRecord::MigrationContext.new(migrations_path)
+    end
+  end
 end

data/lib/ardb/adapter/mysql.rb

@@ -1,22 +1,6 @@
-require 'ardb'
-require 'ardb/adapter/base'
-
-class Ardb::Adapter
-
-  class Mysql < Base
-
-    def foreign_key_add_sql
-      "ALTER TABLE :from_table"\
-      " ADD CONSTRAINT :name"\
-      " FOREIGN KEY (:from_column)"\
-      " REFERENCES :to_table (:to_column)"
-    end
-
-    def foreign_key_drop_sql
-      "ALTER TABLE :from_table"\
-      " DROP FOREIGN KEY :name"
-    end
+require "ardb/adapter/base"
 
+module Ardb::Adapter
+  class Mysql < Ardb::Adapter::Base
   end
-
 end

data/lib/ardb/adapter/postgresql.rb

@@ -1,26 +1,26 @@
-require 'ardb'
-require 'ardb/adapter/base'
+require "ardb/adapter/base"
 
-class Ardb::Adapter
-
-  class Postgresql < Base
-
-    def public_schema_settings
-      self.config_settings.merge({
-        'database'           => 'postgres',
-        'schema_search_path' => 'public'
+module Ardb::Adapter
+  class Postgresql < Ardb::Adapter::Base
+    # the "postgres" db is a "public" (doesn"t typically require auth/grants to
+    # connect to) db that typically exists for all postgres installations; the
+    # adapter uses it to create/drop other databases
+    def public_connect_hash
+      @public_connect_hash ||= self.connect_hash.merge({
+        "database"           => "postgres",
+        "schema_search_path" => "public"
       })
     end
 
     def create_db
-      ActiveRecord::Base.establish_connection(self.public_schema_settings)
-      ActiveRecord::Base.connection.create_database(self.database, self.config_settings)
-      ActiveRecord::Base.establish_connection(self.config_settings)
+      ActiveRecord::Base.establish_connection(self.public_connect_hash)
+      ActiveRecord::Base.connection.create_database(self.database, self.connect_hash)
+      ActiveRecord::Base.establish_connection(self.connect_hash)
     end
 
     def drop_db
       begin
-        ActiveRecord::Base.establish_connection(self.public_schema_settings)
+        ActiveRecord::Base.establish_connection(self.public_connect_hash)
         ActiveRecord::Base.connection.tap do |conn|
           conn.execute "UPDATE pg_catalog.pg_database"\
                        " SET datallowconn=false WHERE datname='#{self.database}'"
@@ -40,47 +40,43 @@ class Ardb::Adapter
         tables = conn.execute "SELECT table_name"\
                               " FROM information_schema.tables"\
                               " WHERE table_schema = 'public';"
-        tables.each{ |row| conn.execute "DROP TABLE #{row['table_name']} CASCADE" }
+        tables.each{ |row| conn.execute "DROP TABLE #{row["table_name"]} CASCADE" }
       end
     end
 
-    def foreign_key_add_sql
-      "ALTER TABLE :from_table"\
-      " ADD CONSTRAINT :name"\
-      " FOREIGN KEY (:from_column)"\
-      " REFERENCES :to_table (:to_column)"
-    end
-
-    def foreign_key_drop_sql
-      "ALTER TABLE :from_table"\
-      " DROP CONSTRAINT :name"
-    end
-
     def load_sql_schema
-      require 'scmd'
+      require "scmd"
       cmd_str = "psql -f \"#{self.sql_schema_path}\" #{self.database}"
       cmd = Scmd.new(cmd_str, :env => env_var_hash).tap(&:run)
-      raise 'Error loading database' unless cmd.success?
+      raise "Error loading database" unless cmd.success?
     end
 
     def dump_sql_schema
-      require 'scmd'
+      require "scmd"
       cmd_str = "pg_dump -i -s -x -O -f \"#{self.sql_schema_path}\" #{self.database}"
       cmd = Scmd.new(cmd_str, :env => env_var_hash).tap(&:run)
-      raise 'Error dumping database' unless cmd.success?
+      raise "Error dumping database" unless cmd.success?
     end
 
     private
 
+    def validate!
+      if self.database =~ /\W/
+        raise(
+          Ardb::ConfigurationError,
+          "database value must not contain non-word characters. "\
+          "Given: #{self.database.inspect}."
+        )
+      end
+    end
+
     def env_var_hash
       @env_var_hash ||= {
-        'PGHOST'     => self.config_settings['host'],
-        'PGPORT'     => self.config_settings['port'],
-        'PGUSER'     => self.config_settings['username'],
-        'PGPASSWORD' => self.config_settings['password']
+        "PGHOST"     => self.connect_hash["host"],
+        "PGPORT"     => self.connect_hash["port"],
+        "PGUSER"     => self.connect_hash["username"],
+        "PGPASSWORD" => self.connect_hash["password"]
       }
     end
-
   end
-
 end

data/lib/ardb/adapter/sqlite.rb

@@ -1,18 +1,11 @@
-require 'pathname'
-require 'fileutils'
-require 'ardb'
-require 'ardb/adapter/base'
-
-class Ardb::Adapter
-
-  class Sqlite < Base
+require "fileutils"
+require "ardb"
+require "ardb/adapter/base"
 
+module Ardb::Adapter
+  class Sqlite < Ardb::Adapter::Base
     def db_file_path
-      if (path = Pathname.new(self.database)).absolute?
-        path.to_s
-      else
-        Ardb.config.root_path.join(path).to_s
-      end
+      File.expand_path(self.database, self.config.root_path)
     end
 
     def validate!
@@ -24,13 +17,11 @@ class Ardb::Adapter
     def create_db
       validate!
       FileUtils.mkdir_p File.dirname(self.db_file_path)
-      ActiveRecord::Base.establish_connection(self.config_settings)
+      ActiveRecord::Base.establish_connection(self.connect_hash)
     end
 
     def drop_db
       FileUtils.rm(self.db_file_path) if File.exist?(self.db_file_path)
     end
-
   end
-
 end

data/lib/ardb/adapter_spy.rb

@@ -1,114 +1,80 @@
-require 'much-plugin'
+require "ardb"
+require "ardb/adapter/base"
 
 module Ardb
-
-  module AdapterSpy
-    include MuchPlugin
-
-    def self.new(&block)
-      block ||= proc{ }
-      record_spy = Class.new{ include Ardb::AdapterSpy }
-      record_spy.class_eval(&block)
-      record_spy
+  class AdapterSpy < Ardb::Adapter::Base
+    attr_accessor :drop_tables_called_count
+    attr_accessor :dump_schema_called_count, :load_schema_called_count
+    attr_accessor :drop_db_called_count, :create_db_called_count
+    attr_accessor :connect_db_called_count, :migrate_db_called_count
+
+    def initialize(config = nil)
+      super(config || Ardb::Config.new)
+      @drop_tables_called_count = 0
+      @dump_schema_called_count = 0
+      @load_schema_called_count = 0
+      @drop_db_called_count     = 0
+      @create_db_called_count   = 0
+      @connect_db_called_count  = 0
+      @migrate_db_called_count  = 0
     end
 
-    plugin_included do
-      include InstanceMethods
+    def create_db_called?
+      self.create_db_called_count > 0
     end
 
-    module InstanceMethods
-
-      attr_accessor :drop_tables_called_count
-      attr_accessor :dump_schema_called_count, :load_schema_called_count
-      attr_accessor :drop_db_called_count, :create_db_called_count
-      attr_accessor :connect_db_called_count, :migrate_db_called_count
-
-      def drop_tables_called_count
-        @drop_tables_called_count ||= 0
-      end
-
-      def drop_tables_called?
-        self.drop_tables_called_count > 0
-      end
-
-      def drop_tables(*args, &block)
-        self.drop_tables_called_count += 1
-      end
-
-      def dump_schema_called_count
-        @dump_schema_called_count ||= 0
-      end
-
-      def dump_schema_called?
-        self.dump_schema_called_count > 0
-      end
-
-      def dump_schema(*args, &block)
-        self.dump_schema_called_count += 1
-      end
-
-      def load_schema_called_count
-        @load_schema_called_count ||= 0
-      end
-
-      def load_schema_called?
-        self.load_schema_called_count > 0
-      end
-
-      def load_schema(*args, &block)
-        self.load_schema_called_count += 1
-      end
-
-      def drop_db_called_count
-        @drop_db_called_count ||= 0
-      end
+    def drop_db_called?
+      self.drop_db_called_count > 0
+    end
 
-      def drop_db_called?
-        self.drop_db_called_count > 0
-      end
+    def drop_tables_called?
+      self.drop_tables_called_count > 0
+    end
 
-      def drop_db(*args, &block)
-        self.drop_db_called_count += 1
-      end
+    def connect_db_called?
+      self.connect_db_called_count > 0
+    end
 
-      def create_db_called_count
-        @create_db_called_count ||= 0
-      end
+    def migrate_db_called?
+      self.migrate_db_called_count > 0
+    end
 
-      def create_db_called?
-        self.create_db_called_count > 0
-      end
+    def load_schema_called?
+      self.load_schema_called_count > 0
+    end
 
-      def create_db(*args, &block)
-        self.create_db_called_count += 1
-      end
+    def dump_schema_called?
+      self.dump_schema_called_count > 0
+    end
 
-      def connect_db_called_count
-        @connect_db_called_count ||= 0
-      end
+    # Overwritten `Adapter::Base` methods
 
-      def connect_db_called?
-        self.connect_db_called_count > 0
-      end
+    def create_db(*args, &block)
+      self.create_db_called_count += 1
+    end
 
-      def connect_db(*args, &block)
-        self.connect_db_called_count += 1
-      end
+    def drop_db(*args, &block)
+      self.drop_db_called_count += 1
+    end
 
-      def migrate_db_called_count
-        @migrate_db_called_count ||= 0
-      end
+    def drop_tables(*args, &block)
+      self.drop_tables_called_count += 1
+    end
 
-      def migrate_db_called?
-        self.migrate_db_called_count > 0
-      end
+    def connect_db(*args, &block)
+      self.connect_db_called_count += 1
+    end
 
-      def migrate_db(*args, &block)
-        self.migrate_db_called_count += 1
-      end
+    def migrate_db(*args, &block)
+      self.migrate_db_called_count += 1
+    end
 
+    def load_schema(*args, &block)
+      self.load_schema_called_count += 1
     end
 
+    def dump_schema(*args, &block)
+      self.dump_schema_called_count += 1
+    end
   end
-
 end