ardb 0.28.3 → 0.30.0

data/lib/ardb.rb

@@ -1,97 +1,109 @@
-require 'active_record'
-require 'logger'
+# frozen_string_literal: true
 
-require 'ardb/version'
+require "active_record"
+require "logger"
 
-ENV['ARDB_DB_FILE'] ||= 'config/db'
+require "ardb/version"
 
-module Ardb
+ENV["ARDB_DB_FILE"] ||= "config/db"
 
+module Ardb
   def self.config
     @config ||= Config.new
   end
 
   def self.configure(&block)
-    self.config.tap(&block)
+    config.tap(&block)
   end
 
   def self.adapter
     @adapter || raise(NotInitializedError.new(caller))
   end
 
-  def self.reset_adapter; @adapter = nil; end
+  def self.reset_adapter
+    @adapter = nil
+  end
 
   def self.init(establish_connection = true)
-    require 'ardb/require_autoloaded_active_record_files'
+    require "ardb/require_autoloaded_active_record_files"
     begin
       require_db_file
-    rescue InvalidDBFileError => exception
-      exception.set_backtrace(caller)
-      raise exception
+    rescue InvalidDBFileError => ex
+      ex.set_backtrace(caller)
+      raise ex
     end
 
-    self.config.validate!
-    @adapter = Adapter.new(self.config)
+    config.validate!
+    @adapter = Adapter.new(config)
 
     # setup AR
-    ActiveRecord::Base.logger = self.config.logger
-    self.adapter.connect_db if establish_connection
+    if ActiveRecord.respond_to?(:default_timezone=)
+      ActiveRecord.default_timezone = config.default_timezone
+    else
+      ActiveRecord::Base.default_timezone = config.default_timezone
+    end
+    ActiveRecord::Base.logger = config.logger
+    adapter.connect_db if establish_connection
   end
 
   def self.escape_like_pattern(pattern, escape_char = nil)
-    self.adapter.escape_like_pattern(pattern, escape_char)
-  rescue NotInitializedError => exception
-    exception.set_backtrace(caller)
-    raise exception
+    adapter.escape_like_pattern(pattern, escape_char)
+  rescue NotInitializedError => ex
+    ex.set_backtrace(caller)
+    raise ex
   end
 
-  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']
+      begin
+        require ENV["ARDB_DB_FILE"]
+      rescue LoadError
+        require File.expand_path(ENV["ARDB_DB_FILE"], ENV["PWD"])
+      end
     rescue LoadError
-      require File.expand_path(ENV['ARDB_DB_FILE'], ENV['PWD'])
+      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
-  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
 
   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
+    ACTIVERECORD_ATTRS =
+      [
+        :adapter,
+        :database,
+        :encoding,
+        :host,
+        :port,
+        :username,
+        :password,
+        :pool,
+        :checkout_timeout,
+        :min_messages,
+      ].freeze
+
+    DEFAULT_MIGRATIONS_PATH = "db/migrations"
+    DEFAULT_SCHEMA_PATH     = "db/schema"
+    RUBY_SCHEMA_FORMAT      = :ruby
+    SQL_SCHEMA_FORMAT       = :sql
     VALID_SCHEMA_FORMATS    = [RUBY_SCHEMA_FORMAT, SQL_SCHEMA_FORMAT].freeze
 
-    attr_accessor *ACTIVERECORD_ATTRS
-    attr_accessor :logger, :root_path
+    attr_accessor(*ACTIVERECORD_ATTRS)
+    attr_accessor :default_timezone, :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
+      @default_timezone = :utc
+      @logger           = Logger.new(STDOUT)
+      @root_path        = ENV["PWD"]
+      @migrations_path  = DEFAULT_MIGRATIONS_PATH
+      @schema_path      = DEFAULT_SCHEMA_PATH
+      @schema_format    = RUBY_SCHEMA_FORMAT
     end
 
     def migrations_path
@@ -103,84 +115,92 @@ module Ardb
     end
 
     def schema_format=(new_value)
-      @schema_format = begin
-        new_value.to_sym
-      rescue NoMethodError
-        raise ArgumentError, "schema format must be a `Symbol`", caller
-      end
+      @schema_format =
+        begin
+          new_value.to_sym
+        rescue NoMethodError
+          raise ArgumentError, "schema format must be a `Symbol`", caller
+        end
     end
 
     def activerecord_connect_hash
-      ACTIVERECORD_ATTRS.inject({}) do |h, attr_name|
-        value = self.send(attr_name)
+      ACTIVERECORD_ATTRS.reduce({}) do |h, attr_name|
+        value = send(attr_name)
         !value.nil? ? h.merge!(attr_name.to_s => value) : h
       end
     end
 
     def validate!
-      if self.adapter.to_s.empty? || self.database.to_s.empty?
+      if adapter.to_s.empty? || database.to_s.empty?
         raise ConfigurationError, "an adapter and database must be provided"
-      elsif !VALID_SCHEMA_FORMATS.include?(self.schema_format)
+      end
+
+      unless VALID_SCHEMA_FORMATS.include?(schema_format)
         raise ConfigurationError, "schema format must be one of: " \
-                                  "#{VALID_SCHEMA_FORMATS.join(', ')}"
+                                  "#{VALID_SCHEMA_FORMATS.join(", ")}"
       end
+
       true
     end
 
     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
+      if other.is_a?(self.class)
+        activerecord_connect_hash == other.activerecord_connect_hash &&
+        default_timezone          == other.default_timezone          &&
+        logger                    == other.logger                    &&
+        root_path                 == other.root_path                 &&
+        schema_format             == other.schema_format             &&
+        migrations_path           == other.migrations_path           &&
+        schema_path               == other.schema_path
       else
         super
       end
     end
-
   end
 
   module Adapter
-
     VALID_ADAPTERS = [
-      'sqlite',
-      'sqlite3',
-      'postgresql',
-      'postgres',
-      'mysql',
-      'mysql2'
+      "sqlite",
+      "sqlite3",
+      "postgresql",
+      "postgres",
+      "mysql",
+      "mysql2",
     ].freeze
 
     def self.new(config)
-      if !VALID_ADAPTERS.include?(config.adapter)
+      unless VALID_ADAPTERS.include?(config.adapter)
         raise InvalidAdapterError, "invalid adapter: `#{config.adapter}`"
       end
-      self.send(config.adapter, config)
+      send(config.adapter, config)
     end
 
     def self.sqlite(config)
-      require 'ardb/adapter/sqlite'
+      require "ardb/adapter/sqlite"
       Adapter::Sqlite.new(config)
     end
 
-    def self.sqlite3(config); self.sqlite(config); end
+    def self.sqlite3(config)
+      sqlite(config)
+    end
 
     def self.postgresql(config)
-      require 'ardb/adapter/postgresql'
+      require "ardb/adapter/postgresql"
       Adapter::Postgresql.new(config)
     end
 
-    def self.postgres(config); self.postgresql(config); end
+    def self.postgres(config)
+      postgresql(config)
+    end
 
     def self.mysql(config)
-      require 'ardb/adapter/mysql'
+      require "ardb/adapter/mysql"
       Adapter::Mysql.new(config)
     end
 
-    def self.mysql2(config); self.mysql(config); end
-
+    def self.mysql2(config)
+      mysql(config)
+    end
   end
 
   InvalidDBFileError  = Class.new(ArgumentError)
@@ -193,5 +213,4 @@ module Ardb
       set_backtrace(backtrace)
     end
   end
-
 end

data/script/determine_autoloaded_active_record_files.rb

@@ -1,8 +1,10 @@
-require 'active_record'
+# frozen_string_literal: true
 
-# this can be slow, this is one of the reasons this shouldn't be done during
+require "active_record"
+
+# this can be slow, this is one of the reasons this shouldn"t be done during
 # the startup of our apps
-gemspec = Gem.loaded_specs['activerecord']
+gemspec = Gem.loaded_specs["activerecord"]
 
 puts "Looking at files in: "
 puts "  #{gemspec.lib_dirs_glob.inspect}"
@@ -11,16 +13,21 @@ paths = Dir["#{gemspec.lib_dirs_glob}/**/*.rb"]
 
 # these are regexs for files we want to ignore requiring. for example,
 # generators fail when we try to require them. the others are pieces of active
-# record we don't use in a production environment
+# record we don"t use in a production environment
 ignored_regexes = [
-  /rails\/generators/,
-  /active_record\/railtie/,
-  /active_record\/migration/,
-  /active_record\/fixtures/,
-  /active_record\/schema/,
-  /active_record\/connection_adapters/,
-  /active_record\/test_case/,
-  /active_record\/coders\/yaml_column/
+  %r{rails/generators},
+  %r{active_record/railtie},
+  %r{active_record/migration},
+  %r{active_record/fixtures},
+  %r{active_record/fixture_set},
+  %r{active_record/schema},
+  %r{active_record/connection_adapters},
+  %r{active_record/test_case},
+  %r{active_record/test_databases},
+  %r{active_record/test_fixtures},
+  %r{active_record/coders/yaml_column},
+  # `destroy_association_async_job` requires `ActiveJob` to be required.
+  %r{active_record/destroy_association_async_job},
 ]
 
 Result = Struct.new(:file, :state, :reason)
@@ -31,18 +38,18 @@ ignored              = []
 errored              = []
 
 paths.sort.each do |full_path|
-  relative_path_with_rb = full_path.gsub("#{gemspec.lib_dirs_glob}/", '')
-  relative_path = relative_path_with_rb.gsub(/\.rb\z/, '')
+  relative_path_with_rb = full_path.gsub("#{gemspec.lib_dirs_glob}/", "")
+  relative_path = relative_path_with_rb.gsub(/\.rb\z/, "")
 
   result = Result.new(relative_path)
 
-  # see if it's ignored
+  # see if it"s ignored
   ignored_regexes.each do |regex|
-    if relative_path =~ regex
-      result.state  = :ignored
-      result.reason = "matched #{regex}"
-      break
-    end
+    next unless relative_path =~ regex
+
+    result.state  = :ignored
+    result.reason = "matched #{regex}"
+    break
   end
   if result.state == :ignored
     ignored << result
@@ -51,14 +58,14 @@ paths.sort.each do |full_path|
 
   # try requiring the file
   begin
-    if result.state = require(relative_path)
+    if (result.state = require(relative_path))
       needs_to_be_required << result
     else
       already_required << result
     end
-  rescue LoadError, SyntaxError => exception
+  rescue LoadError, SyntaxError => ex
     result.state  = :errored
-    result.reason = "#{exception.class}: #{exception.message}"
+    result.reason = "#{ex.class}: #{ex.message}"
     errored << result
   end
 end
@@ -87,5 +94,5 @@ puts "\n"
 
 puts "Needs To Be Required:\n"
 needs_to_be_required.each do |result|
-  puts "require '#{result.file}'"
+  puts "require \"#{result.file}\""
 end

data/test/helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # this file is automatically required when you run `assert`
 # put any test helpers here
 
@@ -7,19 +9,10 @@ $LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
 TEST_SUPPORT_PATH = File.expand_path("../support", __FILE__)
 TMP_PATH          = File.expand_path("../../tmp", __FILE__)
 
-require 'logger'
+require "logger"
 log_path = File.expand_path("../../log/test.log", __FILE__)
-TEST_LOGGER = Logger.new(File.open(log_path, 'w'))
+TEST_LOGGER = Logger.new(File.open(log_path, "w"))
 
 # require pry for debugging (`binding.pry`)
-require 'pry'
-require 'test/support/factory'
-
-# 1.8.7 backfills
-
-# Array#sample
-if !(a = Array.new).respond_to?(:sample) && a.respond_to?(:choice)
-  class Array
-    alias_method :sample, :choice
-  end
-end
+require "pry"
+require "test/support/factory"

data/test/support/factory.rb

@@ -1,10 +1,12 @@
-require 'assert/factory'
+# frozen_string_literal: true
+
+require "assert/factory"
 
 module Factory
   extend Assert::Factory
 
   def self.migration_id
-    # identifiers need to be plural b/c af activesupport's pluralize
+    # identifiers need to be plural b/c af activesupport"s pluralize
     "#{Factory.string}_things"
   end
 
@@ -22,5 +24,4 @@ module Factory
       c.min_messages     = Factory.string
     end
   end
-
 end

data/test/support/fake_schema.rb

@@ -1,4 +1,6 @@
-if !defined?(FAKE_SCHEMA)
+# frozen_string_literal: true
+
+unless defined?(FAKE_SCHEMA)
   fake_schema_class = Struct.new(:load_count)
   FAKE_SCHEMA = fake_schema_class.new(0)
 end

data/test/support/postgresql/schema.rb

@@ -1,3 +1,4 @@
-ActiveRecord::Schema.define(:version => 0) do
+# frozen_string_literal: true
 
+ActiveRecord::Schema.define(version: 0) do
 end

data/test/support/postgresql/setup_test_db.rb

@@ -1,26 +1,29 @@
-require 'assert'
-require 'ardb'
+# frozen_string_literal: true
+
+require "assert"
+require "ardb"
 
 class PostgresqlDbTests < Assert::Context
   setup do
-    @orig_env_ardb_db_file    = ENV['ARDB_DB_FILE']
+    @orig_env_ardb_db_file    = ENV["ARDB_DB_FILE"]
     ActiveRecord::Base.logger = @orig_ar_loggerF
 
-    # no-op, we're manually configuring ardb so we don't need this to do anything
-    ENV['ARDB_DB_FILE'] = File.join(TEST_SUPPORT_PATH, 'require_test_db_file')
-
-    @ardb_config = Ardb::Config.new.tap do |c|
-      c.adapter      = 'postgresql'
-      c.database     = 'redding_ardb_test'
-      c.encoding     = 'unicode'
-      c.min_messages = 'WARNING'
-
-      c.logger          = TEST_LOGGER
-      c.root_path       = File.join(TEST_SUPPORT_PATH, 'postgresql')
-      c.migrations_path = 'migrations'
-      c.schema_path     = 'schema'
-      c.schema_format   = :ruby
-    end
+    # we"re manually configuring ardb so we don"t need this to do anything
+    ENV["ARDB_DB_FILE"] = File.join(TEST_SUPPORT_PATH, "require_test_db_file")
+
+    @ardb_config =
+      Ardb::Config.new.tap do |c|
+        c.adapter      = "postgresql"
+        c.database     = "redding_ardb_test"
+        c.encoding     = "unicode"
+        c.min_messages = "WARNING"
+
+        c.logger          = TEST_LOGGER
+        c.root_path       = File.join(TEST_SUPPORT_PATH, "postgresql")
+        c.migrations_path = "migrations"
+        c.schema_path     = "schema"
+        c.schema_format   = :ruby
+      end
     Assert.stub(Ardb, :config){ @ardb_config }
 
     Ardb.init(false)
@@ -33,7 +36,7 @@ class PostgresqlDbTests < Assert::Context
   teardown do
     Ardb.reset_adapter
     ActiveRecord::Base.logger = @orig_ar_logger
-    ENV['ARDB_DB_FILE']       = @orig_env_ardb_db_file
+    ENV["ARDB_DB_FILE"]       = @orig_env_ardb_db_file
   end
 
   private
@@ -41,12 +44,11 @@ class PostgresqlDbTests < Assert::Context
   # useful when testing creating/dropping/migrating DBs
   def silence_stdout
     current_stdout = $stdout.dup
-    $stdout = File.new('/dev/null', 'w')
+    $stdout = File.new("/dev/null", "w")
     begin
       yield
     ensure
       $stdout = current_stdout
     end
   end
-
 end

data/test/support/relative_require_test_db_file.rb

@@ -1,2 +1,3 @@
+# frozen_string_literal: true
 # this file is used to test that Ardb will relatively require a db file when
 # init

data/test/support/require_test_db_file.rb

@@ -1 +1,2 @@
+# frozen_string_literal: true
 # this file is used to test that Ardb will require a db file when init