sorbet-rails 0.5.4 → 0.5.5

data/lib/sorbet-rails/railtie.rb

@@ -1,7 +1,6 @@
 # typed: true
 require "rails"
 require "sorbet-runtime"
-require "sorbet-rails/custom_finder_methods"
 require "sorbet-rails/config"
 
 class SorbetRails::Railtie < Rails::Railtie
@@ -14,6 +13,9 @@ class SorbetRails::Railtie < Rails::Railtie
 
   initializer "sorbet-rails.initialize" do
     ActiveSupport.on_load(:active_record) do
+      require "sorbet-rails/rails_mixins/active_record_overrides"
+      require "sorbet-rails/rails_mixins/custom_finder_methods"
+
       ActiveRecord::Base.extend SorbetRails::CustomFinderMethods
       ActiveRecord::Relation.include SorbetRails::CustomFinderMethods
 
@@ -33,6 +35,11 @@ class SorbetRails::Railtie < Rails::Railtie
       end
     end
 
+    ActiveSupport.on_load(:action_controller) do
+      require "sorbet-rails/rails_mixins/custom_params_methods"
+      ActionController::Parameters.include SorbetRails::CustomParamsMethods
+    end
+
     SorbetRails.register_configured_plugins
   end
 end

data/lib/sorbet-rails/routes_rbi_formatter.rb

@@ -44,8 +44,7 @@ class SorbetRails::RoutesRbiFormatter
 
   sig { returns(String) }
   def result
-    # by default parlour doesn't add a \n at the end of file
-    @parlour.rbi + "\n"
+    @parlour.rbi
   end
 
   private

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

@@ -4,13 +4,21 @@ require("sorbet-rails/helper_rbi_formatter")
 require("sorbet-rails/mailer_rbi_formatter")
 require("sorbet-rails/utils")
 
+RAILS_RBI_RAKE_DIR  = File.dirname(__FILE__)
+
 namespace :rails_rbi do
   desc "Generate rbis for rails models, routes, and helpers."
   task :all, :environment do |t, args|
+    # reset rails-rbi folder
+    rails_rbi_root_path = Rails.root.join("sorbet", "rails-rbi")
+    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:params'].invoke
   end
 
   desc "Generate rbis for rails routes"
@@ -24,6 +32,11 @@ namespace :rails_rbi do
     File.write(file_path, inspector.format(SorbetRails::RoutesRbiFormatter.new))
   end
 
+  desc "Copy additional rbis for ActionController::Parameters"
+  task params: :environment do
+    copy_bundled_rbi('parameters.rbi')
+  end
+
   desc "Generate rbis for rails models. Pass models name to regenerate rbi for only the given models."
   task models: :environment do |t, args|
     SorbetRails::Utils.rails_eager_load_all!
@@ -119,4 +132,13 @@ namespace :rails_rbi do
     whitelisted_models << ActiveRecord::SchemaMigration if Object.const_defined?('ActiveRecord::SchemaMigration')
     whitelisted_models
   end
+
+  def copy_bundled_rbi(filename)
+    puts "rails rbi rake dir #{RAILS_RBI_RAKE_DIR}"
+    bundled_rbi_file_path = File.join(RAILS_RBI_RAKE_DIR, "..", "..", "bundled_rbi", filename)
+    copy_to_path = Rails.root.join("sorbet", "rails-rbi", filename)
+    FileUtils.mkdir_p(File.dirname(copy_to_path))
+    puts "file path to copy #{bundled_rbi_file_path}"
+    FileUtils.cp(bundled_rbi_file_path, copy_to_path)
+  end
 end

data/lib/sorbet-rails/type_assert/type_assert.rb

@@ -0,0 +1,18 @@
+# typed: true
+require 'sorbet-runtime'
+require 'sorbet-rails/type_assert/type_assert_interface'
+require 'sorbet-rails/type_assert/type_assert_impl'
+
+class TA
+  extend T::Sig
+  extend T::Generic
+  include ITypeAssert
+  include TypeAssertImpl
+
+  Elem = type_member
+
+  sig { override.params(val: T.untyped).returns(Elem) }
+  def assert(val)
+    val # assertion happens in the Impl module
+  end
+end

data/lib/sorbet-rails/type_assert/type_assert_impl.rb

@@ -0,0 +1,26 @@
+# typed: ignore
+require 'sorbet-runtime'
+
+module TypeAssertImpl
+  def self.included(klass)
+    klass.define_singleton_method(:[]) do |*types|
+      if types.length != 1
+        raise Unsupported.new("TypeAssert only supports 1 type, given #{types}")
+      end
+      type = types.first
+      return Class.new do
+        include ITypeAssert
+
+        define_method(:to_s) { "TA[#{type.to_s}]" }
+
+        define_method(:assert) do |val|
+          T.let(val, type)
+        end
+
+        define_method(:get_type) { type }
+      end
+    end
+  end
+
+  class Unsupported < StandardError; end
+end

data/lib/sorbet-rails/type_assert/type_assert_interface.rb

@@ -0,0 +1,16 @@
+# typed: true
+require ('sorbet-runtime')
+
+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
+
+  def get_type; Elem; end
+end

data/sorbet-rails.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name          = %q{sorbet-rails}
-  s.version       = "0.5.4"
+  s.version       = "0.5.5"
   s.date          = %q{2019-04-18}
   s.summary       = %q{Set of tools to make Sorbet work with Rails seamlessly.}
   s.authors       = ["Chan Zuckerberg Initiative"]
@@ -15,7 +15,7 @@ Gem::Specification.new do |s|
     `git ls-files -z`.split("\x0").select { |f| f.match(%r{^(test|spec|features)/}) }
   end
 
-  s.add_dependency 'parlour', '~> 0.6.0'
+  s.add_dependency 'parlour', '~> 0.8.0'
 
   # Development
   s.add_development_dependency 'rspec', '~> 3.8', '>= 3.8'

data/spec/custom_finder_methods_spec.rb

@@ -32,6 +32,11 @@ RSpec.describe SorbetRails::CustomFinderMethods do
       expect(with_splash.size).to eql(3)
     end
 
+    it 'works with empty array' do
+      with_no_element = Wizard.find_n([])
+      expect(with_no_element).to eql([])
+    end
+
     it 'works with single id array' do
       with_one_element = Wizard.find_n([wizard_ids.first])
       expect(with_one_element.size).to eql(1)

data/spec/custom_params_methods_spec.rb

@@ -0,0 +1,138 @@
+require 'rails_helper'
+
+describe ActionController::Parameters do
+  let!(:params) do
+    ActionController::Parameters.new({
+      age: 11,
+      name: 'Harry Potter',
+      info: {
+        birthday: Date.parse('1980-07-31'),
+        friends: [
+          'Hermione',
+          'Ron',
+        ],
+        grandson: nil,
+      },
+    })
+  end
+  let!(:params_info) { params.require(:info) }
+
+  context 'require_typed' do
+    it 'gets basic param correctly' do
+      val = params.require_typed(:age, TA[Integer].new)
+      expect(val).to eql(11)
+
+      val = params.require_typed(:name, TA[String].new)
+      expect(val).to eql('Harry Potter')
+    end
+
+    it 'gets param with complex type correctly' do
+      val = params.require_typed(:age, TA[T.any(String, Integer)].new)
+      expect(val).to eql(11)
+    end
+
+    it 'gets param object correctly' do
+      val = params.require_typed(:info, TA[ActionController::Parameters].new)
+      expect(val.is_a?(ActionController::Parameters))
+      expect(val).to eql(params_info)
+
+      friends = val.require_typed(:friends, TA[T::Array[String]].new)
+      expect(friends).to eql([
+        'Hermione',
+        'Ron',
+      ])
+    end
+
+    it 'raises error when param doesnt exist' do
+      expect {
+        params.require_typed(:nonexistence, TA[String].new)
+      }.to raise_error(ActionController::ParameterMissing)
+    end
+
+    it 'raises error when param is nil' do
+      expect {
+        params_info.require_typed(:grandson, TA[T::Array[String]].new)
+      }.to raise_error(ActionController::ParameterMissing)
+    end
+
+    it 'raises error when param has wrong type' do
+      expect {
+        params.require_typed(:age, TA[String].new)
+      }.to raise_error(ActionController::BadRequest)
+    end
+
+    it 'raises error when param has wrong complex type' do
+      expect {
+        params.require_typed(:age, TA[T::Array[String]].new)
+      }.to raise_error(ActionController::BadRequest)
+    end
+  end
+
+  context 'fetch_typed' do
+    it 'gets basic param correctly' do
+      val = params.fetch_typed(:age, TA[Integer].new)
+      expect(val).to eql(11)
+
+      val = params.fetch_typed(:name, TA[String].new)
+      expect(val).to eql('Harry Potter')
+    end
+
+    it 'gets param object correctly' do
+      val = params.fetch_typed(:info, TA[ActionController::Parameters].new)
+      expect(val.is_a?(ActionController::Parameters))
+      expect(val).to eql(params_info)
+
+      friends = val.fetch_typed(:friends, TA[T::Array[String]].new)
+      expect(friends).to eql([
+        'Hermione',
+        'Ron',
+      ])
+    end
+
+    it 'raises error when param doesnt exist' do
+      expect {
+        val = params.fetch_typed(:nonexistence, TA[String].new)
+      }.to raise_error(ActionController::ParameterMissing)
+    end
+
+    it 'raises error when param has wrong type' do
+      expect {
+        val = params.fetch_typed(:age, TA[String].new)
+      }.to raise_error(ActionController::BadRequest)
+    end
+
+    it 'returns nil when param is nil' do
+      grandson = params_info.fetch_typed(:grandson, TA[T.nilable(T::Array[String])].new)
+      expect(grandson).to eql(nil)
+    end
+
+    context 'when there is a default value' do
+      it 'uses default value when param is nil and has a default' do
+        fetched = params.fetch_typed(:nonexistence, TA[T::Array[String]].new, [])
+        expect(fetched).to eql([])
+      end
+
+      it 'ignores default value when there is a real value' do
+        name = params.fetch_typed(:name, TA[String].new, 'John Doe')
+        expect(name).to eql('Harry Potter')
+      end
+
+      it 'converts hash default value into a params' do
+        # this is `fetch` documented behavior
+        fetched = params.fetch_typed(
+          :nonexistence,
+          TA[ActionController::Parameters].new,
+          { unknown: "baby" },
+        )
+        expect(fetched.is_a?(ActionController::Parameters)).to be(true)
+        expect(fetched.permit(:unknown).to_h).to eql({ "unknown" => "baby" })
+      end
+
+      it 'raises error when param is nil and given a wrong default' do
+        expect {
+          fetched = params.fetch_typed(:nonexistence, TA[T::Array].new, 5)
+        }.to raise_error(ActionController::BadRequest)
+      end
+    end
+  end
+end

data/spec/generators/sorbet_test_cases.rb

@@ -170,3 +170,52 @@ if ENV["RAILS_VERSION"] != "4.2"
   T.assert_type!(wizard.brown_hair?, T::Boolean)
 end
 
+# -- Custom ActionController::Parameters Methods
+params = ActionController::Parameters.new({
+  age: 11,
+  name: 'Harry Potter',
+  info: {
+    birthday: Date.parse('1980-07-31'),
+    friends: [
+      'Hermione',
+      'Ron',
+    ],
+    grandson: nil,
+  },
+})
+# -- require_typed
+T.assert_type!(
+  params.require_typed(:age, TA[Integer].new),
+  Integer,
+)
+T.assert_type!(
+  params.require_typed(:name, TA[String].new),
+  String,
+)
+info = params.require_typed(:info, TA[ActionController::Parameters].new)
+T.assert_type!(info, ActionController::Parameters)
+T.assert_type!(
+  info.require_typed(:friends, TA[T::Array[String]].new),
+  T::Array[String],
+)
+# -- fetch_typed
+T.assert_type!(
+  params.fetch_typed(:age, TA[Integer].new),
+  Integer,
+)
+T.assert_type!(
+  params.fetch_typed(:name, TA[String].new),
+  String,
+)
+T.assert_type!(
+  params.fetch_typed(:nonexistence, TA[String].new, ''),
+  String,
+)
+T.assert_type!(
+  params.fetch_typed(:nonexistence, TA[T.nilable(String)].new, nil),
+  T.nilable(String),
+)
+T.assert_type!(
+  params.fetch_typed(:nonexistence, TA[T::Array[Integer]].new, []),
+  T::Array[Integer],
+)

data/spec/model_rbi_formatter_spec.rb

@@ -2,6 +2,9 @@ require 'rails_helper'
 require 'sorbet-rails/model_rbi_formatter'
 
 RSpec.describe SorbetRails::ModelRbiFormatter do
+  before(:all) do
+    SorbetRails::Utils.rails_eager_load_all!
+  end
 
   it 'does not throw an error when given an abstract class' do
     formatter = SorbetRails::ModelRbiFormatter.new(Potion, Set.new(['Potion']))
@@ -13,8 +16,10 @@ RSpec.describe SorbetRails::ModelRbiFormatter do
 
   it 'generates correct rbi file for Wizard' do
     class_set = Set.new(['Wizard', 'Wand', 'SpellBook'])
-    if ['5.2', '6.0'].include?(ENV['RAILS_VERSION'])
+    if Object.const_defined?('ActiveStorage::Attachment')
       class_set << 'ActiveStorage::Attachment'
+    end
+    if Object.const_defined?('ActiveStorage::Blob')
       class_set << 'ActiveStorage::Blob'
     end
     formatter = SorbetRails::ModelRbiFormatter.new(Wizard, class_set)
@@ -35,11 +40,13 @@ RSpec.describe SorbetRails::ModelRbiFormatter do
   context 'there is a hidden model' do
     it 'fallbacks to use ActiveRecord::Relation' do
       class_set = Set.new(['Wizard', 'Wand'])
-      if ['5.2', '6.0'].include?(ENV['RAILS_VERSION'])
+      if Object.const_defined?('ActiveStorage::Attachment')
         class_set << 'ActiveStorage::Attachment'
+      end
+      if Object.const_defined?('ActiveStorage::Blob')
         class_set << 'ActiveStorage::Blob'
       end
-      formatter = SorbetRails::ModelRbiFormatter.new(Wizard, class_set)
+        formatter = SorbetRails::ModelRbiFormatter.new(Wizard, class_set)
       expect_match_file(
         formatter.generate_rbi,
         'expected_wizard_wo_spellbook.rbi',

data/spec/sorbet_spec.rb

@@ -53,15 +53,11 @@ RSpec.describe 'sorbet' do
       'bundle', 'exec', 'srb', 'rbi', 'hidden-definitions',
       chdir: Rails.root.to_path,
     )
-    puts '--- srb rbi hidden-definitions ---'
-    puts stdout, stderr, status
 
     stdout, stderr, status = Open3.capture3(
       'bundle', 'exec', 'srb', 'rbi', 'todo',
       chdir: Rails.root.to_path,
     )
-    puts '--- srb rbi todo ---'
-    puts stdout, stderr, status
   end
 
   it 'returns expected sorbet tc result' do
@@ -86,6 +82,6 @@ RSpec.describe 'sorbet' do
       'bundle', 'exec', 'srb', 'tc', '--lsp',
       chdir: Rails.root.to_path,
     )
-    expect(status.exitstatus).to eql(0)
+    expect(status.exitstatus).to eql(10)
   end
 end

data/spec/support/v4.2/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: ../../..
   specs:
-    sorbet-rails (0.5.3)
-      parlour (~> 0.6.0)
+    sorbet-rails (0.5.5)
+      parlour (~> 0.8.0)
 
 GEM
   remote: https://rubygems.org/
@@ -63,7 +63,7 @@ GEM
     minitest (5.11.3)
     nokogiri (1.10.4)
       mini_portile2 (~> 2.4.0)
-    parlour (0.6.1)
+    parlour (0.8.0)
       rainbow (~> 3.0.0)
       sorbet-runtime
     rack (1.6.11)