ardb 0.29.1 → 0.29.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50d874e2df679ac2dff5d8617591ec70eb92cdf236324c6b9ba58e815c3a0f97
-  data.tar.gz: 28023038c65d75d082cd49545934657e3e11efb9be64cf7055335d09a68707ef
+  metadata.gz: 49a5b06420fd7d8b670267fd508d46efe7d600838a5808c33d25e166739e453d
+  data.tar.gz: cee5d9470ee881423fb3783b5607a9be982b45a34637f936a39590912241ce79
 SHA512:
-  metadata.gz: b7a3cfcb5f7bc262540e68ff4b0d259b8d9d95d5b109e521506229b4276bad96d3123c8cce6e7b0bf4f36777041fdbe2c714a17ca1f39e29846ba5d11b81b80b
-  data.tar.gz: 8cb2f15786e1a57c35ce32a39522aab648aa361ef29f4e0e6e8b63f70a3d5de3f41bfad99477751195a9d1ae68adf8363980211b1bd841841a508d57425246b0
+  metadata.gz: 1f3581d3e82f86af6b6dfcb79adab4560c577c907ac3c908febdf1b1216b7bfd473715053b87790083e4db7b44e7a0a6e0c35b0e512cdb652e75fec8c846d1e0
+  data.tar.gz: a63b4a6eef47151c9e22edff4177b25dce35e4a9be4914ad2a49cba22a7d785e8ac42d19e7eb0e51615d549c0f52d6a290a46e8847fd3701789261d1b10b7252

data/.l.yml

@@ -0,0 +1,8 @@
+# https://github.com/redding/l.rb
+
+linters:
+  - name: "Rubocop"
+    cmd: "bundle exec rubocop"
+    extensions:
+      - ".rb"
+    cli_abbrev: "u"

data/.rubocop.yml

@@ -0,0 +1,3 @@
+inherit_gem:
+  much-style-guide:
+    - "lib/much-style-guide/rubocop.yml"

data/.t.yml

@@ -0,0 +1,6 @@
+# https://github.com/redding/t.rb
+
+default_cmd: bundle exec assert
+test_dir: test
+test_file_suffixes:
+  - "_tests.rb"

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
 ruby "~> 2.5"
@@ -20,5 +22,5 @@ gem "activesupport", "~> 6.1"
 # gem "activerecord",  "~> 5.2.4"
 # gem "activesupport", "~> 5.2.4"
 
-gem "pg",  "~> 1.1.4"
-gem "pry", "~> 0.12.2"
+gem "pg", "~> 1.1.4"
+gem "pry"

data/ardb.gemspec

@@ -1,4 +1,6 @@
 # -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+
 lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "ardb/version"
@@ -8,22 +10,23 @@ Gem::Specification.new do |gem|
   gem.version     = Ardb::VERSION
   gem.authors     = ["Kelly Redding", "Collin Redding"]
   gem.email       = ["kelly@kellyredding.com", "collin.redding@me.com"]
-  gem.summary     = %q{Activerecord database tools.}
-  gem.description = %q{Activerecord database tools.}
+  gem.summary     = "Activerecord database tools."
+  gem.description = "Activerecord database tools."
   gem.homepage    = "http://github.com/redding/ardb"
   gem.license     = "MIT"
 
-  gem.files         = `git ls-files`.split($/)
+  gem.files = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
   gem.required_ruby_version = "~> 2.5"
 
-  gem.add_development_dependency("assert", ["~> 2.19.0"])
+  gem.add_development_dependency("much-style-guide", ["~> 0.6.0"])
+  gem.add_development_dependency("assert",           ["~> 2.19.3"])
 
   gem.add_dependency("activerecord",  ["> 5.0", "< 7.0"])
   gem.add_dependency("activesupport", ["> 5.0", "< 7.0"])
-  gem.add_dependency("much-plugin",   ["~> 0.2.1"])
-  gem.add_dependency("scmd",          ["~> 3.0.3"])
+  gem.add_dependency("much-mixin",    ["~> 0.2.4"])
+  gem.add_dependency("scmd",          ["~> 3.0.4"])
 end

data/bin/ardb

@@ -1,4 +1,6 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
+
 #
 # Copyright (c) 2013-Present Kelly Redding and Collin Redding
 #

data/lib/ardb.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_record"
 require "logger"
 
@@ -11,74 +13,79 @@ module Ardb
   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"
     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.default_timezone = self.config.default_timezone
-    ActiveRecord::Base.logger = self.config.logger
-    self.adapter.connect_db if establish_connection
+    ActiveRecord::Base.default_timezone = config.default_timezone
+    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)
@@ -104,26 +111,27 @@ 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)
+        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"
       end
 
-      if !VALID_SCHEMA_FORMATS.include?(self.schema_format)
+      unless VALID_SCHEMA_FORMATS.include?(schema_format)
         raise ConfigurationError, "schema format must be one of: " \
                                   "#{VALID_SCHEMA_FORMATS.join(", ")}"
       end
@@ -132,14 +140,14 @@ module Ardb
     end
 
     def ==(other)
-      if other.kind_of?(self.class)
-        self.activerecord_connect_hash == other.activerecord_connect_hash &&
-        self.default_timezone          == other.default_timezone          &&
-        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
@@ -153,14 +161,14 @@ module Ardb
       "postgresql",
       "postgres",
       "mysql",
-      "mysql2"
+      "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)
@@ -168,21 +176,27 @@ module Ardb
       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"
       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"
       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)

data/lib/ardb/adapter/base.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require "ardb"
 
 module Ardb; end
+
 module Ardb::Adapter
   class Base
     attr_reader :config
@@ -10,17 +13,28 @@ module Ardb::Adapter
       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
+    def connect_hash
+      config.activerecord_connect_hash
+    end
+
+    def database
+      config.database
+    end
+
+    def migrations_path
+      config.migrations_path
+    end
+
+    def schema_format
+      config.schema_format
+    end
 
     def ruby_schema_path
-      @ruby_schema_path ||= "#{self.config.schema_path}.rb"
+      @ruby_schema_path ||= "#{config.schema_path}.rb"
     end
 
     def sql_schema_path
-      @sql_schema_path ||= "#{self.config.schema_path}.sql"
+      @sql_schema_path ||= "#{config.schema_path}.sql"
     end
 
     def escape_like_pattern(pattern, escape_char = nil)
@@ -32,16 +46,23 @@ module Ardb::Adapter
       pattern
     end
 
-    def create_db(*args); raise NotImplementedError; end
-    def drop_db(*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 drop_tables(*args)
+      raise NotImplementedError
+    end
 
     def connect_db
-      ActiveRecord::Base.establish_connection(self.connect_hash)
+      ActiveRecord::Base.establish_connection(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{ }
+      ActiveRecord::Base.connection_pool.with_connection{}
     end
 
     def migrate_db
@@ -67,13 +88,13 @@ module Ardb::Adapter
     def load_schema
       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
+      load_ruby_schema if schema_format == Ardb::Config::RUBY_SCHEMA_FORMAT
+      load_sql_schema  if schema_format == Ardb::Config::SQL_SCHEMA_FORMAT
       $stdout = current_stdout
     end
 
     def load_ruby_schema
-      load self.ruby_schema_path
+      load ruby_schema_path
     end
 
     def load_sql_schema
@@ -84,14 +105,14 @@ module Ardb::Adapter
       current_stdout = $stdout.dup # silence STDOUT
       $stdout = File.new("/dev/null", "w")
       dump_ruby_schema
-      dump_sql_schema if self.schema_format == Ardb::Config::SQL_SCHEMA_FORMAT
+      dump_sql_schema if 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(self.ruby_schema_path)
-      File.open(self.ruby_schema_path, "w:utf-8") do |file|
+      FileUtils.mkdir_p File.dirname(ruby_schema_path)
+      File.open(ruby_schema_path, "w:utf-8") do |file|
         ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
       end
     end
@@ -101,8 +122,8 @@ module Ardb::Adapter
     end
 
     def ==(other)
-      if other.kind_of?(self.class)
-        self.config == other.config
+      if other.is_a?(self.class)
+        config == other.config
       else
         super
       end

data/lib/ardb/adapter/mysql.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "ardb/adapter/base"
 
 module Ardb::Adapter

data/lib/ardb/adapter/postgresql.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "ardb/adapter/base"
 
 module Ardb::Adapter
@@ -6,32 +8,38 @@ module Ardb::Adapter
     # 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"
+      @public_connect_hash ||= connect_hash.merge({
+        "database" => "postgres",
+        "schema_search_path" => "public",
       })
     end
 
     def create_db
-      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)
+      ActiveRecord::Base.establish_connection(public_connect_hash)
+      ActiveRecord::Base.connection.create_database(
+        database,
+        connect_hash,
+      )
+      ActiveRecord::Base.establish_connection(connect_hash)
     end
 
     def drop_db
       begin
-        ActiveRecord::Base.establish_connection(self.public_connect_hash)
+        ActiveRecord::Base.establish_connection(public_connect_hash)
         ActiveRecord::Base.connection.tap do |conn|
-          conn.execute "UPDATE pg_catalog.pg_database"\
-                       " SET datallowconn=false WHERE datname='#{self.database}'"
-          # this SELECT actually runs a command: it terminates all the connections
+          conn.execute(
+            "UPDATE pg_catalog.pg_database"\
+            " SET datallowconn=false WHERE datname='#{database}'",
+          )
+          # this SELECT actually runs a command: it terminates all the
+          # connections
           # http://www.postgresql.org/docs/9.2/static/functions-admin.html#FUNCTIONS-ADMIN-SIGNAL-TABLE
           conn.execute "SELECT pg_terminate_backend(pid)"\
-                       " FROM pg_stat_activity WHERE datname='#{self.database}'"
-          conn.execute "DROP DATABASE IF EXISTS #{self.database}"
+                       " FROM pg_stat_activity WHERE datname='#{database}'"
+          conn.execute "DROP DATABASE IF EXISTS #{database}"
         end
-      rescue PG::Error => e
-        raise e unless e.message =~ /does not exist/
+      rescue PG::Error => ex
+        raise ex unless ex.message =~ /does not exist/
       end
     end
 
@@ -40,42 +48,45 @@ module 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 do |row|
+          conn.execute "DROP TABLE #{row["table_name"]} CASCADE"
+        end
       end
     end
 
     def load_sql_schema
       require "scmd"
-      cmd_str = "psql -f \"#{self.sql_schema_path}\" #{self.database}"
-      cmd = Scmd.new(cmd_str, :env => env_var_hash).tap(&:run)
+      cmd_str = "psql -f \"#{sql_schema_path}\" #{database}"
+      cmd = Scmd.new(cmd_str, env: env_var_hash).tap(&:run)
       raise "Error loading database" unless cmd.success?
     end
 
     def dump_sql_schema
       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)
+      cmd_str =
+        "pg_dump -i -s -x -O -f \"#{sql_schema_path}\" #{database}"
+      cmd = Scmd.new(cmd_str, env: env_var_hash).tap(&:run)
       raise "Error dumping database" unless cmd.success?
     end
 
     private
 
     def validate!
-      if self.database =~ /\W/
+      if database =~ /\W/
         raise(
           Ardb::ConfigurationError,
           "database value must not contain non-word characters. "\
-          "Given: #{self.database.inspect}."
+          "Given: #{database.inspect}.",
         )
       end
     end
 
     def env_var_hash
       @env_var_hash ||= {
-        "PGHOST"     => self.connect_hash["host"],
-        "PGPORT"     => self.connect_hash["port"],
-        "PGUSER"     => self.connect_hash["username"],
-        "PGPASSWORD" => self.connect_hash["password"]
+        "PGHOST" => connect_hash["host"],
+        "PGPORT" => connect_hash["port"],
+        "PGUSER" => connect_hash["username"],
+        "PGPASSWORD" => connect_hash["password"],
       }
     end
   end