rspec-sorbet-types 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a22cc57159bb8fcf6011e4f526f04da73e7cb0c6a0f8ba2be14b2fda79f1a516
+  data.tar.gz: 7d4cd90ee0792e2b7bd2c8aa64348b8ec2006f57133774d5d6606518a93b3604
+SHA512:
+  metadata.gz: 4f8dea02beb1c65684aa54552cbfa96b8d7335d1da3f36c866b6fba677f88e9debe451f836c633e4053700768de559449266599bb42e9974b641f8034744245f
+  data.tar.gz: 80b33d85703d7b9ebdcc0e8f37c8f3ce7718af361413a2491731895fa6c44825634a5a2e17318ed65a3950c77b156d75c3361cc925b82034d3732799a0e962db

data/lib/rspec/sorbet/types/sig.rb

@@ -0,0 +1,22 @@
+# typed: true
+
+module RSpec
+  module Sorbet
+    module Types
+      module Sig
+        include Kernel
+
+        def self.extended(sub)
+          super
+          sub.extend(T::Sig)
+        end
+
+        T::Sig::WithoutRuntime.sig { params(decl: T.proc.bind(T::Private::Methods::DeclBuilder).void).void }
+        def rsig(&decl)
+          # It would be better if we could simply use the name "sig", but Sorbet falsely reports that as an overload
+          send(:sig, &decl)
+        end
+      end
+    end
+  end
+end

data/lib/rspec/sorbet/types.rb

@@ -0,0 +1,2 @@
+require "sorbet-runtime"
+require_relative "types/sig"

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

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+# typed: strict
+
+require "rspec/core"
+
+module Tapioca
+  module Dsl
+    module Compilers
+      class RSpec < Compiler
+        extend T::Sig
+
+        ConstantType = type_member { {fixed: T.class_of(::RSpec::Core::ExampleGroup)} }
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            all_classes.select { |c| c < ::RSpec::Core::ExampleGroup }
+          end
+
+          private
+
+          sig { void }
+          def require_spec_files!
+            Dir.glob(spec_glob).each do |file|
+              require(file)
+            end
+          end
+
+          sig { returns(String) }
+          def spec_glob
+            ENV["SORBET_RSPEC_GLOB"] || File.join(".", "spec", "**", "*.rb")
+          end
+        end
+
+        # Set environment variable, allowing other code to detect that we're compiling
+        ENV["SORBET_RSPEC_TYPES_COMPILING"] = "1"
+
+        # Load all spec files during compiler definition
+        require_spec_files!
+
+        sig { override.void }
+        def decorate
+          klass = root.create_class(T.must(constant.name), superclass_name: T.must(constant.superclass).name)
+          create_includes(klass)
+          create_example_group_submodules(klass)
+          create_singleton_methods(klass)
+        end
+
+        private
+
+        sig { params(klass: RBI::Scope).void }
+        def create_includes(klass)
+          directly_included_modules_for(constant).each do |mod|
+            klass.create_include("::#{mod}")
+          end
+        end
+
+        # A method can have a signature even if the method is defined dynamically with define_method
+        # The next call to def or define_method will be the one associated with the signature
+        # However, an exception will be raised if we have two signature declarations in a row
+        # without a method definition.
+        sig { params(method_name: Symbol).returns(String) }
+        def return_type_for_let_declaration(method_name)
+          T::Utils.signature_for_instance_method(constant, method_name)&.return_type&.to_s || "T.untyped"
+        end
+
+        sig { params(klass: RBI::Scope).void }
+        def create_example_group_submodules(klass)
+          modules = directly_included_modules_for(constant).select { |mod| mod.name&.start_with?("RSpec::ExampleGroups::") }
+          modules.each do |mod|
+            scope = root.create_module(T.must(mod.name))
+            direct_public_instance_methods_for(mod).each do |method_name|
+              method_def = mod.instance_method(method_name)
+              return_type = return_type_for_let_declaration(method_name)
+
+              scope.create_method(
+                method_def.name.to_s,
+                parameters: compile_method_parameters_to_rbi(method_def),
+                return_type:,
+                class_method: false
+              )
+            end
+          end
+        end
+
+        sig { params(klass: RBI::Scope).void }
+        def create_singleton_methods(klass)
+          scope = klass.create_class("<< self")
+          scope.create_method(
+            "let",
+            parameters: [
+              create_rest_param("name", type: "T.untyped"),
+              create_block_param("block", type: "T.proc.bind(#{constant.name}).void")
+            ]
+          )
+          scope.create_method(
+            "let!",
+            parameters: [
+              create_rest_param("name", type: "T.untyped"),
+              create_block_param("block", type: "T.proc.bind(#{constant.name}).void")
+            ]
+          )
+
+          scope.create_method(
+            "before",
+            parameters: [
+              create_rest_param("args", type: "T.untyped"),
+              create_block_param("block", type: "T.proc.bind(#{constant.name}).void")
+            ]
+          )
+
+          scope.create_method(
+            "after",
+            parameters: [
+              create_rest_param("args", type: "T.untyped"),
+              create_block_param("block", type: "T.proc.bind(#{constant.name}).void")
+            ]
+          )
+
+          scope.create_method(
+            "it",
+            parameters: [
+              create_rest_param("all_args", type: "T.untyped"),
+              create_block_param("block", type: "T.proc.bind(#{constant.name}).void")
+            ]
+          )
+
+          scope.create_method(
+            "specify",
+            parameters: [
+              create_rest_param("all_args", type: "T.untyped"),
+              create_block_param("block", type: "T.proc.bind(#{constant.name}).void")
+            ]
+          )
+
+          scope.create_method(
+            "subject",
+            parameters: [
+              create_block_param("block", type: "T.proc.bind(#{constant.name}).void")
+            ]
+          )
+
+          singleton_class = constant.singleton_class
+          direct_public_instance_methods_for(singleton_class).each do |method_name|
+            create_method_from_def(scope, singleton_class.instance_method(method_name))
+          end
+        end
+
+        sig { params(constant: Module).returns(T::Enumerable[Module]) }
+        def directly_included_modules_for(constant)
+          result = constant.included_modules
+          result -= constant.included_modules.map do |included_mod|
+            included_mod.ancestors - [included_mod]
+          end.flatten
+          if constant.is_a?(Class) && constant.superclass
+            result -= T.must(constant.superclass).included_modules
+          end
+          result
+        end
+
+        sig { params(constant: Module).returns(T::Enumerable[Symbol]) }
+        def direct_public_instance_methods_for(constant)
+          result = constant.public_instance_methods
+          constant.included_modules.each do |included_mod|
+            result -= included_mod.public_instance_methods
+          end
+          if constant.is_a?(Class) && constant.superclass
+            result -= T.must(constant.superclass).public_instance_methods
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/rbi/rspec-core.rbi

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+# typed: strict
+
+module RSpec
+  class << self
+    sig do
+      params(
+        args: T.untyped,
+        example_group_block: T.proc.bind(T.class_of(RSpec::Core::ExampleGroup)).void,
+      ).void
+    end
+
+    def describe(*args, &example_group_block); end
+  end
+end
+
+class RSpec::Core::ExampleGroup
+  include ::RSpec::Matchers
+  include ::RSpec::Mocks::ExampleMethods
+
+  class << self
+    sig do
+      params(
+        all_args: T.untyped,
+        block: T.proc.bind(RSpec::Core::ExampleGroup).void,
+      ).void
+    end
+
+    def it(*all_args, &block); end
+
+    sig do
+      params(
+        all_args: T.untyped,
+        block: T.proc.bind(RSpec::Core::ExampleGroup).void,
+      ).void
+    end
+
+    def specify(*all_args, &block); end
+
+    sig do
+      params(
+        args: T.untyped,
+        block: T.proc.bind(RSpec::Core::ExampleGroup).void,
+      ).void
+    end
+
+    def before(*args, &block); end
+
+    sig do
+      params(
+        args: T.untyped,
+        block: T.proc.bind(RSpec::Core::ExampleGroup).void,
+      ).void
+    end
+
+    def after(*args, &block); end
+
+    sig do
+      params(
+        args: T.untyped,
+        block: T.proc.bind(RSpec::Core::ExampleGroup).void,
+      ).void
+    end
+
+    def around(*args, &block); end
+  end
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: rspec-sorbet-types
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Hongli Lai
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-01-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sorbet-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tapioca
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.16'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A gem that provides integration between Sorbet type checking and RSpec
+  testing framework
+email:
+- hongli@hongli.nl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rspec/sorbet/types.rb
+- lib/rspec/sorbet/types/sig.rb
+- lib/tapioca/dsl/compilers/rspec.rb
+- rbi/rspec-core.rbi
+homepage: https://github.com/FooBarWidget/sorbet-rspec
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/FooBarWidget/sorbet-rspec
+  source_code_uri: https://github.com/FooBarWidget/sorbet-rspec
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: Sorbet integration for RSpec
+test_files: []