tapioca 0.11.8 → 0.11.9

data/lib/tapioca/gem/pipeline.rb

@@ -50,6 +50,8 @@ module Tapioca
         @root
       end
 
+      # Events handling
+
       sig { params(symbol: String).void }
       def push_symbol(symbol)
         @events << Gem::SymbolFound.new(symbol)
@@ -98,6 +100,8 @@ module Tapioca
         @events << Gem::MethodNodeAdded.new(symbol, constant, method, node, signature, parameters)
       end
 
+      # Constants and properties filtering
+
       sig { params(symbol_name: String).returns(T::Boolean) }
       def symbol_in_payload?(symbol_name)
         symbol_name = symbol_name[2..-1] if symbol_name.start_with?("::")
@@ -106,16 +110,27 @@ module Tapioca
         @payload_symbols.include?(symbol_name)
       end
 
+      # this looks something like:
+      # "(eval at /path/to/file.rb:123)"
+      # and we are just interested in the "/path/to/file.rb" part
+      EVAL_SOURCE_FILE_PATTERN = T.let(/\(eval at (.+):\d+\)/, Regexp)
+
       sig { params(name: T.any(String, Symbol)).returns(T::Boolean) }
       def constant_in_gem?(name)
         return true unless Object.respond_to?(:const_source_location)
 
-        source_location, _ = Object.const_source_location(name)
-        return true unless source_location
+        source_file, _ = Object.const_source_location(name)
+        return true unless source_file
         # If the source location of the constant is "(eval)", all bets are off.
-        return true if source_location == "(eval)"
+        return true if source_file == "(eval)"
 
-        gem.contains_path?(source_location)
+        # Ruby 3.3 adds automatic definition of source location for evals if
+        # `file` and `line` arguments are not provided. This results in the source
+        # file being something like `(eval at /path/to/file.rb:123)`. We try to parse
+        # this string to get the actual source file.
+        source_file = source_file.sub(EVAL_SOURCE_FILE_PATTERN, "\\1")
+
+        gem.contains_path?(source_file)
       end
 
       sig { params(method: UnboundMethod).returns(T::Boolean) }
@@ -126,6 +141,8 @@ module Tapioca
         @gem.contains_path?(source_location)
       end
 
+      # Helpers
+
       sig { params(constant: Module).returns(T.nilable(String)) }
       def name_of(constant)
         name = name_of_proxy_target(constant, super(class_of(constant)))
@@ -149,6 +166,8 @@ module Tapioca
         gem_symbols.union(engine_symbols)
       end
 
+      # Events handling
+
       sig { returns(Gem::Event) }
       def next_event
         T.must(@events.shift)
@@ -171,7 +190,7 @@ module Tapioca
       sig { params(event: Gem::SymbolFound).void }
       def on_symbol(event)
         symbol = event.symbol.delete_prefix("::")
-        return if symbol_in_payload?(symbol) && !@bootstrap_symbols.include?(symbol)
+        return if skip_symbol?(symbol)
 
         constant = constantize(symbol)
         push_constant(symbol, constant) if Runtime::Reflection.constant_defined?(constant)
@@ -180,13 +199,7 @@ module Tapioca
       sig { params(event: Gem::ConstantFound).void.checked(:never) }
       def on_constant(event)
         name = event.symbol
-
-        return if name.strip.empty?
-        return if name.start_with?("#<")
-        return if name.downcase == name
-        return if alias_namespaced?(name)
-
-        return if T::Enum === event.constant # T::Enum instances are defined via `compile_enums`
+        return if skip_constant?(name, event.constant)
 
         if event.is_a?(Gem::ForeignConstantFound)
           compile_foreign_constant(name, event.constant)
@@ -200,11 +213,17 @@ module Tapioca
         @node_listeners.each { |listener| listener.dispatch(event) }
       end
 
-      # Compile
+      # Compiling
 
       sig { params(symbol: String, constant: Module).void }
       def compile_foreign_constant(symbol, constant)
-        compile_module(symbol, constant, foreign_constant: true)
+        return if skip_foreign_constant?(symbol, constant)
+        return if seen?(symbol)
+
+        seen!(symbol)
+
+        scope = compile_scope(symbol, constant)
+        push_foreign_scope(symbol, constant, scope)
       end
 
       sig { params(symbol: String, constant: BasicObject).void.checked(:never) }
@@ -225,10 +244,9 @@ module Tapioca
       def compile_alias(name, constant)
         return if seen?(name)
 
-        mark_seen(name)
+        seen!(name)
 
-        return if symbol_in_payload?(name)
-        return unless constant_in_gem?(name)
+        return if skip_alias?(name, constant)
 
         target = name_of(constant)
         # If target has no name, let's make it an anonymous class or module with `Class.new` or `Module.new`
@@ -247,10 +265,9 @@ module Tapioca
       def compile_object(name, value)
         return if seen?(name)
 
-        mark_seen(name)
+        seen!(name)
 
-        return if symbol_in_payload?(name)
-        return unless constant_in_gem?(name)
+        return if skip_object?(name, value)
 
         klass = class_of(value)
 
@@ -279,29 +296,29 @@ module Tapioca
         @root << node
       end
 
-      sig { params(name: String, constant: Module, foreign_constant: T::Boolean).void }
-      def compile_module(name, constant, foreign_constant: false)
-        return unless defined_in_gem?(constant, strict: false) || foreign_constant
-        return if Tapioca::TypeVariableModule === constant
+      sig { params(name: String, constant: Module).void }
+      def compile_module(name, constant)
+        return if skip_module?(name, constant)
         return if seen?(name)
 
-        mark_seen(name)
+        seen!(name)
 
-        scope =
-          if constant.is_a?(Class)
-            superclass = compile_superclass(constant)
-            RBI::Class.new(name, superclass_name: superclass)
-          else
-            RBI::Module.new(name)
-          end
+        scope = compile_scope(name, constant)
+        push_scope(name, constant, scope)
+      end
 
-        if foreign_constant
-          push_foreign_scope(name, constant, scope)
+      sig { params(name: String, constant: Module).returns(RBI::Scope) }
+      def compile_scope(name, constant)
+        scope = if constant.is_a?(Class)
+          superclass = compile_superclass(constant)
+          RBI::Class.new(name, superclass_name: superclass)
         else
-          push_scope(name, constant, scope)
+          RBI::Module.new(name)
         end
 
         @root << scope
+
+        scope
       end
 
       sig { params(constant: T::Class[T.anything]).returns(T.nilable(String)) }
@@ -353,6 +370,54 @@ module Tapioca
         "::#{name}"
       end
 
+      # Constants and properties filtering
+
+      sig { params(name: String).returns(T::Boolean) }
+      def skip_symbol?(name)
+        symbol_in_payload?(name) && !@bootstrap_symbols.include?(name)
+      end
+
+      sig { params(name: String, constant: T.anything).returns(T::Boolean).checked(:never) }
+      def skip_constant?(name, constant)
+        return true if name.strip.empty?
+        return true if name.start_with?("#<")
+        return true if name.downcase == name
+        return true if alias_namespaced?(name)
+
+        return true if T::Enum === constant # T::Enum instances are defined via `compile_enums`
+
+        false
+      end
+
+      sig { params(name: String, constant: Module).returns(T::Boolean) }
+      def skip_alias?(name, constant)
+        return true if symbol_in_payload?(name)
+        return true unless constant_in_gem?(name)
+
+        false
+      end
+
+      sig { params(name: String, constant: BasicObject).returns(T::Boolean).checked(:never) }
+      def skip_object?(name, constant)
+        return true if symbol_in_payload?(name)
+        return true unless constant_in_gem?(name)
+
+        false
+      end
+
+      sig { params(name: String, constant: Module).returns(T::Boolean) }
+      def skip_foreign_constant?(name, constant)
+        Tapioca::TypeVariableModule === constant
+      end
+
+      sig { params(name: String, constant: Module).returns(T::Boolean) }
+      def skip_module?(name, constant)
+        return true unless defined_in_gem?(constant, strict: false)
+        return true if Tapioca::TypeVariableModule === constant
+
+        false
+      end
+
       sig { params(constant: Module, strict: T::Boolean).returns(T::Boolean) }
       def defined_in_gem?(constant, strict: true)
         files = get_file_candidates(constant)
@@ -385,7 +450,7 @@ module Tapioca
       end
 
       sig { params(name: String).void }
-      def mark_seen(name)
+      def seen!(name)
         @seen.add(name)
       end
 
@@ -394,6 +459,8 @@ module Tapioca
         @seen.include?(name)
       end
 
+      # Helpers
+
       sig { params(constant: T.all(Module, T::Generic)).returns(String) }
       def generic_name_of(constant)
         type_name = T.must(constant.name)

data/lib/tapioca/gemfile.rb

@@ -156,6 +156,11 @@ module Tapioca
         @spec.name
       end
 
+      sig { returns(T::Array[::Gem::Dependency]) }
+      def dependencies
+        @spec.dependencies
+      end
+
       sig { returns(String) }
       def rbi_file_name
         "#{name}@#{version}.rbi"
@@ -230,13 +235,14 @@ module Tapioca
 
       sig { returns(Regexp) }
       def require_paths_prefix_matcher
-        @require_paths_prefix_matcher = T.let(@require_paths_prefix_matcher, T.nilable(Regexp))
-
-        @require_paths_prefix_matcher ||= begin
-          require_paths = T.unsafe(@spec).require_paths
-          prefix_matchers = require_paths.map { |rp| Regexp.new("^#{rp}/") }
-          Regexp.union(prefix_matchers)
-        end
+        @require_paths_prefix_matcher ||= T.let(
+          begin
+            require_paths = T.unsafe(@spec).require_paths
+            prefix_matchers = require_paths.map { |rp| Regexp.new("^#{rp}/") }
+            Regexp.union(prefix_matchers)
+          end,
+          T.nilable(Regexp),
+        )
       end
 
       sig { params(file: String).returns(Pathname) }

data/lib/tapioca/helpers/git_attributes.rb

@@ -0,0 +1,34 @@
+# typed: strict
+# frozen_string_literal: true
+
+class GitAttributes
+  class << self
+    extend T::Sig
+
+    sig { params(path: Pathname).void }
+    def create_generated_attribute_file(path)
+      create_gitattributes_file(path, <<~CONTENT)
+        **/*.rbi linguist-generated=true
+      CONTENT
+    end
+
+    sig { params(path: Pathname).void }
+    def create_vendored_attribute_file(path)
+      create_gitattributes_file(path, <<~CONTENT)
+        **/*.rbi linguist-vendored=true
+      CONTENT
+    end
+
+    private
+
+    sig { params(path: Pathname, content: String).void }
+    def create_gitattributes_file(path, content)
+      # We don't want to start creating folders, just to write
+      # the `.gitattributes` file. So, if the folder doesn't
+      # exist, we just return.
+      return unless path.exist?
+
+      File.write(path.join(".gitattributes"), content)
+    end
+  end
+end

data/lib/tapioca/helpers/test/template.rb

@@ -24,12 +24,12 @@ module Tapioca
           ::Gem::Requirement.new(selector).satisfied_by?(ActiveSupport.gem_version)
         end
 
-        sig { params(src: String).returns(String) }
-        def template(src)
+        sig { params(src: String, trim_mode: String).returns(String) }
+        def template(src, trim_mode: ">")
           erb = if ERB_SUPPORTS_KVARGS
-            ::ERB.new(src, trim_mode: ">")
+            ::ERB.new(src, trim_mode: trim_mode)
           else
-            ::ERB.new(src, nil, ">")
+            ::ERB.new(src, nil, trim_mode)
           end
 
           erb.result(binding)

data/lib/tapioca/internal.rb

@@ -28,6 +28,7 @@ require "yard-sorbet"
 require "tapioca/runtime/dynamic_mixin_compiler"
 require "tapioca/helpers/gem_helper"
 
+require "tapioca/helpers/git_attributes"
 require "tapioca/helpers/sorbet_helper"
 require "tapioca/helpers/rbi_helper"
 require "tapioca/sorbet_ext/backcompat_patches"

data/lib/tapioca/loaders/dsl.rb

@@ -46,7 +46,17 @@ module Tapioca
 
       sig { void }
       def load_dsl_extensions
-        Dir["#{__dir__}/../dsl/extensions/*.rb"].sort.each { |f| require(f) }
+        say("Loading DSL extension classes... ")
+
+        Dir.glob(["#{@tapioca_path}/extensions/**/*.rb"]).each do |extension|
+          require File.expand_path(extension)
+        end
+
+        ::Gem.find_files("tapioca/dsl/extensions/*.rb").each do |extension|
+          require File.expand_path(extension)
+        end
+
+        say("Done", :green)
       end
 
       sig { void }

data/lib/tapioca/sorbet_ext/generic_name_patch.rb

@@ -191,19 +191,6 @@ module Tapioca
     sig { returns(T.nilable(String)) }
     def name
       constant_name = super
-
-      # This is a hack to work around modules under anonymous modules not having
-      # names in 2.7: https://bugs.ruby-lang.org/issues/14895
-      #
-      # This happens when a type variable is declared under `class << self`, for
-      # example.
-      #
-      # The workaround is to give the parent context a name, at which point, our
-      # module gets bound to a name under that name, as well.
-      unless constant_name
-        constant_name = with_bound_name_pre_3_0 { super }
-      end
-
       constant_name&.split("::")&.last
     end
 
@@ -247,20 +234,6 @@ module Tapioca
       -> { bounds }
     end
 
-    sig do
-      type_parameters(:Result)
-        .params(block: T.proc.returns(T.type_parameter(:Result)))
-        .returns(T.type_parameter(:Result))
-    end
-    def with_bound_name_pre_3_0(&block)
-      require "securerandom"
-      temp_name = "TYPE_VARIABLE_TRACKING_#{SecureRandom.hex}"
-      self.class.const_set(temp_name, @context)
-      block.call
-    ensure
-      self.class.send(:remove_const, temp_name) if temp_name
-    end
-
     sig { returns(T::Hash[Symbol, T.untyped]) }
     def bounds
       @bounds ||= @bounds_proc.call

data/lib/tapioca/static/symbol_loader.rb

@@ -59,14 +59,15 @@ module Tapioca
 
         sig { returns(T::Array[T.class_of(Rails::Engine)]) }
         def engines
-          @engines = T.let(@engines, T.nilable(T::Array[T.class_of(Rails::Engine)]))
-
-          @engines ||= if Object.const_defined?("Rails::Engine")
-            descendants_of(Object.const_get("Rails::Engine"))
-              .reject(&:abstract_railtie?)
-          else
-            []
-          end
+          @engines ||= T.let(
+            if Object.const_defined?("Rails::Engine")
+              descendants_of(Object.const_get("Rails::Engine"))
+                .reject(&:abstract_railtie?)
+            else
+              []
+            end,
+            T.nilable(T::Array[T.class_of(Rails::Engine)]),
+          )
         end
 
         sig { params(input: String, table_type: String).returns(String) }

data/lib/tapioca/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Tapioca
-  VERSION = "0.11.8"
+  VERSION = "0.11.9"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.11.8
+  version: 0.11.9
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-07-12 00:00:00.000000000 Z
+date: 2023-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -61,20 +61,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.0
+        version: 0.1.0
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.16
+        version: 0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.0
+        version: 0.1.0
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.16
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: sorbet-static-and-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -152,13 +152,19 @@ files:
 - lib/tapioca/bundler_ext/auto_require_hook.rb
 - lib/tapioca/cli.rb
 - lib/tapioca/commands.rb
+- lib/tapioca/commands/abstract_dsl.rb
+- lib/tapioca/commands/abstract_gem.rb
 - lib/tapioca/commands/annotations.rb
 - lib/tapioca/commands/check_shims.rb
 - lib/tapioca/commands/command.rb
 - lib/tapioca/commands/command_without_tracker.rb
 - lib/tapioca/commands/configure.rb
-- lib/tapioca/commands/dsl.rb
-- lib/tapioca/commands/gem.rb
+- lib/tapioca/commands/dsl_compiler_list.rb
+- lib/tapioca/commands/dsl_generate.rb
+- lib/tapioca/commands/dsl_verify.rb
+- lib/tapioca/commands/gem_generate.rb
+- lib/tapioca/commands/gem_sync.rb
+- lib/tapioca/commands/gem_verify.rb
 - lib/tapioca/commands/require.rb
 - lib/tapioca/commands/todo.rb
 - lib/tapioca/dsl.rb
@@ -170,6 +176,7 @@ files:
 - lib/tapioca/dsl/compilers/active_job.rb
 - lib/tapioca/dsl/compilers/active_model_attributes.rb
 - lib/tapioca/dsl/compilers/active_model_secure_password.rb
+- lib/tapioca/dsl/compilers/active_model_validations_confirmation.rb
 - lib/tapioca/dsl/compilers/active_record_associations.rb
 - lib/tapioca/dsl/compilers/active_record_columns.rb
 - lib/tapioca/dsl/compilers/active_record_delegated_types.rb
@@ -188,6 +195,7 @@ files:
 - lib/tapioca/dsl/compilers/graphql_input_object.rb
 - lib/tapioca/dsl/compilers/graphql_mutation.rb
 - lib/tapioca/dsl/compilers/identity_cache.rb
+- lib/tapioca/dsl/compilers/json_api_client_resource.rb
 - lib/tapioca/dsl/compilers/kredis.rb
 - lib/tapioca/dsl/compilers/mixed_in_class_attributes.rb
 - lib/tapioca/dsl/compilers/protobuf.rb
@@ -228,6 +236,7 @@ files:
 - lib/tapioca/helpers/config_helper.rb
 - lib/tapioca/helpers/env_helper.rb
 - lib/tapioca/helpers/gem_helper.rb
+- lib/tapioca/helpers/git_attributes.rb
 - lib/tapioca/helpers/rbi_files_helper.rb
 - lib/tapioca/helpers/rbi_helper.rb
 - lib/tapioca/helpers/sorbet_helper.rb
@@ -276,14 +285,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.16
+rubygems_version: 3.4.19
 signing_key: 
 specification_version: 4
 summary: A Ruby Interface file generator for gems, core types and the Ruby standard