tapioca 0.4.18 → 0.4.23

data/lib/tapioca/core_ext/string.rb

@@ -0,0 +1,18 @@
+# typed: strict
+# frozen_string_literal: true
+
+class String
+  extend T::Sig
+
+  sig { returns(String) }
+  def underscore
+    return self unless /[A-Z-]|::/.match?(self)
+
+    word = to_s.gsub("::", "/")
+    word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
+end

data/lib/tapioca/gemfile.rb

@@ -108,8 +108,14 @@ module Tapioca
 
       sig { returns(T::Array[Pathname]) }
       def files
-        @spec.full_require_paths.flat_map do |path|
-          Pathname.glob((Pathname.new(path) / "**/*.rb").to_s)
+        if default_gem?
+          @spec.files.map do |file|
+            ruby_lib_dir.join(file)
+          end
+        else
+          @spec.full_require_paths.flat_map do |path|
+            Pathname.glob((Pathname.new(path) / "**/*.rb").to_s)
+          end
         end
       end
 
@@ -125,11 +131,25 @@ module Tapioca
 
       sig { params(path: String).returns(T::Boolean) }
       def contains_path?(path)
-        to_realpath(path).start_with?(full_gem_path) || has_parent_gemspec?(path)
+        if default_gem?
+          files.any? { |file| file.to_s == to_realpath(path) }
+        else
+          to_realpath(path).start_with?(full_gem_path) || has_parent_gemspec?(path)
+        end
       end
 
       private
 
+      sig { returns(T::Boolean) }
+      def default_gem?
+        @spec.respond_to?(:default_gem?) && @spec.default_gem?
+      end
+
+      sig { returns(Pathname) }
+      def ruby_lib_dir
+        Pathname.new(RbConfig::CONFIG["rubylibdir"])
+      end
+
       sig { returns(String) }
       def version_string
         version = @spec.version.to_s
@@ -176,7 +196,7 @@ module Tapioca
 
       sig { returns(T::Boolean) }
       def gem_in_bundle_path?
-        full_gem_path.start_with?(Bundler.bundle_path.to_s)
+        full_gem_path.start_with?(Bundler.bundle_path.to_s, Bundler.app_cache.to_s)
       end
     end
   end

data/lib/tapioca/generator.rb

@@ -3,6 +3,7 @@
 
 require 'pathname'
 require 'thor'
+require "tapioca/core_ext/string"
 
 module Tapioca
   class Generator < ::Thor::Shell::Color
@@ -120,9 +121,10 @@ module Tapioca
       params(
         requested_constants: T::Array[String],
         should_verify: T::Boolean,
+        quiet: T::Boolean
       ).void
     end
-    def build_dsl(requested_constants, should_verify: false)
+    def build_dsl(requested_constants, should_verify: false, quiet: false)
       load_application(eager_load: requested_constants.empty?)
       load_dsl_generators
 
@@ -133,7 +135,7 @@ module Tapioca
       end
       say("")
 
-      outpath = should_verify ? Dir.mktmpdir : config.outpath
+      outpath = should_verify ? Pathname.new(Dir.mktmpdir) : config.outpath
       rbi_files_to_purge = existing_rbi_filenames(requested_constants)
 
       compiler = Compilers::DslCompiler.new(
@@ -145,8 +147,18 @@ module Tapioca
       )
 
       compiler.run do |constant, contents|
-        filename = compile_dsl_rbi(constant, contents, outpath: Pathname.new(outpath))
-        rbi_files_to_purge.delete(filename) if filename
+        constant_name = Module.instance_method(:name).bind(constant).call
+
+        filename = compile_dsl_rbi(
+          constant_name,
+          contents,
+          outpath: outpath,
+          quiet: should_verify || quiet
+        )
+
+        if filename
+          rbi_files_to_purge.delete(filename)
+        end
       end
       say("")
 
@@ -274,7 +286,7 @@ module Tapioca
     def constantize(constant_names)
       constant_map = constant_names.map do |name|
         begin
-          [name, name.constantize]
+          [name, Object.const_get(name)]
         rescue NameError
           [name, nil]
         end
@@ -506,60 +518,101 @@ module Tapioca
       end
     end
 
-    sig { params(constant: Module, contents: String, outpath: Pathname).returns(T.nilable(Pathname)) }
-    def compile_dsl_rbi(constant, contents, outpath: config.outpath)
+    sig do
+      params(constant_name: String, contents: String, outpath: Pathname, quiet: T::Boolean)
+        .returns(T.nilable(Pathname))
+    end
+    def compile_dsl_rbi(constant_name, contents, outpath: config.outpath, quiet: false)
       return if contents.nil?
 
-      constant_name = Module.instance_method(:name).bind(constant).call
       rbi_name = constant_name.underscore + ".rbi"
       filename = outpath / rbi_name
 
       out = String.new
       out << rbi_header(
         "#{Config::DEFAULT_COMMAND} dsl #{constant_name}",
-        reason: "dynamic methods in `#{constant.name}`"
+        reason: "dynamic methods in `#{constant_name}`"
       )
       out << contents
 
       FileUtils.mkdir_p(File.dirname(filename))
       File.write(filename, out)
-      say("Wrote: ", [:green])
-      say(filename)
+
+      unless quiet
+        say("Wrote: ", [:green])
+        say(filename)
+      end
 
       filename
     end
 
-    sig { params(tmp_dir: Pathname).returns(T.nilable(String)) }
+    sig { params(tmp_dir: Pathname).returns(T::Hash[String, Symbol]) }
     def verify_dsl_rbi(tmp_dir:)
-      existing_rbis = existing_rbi_filenames([]).sort
-      new_rbis = existing_rbi_filenames([], path: tmp_dir).grep_v(/gem|shim/).sort
+      diff = {}
 
-      return "New file(s) introduced." if existing_rbis.length != new_rbis.length
+      existing_rbis = rbi_files_in(config.outpath)
+      new_rbis = rbi_files_in(tmp_dir)
 
-      desynced_files = []
+      added_files = (new_rbis - existing_rbis)
 
-      (0..existing_rbis.length - 1).each do |i|
-        desynced_files << new_rbis[i] unless FileUtils.identical?(existing_rbis[i], new_rbis[i])
+      added_files.each do |file|
+        diff[file] = :added
       end
 
-      unless desynced_files.empty?
-        filenames = desynced_files.map { |f| f.to_s.sub!(tmp_dir.to_s, "sorbet/rbi/dsl") }.join("\n  - ")
+      removed_files = (existing_rbis - new_rbis)
 
-        return "File(s) updated:\n  - #{filenames}"
+      removed_files.each do |file|
+        diff[file] = :removed
       end
 
-      nil
+      common_files = (existing_rbis & new_rbis)
+
+      changed_files = common_files.map do |filename|
+        filename unless FileUtils.identical?(config.outpath / filename, tmp_dir / filename)
+      end.compact
+
+      changed_files.each do |file|
+        diff[file] = :changed
+      end
+
+      diff
+    end
+
+    sig { params(cause: Symbol, files: T::Array[String]).returns(String) }
+    def build_error_for_files(cause, files)
+      filenames = files.map do |file|
+        config.outpath / file
+      end.join("\n  - ")
+
+      "  File(s) #{cause}:\n  - #{filenames}"
+    end
+
+    sig { params(path: Pathname).returns(T::Array[Pathname]) }
+    def rbi_files_in(path)
+      Pathname.glob(path / "**/*.rbi").map do |file|
+        file.relative_path_from(path)
+      end.sort
     end
 
-    sig { params(dir: String).void }
+    sig { params(dir: Pathname).void }
     def perform_dsl_verification(dir)
-      if (error = verify_dsl_rbi(tmp_dir: Pathname.new(dir)))
-        say("RBI files are out-of-date, please run `#{Config::DEFAULT_COMMAND} dsl` to update.")
-        say("Reason: ", [:red])
-        say(error)
-        exit(1)
-      else
+      diff = verify_dsl_rbi(tmp_dir: dir)
+
+      if diff.empty?
         say("Nothing to do, all RBIs are up-to-date.")
+      else
+        say("RBI files are out-of-date. In your development environment, please run:", :green)
+        say("  `#{Config::DEFAULT_COMMAND} dsl`", [:green, :bold])
+        say("Once it is complete, be sure to commit and push any changes", :green)
+
+        say("")
+
+        say("Reason:", [:red])
+        diff.group_by(&:last).sort.each do |cause, diff_for_cause|
+          say(build_error_for_files(cause, diff_for_cause.map(&:first)))
+        end
+
+        exit(1)
       end
     ensure
       FileUtils.remove_entry(dir)

data/lib/tapioca/generic_type_registry.rb

@@ -51,14 +51,12 @@ module Tapioca
         type_list = types.map { |type| T::Utils.coerce(type).name }.join(", ")
         name = "#{name_of(constant)}[#{type_list}]"
 
-        # Create a clone of the constant with an overridden `name`
+        # Create a generic type with an overridden `name`
         # method that returns the name we constructed above.
         #
-        # Also, we try to memoize the clone based on the name, so that
-        # we don't have to keep recreating clones all the time.
-        @generic_instances[name] ||= constant.clone.tap do |clone|
-          clone.define_singleton_method(:name) { name }
-        end
+        # Also, we try to memoize the generic type based on the name, so that
+        # we don't have to keep recreating them all the time.
+        @generic_instances[name] ||= create_generic_type(constant, name)
       end
 
       sig do
@@ -94,6 +92,31 @@ module Tapioca
 
       private
 
+      sig { params(constant: Module, name: String).returns(Module) }
+      def create_generic_type(constant, name)
+        generic_type = case constant
+        when Class
+          # For classes, we want to create a subclass, so that an instance of
+          # the generic class `Foo[Bar]` is still a `Foo`. That is:
+          # `Foo[Bar].new.is_a?(Foo)` should be true, which isn't the case
+          # if we just clone the class. But subclassing works just fine.
+          create_safe_subclass(constant)
+        else
+          # This can only be a module and it is fine to just clone modules
+          # since they can't have instances and will not have `is_a?` relationships.
+          # Moreover, we never `include`/`extend` any generic modules into the
+          # ancestor tree, so this doesn't become a problem with checking the
+          # instance of a class being `is_a?` of a module type.
+          constant.clone
+        end
+
+        # Let's set the `name` method to return the proper generic name
+        generic_type.define_singleton_method(:name) { name }
+
+        # Return the generic type we created
+        generic_type
+      end
+
       # This method is called from intercepted calls to `type_member` and `type_template`.
       # We get passed all the arguments to those methods, as well as the `T::Types::TypeVariable`
       # instance generated by the Sorbet defined `type_member`/`type_template` call on `T::Generic`.
@@ -127,6 +150,35 @@ module Tapioca
         )
       end
 
+      sig { params(constant: Class).returns(Class) }
+      def create_safe_subclass(constant)
+        # Lookup the "inherited" class method
+        inherited_method = constant.method(:inherited)
+        # and the module that defines it
+        owner = inherited_method.owner
+
+        # If no one has overriden the inherited method yet, just subclass
+        return Class.new(constant) if Class == owner
+
+        begin
+          # Otherwise, some inherited method could be preventing us
+          # from creating subclasses, so let's override it and rescue
+          owner.send(:define_method, :inherited) do |s|
+            begin
+              inherited_method.call(s)
+            rescue
+              # Ignoring errors
+            end
+          end
+
+          # return a subclass
+          Class.new(constant)
+        ensure
+          # Reinstate the original inherited method back.
+          owner.send(:define_method, :inherited, inherited_method)
+        end
+      end
+
       sig { params(constant: Module).returns(T::Hash[Integer, String]) }
       def lookup_or_initialize_type_variables(constant)
         @type_variables[object_id_of(constant)] ||= {}

data/lib/tapioca/internal.rb

@@ -6,12 +6,20 @@ require "tapioca/loader"
 require "tapioca/constant_locator"
 require "tapioca/generic_type_registry"
 require "tapioca/sorbet_ext/generic_name_patch"
+require "tapioca/sorbet_ext/fixed_hash_patch"
 require "tapioca/config"
 require "tapioca/config_builder"
 require "tapioca/generator"
 require "tapioca/cli"
 require "tapioca/cli/main"
 require "tapioca/gemfile"
+require "tapioca/rbi/model"
+require "tapioca/rbi/visitor"
+require "tapioca/rbi/rewriters/nest_singleton_methods"
+require "tapioca/rbi/rewriters/nest_non_public_methods"
+require "tapioca/rbi/rewriters/group_nodes"
+require "tapioca/rbi/rewriters/sort_nodes"
+require "tapioca/rbi/printer"
 require "tapioca/compilers/sorbet"
 require "tapioca/compilers/requires_compiler"
 require "tapioca/compilers/symbol_table_compiler"

data/lib/tapioca/rbi/model.rb

@@ -0,0 +1,405 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module RBI
+    class Node
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { returns(T.nilable(Tree)) }
+      attr_accessor :parent_tree
+
+      sig { void }
+      def initialize
+        @parent_tree = nil
+      end
+
+      sig { void }
+      def detach
+        tree = parent_tree
+        return unless tree
+        tree.nodes.delete(self)
+        self.parent_tree = nil
+      end
+    end
+
+    class Tree < Node
+      extend T::Sig
+
+      sig { returns(T::Array[Node]) }
+      attr_reader :nodes
+
+      sig { void }
+      def initialize
+        super()
+        @nodes = T.let([], T::Array[Node])
+      end
+
+      sig { params(node: Node).void }
+      def <<(node)
+        node.parent_tree = self
+        @nodes << node
+      end
+
+      sig { returns(T::Boolean) }
+      def empty?
+        nodes.empty?
+      end
+    end
+
+    # Scopes
+
+    class Scope < Tree
+      extend T::Helpers
+
+      abstract!
+    end
+
+    class Module < Scope
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { params(name: String).void }
+      def initialize(name)
+        super()
+        @name = name
+      end
+    end
+
+    class Class < Scope
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :superclass_name
+
+      sig { params(name: String, superclass_name: T.nilable(String)).void }
+      def initialize(name, superclass_name: nil)
+        super()
+        @name = name
+        @superclass_name = superclass_name
+      end
+    end
+
+    class SingletonClass < Scope
+      extend T::Sig
+
+      sig { void }
+      def initialize
+        super()
+      end
+    end
+
+    # Consts
+
+    class Const < Node
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :name, :value
+
+      sig { params(name: String, value: String).void }
+      def initialize(name, value)
+        super()
+        @name = name
+        @value = value
+      end
+    end
+
+    # Methods and args
+
+    class Method < Node
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { returns(T::Array[Param]) }
+      attr_reader :params
+
+      sig { returns(T::Boolean) }
+      attr_accessor :is_singleton
+
+      sig { returns(Visibility) }
+      attr_accessor :visibility
+
+      sig { returns(T::Array[Sig]) }
+      attr_accessor :sigs
+
+      sig do
+        params(
+          name: String,
+          params: T::Array[Param],
+          is_singleton: T::Boolean,
+          visibility: Visibility,
+          sigs: T::Array[Sig]
+        ).void
+      end
+      def initialize(name, params: [], is_singleton: false, visibility: Visibility::Public, sigs: [])
+        super()
+        @name = name
+        @params = params
+        @is_singleton = is_singleton
+        @visibility = visibility
+        @sigs = sigs
+      end
+
+      sig { params(param: Param).void }
+      def <<(param)
+        @params << param
+      end
+    end
+
+    class Param < Node
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      def initialize(name)
+        super()
+        @name = name
+      end
+    end
+
+    class OptParam < Param
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :value
+
+      sig { params(name: String, value: String).void }
+      def initialize(name, value)
+        super(name)
+        @value = value
+      end
+    end
+
+    class RestParam < Param; end
+    class KwParam < Param; end
+    class KwOptParam < OptParam; end
+    class KwRestParam < Param; end
+    class BlockParam < Param; end
+
+    # Mixins
+
+    class Mixin < Node
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { returns(String) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      def initialize(name)
+        super()
+        @name = name
+      end
+    end
+
+    class Include < Mixin; end
+    class Extend < Mixin; end
+
+    # Visibility
+
+    class Visibility < Node
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { returns(Symbol) }
+      attr_reader :visibility
+
+      sig { params(visibility: Symbol).void }
+      def initialize(visibility)
+        super()
+        @visibility = visibility
+      end
+
+      sig { returns(T::Boolean) }
+      def public?
+        visibility == :public
+      end
+
+      Public = T.let(Visibility.new(:public), Visibility)
+      Protected = T.let(Visibility.new(:protected), Visibility)
+      Private = T.let(Visibility.new(:private), Visibility)
+    end
+
+    # Sorbet's sigs
+
+    class Sig < Node
+      extend T::Sig
+
+      sig { returns(T::Array[SigParam]) }
+      attr_reader :params
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :return_type
+
+      sig { returns(T::Boolean) }
+      attr_accessor :is_abstract, :is_override, :is_overridable
+
+      sig { returns(T::Array[String]) }
+      attr_reader :type_params
+
+      sig do
+        params(
+          params: T::Array[SigParam],
+          return_type: T.nilable(String),
+          is_abstract: T::Boolean,
+          is_override: T::Boolean,
+          is_overridable: T::Boolean,
+          type_params: T::Array[String]
+        ).void
+      end
+      def initialize(
+        params: [],
+        return_type: nil,
+        is_abstract: false,
+        is_override: false,
+        is_overridable: false,
+        type_params: []
+      )
+        super()
+        @params = params
+        @return_type = return_type
+        @is_abstract = is_abstract
+        @is_override = is_override
+        @is_overridable = is_overridable
+        @type_params = type_params
+      end
+
+      sig { params(param: SigParam).void }
+      def <<(param)
+        @params << param
+      end
+    end
+
+    class SigParam < Node
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :name, :type
+
+      sig { params(name: String, type: String).void }
+      def initialize(name, type)
+        super()
+        @name = name
+        @type = type
+      end
+    end
+
+    # Sorbet's T::Struct
+
+    class TStruct < Class
+      extend T::Sig
+
+      sig { params(name: String).void }
+      def initialize(name)
+        super(name, superclass_name: "::T::Struct")
+      end
+    end
+
+    class TStructField < Node
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { returns(String) }
+      attr_accessor :name, :type
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :default
+
+      sig do
+        params(
+          name: String,
+          type: String,
+          default: T.nilable(String)
+        ).void
+      end
+      def initialize(name, type, default: nil)
+        super()
+        @name = name
+        @type = type
+        @default = default
+      end
+    end
+
+    class TStructProp < TStructField; end
+    class TStructConst < TStructField; end
+
+    # Sorbet's T::Enum
+
+    class TEnum < Class
+      extend T::Sig
+
+      sig { params(name: String).void }
+      def initialize(name)
+        super(name, superclass_name: "::T::Enum")
+      end
+    end
+
+    class TEnumBlock < Node
+      extend T::Sig
+
+      sig { returns(T::Array[String]) }
+      attr_reader :names
+
+      sig { params(names: T::Array[String]).void }
+      def initialize(names = [])
+        super()
+        @names = names
+      end
+
+      sig { returns(T::Boolean) }
+      def empty?
+        names.empty?
+      end
+    end
+
+    # Sorbet's misc.
+
+    class Helper < Node
+      extend T::Helpers
+
+      sig { returns(String) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      def initialize(name)
+        super()
+        @name = name
+      end
+    end
+
+    class TypeMember < Node
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :name, :value
+
+      sig { params(name: String, value: String).void }
+      def initialize(name, value)
+        super()
+        @name = name
+        @value = value
+      end
+    end
+
+    class MixesInClassMethods < Mixin; end
+  end
+end