ardb 0.28.3 → 0.30.0

data/lib/ardb/adapter/postgresql.rb

@@ -1,39 +1,45 @@
-require 'ardb/adapter/base'
+# frozen_string_literal: true
 
-module Ardb::Adapter
-
-  class Postgresql < Base
+require "ardb/adapter/base"
 
-    # the 'postgres' db is a "public" (doesn't typically require auth/grants to
+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'
+      @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
 
@@ -42,47 +48,46 @@ 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 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'
-      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?
+      require "scmd"
+      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)
-      raise 'Error dumping database' unless cmd.success?
+      require "scmd"
+      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 database =~ /\W/
+        raise(
+          Ardb::ConfigurationError,
+          "database value must not contain non-word characters. "\
+          "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
-
 end

data/lib/ardb/adapter/sqlite.rb

@@ -1,31 +1,27 @@
-require 'fileutils'
-require 'ardb'
-require 'ardb/adapter/base'
+# frozen_string_literal: true
 
-module 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
-      File.expand_path(self.database, self.config.root_path)
+      File.expand_path(database, config.root_path)
     end
 
     def validate!
-      if File.exist?(self.db_file_path)
-        raise RuntimeError, "`#{self.database}` already exists"
-      end
+      raise "`#{database}` already exists" if File.exist?(db_file_path)
     end
 
     def create_db
       validate!
-      FileUtils.mkdir_p File.dirname(self.db_file_path)
-      ActiveRecord::Base.establish_connection(self.connect_hash)
+      FileUtils.mkdir_p File.dirname(db_file_path)
+      ActiveRecord::Base.establish_connection(connect_hash)
     end
 
     def drop_db
-      FileUtils.rm(self.db_file_path) if File.exist?(self.db_file_path)
+      FileUtils.rm(db_file_path) if File.exist?(db_file_path)
     end
-
   end
-
 end

data/lib/ardb/adapter_spy.rb

@@ -1,10 +1,10 @@
-require 'ardb'
-require 'ardb/adapter/base'
+# frozen_string_literal: true
 
-module Ardb
+require "ardb"
+require "ardb/adapter/base"
 
+module Ardb
   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
@@ -22,73 +22,61 @@ module Ardb
     end
 
     def create_db_called?
-      self.create_db_called_count > 0
+      create_db_called_count > 0
     end
 
     def drop_db_called?
-      self.drop_db_called_count > 0
+      drop_db_called_count > 0
     end
 
     def drop_tables_called?
-      self.drop_tables_called_count > 0
+      drop_tables_called_count > 0
     end
 
     def connect_db_called?
-      self.connect_db_called_count > 0
+      connect_db_called_count > 0
     end
 
     def migrate_db_called?
-      self.migrate_db_called_count > 0
+      migrate_db_called_count > 0
     end
 
     def load_schema_called?
-      self.load_schema_called_count > 0
+      load_schema_called_count > 0
     end
 
     def dump_schema_called?
-      self.dump_schema_called_count > 0
+      dump_schema_called_count > 0
     end
 
     # Overwritten `Adapter::Base` methods
 
-    def foreign_key_add_sql
-      "FAKE ADD FOREIGN KEY SQL :from_table :from_column " \
-      ":to_table :to_column :name"
-    end
-
-    def foreign_key_drop_sql
-      "FAKE DROP FOREIGN KEY SQL :from_table :from_column " \
-      ":to_table :to_column :name"
-    end
-
-    def create_db(*args, &block)
+    def create_db(*_args)
       self.create_db_called_count += 1
     end
 
-    def drop_db(*args, &block)
+    def drop_db(*_args)
       self.drop_db_called_count += 1
     end
 
-    def drop_tables(*args, &block)
+    def drop_tables(*_args)
       self.drop_tables_called_count += 1
     end
 
-    def connect_db(*args, &block)
+    def connect_db(*_args)
       self.connect_db_called_count += 1
     end
 
-    def migrate_db(*args, &block)
+    def migrate_db(*_args)
       self.migrate_db_called_count += 1
     end
 
-    def load_schema(*args, &block)
+    def load_schema(*_args)
       self.load_schema_called_count += 1
     end
 
-    def dump_schema(*args, &block)
+    def dump_schema(*_args)
       self.dump_schema_called_count += 1
     end
-
   end
-
 end

data/lib/ardb/cli/clirb.rb

@@ -1,24 +1,24 @@
 module Ardb; end
-class Ardb::CLI
 
-  class CLIRB  # Version 1.0.0, https://github.com/redding/cli.rb
+class Ardb::CLI
+  class CLIRB  # Version 1.2.0, https://github.com/redding/cli.rb
     Error    = Class.new(RuntimeError);
     HelpExit = Class.new(RuntimeError); VersionExit = Class.new(RuntimeError)
     attr_reader :argv, :args, :opts, :data
 
     def initialize(&block)
       @options = []; instance_eval(&block) if block
-      require 'optparse'
+      require "optparse"
       @data, @args, @opts = [], [], {}; @parser = OptionParser.new do |p|
-        p.banner = ''; @options.each do |o|
+        p.banner = ""; @options.each do |o|
           @opts[o.name] = o.value; p.on(*o.parser_args){ |v| @opts[o.name] = v }
         end
-        p.on_tail('--version', ''){ |v| raise VersionExit, v.to_s }
-        p.on_tail('--help',    ''){ |v| raise HelpExit,    v.to_s }
+        p.on_tail("--version", ""){ |v| raise VersionExit, v.to_s }
+        p.on_tail("--help",    ""){ |v| raise HelpExit,    v.to_s }
       end
     end
 
-    def option(*args); @options << Option.new(*args); end
+    def option(*args, **kargs); @options << Option.new(*args, **kargs); end
     def parse!(argv)
       @args = (argv || []).dup.tap do |args_list|
         begin; @parser.parse!(args_list)
@@ -27,33 +27,31 @@ class Ardb::CLI
     end
     def to_s; @parser.to_s; end
     def inspect
-      "#<#{self.class}:#{'0x0%x' % (object_id << 1)} @data=#{@data.inspect}>"
+      "#<#{self.class}:#{"0x0%x" % (object_id << 1)} @data=#{@data.inspect}>"
     end
 
     class Option
       attr_reader :name, :opt_name, :desc, :abbrev, :value, :klass, :parser_args
 
-      def initialize(name, *args)
-        settings, @desc = args.last.kind_of?(::Hash) ? args.pop : {}, args.pop || ''
-        @name, @opt_name, @abbrev = parse_name_values(name, settings[:abbrev])
-        @value, @klass = gvalinfo(settings[:value])
+      def initialize(name, desc = nil, abbrev: nil, value: nil)
+        @name, @desc = name, desc || ""
+        @opt_name, @abbrev = parse_name_values(name, abbrev)
+        @value, @klass = gvalinfo(value)
         @parser_args = if [TrueClass, FalseClass, NilClass].include?(@klass)
           ["-#{@abbrev}", "--[no-]#{@opt_name}", @desc]
         else
-          ["-#{@abbrev}", "--#{@opt_name} #{@opt_name.upcase}", @klass, @desc]
+          ["-#{@abbrev}", "--#{@opt_name} VALUE", @klass, @desc]
         end
       end
 
       private
 
       def parse_name_values(name, custom_abbrev)
-        [ (processed_name = name.to_s.strip.downcase), processed_name.gsub('_', '-'),
-          custom_abbrev || processed_name.gsub(/[^a-z]/, '').chars.first || 'a'
+        [ (processed_name = name.to_s.strip.downcase).gsub("_", "-"),
+          custom_abbrev || processed_name.gsub(/[^a-z]/, "").chars.first || "a"
         ]
       end
-      def gvalinfo(v); v.kind_of?(Class) ? [nil,gklass(v)] : [v,gklass(v.class)]; end
-      def gklass(k); k == Fixnum ? Integer : k; end
+      def gvalinfo(v); v.kind_of?(Class) ? [nil,v] : [v,v.class]; end
     end
   end
-
 end