sorbet_factory_bot 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9c5aa26a1fd0c9aef25e9659068f31a9f43cc62c77b4bf7a335a36ee3ce096bc
+  data.tar.gz: bed138de6e79f20761c6868245c5e4ddb7504f037c7fc10c36a3e006cd78facc
+SHA512:
+  metadata.gz: 899341bbebbd6762aeef1971cd80d4d93de5b59d964456628c627733518542b1ec1b2550911fee262eccb1870218384a880ca6d8bef6814c08b1cfab0de32786
+  data.tar.gz: 6980e7e3e13067b700f132ae611838267b0626f6064b08430a0d8565bfb374d661b703a4437e2b1af4be8481871ee8f06d0945d6358c072ea0c6e445a87662af

data/README.md

@@ -0,0 +1,79 @@
+# SorbetFactoryBot
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add sorbet_factory_bot
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install sorbet_factory_bot
+```
+
+## Setup
+
+Add `sorbet_factory_bot` to your Tapioca require.rb file. When running `tapioca dsl` 
+you should see a new `sorbet/rbi/dsl/sorbet_factory_bot/helpers.rbi` file generated.
+
+```ruby
+# sorbet/tapioca/require.rb
+require "sorbet_factory_bot"
+```
+
+In your test helper, include:
+
+```ruby
+# test/test_helper.rb
+require_relative "../path/to/factories.rb"
+
+module ActiveSupport
+  class TestCase
+    include SorbetFactoryBot::Helpers
+    SorbetFactoryBot::Helpers.generate_module_helpers!(FactoryBot.factories)
+  end
+end
+```
+
+## Usage
+
+`sorbet_factory_bot` generates typesafe shims for each FactoryBot factory:
+
+```ruby
+# Before
+build(:user)
+build_list(:user)
+create(:user, name: "Astrid")
+create_list(:user)
+
+# After
+build_user()
+build_user_list()
+create_user(name: "Astrid")
+create_user_list()
+```
+
+### Traits
+
+FactoryBot allows passing trait names as symbols directly into the builder methods.
+This is not compatible with how Sorbet defines signatures, so use the `traits_` 
+keyword argument to pass a list of traits.
+
+
+```ruby
+# Before
+create(:user, :trait1, name: "Astrid")
+
+# After
+create_user(traits_: [:trait_1], name: "Astrid")
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/lib/sorbet_factory_bot/helpers.rb

@@ -0,0 +1,37 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "factory_bot"
+require "sorbet-runtime"
+
+module SorbetFactoryBot
+  module Helpers
+    extend ::T::Helpers
+    extend ::T::Sig
+
+    sig { params(registry: FactoryBot::Registry).void }
+    def generate_model_helpers!(registry)
+      registry.each do |factory|
+        name = factory.name
+
+        # For each factory, generate a corresponding wrapper that has Tapioca-generated
+        # signatures.
+        T.unsafe(self).define_method(:"build_#{name}") do |traits_: [], **overrides, &blk|
+          T.unsafe(FactoryBot).build(name, *traits_, **overrides, &blk)
+        end
+        T.unsafe(self).define_method(:"create_#{name}") do |traits_: [], **overrides, &blk|
+          T.unsafe(FactoryBot).create(name, *traits_, **overrides, &blk)
+        end
+
+        T.unsafe(self).define_method(:"build_#{name}_list") do |count_, traits_: [], **overrides, &blk|
+          T.unsafe(FactoryBot).build_list(name, count_, *traits_, **overrides, &blk)
+        end
+        T.unsafe(self).define_method(:"create_#{name}_list") do |count_, traits_: [], **overrides, &blk|
+          T.unsafe(FactoryBot).create_list(name, count_, *traits_, **overrides, &blk)
+        end
+      end
+    end
+
+    extend self
+  end
+end

data/lib/sorbet_factory_bot/version.rb

@@ -0,0 +1,6 @@
+# typed: true
+# frozen_string_literal: true
+
+module SorbetFactoryBot
+  VERSION = "0.1.0"
+end

data/lib/sorbet_factory_bot.rb

@@ -0,0 +1,8 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "sorbet_factory_bot/helpers"
+require_relative "sorbet_factory_bot/version"
+require_relative "tapioca/runtime/reflection_monkey_patch"
+
+module SorbetFactoryBot; end

data/lib/tapioca/dsl/compilers/sorbet_factory_bot_compiler.rb

@@ -0,0 +1,250 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "tapioca/dsl"
+require "tapioca/dsl/compiler"
+
+require_relative "../../../sorbet_factory_bot/helpers"
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # This Tapioca compiler generates RBI for FactoryBot factories that back onto Rails models.
+      # The wrapper methods generated in SorbetFactoryBot::Helpers have a few key differences from
+      # the built-in interface:
+      #   * Traits are specified via an optional `trait_` kwarg for all methods.
+      #     Example: build_person(traits_: [:active], name: "Edgar")
+      class SorbetFactoryBotCompiler < Tapioca::Dsl::Compiler
+        extend T::Sig
+        extend T::Generic
+
+        ConstantType = type_member { { fixed: T.class_of(::SorbetFactoryBot::Helpers) } }
+
+        RBI_MODULE_NAME = "SorbetFactoryBotMethods"
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[T::Module[T.anything]]) }
+          def gather_constants
+            Array(SorbetFactoryBot::Helpers)
+          end
+        end
+
+        sig { override.void }
+        def decorate
+          root.create_path(constant) do |klass|
+            klass.create_module(RBI_MODULE_NAME) do |methods_mod|
+              if FactoryBot.factories.count == 0 # rubocop:disable Style/NumericPredicate
+                if defined?(::Rails)
+                  # If there are no factories, check in the Rails root for some common paths
+                  [
+                    Rails.root.join("factories"),
+                    Rails.root.join("factories.rb"),
+                    Rails.root.join("test", "factories"),
+                    Rails.root.join("test", "factories.rb"),
+                  ].each do |path|
+                    if path.exist?
+                      if path.ftype == "file"
+                        require_relative path.to_s
+                        break
+                      elsif path.ftype == "directory"
+                        require_relative File.join(path, "require")
+                        break
+                      end
+                    end
+                  end
+                end
+              end
+
+              FactoryBot.factories.each do |factory|
+                model = model_klass(factory)
+                next if model.nil?
+
+                name = factory.name
+                base_params = generate_parameters(factory, model)
+                return_type = model.name
+
+                methods_mod.create_method(
+                  "build_#{name}",
+                  parameters: base_params,
+                  return_type: return_type,
+                )
+                methods_mod.create_method(
+                  "create_#{name}",
+                  parameters: base_params,
+                  return_type: return_type,
+                )
+
+                methods_mod.create_method(
+                  "build_#{name}_list",
+                  parameters: [
+                    create_param("count_", type: "Integer"),
+                  ] + base_params,
+                  return_type: "T::Array[#{return_type}]",
+                )
+                methods_mod.create_method(
+                  "create_#{name}_list",
+                  parameters: [
+                    create_param("count_", type: "Integer"),
+                  ] + base_params,
+                  return_type: "T::Array[#{return_type}]",
+                )
+              end
+            end
+            klass.create_include(RBI_MODULE_NAME)
+          end
+        end
+
+        sig { params(factory: FactoryBot::Factory).returns(T.nilable(FactoryBot::Factory)) }
+        def parent_factory(factory)
+          parent = factory.send(:parent)
+          if !parent.is_a?(FactoryBot::NullFactory)
+            parent
+          end
+        end
+
+        sig { params(factory: FactoryBot::Factory).returns(FactoryBot::Factory) }
+        def root_factory(factory)
+          if parent = parent_factory(factory)
+            root_factory(parent)
+          else
+            factory
+          end
+        end
+
+        sig { params(factory: FactoryBot::Factory).returns(T.nilable(T.class_of(ActiveRecord::Base))) }
+        def model_klass(factory)
+          root = root_factory(factory)
+
+          begin
+            klass = Object.const_get(root.name.to_s.classify) # rubocop:disable Sorbet/ConstantsFromStrings
+            klass if klass < ActiveRecord::Base
+          rescue NameError
+            nil
+          end
+        end
+
+        sig do
+          params(
+            factory: FactoryBot::Factory,
+            model: T.class_of(ActiveRecord::Base),
+          ).returns(T::Array[RBI::TypedParam])
+        end
+        def generate_parameters(factory, model)
+          [ create_kw_opt_param("traits_", type: "T::Array[Symbol]", default: "[]") ] +
+            generate_parameters_hash(factory, model).values +
+            [ create_block_param("blk", type: "T.nilable(T.proc.params(arg0: #{model}).void)") ]
+        end
+
+        sig do
+          params(
+            factory: FactoryBot::Factory,
+            model: T.class_of(ActiveRecord::Base),
+          ).returns(T::Hash[Symbol, RBI::TypedParam])
+        end
+        def generate_parameters_hash(factory, model)
+          params = generate_parameters_from_model(model, factory.definition.declarations)
+
+          parent = parent_factory(factory)
+          parent_params =
+            if parent
+              generate_parameters_hash(parent, model)
+            else
+              {}
+            end
+
+          # Clobber any collisions in parent in case fields are redeclared
+          parent_params.merge(params)
+        end
+
+        sig do
+          params(
+            model_klass: T.class_of(ActiveRecord::Base),
+            declarations: FactoryBot::DeclarationList,
+          ).returns(
+            T::Hash[Symbol, RBI::TypedParam],
+          )
+        end
+        def generate_parameters_from_model(model_klass, declarations)
+          declarations.map do |d|
+            type = type_for_declaration(model_klass, d)
+            [ d.name, create_kw_opt_param(d.name, type: nilable(type), default: "nil") ]
+          end.to_h
+        end
+
+        sig do
+          params(
+            model_klass: T.class_of(ActiveRecord::Base),
+            declaration: FactoryBot::Declaration,
+          ).returns(String)
+        end
+        def type_for_declaration(model_klass, declaration)
+          # If the model uses RailsSorbetEnum, use the enum class rather than the column type
+          if model_klass.respond_to?(:sorbet_enum_attributes)
+            enum_klass = T.unsafe(model_klass).sorbet_enum_attributes.to_h[declaration.name]
+            return enum_klass if enum_klass
+          end
+
+          if col_type = model_klass.column_for_attribute(declaration.name.to_s).type
+            convert_db_type_to_sorbet(col_type)
+          elsif col_klass = model_klass.reflect_on_association(declaration.name.to_s)
+            convert_association_to_sorbet(col_klass)
+          else
+            "T.untyped"
+          end
+        end
+
+        sig { params(type: Symbol).returns(String) }
+        def convert_db_type_to_sorbet(type)
+          case type
+          when :big_integer
+            "Integer"
+          when :binary
+            "T.untyped"
+          when :boolean
+            "T::Boolean"
+          when :date
+            "T.untyped"
+          when :datetime
+            "ActiveSupport::TimeWithZone"
+          when :decimal
+            "Float"
+          when :float
+            "Float"
+          when :integer
+            "Integer"
+          when :string
+            "String"
+          else
+            "T.untyped"
+          end
+        end
+
+        sig { params(col_klass: ActiveRecord::Reflection::AbstractReflection).returns(String) }
+        def convert_association_to_sorbet(col_klass)
+          if T.unsafe(col_klass).polymorphic?
+            return "T.untyped"
+          end
+
+          case col_klass
+          when ActiveRecord::Reflection::HasManyReflection,
+            ActiveRecord::Reflection::HasAndBelongsToManyReflection
+            "T::Array[#{col_klass.klass.name}]"
+          else
+            T.unsafe(col_klass).klass.name
+          end
+        end
+
+        sig { params(type: String).returns(String) }
+        def nilable(type)
+          if type == "T.untyped"
+            type
+          else
+            "T.nilable(#{type})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/runtime/reflection_monkey_patch.rb

@@ -0,0 +1,27 @@
+# typed: false
+# frozen_string_literal: true
+
+# rubocop:disable Sorbet
+module Tapioca
+  module Runtime
+    # This just monkey patches the constantize method to rescue ActiveRecord::AdapterNotSpecified
+    # This is needed as a workaround for: https://github.com/Shopify/tapioca/issues/2004
+    #
+    # See also ./sorbet/rbi/shims/gems/tapioca.rbi
+    module ReflectionMonkeyPatch
+      # @without_runtime
+      # (String symbol, ?inherit: bool, ?namespace: Module) -> BasicObject
+      def constantize(symbol, inherit: false, namespace: Object)
+        namespace.const_get(symbol, inherit)
+      rescue NameError, LoadError, RuntimeError, ArgumentError, TypeError, ActiveRecord::AdapterNotSpecified, ActiveRecord::ConnectionNotEstablished
+        ::Tapioca::Runtime::Reflection::UNDEFINED_CONSTANT
+      end
+    end
+  end
+end
+
+# https://github.com/Shopify/tapioca/blob/main/lib/tapioca/runtime/reflection.rb
+if defined?(::Tapioca::Runtime::Reflection)
+  Tapioca::Runtime::Reflection.prepend(Tapioca::Runtime::ReflectionMonkeyPatch)
+end
+# rubocop:enable Sorbet

data/sig/sorbet_factory_bot.rbs

@@ -0,0 +1,4 @@
+module SorbetFactoryBot
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: sorbet_factory_bot
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Franklin Hu
+- Jay Shirley
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: factory_bot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.5.0
+- !ruby/object:Gem::Dependency
+  name: tapioca
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.17'
+- !ruby/object:Gem::Dependency
+  name: sorbet-static-and-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
+description: For projects that use FactoryBot and Sorbet, this generates type signatures
+  for FactoryBot factories
+email:
+- franklin@thisisfranklin.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/sorbet_factory_bot.rb
+- lib/sorbet_factory_bot/helpers.rb
+- lib/sorbet_factory_bot/version.rb
+- lib/tapioca/dsl/compilers/sorbet_factory_bot_compiler.rb
+- lib/tapioca/runtime/reflection_monkey_patch.rb
+- sig/sorbet_factory_bot.rbs
+homepage: https://github.com/jointbits/sorbet_factory_bot
+licenses: []
+metadata:
+  homepage_uri: https://github.com/jointbits/sorbet_factory_bot
+  source_code_uri: https://github.com/jointbits/sorbet_factory_bot
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Helpers for generating Sorbet RBI via Tapioca for FactoryBot factories
+test_files: []