tapioca 0.5.6 → 0.6.0

data/lib/tapioca/rbi_ext/model.rb

@@ -67,10 +67,11 @@ module RBI
       end
     end
 
-    sig { params(name: String, block: T.nilable(T.proc.params(scope: Scope).void)).void }
+    sig { params(name: String, block: T.nilable(T.proc.params(scope: Scope).void)).returns(Scope) }
     def create_module(name, &block)
-      node = create_node(RBI::Module.new(name))
-      block&.call(T.cast(node, RBI::Scope))
+      T.cast(create_node(RBI::Module.new(name)), RBI::Scope).tap do |node|
+        block&.call(node)
+      end
     end
 
     sig do
@@ -78,11 +79,12 @@ module RBI
         name: String,
         superclass_name: T.nilable(String),
         block: T.nilable(T.proc.params(scope: RBI::Scope).void)
-      ).void
+      ).returns(Scope)
     end
     def create_class(name, superclass_name: nil, &block)
-      node = create_node(RBI::Class.new(name, superclass_name: superclass_name))
-      block&.call(T.cast(node, RBI::Scope))
+      T.cast(create_node(RBI::Class.new(name, superclass_name: superclass_name)), RBI::Scope).tap do |node|
+        block&.call(node)
+      end
     end
 
     sig { params(name: String, value: String).void }
@@ -115,14 +117,15 @@ module RBI
         name: String,
         parameters: T::Array[TypedParam],
         return_type: String,
-        class_method: T::Boolean
+        class_method: T::Boolean,
+        visibility: RBI::Visibility
       ).void
     end
-    def create_method(name, parameters: [], return_type: "T.untyped", class_method: false)
+    def create_method(name, parameters: [], return_type: "T.untyped", class_method: false, visibility: RBI::Public.new)
       return unless valid_method_name?(name)
 
       sig = RBI::Sig.new(return_type: return_type)
-      method = RBI::Method.new(name, sigs: [sig], is_singleton: class_method)
+      method = RBI::Method.new(name, sigs: [sig], is_singleton: class_method, visibility: visibility)
       parameters.each do |param|
         method << param.param
         sig << RBI::SigParam.new(param.param.name, param.type)

data/lib/tapioca/reflection.rb

@@ -19,6 +19,19 @@ module Tapioca
     PRIVATE_INSTANCE_METHODS_METHOD = T.let(Module.instance_method(:private_instance_methods), UnboundMethod)
     METHOD_METHOD = T.let(Kernel.instance_method(:method), UnboundMethod)
 
+    sig do
+      params(
+        symbol: String,
+        inherit: T::Boolean,
+        namespace: Module
+      ).returns(BasicObject).checked(:never)
+    end
+    def constantize(symbol, inherit: false, namespace: Object)
+      namespace.const_get(symbol, inherit)
+    rescue NameError, LoadError, RuntimeError, ArgumentError, TypeError
+      nil
+    end
+
     sig { params(object: BasicObject).returns(Class).checked(:never) }
     def class_of(object)
       CLASS_METHOD.bind(object).call

data/lib/tapioca/trackers/autoload.rb

@@ -0,0 +1,70 @@
+# typed: true
+# frozen_string_literal: true
+
+module Tapioca
+  module Trackers
+    module Autoload
+      extend T::Sig
+
+      NOOP_METHOD = -> (*_args, **_kwargs, &_block) {}
+
+      @constant_names_registered_for_autoload = T.let([], T::Array[String])
+
+      class << self
+        extend T::Sig
+
+        sig { void }
+        def eager_load_all!
+          with_disabled_exits do
+            until @constant_names_registered_for_autoload.empty?
+              # Grab the next constant name
+              constant_name = T.must(@constant_names_registered_for_autoload.shift)
+              # Trigger autoload by constantizing the registered name
+              Reflection.constantize(constant_name, inherit: true)
+            end
+          end
+        end
+
+        sig { params(constant_name: String).void }
+        def register(constant_name)
+          @constant_names_registered_for_autoload << constant_name
+        end
+
+        sig do
+          type_parameters(:Result)
+            .params(block: T.proc.returns(T.type_parameter(:Result)))
+            .returns(T.type_parameter(:Result))
+        end
+        def with_disabled_exits(&block)
+          original_abort = Kernel.instance_method(:abort)
+          original_exit = Kernel.instance_method(:exit)
+
+          begin
+            Kernel.define_method(:abort, NOOP_METHOD)
+            Kernel.define_method(:exit, NOOP_METHOD)
+
+            block.call
+          ensure
+            Kernel.define_method(:exit, original_exit)
+            Kernel.define_method(:abort, original_abort)
+          end
+        end
+      end
+    end
+  end
+end
+
+# We need to do the alias-method-chain dance since Bootsnap does the same,
+# and prepended modules and alias-method-chain don't play well together.
+#
+# So, why does Bootsnap do alias-method-chain and not prepend? Glad you asked!
+# That's because RubyGems does alias-method-chain for Kernel#require and such,
+# so, if Bootsnap were to do prepend, it might end up breaking RubyGems.
+class Module
+  alias_method(:autoload_without_tapioca, :autoload)
+
+  def autoload(const_name, path)
+    Tapioca::Trackers::Autoload.register("#{self}::#{const_name}")
+    autoload_without_tapioca(const_name, path)
+  end
+end

data/lib/tapioca/trackers/constant_definition.rb

@@ -0,0 +1,42 @@
+# typed: true
+# frozen_string_literal: true
+
+require "set"
+
+module Tapioca
+  module Trackers
+    # Registers a TracePoint immediately upon load to track points at which
+    # classes and modules are opened for definition. This is used to track
+    # correspondence between classes/modules and files, as this information isn't
+    # available in the ruby runtime without extra accounting.
+    module ConstantDefinition
+      extend Reflection
+
+      @class_files = {}
+
+      # Immediately activated upon load. Observes class/module definition.
+      TracePoint.trace(:class) do |tp|
+        unless tp.self.singleton_class?
+          key = name_of(tp.self)
+          file = tp.path
+          if file == "(eval)"
+            file = T.must(caller_locations)
+              .drop_while { |loc| loc.path == "(eval)" }
+              .first&.path
+          end
+          @class_files[key] ||= Set.new
+          @class_files[key] << file
+        end
+      end
+
+      # Returns the files in which this class or module was opened. Doesn't know
+      # about situations where the class was opened prior to +require+ing,
+      # or where metaprogramming was used via +eval+, etc.
+      def self.files_for(klass)
+        name = String === klass ? klass : name_of(klass)
+        files = @class_files[name]
+        files || Set.new
+      end
+    end
+  end
+end

data/lib/tapioca/trackers/mixin.rb

@@ -0,0 +1,78 @@
+# typed: true
+# frozen_string_literal: true
+
+module Tapioca
+  module Trackers
+    module Mixin
+      extend T::Sig
+
+      @mixin_map = {}.compare_by_identity
+
+      class Type < T::Enum
+        enums do
+          Prepend = new
+          Include = new
+          Extend = new
+        end
+      end
+
+      sig do
+        params(
+          constant: Module,
+          mod: Module,
+          mixin_type: Type,
+          locations: T.nilable(T::Array[Thread::Backtrace::Location])
+        ).void
+      end
+      def self.register(constant, mod, mixin_type, locations)
+        locations ||= []
+        locations.map!(&:absolute_path).uniq!
+        locs = mixin_locations_for(constant)
+        locs.fetch(mixin_type).store(mod, T.cast(locations, T::Array[String]))
+      end
+
+      sig { params(constant: Module).returns(T::Hash[Type, T::Hash[Module, T::Array[String]]]) }
+      def self.mixin_locations_for(constant)
+        @mixin_map[constant] ||= {
+          Type::Prepend => {}.compare_by_identity,
+          Type::Include => {}.compare_by_identity,
+          Type::Extend => {}.compare_by_identity,
+        }
+      end
+    end
+  end
+end
+
+class Module
+  prepend(Module.new do
+    def prepend_features(constant)
+      Tapioca::Trackers::Mixin.register(
+        constant,
+        self,
+        Tapioca::Trackers::Mixin::Type::Prepend,
+        caller_locations
+      )
+      super
+    end
+
+    def append_features(constant)
+      Tapioca::Trackers::Mixin.register(
+        constant,
+        self,
+        Tapioca::Trackers::Mixin::Type::Include,
+        caller_locations
+      )
+      super
+    end
+
+    def extend_object(obj)
+      Tapioca::Trackers::Mixin.register(
+        obj,
+        self,
+        Tapioca::Trackers::Mixin::Type::Extend,
+        caller_locations
+      ) if Module === obj
+      super
+    end
+  end)
+end

data/lib/tapioca/trackers.rb

@@ -0,0 +1,14 @@
+# typed: strict
+# frozen_string_literal: true
+
+# The load order below is important:
+# ----------------------------------
+# We want the mixin tracker to be the first thing that is
+# loaded because other trackers might apply their own mixins
+# into core types (like `Module` and `Kernel`). In order to
+# catch and filter those mixins as coming from Tapioca, we need
+# the mixin tracker to be in place, before any mixin operations
+# are performed.
+require "tapioca/trackers/mixin"
+require "tapioca/trackers/constant_definition"
+require "tapioca/trackers/autoload"

data/lib/tapioca/version.rb

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

data/lib/tapioca.rb

@@ -1,9 +1,16 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "sorbet-runtime"
 
 module Tapioca
+  extend T::Sig
+
+  sig do
+    type_parameters(:Result)
+      .params(blk: T.proc.returns(T.type_parameter(:Result)))
+      .returns(T.type_parameter(:Result))
+  end
   def self.silence_warnings(&blk)
     original_verbosity = $VERBOSE
     $VERBOSE = nil
@@ -15,10 +22,29 @@ module Tapioca
   end
 
   class Error < StandardError; end
+
+  SORBET_DIR = T.let("sorbet", String)
+  SORBET_CONFIG_FILE = T.let("#{SORBET_DIR}/config", String)
+  TAPIOCA_DIR = T.let("#{SORBET_DIR}/tapioca", String)
+  TAPIOCA_CONFIG_FILE = T.let("#{TAPIOCA_DIR}/config.yml", String)
+
+  DEFAULT_COMMAND = T.let("bin/tapioca", String)
+  DEFAULT_POSTREQUIRE_FILE = T.let("#{TAPIOCA_DIR}/require.rb", String)
+  DEFAULT_RBI_DIR = T.let("#{SORBET_DIR}/rbi", String)
+  DEFAULT_DSL_DIR = T.let("#{DEFAULT_RBI_DIR}/dsl", String)
+  DEFAULT_GEM_DIR = T.let("#{DEFAULT_RBI_DIR}/gems", String)
+  DEFAULT_SHIM_DIR = T.let("#{DEFAULT_RBI_DIR}/shims", String)
+  DEFAULT_TODO_FILE = T.let("#{DEFAULT_RBI_DIR}/todo.rbi", 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])
 end
 
 require "tapioca/reflection"
-require "tapioca/constant_locator"
+require "tapioca/trackers"
 require "tapioca/compilers/dsl/base"
 require "tapioca/compilers/dynamic_mixin_compiler"
 require "tapioca/helpers/active_record_column_type_helper"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.5.6
+  version: 0.6.0
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-12-03 00:00:00.000000000 Z
+date: 2021-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -50,7 +50,7 @@ dependencies:
         version: 0.0.0
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.8
+        version: 0.0.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -60,7 +60,7 @@ dependencies:
         version: 0.0.0
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.8
+        version: 0.0.9
 - !ruby/object:Gem::Dependency
   name: sorbet-static
   requirement: !ruby/object:Gem::Requirement
@@ -161,6 +161,7 @@ files:
 - lib/tapioca/compilers/dsl/active_record_columns.rb
 - lib/tapioca/compilers/dsl/active_record_enum.rb
 - lib/tapioca/compilers/dsl/active_record_fixtures.rb
+- lib/tapioca/compilers/dsl/active_record_relations.rb
 - lib/tapioca/compilers/dsl/active_record_scope.rb
 - lib/tapioca/compilers/dsl/active_record_typed_store.rb
 - lib/tapioca/compilers/dsl/active_resource.rb
@@ -169,10 +170,14 @@ files:
 - lib/tapioca/compilers/dsl/active_support_current_attributes.rb
 - lib/tapioca/compilers/dsl/base.rb
 - lib/tapioca/compilers/dsl/config.rb
+- lib/tapioca/compilers/dsl/extensions/frozen_record.rb
 - lib/tapioca/compilers/dsl/frozen_record.rb
+- lib/tapioca/compilers/dsl/helper/active_record_constants.rb
 - lib/tapioca/compilers/dsl/identity_cache.rb
 - lib/tapioca/compilers/dsl/mixed_in_class_attributes.rb
+- lib/tapioca/compilers/dsl/param_helper.rb
 - lib/tapioca/compilers/dsl/protobuf.rb
+- lib/tapioca/compilers/dsl/rails_generators.rb
 - lib/tapioca/compilers/dsl/sidekiq_worker.rb
 - lib/tapioca/compilers/dsl/smart_properties.rb
 - lib/tapioca/compilers/dsl/state_machines.rb
@@ -185,9 +190,7 @@ files:
 - lib/tapioca/compilers/symbol_table/symbol_loader.rb
 - lib/tapioca/compilers/symbol_table_compiler.rb
 - lib/tapioca/compilers/todos_compiler.rb
-- lib/tapioca/config.rb
-- lib/tapioca/config_builder.rb
-- lib/tapioca/constant_locator.rb
+- lib/tapioca/executor.rb
 - lib/tapioca/gemfile.rb
 - lib/tapioca/generators.rb
 - lib/tapioca/generators/base.rb
@@ -198,6 +201,11 @@ files:
 - lib/tapioca/generators/todo.rb
 - lib/tapioca/generic_type_registry.rb
 - lib/tapioca/helpers/active_record_column_type_helper.rb
+- lib/tapioca/helpers/cli_helper.rb
+- lib/tapioca/helpers/config_helper.rb
+- lib/tapioca/helpers/test/content.rb
+- lib/tapioca/helpers/test/isolation.rb
+- lib/tapioca/helpers/test/template.rb
 - lib/tapioca/internal.rb
 - lib/tapioca/loader.rb
 - lib/tapioca/rbi_ext/model.rb
@@ -205,6 +213,10 @@ files:
 - lib/tapioca/sorbet_ext/fixed_hash_patch.rb
 - lib/tapioca/sorbet_ext/generic_name_patch.rb
 - lib/tapioca/sorbet_ext/name_patch.rb
+- lib/tapioca/trackers.rb
+- lib/tapioca/trackers/autoload.rb
+- lib/tapioca/trackers/constant_definition.rb
+- lib/tapioca/trackers/mixin.rb
 - lib/tapioca/version.rb
 homepage: https://github.com/Shopify/tapioca
 licenses:

data/lib/tapioca/config.rb

@@ -1,45 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Tapioca
-  class Config < T::Struct
-    extend(T::Sig)
-
-    const(:outdir, String)
-    const(:prerequire, T.nilable(String))
-    const(:postrequire, String)
-    const(:exclude, T::Array[String])
-    const(:exclude_generators, T::Array[String])
-    const(:typed_overrides, T::Hash[String, String])
-    const(:todos_path, String)
-    const(:generators, T::Array[String])
-    const(:file_header, T::Boolean, default: true)
-    const(:doc, T::Boolean, default: false)
-
-    sig { returns(Pathname) }
-    def outpath
-      @outpath = T.let(@outpath, T.nilable(Pathname))
-      @outpath ||= Pathname.new(outdir)
-    end
-
-    private_class_method :new
-
-    SORBET_PATH = T.let("sorbet", String)
-    SORBET_CONFIG = T.let("#{SORBET_PATH}/config", String)
-    TAPIOCA_PATH = T.let("#{SORBET_PATH}/tapioca", String)
-    TAPIOCA_CONFIG = T.let("#{TAPIOCA_PATH}/config.yml", String)
-
-    DEFAULT_COMMAND = T.let("bin/tapioca", String)
-    DEFAULT_POSTREQUIRE = T.let("#{TAPIOCA_PATH}/require.rb", String)
-    DEFAULT_RBIDIR = T.let("#{SORBET_PATH}/rbi", String)
-    DEFAULT_DSLDIR = T.let("#{DEFAULT_RBIDIR}/dsl", String)
-    DEFAULT_GEMDIR = T.let("#{DEFAULT_RBIDIR}/gems", String)
-    DEFAULT_TODOSPATH = T.let("#{DEFAULT_RBIDIR}/todo.rbi", 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])
-  end
-end

data/lib/tapioca/config_builder.rb

@@ -1,73 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "yaml"
-
-module Tapioca
-  class ConfigBuilder
-    class << self
-      extend(T::Sig)
-
-      sig { params(command: Symbol, options: T::Hash[String, T.untyped]).returns(Config) }
-      def from_options(command, options)
-        merged_options = merge_options(default_options(command), config_options, options)
-
-        puts(<<~MSG) if merged_options.include?("generate_command")
-          DEPRECATION: The `-c` and `--cmd` flags will be removed in a future release.
-        MSG
-
-        Config.from_hash(merged_options)
-      end
-
-      private
-
-      sig { returns(T::Hash[String, T.untyped]) }
-      def config_options
-        if File.exist?(Config::TAPIOCA_CONFIG)
-          YAML.load_file(Config::TAPIOCA_CONFIG, fallback: {})
-        else
-          {}
-        end
-      end
-
-      sig { params(command: Symbol).returns(T::Hash[String, T.untyped]) }
-      def default_options(command)
-        default_outdir = case command
-        when :sync, :generate, :gem
-          Config::DEFAULT_GEMDIR
-        when :dsl
-          Config::DEFAULT_DSLDIR
-        else
-          Config::SORBET_PATH
-        end
-
-        DEFAULT_OPTIONS.merge("outdir" => default_outdir)
-      end
-
-      sig { params(options: T::Hash[String, T.untyped]).returns(T::Hash[String, T.untyped]) }
-      def merge_options(*options)
-        options.each_with_object({}) do |option, result|
-          result.merge!(option) do |_, this_val, other_val|
-            if this_val.is_a?(Hash) && other_val.is_a?(Hash)
-              this_val.merge(other_val)
-            else
-              other_val
-            end
-          end
-        end
-      end
-    end
-
-    DEFAULT_OPTIONS = T.let({
-      "postrequire" => Config::DEFAULT_POSTREQUIRE,
-      "outdir" => nil,
-      "exclude" => [],
-      "exclude_generators" => [],
-      "typed_overrides" => Config::DEFAULT_OVERRIDES,
-      "todos_path" => Config::DEFAULT_TODOSPATH,
-      "generators" => [],
-      "file_header" => true,
-      "doc" => false,
-    }.freeze, T::Hash[String, T.untyped])
-  end
-end

data/lib/tapioca/constant_locator.rb

@@ -1,40 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "set"
-
-module Tapioca
-  # Registers a TracePoint immediately upon load to track points at which
-  # classes and modules are opened for definition. This is used to track
-  # correspondence between classes/modules and files, as this information isn't
-  # available in the ruby runtime without extra accounting.
-  module ConstantLocator
-    extend Reflection
-
-    @class_files = {}
-
-    # Immediately activated upon load. Observes class/module definition.
-    TracePoint.trace(:class) do |tp|
-      unless tp.self.singleton_class?
-        key = name_of(tp.self)
-        file = tp.path
-        if file == "(eval)"
-          file = T.must(caller_locations)
-            .drop_while { |loc| loc.path == "(eval)" }
-            .first&.path
-        end
-        @class_files[key] ||= Set.new
-        @class_files[key] << file
-      end
-    end
-
-    # Returns the files in which this class or module was opened. Doesn't know
-    # about situations where the class was opened prior to +require+ing,
-    # or where metaprogramming was used via +eval+, etc.
-    def self.files_for(klass)
-      name = String === klass ? klass : name_of(klass)
-      files = @class_files[name]
-      files || Set.new
-    end
-  end
-end