sorbet-rails 0.5.5 → 0.5.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4532cfd7b6aa106f5b870cd2b6013acd7d72644985a29cb398f0b25959b2d4b0
-  data.tar.gz: 39329d64e2eaee0afd14a180404897c1ec0b1601a8b33bdedb6e3d3e9f12695e
+  metadata.gz: f4aa01ecf2a262e021765ef53cdd6d5dbaaa93776c0d45ce991f9e70943eae84
+  data.tar.gz: 3957eb0b707a6615466d102eb7fafc25ab21ec35a6a7b3413629ac2924cda36d
 SHA512:
-  metadata.gz: 693c741863b4edf77cbb843b9cf030e91f098ad6291be63d2a365e845c99701b32f14a1c35658a0375aeeec25f9fcff702d0045fc36904704c3f49dd9640fca9
-  data.tar.gz: 9985e82caf4debbbac6512698190c2f787d0e8bb51ae2853bf17a3828ee4f1921330ad86829615f3f4e503d992617f43c5b6bd1c11d32f62cb75f1d03fd267e9
+  metadata.gz: cf331590decda2ee306cecda5bd89b1c603b5cbbfb1000f8dfe13e2ca6277d13269e5916cf9337c855be390da9a09eb0b6dd5e36867425421adeb563f1ffafe4
+  data.tar.gz: 61f5427e41cbee6b74311596b8aa54aa981ddf522692c151ca6db95b0cb5fc409e0ee476aab307b6baf0eb0576f38352c2e6c65be1d1d7bd7ccd28753bc3e5a8

data/README.md

@@ -87,6 +87,12 @@ For example:
 key = params.require_typed(:key, TA[String].new)
 T.reveal_type(key) # String
 
+# nested params
+nested_params = params.require_typed(:nested, TA[ActionController::Parameters].new)
+T.reveal_type(nested_params) # ActionController::Parameters
+key = nested_params.require_typed(:key, TA[String.new])
+T.reveal_type(key) # String
+
 # fetch_typed
 key = params.fetch_typed(:key, TA[T.nilable(String)].new) # raises error if params doesn't have :key
 T.reveal_type(key) # T.nilable(String)
@@ -96,7 +102,7 @@ T.reveal_type(key) # T.nilable(String)
 ```
 The parameters are type-checked both statically and at runtime.
 
-Note: The API `TA[...].new` may seems verbose, but necessary to support this feature. Ideally, the API can be simply `require_typed(:key, Type)`. However, `sorbet` [doesn't support](http://github.com/sorbet/sorbet/issues/62) defining a method that accept a type and return an instance of the type. The library provides a wrapper `TA` (stands for TypeAssert) in order to achieve the behavior. If it is by `sorbet` in the future, it will be easy to codemod to remove the `TA[...].new` part from your code.
+Note: The API `TA[...].new` may seem verbose, but necessary to support this feature. Ideally, the API can be simply `require_typed(:key, Type)`. However, `sorbet` [doesn't support](http://github.com/sorbet/sorbet/issues/62) defining a method that accept a type and return an instance of the type. The library provides a wrapper `TA` (which stands for `TypeAssert`) in order to achieve the behavior. If this feature is supported by `sorbet` in the future, it will be easy to codemod to remove the `TA[...].new` part from your code.
 
 ### Routes
 

data/lib/sorbet-rails.rb

@@ -4,5 +4,7 @@ module SorbetRails
     require 'sorbet-rails/railtie'
     require 'sorbet-rails/model_rbi_formatter'
     require 'sorbet-rails/type_assert/type_assert'
+    require 'sorbet-rails/custom_types/integer_string'
+    require 'sorbet-rails/custom_types/boolean_string'
   end
 end

data/lib/sorbet-rails/custom_types/boolean_string.rb

@@ -0,0 +1,32 @@
+# typed: false
+module BooleanStringImpl
+  def is_a?(type)
+    return super unless type == BooleanString
+    _is_a_boolean_string?
+  end
+
+  def kind_of?(type)
+    return super unless type == BooleanString
+    _is_a_boolean_string?
+  end
+
+  def instance_of?(type)
+    return super unless type == BooleanString
+    _is_a_boolean_string?
+  end
+
+  def _is_a_boolean_string?
+    return @cached_is_a unless @cached_is_a.nil?
+    @cached_is_a = (self =~ /^(true|false)$/i) == 0
+  end
+end
+
+class String
+  include BooleanStringImpl
+end
+
+class BooleanString < String
+  def self.===(other)
+    other.is_a?(BooleanString)
+  end
+end

data/lib/sorbet-rails/custom_types/integer_string.rb

@@ -0,0 +1,35 @@
+# typed: false
+module IntegerStringImpl
+  def is_a?(type)
+    return super unless type == IntegerString
+    _is_a_integer_string?
+  end
+
+  def kind_of?(type)
+    return super unless type == IntegerString
+    _is_a_integer_string?
+  end
+
+  def instance_of?(type)
+    return super unless type == IntegerString
+    _is_a_integer_string?
+  end
+
+  def _is_a_integer_string?
+    return @cached_is_a unless @cached_is_a.nil?
+    Integer(self, 10)
+    @cached_is_a = true
+  rescue ArgumentError => err
+    @cached_is_a = false
+  end
+end
+
+class String
+  include IntegerStringImpl
+end
+
+class IntegerString < String
+  def self.===(other)
+    other.is_a?(IntegerString)
+  end
+end

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

@@ -32,7 +32,11 @@ class SorbetRails::ModelPlugins::ActiveRecordEnum < SorbetRails::ModelPlugins::B
         class_method: true,
       )
 
-      enum_call = enum_calls.find {|call| call.has_key?(enum_name.to_sym)}
+      enum_call = ActiveRecordOverrides.instance.get_enum_call(@model_class, enum_name.to_sym)
+      if enum_call.nil?
+        puts "Error: unable to find enum call for enum #{enum_name}, model #{self.model_class_name}"
+        next
+      end
 
       enum_prefix = enum_call[:_prefix]
       prefix =

data/lib/sorbet-rails/rails_mixins/active_record_overrides.rb

@@ -11,9 +11,23 @@ class ActiveRecordOverrides
     @enum_calls = {}
   end
 
-  def store_enum_call(class_name, kwargs)
-    @enum_calls[class_name] ||= []
-    @enum_calls[class_name] << kwargs
+  def store_enum_call(klass, kwargs)
+    class_name = klass.name
+    @enum_calls[class_name] ||= {}
+    # modeling the logic in
+    # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/enum.rb#L152
+    kwargs.each do |name, values|
+      next if [:_prefix, :_suffix, :_scopes].include?(name)
+      @enum_calls[class_name][name] = kwargs
+    end
+  end
+
+  def get_enum_call(klass, enum_sym)
+    return nil if klass == Object
+    class_name = klass.name
+    class_enum_calls = @enum_calls[klass.name]
+    return class_enum_calls[enum_sym] if class_enum_calls && class_enum_calls.has_key?(enum_sym)
+    return get_enum_call(klass.superclass, enum_sym)
   end
 end
 
@@ -21,7 +35,7 @@ module ::ActiveRecord::Enum
   alias old_enum enum
 
   def enum(*args, **kwargs)
-    ActiveRecordOverrides.instance.store_enum_call(T.unsafe(self).name, kwargs)
+    ActiveRecordOverrides.instance.store_enum_call(self, kwargs)
     old_enum(*args, **kwargs)
   end
 end

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

@@ -134,11 +134,10 @@ namespace :rails_rbi do
   end
 
   def copy_bundled_rbi(filename)
-    puts "rails rbi rake dir #{RAILS_RBI_RAKE_DIR}"
+    puts "Copy bundled file #{filename}"
     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

@@ -7,7 +7,6 @@ class TA
   extend T::Sig
   extend T::Generic
   include ITypeAssert
-  include TypeAssertImpl
 
   Elem = type_member
 

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

@@ -1,26 +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
+if !$PROGRAM_NAME.include?('sorbet')
+  module TypeAssertImpl
+    def self.included(klass)
+      klass.define_singleton_method(:[]) do |type|
+        return Class.new do
+          include ITypeAssert
 
-        define_method(:to_s) { "TA[#{type.to_s}]" }
+          define_method(:to_s) { "TA[#{type.to_s}]" }
 
-        define_method(:assert) do |val|
-          T.let(val, type)
-        end
+          define_method(:assert) do |val|
+            T.let(val, type)
+          end
 
-        define_method(:get_type) { type }
+          define_method(:get_type) { type }
+        end
       end
     end
   end
 
-  class Unsupported < StandardError; end
-end
+  class TA
+    include TypeAssertImpl
+  end
+end

data/sorbet-rails.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name          = %q{sorbet-rails}
-  s.version       = "0.5.5"
+  s.version       = "0.5.5.1"
   s.date          = %q{2019-04-18}
   s.summary       = %q{Set of tools to make Sorbet work with Rails seamlessly.}
   s.authors       = ["Chan Zuckerberg Initiative"]

data/spec/boolean_string_spec.rb

@@ -0,0 +1,59 @@
+require 'rails_helper'
+require 'sorbet-rails/custom_types/boolean_string'
+require 'sorbet-runtime'
+
+RSpec.describe BooleanString do
+  shared_examples 'boolean string' do |str|
+    it 'acts as BooleanString perfectly' do
+      expect(str.is_a?(BooleanString)).to be(true)
+      expect(str.kind_of?(BooleanString)).to be(true)
+      expect(str.instance_of?(BooleanString)).to be(true)
+      expect(BooleanString === str).to be(true)
+    end
+  end
+
+  include_examples 'boolean string', 'true'
+  include_examples 'boolean string', 'false'
+  include_examples 'boolean string', 'True'
+  include_examples 'boolean string', 'False'
+
+  shared_examples 'non boolean string' do |str|
+    it 'does not acts as BooleanString' do
+      expect(str.is_a?(BooleanString)).to be(false)
+      expect(str.kind_of?(BooleanString)).to be(false)
+      expect(str.instance_of?(BooleanString)).to be(false)
+      expect(BooleanString === str).to be(false)
+    end
+  end
+
+  include_examples 'non boolean string', 'yes'
+  include_examples 'non boolean string', 'no'
+  include_examples 'non boolean string', 'alala'
+
+  context 'sorbet recognizes it at runtime' do
+    it 'lets boolean string pass runtime check' do
+      expect(T.let('true', BooleanString)).to eql('true')
+    end
+
+    it 'doesnt let normal string pass runtime typecheck' do
+      expect {
+        T.let('yes', BooleanString)
+      }.to raise_error(TypeError)
+    end
+  end
+
+  context 'using with TypeAssert' do
+    let!(:ta) { TA[BooleanString].new }
+
+    it 'lets boolean string pass runtime typecheck' do
+      expect(ta.assert('true')).to eql('true')
+    end
+
+    it 'doesnt let normal string pass runtime typecheck' do
+      expect {
+        ta.assert('yes')
+      }.to raise_error(TypeError)
+    end
+  end
+end
+

data/spec/generators/rails-template.rb

@@ -216,6 +216,14 @@ def create_models
       end
     end
   RUBY
+
+  file "app/models/squib.rb", <<~RUBY
+    class Squib < Wizard
+      def is_magical
+        false
+      end
+    end
+  RUBY
 end
 
 def create_migrations
@@ -304,6 +312,14 @@ def create_migrations
       end
     RUBY
   end
+
+  file "db/migrate/20190620000007_add_type_to_wizard.rb", <<~RUBY
+    class AddTypeToWizard < #{migration_superclass}
+      def change
+        add_column :wizards, :type, :string, null: false, default: 'Wizard'
+      end
+    end
+  RUBY
 end
 
 def create_mailers

data/spec/integer_string_spec.rb

@@ -0,0 +1,46 @@
+require 'rails_helper'
+require 'sorbet-rails/custom_types/integer_string'
+require 'sorbet-runtime'
+
+RSpec.describe IntegerString do
+  it 'lets integer string acts as IntegerString perfectly' do
+    expect('1'.is_a?(IntegerString)).to be(true)
+    expect('12'.kind_of?(IntegerString)).to be(true)
+    expect('123'.instance_of?(IntegerString)).to be(true)
+    expect(IntegerString === '1234').to be(true)
+  end
+
+  it 'does not let other string acts as IntegerString' do
+    expect('a1'.is_a?(IntegerString)).to be(false)
+    expect('a12'.kind_of?(IntegerString)).to be(false)
+    expect('a123'.instance_of?(IntegerString)).to be(false)
+    expect(IntegerString === 'a1234').to be(false)
+  end
+
+  context 'sorbet recognizes it at runtime' do
+    it 'lets integer string pass runtime check' do
+      expect(T.let('123', IntegerString)).to eql('123')
+    end
+
+    it 'doesnt let normal string pass runtime typecheck' do
+      expect {
+        T.let('a123', IntegerString)
+      }.to raise_error(TypeError)
+    end
+  end
+
+  context 'using with TypeAssert' do
+    let!(:ta) { TA[IntegerString].new }
+
+    it 'lets integer string pass runtime typecheck' do
+      expect(ta.assert('123')).to eql('123')
+    end
+
+    it 'doesnt let normal string pass runtime typecheck' do
+      expect {
+        ta.assert('a123')
+      }.to raise_error(TypeError)
+    end
+  end
+end
+

data/spec/rake_rails_rbi_models_spec.rb

@@ -14,6 +14,7 @@ RSpec.describe 'rake rails_rbi:models', type: :task do
       files: [
         'potion.rbi',
         'spell_book.rbi',
+        'squib.rbi',
         'wand.rbi',
         'wizard.rbi',
       ]

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

@@ -95,10 +95,10 @@ GEM
       thor (>= 0.18.1, < 2.0)
     rainbow (3.0.0)
     rake (12.3.3)
-    sorbet (0.4.4709)
-      sorbet-static (= 0.4.4709)
-    sorbet-runtime (0.4.4709)
-    sorbet-static (0.4.4709-x86_64-linux)
+    sorbet (0.4.4755)
+      sorbet-static (= 0.4.4755)
+    sorbet-runtime (0.4.4755)
+    sorbet-static (0.4.4755-x86_64-linux)
     sprockets (3.7.2)
       concurrent-ruby (~> 1.0)
       rack (> 1, < 3)

data/spec/support/v4.2/app/models/squib.rb

@@ -0,0 +1,6 @@
+# typed: true
+class Squib < Wizard
+  def is_magical
+    false
+  end
+end

data/spec/support/v4.2/app/models/wizard.rb

@@ -1,4 +1,4 @@
-# typed: strict
+# typed: ignore
 class Wizard < ApplicationRecord
   validates :name, length: { minimum: 5 }, presence: true
 
@@ -26,5 +26,4 @@ class Wizard < ApplicationRecord
   has_many :spell_books
 
   scope :recent, -> { where('created_at > ?', 1.month.ago) }
-  
 end

data/spec/support/v4.2/db/migrate/20190620000007_add_type_to_wizard.rb

@@ -0,0 +1,6 @@
+# typed: false
+class AddTypeToWizard < ActiveRecord::Migration
+  def change
+    add_column :wizards, :type, :string, null: false, default: 'Wizard'
+  end
+end

data/spec/support/v4.2/db/schema.rb

@@ -12,7 +12,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 20190620000005) do
+ActiveRecord::Schema.define(version: 20190620000007) do
 
   create_table "spell_books", force: :cascade do |t|
     t.string  "name"
@@ -42,6 +42,7 @@ ActiveRecord::Schema.define(version: 20190620000005) do
     t.datetime "created_at"
     t.datetime "updated_at"
     t.string   "broom"
+    t.string   "type",         default: "Wizard", null: false
   end
 
 end