sorbet-rails 0.5.6 → 0.5.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94d5e7839ac88952e888bdde9ac9ee2c838c7833732a9e5f3af80c2eaf29b62c
-  data.tar.gz: 74d8006e67f5283ba3f8dbdbefc347a49284c31307ad4cbc9a4e5a9986de80a6
+  metadata.gz: c8a83533dd2f5cd4cd6dc60f015808792494c7826240edd37c04e8de10aa4089
+  data.tar.gz: 9162300d63a55b865a901d55a2e76261ebf64ac003fae61d1904c8656c37b879
 SHA512:
-  metadata.gz: 734626fabb0cd9761597f102b4b626a09c4f6f15663abb776fcdadf044851e4f08cfb7da2e125c1109a115037a79192b16bc9f69f989a789b8c57d55835da8ee
-  data.tar.gz: 9d6dff417e3a1c160055b6880117a333efa0f3a3d6ff4ec8d0d9dce0b9298130857ed97a2e0e9e7d149019dd51b38a349b02302818fa57c47fec06eb8e28e6ab
+  metadata.gz: 21c050153045a1d5dab06bea09e8e571fbf598b073f53d9da34f42bd446dd79b43d67076f8f686e1e534306797253763bee825c0ec3d28dbcc0bc0bba86247be
+  data.tar.gz: a25bdfdfa28cab5ea91233ae34ae116005f9a7b99481892851a4af74d70ffee75dfba2618bb91f557b07fe97ef5335b4072f2d8fbe678e5afb644183b02d450d

data/.gitignore

@@ -95,3 +95,5 @@ build-iPhoneSimulator/
 
 lib/sorbet/rbi/hidden-definitions/errors.txt
 .vscode
+
+.rake_tasks~

data/.travis.yml

@@ -1,7 +1,6 @@
 language: ruby
 env:
   matrix:
-  - RAILS_VERSION=4.2
   - RAILS_VERSION=5.0
   - RAILS_VERSION=5.1
   - RAILS_VERSION=5.2
@@ -28,7 +27,6 @@ matrix:
 before_install:
 - gem install bundler -v 2.0.1 --no-doc
 - gem install bundler -v 1.17.3 --no-doc
-install: "./spec/bin/install.sh"
 script:
 - (cd lib && bundle exec srb tc)
 - "./spec/bin/run_spec.sh"

data/CONTRIBUTING.md

@@ -87,7 +87,6 @@ To run the tests against all supported Rails branches, use:
 You can also switch to a version of Rails with `RAILS_VERSION`:
 
 ```sh
-❯ RAILS_VERSION=4.2 ./spec/bin/run_spec.sh
 ❯ RAILS_VERSION=5.0 ./spec/bin/run_spec.sh
 ❯ RAILS_VERSION=5.1 ./spec/bin/run_spec.sh
 ❯ RAILS_VERSION=5.2 ./spec/bin/run_spec.sh
@@ -124,9 +123,8 @@ copied into each app with `cp`.
 The `rails-template.rb` file uses the
 [Rails Application Template](https://guides.rubyonrails.org/rails_application_templates.html)
 functionality included in Rails. You can then regenerate each Rails app from
-the same file using `bundle _1.17.3_ exec rake update_spec:v4_2`, `bundle exec rake update_spec:v5_0`,
-`bundle exec rake update_spec:v5_1`, etc. (or just `bundle exec rake update_spec:v5_plus`,
-though this excludes regenerating 4.2 because 4.2 blocks usage of Bundler 2.x).
+the same file using `bundle exec rake update_spec:v5_0`,
+`bundle exec rake update_spec:v5_1`, etc. (or just `bundle exec rake update_spec:all`.
 
 #### Expected Output
 

data/Gemfile

@@ -13,10 +13,6 @@ case rails_version
 when "master"
   gem "rails", {github: "rails/rails"}
   gem "bundler", ">= 1.3.0"
-when "4.2"
-  gem "rails", "~> 4.2.11"
-  gem "bundler", "~> 1.17.3"
-  gem "sqlite3", "~> 1.3.6"
 when "5.0"
   gem "rails", "~> 5.0.7"
   gem "bundler", ">= 2.0"

data/README.md

@@ -27,13 +27,15 @@ gem 'sorbet-rails'
 ❯ bundle install
 ```
 
+Warning: *don't* add `sorbet-rails` to a specific environment group (eg. `development` only). `sorbet-rails` adds a bunch of helper methods to your Rails runtime as well as generators for RBI files. You'll want to run the gem in all environments.
+
 3. Generate RBI files for your routes, models, etc
 ```sh
 ❯ rake rails_rbi:routes
 ❯ rake rails_rbi:models
 ❯ rake rails_rbi:helpers
 ❯ rake rails_rbi:mailers
-❯ rake rails_rbi:params
+❯ rake rails_rbi:custom
 
 # or run them all at once
 ❯ rake rails_rbi:all
@@ -54,7 +56,7 @@ This Rake task generates RBI files for all models in the Rails application (all
 ```sh
 ❯ rake rails_rbi:models
 ```
-You can also regenerate RBI files for specific models:
+You can also regenerate RBI files for specific models. To accommodate for STI, this will generate rbi for all the subclasses of the models included.
 ```sh
 ❯ rake rails_rbi:models[ModelName,AnotherOne,...]
 ```
@@ -68,15 +70,19 @@ The generation task currently creates the following signatures:
 
 It is possible to add custom RBI generation logic for your custom module or gems via the plugin system. Check out the [plugins section](#extending-model-generation-task-with-custom-plugins) below if you are interested.
 
+We also add following methods to make type-checking more easily:
+- [`find_n`, `first_n`, `last_n`](https://github.com/chanzuckerberg/sorbet-rails#find-first-and-last)
+- [`pluck_to_tstruct`](#pluck_to_tstruct-instead-of-pluck)
+
 ### Controllers
 ```sh
-❯ rake rails_rbi:params
+❯ rake rails_rbi:custom
 ```
 
 `sorbet-rails` adds methods to extract typed parameters from `params`, namely `require_typed` and `fetch_typed`. They are direct replacement of `require` and `fetch` that return typed object. They have the same API their counterpart, with an addition of the parameter's type, which can be any type understood by `sorbet`
 
 This is the conversion in essence:
-```
+```ruby
 params.require(:key)              -> params.require_typed(:key, TA[Type].new)
 params.fetch(:key)                -> params.fetch_typed(:key, TA[Type].new)
 params.fetch(:key, default_value) -> params.fetch_typed(:key, TA[Type].new, default_value)
@@ -84,7 +90,7 @@ params[:key]                      -> params.fetch_typed(:key, TA[T.nilable(Type)
 ```
 
 For example:
-```
+```ruby
 # require_typed
 key = params.require_typed(:key, TA[String].new)
 T.reveal_type(key) # String
@@ -230,6 +236,30 @@ with:
 Model.unscoped.scoping do … end
 ```
 
+### `select` with a block
+
+The [`select` method](https://apidock.com/rails/v4.0.2/ActiveRecord/QueryMethods/select) in Rails has two modes: it can be given a list of symbols, in which case rails will only return the given columns from the database, or it can be given a block, in which case it acts like [`Enumerable.select`](https://ruby-doc.org/core-2.6.4/Enumerable.html) and returns an array. We have chosen to support the first use case. If you want to pass a block to `select`, you can simply call `to_a` before you do. Note that this would be done within the `select` call anyway, so the performance penalty will be minimal.
+
+### `pluck_to_tstruct` instead of `pluck`
+
+The [`pluck` method](https://apidock.com/rails/ActiveRecord/Calculations/pluck) in Rails is a performant way to query value without instantiating ActiveRecord objects. However, it doesn't have any type information: it doesn't have type information (or name) of the attribute plucked. Sorbet-rails provides `pluck_to_tstruct` method as a replacement that does the same thing, but creates `T::Struct` object instead, and returns an array of `T::Struct`. The attributes plucked is based on props defined in the `T::Struct`
+
+```ruby
+# -- API
+Arel.pluck_to_tstruct(TA[ <TStructSubClass> ].new)
+
+# -- example
+class WizardStruct < T::Struct
+  const :name, String
+  const :house, T.nilable(String)
+end
+
+Wizard.pluck_to_tstruct(TA[WizardStruct].new)  # T::Array[WizardStruct]
+Wizard.all.pluck_to_tstruct(TA[WizardStruct].new)  # T::Array[WizardStruct]
+```
+
+This method is based on [pluck_to_hash](https://github.com/girishso/pluck_to_hash) gem.
+
 ## Extending Model Generation Task with Custom Plugins
 
 `sorbet-rails` support a customizable plugin system that you can use to generate additional RBI for each model. This will be useful to generate RBI for methods dynamically added by gems or private concerns. If you write plugins for public gems, please feel free to contribute it to this repo.
@@ -307,16 +337,20 @@ These are the currently-supported gems and their symbolized names:
 
 | Gem          | Symbol         |
 |--------------|----------------|
+| [ElasticSearch]| `:elastic_search` |
+| [FriendlyId] | `:friendly_id` |
 | [Kaminari]   | `:kaminari`    |
 | [PgSearch]   | `:pg_search`   |
-| [FriendlyId] | `:friendly_id` |
+| [Shrine]     | `:shrine`      |
 
-You can also configure the core model plugins if needed. The default plugins are defined in the [config](https://github.com/chanzuckerberg/sorbet-rails/blob/master/lib/sorbet-rails/lib/sorbet-rails/config.rb). For the full list of plugin symbols, check out [here](https://github.com/chanzuckerberg/sorbet-rails/blob/master/lib/sorbet-rails/model_plugins/plugins.rb).
+You can also configure the core model plugins if needed. The default plugins are defined in the [config](https://github.com/chanzuckerberg/sorbet-rails/blob/master/lib/sorbet-rails/config.rb). For the full list of plugin symbols, check out [here](https://github.com/chanzuckerberg/sorbet-rails/blob/master/lib/sorbet-rails/model_plugins/plugins.rb).
 
 
 [Kaminari]: https://github.com/kaminari/kaminari
 [PgSearch]: https://github.com/Casecommons/pg_search
 [FriendlyId]: https://github.com/norman/friendly_id
+[ElasticSearch]: https://github.com/elastic/elasticsearch-rails
+[Shrine]: https://github.com/shrinerb/shrine
 
 ## Contributing
 

data/Rakefile

@@ -8,9 +8,8 @@ task :default => :spec
 namespace :update_spec do
   require 'fileutils'
 
-  # This excludes 4.2 because it won't work with Bundler 2.0
-  desc "Generate Rails apps for all versions (except 4.2)."
-  task :v5_plus do |t, args|
+  desc "Generate Rails apps for all versions."
+  task :all do |t, args|
     Rake::Task['update_spec:v6_0'].invoke
     Rake::Task['update_spec:v5_2'].invoke
     Rake::Task['update_spec:v5_1'].invoke
@@ -57,19 +56,9 @@ namespace :update_spec do
     end
   end
 
-  desc "Delete the Rails 4.2 spec directory and regenerate it."
-  task :v4_2 do |t, args|
-    Bundler.with_clean_env do
-      FileUtils.rm_rf 'spec/support/v4.2' if File.directory?('spec/support/v4.2')
-      system("gem install rails -v 4.2.11")
-      system("rails _4.2.11_ -v")
-      system("RAILS_VERSION='4.2' rails _4.2.11_ new --template spec/generators/rails-template.rb spec/support/v4.2 --skip-javascript --skip-test --skip-sprockets --skip-spring --skip-listen")
-    end
-  end
-
   desc "Update sorbet_test_cases.rb in all the Rails apps in spec/support."
   task :sorbet_test_cases do |t, args|
-    ['v6.0', 'v5.2', 'v5.1', 'v5.0', 'v4.2'].each do |version|
+    ['v6.0', 'v5.2', 'v5.1', 'v5.0'].each do |version|
       FileUtils.cp("spec/generators/sorbet_test_cases.rb", "spec/support/#{version}/sorbet_test_cases.rb")
     end
   end

data/lib/bundled_rbi/parameters.rbi

@@ -1,31 +1,5 @@
 # typed: strong
 
-module ITypeAssert
-  extend T::Sig
-  extend T::Generic
-
-  Elem = type_member(:out)
-
-  abstract!
-
-  sig { abstract.params(val: T.untyped).returns(Elem) }
-  def assert(val); end
-end
-
-module TypeAssertImpl; end
-
-class TA
-  extend T::Sig
-  extend T::Generic
-  include ITypeAssert
-  extend TypeAssertImpl
-
-  Elem = type_member
-
-  sig { override.params(val: T.untyped).returns(Elem) }
-  def assert(val); end
-end
-
 module SorbetRails::CustomParamsMethods
   extend T::Sig
 
@@ -48,3 +22,7 @@ module SorbetRails::CustomParamsMethods
   }
   def fetch_typed(key, ta, *args); end
 end
+
+class ActionController::Parameters
+  include SorbetRails::CustomParamsMethods
+end

data/lib/bundled_rbi/pluck_to_tstruct.rbi

@@ -0,0 +1,22 @@
+# typed: strong
+
+module SorbetRails::PluckToTStruct
+  extend T::Sig
+  sig {
+    type_parameters(:U).
+    params(
+      ta_struct: ITypeAssert[T.type_parameter(:U)],
+    ).
+    returns(T::Array[T.type_parameter(:U)])
+  }
+  def pluck_to_tstruct(ta_struct, &blk); end
+end
+
+class ActiveRecord::Base
+  extend SorbetRails::PluckToTStruct
+end
+
+class ActiveRecord::Relation
+  Elem = type_member
+  include SorbetRails::PluckToTStruct
+end

data/lib/bundled_rbi/type_assert.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module ITypeAssert
+  extend T::Sig
+  extend T::Generic
+
+  Elem = type_member(:out)
+
+  abstract!
+
+  sig { abstract.params(val: T.untyped).returns(Elem) }
+  def assert(val); end
+end
+
+module TypeAssertImpl; end
+
+class TA
+  extend T::Sig
+  extend T::Generic
+  include ITypeAssert
+  extend TypeAssertImpl
+
+  Elem = type_member
+
+  sig { override.params(val: T.untyped).returns(Elem) }
+  def assert(val); end
+end

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

@@ -0,0 +1,40 @@
+# typed: true
+class ElasticSearchPlugin < SorbetRails::ModelPlugins::Base
+  sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
+  def generate(root)
+    return unless @model_class.include?(::Elasticsearch::Model)
+
+    model_rbi = root.create_class(model_class_name)
+    model_rbi.create_method(
+      'mapping',
+      class_method: true,
+      parameters: [
+        ::Parlour::RbiGenerator::Parameter.new(
+          "options",
+          type: "T.nilable(T::Hash[Symbol, T.untyped])", default: 'nil',
+        ),
+        ::Parlour::RbiGenerator::Parameter.new(
+          "&block",
+          type: "T.proc.bind(Elasticsearch::Model::Indexing::Mappings).void",
+        )
+      ],
+      return_type: "Elasticsearch::Model::Indexing::Mappings",
+    )
+
+    model_rbi.create_method(
+      'mappings',
+      class_method: true,
+      parameters: [
+        ::Parlour::RbiGenerator::Parameter.new(
+          "options",
+          type: "T.nilable(T::Hash[Symbol, T.untyped])", default: 'nil',
+        ),
+        ::Parlour::RbiGenerator::Parameter.new(
+          "&block",
+          type: "T.proc.bind(Elasticsearch::Model::Indexing::Mappings).void",
+        )
+      ],
+      return_type: "Elasticsearch::Model::Indexing::Mappings",
+    )
+  end
+end

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

@@ -0,0 +1,76 @@
+# typed: false
+class ShrinePlugin < SorbetRails::ModelPlugins::Base
+  sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
+  def generate(root)
+    model_rbi = root.create_class(model_class_name)
+    processed_attachments = Set.new
+    @model_class.included_modules.each do |included_module|
+      # based on https://github.com/shrinerb/shrine/blob/master/lib/shrine/attachment.rb
+      if included_module.is_a?(Shrine::Attachment)
+        attachment_name = included_module.attachment_name.to_s
+        next if processed_attachments.include?(attachment_name)
+        processed_attachments.add(attachment_name)
+
+        # TODO: detect nilability based on column nilability
+        model_rbi.create_method(
+          attachment_name,
+          return_type: "T.nilable(#{included_module.shrine_class}::UploadedFile)",
+        )
+        model_rbi.create_method(
+          "#{attachment_name}=",
+          parameters: [
+            ::Parlour::RbiGenerator::Parameter.new(
+              "file",
+              type:
+                "T.any(String, T::Hash[T.untyped, T.untyped],
+                #{included_module.shrine_class}::UploadedFile)".squish!,
+            ),
+          ],
+        )
+        model_rbi.create_method(
+          "#{attachment_name}_attacher",
+          return_type: "T.nilable(#{included_module.shrine_class}::Attacher)",
+        )
+
+        # remote_url plugin
+        # https://github.com/shrinerb/shrine/blob/2b7fad37dbaa955a7d3b82e9e05eaacb3506b4ba/
+        # ../lib/shrine/plugins/remote_url.rb
+        if included_module.is_a?(Shrine::Plugins::RemoteUrl::AttachmentMethods)
+          model_rbi.create_method(
+            "#{attachment_name}_remote_url",
+            return_type: "T.nilable(String)",
+          )
+          model_rbi.create_method(
+            "#{attachment_name}_remote_url=",
+            parameters: [
+              ::Parlour::RbiGenerator::Parameter.new(
+                "url",
+                type: T.untyped # TODO likely T.nilable(String)
+              ),
+            ],
+          )
+        end
+
+        #--
+        attachment = Object.const_get("#{included_module.shrine_class}::Attachment")
+        attachment_rbi = root.create_class(
+          attachment.name,
+          superclass: 'Shrine::Attachment',
+        )
+        attachment_rbi.create_method(
+          "initialize",
+          parameters: [
+            ::Parlour::RbiGenerator::Parameter.new('name', type: 'T.any(String, Symbol)'),
+            ::Parlour::RbiGenerator::Parameter.new('**option', type: 'T.untyped'),
+          ]
+        )
+        #--
+        uploaded_file = Object.const_get("#{included_module.shrine_class}::UploadedFile")
+        uploaded_file_rbi = root.create_class(
+          uploaded_file.name,
+          superclass: 'Shrine::UploadedFile',
+        )
+      end
+    end
+  end
+end

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

@@ -38,17 +38,8 @@ class SorbetRails::ModelPlugins::ActiveRecordAssoc < SorbetRails::ModelPlugins::
     assoc_type = "T.nilable(#{assoc_class})"
     if reflection.belongs_to?
       column_def = @columns_hash[reflection.foreign_key.to_s]
-      if ENV["RAILS_VERSION"] == "4.2"
-        # Before Rails 5, belongs_to relations were nilable by default
-        # if this is a belongs_to connection, we may be able to detect whether
-        # this field is required & use a stronger type
-        if column_def
-          assoc_type = assoc_class if !column_def.null
-        end
-      else
-        # In Rails 5 and later, belongs_to are required unless specified to be optional
-        assoc_type = assoc_class if !reflection.options[:optional]
-      end
+      # In Rails 5 and later, belongs_to are required unless specified to be optional
+      assoc_type = assoc_class if !reflection.options[:optional]
     end
 
     assoc_module_rbi.create_method(

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

@@ -75,8 +75,7 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
 
   sig do
     params(
-      # in v4.2, datetime can be TimeZoneConverter
-      klass: T.any(Object, ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter),
+      klass: Object,
       time_zone_aware: T::Boolean,
     ).returns(T.any(String, Class))
   end
@@ -88,10 +87,6 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
       time_zone_aware ? ActiveSupport::TimeWithZone : Time
     when ActiveRecord::Type::Date
       Date
-    when ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter
-      # if type has already been decorated with TimeZoneConverter, it's probably
-      # a Rails 4.2 datetime column and can be considered a TimeWithZone
-      ActiveSupport::TimeWithZone
     when ActiveRecord::Type::Decimal
       BigDecimal
     when ActiveRecord::Type::Float
@@ -145,6 +140,8 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
       "T.any(#{assignable_time_types.join(', ')})"
     elsif column_type == "T.nilable(ActiveSupport::TimeWithZone)"
       "T.nilable(T.any(#{assignable_time_types.join(', ')}))"
+    elsif column_type == String
+      'T.any(String, Symbol)'
     else
       column_type.to_s
     end