sorbet-rails 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e3f7dd83f8d099f5951a1a8bd13707c4e38d60e5
+  data.tar.gz: 4c7e2dc570d7695826c1c88d3f6711c7600dbe57
+SHA512:
+  metadata.gz: '0780d48a3e347edd504e6b3b2e11ca88e60118a29e25b3b0b4c931192aec27e8c2f2d1f2ddeff5c111a106a5174ed2feb8e7d462f92a59cc8a91284c9d0c48eb'
+  data.tar.gz: 8a3af472623c72b6cf615acd4a19b52b341b82ed18392feb8e25ddcd9a10177b329d3ab77c557b1ca32dacada4216f1ac92e6dcc1503ada0fa9507a087ebf786

data/Gemfile

@@ -0,0 +1 @@
+source 'https://rubygems.org'

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Chan Zuckerberg Initiative 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,95 @@
+# sorbet-rails
+Set of tools to make sorbet work with rails seamlessly.
+
+This gem adds a few rake tasks to generate RBI for dynamic methods generated by Rails. It also includes sigs for related Rails classes. The generated rbis are added to `sorbet/rails-rbi/` folder.
+
+Please feel free to send PR requests or file issues to improve the functionality of the gem!
+
+## Initial setup
+
+Following the steps below to setup the rbis after `srb tc`
+1. Include ActiveRecord RBI
+```
+  $ srb tc sorbet-typed
+```
+2. Generate routes RBI
+```
+  $ rake rails_rbi:routes
+```
+3. Generate models RBI
+```
+  $ rake rails_rbi:models
+```
+4. Auto-upgrade the typecheck level of files
+```
+  $ srb tc --suggest-typed --typed=strict --error-white-list=7022 -a
+```
+Because we've generated RBI files for models & routes, a lot more files should be type-checkable now
+
+## ActiveRecord RBI
+
+There are ActiveRecord RBI that we vendor with this gem. Please run `srb tc sorbet-typed` to include the provided RBI in your `sorbet/rbi_list`
+
+## Routes RBI
+The following rake task generates `_path` and `_url` methods for all named routes defined in `routes.rb`
+```
+  rake rails_rbi:routes
+```
+## Models RBI
+The following rake task generates rbi files for all models in the Rails App (all descendants of ActiveRecord::Base)
+```
+  rake rails_rbi:models
+```
+You can also regenerate rbi files for specific models
+```
+  rake rails_rbi:models[ModelName,AnotherOne,...]
+```
+At the moment, the generation task generate the following signatures
+- Column getters & setters
+- Associations getters & setters
+- Enum values, checkers & scopes
+- Named scopes
+- Model relation class
+
+## Tips & Tricks
+### `find`, `first` and `last` 
+These 3 methods can either return a single nilable record or an array of records. Sorbet does not allow us to define multiple sigs for a function. It doesn't support defining one function sig that has varying returning value depending on the input param type. We opt to define the most commonly used sig for these methods, and monkey-patch new functions for the secondary use.
+
+In short:
+- Use `find`, `first` and `last` to fetch a single record
+- Use `find_n`, `first_n`, `last_n` to fetch an array of records.
+
+### `find_by_<attributes>`, `<attribute>_changed?`, etc.
+Rails supports dynamic methods based on attribute names, such as `find_by_<attribute>`, `<attribute>_changed?`, etc. They all have static counterparts. Instead of generating all possible dynamic methods that Rails support, we recommend to use of the static version of these methods instead (also recommended by RuboCop). We've added sigs for th
+
+Following are the list of attribute dynamic methods and their static counterpart. The static methods have proper sigs.
+- `find_by_<attributes>` -> `find_by(<attributes>)`
+- `find_by_<attributes>!` -> `find_by!(<attributes>)`
+- `<attribute>_changed?` -> `attribute_changed?(<attribute>)`
+- `saved_change_to_<attribute>?` -> `saved_change_to_attribute?(<attribute>)`
+
+### `after_commit` and other callbacks
+Consider codemod-ing `after_commit` callbacks to use instance method functions. Sorbet doesn't support binding an optional block with a different context. Because of this, when using a callback with a custom block, the block is evaluated in the wrong context (Class-level context). 
+
+```
+after_commit do ... end
+```
+codemod to 
+```
+after_commit :after_commit
+def after_commit
+  ...
+end
+```
+
+I've created a gist with codemod commands to convert the code automatically
+https://gist.github.com/manhhung741/d2e0a8f9c4178f328b241dd8b28ccc67
+
+See this link for a full list of callbacks available in Rails:
+https://api.rubyonrails.org/classes/ActiveRecord/Callbacks.html
+
+### Look for `# typed: ignore` files
+
+Because sorbet initial setup tries to flag files at the typecheck level that generates 0 errors, there may be files in your repository that is `# typed: ignore`. This is because sometimes Rails allow very dynamic code that Sorbet does not regard as typecheck-able. 
+
+It is worth going through the list of files that is ignored and resolve them (and auto upgrade the types of other files -- see Initial Setup #4). Usually this will resolve in many more files typecheckable.

data/lib/sorbet-rails.rb

@@ -0,0 +1,3 @@
+module SorbetRails
+  require 'sorbet-rails/railtie' if defined?(Rails)
+end

data/lib/sorbet-rails/custom_finder_methods.rb

@@ -0,0 +1,15 @@
+module SorbetRails
+  module CustomFinderMethods
+    def find_n(ids)
+      find(ids)
+    end
+
+    def first_n(n)
+      first(n)
+    end
+
+    def last_n(n)
+      last(n)
+    end
+  end
+end

data/lib/sorbet-rails/model_rbi_formatter.rb

@@ -0,0 +1,367 @@
+# typed: true
+class ModelRbiFormatter
+
+  RUBY_TO_SORBET_TYPE_MAPPING = {
+    boolean: 'T::Boolean',
+    date: 'Date',
+    datetime: 'DateTime',
+    decimal: 'Integer',
+    integer: 'Integer',
+    string: 'String',
+    text: 'String',
+    json: 'Hash',
+    jsonb: 'Hash',
+  }
+
+  def initialize(model_class, available_classes)
+    @model_class = model_class
+    @available_classes = available_classes
+    @columns_hash = model_class.columns_hash
+    @generated_sigs = ActiveSupport::HashWithIndifferentAccess.new
+    @generated_class_sigs = ActiveSupport::HashWithIndifferentAccess.new
+    @generated_scope_sigs = ActiveSupport::HashWithIndifferentAccess.new
+    @generated_querying_sigs = ActiveSupport::HashWithIndifferentAccess.new
+    begin
+      # Load all dynamic instance methods of this model by instantiating a fake model
+      @model_class.new
+    rescue StandardError
+      puts "Note: Unable to create new instance of #{model_class.name}"
+    end
+  end
+
+  def generate_rbi
+    puts "-- Generate sigs for #{@model_class.name} --"
+    populate_activerecord_querying_methods
+    populate_named_scope_methods
+    populate_generated_column_methods
+    populate_generated_association_methods
+    populate_generated_enum_methods
+
+    @buffer = []
+    @buffer << draw_class_header
+
+    @model_class.instance_methods.sort.each do |method_name|
+      expected_sig = @generated_sigs[method_name]
+      next unless expected_sig.present?
+      method_obj = @model_class.instance_method(method_name)
+      draw_method(method_name, method_obj, expected_sig, false)
+    end
+
+    @model_class.methods.sort.each do |method_name|
+      expected_sig = @generated_class_sigs[method_name]
+      next unless expected_sig.present?
+      method_obj = @model_class.method(method_name)
+      draw_method(method_name, method_obj, expected_sig, true)
+    end
+
+    @buffer << draw_class_footer
+
+    # <Model>::NamedScope is a fake module added so that when a method is defined
+    # in this module, it'll be added to both the Model class as a class method
+    # and to its relation as an instance method.
+    #
+    # We need to define the NamedScope module after the other classes
+    # to work around Sorbet loading order bug
+    # https://sorbet-ruby.slack.com/archives/CHN2L03NH/p1556065791047300
+    @buffer << "\n"
+    @buffer << draw_named_scope_header
+    # For simplicity, generate both in the same module for now.
+    # We don't need to define two fake modules to share methods between <Model> and <Relation>
+    ({}.
+      merge(@generated_scope_sigs).
+      merge(@generated_querying_sigs)
+    ).each do |method_name, expected_sig|
+      method_obj = @model_class.method(method_name) if @model_class.methods.include?(method_name.to_sym)
+      # this is not a class method because it is added to NamedScope
+      draw_method(method_name, method_obj, expected_sig, false)
+    end
+    @buffer << draw_named_scope_footer
+    @buffer << "\n"
+    @buffer.join("\n")
+  end
+
+  def draw_method(method_name, method_obj, expected_sig, is_class_method)
+    if !method_obj.present?
+      # not very actionable because this could be a method in a newer version of Rails
+      # puts "Skip method '#{method_name}' because there is no matching method object."
+      return
+    end
+    if !is_method_autogenerated?(method_obj)
+      puts "Skip method '#{method_name}' because it is not autogenerated by Rails."
+      return
+    end
+    if !matched_signature?(method_obj, expected_sig)
+      puts "Skip method '#{method_name}' because it has different signature from expected."
+      return
+    end
+    @buffer << generate_method_sig(method_name, expected_sig, is_class_method).indent(2)
+  end
+
+  def populate_activerecord_querying_methods
+    # All is a named scope that most method from ActiveRecord::Querying delegate to
+    # rails/activerecord/lib/active_record/querying.rb:21
+    @generated_scope_sigs["all"] = { ret: "#{@model_class.name}::Relation" }
+    # It's not possible to typedef all methods in ActiveRecord::Querying module to have the
+    # matching type. By generating model-specific sig, we can typedef these methods to return
+    # <Model>::Relation class.
+    # rails/activerecord/lib/active_record/querying.rb
+    model_query_relation_methods = [
+      :select, :reselect, :order, :reorder, :group, :limit, :offset, :joins, :left_joins, :left_outer_joins,
+      :where, :rewhere, :preload, :extract_associated, :eager_load, :includes, :from, :lock, :readonly, :extending, :or,
+      :having, :create_with, :distinct, :references, :none, :unscope, :optimizer_hints, :merge, :except, :only,
+    ]
+    model_query_relation_methods.each do |method_name|
+      @generated_querying_sigs[method_name.to_s] = {
+        args: [
+          {name: :args, arg_type: :rest, value_type: 'T.untyped'},
+          {name: :block, arg_type: :block, value_type: 'T.nilable(T.proc.void)'},
+        ],
+        ret: "#{@model_class.name}::Relation",
+      }
+    end
+  end
+
+  def populate_named_scope_methods
+    @model_class.methods.sort.each do |method_name|
+      method_obj = @model_class.method(method_name)
+      next unless method_obj.present? && method_obj.source_location.present?
+      # we detect sscopes defined in a model by 2 criteria:
+      # - they don't have an owner name
+      # - they are defined in 'activerecord/lib/active_record/scoping/named.rb'
+      # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/scoping/named.rb
+      next unless method_obj.owner.name == nil
+      source_file = method_obj.source_location[0]
+      next unless source_file.include?('lib/active_record/scoping/named.rb')
+      @generated_scope_sigs[method_name] = {
+        args: [ name: :args, arg_type: :rest, value_type: 'T.untyped' ],
+        ret: "#{@model_class.name}::Relation",
+      }
+    end
+  end
+
+  def populate_generated_column_methods
+    @columns_hash.each do |column_name, column_def|
+      if @model_class.defined_enums.has_key?(column_name)
+        # enum attribute is treated differently
+        assignable_type = "T.any(Integer, String, Symbol)"
+        assignable_type = "T.nilable(#{assignable_type})" if column_def.null
+        @generated_sigs.merge!({
+          "#{column_name}" => { ret: "String" },
+          "#{column_name}=" => {
+            args: [ name: :value, arg_type: :req, value_type: assignable_type],
+          },
+        })
+      else
+        column_type = type_for_column_def(column_def)
+        @generated_sigs.merge!({
+          "#{column_name}" => { ret: column_type },
+          "#{column_name}=" => {
+            args: [ name: :value, arg_type: :req, value_type: column_type ],
+          },
+        })
+      end
+
+      if column_def.type == :boolean
+        @generated_sigs["#{column_name}?"] = {
+          ret: "T::Boolean",
+          args: [ name: :args, arg_type: :rest, value_type: 'T.untyped' ],
+        }
+      end
+    end
+  end
+
+  def populate_generated_association_methods
+    @model_class.reflections.each do |assoc_name, reflection|
+      reflection.collection? ?
+        populate_collection_assoc_getter_setter(assoc_name, reflection) :
+        populate_single_assoc_getter_setter(assoc_name, reflection)
+    end
+  end
+
+  def populate_single_assoc_getter_setter(assoc_name, reflection)
+    # TODO allow people to specify the possible values of polymorphic associations
+    assoc_class = assoc_should_be_untyped?(reflection) ? "T.untyped" : reflection.class_name
+    assoc_type = "T.nilable(#{assoc_class})"
+    if reflection.belongs_to?
+      # if this is a belongs_to connection, we may be able to detect whether
+      # this field is required & use a stronger type
+      column_def = @columns_hash[reflection.foreign_key.to_s]
+      if column_def
+        assoc_type = assoc_class if !column_def.null
+      end
+    end
+
+    @generated_sigs.merge!({
+      "#{assoc_name}" => { ret: assoc_type },
+      "#{assoc_name}=" => {
+        args: [ name: :value, arg_type: :req, value_type: assoc_type ],
+      },
+    })
+  end
+
+  def populate_collection_assoc_getter_setter(assoc_name, reflection)
+    # TODO allow people to specify the possible values of polymorphic associations
+    assoc_class = assoc_should_be_untyped?(reflection) ? "T.untyped" : reflection.class_name
+    relation_class = relation_should_be_untyped?(reflection) ?
+      "ActiveRecord::Relation[T.untyped]" :
+      "#{assoc_class}::Relation"
+    @generated_sigs.merge!({
+      "#{assoc_name}" => { ret: relation_class },
+      "#{assoc_name}=" => {
+        args: [ name: :value, arg_type: :req, value_type: "T.any(T::Array[#{assoc_class}], #{relation_class})" ],
+      },
+    })
+  end
+
+  def populate_generated_enum_methods
+    @model_class.defined_enums.each do |enum_name, enum_hash|
+      @generated_class_sigs["#{enum_name.pluralize}"] = { ret: "T::Hash[T.any(String, Symbol), Integer]"}
+      enum_hash.keys.each do |enum_val|
+        @generated_sigs["#{enum_val}?"] = { ret: "T::Boolean" }
+        @generated_scope_sigs["#{enum_val}"] = {
+          args: [ name: :args, arg_type: :rest, value_type: 'T.untyped' ],
+          ret: "#{@model_class.name}::Relation",
+        }
+      end
+    end
+  end
+
+  def assoc_should_be_untyped?(reflection)
+    polymorphic_assoc?(reflection) || !Object.const_defined?(reflection.class_name)
+  end
+
+  def relation_should_be_untyped?(reflection)
+    # only type the relation we'll generate
+    assoc_should_be_untyped?(reflection) || !@available_classes.include?(reflection.class_name)
+  end
+
+  def polymorphic_assoc?(reflection)
+    reflection.through_reflection? ?
+      polymorphic_assoc?(reflection.source_reflection) :
+      reflection.polymorphic?
+  end
+
+  def draw_class_header
+    # We define a custom <ModelName>::Relation class so that it can be extended
+    # to contain custom scopes for each models
+    <<~MESSAGE
+      # This is an autogenerated file for dynamic methods in #{@model_class.name}
+      # Please rerun rake rails_rbi:models to regenerate.
+      # typed: strong
+
+      class #{@model_class.name}::Relation < ActiveRecord::Relation
+        include #{@model_class.name}::NamedScope
+        extend T::Generic
+        Elem = type_member(fixed: #{@model_class.name})
+      end
+
+      class #{@model_class.name} < #{@model_class.superclass}
+        extend T::Sig
+        extend T::Generic
+        extend #{@model_class.name}::NamedScope
+        Elem = type_template(fixed: #{@model_class.name})
+    MESSAGE
+  end
+
+  def draw_class_footer
+    "end"
+  end
+
+  def draw_named_scope_header
+    <<~MESSAGE
+      module #{@model_class.name}::NamedScope
+        extend T::Sig
+    MESSAGE
+  end
+
+  def draw_named_scope_footer
+    "end"
+  end
+
+  def generate_column_methods(buffer)
+    @columns_hash.each do |column_name, column_def|
+      buffer << draw_column_methods(column_name, column_def)
+    end
+  end
+
+  def type_for_column_def(column_def)
+    strict_type = RUBY_TO_SORBET_TYPE_MAPPING[column_def.type] || 'T.untyped'
+    if column_def.array?
+      strict_type = "T::Array[#{strict_type}]"
+    end
+    column_def.null ? "T.nilable(#{strict_type})" : strict_type
+  end
+
+  def is_method_autogenerated?(method_obj)
+    # check if this method is autogenerated or overridden
+    # Note: sometimes this is a module, sometimes it's an instance of a class
+    return false unless method_obj.source_location.present? # BaseObject
+
+    owner_name = method_obj.owner.to_s
+    source_file = method_obj.source_location[0]
+
+    (
+      [
+        "ActiveRecord::AttributeMethods::GeneratedAttributeMethods",
+        "GeneratedAssociationMethods",
+        "ActiveRecord::Querying",
+        "ActiveRecord::AttributeMethods::PrimaryKey",
+      ].any? { |k| owner_name.include?(k) } ||
+      [
+        "lib/active_record/enum.rb",
+        "lib/active_record/scoping/named.rb",
+      ].any? { |k| source_file.include?(k) }
+    )
+  end
+
+  def matched_signature?(method_obj, generated_method_def)
+    # use parameters reflection to find method arguments
+    actual_params = method_obj.parameters
+    expected_args = generated_method_def[:args] || []
+    expected_params = expected_args.map { |arg| [arg[:arg_type], arg[:name]] }
+    actual_params == expected_params
+  end
+
+  def generate_method_sig(method_name, generated_method_def, is_class_method)
+    # generated_method_def:
+    # {
+    # .  ret: <return_type>
+    #    args: [ name: :value, arg_type: :req, value_type: "T.any(T::Array[#{assoc_class}], ActiveRecord::Relation" ]
+    #  }
+    #
+    # Generate something like this
+    #
+    #  sig {returns(T.nilable(String))}
+    # .def email; end
+    #  sig {params(record: T.nilable(String)).void}
+    #  def email=(record); end
+
+    param_sig = ""
+    param_def = ""
+    if generated_method_def[:args]
+      sig_args_string = generated_method_def[:args].map { |arg_def|
+        "#{arg_def[:name]}: #{arg_def[:value_type]}"
+      }.join(", ")
+      param_sig = "params(#{sig_args_string})."
+
+      param_def = generated_method_def[:args].map { |arg_def|
+        prefix = ""
+        prefix = "*" if arg_def[:arg_type] == :rest
+        prefix = "**" if arg_def[:arg_type] == :keyrest
+
+        "#{prefix}#{arg_def[:name]}"
+      }.join(", ")
+    end
+
+    return_type = generated_method_def[:ret] ?
+      "returns(#{generated_method_def[:ret]})" :
+      "void"
+
+    prefix = is_class_method ? "self." : ""
+
+    <<~MESSAGE
+      sig { #{param_sig}#{return_type} }
+      def #{prefix}#{method_name}(#{param_def}); end
+    MESSAGE
+  end
+end

data/lib/sorbet-rails/railtie.rb

@@ -0,0 +1,18 @@
+require "rails"
+require "sorbet-rails/custom_finder_methods"
+
+class SorbetRails::Railtie < Rails::Railtie
+  railtie_name "sorbet-rails"
+
+  rake_tasks do
+    path = File.expand_path(__dir__)
+    Dir.glob("#{path}/tasks/**/*.rake").each { |f| load f }
+  end
+
+  initializer "sorbet-rails.initialize" do
+    ActiveSupport.on_load(:active_record) do
+      ActiveRecord::Base.extend SorbetRails::CustomFinderMethods
+      ActiveRecord::Relation.include SorbetRails::CustomFinderMethods
+    end
+  end
+end

data/lib/sorbet-rails/routes_rbi_formatter.rb

@@ -0,0 +1,63 @@
+# typed: true
+class RoutesRbiFormatter
+  def initialize
+    @buffer = []
+  end
+
+  def section_title(title)
+    @buffer << "\n# Section #{title}"
+  end
+
+  def section(routes)
+    @buffer << draw_section(routes)
+  end
+
+  def header(routes)
+  end
+
+  def no_routes(routes, filter)
+    @buffer <<
+      if routes.none?
+        <<~MESSAGE
+          You do not have any routes defined!
+          Please add some routes in config/routes.rb.
+        MESSAGE
+      elsif filter.key?(:controller)
+        "No routes were found for this controller."
+      elsif filter.key?(:grep)
+        "No routes were found for this grep pattern."
+      end
+
+    @buffer << "For more information about routes, see the Rails guide: https://guides.rubyonrails.org/routing.html."
+  end
+
+  def result
+    <<~MESSAGE
+      # This is an autogenerated file for routes helper methods
+
+      # typed: strong
+      class ActionController::Base
+        extend T::Sig
+
+      #{@buffer.join("\n").indent(2)}
+      end
+    MESSAGE
+  end
+
+  private
+  def draw_section(routes)
+    routes.map do |r|
+      if r[:name].present?
+        <<~MESSAGE
+          # Sigs for route #{r[:path]}
+          sig { params(args: T.untyped, kwargs: T.untyped).returns(String) }
+          def #{r[:name]}_path(*args, **kwargs); end
+          sig { params(args: T.untyped, kwargs: T.untyped).returns(String) }
+          def #{r[:name]}_url(*args, **kwargs); end
+        MESSAGE
+      else
+        nil
+      end
+    end.compact
+  end
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: sorbet-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Chan Zuckerberg Initiative
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-04-18 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: opensource@chanzuckerberg.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- lib/sorbet-rails.rb
+- lib/sorbet-rails/custom_finder_methods.rb
+- lib/sorbet-rails/model_rbi_formatter.rb
+- lib/sorbet-rails/railtie.rb
+- lib/sorbet-rails/routes_rbi_formatter.rb
+homepage: https://github.com/chanzuckerberg/sorbet-rails
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Set of tools to make Sorbet work with Rails seamlessly.
+test_files: []