tapioca 0.4.12 → 0.4.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa0397f8a108fad9551d726b06c39f1aa7f8e03c86d43a7ef50c25ad4cf8d10b
-  data.tar.gz: d3207d13a06219a661f7fbaa5a55300d19512815c03c3db9bb653730a86ca448
+  metadata.gz: 9293078ee1614e88f45586904e3d90cc556cab3218340699325902e224d94aed
+  data.tar.gz: d14050953a3de23bfc4830b6b27282331dcac745090695cd2552a5e7a1ee6296
 SHA512:
-  metadata.gz: 6c99c218f798feb84115db8a93f9297883e249b9418b2bcdafe7f31da53dc2c1b741c6ded274839df29e25597aeeda818d3d6440a0000f1996d8e8a12233a67c
-  data.tar.gz: 594daf8423059604af0ba86a8d3e8afff7dd52cffc3b13a3075d0ec66f9fb85b0e17cc15787e89b948f1dc9ad44848558b1b95ef5377ad68dc7a2ca4fd06211b
+  metadata.gz: bd3bbcbc3a7d5448e7ace8472258e96c654d8854f1c4ec3ffe498a5b06e136f46df526f5a83d4b7814bf1ed57eec24cb3694c8fce686dd2df02a6d6af6de8414
+  data.tar.gz: 641e472a327784295d117481c9676b7fc92c320a764d06449ed9c5d65e1f5cc76cb63b0446e4269d85fd606df8ec19e519ce42cfe503403a1cf2197c042ad494

data/Gemfile

@@ -10,7 +10,6 @@ group(:deployment, :development) do
   gem("rake")
 end
 
-gem("bundler", "~> 1.17")
 gem("yard", "~> 0.9.25")
 gem("pry-byebug")
 gem("minitest")

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

@@ -24,6 +24,8 @@ module Tapioca
       #   belongs_to :category
       #   has_many :comments
       #   has_one :author, class_name: "User"
+      #
+      #   accepts_nested_attributes_for :category, :comments, :author
       # end
       # ~~~
       #
@@ -44,6 +46,9 @@ module Tapioca
       #     sig { params(value: T.nilable(::User)).void }
       #     def author=(value); end
       #
+      #     sig { params(attributes: T.untyped).returns(T.untyped) }
+      #     def author_attributes=(attributes); end
+      #
       #     sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
       #     def build_author(*args, &blk); end
       #
@@ -56,6 +61,9 @@ module Tapioca
       #     sig { params(value: T.nilable(::Category)).void }
       #     def category=(value); end
       #
+      #     sig { params(attributes: T.untyped).returns(T.untyped) }
+      #     def category_attributes=(attributes); end
+      #
       #     sig { returns(T::Array[T.untyped]) }
       #     def comment_ids; end
       #
@@ -68,6 +76,9 @@ module Tapioca
       #     sig { params(value: T::Enumerable[::Comment]).void }
       #     def comments=(value); end
       #
+      #     sig { params(attributes: T.untyped).returns(T.untyped) }
+      #     def comments_attributes=(attributes); end
+      #
       #     sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
       #     def create_author(*args, &blk); end
       #
@@ -103,13 +114,8 @@ module Tapioca
             module_name = "GeneratedAssociationMethods"
 
             model.create_module(module_name) do |mod|
-              constant.reflections.each do |association_name, reflection|
-                if reflection.collection?
-                  populate_collection_assoc_getter_setter(mod, constant, association_name, reflection)
-                else
-                  populate_single_assoc_getter_setter(mod, constant, association_name, reflection)
-                end
-              end
+              populate_nested_attribute_writers(mod, constant)
+              populate_associations(mod, constant)
             end
 
             model.create_include(module_name)
@@ -123,6 +129,31 @@ module Tapioca
 
         private
 
+        sig { params(mod: Parlour::RbiGenerator::Namespace, constant: T.class_of(ActiveRecord::Base)).void }
+        def populate_nested_attribute_writers(mod, constant)
+          constant.nested_attributes_options.keys.each do |association_name|
+            create_method(
+              mod,
+              "#{association_name}_attributes=",
+              parameters: [
+                Parlour::RbiGenerator::Parameter.new("attributes", type: "T.untyped"),
+              ],
+              return_type: "T.untyped"
+            )
+          end
+        end
+
+        sig { params(mod: Parlour::RbiGenerator::Namespace, constant: T.class_of(ActiveRecord::Base)).void }
+        def populate_associations(mod, constant)
+          constant.reflections.each do |association_name, reflection|
+            if reflection.collection?
+              populate_collection_assoc_getter_setter(mod, constant, association_name, reflection)
+            else
+              populate_single_assoc_getter_setter(mod, constant, association_name, reflection)
+            end
+          end
+        end
+
         sig do
           params(
             klass: Parlour::RbiGenerator::Namespace,

data/lib/tapioca/compilers/sorbet.rb

@@ -8,6 +8,7 @@ module Tapioca
   module Compilers
     module Sorbet
       SORBET = Pathname.new(Gem::Specification.find_by_name("sorbet-static").full_gem_path) / "libexec" / "sorbet"
+      EXE_PATH_ENV_VAR = "TAPIOCA_SORBET_EXE"
 
       class << self
         extend(T::Sig)
@@ -26,7 +27,9 @@ module Tapioca
 
         sig { returns(String) }
         def sorbet_path
-          SORBET.to_s.shellescape
+          sorbet_path = ENV.fetch(EXE_PATH_ENV_VAR, SORBET)
+          sorbet_path = SORBET if sorbet_path.empty?
+          sorbet_path.to_s.shellescape
         end
       end
     end

data/lib/tapioca/compilers/symbol_table/symbol_generator.rb

@@ -95,6 +95,7 @@ module Tapioca
           return if alias_namespaced?(name)
           return if seen?(name)
           return unless parent_declares_constant?(name)
+          return if T::Enum === constant # T::Enum instances are defined via `compile_enums`
 
           mark_seen(name)
           compile_constant(name, constant)
@@ -122,12 +123,15 @@ module Tapioca
         def compile_alias(name, constant)
           return if symbol_ignored?(name)
 
-          constant_name = name_of(constant)
+          target = name_of(constant)
+          # If target has no name, let's make it an anonymous class or module with `Class.new` or `Module.new`
+          target = "#{constant.class}.new" unless target
+
           add_to_alias_namespace(name)
 
           return if IGNORED_SYMBOLS.include?(name)
 
-          indented("#{name} = #{constant_name}")
+          indented("#{name} = #{target}")
         end
 
         sig do
@@ -180,6 +184,7 @@ module Tapioca
               compile_mixins(constant),
               compile_mixes_in_class_methods(constant),
               compile_props(constant),
+              compile_enums(constant),
               methods,
             ].select { |b| b != "" }.join("\n\n")
           end
@@ -189,15 +194,12 @@ module Tapioca
         def compile_module_helpers(constant)
           abstract_type = T::Private::Abstract::Data.get(constant, :abstract_type)
 
-          if abstract_type
-            indented("#{abstract_type}!")
-          elsif T::Private::Final.final_module?(constant)
-            indented("final!")
-          elsif T::Private::Sealed.sealed_module?(constant)
-            indented("sealed!")
-          else
-            ""
-          end
+          helpers = []
+          helpers << indented("#{abstract_type}!") if abstract_type
+          helpers << indented("final!") if T::Private::Final.final_module?(constant)
+          helpers << indented("sealed!") if T::Private::Sealed.sealed_module?(constant)
+
+          helpers.join("\n")
         end
 
         sig { params(constant: Module).returns(String) }
@@ -207,7 +209,7 @@ module Tapioca
           constant.props.map do |name, prop|
             method = "prop"
             method = "const" if prop.fetch(:immutable, false)
-            type = prop.fetch(:type_object, "T.untyped")
+            type = prop.fetch(:type_object, "T.untyped").to_s.gsub(".returns(<VOID>)", ".void")
 
             if prop.key?(:default)
               indented("#{method} :#{name}, #{type}, default: T.unsafe(nil)")
@@ -217,6 +219,23 @@ module Tapioca
           end.join("\n")
         end
 
+        sig { params(constant: Module).returns(String) }
+        def compile_enums(constant)
+          return "" unless T::Enum > constant
+
+          enums = T.cast(constant, T::Enum).values.map do |enum_type|
+            enum_type.instance_variable_get(:@const_name).to_s
+          end
+
+          content = [
+            indented('enums do'),
+            *enums.map { |e| indented("  #{e} = new") }.join("\n"),
+            indented('end'),
+          ]
+
+          content.join("\n")
+        end
+
         sig { params(name: String, constant: Module).returns(T.nilable(String)) }
         def compile_subconstants(name, constant)
           output = constants_of(constant).sort.uniq.map do |constant_name|
@@ -345,9 +364,13 @@ module Tapioca
             end
 
             define_singleton_method(:include) do |mod|
-              before = singleton_class.ancestors
-              super(mod).tap do
-                mixins_from_modules[mod] = singleton_class.ancestors - before
+              begin
+                before = singleton_class.ancestors
+                super(mod).tap do
+                  mixins_from_modules[mod] = singleton_class.ancestors - before
+                end
+              rescue Exception # rubocop:disable Lint/RescueException
+                # this is a best effort, bail if we can't perform this
               end
             end
 

data/lib/tapioca/gemfile.rb

@@ -17,27 +17,23 @@ module Tapioca
       )
     end
 
+    sig { returns(Bundler::Definition) }
+    attr_reader(:definition)
+
+    sig { returns(T::Array[Gem]) }
+    attr_reader(:dependencies)
+
+    sig { returns(T::Array[String]) }
+    attr_reader(:missing_specs)
+
     sig { void }
     def initialize
       @gemfile = T.let(File.new(Bundler.default_gemfile), File)
       @lockfile = T.let(File.new(Bundler.default_lockfile), File)
-      @dependencies = T.let(nil, T.nilable(T::Array[Gem]))
-      @definition = T.let(nil, T.nilable(Bundler::Definition))
-    end
-
-    sig { returns(T::Array[Gem]) }
-    def dependencies
-      @dependencies ||= begin
-        specs = definition.locked_gems.specs.to_a
-
-        definition
-          .resolve
-          .materialize(specs)
-          .map { |spec| Gem.new(spec) }
-          .reject { |gem| gem.ignore?(dir) }
-          .uniq(&:rbi_file_name)
-          .sort_by(&:rbi_file_name)
-      end
+      @definition = T.let(Bundler::Dsl.evaluate(gemfile, lockfile, {}), Bundler::Definition)
+      dependencies, missing_specs = load_dependencies
+      @dependencies = T.let(dependencies, T::Array[Gem])
+      @missing_specs = T.let(missing_specs, T::Array[String])
     end
 
     sig { params(gem_name: String).returns(T.nilable(Gem)) }
@@ -55,6 +51,23 @@ module Tapioca
     sig { returns(File) }
     attr_reader(:gemfile, :lockfile)
 
+    sig { returns([T::Array[Gem], T::Array[String]]) }
+    def load_dependencies
+      deps = definition.locked_gems.dependencies.values
+
+      missing_specs = T::Array[String].new
+
+      dependencies = definition
+        .resolve
+        .materialize(deps, missing_specs)
+        .map { |spec| Gem.new(spec) }
+        .reject { |gem| gem.ignore?(dir) }
+        .uniq(&:rbi_file_name)
+        .sort_by(&:rbi_file_name)
+
+      [dependencies, missing_specs]
+    end
+
     sig { returns(Bundler::Runtime) }
     def runtime
       Bundler::Runtime.new(File.dirname(gemfile.path), definition)
@@ -65,11 +78,6 @@ module Tapioca
       definition.groups
     end
 
-    sig { returns(Bundler::Definition) }
-    def definition
-      @definition ||= Bundler::Dsl.evaluate(gemfile, lockfile, {})
-    end
-
     sig { returns(String) }
     def dir
       File.expand_path(gemfile.path + "/..")

data/lib/tapioca/generator.rb

@@ -121,6 +121,8 @@ module Tapioca
       load_application(eager_load: requested_constants.empty?)
       load_dsl_generators
 
+      rbi_files_to_purge = existing_rbi_filenames(requested_constants)
+
       say("Compiling DSL RBI files...")
       say("")
 
@@ -133,7 +135,17 @@ module Tapioca
       )
 
       compiler.run do |constant, contents|
-        compile_dsl_rbi(constant, contents)
+        filename = compile_dsl_rbi(constant, contents)
+        rbi_files_to_purge.delete(filename) if filename
+      end
+
+      unless rbi_files_to_purge.empty?
+        say("")
+        say("Removing stale RBI files...")
+
+        rbi_files_to_purge.sort.each do |filename|
+          remove(filename)
+        end
       end
 
       say("")
@@ -192,6 +204,10 @@ module Tapioca
         exit(1)
       end
       say(" Done", :green)
+      unless bundle.missing_specs.empty?
+        say("  completed with missing specs: ")
+        say(bundle.missing_specs.join(', '), :yellow)
+      end
       puts
     end
 
@@ -249,13 +265,38 @@ module Tapioca
 
     sig { params(constant_names: T::Array[String]).returns(T::Array[Module]) }
     def constantize(constant_names)
-      constant_names.map do |name|
+      constant_map = constant_names.map do |name|
         begin
-          name.constantize
+          [name, name.constantize]
         rescue NameError
-          nil
+          [name, nil]
         end
-      end.compact
+      end.to_h
+
+      unprocessable_constants = constant_map.select { |_, v| v.nil? }
+      unless unprocessable_constants.empty?
+        unprocessable_constants.each do |name, _|
+          say("Error: Cannot find constant '#{name}'", :red)
+          remove(dsl_rbi_filename(name))
+        end
+
+        exit(1)
+      end
+
+      constant_map.values
+    end
+
+    sig { params(requested_constants: T::Array[String]).returns(T::Set[Pathname]) }
+    def existing_rbi_filenames(requested_constants)
+      filenames = if requested_constants.empty?
+        Pathname.glob(config.outpath / "**/*.rbi")
+      else
+        requested_constants.map do |constant_name|
+          dsl_rbi_filename(constant_name)
+        end
+      end
+
+      filenames.to_set
     end
 
     sig { returns(T::Hash[String, String]) }
@@ -273,6 +314,11 @@ module Tapioca
         .to_h
     end
 
+    sig { params(constant_name: String).returns(Pathname) }
+    def dsl_rbi_filename(constant_name)
+      config.outpath / "#{constant_name.underscore}.rbi"
+    end
+
     sig { params(gem_name: String, version: String).returns(Pathname) }
     def gem_rbi_filename(gem_name, version)
       config.outpath / "#{gem_name}@#{version}.rbi"
@@ -312,6 +358,7 @@ module Tapioca
 
     sig { params(filename: Pathname).void }
     def remove(filename)
+      return unless filename.exist?
       say("-- Removing: #{filename}")
       filename.unlink
     end
@@ -452,7 +499,7 @@ module Tapioca
       end
     end
 
-    sig { params(constant: Module, contents: String).void }
+    sig { params(constant: Module, contents: String).returns(T.nilable(Pathname)) }
     def compile_dsl_rbi(constant, contents)
       return if contents.nil?
 
@@ -472,6 +519,8 @@ module Tapioca
       File.write(filename, out)
       say("Wrote: ", [:green])
       say(filename)
+
+      filename
     end
   end
 end

data/lib/tapioca/loader.rb

@@ -99,17 +99,28 @@ module Tapioca
 
     sig { void }
     def eager_load_rails_app
+      rails = Object.const_get("Rails")
+      application = rails.application
+
       if Object.const_defined?("ActiveSupport")
         Object.const_get("ActiveSupport").run_load_hooks(
           :before_eager_load,
-          Object.const_get("Rails").application
+          application
         )
       end
+
       if Object.const_defined?("Zeitwerk::Loader")
         zeitwerk_loader = Object.const_get("Zeitwerk::Loader")
         zeitwerk_loader.eager_load_all
       end
-      Object.const_get("Rails").autoloaders.each(&:eager_load)
+
+      if rails.respond_to?(:autoloaders) && rails.autoloaders.zeitwerk_enabled?
+        rails.autoloaders.each(&:eager_load)
+      end
+
+      if application.config.respond_to?(:eager_load_namespaces)
+        application.config.eager_load_namespaces.each(&:eager_load!)
+      end
     end
 
     sig { void }

data/lib/tapioca/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.4.12
+  version: 0.4.17
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,8 +11,22 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-01-14 00:00:00.000000000 Z
+date: 2021-03-11 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.17.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.17.3
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement