tapioca 0.10.4 → 0.10.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbed9bfddb52a94735d9455ed4351c4ef1389236ceba2e19ce46d999a05536b0
-  data.tar.gz: b1a35528c1e9cfa5fd735a64d4988bfd72c0f980835d58e4a37c62d5694e3daa
+  metadata.gz: 9df4814fb4f17b9f1d53aab7a9b9b23498cfea0330fb48b47d909af119ac6ea0
+  data.tar.gz: 7f2d233a47a7ceb2b4a1f4894c794d65c2cca9c9e1547022630d7b395de0cd47
 SHA512:
-  metadata.gz: 6138060ec0cea66dda6f96484329626d613494404cf99f851d1dbd59249546ffdfa0b0dd58236ef63d65b93acd250eb3a46b5a3eb1a3f8491014125b18a50800
-  data.tar.gz: 266205a5dd212e87836d1d26f1f018ab83d64aaacc9b793e9a01b88c6213bda834991194896a602ce6f267ef96e3ef8f78d14464005cefcfc010bb666ddc6f3e
+  metadata.gz: f65d462c261005c62b31f0864df29b550d5a07551433203f485f8f66c57a8e100fccdb1deb1b7f29e185a1f6e8bf5b4e9f59387a1ba24ea8b4cff168b1b4ca12
+  data.tar.gz: 721c40a48f379eda0e6302ff59b2a3228f0262c5d2b2bac1111016d92ec02597e9d35c28a38a6fcc903a8ac13b0b8c4dddcc7e1d747907390762f47601d19e68

data/lib/tapioca/cli.rb

@@ -25,9 +25,12 @@ module Tapioca
 
     desc "init", "get project ready for type checking"
     def init
-      invoke(:configure)
-      invoke(:annotations)
-      invoke(:gem)
+      # We need to make sure that trackers stay enabled until the `gem` command is invoked
+      Runtime::Trackers.with_trackers_enabled do
+        invoke(:configure)
+        invoke(:annotations)
+        invoke(:gem)
+      end
       invoke(:todo)
 
       print_init_next_steps
@@ -293,7 +296,9 @@ module Tapioca
     end
 
     desc "annotations", "Pull gem RBI annotations from remote sources"
-    option :sources, type: :array, default: [CENTRAL_REPO_ROOT_URI],
+    option :sources,
+      type: :array,
+      default: [CENTRAL_REPO_ROOT_URI],
       desc: "URIs of the sources to pull gem RBI annotations from"
     option :netrc, type: :boolean, default: true, desc: "Use .netrc to authenticate to private sources"
     option :netrc_file, type: :string, desc: "Path to .netrc file"

data/lib/tapioca/commands/gem.rb

@@ -156,9 +156,11 @@ module Tapioca
 
         rbi = RBI::File.new(strictness: @typed_overrides[gem.name] || "true")
 
-        @rbi_formatter.write_header!(rbi,
+        @rbi_formatter.write_header!(
+          rbi,
           default_command(:gem, gem.name),
-          reason: "types exported from the `#{gem.name}` gem") if @file_header
+          reason: "types exported from the `#{gem.name}` gem",
+        ) if @file_header
 
         rbi.root = Tapioca::Gem::Pipeline.new(gem, include_doc: @include_doc, include_loc: @include_loc).compile
 

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

@@ -44,8 +44,17 @@ module Tapioca
         # https://github.com/aasm/aasm/blob/0e03746/lib/aasm/core/event.rb#L21-L29
         EVENT_CALLBACKS =
           T.let(
-            ["after", "after_commit", "after_transaction", "before", "before_transaction", "ensure", "error",
-             "before_success", "success",].freeze,
+            [
+              "after",
+              "after_commit",
+              "after_transaction",
+              "before",
+              "before_transaction",
+              "ensure",
+              "error",
+              "before_success",
+              "success",
+            ].freeze,
             T::Array[String],
           )
 

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

@@ -72,11 +72,14 @@ module Tapioca
 
         sig { returns(Class) }
         def fixture_loader
-          @fixture_loader ||= T.let(Class.new do
-            T.unsafe(self).include(ActiveRecord::TestFixtures)
-            T.unsafe(self).fixture_path = Rails.root.join("test", "fixtures")
-            T.unsafe(self).fixtures(:all)
-          end, T.nilable(Class))
+          @fixture_loader ||= T.let(
+            Class.new do
+              T.unsafe(self).include(ActiveRecord::TestFixtures)
+              T.unsafe(self).fixture_path = Rails.root.join("test", "fixtures")
+              T.unsafe(self).fixtures(:all)
+            end,
+            T.nilable(Class),
+          )
         end
 
         sig { returns(T::Array[String]) }

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

@@ -196,28 +196,34 @@ module Tapioca
           T::Array[Symbol],
         )
 
-        QUERY_METHODS = T.let(begin
-          # Grab all Query methods
-          query_methods = ActiveRecord::QueryMethods.instance_methods(false)
-          # Grab all Spawn methods
-          query_methods |= ActiveRecord::SpawnMethods.instance_methods(false)
-          # Remove the ones we know are private API
-          query_methods -= [:arel, :build_subquery, :construct_join_dependency, :extensions, :spawn]
-          # Remove "where" which needs a custom return type for WhereChains
-          query_methods -= [:where]
-          # Remove the methods that ...
-          query_methods
-            .grep_v(/_clause$/) # end with "_clause"
-            .grep_v(/_values?$/) # end with "_value" or "_values"
-            .grep_v(/=$/) # end with "=""
-            .grep_v(/(?<!uniq)!$/) # end with "!" except for "uniq!"
-        end, T::Array[Symbol])
+        QUERY_METHODS = T.let(
+          begin
+            # Grab all Query methods
+            query_methods = ActiveRecord::QueryMethods.instance_methods(false)
+            # Grab all Spawn methods
+            query_methods |= ActiveRecord::SpawnMethods.instance_methods(false)
+            # Remove the ones we know are private API
+            query_methods -= [:arel, :build_subquery, :construct_join_dependency, :extensions, :spawn]
+            # Remove "where" which needs a custom return type for WhereChains
+            query_methods -= [:where]
+            # Remove the methods that ...
+            query_methods
+              .grep_v(/_clause$/) # end with "_clause"
+              .grep_v(/_values?$/) # end with "_value" or "_values"
+              .grep_v(/=$/) # end with "=""
+              .grep_v(/(?<!uniq)!$/) # end with "!" except for "uniq!"
+          end,
+          T::Array[Symbol],
+        )
         WHERE_CHAIN_QUERY_METHODS = T.let(
           ActiveRecord::QueryMethods::WhereChain.instance_methods(false),
           T::Array[Symbol],
         )
         FINDER_METHODS = T.let(ActiveRecord::FinderMethods.instance_methods(false), T::Array[Symbol])
-        SIGNED_FINDER_METHODS = T.let(ActiveRecord::SignedId::ClassMethods.instance_methods(false), T::Array[Symbol])
+        SIGNED_FINDER_METHODS = T.let(
+          defined?(ActiveRecord::SignedId) ? ActiveRecord::SignedId::ClassMethods.instance_methods(false) : [],
+          T::Array[Symbol],
+        )
         CALCULATION_METHODS = T.let(ActiveRecord::Calculations.instance_methods(false), T::Array[Symbol])
         ENUMERABLE_QUERY_METHODS = T.let([:any?, :many?, :none?, :one?], T::Array[Symbol])
         FIND_OR_CREATE_METHODS = T.let(

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

@@ -126,17 +126,20 @@ module Tapioca
 
         private
 
-        TYPES = T.let({
-          boolean: "T::Boolean",
-          integer: "Integer",
-          string: "String",
-          float: "Float",
-          date: "Date",
-          time: "Time",
-          datetime: "DateTime",
-          decimal: "BigDecimal",
-          any: "T.untyped",
-        }.freeze, T::Hash[Symbol, String])
+        TYPES = T.let(
+          {
+            boolean: "T::Boolean",
+            integer: "Integer",
+            string: "String",
+            float: "Float",
+            date: "Date",
+            time: "Time",
+            datetime: "DateTime",
+            decimal: "BigDecimal",
+            any: "T.untyped",
+          }.freeze,
+          T::Hash[Symbol, String],
+        )
 
         sig { params(attr_type: Symbol).returns(String) }
         def type_for(attr_type)

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

@@ -85,18 +85,21 @@ module Tapioca
 
         private
 
-        TYPES = T.let({
-          boolean: "T::Boolean",
-          integer: "Integer",
-          string: "String",
-          float: "Float",
-          date: "Date",
-          time: "Time",
-          datetime: "DateTime",
-          decimal: "BigDecimal",
-          binary: "String",
-          text: "String",
-        }.freeze, T::Hash[Symbol, String])
+        TYPES = T.let(
+          {
+            boolean: "T::Boolean",
+            integer: "Integer",
+            string: "String",
+            float: "Float",
+            date: "Date",
+            time: "Time",
+            datetime: "DateTime",
+            decimal: "BigDecimal",
+            binary: "String",
+            text: "String",
+          }.freeze,
+          T::Hash[Symbol, String],
+        )
 
         sig { params(attr_type: Symbol).returns(String) }
         def type_for(attr_type)
@@ -109,9 +112,13 @@ module Tapioca
 
           klass.create_method(attribute, return_type: return_type)
           klass.create_method("#{attribute}?", return_type: "T::Boolean")
-          klass.create_method("#{attribute}=", parameters: [
-            create_param("value", type: return_type),
-          ], return_type: return_type)
+          klass.create_method(
+            "#{attribute}=",
+            parameters: [
+              create_param("value", type: return_type),
+            ],
+            return_type: return_type,
+          )
         end
       end
     end

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

@@ -48,8 +48,10 @@ module Tapioca
 
         ConstantType = type_member do
           {
-            fixed: T.all(Module,
-              ::ActiveStorage::Reflection::ActiveRecordExtensions::ClassMethods),
+            fixed: T.all(
+              Module,
+              ::ActiveStorage::Reflection::ActiveRecordExtensions::ClassMethods,
+            ),
           }
         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/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/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/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

data/lib/tapioca/loaders/loader.rb

@@ -47,9 +47,12 @@ module Tapioca
 
         eager_load_rails_app if eager_load
       rescue LoadError, StandardError => e
-        say("Tapioca attempted to load the Rails application after encountering a `config/application.rb` file, " \
-          "but it failed. If your application uses Rails please ensure it can be loaded correctly before generating " \
-          "RBIs.\n#{e}", :yellow)
+        say(
+          "Tapioca attempted to load the Rails application after encountering a `config/application.rb` file, " \
+            "but it failed. If your application uses Rails please ensure it can be loaded correctly before " \
+            "generating RBIs.\n#{e}",
+          :yellow,
+        )
         say("Continuing RBI generation without loading the Rails application.")
       end
 

data/lib/tapioca/rbi_ext/model.rb

@@ -91,8 +91,13 @@ module RBI
       return unless Tapioca::RBIHelper.valid_method_name?(name)
 
       sig = RBI::Sig.new(return_type: return_type)
-      method = RBI::Method.new(name, sigs: [sig], is_singleton: class_method, visibility: visibility,
-        comments: comments)
+      method = RBI::Method.new(
+        name,
+        sigs: [sig],
+        is_singleton: class_method,
+        visibility: visibility,
+        comments: comments,
+      )
       parameters.each do |param|
         method << param.param
         sig << RBI::SigParam.new(param.param.name, param.type)

data/lib/tapioca/rbi_formatter.rb

@@ -26,12 +26,15 @@ module Tapioca
     end
   end
 
-  DEFAULT_RBI_FORMATTER = T.let(RBIFormatter.new(
-    add_sig_templates: false,
-    group_nodes: true,
-    max_line_length: nil,
-    nest_singleton_methods: true,
-    nest_non_public_methods: true,
-    sort_nodes: true,
-  ), RBIFormatter)
+  DEFAULT_RBI_FORMATTER = T.let(
+    RBIFormatter.new(
+      add_sig_templates: false,
+      group_nodes: true,
+      max_line_length: nil,
+      nest_singleton_methods: true,
+      nest_non_public_methods: true,
+      sort_nodes: true,
+    ),
+    RBIFormatter,
+  )
 end

data/lib/tapioca/runtime/trackers.rb

@@ -13,6 +13,23 @@ module Tapioca
       class << self
         extend T::Sig
 
+        sig do
+          type_parameters(:Return)
+            .params(blk: T.proc.returns(T.type_parameter(:Return)))
+            .returns(T.type_parameter(:Return))
+        end
+        def with_trackers_enabled(&blk)
+          # Currently this is a dirty hack to ensure disabling trackers
+          # doesn't work while in the block passed to this method.
+          disable_all_method = method(:disable_all!)
+          define_singleton_method(:disable_all!) {}
+          blk.call
+        ensure
+          if disable_all_method
+            define_singleton_method(:disable_all!, disable_all_method)
+          end
+        end
+
         sig { void }
         def disable_all!
           @trackers.each(&:disable!)

data/lib/tapioca/version.rb

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

data/lib/tapioca.rb

@@ -43,11 +43,14 @@ module Tapioca
   DEFAULT_TODO_FILE = T.let("#{DEFAULT_RBI_DIR}/todo.rbi", String)
   DEFAULT_ANNOTATIONS_DIR = T.let("#{DEFAULT_RBI_DIR}/annotations", String)
 
-  DEFAULT_OVERRIDES = T.let({
-    # ActiveSupport overrides some core methods with different signatures
-    # so we generate a typed: false RBI for it to suppress errors
-    "activesupport" => "false",
-  }.freeze, T::Hash[String, String])
+  DEFAULT_OVERRIDES = T.let(
+    {
+      # ActiveSupport overrides some core methods with different signatures
+      # so we generate a typed: false RBI for it to suppress errors
+      "activesupport" => "false",
+    }.freeze,
+    T::Hash[String, String],
+  )
 
   DEFAULT_RBI_MAX_LINE_LENGTH = 120
   DEFAULT_ENVIRONMENT = "development"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.10.4
+  version: 0.10.5
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-12-19 00:00:00.000000000 Z
+date: 2023-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler