sorbet-rails 0.7.3 → 0.7.19

data/lib/sorbet-rails/gem_plugins/aasm_plugin.rb

@@ -0,0 +1,50 @@
+# typed: false
+class AasmPlugin < SorbetRails::ModelPlugins::Base
+  sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
+  def generate(root)
+    return unless @model_class.include?(::AASM)
+
+    model_rbi = root.create_class(
+      model_class_name
+    )
+
+    aasm_events = @model_class.aasm.events.map(&:name)
+    aasm_states = @model_class.aasm.states.map(&:name)
+
+    # If you have an event like :bazify, you get these methods:
+    # - `may_bazify?`
+    # - `bazify`
+    # - `bazify!`
+    # - `bazify_without_validation!`
+    aasm_events.each do |event|
+      model_rbi.create_method(
+        "may_#{event}?",
+        return_type: 'T::Boolean'
+      )
+
+      model_rbi.create_method(
+        event.to_s,
+        return_type: 'T::Boolean'
+      )
+
+      model_rbi.create_method(
+        "#{event}!",
+        return_type: 'T::Boolean'
+      )
+
+      model_rbi.create_method(
+        "#{event}_without_validation!",
+        return_type: 'T::Boolean'
+      )
+    end
+
+    # - If you have a state like :baz, you get these methods:
+    # - `baz?`
+    aasm_states.each do |state|
+      model_rbi.create_method(
+        "#{state}?",
+        return_type: 'T::Boolean'
+      )
+    end
+  end
+end

data/lib/sorbet-rails/gem_plugins/attr_json_plugin.rb

@@ -0,0 +1,137 @@
+# typed: false
+class AttrJsonPlugin < SorbetRails::ModelPlugins::Base
+  sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
+  def generate(root)
+    return unless @model_class.include?(::AttrJson::Record)
+
+    # Module for instance methods
+    obj_custom_module_name = self.model_module_name("GeneratedAttrJsonMethods")
+    obj_custom_module_rbi = root.create_module(obj_custom_module_name)
+
+    # Module for class methods
+    klass_custom_module_name = self.model_module_name("GeneratedAttrJsonClassMethods")
+    klass_custom_module_rbi = root.create_module(klass_custom_module_name)
+
+    # here we re-create the model class!
+    model_class_rbi = root.create_class(self.model_class_name)
+    model_class_rbi.create_include(obj_custom_module_name)
+    model_class_rbi.create_extend(klass_custom_module_name)
+
+    # then create custom methods, constants, etc. for this module.
+    add_class_methods(klass_custom_module_rbi)
+
+    @model_class.attr_json_registry.definitions.each do |definition|
+      add_methods_for_attributes(definition, obj_custom_module_rbi)
+    end
+
+    if @model_class.include?(::AttrJson::Record::Dirty)
+      obj_custom_module_rbi.create_method(
+        'attr_json_changes',
+        returns: 'AttrJson::Record::Dirty::Implementation'
+      )
+    end
+  end
+
+  private
+
+  sig { params(custom_module_rbi: Parlour::RbiGenerator::ModuleNamespace).void }
+  def add_class_methods(custom_module_rbi)
+    custom_module_rbi.create_method(
+      'attr_json_config',
+      parameters: [
+        ::Parlour::RbiGenerator::Parameter.new(
+          'new_values',
+          type: 'T.nilable(T::Hash[Symbol, T.untyped])'
+        )
+      ],
+      returns: 'T::Hash[Symbol, T.untyped]'
+    )
+
+    custom_module_rbi.create_method(
+      'attr_json',
+      parameters: [
+        ::Parlour::RbiGenerator::Parameter.new(
+          'name',
+          type: 'T.any(Symbol, String)'
+        ),
+        ::Parlour::RbiGenerator::Parameter.new(
+          'type',
+          type: 'T.any(Symbol, ActiveModel::Type::Value)'
+        ),
+        ::Parlour::RbiGenerator::Parameter.new(
+          '**options',
+          type: 'T.untyped'
+        )
+      ]
+    )
+  end
+
+  sig do
+    params(
+      definition: ::AttrJson::AttributeDefinition,
+      custom_module_rbi: Parlour::RbiGenerator::ModuleNamespace
+    )
+    .void
+  end
+  def add_methods_for_attributes(definition, custom_module_rbi)
+    # set methods can receive an argument of any type because attr_json will try
+    # to parse to the correct type. Example:
+    #
+    # class Post < ApplicationRecord
+    #   ...
+    #   attr_json :my_datetime, :datetime
+    # end
+    #
+    # > p = Post.new
+    # > (p.my_datetime = '2020-02-02').class
+    # => String
+    # > p.my_datetime.class
+    # => Time
+    #
+    # Also, the setter type return is the same as its argument type (before parse).
+    custom_module_rbi.create_method(
+      "#{definition.name}=",
+      parameters: [
+        ::Parlour::RbiGenerator::Parameter.new(
+          'value',
+          type: 'T.untyped'
+        )
+      ],
+      returns: 'T.untyped'
+    )
+
+    definition_type = get_definition_type(definition)
+
+    custom_module_rbi.create_method(
+      definition.name.to_s,
+      returns: definition_type
+    )
+
+    custom_module_rbi.create_method(
+      "#{definition.name}?",
+      returns: 'T::Boolean'
+    )
+  end
+
+  sig { params(definition: ::AttrJson::AttributeDefinition).returns(String) }
+  def get_definition_type(definition)
+
+    if definition.array_type?
+      "T::Array[#{type_to_class(definition.type.base_type.type.to_s)}]"
+    else
+      "T.nilable(#{type_to_class(definition.type.type.to_s)})"
+    end
+  end
+
+  sig { params(type: String).returns(String) }
+  def type_to_class(type)
+    return 'T.untyped' unless type.present?
+
+    case type
+    when 'datetime' then 'Time'
+    when 'decimal' then 'BigDecimal'
+    when 'boolean' then 'T::Boolean'
+    else type.camelize
+    end
+  end
+end

data/lib/sorbet-rails/gem_plugins/flag_shih_tzu_plugin.rb

@@ -0,0 +1,201 @@
+# typed: false
+class FlagShihTzuPlugin < SorbetRails::ModelPlugins::Base
+  sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
+  def generate(root)
+    return unless @model_class.include?(::FlagShihTzu)
+
+    obj_custom_module_name = self.model_module_name("GeneratedFlagShihTzuMethods")
+    obj_custom_module_rbi  = root.create_module(obj_custom_module_name)
+
+    klass_custom_module_name = self.model_module_name("GeneratedFlagShihTzuClassMethods")
+    klass_custom_module_rbi  = root.create_module(klass_custom_module_name)
+
+
+    # here we re-create the model class!
+    model_class_rbi = root.create_class(self.model_class_name)
+    model_class_rbi.create_include(obj_custom_module_name)
+    model_class_rbi.create_extend(klass_custom_module_name)
+
+    # then create custom methods, constants, etc. for this module.
+    add_class_methods(klass_custom_module_rbi)
+
+    if @model_class.flag_columns.present?
+      @model_class
+        .flag_columns
+        .each do |column|
+          add_methods_for_column(column, obj_custom_module_rbi)
+        end
+    end
+
+    if @model_class.flag_mapping.present?
+      @model_class
+        .flag_mapping
+        .each do |column, flags|
+          flags.keys
+            .select { |flag_key| really_has_the_flag?(flag_key) }
+            .each do |flag_key|
+              add_methods_for_flag(column, flag_key, obj_custom_module_rbi)
+            end
+        end
+    end
+  end
+
+  private
+
+  sig { params(custom_module_rbi: Parlour::RbiGenerator::ModuleNamespace).void }
+  def add_class_methods(custom_module_rbi)
+    # https://github.com/pboling/flag_shih_tzu/blob/6a3f1c5f62bd56aa932252eef935826c9674b096/lib/flag_shih_tzu.rb#L12
+    custom_module_rbi.create_method(
+      'flag_options',
+      returns: 'T::Hash[String, T::Hash[Symbol, T.untyped]]'
+    )
+
+    # https://github.com/pboling/flag_shih_tzu/blob/6a3f1c5f62bd56aa932252eef935826c9674b096/lib/flag_shih_tzu.rb#L13
+    custom_module_rbi.create_method(
+      'flag_mapping',
+      returns: 'T::Hash[String, T::Hash[Symbol, Integer]]'
+    )
+
+    # https://github.com/pboling/flag_shih_tzu/blob/6a3f1c5f62bd56aa932252eef935826c9674b096/lib/flag_shih_tzu.rb#L14
+    custom_module_rbi.create_method(
+      'flag_columns',
+      returns: 'T::Array[Symbol]'
+    )
+
+    # https://github.com/pboling/flag_shih_tzu#updating-flag-column-by-raw-sql
+    custom_module_rbi.create_method(
+      'set_flag_sql',
+      parameters: [
+        ::Parlour::RbiGenerator::Parameter.new(
+          'flag',
+          type: 'Symbol'
+        ),
+        ::Parlour::RbiGenerator::Parameter.new(
+          'value',
+          type: 'T::Boolean'
+        ),
+        ::Parlour::RbiGenerator::Parameter.new(
+          'colmn',
+          type: 'T.nilable(String)'
+        ),
+        ::Parlour::RbiGenerator::Parameter.new(
+          'custom_table_name',
+          type: 'T.any(String, Symbol)'
+        )
+      ],
+      returns: 'T::Hash[String, T::Hash[Symbol, T.untyped]]'
+    )
+
+    if @model_class.flag_mapping.present?
+      # https://github.com/pboling/flag_shih_tzu#support-for-manually-building-conditions
+      @model_class
+        .flag_mapping
+        .flat_map { |_, flags| flags.keys }
+        .each do |flag_key|
+          next unless really_has_the_flag?(flag_key)
+
+          custom_module_rbi.create_method(
+            "#{flag_key}_condition",
+            parameters: [
+              ::Parlour::RbiGenerator::Parameter.new(
+                'options',
+                type: 'T.nilable(T::Hash[Symbol, T.untyped])'
+              )
+            ],
+            returns: 'String'
+          )
+
+          custom_module_rbi.create_method(
+            "not_#{flag_key}_condition",
+            parameters: [
+              ::Parlour::RbiGenerator::Parameter.new(
+                'options',
+                type: 'T.nilable(T::Hash[Symbol, T.untyped])'
+              )
+            ],
+            returns: 'String'
+          )
+        end
+    end
+  end
+
+  # https://github.com/pboling/flag_shih_tzu#generated-boolean-patterned-instance-methods
+  sig { params(column: String, custom_module_rbi: Parlour::RbiGenerator::ModuleNamespace).void }
+  def add_methods_for_column(column, custom_module_rbi)
+    custom_module_rbi.create_method(
+      "all_#{column}",
+      returns: 'T::Array[Symbol]'
+    )
+
+    custom_module_rbi.create_method(
+      "selected_#{column}",
+      returns: 'T::Array[Symbol]'
+    )
+
+    custom_module_rbi.create_method(
+      "select_all_#{column}",
+      returns: 'T::Array[Symbol]'
+    )
+
+    custom_module_rbi.create_method(
+      "unselect_all_#{column}",
+      returns: 'T::Array[Symbol]'
+    )
+
+    custom_module_rbi.create_method(
+      "selected_#{column}=",
+      parameters: [
+        ::Parlour::RbiGenerator::Parameter.new(
+          'chosen_flags',
+          type: 'T.nilable(T::Array[Symbol])'
+        )
+      ],
+      returns: 'T::Array[Symbol]'
+    )
+
+  end
+
+  # https://github.com/pboling/flag_shih_tzu#generated-boolean-patterned-instance-methods
+  sig { params(column: String, flag_key: Symbol, custom_module_rbi: Parlour::RbiGenerator::ModuleNamespace).void }
+  def add_methods_for_flag(column, flag_key, custom_module_rbi)
+    custom_module_rbi.create_method(flag_key.to_s, returns: 'T::Boolean')
+    custom_module_rbi.create_method("#{flag_key}?", returns: 'T::Boolean')
+    custom_module_rbi.create_method(
+      "#{flag_key}=",
+      parameters: [
+        ::Parlour::RbiGenerator::Parameter.new(
+          'value',
+          type: 'T::Boolean'
+        )
+      ],
+      returns: 'T::Boolean'
+    )
+
+    custom_module_rbi.create_method("not_#{flag_key}", returns: 'T::Boolean')
+    custom_module_rbi.create_method("not_#{flag_key}?", returns: 'T::Boolean')
+    custom_module_rbi.create_method(
+      "not_#{flag_key}=",
+      parameters: [
+        ::Parlour::RbiGenerator::Parameter.new(
+          'value',
+          type: 'T::Boolean'
+        )
+      ],
+      returns: 'T::Boolean'
+    )
+
+    custom_module_rbi.create_method("#{flag_key}_changed?", returns: 'T::Boolean')
+
+    custom_module_rbi.create_method("has_#{flag_key}?", returns: 'T::Boolean')
+
+    if @model_class.flag_options[column][:bang_methods]
+      custom_module_rbi.create_method("#{flag_key}!", returns: 'T::Boolean')
+      custom_module_rbi.create_method("not_#{flag_key}!", returns: 'T::Boolean')
+    end
+  end
+
+  sig { params(flag_name: Symbol).returns(T::Boolean) }
+  def really_has_the_flag?(flag_name)
+    @model_class.respond_to?("#{flag_name}_condition")
+  end
+end

data/lib/sorbet-rails/gem_plugins/kaminari_plugin.rb

@@ -43,5 +43,25 @@ class KaminariPlugin < SorbetRails::ModelPlugins::Base
       return_type: "Integer",
       class_method: true,
     )
+
+    # https://github.com/kaminari/kaminari/blob/c5186f5d9b7f23299d115408e62047447fd3189d/kaminari-core/lib/kaminari/models/page_scope_methods.rb#L82
+    model_relation_rbi = root.create_class(self.model_relation_class_name)
+    model_relation_rbi.create_method(
+      'last_page?',
+      parameters: nil,
+      return_type: 'T::Boolean',
+    )
+    model_assoc_relation_rbi = root.create_class(self.model_assoc_relation_class_name)
+    model_assoc_relation_rbi.create_method(
+      'last_page?',
+      parameters: nil,
+      return_type: 'T::Boolean',
+    )
+    collection_proxy_rbi = root.create_class(self.model_assoc_proxy_class_name)
+    collection_proxy_rbi.create_method(
+      'last_page?',
+      parameters: nil,
+      return_type: 'T::Boolean',
+    )
   end
 end

data/lib/sorbet-rails/gem_plugins/money_rails_plugin.rb

@@ -0,0 +1,76 @@
+# typed: strict
+class MoneyRailsPlugin < SorbetRails::ModelPlugins::Base
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Boolean) }
+  def allows_nil(attribute)
+    validators = model_class.validators_on(attribute)
+    return false if validators.empty?
+
+    validators.any? do |validator|
+      validator.respond_to?(:options) &&
+        validator.options[:allow_nil]
+    end
+  end
+
+  sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
+  def generate(root)
+    return unless exists_class_method?(:monetize)
+
+    # money-rails gives us a hash mapping the monetized attribute to its subunit
+    # equivalent, eg: `{"price": "price_cents"}`
+    monetized_attributes = T.let(
+      T.unsafe(model_class).monetized_attributes,
+      T::Hash[String,String]
+    )
+
+    return if monetized_attributes.empty?
+
+    module_name = model_module_name("GeneratedMoneyRailsMethods")
+    module_rbi = root.create_module(module_name)
+
+    model_class_rbi = root.create_class(model_class_name)
+    model_class_rbi.create_include(module_name)
+
+    monetized_attributes.each do |name, subunit_name|
+      validators = model_class.validators_on(name)
+
+      money_attribute_type = allows_nil(name) ? "T.nilable(::Money)" : "::Money"
+      subunit_attribute_type = allows_nil(name) ? "T.nilable(Integer)" : "Integer"
+
+      module_rbi.create_method(
+        name,
+        return_type: money_attribute_type
+      )
+
+      module_rbi.create_method(
+        subunit_name,
+        return_type: subunit_attribute_type
+      )
+
+      module_rbi.create_method(
+        "#{name}_money_before_type_cast",
+        return_type: 'T.untyped'
+      )
+
+      module_rbi.create_method(
+        "#{name}=",
+        parameters:  [
+           Parlour::RbiGenerator::Parameter.new("value", type: money_attribute_type)
+        ],
+        return_type: nil
+      )
+
+      module_rbi.create_method(
+        "#{subunit_name}=",
+        parameters:  [
+           Parlour::RbiGenerator::Parameter.new("value", type: subunit_attribute_type)
+        ],
+        return_type: nil
+      )
+
+      module_rbi.create_method(
+        "currency_for_#{name}",
+        return_type: "T.nilable(::Money::Currency)"
+      )
+    end
+  end
+end

data/lib/sorbet-rails/gem_plugins/shrine_plugin.rb

@@ -45,7 +45,7 @@ class ShrinePlugin < SorbetRails::ModelPlugins::Base
             parameters: [
               ::Parlour::RbiGenerator::Parameter.new(
                 "url",
-                type: T.untyped # TODO likely T.nilable(String)
+                type: "T.untyped" # TODO likely T.nilable(String)
               ),
             ],
           )

data/lib/sorbet-rails/job_rbi_formatter.rb

@@ -80,7 +80,7 @@ module SorbetRails
 
     sig { returns(String) }
     def generate_rbi
-      puts "-- Generate sigs for mailer #{@job_class.name} --"
+      puts "-- Generate sigs for ActiveJob #{@job_class.name} --"
       populate_rbi
       @rbi_generator.rbi
     end

data/lib/sorbet-rails/model_plugins/active_record_serialized_attribute.rb

@@ -60,9 +60,10 @@ class SorbetRails::ModelPlugins::ActiveRecordSerializedAttribute < SorbetRails::
       # ActiveSupport::JSON.encode/ActiveSupport::JSON.decode
       # note that Hash keys are Strings since this is JSON
       'T.any(T::Array[T.untyped], T::Boolean, Float, T::Hash[String, T.untyped], Integer, String)'
-    else
-      # unknown uses YAML.load/YAML.dump
+    when 'Object', ''
       'T.any(T::Array[T.untyped], T::Boolean, Float, T::Hash[T.untyped, T.untyped], Integer, String)'
+    else
+      serialization_coder.to_s
     end
   end
 end

data/lib/sorbet-rails/model_plugins/base.rb

@@ -35,7 +35,14 @@ module SorbetRails::ModelPlugins
       column_type = @model_class.type_for_attribute(column_name)
       return unless column_type.is_a?(ActiveRecord::Type::Serialized)
 
-      column_type.coder.try(:object_class) || Object
+      object_class = column_type.coder.try(:object_class)
+      if object_class
+        object_class
+      elsif column_type.coder.is_a? Class
+        column_type.coder
+      else
+        Object
+      end
     end
   end
 end

data/lib/sorbet-rails/model_plugins/custom_finder_methods.rb

@@ -39,7 +39,7 @@ class SorbetRails::ModelPlugins::CustomFinderMethods < SorbetRails::ModelPlugins
     # allow common cases find_by_id
     custom_module_rbi.create_method(
       "find_by_id",
-      parameters: [ Parameter.new("id", type: "Integer") ],
+      parameters: [ Parameter.new("id", type: "T.nilable(Integer)") ],
       return_type: "T.nilable(#{self.model_class_name})",
     )
     custom_module_rbi.create_method(

data/lib/sorbet-rails/model_plugins/plugins.rb

@@ -81,6 +81,18 @@ module SorbetRails::ModelPlugins
     when :paperclip
       require('sorbet-rails/gem_plugins/paperclip_plugin')
       PaperclipPlugin
+    when :attr_json
+      require('sorbet-rails/gem_plugins/attr_json_plugin')
+      AttrJsonPlugin
+    when :flag_shih_tzu
+      require('sorbet-rails/gem_plugins/flag_shih_tzu_plugin')
+      FlagShihTzuPlugin
+    when :aasm
+      require('sorbet-rails/gem_plugins/aasm_plugin')
+      AasmPlugin
+    when :money_rails
+      require('sorbet-rails/gem_plugins/money_rails_plugin')
+      MoneyRailsPlugin
     else
       raise UnrecognizedPluginName.new(
         "Unrecognized plugin with name: #{plugin_name}. Please check available plugins in the

data/lib/sorbet-rails/railtie.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: false
 require "rails"
 require "sorbet-runtime"
 require "sorbet-rails/config"

data/lib/sorbet-rails/routes_rbi_formatter.rb

@@ -39,6 +39,14 @@ class SorbetRails::RoutesRbiFormatter
     @parlour.root.create_class('ActionMailer::Base') do |mod|
       mod.create_include('GeneratedUrlHelpers')
     end
+
+    @parlour.root.create_class('ActionDispatch::IntegrationTest') do |mod|
+      mod.create_include('GeneratedUrlHelpers')
+    end
+
+    @parlour.root.create_class('ActionDispatch::SystemTestCase') do |mod|
+      mod.create_include('GeneratedUrlHelpers')
+    end
   end
 
   sig { params(routes: T.untyped, filter: T.untyped).void }

data/lib/sorbet-rails/tasks/rails_rbi.rake

@@ -16,12 +16,12 @@ namespace :rails_rbi do
     FileUtils.rm_rf(rails_rbi_root_path)
 
     # run all rake tasks
-    Rake::Task['rails_rbi:routes'].invoke
-    Rake::Task['rails_rbi:models'].invoke
-    Rake::Task['rails_rbi:helpers'].invoke
-    Rake::Task['rails_rbi:mailers'].invoke
-    Rake::Task['rails_rbi:jobs'].invoke
-    Rake::Task['rails_rbi:custom'].invoke
+    Rake::Task[rails_rbi_task_name(t, 'routes')].invoke
+    Rake::Task[rails_rbi_task_name(t, 'models')].invoke
+    Rake::Task[rails_rbi_task_name(t, 'helpers')].invoke
+    Rake::Task[rails_rbi_task_name(t, 'mailers')].invoke
+    Rake::Task[rails_rbi_task_name(t, 'jobs')].invoke
+    Rake::Task[rails_rbi_task_name(t, 'custom')].invoke
   end
 
   desc "Generate rbis for rails routes"
@@ -36,7 +36,7 @@ namespace :rails_rbi do
   end
 
   desc "Copy custom rbis for typed_params, pluck_to_struct, etc."
-  task custom: :environment do
+  task custom: :environment do |t, args|
     copy_bundled_rbi('type_assert.rbi')
     copy_bundled_rbi('pluck_to_tstruct.rbi')
     copy_bundled_rbi('typed_params.rbi')
@@ -44,7 +44,7 @@ namespace :rails_rbi do
 
     # These files were previously bundled_rbi but are now generated so this
     # is needed for backwards compatibility with anyone using `rails_rbi:custom`
-    Rake::Task['rails_rbi:active_record'].invoke
+    Rake::Task[rails_rbi_task_name(t, 'active_record')].invoke
   end
 
   desc "Generate rbis for rails active_record base"
@@ -182,4 +182,8 @@ namespace :rails_rbi do
     FileUtils.mkdir_p(File.dirname(copy_to_path))
     FileUtils.cp(bundled_rbi_file_path, copy_to_path)
   end
+
+  def rails_rbi_task_name(current_task, target_task_suffix)
+    current_task.to_s.sub(/\w+$/, target_task_suffix)
+  end
 end

data/sorbet-rails.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name          = %q{sorbet-rails}
-  s.version       = "0.7.3"
+  s.version       = "0.7.#{ENV['GITHUB_RUN_NUMBER']}".strip
   s.date          = %q{2019-04-18}
   s.summary       = %q{Set of tools to make Sorbet work with Rails seamlessly.}
   s.authors       = ["Chan Zuckerberg Initiative"]
@@ -25,7 +25,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rspec', '~> 3.8', '>= 3.8'
   # Debugging
   s.add_development_dependency 'awesome_print', '~>1.8.0', '>=1.8.0'
-  s.add_development_dependency 'byebug', '~>11.0.1', '>=11.0.1'
+  s.add_development_dependency 'byebug', '~>11.1.3', '>=11.1.3'
 
   # for testing a gem with a rails app (controller specs)
   s.add_development_dependency 'rspec-rails', '>=3.8.2'

data/spec/bin/run_all_specs.sh

@@ -3,9 +3,8 @@
 
 wd="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 
-RAILS_VERSION=5.0 bash $wd/run_spec.sh
-RAILS_VERSION=5.1 bash $wd/run_spec.sh
-RAILS_VERSION=6.0 bash $wd/run_spec.sh
+RAILS_VERSION=5.2 bash $wd/run_spec.sh
+RAILS_VERSION=6.1 bash $wd/run_spec.sh
 
-# Always end with the default version, which is Rails 5.2
+# Always end with the default version, which is Rails 6.0
 bash $wd/run_spec.sh