sorbet-rails 0.7.2 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca33522fb17d2e6461e49a4d0a4b851a046193c046ec2460d7ff0f1b5363fd8f
-  data.tar.gz: b59025b18da945ed7c81e2e9dbee17f4994f9aa439b071568aba0161034fd4cb
+  metadata.gz: 04e15a0b91862375e9b3f853928e0f46a3c44e6176cb10ecb813a337ac50a45a
+  data.tar.gz: e6a5b10b3ac40664e0dce8a51c80795d8fd2e0c7ef4cc665c6ad169d6cd3f0dc
 SHA512:
-  metadata.gz: a50fdea8e48fabf8da5c5bfc619de8b6cfc72410f17a4011c723fd6f45d8bbd5f1d65057289afcbdec4cb1691afd00385c90c987be753cf04d7d1d28d565190f
-  data.tar.gz: ded509eaa92c25474c8e098269ea85436307f86689c0363c880e08d7100699f64e05cefb0a374dccdef32245d112e4d91c2a44859a0034defb47df7bed9a5d5f
+  metadata.gz: 3b3bddd29abcb7d6496ece148526fc204c9a7e2bd51f54a264d526e3c10bcacafe6118a49e9ad9c36f6edb9927fe80cd31de28ce4ddda035811f5d15520e2599
+  data.tar.gz: '05249019b6251b14ab95a71599c666710478c8468702546c0619ff9111021447d246ea47bc9f62bb038e04616e6b306647b4c669315ff59672b93a1682e6eb39'

data/.travis.yml

@@ -16,7 +16,7 @@ rvm:
 matrix:
   include:
   - rvm: 2.5
-    env: RAILS_VERSION=5.2 SORBET_VERSION=0.5.5737
+    env: RAILS_VERSION=5.2 SORBET_VERSION=0.5.6210
   exclude:
   - rvm: 2.3
     env: RAILS_VERSION=6.0

data/lib/sorbet-rails/config.rb

@@ -54,6 +54,7 @@ module SorbetRails
         :active_record_named_scope,
         :active_record_querying,
         :active_relation_where_not,
+        :active_record_serialized_attribute,
         :active_record_attribute,
         :active_record_assoc,
         :custom_finder_methods,

data/lib/sorbet-rails/dependent_gem_rbis/activerecord.rbi

@@ -12,6 +12,9 @@ class ActiveRecord::Base < Object
   sig { returns(T::Hash[String, T.untyped]) }
   def self.columns_hash; end
 
+  sig { params(column_name: String).returns(T.nilable(T.any(ActiveModel::Type::Value, ActiveRecord::Type::Serialized))) }
+  def self.type_for_attribute(column_name); end
+
   sig { returns(T::Hash[String, T.untyped]) }
   def self.reflections; end
 

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

@@ -67,6 +67,10 @@ class SorbetRails::ModelPlugins::ActiveRecordAssoc < SorbetRails::ModelPlugins::
       ],
       return_type: nil,
     )
+    assoc_module_rbi.create_method(
+      "reload_#{assoc_name}",
+      return_type: assoc_type,
+    )
   end
 
   sig { params(reflection: T.untyped).returns(T::Boolean) }
@@ -134,13 +138,21 @@ class SorbetRails::ModelPlugins::ActiveRecordAssoc < SorbetRails::ModelPlugins::
       return_type: relation_class,
     )
     unless assoc_should_be_untyped?(reflection)
+      id_type = "T.untyped"
+
       if reflection.klass.table_exists?
-        # Normally the id_type is an Integer, but it could be a String if using
-        # UUIDs.
-        id_type = type_for_column_def(reflection.klass.columns_hash[reflection.klass.primary_key]).to_s
-      else
-        id_type = "T.untyped"
+        # For DB views, the PK column would not exist.
+        id_column = reflection.klass.primary_key
+
+        if id_column
+          id_column_def = reflection.klass.columns_hash[id_column]
+
+          # Normally the id_type is an Integer, but it could be a String if using
+          # UUIDs.
+          id_type = type_for_column_def(id_column_def).to_s if id_column_def
+        end
       end
+
       assoc_module_rbi.create_method(
         "#{assoc_name.singularize}_ids",
         return_type: "T::Array[#{id_type}]",

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

@@ -24,6 +24,8 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
           column_name,
           column_def,
         )
+      elsif serialization_coder_for_column(column_name)
+        next # handled by the ActiveRecordSerializedAttribute plugin
       else
         column_type = type_for_column_def(column_def)
         attribute_module_rbi.create_method(

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

@@ -0,0 +1,68 @@
+# typed: strict
+require ('sorbet-rails/model_plugins/base')
+class SorbetRails::ModelPlugins::ActiveRecordSerializedAttribute < SorbetRails::ModelPlugins::Base
+
+  sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
+  def generate(root)
+    columns_hash = @model_class.table_exists? ? @model_class.columns_hash : {}
+    return unless any_serialized_columns?(columns_hash)
+
+    serialize_module_name = self.model_module_name('GeneratedSerializedAttributeMethods')
+    serialize_module_rbi = root.create_module(serialize_module_name)
+
+    model_class_rbi = root.create_class(self.model_class_name)
+    model_class_rbi.create_include(serialize_module_name)
+
+    columns_hash.sort.each do |column_name, column_def|
+      serialization_coder = serialization_coder_for_column(column_name)
+      next unless serialization_coder
+
+      nilable = nilable_column?(column_def)
+      attr_type = attr_types_for_coder(serialization_coder)
+
+      serialize_module_rbi.create_method(
+        column_name.to_s,
+        return_type: ColumnType.new(base_type: attr_type, nilable: nilable).to_s,
+      )
+
+      serialize_module_rbi.create_method(
+        "#{column_name}=",
+        parameters: [
+          Parameter.new('value', type: ColumnType.new(base_type: attr_type, nilable: nilable).to_s)
+        ],
+        return_type: nil,
+      )
+
+      serialize_module_rbi.create_method(
+        "#{column_name}?",
+        return_type: 'T::Boolean',
+      )
+    end
+  end
+
+  sig { params(columns_hash: T::Hash[String, ActiveRecord::ConnectionAdapters::Column]).returns(T::Boolean) }
+  def any_serialized_columns?(columns_hash)
+    columns_hash.keys.any? do |column_name|
+      !serialization_coder_for_column(column_name).nil?
+    end
+  end
+
+  sig { params(serialization_coder: T.nilable(Class)).returns(String) }
+  def attr_types_for_coder(serialization_coder)
+    case serialization_coder.to_s
+    when 'Hash'
+      # Hash uses YAML.load/YAML.dump, and permits pretty much any kind of Hash key
+      'T::Hash[T.untyped, T.untyped]'
+    when 'Array'
+      # YAML.load/YAML.dump
+      'T::Array[T.untyped]'
+    when 'JSON'
+      # 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
+      'T.any(T::Array[T.untyped], T::Boolean, Float, T::Hash[T.untyped, T.untyped], Integer, String)'
+    end
+  end
+end

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

@@ -29,5 +29,13 @@ module SorbetRails::ModelPlugins
       @model_class = T.let(model_class, T.class_of(ActiveRecord::Base))
       @available_classes = T.let(available_classes, T::Set[String])
     end
+
+    sig { params(column_name: String).returns(T.nilable(Class)) }
+    def serialization_coder_for_column(column_name)
+      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
+    end
   end
 end

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

@@ -6,6 +6,7 @@ require('sorbet-rails/model_plugins/active_relation_where_not')
 require('sorbet-rails/model_plugins/active_record_named_scope')
 require('sorbet-rails/model_plugins/active_record_attribute')
 require('sorbet-rails/model_plugins/active_record_assoc')
+require('sorbet-rails/model_plugins/active_record_serialized_attribute')
 require('sorbet-rails/model_plugins/custom_finder_methods')
 require('sorbet-rails/model_plugins/enumerable_collections')
 require('sorbet-rails/model_plugins/active_storage_methods')
@@ -47,6 +48,8 @@ module SorbetRails::ModelPlugins
       ActiveRecordQuerying
     when :active_relation_where_not
       ActiveRelationWhereNot
+    when :active_record_serialized_attribute
+      ActiveRecordSerializedAttribute
     when :active_record_attribute
       ActiveRecordAttribute
     when :active_record_assoc

data/lib/sorbet-rails/model_rbi_formatter.rb

@@ -42,7 +42,7 @@ class SorbetRails::ModelRbiFormatter
     end
 
     generator = Parlour::RbiGenerator.new(break_params: 3)
-    run_plugins(plugin_instances, generator, allow_failure: true)
+    run_plugins(plugin_instances, generator)
     # Generate the base after the plugins because when ConflictResolver merge the modules,
     # it'll put the modules at the last position merged. Putting the base stuff
     # last will keep the order consistent and minimize changes when new plugins are added.
@@ -115,11 +115,11 @@ class SorbetRails::ModelRbiFormatter
     params(
       plugins: T::Array[Parlour::Plugin],
       generator: Parlour::RbiGenerator,
-      allow_failure: T::Boolean,
     ).
     void
   }
-  def run_plugins(plugins, generator, allow_failure: true)
+  def run_plugins(plugins, generator)
+    allow_failure = ENV["SBR_DEBUG_MODE"] == "true"
     plugins.each do |plugin|
       begin
         generator.current_plugin = plugin

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

@@ -3,6 +3,9 @@ require 'sorbet-runtime'
 
 module SorbetRails::PluckToTStruct
   extend T::Sig
+
+  NILCLASS_STRING = "NilClass".freeze
+
   sig {
     type_parameters(:U).
     params(
@@ -18,7 +21,8 @@ module SorbetRails::PluckToTStruct
       raise UnexpectedType.new("pluck_to_tstruct expects a tstruct subclass, given #{tstruct}")
     end
 
-    tstruct_keys = tstruct.props.keys
+    tstruct_props = tstruct.props
+    tstruct_keys = tstruct_props.keys
     associations_keys = associations.keys
     invalid_keys = associations_keys - tstruct_keys
 
@@ -33,11 +37,44 @@ module SorbetRails::PluckToTStruct
     keys_one = pluck_keys.size == 1
     pluck(*pluck_keys).map do |row|
       row = [row] if keys_one
-      value = Hash[tstruct_keys.zip(row)]
+      value = Hash[map_nil_values_to_default(tstruct_props, tstruct_keys.zip(row))]
       tstruct.new(value)
     end
   end
 
+  sig {params(type_object: T::Types::Base).returns(T::Boolean)}
+  private def nilable?(type_object)
+    return false unless type_object.is_a?(T::Types::Union)
+
+    type_object.types.any? { |type| type.name == NILCLASS_STRING }
+  end
+
+  sig {
+    params(
+      tstruct_props: T::Hash[Symbol, T.untyped],
+      zipped_rows: T::Array[[Symbol, T.untyped]]
+    )
+    .returns(T::Array[[Symbol, T.untyped]])
+  }
+  private def map_nil_values_to_default(tstruct_props, zipped_rows)
+    # we use the default value defined on a prop if
+    # 1. the plucked value is nil
+    # 2. the prop has a default
+    # 3. the prop's type isn't nilable
+
+    zipped_rows.map do |key, value|
+      next [key, value] unless value.nil?
+
+      default = tstruct_props.dig(key, :default)
+      next [key, value] unless default
+
+      type_object = tstruct_props.dig(key, :type_object)
+      next [key, value] if nilable?(type_object)
+
+      [key, default]
+    end
+  end
+
   class UnexpectedType < StandardError; end
   class UnexpectedAssociations < StandardError; end
 end

data/lib/sorbet-rails/routes_rbi_formatter.rb

@@ -28,6 +28,10 @@ class SorbetRails::RoutesRbiFormatter
       klass.create_include('GeneratedUrlHelpers')
     end
 
+    @parlour.root.create_class('ActionController::API') do |klass|
+      klass.create_include('GeneratedUrlHelpers')
+    end
+
     @parlour.root.create_module('ActionView::Helpers') do |mod|
       mod.create_include('GeneratedUrlHelpers')
     end

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

@@ -97,17 +97,18 @@ namespace :rails_rbi do
   task helpers: :environment do |t, args|
     SorbetRails::Utils.rails_eager_load_all!
 
-    if ApplicationController.methods.include?(:modules_for_helpers)
+    # API controller does not include ActionController::Helpers
+    if ApplicationController < ActionController::Helpers
       helpers = ApplicationController.modules_for_helpers([:all])
     end
 
     # If ApplicationController doesn't work or doesn't return any helpers,
     # try using ActionController::Base.
-    if ActionController::Base.methods.include?(:modules_for_helpers) && (helpers.nil? || helpers.length == 0)
+    if ApplicationController < ActionController::Helpers && helpers.blank?
       helpers = ActionController::Base.modules_for_helpers([:all])
     end
 
-    if helpers.nil? || helpers.length == 0
+    if helpers.blank?
       puts 'No helpers found.'
     else
       formatter = SorbetRails::HelperRbiFormatter.new(helpers)

data/sorbet-rails.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name          = %q{sorbet-rails}
-  s.version       = "0.7.2"
+  s.version       = "0.7.3"
   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/bin/run_spec.sh

@@ -30,5 +30,5 @@ if [[ -z $RAILS_VERSION ]]; then
 else
   echo "---- Run $RAILS_VERSION ----"
   RAILS_VERSION=$RAILS_VERSION bundle update
-  RAILS_VERSION=$RAILS_VERSION DISABLE_DATABASE_ENVIRONMENT_CHECK=1 bundle exec rake
+  RAILS_VERSION=$RAILS_VERSION DISABLE_DATABASE_ENVIRONMENT_CHECK=1 SBR_DEBUG_MODE=true bundle exec rake
 fi

data/spec/generators/rails-template.rb

@@ -180,6 +180,11 @@ def create_models
         blue: 2,
       }, _prefix: :color, _suffix: :eyes
 
+      serialize :owl_results, Hash
+      serialize :newt_subjects # no specific data type, uses the default YAML Object coder
+      serialize :pets, Array
+      serialize :patronus_characteristics, JSON
+
       has_one :wand
       has_many :spell_books
       # habtm which is optional at the db level
@@ -417,6 +422,17 @@ def create_migrations
     end
   RUBY
 
+  file "db/migrate/20190620000015_add_serialized_to_wizards.rb", <<~RUBY
+    class AddSerializedToWizards < #{migration_superclass}
+      def change
+        add_column :wizards, :owl_results, :text # Hash
+        add_column :wizards, :newt_subjects, :text # generic
+        add_column :wizards, :pets, :text # Array
+        add_column :wizards, :patronus_characteristics, :text # serialized as JSON, but not a JSON column type
+      end
+    end
+  RUBY
+
 end
 
 def create_mailers

data/spec/generators/sorbet_test_cases.rb

@@ -305,6 +305,21 @@ T.assert_type!(Wizard::House::Hufflepuff, Wizard::House)
 T.assert_type!(Wizard::House::Ravenclaw, Wizard::House)
 T.assert_type!(Wizard::House::Slytherin, Wizard::House)
 
+# Serialization
+T.assert_type!(
+  wizard.owl_results,
+  T.nilable(T::Hash[T.untyped, T.untyped])
+)
+T.assert_type!(
+  wizard.newt_subjects,
+  T.nilable(T.any(T::Array[T.untyped], T::Boolean, Float, T::Hash[T.untyped, T.untyped], Integer, String))
+)
+T.assert_type!(
+  wizard.patronus_characteristics,
+  T.nilable(T.any(T::Array[T.untyped], T::Boolean, Float, T::Hash[String, T.untyped], Integer, String))
+)
+T.assert_type!(wizard.pets, T.nilable(T::Array[T.untyped]))
+
 # Mythical plugin
 T.assert_type!(Wand.mythicals, T::Array[Wand])
 

data/spec/pluck_to_tstruct_spec.rb

@@ -1,5 +1,6 @@
 require 'rails_helper'
 require 'sorbet-rails/model_rbi_formatter'
+require 'tstruct_comparable'
 
 RSpec.describe SorbetRails::PluckToTStruct do
   let!(:harry) do
@@ -41,45 +42,40 @@ RSpec.describe SorbetRails::PluckToTStruct do
   end
 
   class WizardName < T::Struct
-    const :name, String
-
-    def ==(other)
-      return false unless other.is_a?(self.class)
-      name == other.name
-    end
+    include TStructComparable
 
-    def eql?(other)
-      self == other
-    end
+    const :name, String
   end
 
   class WizardT < T::Struct
+    include TStructComparable
+
     const :name, String
     const :house, String
-
-    def ==(other)
-      return false unless other.is_a?(self.class)
-      name == other.name && house == other.house
-    end
-
-    def eql?(other)
-      self == other
-    end
   end
 
   class WizardWithWandT < T::Struct
+    include TStructComparable
+
     const :name, String
     const :house, String
     const :wand_wood_type, String
+  end
 
-    def ==(other)
-      return false unless other.is_a?(self.class)
-      name == other.name && house == other.house
-    end
+  class WizardWithDefaultParentEmailT < T::Struct
+    include TStructComparable
 
-    def eql?(other)
-      self == other
-    end
+    const :name, String
+    const :house, String
+    const :parent_email, String, default: "hagrid@hogwarts.com"
+  end
+
+  class WizardWithDefaultNilableParentEmailT < T::Struct
+    include TStructComparable
+
+    const :name, String
+    const :house, String
+    const :parent_email, T.nilable(String), default: "hagrid@hogwarts.com"
   end
 
   shared_examples 'pluck_to_tstruct' do |struct_type, expected_values|
@@ -149,4 +145,34 @@ RSpec.describe SorbetRails::PluckToTStruct do
 
     it_should_behave_like 'pluck_to_tstruct with associations', WizardWithWandT, associations, expected
   end
+
+  context 'uses default value if prop type is not nilable and has default value' do
+    it_should_behave_like 'pluck_to_tstruct', WizardWithDefaultParentEmailT, [
+      WizardWithDefaultParentEmailT.new(
+        name: "Harry Potter",
+        house: "Gryffindor",
+        parent_email: "hagrid@hogwarts.com"
+      ),
+      WizardWithDefaultParentEmailT.new(
+        name: "Hermione Granger",
+        house: "Gryffindor",
+        parent_email: "hagrid@hogwarts.com"
+      ),
+    ]
+  end
+
+  context 'doesnt use default value if prop type is nilable even with a default value' do
+    it_should_behave_like 'pluck_to_tstruct', WizardWithDefaultNilableParentEmailT, [
+      WizardWithDefaultNilableParentEmailT.new(
+        name: "Harry Potter",
+        house: "Gryffindor",
+        parent_email: nil
+      ),
+      WizardWithDefaultNilableParentEmailT.new(
+        name: "Hermione Granger",
+        house: "Gryffindor",
+        parent_email: nil
+      ),
+    ]
+  end
 end