cleanup code based on several rubocop rules

Author: urkle

.simplecov

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 SimpleCov.configure do
   enable_coverage :branch
   add_filter '/spec/'

Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in schema_dev.gemspec

Rakefile

@@ -1,4 +1,6 @@
-require "bundler/gem_tasks"
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
 
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)

bin/schema_dev

@@ -1,66 +1,70 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'active_support/core_ext/hash'
 require 'thor'
+require 'English'
 require_relative '../lib/schema_dev/config'
 require_relative '../lib/schema_dev/gem'
 require_relative '../lib/schema_dev/runner'
 require_relative '../lib/schema_dev/version'
 
 def runner
-    $config ||= SchemaDev::Config.load
-    $runner ||= SchemaDev::Runner.new($config)
+  config = SchemaDev::Config.load rescue nil
+  @runner ||= SchemaDev::Runner.new(config)
 end
 
-$cmd = File.basename $0
+def cmd
+  @cmd ||= File.basename $PROGRAM_NAME
+end
 
 class CLI < Thor
-
   def self.matrix_options
-    method_option :dry_run, aliases: "-n", type: :boolean, desc: "Show what the commands would be without running them"
-    method_option :quick, type: :boolean, desc: "Only execute on the 'quick' choice: #{$config ? $config.quick.inspect : "[from schema_dev.yml]"}"
-    method_option :ruby, type: :string, desc: "Only execute for the specified version of ruby"
-    method_option :activerecord, aliases: "--ar", type: :string, desc: "Only execute for the specified version of activerecord"
-    method_option :db, type: :string, desc: "Only execute for the specified database"
+    method_option :dry_run, aliases: '-n', type: :boolean, desc: 'Show what the commands would be without running them'
+    method_option :quick, type: :boolean, desc: "Only execute on the 'quick' choice: #{runner.config ? runner.config.quick.inspect : '[from schema_dev.yml]'}"
+    method_option :ruby, type: :string, desc: 'Only execute for the specified version of ruby'
+    method_option :activerecord, aliases: '--ar', type: :string, desc: 'Only execute for the specified version of activerecord'
+    method_option :db, type: :string, desc: 'Only execute for the specified database'
   end
 
-  desc "freshen", "update files that depend on schema_dev.yml: .github/worksflows/prs.yml, gemfiles/, README.md"
+  desc 'freshen', 'update files that depend on schema_dev.yml: .github/worksflows/prs.yml, gemfiles/, README.md'
   def freshen
-      runner.freshen
+    runner.freshen
   end
 
-  desc "matrix", "run a command over the matrix"
+  desc 'matrix', 'run a command over the matrix'
   matrix_options
   def matrix(*args)
     runner.run(args, **options.to_h.symbolize_keys)
   end
 
-  desc "bundle", "shorthand for '#{$cmd} matrix bundle ...'"
+  desc 'bundle', "shorthand for '#{cmd} matrix bundle ...'"
   matrix_options
   def bundle(*args)
     runner.run('bundle', args, **options.to_h.symbolize_keys)
   end
 
-  desc "rake", "shorthand for '#{$cmd} matrix bundle exec rake ...'"
+  desc 'rake', "shorthand for '#{cmd} matrix bundle exec rake ...'"
   matrix_options
   def rake(*args)
     runner.run('bundle', 'exec', 'rake', args, **options.to_h.symbolize_keys)
   end
 
-  desc "rspec", "shorthand for '#{$cmd} bundle exec rspec ...'"
+  desc 'rspec', "shorthand for '#{cmd} bundle exec rspec ...'"
   matrix_options
   def rspec(*args)
     runner.run('bundle', 'exec', 'rspec', args, **options.to_h.symbolize_keys)
   end
 
-  desc "gem", "create a new SchemaPlus gem"
+  desc 'gem', 'create a new SchemaPlus gem'
   def gem(name)
-      SchemaDev::Gem.build(name)
+    SchemaDev::Gem.build(name)
   end
-
 end
 
-case
-when ARGV[0] == "--version" then puts "SchemaDev #{SchemaDev::VERSION}"
-else CLI.start(ARGV)
+case ARGV[0]
+when '--version'
+  puts "SchemaDev #{SchemaDev::VERSION}"
+else
+  CLI.start(ARGV)
 end

lib/schema_dev.rb

@@ -1 +1,3 @@
-require "schema_dev/version"
+# frozen_string_literal: true
+
+require 'schema_dev/version'

lib/schema_dev/config.rb

@@ -1,32 +1,35 @@
+# frozen_string_literal: true
+
 require 'active_support/core_ext/hash'
-require 'enumerator'
 require 'pathname'
 require 'yaml'
 require 'rubygems/version'
 
 module SchemaDev
-  CONFIG_FILE = "schema_dev.yml"
+  CONFIG_FILE = 'schema_dev.yml'
 
   class Config
-
     attr_accessor :quick, :db, :dbversions, :ruby, :activerecord, :exclude
 
-    def self._reset ; @config = nil end  # for use by rspec
+    # for use by rspec
+    def self._reset
+      @load = nil
+    end
 
     def self.read
-      new(**(YAML.load Pathname.new(CONFIG_FILE).read).symbolize_keys)
+      new(**YAML.safe_load(Pathname.new(CONFIG_FILE).read, [Symbol]).symbolize_keys)
     end
 
     def self.load
-      @config ||= read
+      @load ||= read
     end
 
     def initialize(ruby:, activerecord:, db:, dbversions: nil, exclude: nil, notify: nil, quick: nil)
       @ruby = Array.wrap(ruby).map(&:to_s)
       @activerecord = Array.wrap(activerecord).map(&:to_s)
       @db = Array.wrap(db)
       @dbversions = (dbversions || {}).symbolize_keys
-      @exclude = Array.wrap(exclude).map(&:symbolize_keys).map {|tuple| Tuple.new(**tuple.transform_values(&:to_s))}
+      @exclude = Array.wrap(exclude).map(&:symbolize_keys).map { |tuple| Tuple.new(**tuple.transform_values(&:to_s)) }
       if @activerecord.include?('5.2')
         ruby3 = ::Gem::Version.new('3.0')
 
@@ -35,18 +38,18 @@ def initialize(ruby:, activerecord:, db:, dbversions: nil, exclude: nil, notify:
         end
       end
       unless notify.nil?
-        warn "Notify is no longer supported"
+        warn 'Notify is no longer supported'
       end
-      @quick = Array.wrap(quick || {ruby: @ruby.last, activerecord: @activerecord.last, db: @db.last})
+      @quick = Array.wrap(quick || { ruby: @ruby.last, activerecord: @activerecord.last, db: @db.last })
     end
 
     def dbms
-      @dbms ||= [:postgresql, :mysql].select{|dbm| @db.grep(/^#{dbm}/).any?}
+      @dbms ||= %i[postgresql mysql].select { |dbm| @db.grep(/^#{dbm}/).any? }
     end
 
     DB_VERSION_DEFAULTS = {
       postgresql: ['9.6']
-    }
+    }.freeze
 
     def db_versions_for(db)
       @dbversions.fetch(db.to_sym, DB_VERSION_DEFAULTS.fetch(db.to_sym, [])).map(&:to_s)
@@ -57,9 +60,9 @@ def matrix(quick: false, ruby: nil, activerecord: nil, db: nil, excluded: nil, w
       use_activerecord = @activerecord
       use_db = @db
       if quick
-        use_ruby = @quick.map{|q| q[:ruby]}
-        use_activerecord = @quick.map{|q| q[:activerecord]}
-        use_db = @quick.map{|q| q[:db]}
+        use_ruby = @quick.map { |q| q[:ruby] }
+        use_activerecord = @quick.map { |q| q[:activerecord] }
+        use_db = @quick.map { |q| q[:db] }
       end
       use_ruby = Array.wrap(ruby) if ruby
       use_activerecord = Array.wrap(activerecord) if activerecord
@@ -70,13 +73,13 @@ def matrix(quick: false, ruby: nil, activerecord: nil, db: nil, excluded: nil, w
       use_db = [nil] unless use_db.any?
 
       m = use_ruby.product(use_activerecord, use_db)
-      m = m.flat_map { |_ruby, _activerecord, _db|
-        if with_dbversion && !(dbversions = db_versions_for(_db)).empty?
-          dbversions.map { |v| Tuple.new(ruby: _ruby, activerecord: _activerecord, db: _db, dbversion: v) }
+      m = m.flat_map do |loop_ruby, loop_activerecord, loop_db|
+        if with_dbversion && !(dbversions = db_versions_for(loop_db)).empty?
+          dbversions.map { |v| Tuple.new(ruby: loop_ruby, activerecord: loop_activerecord, db: loop_db, dbversion: v) }
         else
-          [Tuple.new(ruby: _ruby, activerecord: _activerecord, db: _db)]
+          [Tuple.new(ruby: loop_ruby, activerecord: loop_activerecord, db: loop_db)]
         end
-      }.compact
+      end.compact
       m = m.reject { |r| r.match_any?(@exclude) } unless excluded == :none
       m = m.map(&:to_hash)
 
@@ -89,15 +92,16 @@ def matrix(quick: false, ruby: nil, activerecord: nil, db: nil, excluded: nil, w
 
     Tuple = Struct.new(:ruby, :activerecord, :db, :dbversion, keyword_init: true) do
       def match?(other)
-        return false if self.ruby and other.ruby and self.ruby != other.ruby
-        return false if self.activerecord and other.activerecord and self.activerecord != other.activerecord
-        return false if self.db and other.db and self.db != other.db
-        return false if self.dbversion and other.dbversion and self.dbversion != other.dbversion
+        return false if ruby and other.ruby and ruby != other.ruby
+        return false if activerecord and other.activerecord and activerecord != other.activerecord
+        return false if db and other.db and db != other.db
+        return false if dbversion and other.dbversion and dbversion != other.dbversion
+
         true
       end
 
       def match_any?(others)
-        others.any?{|other| self.match? other}
+        others.any? { |other| match? other }
       end
 
       def to_hash

lib/schema_dev/executor.rb

@@ -1,12 +1,13 @@
+# frozen_string_literal: true
+
 require 'json'
 require 'open3'
 
-require_relative "ruby_selector"
-require_relative "gemfile_selector"
+require_relative 'ruby_selector'
+require_relative 'gemfile_selector'
 
 module SchemaDev
   class Executor
-
     attr_reader :ruby, :activerecord, :db, :error
 
     def initialize(ruby:, activerecord:, db:)
@@ -15,20 +16,20 @@ def initialize(ruby:, activerecord:, db:)
     end
 
     def run(cmd, dry_run: false)
-      fullcommand = ["/usr/bin/env", @gemfile_selector, @ruby_selector, cmd].compact.join(' ')
+      fullcommand = ['/usr/bin/env', @gemfile_selector, @ruby_selector, cmd].compact.join(' ')
       puts "* #{fullcommand}"
       return true if dry_run
 
       @error = false
-      Open3.popen2e(fullcommand) do |i, oe, t|
-        oe.each {|line|
+      Open3.popen2e(fullcommand) do |_i, oe, t|
+        oe.each do |line|
           puts line
           @error ||= (line =~ /(^Failed examples)|(rake aborted)|(LoadError)/)
-        }
+        end
         @error ||= !t.value.success?
       end
 
-      return !@error
+      !@error
     end
   end
 end