schema_dev 3.13.0 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90ab78fd21ab9a8ae12692239c87be54a75f5f8c50389059810909e3d215f8d4
-  data.tar.gz: 34c994d368566f17cfe8956a7823bd0f386d913ae36298e59c32465825b1f848
+  metadata.gz: ec4c4b34d4c065f5027f7b4edf76af56b328d10194ba6e4b6ec13d6b0ffdc4bf
+  data.tar.gz: dc39ed695a1fa9df914cbaa0aa4163d4bade79237e80ab306238bee5605755d2
 SHA512:
-  metadata.gz: acc82f9f47a8325b17219c20a91930a9650e1259ae133b9fb20449151b5134ff3074401405ec9274be7f7826e66cca8030031b66cbb90f496b2c5bb31e52d5e4
-  data.tar.gz: ffe5d72d51599a4656c1cc58a5daecf8ba8363d055ed0cdc297e7cec531d228651aaac46e89c60b7caf5ac8effcc39effd7972d4608fe1f395fe839dd0f24fd3
+  metadata.gz: af15e3126328563021a8662d2a0c9180f6978a6095de9471ac2627bfbb0cf64ba47773f48f3c3c4fe21f1871511b0c249c83a9f87801651b1fef7fd367647bf3
+  data.tar.gz: 4f2d82816b77a658f41d5afb34f8f9f4401a58a739f1b1fc05ddc1a3b5d8ef304613363f30a2d3ed14da17cf15fb991d5febf5bb5c3ae4b0ad28cc568977058c

data/.github/workflows/prs.yml

@@ -0,0 +1,49 @@
+name: CI PR Builds
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+
+concurrency:
+  group: ${{ github.head_ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby-version: ['2.5', '2.6', '2.7', '3.0']
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true
+
+      - name: 'Run bundle update'
+        run: bundle update
+
+      - name: Run tests
+        run: bundle exec rake spec
+
+      - name: Coveralls Parallel
+        uses: coverallsapp/github-action@master
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          flag-name: run-${{ matrix.ruby-version }}
+          parallel: true
+  finish:
+    needs: 'test'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Coveralls Finished
+        uses: coverallsapp/github-action@master
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          parallel-finished: true

data/.simplecov

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+SimpleCov.configure do
+  enable_coverage :branch
+  add_filter '/spec/'
+
+  add_group 'Binaries', '/bin/'
+  add_group 'Libraries', '/lib/'
+
+  if ENV['CI']
+    require 'simplecov-lcov'
+
+    SimpleCov::Formatter::LcovFormatter.config do |c|
+      c.report_with_single_file = true
+      c.single_report_path = 'coverage/lcov.info'
+    end
+
+    formatter SimpleCov::Formatter::LcovFormatter
+  end
+end

data/Gemfile

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

data/README.md

@@ -1,13 +1,12 @@
 # SchemaDev
 
 [![Gem Version](https://badge.fury.io/rb/schema_dev.svg)](http://badge.fury.io/rb/schema_dev)
-[![Build Status](https://secure.travis-ci.org/SchemaPlus/schema_dev.svg)](http://travis-ci.org/SchemaPlus/schema_dev)
+[![Build Status](https://github.com/SchemaPlus/schema_dev/actions/workflows/prs.yml/badge.svg)](https://github.com/SchemaPlus/schema_dev/actions)
 [![Coverage Status](https://img.shields.io/coveralls/SchemaPlus/schema_dev.svg)](https://coveralls.io/r/SchemaPlus/schema_dev)
-[![Dependency Status](https://gemnasium.com/SchemaPlus/schema_dev.svg)](https://gemnasium.com/SchemaPlus/schema_dev)
 
 Development tools for the SchemaPlus family of gems.
 
-Provides support for working with multiple ruby versions, ActiveRecord, and db versions.  In particular provides a command `schema_dev` for running rspec (or whatever) on the matrix or  a slice or element of it.  It also auto-generates the `.travis.yml` file for [travis-ci](https://travis-ci.org) testing.
+Provides support for working with multiple ruby versions, ActiveRecord, and db versions.  In particular provides a command `schema_dev` for running rspec (or whatever) on the matrix or  a slice or element of it.  It also auto-generates the `.github/workflows/prs.yml` file for [github actions](https://docs.github.com/en/actions) testing.
 
 ## Creating a new gem for the SchemaPlus family
 
@@ -71,14 +70,14 @@ For interactive debugging you may want to run rspec directly from the shell rath
 
 	$ schema_dev rspec --quick -- -e 'select which spec' -n
 
-	*** ruby 2.7.3 - activerecord 5.2 - db postgresql [1 of 1]
+	*** ruby 2.7.4 - activerecord 5.2 - db postgresql [1 of 1]
 
-	* /usr/bin/env BUNDLE_GEMFILE=gemfiles/activerecord-4.2/Gemfile.postgresql SHELL=`which bash` chruby-exec ruby-2.1.5 -- bundle exec rspec -e select\ which\ spec
+	* /usr/bin/env BUNDLE_GEMFILE=gemfiles/activerecord-4.2/Gemfile.postgresql SHELL=`which bash` chruby-exec ruby-2.7.4 -- bundle exec rspec -e select\ which\ spec
 
 
 There's no hidden environment setup; so you can copy and paste the command line into a shell:
 
-	$ /usr/bin/env BUNDLE_GEMFILE=gemfiles/activerecord-4.2/Gemfile.postgresql SHELL=`which bash` chruby-exec ruby-2.1.5 -- bundle exec rspec -e select\ which\ spec
+	$ /usr/bin/env BUNDLE_GEMFILE=gemfiles/activerecord-4.2/Gemfile.postgresql SHELL=`which bash` chruby-exec ruby-2.7.4 -- bundle exec rspec -e select\ which\ spec
 
 	
 For more info, see
@@ -99,9 +98,9 @@ Note that freshening the gemfiles happens automatically whenever you run a schem
 
 If you need to include extra specifications in the Gemfile (e.g. to specify a path for a gem), you can create a file `Gemfile.local` in the project root, and its contents will be included in the Gemfile.
 
-### .travis.yml
+### .github/workflows/prs.yml
 
-The `.travis.yml` file gets created automatically.  Don't edit it by hand.
+The `.github/workflows/prs.yml` file gets created automatically.  Don't edit it by hand.
 
 ### README.md
 
@@ -131,12 +130,15 @@ The client gem's `Rakefile` includes:
 
     require 'schema_dev/tasks'
 
-Which defines the rake task `create_databases` and also a task for travis-ci
+Which defines the rake task `create_databases` and also a task for github actions
 
-## Relase Notes
+## Release Notes
 
 Release notes for schema_dev versions:
 
+* **4.1.0** - Switch to GitHub actions instead of travis CI
+* **4.0.0** - Drop support for AR < 5.2 and add AR 6.0 and 6.1
+* **3.13.1** - Adjust travis.yml generation to work with mysql again
 * **3.13.0** - Change coveralls gem and test against newer ruby versions
 * **3.12.1** - fix simple case when only one postgresql version
 * **3.12.0** - support testing against multiple postgresql versions

data/Rakefile

@@ -1,8 +1,6 @@
-require "bundler/gem_tasks"
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
 
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
-
-require 'coveralls/rake/task'
-Coveralls::RakeTask.new
-task :travis => [:spec, 'coveralls:push']

data/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: .travis, 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

data/lib/schema_dev/config.rb

@@ -1,94 +1,112 @@
+# frozen_string_literal: true
+
 require 'active_support/core_ext/hash'
-require 'enumerator'
-require 'fastandand'
-require 'its-it'
-require 'key_struct'
 require 'pathname'
 require 'yaml'
-require 'hash_keyword_args'
+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
 
-    attr_accessor :quick, :db, :dbversions, :ruby, :activerecord, :notify, :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(opts={}) # once we no longer support ruby 1.9.3, can switch to native keyword args
-      opts = opts.keyword_args(ruby: :required, activerecord: :required, db: :required, dbversions: nil, exclude: nil, notify: nil, quick: nil)
-      @ruby = Array.wrap(opts.ruby)
-      @activerecord = Array.wrap(opts.activerecord)
-      @db = Array.wrap(opts.db)
-      @dbversions = (opts.dbversions || {}).symbolize_keys
-      @exclude = Array.wrap(opts.exclude).map(&:symbolize_keys).map {|tuple| Tuple.new(tuple)}
-      @notify = Array.wrap(opts.notify)
-      @quick = Array.wrap(opts.quick || {ruby: @ruby.last, activerecord: @activerecord.last, db: @db.last})
+    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)) }
+      if @activerecord.include?('5.2')
+        ruby3 = ::Gem::Version.new('3.0')
+
+        @ruby.select { |e| ::Gem::Version.new(e) >= ruby3 }.each do |v|
+          @exclude << Tuple.new(ruby: v, activerecord: '5.2')
+        end
+      end
+      unless notify.nil?
+        warn 'Notify is no longer supported'
+      end
+      @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
 
-    def dbms_versions_for(db, default = [])
-      @dbversions.fetch(db, default)
+    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)
     end
 
-    def matrix(opts={}) # once we no longer support ruby 1.9.3, can switch to native keyword args
-      opts = opts.keyword_args(quick: false, ruby: nil, activerecord: nil, db: nil, excluded: nil)
+    def matrix(quick: false, ruby: nil, activerecord: nil, db: nil, excluded: nil, with_dbversion: false)
       use_ruby = @ruby
       use_activerecord = @activerecord
       use_db = @db
-      if opts.quick
-        use_ruby = @quick.map{|q| q[:ruby]}
-        use_activerecord = @quick.map{|q| q[:activerecord]}
-        use_db = @quick.map{|q| q[:db]}
+      if quick
+        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(opts.ruby) if opts.ruby
-      use_activerecord = Array.wrap(opts.activerecord) if opts.activerecord
-      use_db = Array.wrap(opts.db) if opts.db
+      use_ruby = Array.wrap(ruby) if ruby
+      use_activerecord = Array.wrap(activerecord) if activerecord
+      use_db = Array.wrap(db) if db
 
       use_ruby = [nil] unless use_ruby.any?
       use_activerecord = [nil] unless use_activerecord.any?
       use_db = [nil] unless use_db.any?
 
       m = use_ruby.product(use_activerecord, use_db)
-      m = m.map { |_ruby, _activerecord, _db| Tuple.new(ruby: _ruby, activerecord: _activerecord, db: _db) }.compact
-      m = m.reject(&it.match_any?(@exclude)) unless opts.excluded == :none
+      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: loop_ruby, activerecord: loop_activerecord, db: loop_db)]
+        end
+      end.compact
+      m = m.reject { |r| r.match_any?(@exclude) } unless excluded == :none
       m = m.map(&:to_hash)
 
-      if opts.excluded == :only
-        return matrix(opts.merge(excluded: :none)) - m
+      if excluded == :only
+        matrix(quick: quick, ruby: ruby, activerecord: activerecord, db: db, with_dbversion: with_dbversion, excluded: :none) - m
       else
-        return m
+        m
       end
     end
 
-    class Tuple < KeyStruct[:ruby, :activerecord, :db]
+    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 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
-        super.reject{ |k, val| val.nil? }
+        to_h.compact.transform_values(&:to_s)
       end
     end
-
   end
 end

data/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 @@ module SchemaDev
     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

data/lib/schema_dev/gem.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'faraday'
 require 'json'
 require 'fileutils'
@@ -15,7 +17,7 @@ module SchemaDev
 
     attr_accessor :gem_name, :gem_module, :gem_root, :gem_parent_name, :gem_base_name, :gem_lib_path, :fullname, :email
 
-    class TemplateEnv 
+    class TemplateEnv
       extend Forwardable
 
       def_delegators :@gem, :gem_name, :gem_module, :gem_root, :gem_parent_name, :gem_base_name, :gem_lib_path, :fullname, :email
@@ -33,27 +35,28 @@ module SchemaDev
       end
 
       def year
-        Time.now.strftime("%Y")
+        Time.now.strftime('%Y')
       end
 
       def get_binding
         binding
       end
-      
+
       def self.schema_plus_core_version
-        @core_version ||= begin
-                            gems = JSON.parse Faraday.get('https://rubygems.org/api/v1/versions/schema_plus_core.json').body
-                            gems.reject(&it["prerelease"]).sort_by(&it["number"].split('.')).last["number"]
-                          end
+        @schema_plus_core_version ||=
+          begin
+            gems = JSON.parse Faraday.get('https://rubygems.org/api/v1/versions/schema_plus_core.json').body
+            last = gems.reject { |e| e['prerelease'] }.max_by { |e| e['number'].split('.') }
+            last['number']
+          end
       end
 
-      def _dependency(v)
-        major, minor, patch = v.split('.')
-        dep = %Q{"~> #{major}.#{minor}"}
-        dep += %Q{, ">= #{v}"} if patch != "0"
+      def _dependency(version)
+        major, minor, patch = version.split('.')
+        dep = %('~> #{major}.#{minor}')
+        dep += %(, '>= #{version}') if patch != '0'
         dep
       end
-        
     end
 
     def initialize(name)
@@ -79,20 +82,20 @@ module SchemaDev
       ensure_not_in_git
       ensure_doesnt_exist
       copy_template
-      self.gem_root = self.gem_root.realpath
+      self.gem_root = gem_root.realpath
       rename_files
       fixup_subdir if @subdir
       freshen
       git_init
-      puts <<-END.strip_heredoc
+      puts <<~TEXT
 
-         Created #{gem_name}.  Your recommended next steps are:
+        Created #{gem_name}.  Your recommended next steps are:
 
-                $ cd #{gem_name}
-                $ bundle install
-                $ schema_dev bundle install
-                $ schema_dev rspec
-      END
+               $ cd #{gem_name}
+               $ bundle install
+               $ schema_dev bundle install
+               $ schema_dev rspec
+      TEXT
     end
 
     def die(msg)
@@ -100,8 +103,8 @@ module SchemaDev
     end
 
     def ensure_not_in_git
-      if system("git rev-parse >& /dev/null")
-        die "Cannot create new gem inside existing git worktree; please cd elsewhere"
+      if system('git rev-parse >& /dev/null')
+        die 'Cannot create new gem inside existing git worktree; please cd elsewhere'
       end
     end
 
@@ -112,42 +115,43 @@ module SchemaDev
     end
 
     def get_fullname_and_email
-      {'fullname' => 'name', 'email' => 'email' }.each do |myattr, gitattr|
-        if (self.send myattr+"=", `git config user.#{gitattr}`.strip).blank?
+      { 'fullname' => 'name', 'email' => 'email' }.each do |myattr, gitattr|
+        if (send myattr + '=', `git config user.#{gitattr}`.strip).blank?
           die "Who are you?  Please run 'git config --global user.#{gitattr} <your-#{gitattr}>'"
         end
       end
     end
 
     def copy_template
-      Templates.install_subtree src: "gem", dst: gem_root, bound: template_binding
+      Templates.install_subtree src: 'gem', dst: gem_root, bound: template_binding
     end
 
     def rename_files
-      (gem_root + "gitignore").rename gem_root + ".gitignore"
-      Dir.glob(gem_root + "**/*GEM_NAME*").each do |path|
+      (gem_root + 'gitignore').rename gem_root + '.gitignore'
+      (gem_root + 'simplecov').rename gem_root + '.simplecov'
+      Dir.glob(gem_root + '**/*GEM_NAME*').each do |path|
         FileUtils.mv path, path.gsub(/GEM_NAME/, gem_name)
       end
-      Dir.glob(gem_root + "**/*GEM_BASE_NAME*").each do |path|
+      Dir.glob(gem_root + '**/*GEM_BASE_NAME*').each do |path|
         FileUtils.mv path, path.gsub(/GEM_BASE_NAME/, gem_base_name)
       end
     end
 
     def fixup_subdir
-      libdir = gem_root + "lib"
-      aside = libdir.to_s + "x"
+      libdir = gem_root + 'lib'
+      aside = libdir.to_s + 'x'
       subdir = libdir + gem_parent_name
 
       FileUtils.mv libdir, aside
       libdir.mkpath
       FileUtils.mv aside, subdir
-      (gem_root + "lib" + "#{gem_name}.rb").write <<-END.lstrip
+      (gem_root + 'lib' + "#{gem_name}.rb").write <<~RUBY
         require_relative '#{gem_parent_name}/#{gem_base_name}'
-      END
+      RUBY
     end
 
-    def erb(s)
-      ERB.new(s).result template_binding
+    def erb(string)
+      ERB.new(string).result template_binding
     end
 
     def template_binding
@@ -156,14 +160,18 @@ module SchemaDev
 
     def freshen
       Dir.chdir gem_root do
-        Runner.new(Config.read).freshen(quiet:true)
+        Runner.new(Config.read).freshen(quiet: true)
       end
     end
 
     def git_init
       Dir.chdir gem_name do
-        system "git init"
-        system "git add #{gem_root.find.select(&:exist?).reject(&it.basename.to_s == 'Gemfile.local').join(' ')}"
+        system 'git init'
+        add_param = gem_root.find
+                            .select(&:exist?)
+                            .reject { |e| e.basename.to_s == 'Gemfile.local' }
+                            .join(' ')
+        system "git add #{add_param}"
         system "git commit -m 'Initial skeleton generated by `schema_dev gem #{gem_name}`'"
       end
     end

data/lib/schema_dev/gemfile_selector.rb

@@ -1,19 +1,19 @@
+# frozen_string_literal: true
+
 require 'pathname'
 
 module SchemaDev
-  GEMFILES_DIR = "gemfiles"
+  GEMFILES_DIR = 'gemfiles'
 
   module GemfileSelector
     extend self
 
-    def gemfile(opts = {})
-      opts = opts.keyword_args(activerecord: :required, db: :required)
-      Pathname.new(GEMFILES_DIR).join("activerecord-#{opts.activerecord}", "Gemfile.#{opts.db}")
+    def gemfile(activerecord:, db:)
+      Pathname.new(GEMFILES_DIR).join("activerecord-#{activerecord}", "Gemfile.#{db}")
     end
 
-    def command(opts={})
-      opts = opts.keyword_args(activerecord: :required, db: :required)
-      "BUNDLE_GEMFILE=#{gemfile(activerecord: opts.activerecord, db: opts.db)}"
+    def command(activerecord:, db:)
+      "BUNDLE_GEMFILE=#{gemfile(activerecord: activerecord, db: db)}"
     end
 
     def infer_db