tapioca 0.10.4 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbed9bfddb52a94735d9455ed4351c4ef1389236ceba2e19ce46d999a05536b0
-  data.tar.gz: b1a35528c1e9cfa5fd735a64d4988bfd72c0f980835d58e4a37c62d5694e3daa
+  metadata.gz: f32d4fd559ee85f540926b3faa454aaf2ddd919b502438bf2deda24a4b04f855
+  data.tar.gz: 9368c2329923554e639310003630d36f9bf7a2f895df619cfe844dacd9a2c176
 SHA512:
-  metadata.gz: 6138060ec0cea66dda6f96484329626d613494404cf99f851d1dbd59249546ffdfa0b0dd58236ef63d65b93acd250eb3a46b5a3eb1a3f8491014125b18a50800
-  data.tar.gz: 266205a5dd212e87836d1d26f1f018ab83d64aaacc9b793e9a01b88c6213bda834991194896a602ce6f267ef96e3ef8f78d14464005cefcfc010bb666ddc6f3e
+  metadata.gz: c997e7598a5cef84e52935b0f9681ca636fef5fb866d30f1e6d19e2912ae38b5ec7499e69cde6cd147b4a723214d80abb109dbd523e48f143eae0b1edbefd46e
+  data.tar.gz: 33882ab5de1b8b43d775bdb20b0fab39d97ebe2ce7b346bb9828b64e27dd99bb7d46814ac441dd1b6b7aadb3b4aa02f93a652d4e6fa42c34ac83241eb9eb78d7

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
@@ -127,11 +130,15 @@ module Tapioca
       type: :string,
       desc: "The path to the Rails application",
       default: "."
-    def dsl(*constants)
+    def dsl(*constant_or_paths)
       set_environment(options)
 
+      # Assume anything starting with a capital letter or colon is a class, otherwise a path
+      constants, paths = constant_or_paths.partition { |c| c =~ /\A[A-Z:]/ }
+
       command = Commands::Dsl.new(
         requested_constants: constants,
+        requested_paths: paths.map { |p| Pathname.new(p) },
         outpath: Pathname.new(options[:outdir]),
         only: options[:only],
         exclude: options[:exclude],
@@ -293,7 +300,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/annotations.rb

@@ -189,6 +189,8 @@ module Tapioca
 
       sig { params(name: String, content: String).returns(String) }
       def add_header(name, content)
+        # WARNING: Changing this header could impact how GitHub determines if the file should be hidden:
+        # https://github.com/github/linguist/pull/6143
         header = <<~COMMENT
           # DO NOT EDIT MANUALLY
           # This file was pulled from a central RBI files repository.

data/lib/tapioca/commands/configure.rb

@@ -41,6 +41,7 @@ module Tapioca
         create_file(@sorbet_config, <<~CONTENT, skip: true, force: false)
           --dir
           .
+          --ignore=tmp/
           --ignore=vendor/
         CONTENT
       end

data/lib/tapioca/commands/dsl.rb

@@ -10,6 +10,7 @@ module Tapioca
       sig do
         params(
           requested_constants: T::Array[String],
+          requested_paths: T::Array[Pathname],
           outpath: Pathname,
           only: T::Array[String],
           exclude: T::Array[String],
@@ -27,6 +28,7 @@ module Tapioca
       end
       def initialize(
         requested_constants:,
+        requested_paths:,
         outpath:,
         only:,
         exclude:,
@@ -42,6 +44,7 @@ module Tapioca
         app_root: "."
       )
         @requested_constants = requested_constants
+        @requested_paths = requested_paths
         @outpath = outpath
         @only = only
         @exclude = exclude
@@ -63,7 +66,7 @@ module Tapioca
       def list_compilers
         Loaders::Dsl.load_application(
           tapioca_path: @tapioca_path,
-          eager_load: @requested_constants.empty?,
+          eager_load: @requested_constants.empty? && @requested_paths.empty?,
           app_root: @app_root,
         )
 
@@ -101,6 +104,15 @@ module Tapioca
         end
         say("")
 
+        unless @requested_paths.empty?
+          constants_from_paths = Static::SymbolLoader.symbols_from_paths(@requested_paths).to_a
+          if constants_from_paths.empty?
+            say_error("\nWarning: No constants found in: #{@requested_paths.map(&:to_s).join(", ")}", :yellow)
+          end
+
+          @requested_constants += constants_from_paths
+        end
+
         outpath = @should_verify ? Pathname.new(Dir.mktmpdir) : @outpath
         rbi_files_to_purge = existing_rbi_filenames(@requested_constants)
 
@@ -153,6 +165,7 @@ module Tapioca
       def create_pipeline
         Tapioca::Dsl::Pipeline.new(
           requested_constants: constantize(@requested_constants),
+          requested_paths: @requested_paths,
           requested_compilers: constantize_compilers(@only),
           excluded_compilers: constantize_compilers(@exclude),
           error_handler: ->(error) {
@@ -167,8 +180,9 @@ module Tapioca
         filenames = if requested_constants.empty?
           Pathname.glob(path / "**/*.rbi")
         else
-          requested_constants.map do |constant_name|
-            dsl_rbi_filename(constant_name)
+          requested_constants.filter_map do |constant_name|
+            filename = dsl_rbi_filename(constant_name)
+            filename if File.exist?(filename)
           end
         end
 

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,33 @@ 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],
+          )
+
+        # Taken directly from the AASM::Base class, here:
+        # https://github.com/aasm/aasm/blob/0e03746a2b86558ee1bf7bd7db873938cbb3b29b/lib/aasm/base.rb#L145-L171
+        GLOBAL_CALLBACKS =
+          T.let(
+            [
+              "after_all_transitions",
+              "after_all_transactions",
+              "before_all_transactions",
+              "before_all_events",
+              "after_all_events",
+              "error_on_all_events",
+              "ensure_on_all_events",
+            ].freeze,
             T::Array[String],
           )
 
@@ -53,23 +78,47 @@ module Tapioca
 
         sig { override.void }
         def decorate
-          aasm = constant.aasm
-          return if !aasm || aasm.states.empty?
+          state_machine_store = ::AASM::StateMachineStore.fetch(constant)
+          return unless state_machine_store
+
+          state_machines = state_machine_store.machine_names.map { |n| constant.aasm(n) }
+          return if state_machines.all? { |m| m.states.empty? }
 
           root.create_path(constant) do |model|
-            # Create all of the constants and methods for each state
-            aasm.states.each do |state|
-              model.create_constant("STATE_#{state.name.upcase}", value: "T.let(T.unsafe(nil), Symbol)")
-              model.create_method("#{state.name}?", return_type: "T::Boolean")
-            end
+            state_machines.each do |state_machine|
+              namespace = state_machine.__send__(:namespace)
+
+              # Create all of the constants and methods for each state
+              state_machine.states.each do |state|
+                name = state.name
+                name = "#{namespace}_#{name}" if namespace
+
+                model.create_constant("STATE_#{name.upcase}", value: "T.let(T.unsafe(nil), Symbol)")
+                model.create_method("#{name}?", return_type: "T::Boolean")
+              end
 
-            # Create all of the methods for each event
-            parameters = [create_rest_param("opts", type: "T.untyped")]
-            aasm.events.each do |event|
-              model.create_method(event.name.to_s, parameters: parameters)
-              model.create_method("#{event.name}!", parameters: parameters)
-              model.create_method("#{event.name}_without_validation!", parameters: parameters)
-              model.create_method("may_#{event.name}?", return_type: "T::Boolean")
+              # Create all of the methods for each event
+              parameters = [create_rest_param("opts", type: "T.untyped")]
+              state_machine.events.each do |event|
+                model.create_method(event.name.to_s, parameters: parameters)
+                model.create_method("#{event.name}!", parameters: parameters)
+                model.create_method("#{event.name}_without_validation!", parameters: parameters)
+                model.create_method("may_#{event.name}?", return_type: "T::Boolean")
+
+                # For events, if there's a namespace the default methods are created in addition to
+                # namespaced ones.
+                next unless namespace
+
+                name = "#{event.name}_#{namespace}"
+
+                model.create_method(name.to_s, parameters: parameters)
+                model.create_method("#{name}!", parameters: parameters)
+                model.create_method("may_#{name}?", return_type: "T::Boolean")
+
+                # There's no namespaced method created for `_without_validation`, so skip
+                # defining a method for:
+                #   "#{name}_without_validation!"
+              end
             end
 
             # Create the overall state machine method, which will return an
@@ -97,6 +146,18 @@ module Tapioca
                 ],
               )
 
+              constant_name = name_of(constant)
+
+              GLOBAL_CALLBACKS.each do |method|
+                machine.create_method(
+                  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)"),
+                  ],
+                )
+              end
+
               # Create a private event class that we can pass around for the
               # purpose of binding all of the callbacks without having to
               # explicitly bind self in each one.
@@ -106,7 +167,7 @@ module Tapioca
                     method,
                     parameters: [
                       create_opt_param("symbol", type: "T.nilable(Symbol)", default: "nil"),
-                      create_block_param("block", type: "T.nilable(T.proc.bind(#{name_of(constant)}).void)"),
+                      create_block_param("block", type: "T.nilable(T.proc.bind(#{constant_name}).void)"),
                     ],
                   )
                 end

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

@@ -156,7 +156,7 @@ module Tapioca
         sig { params(mod: Module).returns(T::Array[String]) }
         def gather_includes(mod)
           mod.ancestors
-            .reject { |ancestor| ancestor.is_a?(Class) || ancestor == mod || ancestor.name.nil? }
+            .reject { |ancestor| ancestor.is_a?(Class) || ancestor == mod || name_of(ancestor).nil? }
             .map { |ancestor| T.must(qualified_name_of(ancestor)) }
             .reverse
         end

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

@@ -16,7 +16,8 @@ module Tapioca
       # `Tapioca::Dsl::Compilers::ActiveRecordColumns` refines RBI files for subclasses of
       # [`ActiveRecord::Base`](https://api.rubyonrails.org/classes/ActiveRecord/Base.html).
       # This compiler is only responsible for defining the attribute methods that would be
-      # created for the columns that are defined in the Active Record model.
+      # created for columns and virtual attributes that are defined in the Active Record
+      # model.
       #
       # For example, with the following model class:
       # ~~~rb
@@ -109,8 +110,7 @@ module Tapioca
 
           root.create_path(constant) do |model|
             model.create_module(AttributeMethodsModuleName) do |mod|
-              constant.columns_hash.each_key do |column_name|
-                column_name = column_name.to_s
+              constant.attribute_names.each do |column_name|
                 add_methods_for_attribute(mod, column_name)
               end
 

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]) }