tapioca 0.10.4 → 0.11.0

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

@@ -45,7 +45,11 @@ module Tapioca
 
         sig { override.void }
         def decorate
-          arguments = constant.all_argument_definitions
+          # Skip methods explicitly defined in code
+          arguments = constant.all_argument_definitions.select do |argument|
+            method_defined_by_graphql?(argument.keyword.to_s)
+          end
+
           return if arguments.empty?
 
           root.create_path(constant) do |input_object|
@@ -56,6 +60,22 @@ module Tapioca
           end
         end
 
+        private
+
+        sig { returns(T.nilable(String)) }
+        def graphql_input_object_argument_source_file
+          @graphql_input_object_argument_source_file ||= T.let(
+            GraphQL::Schema::InputObject.method(:argument).source_location&.first,
+            T.nilable(String),
+          )
+        end
+
+        sig { params(method_name: String).returns(T::Boolean) }
+        def method_defined_by_graphql?(method_name)
+          method_file = constant.instance_method(method_name).source_location&.first
+          !!(method_file && graphql_input_object_argument_source_file == method_file)
+        end
+
         class << self
           extend T::Sig
 

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

@@ -0,0 +1,130 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "kredis"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::Kredis` decorates RBI files for all
+      # classes that include [`Kredis::Attributes`](https://github.com/rails/kredis/blob/main/lib/kredis/attributes.rb).
+      #
+      # For example, with the following class:
+      #
+      # ~~~rb
+      # class Person < ApplicationRecord
+      #   kredis_list :names
+      #   kredis_flag :awesome
+      #   kredis_counter :steps, expires_in: 1.hour
+      #   kredis_enum :morning, values: %w[ bright blue black ], default: "bright"
+      # end
+      # ~~~
+      #
+      # this compiler will produce an RBI file with the following content:
+      # ~~~rbi
+      # # typed: true
+      #
+      # class Person
+      #   module GeneratedKredisAttributeMethods
+      #     sig { returns(Kredis::Types::Flag) }
+      #     def awesome; end
+      #
+      #     sig { returns(T::Boolean) }
+      #     def awesome?; end
+      #
+      #     sig { returns(PrivateEnumMorning) }
+      #     def morning; end
+      #
+      #     sig { returns(Kredis::Types::List) }
+      #     def names; end
+      #
+      #     sig { returns(Kredis::Types::Counter) }
+      #     def steps; end
+      #
+      #     class PrivateEnumMorning < Kredis::Types::Enum
+      #       sig { void }
+      #       def black!; end
+      #
+      #       sig { returns(T::Boolean) }
+      #       def black?; end
+      #
+      #       sig { void }
+      #       def blue!; end
+      #
+      #       sig { returns(T::Boolean) }
+      #       def blue?; end
+      #
+      #       sig { void }
+      #       def bright!; end
+      #
+      #       sig { returns(T::Boolean) }
+      #       def bright?; end
+      #     end
+      #   end
+      # end
+      # ~~~
+      class Kredis < Compiler
+        extend T::Sig
+
+        ConstantType = type_member { { fixed: T.all(Class, ::Kredis::Attributes::ClassMethods, Extensions::Kredis) } }
+
+        sig { override.void }
+        def decorate
+          return if constant.__tapioca_kredis_types.nil?
+
+          module_name = "GeneratedKredisAttributeMethods"
+
+          root.create_path(constant) do |model|
+            model.create_module(module_name) do |mod|
+              constant.__tapioca_kredis_types.each do |method, data|
+                generate_methods(mod, method, data)
+              end
+            end
+            model.create_include(module_name)
+          end
+        end
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            all_classes
+              .grep(::Kredis::Attributes::ClassMethods)
+              .reject { |klass| klass.to_s == "ActiveRecord::Base" || klass.try(:abstract_class?) }
+          end
+        end
+
+        private
+
+        sig { params(mod: RBI::Scope, method: String, data: T::Hash[Symbol, T.untyped]).void }
+        def generate_methods(mod, method, data)
+          return_type = data.fetch(:type)
+          case return_type
+          when "Kredis::Types::Enum"
+            klass_name = "PrivateEnum#{method.split("_").map(&:capitalize).join}"
+            create_enum_class(mod, klass_name, data.fetch(:values))
+            return_type = klass_name
+          when "Kredis::Types::Flag"
+            mod.create_method("#{method}?", return_type: "T::Boolean")
+          end
+
+          mod.create_method(method, return_type: return_type)
+        end
+
+        sig { params(mod: RBI::Scope, klass_name: String, values: T::Array[T.untyped]).void }
+        def create_enum_class(mod, klass_name, values)
+          klass = mod.create_class(klass_name, superclass_name: "Kredis::Types::Enum")
+          values.each do |value|
+            klass.create_method("#{value}!", return_type: "void")
+            klass.create_method("#{value}?", return_type: "T::Boolean")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -119,10 +119,13 @@ module Tapioca
           mod.create_method(property.reader.to_s, return_type: type)
         end
 
-        BOOLEANS = T.let([
-          [true, false],
-          [false, true],
-        ].freeze, T::Array[[T::Boolean, T::Boolean]])
+        BOOLEANS = T.let(
+          [
+            [true, false],
+            [false, true],
+          ].freeze,
+          T::Array[[T::Boolean, T::Boolean]],
+        )
 
         sig { params(property: ::SmartProperties::Property).returns(String) }
         def type_for(property)

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

@@ -102,10 +102,13 @@ module Tapioca
           end
         end
 
-        NON_DISCOVERABLE_INCLUDERS = T.let([
-          ActionDispatch::IntegrationTest,
-          ActionView::Helpers,
-        ], T::Array[Module])
+        NON_DISCOVERABLE_INCLUDERS = T.let(
+          [
+            ActionDispatch::IntegrationTest,
+            ActionView::Helpers,
+          ],
+          T::Array[Module],
+        )
 
         class << self
           extend T::Sig

data/lib/tapioca/dsl/extensions/active_record.rb

@@ -21,6 +21,15 @@ module Tapioca
             super
           end
 
+          attr_reader :__tapioca_secure_tokens
+
+          def has_secure_token(attribute = :token, length: ::ActiveRecord::SecureToken::MINIMUM_TOKEN_LENGTH)
+            @__tapioca_secure_tokens ||= []
+            @__tapioca_secure_tokens << attribute
+
+            super
+          end
+
           ::ActiveRecord::Base.singleton_class.prepend(self)
         end
       end

data/lib/tapioca/dsl/extensions/kredis.rb

@@ -0,0 +1,114 @@
+# typed: true
+# frozen_string_literal: true
+
+begin
+  require "kredis"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Dsl
+    module Compilers
+      module Extensions
+        module Kredis
+          attr_reader :__tapioca_kredis_types
+
+          def kredis_proxy(name, key: nil, config: :shared, after_change: nil)
+            collect_kredis_type(name, "Kredis::Types::Proxy")
+            super
+          end
+
+          def kredis_string(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+            collect_kredis_type(name, "Kredis::Types::Scalar")
+            super
+          end
+
+          def kredis_integer(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+            collect_kredis_type(name, "Kredis::Types::Scalar")
+            super
+          end
+
+          def kredis_decimal(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+            collect_kredis_type(name, "Kredis::Types::Scalar")
+            super
+          end
+
+          def kredis_datetime(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+            collect_kredis_type(name, "Kredis::Types::Scalar")
+            super
+          end
+
+          def kredis_flag(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+            collect_kredis_type(name, "Kredis::Types::Flag")
+            super
+          end
+
+          def kredis_float(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+            collect_kredis_type(name, "Kredis::Types::Scalar")
+            super
+          end
+
+          def kredis_enum(name, key: nil, values:, default:, config: :shared, after_change: nil)
+            collect_kredis_type(name, "Kredis::Types::Enum", values: values)
+            super
+          end
+
+          def kredis_json(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+            collect_kredis_type(name, "Kredis::Types::Scalar")
+            super
+          end
+
+          def kredis_list(name, key: nil, typed: :string, config: :shared, after_change: nil)
+            collect_kredis_type(name, "Kredis::Types::List")
+            super
+          end
+
+          def kredis_unique_list(name, limit: nil, key: nil, typed: :string, config: :shared, after_change: nil)
+            collect_kredis_type(name, "Kredis::Types::UniqueList")
+            super
+          end
+
+          def kredis_set(name, key: nil, typed: :string, config: :shared, after_change: nil)
+            collect_kredis_type(name, "Kredis::Types::Set")
+            super
+          end
+
+          def kredis_slot(name, key: nil, config: :shared, after_change: nil)
+            collect_kredis_type(name, "Kredis::Types::Slots")
+            super
+          end
+
+          def kredis_slots(name, available:, key: nil, config: :shared, after_change: nil)
+            collect_kredis_type(name, "Kredis::Types::Slots")
+            super
+          end
+
+          def kredis_counter(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+            collect_kredis_type(name, "Kredis::Types::Counter")
+            super
+          end
+
+          def kredis_hash(name, key: nil, typed: :string, config: :shared, after_change: nil)
+            collect_kredis_type(name, "Kredis::Types::Hash")
+            super
+          end
+
+          def kredis_boolean(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+            collect_kredis_type(name, "Kredis::Types::Scalar")
+            super
+          end
+
+          private
+
+          def collect_kredis_type(method, type, values: nil)
+            @__tapioca_kredis_types ||= {}
+            @__tapioca_kredis_types[method.to_s] = { type: type, values: values }
+          end
+
+          ::Kredis::Attributes::ClassMethods.prepend(self)
+        end
+      end
+    end
+  end
+end

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

@@ -19,33 +19,7 @@ module Tapioca
 
           column_type = @constant.attribute_types[column_name]
 
-          getter_type =
-            case column_type
-            when defined?(MoneyColumn) && MoneyColumn::ActiveRecordType
-              "::Money"
-            when ActiveRecord::Type::Integer
-              "::Integer"
-            when ActiveRecord::Type::String
-              "::String"
-            when ActiveRecord::Type::Date
-              "::Date"
-            when ActiveRecord::Type::Decimal
-              "::BigDecimal"
-            when ActiveRecord::Type::Float
-              "::Float"
-            when ActiveRecord::Type::Boolean
-              "T::Boolean"
-            when ActiveRecord::Type::DateTime, ActiveRecord::Type::Time
-              "::Time"
-            when ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter
-              "::ActiveSupport::TimeWithZone"
-            when ActiveRecord::Enum::EnumType
-              "::String"
-            when ActiveRecord::Type::Serialized
-              serialized_column_type(column_type)
-            else
-              handle_unknown_type(column_type)
-            end
+          getter_type = type_for_activerecord_value(column_type)
 
           column = @constant.columns_hash[column_name]
           setter_type =
@@ -71,6 +45,42 @@ module Tapioca
 
         private
 
+        sig { params(column_type: T.untyped).returns(String) }
+        def type_for_activerecord_value(column_type)
+          case column_type
+          when defined?(MoneyColumn) && MoneyColumn::ActiveRecordType
+            "::Money"
+          when ActiveRecord::Type::Integer
+            "::Integer"
+          when ActiveRecord::Type::String
+            "::String"
+          when ActiveRecord::Type::Date
+            "::Date"
+          when ActiveRecord::Type::Decimal
+            "::BigDecimal"
+          when ActiveRecord::Type::Float
+            "::Float"
+          when ActiveRecord::Type::Boolean
+            "T::Boolean"
+          when ActiveRecord::Type::DateTime, ActiveRecord::Type::Time
+            "::Time"
+          when ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter
+            "::ActiveSupport::TimeWithZone"
+          when ActiveRecord::Enum::EnumType
+            "::String"
+          when ActiveRecord::Type::Serialized
+            serialized_column_type(column_type)
+          when defined?(ActiveRecord::ConnectionAdapters::PostgreSQL) &&
+            ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Hstore
+            "T::Hash[::String, ::String]"
+          when defined?(ActiveRecord::ConnectionAdapters::PostgreSQL) &&
+            ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array
+            "T::Array[#{type_for_activerecord_value(column_type.subtype)}]"
+          else
+            handle_unknown_type(column_type)
+          end
+        end
+
         sig { params(constant: Module).returns(T::Boolean) }
         def do_not_generate_strong_types?(constant)
           Object.const_defined?(:StrongTypeGeneration) &&

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

@@ -14,6 +14,7 @@ module Tapioca
         AttributeMethodsModuleName = T.let("GeneratedAttributeMethods", String)
         AssociationMethodsModuleName = T.let("GeneratedAssociationMethods", String)
         DelegatedTypesModuleName = T.let("GeneratedDelegatedTypeMethods", String)
+        SecureTokensModuleName = T.let("GeneratedSecureTokenMethods", String)
 
         RelationMethodsModuleName = T.let("GeneratedRelationMethods", String)
         AssociationRelationMethodsModuleName = T.let("GeneratedAssociationRelationMethods", String)

data/lib/tapioca/dsl/pipeline.rb

@@ -12,6 +12,9 @@ module Tapioca
       sig { returns(T::Array[Module]) }
       attr_reader :requested_constants
 
+      sig { returns(T::Array[Pathname]) }
+      attr_reader :requested_paths
+
       sig { returns(T.proc.params(error: String).void) }
       attr_reader :error_handler
 
@@ -21,6 +24,7 @@ module Tapioca
       sig do
         params(
           requested_constants: T::Array[Module],
+          requested_paths: T::Array[Pathname],
           requested_compilers: T::Array[T.class_of(Compiler)],
           excluded_compilers: T::Array[T.class_of(Compiler)],
           error_handler: T.proc.params(error: String).void,
@@ -29,6 +33,7 @@ module Tapioca
       end
       def initialize(
         requested_constants:,
+        requested_paths: [],
         requested_compilers: [],
         excluded_compilers: [],
         error_handler: $stderr.method(:puts).to_proc,
@@ -39,6 +44,7 @@ module Tapioca
           T::Enumerable[T.class_of(Compiler)],
         )
         @requested_constants = requested_constants
+        @requested_paths = requested_paths
         @error_handler = error_handler
         @number_of_workers = number_of_workers
         @errors = T.let([], T::Array[String])
@@ -50,11 +56,12 @@ module Tapioca
         ).returns(T::Array[T.type_parameter(:T)])
       end
       def run(&blk)
-        constants_to_process = gather_constants(requested_constants)
+        constants_to_process = gather_constants(requested_constants, requested_paths)
           .select { |c| Module === c } # Filter value constants out
           .sort_by! { |c| T.must(Runtime::Reflection.name_of(c)) }
 
-        if constants_to_process.empty?
+        # It's OK if there are no constants to process if we received a valid file/path.
+        if constants_to_process.empty? && requested_paths.select { |p| File.exist?(p) }.empty?
           report_error(<<~ERROR)
             No classes/modules can be matched for RBI generation.
             Please check that the requested classes/modules include processable DSL methods.
@@ -115,12 +122,12 @@ module Tapioca
         active_compilers
       end
 
-      sig { params(requested_constants: T::Array[Module]).returns(T::Set[Module]) }
-      def gather_constants(requested_constants)
+      sig { params(requested_constants: T::Array[Module], requested_paths: T::Array[Pathname]).returns(T::Set[Module]) }
+      def gather_constants(requested_constants, requested_paths)
         constants = active_compilers.map(&:processable_constants).reduce(Set.new, :union)
         constants = filter_anonymous_and_reloaded_constants(constants)
 
-        constants &= requested_constants unless requested_constants.empty?
+        constants &= requested_constants unless requested_constants.empty? && requested_paths.empty?
         constants
       end
 

data/lib/tapioca/gem/listeners/sorbet_enums.rb

@@ -12,7 +12,7 @@ module Tapioca
         sig { override.params(event: ScopeNodeAdded).void }
         def on_scope(event)
           constant = event.constant
-          return unless T::Enum > event.constant
+          return unless T::Enum > event.constant # rubocop:disable Style/InvertibleUnlessCondition
 
           enums = T.unsafe(constant).values.map do |enum_type|
             enum_type.instance_variable_get(:@const_name).to_s

data/lib/tapioca/gem/listeners/yard_doc.rb

@@ -7,16 +7,19 @@ module Tapioca
       class YardDoc < Base
         extend T::Sig
 
-        IGNORED_COMMENTS = T.let([
-          ":doc:",
-          ":nodoc:",
-          "typed:",
-          "frozen_string_literal:",
-          "encoding:",
-          "warn_indent:",
-          "shareable_constant_value:",
-          "rubocop:",
-        ], T::Array[String])
+        IGNORED_COMMENTS = T.let(
+          [
+            ":doc:",
+            ":nodoc:",
+            "typed:",
+            "frozen_string_literal:",
+            "encoding:",
+            "warn_indent:",
+            "shareable_constant_value:",
+            "rubocop:",
+          ],
+          T::Array[String],
+        )
 
         IGNORED_SIG_TAGS = T.let(["param", "return"], T::Array[String])
 

data/lib/tapioca/gem/pipeline.rb

@@ -106,6 +106,18 @@ module Tapioca
         @payload_symbols.include?(symbol_name)
       end
 
+      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
+        # If the source location of the constant is "(eval)", all bets are off.
+        return true if source_location == "(eval)"
+
+        gem.contains_path?(source_location)
+      end
+
       sig { params(method: UnboundMethod).returns(T::Boolean) }
       def method_in_gem?(method)
         source_location = method.source_location&.first
@@ -216,6 +228,7 @@ module Tapioca
         mark_seen(name)
 
         return if symbol_in_payload?(name)
+        return unless constant_in_gem?(name)
 
         target = name_of(constant)
         # If target has no name, let's make it an anonymous class or module with `Class.new` or `Module.new`
@@ -237,6 +250,7 @@ module Tapioca
         mark_seen(name)
 
         return if symbol_in_payload?(name)
+        return unless constant_in_gem?(name)
 
         klass = class_of(value)
 

data/lib/tapioca/gemfile.rb

@@ -154,8 +154,12 @@ module Tapioca
 
       IGNORED_GEMS = T.let(
         [
-          "sorbet", "sorbet-static", "sorbet-runtime", "sorbet-static-and-runtime",
-          "debug", "fakefs",
+          "sorbet",
+          "sorbet-static",
+          "sorbet-runtime",
+          "sorbet-static-and-runtime",
+          "debug",
+          "fakefs",
         ].freeze,
         T::Array[String],
       )

data/lib/tapioca/helpers/rbi_files_helper.rb

@@ -212,16 +212,22 @@ module Tapioca
 
     sig { params(nodes: T::Array[RBI::Node]).returns(T::Array[T.any(RBI::Method, RBI::Attr)]) }
     def extract_methods_and_attrs(nodes)
-      T.cast(nodes.select do |node|
-        node.is_a?(RBI::Method) || node.is_a?(RBI::Attr)
-      end, T::Array[T.any(RBI::Method, RBI::Attr)])
+      T.cast(
+        nodes.select do |node|
+          node.is_a?(RBI::Method) || node.is_a?(RBI::Attr)
+        end,
+        T::Array[T.any(RBI::Method, RBI::Attr)],
+      )
     end
 
     sig { params(nodes: T::Array[RBI::Node]).returns(T::Array[T.any(RBI::Mixin, RBI::RequiresAncestor)]) }
     def extract_mixins(nodes)
-      T.cast(nodes.select do |node|
-        node.is_a?(RBI::Mixin) || node.is_a?(RBI::RequiresAncestor)
-      end, T::Array[T.all(RBI::Mixin, RBI::RequiresAncestor)])
+      T.cast(
+        nodes.select do |node|
+          node.is_a?(RBI::Mixin) || node.is_a?(RBI::RequiresAncestor)
+        end,
+        T::Array[T.all(RBI::Mixin, RBI::RequiresAncestor)],
+      )
     end
 
     sig { params(nodes: T::Array[T.any(RBI::Method, RBI::Attr)]).returns(T::Array[T.any(RBI::Method, RBI::Attr)]) }

data/lib/tapioca/helpers/sorbet_helper.rb

@@ -19,10 +19,13 @@ module Tapioca
 
     SORBET_PAYLOAD_URL = "https://github.com/sorbet/sorbet/tree/master/rbi"
 
-    FEATURE_REQUIREMENTS = T.let({
-      # feature_name: ::Gem::Requirement.new(">= ___"), # https://github.com/sorbet/sorbet/pull/___
-      non_generic_weak_map: ::Gem::Requirement.new(">= 0.5.10587"), # https://github.com/sorbet/sorbet/pull/6610
-    }.freeze, T::Hash[Symbol, ::Gem::Requirement])
+    FEATURE_REQUIREMENTS = T.let(
+      {
+        # feature_name: ::Gem::Requirement.new(">= ___"), # https://github.com/sorbet/sorbet/pull/___
+        non_generic_weak_map: ::Gem::Requirement.new(">= 0.5.10587"), # https://github.com/sorbet/sorbet/pull/6610
+      }.freeze,
+      T::Hash[Symbol, ::Gem::Requirement],
+    )
 
     sig { params(sorbet_args: String).returns(Spoom::ExecResult) }
     def sorbet(*sorbet_args)

data/lib/tapioca/helpers/source_uri.rb

@@ -7,13 +7,16 @@ module URI
   class Source < URI::File
     extend T::Sig
 
-    COMPONENT = T.let([
-      :scheme,
-      :gem_name,
-      :gem_version,
-      :path,
-      :line_number,
-    ].freeze, T::Array[Symbol])
+    COMPONENT = T.let(
+      [
+        :scheme,
+        :gem_name,
+        :gem_version,
+        :path,
+        :line_number,
+      ].freeze,
+      T::Array[Symbol],
+    )
 
     alias_method(:gem_name, :host)
     alias_method(:line_number, :fragment)

data/lib/tapioca/loaders/gem.rb

@@ -18,10 +18,12 @@ module Tapioca
           ).void
         end
         def load_application(bundle:, prerequire:, postrequire:, default_command:)
-          loader = new(bundle: bundle,
+          loader = new(
+            bundle: bundle,
             prerequire: prerequire,
             postrequire: postrequire,
-            default_command: default_command)
+            default_command: default_command,
+          )
           loader.load
         end
       end