tapioca 0.16.2 → 0.16.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc2c2c6ae059634316e511dce8839f7e4930b0263093e6250612aa7d6aae582d
-  data.tar.gz: 7ee41089cca733c46e3d3c9dca9384c1e8a516fd7ebb0fb347eb31935da8d3ee
+  metadata.gz: 80c01f44b0600c3a471756da73e43322f23a951c8f3ebc15c922173a0ccf4d3c
+  data.tar.gz: c778cfa78b0494513f5ad329e432c534486c3ba75fcf83969462a874c7dc7654
 SHA512:
-  metadata.gz: 00ecd9606853f9bf27821df7c20b74af4898d84d5b3a32472a5156c2d0ba353b4ab53e7ddc4d21474a2b1599409aecad05693ac6713100798a4cf77dc2d50b83
-  data.tar.gz: 4b8d2455cf3cd89c0744d4e266331ee61c3ca585380db1da348bafaa014fbeaa7483401100f1148f8c89fe21119c9a555e9af86be3699ba2733f48cab1929901
+  metadata.gz: f12a7fbe0d64109a5de03d8a98f564413bee79dc0db1ced8c1eaeae8dae73e68c73e8e76a188a06ddfefa333b11024d606359b7f706d13e15dacea081b0a19ea
+  data.tar.gz: 99ef8194c8dab5e776b591992aefa8b59b0b8e2d8927caecfc68d63bf7bb4c7687a92af772c6f8ac5fcfbdd8ebe1f9c1b748a2334b8207d233939d35d02d2b26

data/lib/tapioca/dsl/compiler.rb

@@ -25,6 +25,8 @@ module Tapioca
       sig { returns(T::Hash[String, T.untyped]) }
       attr_reader :options
 
+      @@requested_constants = T.let([], T::Array[Module]) # rubocop:disable Style/ClassVars
+
       class << self
         extend T::Sig
 
@@ -44,12 +46,39 @@ module Tapioca
           )
         end
 
+        sig { params(constants: T::Array[Module]).void }
+        def requested_constants=(constants)
+          @@requested_constants = constants # rubocop:disable Style/ClassVars
+        end
+
         private
 
+        sig do
+          type_parameters(:U)
+            .params(klass: T.all(T::Class[T.anything], T.type_parameter(:U)))
+            .returns(T::Array[T.type_parameter(:U)])
+        end
+        def descendants_of(klass)
+          if @@requested_constants.any?
+            T.cast(
+              @@requested_constants.select do |k|
+                k < klass && !k.singleton_class?
+              end,
+              T::Array[T.type_parameter(:U)],
+            )
+          else
+            super
+          end
+        end
+
         sig { returns(T::Enumerable[T::Class[T.anything]]) }
         def all_classes
           @all_classes ||= T.let(
-            ObjectSpace.each_object(Class),
+            if @@requested_constants.any?
+              @@requested_constants.grep(Class)
+            else
+              ObjectSpace.each_object(Class)
+            end,
             T.nilable(T::Enumerable[T::Class[T.anything]]),
           )
         end
@@ -57,7 +86,11 @@ module Tapioca
         sig { returns(T::Enumerable[Module]) }
         def all_modules
           @all_modules ||= T.let(
-            ObjectSpace.each_object(Module),
+            if @@requested_constants.any?
+              @@requested_constants.select { |k| k.is_a?(Module) }
+            else
+              ObjectSpace.each_object(Module)
+            end,
             T.nilable(T::Enumerable[Module]),
           )
         end

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

@@ -69,6 +69,17 @@ module Tapioca
             T::Array[String],
           )
 
+        TRANSITION_CALLBACKS =
+          T.let(
+            [
+              "on_transition",
+              "guard",
+              "after",
+              "success",
+            ].freeze,
+            T::Array[String],
+          )
+
         ConstantType = type_member { { fixed: T.all(T::Class[::AASM], ::AASM::ClassMethods) } }
 
         sig { override.void }
@@ -162,8 +173,37 @@ module Tapioca
                     method,
                     parameters: [
                       create_opt_param("symbol", type: "T.nilable(Symbol)", default: "nil"),
-                      create_block_param("block", type: "T.nilable(T.proc.bind(#{constant_name}).void)"),
+                      create_block_param(
+                        "block",
+                        type: "T.nilable(T.proc.bind(#{constant_name}).params(opts: T.untyped).void)",
+                      ),
+                    ],
+                  )
+                end
+
+                event.create_method(
+                  "transitions",
+                  parameters: [
+                    create_opt_param("definitions", default: "nil", type: "T.untyped"),
+                    create_block_param("block", type: "T.nilable(T.proc.bind(PrivateAASMTransition).void)"),
+                  ],
+                )
+              end
+
+              machine.create_class("PrivateAASMTransition", superclass_name: "AASM::Core::Transition") do |transition|
+                TRANSITION_CALLBACKS.each do |method|
+                  return_type = "T.untyped"
+                  return_type = "T::Boolean" if method == "guard"
+
+                  transition.create_method(
+                    method,
+                    parameters: [
+                      create_block_param(
+                        "block",
+                        type: "T.nilable(T.proc.bind(#{constant_name}).params(opts: T.untyped).void)",
+                      ),
                     ],
+                    return_type: return_type,
                   )
                 end
               end

data/lib/tapioca/dsl/helpers/active_record_column_type_helper.rb

@@ -88,17 +88,24 @@ module Tapioca
         sig { returns([String, String]) }
         def id_type
           if @constant.respond_to?(:composite_primary_key?) && T.unsafe(@constant).composite_primary_key?
-            @constant.primary_key.map do |column|
-              column_type_for(column)
-            end.map do |tuple|
-              "[#{tuple.join(", ")}]"
+            primary_key_columns = @constant.primary_key
+
+            getters = []
+            setters = []
+
+            primary_key_columns.each do |column|
+              getter, setter = column_type_for(column)
+              getters << getter
+              setters << setter
             end
+
+            ["[#{getters.join(", ")}]", "[#{setters.join(", ")}]"]
           else
             column_type_for(@constant.primary_key)
           end
         end
 
-        sig { params(column_name: String).returns([String, String]) }
+        sig { params(column_name: T.nilable(String)).returns([String, String]) }
         def column_type_for(column_name)
           return ["T.untyped", "T.untyped"] if @column_type_option.untyped?
 
@@ -179,11 +186,31 @@ module Tapioca
                    ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Hstore === type
                }
             "T::Hash[::String, ::String]"
+          when ->(type) {
+                 defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Interval) &&
+                   ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Interval === type
+               }
+            "::ActiveSupport::Duration"
           when ->(type) {
                  defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array) &&
                    ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array === type
                }
             "T::Array[#{type_for_activerecord_value(column_type.subtype, column_nullability:)}]"
+          when ->(type) {
+                 defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Bit) &&
+                   ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Bit === type
+               }
+            "::String"
+          when ->(type) {
+                 defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::BitVarying) &&
+                   ActiveRecord::ConnectionAdapters::PostgreSQL::OID::BitVarying === type
+               }
+            "::String"
+          when ->(type) {
+                 defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Range) &&
+                   ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Range === type
+               }
+            "T::Range[#{type_for_activerecord_value(column_type.subtype, column_nullability:)}]"
           else
             as_non_nilable_if_persisted_and_not_nullable(
               ActiveModelTypeHelper.type_for(column_type),

data/lib/tapioca/dsl/pipeline.rb

@@ -145,6 +145,7 @@ module Tapioca
         ).returns(T::Set[Module])
       end
       def gather_constants(requested_constants, requested_paths, skipped_constants)
+        Compiler.requested_constants = requested_constants
         constants = Set.new.compare_by_identity
         active_compilers.each do |compiler|
           constants.merge(compiler.processable_constants)

data/lib/tapioca/helpers/rbi_helper.rb

@@ -107,36 +107,12 @@ module Tapioca
 
     sig { params(name: String).returns(T::Boolean) }
     def valid_method_name?(name)
-      # try to parse a method definition with this name
-      iseq = RubyVM::InstructionSequence.compile("def #{name}; end", nil, nil, 0, false)
-      # pull out the first operation in the instruction sequence and its first argument
-      op, arg, _data = iseq.to_a.dig(-1, 0)
-      # make sure that the operation is a method definition and the method that was
-      # defined has the expected name, for example, for `def !foo; end` we don't get
-      # a syntax error but instead get a method defined as `"foo"`
-      op == :definemethod && arg == name.to_sym
-    rescue SyntaxError
-      false
+      Prism.parse_success?("def self.#{name}(a); end")
     end
 
     sig { params(name: String).returns(T::Boolean) }
     def valid_parameter_name?(name)
-      sentinel_method_name = :sentinel_method_name
-      # try to parse a method definition with this name as the name of a
-      # keyword parameter. If we use a positional parameter, then parameter names
-      # like `&` (and maybe others) will be treated like `def foo(&); end` and will
-      # thus be considered valid. Using a required keyword parameter prevents that
-      # confusion between Ruby syntax and parameter name.
-      iseq = RubyVM::InstructionSequence.compile("def #{sentinel_method_name}(#{name}:); end", nil, nil, 0, false)
-      # pull out the first operation in the instruction sequence and its first argument and data
-      op, arg, data = iseq.to_a.dig(-1, 0)
-      # make sure that:
-      # 1. a method was defined, and
-      # 2. the method has the expected method name, and
-      # 3. the method has a keyword parameter with the expected name
-      op == :definemethod && arg == sentinel_method_name && data.dig(11, :keyword, 0) == name.to_sym
-    rescue SyntaxError
-      false
+      Prism.parse_success?("def sentinel_method_name(#{name}:); end")
     end
   end
 end

data/lib/tapioca/helpers/source_uri.rb

@@ -18,6 +18,13 @@ module URI
       T::Array[Symbol],
     )
 
+    # `uri` for Ruby 3.4 switched the default parser from RFC2396 to RFC3986. The new parser emits a deprecation
+    # warning on a few methods and delegates them to RFC2396, namely `extract`/`make_regexp`/`escape`/`unescape`.
+    # On earlier versions of the uri gem, the RFC2396_PARSER constant doesn't exist, so it needs some special
+    # handling to select a parser that doesn't emit deprecations. While it was backported to Ruby 3.1, users may
+    # have the uri gem in their own bundle and thus not use a compatible version.
+    PARSER = T.let(const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER, RFC2396_Parser)
+
     alias_method(:gem_name, :host)
     alias_method(:line_number, :fragment)
 
@@ -40,7 +47,7 @@ module URI
           {
             scheme: "source",
             host: gem_name,
-            path: DEFAULT_PARSER.escape("/#{gem_version}/#{path}"),
+            path: PARSER.escape("/#{gem_version}/#{path}"),
             fragment: line_number,
           }
         )

data/lib/tapioca/internal.rb

@@ -23,6 +23,7 @@ require "tempfile"
 require "thor"
 require "yaml"
 require "yard-sorbet"
+require "prism"
 
 require "tapioca/runtime/dynamic_mixin_compiler"
 require "tapioca/sorbet_ext/backcompat_patches"

data/lib/tapioca/runtime/reflection.rb

@@ -178,13 +178,19 @@ module Tapioca
       end
 
       # Examines the call stack to identify the closest location where a "require" is performed
-      # by searching for the label "<top (required)>". If none is found, it returns the location
+      # by searching for the label "<top (required)>" or "block in <class:...>" in the
+      # case of an ActiveSupport.on_load hook. If none is found, it returns the location
       # labeled "<main>", which is the original call site.
       sig { params(locations: T.nilable(T::Array[Thread::Backtrace::Location])).returns(String) }
       def resolve_loc(locations)
         return "" unless locations
 
-        resolved_loc = locations.find { |loc| REQUIRED_FROM_LABELS.include?(loc.label) }
+        resolved_loc = locations.find do |loc|
+          label = loc.label
+          next unless label
+
+          REQUIRED_FROM_LABELS.include?(label) || label.start_with?("block in <class:")
+        end
         return "" unless resolved_loc
 
         resolved_loc.absolute_path || ""

data/lib/tapioca/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.16.2
+  version: 0.16.4
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-29 00:00:00.000000000 Z
+date: 2024-11-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -284,7 +284,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.17
+rubygems_version: 3.5.23
 signing_key:
 specification_version: 4
 summary: A Ruby Interface file generator for gems, core types and the Ruby standard