ardb 0.27.3 → 0.28.0

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
 SHA1: 
-  metadata.gz: efed4edb38eade9eaa2de6263e30f163b4ffa3db
-  data.tar.gz: 41bb43c7936a806124cdeb747d78c6a4de2393e4
+  data.tar.gz: 33194d527399daa093277e134bbcda8dee5c6069
+  metadata.gz: 7718eb32a25016d2d620a820b5a2b04244445b6a
 SHA512: 
-  metadata.gz: ba2ed871805feac6de258476b78dc906c63b6a4491b8ab24925dc87447e19f4e89f073b6642729d8ec863a3b760257293da95ed4aa7e8d2b3f7d09aedc86cefe
-  data.tar.gz: f521735072f0ce180c0073593af0aefc5ae16cc3bcab8ed5c0dcf7677f1da6d818fa8b051c1f91fa07b18626582b4beeec021810a51223f6ca538d503c9fb7bb
+  data.tar.gz: 1597717aba91e83109628879b8ab51c52a81fe47c9f8182bf8bff32e91b7fe30f72a0543d97e1200b77926824b1d669790144fc3bf39bb9e9a30a95110192a69
+  metadata.gz: 02366a02d6aff1a513ea34969017cc07b56be184e906a7cb34b446811c6d4ebaa6fb97f6eddd04344b3f4d2dbca51624c4c57316f996e1b6b98809826e5d03f4

data/Gemfile

@@ -2,8 +2,12 @@ source "https://rubygems.org"
 
 gemspec
 
-gem 'pry',  "~> 0.9.0"
+gem 'pg',  "~> 0.17.1"
+gem 'pry', "~> 0.9.0"
 
 # Lock down gem versions because they require a newer version of ruby
 gem 'i18n', "< 0.7"
 
+platform :ruby_18 do
+  gem 'json', '~> 1.8'
+end

data/ardb.gemspec

@@ -18,12 +18,11 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_development_dependency("assert", ["~> 2.15.1"])
+  gem.add_development_dependency("assert", ["~> 2.16.1"])
 
   gem.add_dependency('activerecord',  ["~> 3.2"])
   gem.add_dependency('activesupport', ["~> 3.2"])
-  gem.add_dependency('much-plugin',   ["~> 0.1.0"])
-  gem.add_dependency('ns-options',    ["~> 1.1.6"])
-  gem.add_dependency('scmd',          ["~> 3.0.1"])
+  gem.add_dependency('much-plugin',   ["~> 0.1.1"])
+  gem.add_dependency('scmd',          ["~> 3.0.2"])
 
 end

data/lib/ardb.rb

@@ -1,115 +1,182 @@
-require 'pathname'
-require 'singleton'
 require 'active_record'
-require 'ns-options'
+require 'logger'
 
 require 'ardb/version'
-require 'ardb/root_path'
 
 ENV['ARDB_DB_FILE'] ||= 'config/db'
 
 module Ardb
-  NotConfiguredError = Class.new(RuntimeError)
 
-  def self.config; Config; end
-  def self.configure(&block); Config.define(&block); end
-
-  def self.adapter; Adapter.current; end
+  def self.config
+    @config ||= Config.new
+  end
 
-  def self.validate!
-    if !self.config.required_set?
-      raise NotConfiguredError, "missing required configs"
-    end
+  def self.configure(&block)
+    self.config.tap(&block)
   end
 
+  def self.adapter; @adapter; end
+
   def self.init(establish_connection = true)
     require 'ardb/require_autoloaded_active_record_files'
-    require self.config.db_file
-    validate!
-    Adapter.init
+    begin
+      require_db_file
+    rescue InvalidDBFileError => exception
+      raise exception.tap{ |e| e.set_backtrace(caller) }
+    end
+
+    self.config.validate!
+    @adapter = Adapter.new(self.config)
 
     # setup AR
     ActiveRecord::Base.logger = self.config.logger
-    if establish_connection
-      ActiveRecord::Base.establish_connection(self.config.db_settings)
-    end
+    self.adapter.connect_db if establish_connection
   end
 
   def self.escape_like_pattern(pattern, escape_char = nil)
     self.adapter.escape_like_pattern(pattern, escape_char)
   end
 
-  class Config
-    include NsOptions::Proxy
-
-    namespace :db do
-      option :adapter,          String,  :required => true
-      option :database,         String,  :required => true
-      option :encoding,         String,  :required => false
-      option :host,             String,  :required => false
-      option :port,             Integer, :required => false
-      option :username,         String,  :required => false
-      option :password,         String,  :required => false
-      option :pool,             Integer, :required => false
-      option :checkout_timeout, Integer, :required => false
+  private
+
+  # try requiring the db file via the load path or as an absolute path, if
+  # that fails it tries requiring relative to the current working directory
+  def self.require_db_file
+    begin
+      require ENV['ARDB_DB_FILE']
+    rescue LoadError
+      require File.expand_path(ENV['ARDB_DB_FILE'], ENV['PWD'])
     end
+  rescue LoadError
+    raise InvalidDBFileError, "can't require `#{ENV['ARDB_DB_FILE']}`, " \
+                              "check that the ARDB_DB_FILE env var is set to " \
+                              "the file path of your db file"
+  end
 
-    option :db_file,         Pathname, :default => ENV['ARDB_DB_FILE']
-    option :root_path,       Pathname, :required => true
-    option :logger,                    :required => true
-    option :migrations_path, RootPath, :default => proc{ "db/migrations" }
-    option :schema_path,     RootPath, :default => proc{ "db/schema" }
-    option :schema_format,   Symbol,   :default => :ruby
-
-    def self.db_settings
-      db.to_hash.inject({}) do |settings, (k, v)|
-        settings[k.to_s] = v if !v.nil?
-        settings
-      end
+  class Config
+
+    ACTIVERECORD_ATTRS = [
+      :adapter,
+      :database,
+      :encoding,
+      :host,
+      :port,
+      :username,
+      :password,
+      :pool,
+      :checkout_timeout,
+      :min_messages
+    ].freeze
+    DEFAULT_MIGRATIONS_PATH = 'db/migrations'.freeze
+    DEFAULT_SCHEMA_PATH     = 'db/schema'.freeze
+    RUBY_SCHEMA_FORMAT      = :ruby.freeze
+    SQL_SCHEMA_FORMAT       = :sql.freeze
+    VALID_SCHEMA_FORMATS    = [RUBY_SCHEMA_FORMAT, SQL_SCHEMA_FORMAT].freeze
+
+    attr_accessor *ACTIVERECORD_ATTRS
+    attr_accessor :logger, :root_path
+    attr_reader :schema_format
+    attr_writer :migrations_path, :schema_path
+
+    def initialize
+      @logger          = Logger.new(STDOUT)
+      @root_path       = ENV['PWD']
+      @migrations_path = DEFAULT_MIGRATIONS_PATH
+      @schema_path     = DEFAULT_SCHEMA_PATH
+      @schema_format   = RUBY_SCHEMA_FORMAT
     end
 
-  end
+    def migrations_path
+      File.expand_path(@migrations_path.to_s, @root_path.to_s)
+    end
 
-  class Adapter
-    include Singleton
+    def schema_path
+      File.expand_path(@schema_path.to_s, @root_path.to_s)
+    end
 
-    attr_accessor :current
+    def schema_format=(new_value)
+      @schema_format = begin
+        new_value.to_sym
+      rescue NoMethodError
+        raise ArgumentError, "schema format must be a `Symbol`", caller
+      end
+    end
 
-    def init
-      @current = Adapter.send(Ardb.config.db.adapter)
+    def activerecord_connect_hash
+      ACTIVERECORD_ATTRS.inject({}) do |h, attr_name|
+        value = self.send(attr_name)
+        !value.nil? ? h.merge!(attr_name.to_s => value) : h
+      end
     end
 
-    def reset
-      @current = nil
+    def validate!
+      if self.adapter.to_s.empty? || self.database.to_s.empty?
+        raise ConfigurationError, "an adapter and database must be provided"
+      elsif !VALID_SCHEMA_FORMATS.include?(self.schema_format)
+        raise ConfigurationError, "schema format must be one of: " \
+                                  "#{VALID_SCHEMA_FORMATS.join(', ')}"
+      end
+      true
     end
 
-    def sqlite
-      require 'ardb/adapter/sqlite'
-      Adapter::Sqlite.new
+    def ==(other)
+      if other.kind_of?(self.class)
+        self.activerecord_connect_hash == other.activerecord_connect_hash &&
+        self.logger                    == other.logger           &&
+        self.root_path                 == other.root_path        &&
+        self.schema_format             == other.schema_format    &&
+        self.migrations_path           == other.migrations_path  &&
+        self.schema_path               == other.schema_path
+      else
+        super
+      end
     end
-    alias_method :sqlite3, :sqlite
 
-    def postgresql
-      require 'ardb/adapter/postgresql'
-      Adapter::Postgresql.new
+  end
+
+  module Adapter
+
+    VALID_ADAPTERS = [
+      'sqlite',
+      'sqlite3',
+      'postgresql',
+      'postgres',
+      'mysql',
+      'mysql2'
+    ].freeze
+
+    def self.new(config)
+      if !VALID_ADAPTERS.include?(config.adapter)
+        raise InvalidAdapterError, "invalid adapter: `#{config.adapter}`"
+      end
+      self.send(config.adapter, config)
     end
 
-    def mysql
-      require 'ardb/adapter/mysql'
-      Adapter::Mysql.new
+    def self.sqlite(config)
+      require 'ardb/adapter/sqlite'
+      Adapter::Sqlite.new(config)
     end
-    alias_method :mysql2, :mysql
 
-    # nice singleton api
+    def self.sqlite3(config); self.sqlite(config); end
 
-    def self.method_missing(method, *args, &block)
-      self.instance.send(method, *args, &block)
+    def self.postgresql(config)
+      require 'ardb/adapter/postgresql'
+      Adapter::Postgresql.new(config)
     end
 
-    def self.respond_to?(method)
-      super || self.instance.respond_to?(method)
+    def self.postgres(config); self.postgresql(config); end
+
+    def self.mysql(config)
+      require 'ardb/adapter/mysql'
+      Adapter::Mysql.new(config)
     end
 
+    def self.mysql2(config); self.mysql(config); end
+
   end
 
+  InvalidDBFileError  = Class.new(ArgumentError)
+  ConfigurationError  = Class.new(ArgumentError)
+  InvalidAdapterError = Class.new(RuntimeError)
+
 end

data/lib/ardb/adapter/base.rb

@@ -1,18 +1,27 @@
+require 'ardb'
+
 module Ardb; end
-class Ardb::Adapter
+module Ardb::Adapter
 
   class Base
 
-    attr_reader :config_settings, :database
-    attr_reader :schema_format, :ruby_schema_path, :sql_schema_path
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+    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
+
+    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)
@@ -29,14 +38,18 @@ class Ardb::Adapter
     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'
@@ -45,26 +58,24 @@ class Ardb::Adapter
         end
       end
 
-      ActiveRecord::Migrator.migrations_path = migrations_path
+      ActiveRecord::Migrator.migrations_path = self.migrations_path
       ActiveRecord::Migration.verbose = verbose
-      ActiveRecord::Migrator.migrate(migrations_path, version) do |migration|
+      ActiveRecord::Migrator.migrate(self.migrations_path, version) do |migration|
         ENV["MIGRATE_SCOPE"].blank? || (ENV["MIGRATE_SCOPE"] == migration.scope)
       end
     end
 
-    def drop_tables(*args); raise NotImplementedError; 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
+      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
@@ -76,14 +87,14 @@ class Ardb::Adapter
       current_stdout = $stdout.dup
       $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|
+      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,8 +103,12 @@ 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

data/lib/ardb/adapter/mysql.rb

@@ -1,7 +1,6 @@
-require 'ardb'
 require 'ardb/adapter/base'
 
-class Ardb::Adapter
+module Ardb::Adapter
 
   class Mysql < Base
 

data/lib/ardb/adapter/postgresql.rb

@@ -1,26 +1,28 @@
-require 'ardb'
 require 'ardb/adapter/base'
 
-class Ardb::Adapter
+module Ardb::Adapter
 
   class Postgresql < Base
 
-    def public_schema_settings
-      self.config_settings.merge({
+    # 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}'"
@@ -74,10 +76,10 @@ class Ardb::Adapter
 
     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