tapioca 0.5.0 → 0.5.4

data/lib/tapioca/generators/dsl.rb

@@ -0,0 +1,362 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Generators
+    class Dsl < Base
+      sig do
+        params(
+          requested_constants: T::Array[String],
+          outpath: Pathname,
+          generators: T::Array[String],
+          exclude_generators: T::Array[String],
+          file_header: T::Boolean,
+          compiler_path: String,
+          tapioca_path: String,
+          default_command: String,
+          file_writer: Thor::Actions,
+          should_verify: T::Boolean,
+          quiet: T::Boolean,
+          verbose: T::Boolean
+        ).void
+      end
+      def initialize(
+        requested_constants:,
+        outpath:,
+        generators:,
+        exclude_generators:,
+        file_header:,
+        compiler_path:,
+        tapioca_path:,
+        default_command:,
+        file_writer: FileWriter.new,
+        should_verify: false,
+        quiet: false,
+        verbose: false
+      )
+        @requested_constants = requested_constants
+        @outpath = outpath
+        @generators = generators
+        @exclude_generators = exclude_generators
+        @file_header = file_header
+        @compiler_path = compiler_path
+        @tapioca_path = tapioca_path
+        @should_verify = should_verify
+        @quiet = quiet
+        @verbose = verbose
+
+        super(default_command: default_command, file_writer: file_writer)
+
+        @loader = T.let(nil, T.nilable(Loader))
+      end
+
+      sig { override.void }
+      def generate
+        load_application(eager_load: @requested_constants.empty?)
+        abort_if_pending_migrations!
+        load_dsl_generators
+
+        if @should_verify
+          say("Checking for out-of-date RBIs...")
+        else
+          say("Compiling DSL RBI files...")
+        end
+        say("")
+
+        outpath = @should_verify ? Pathname.new(Dir.mktmpdir) : @outpath
+        rbi_files_to_purge = existing_rbi_filenames(@requested_constants)
+
+        compiler = Compilers::DslCompiler.new(
+          requested_constants: constantize(@requested_constants),
+          requested_generators: constantize_generators(@generators),
+          excluded_generators: constantize_generators(@exclude_generators),
+          error_handler: ->(error) {
+            say_error(error, :bold, :red)
+          }
+        )
+
+        compiler.run do |constant, contents|
+          constant_name = T.must(Reflection.name_of(constant))
+
+          if @verbose && !@quiet
+            say_status(:processing, constant_name, :yellow)
+          end
+
+          filename = compile_dsl_rbi(
+            constant_name,
+            contents,
+            outpath: outpath,
+            quiet: @should_verify || @quiet && !@verbose
+          )
+
+          if filename
+            rbi_files_to_purge.delete(filename)
+          end
+        end
+        say("")
+
+        if @should_verify
+          perform_dsl_verification(outpath)
+        else
+          purge_stale_dsl_rbi_files(rbi_files_to_purge)
+
+          say("Done", :green)
+
+          say("All operations performed in working directory.", [:green, :bold])
+          say("Please review changes and commit them.", [:green, :bold])
+        end
+      end
+
+      private
+
+      sig { params(eager_load: T::Boolean).void }
+      def load_application(eager_load:)
+        say("Loading Rails application... ")
+
+        loader.load_rails_application(
+          environment_load: true,
+          eager_load: eager_load
+        )
+
+        say("Done", :green)
+      end
+
+      sig { void }
+      def abort_if_pending_migrations!
+        return unless File.exist?("config/application.rb")
+        return unless defined?(::Rake)
+
+        Rails.application.load_tasks
+        if Rake::Task.task_defined?("db:abort_if_pending_migrations")
+          Rake::Task["db:abort_if_pending_migrations"].invoke
+        end
+      end
+
+      sig { void }
+      def load_dsl_generators
+        say("Loading DSL generator classes... ")
+
+        Dir.glob([
+          "#{@compiler_path}/*.rb",
+          "#{@tapioca_path}/generators/**/*.rb",
+        ]).each do |generator|
+          require File.expand_path(generator)
+        end
+
+        say("Done", :green)
+      end
+
+      sig { params(requested_constants: T::Array[String], path: Pathname).returns(T::Set[Pathname]) }
+      def existing_rbi_filenames(requested_constants, path: @outpath)
+        filenames = if requested_constants.empty?
+          Pathname.glob(path / "**/*.rbi")
+        else
+          requested_constants.map do |constant_name|
+            dsl_rbi_filename(constant_name)
+          end
+        end
+
+        filenames.to_set
+      end
+
+      sig { params(constant_names: T::Array[String]).returns(T::Array[Module]) }
+      def constantize(constant_names)
+        constant_map = constant_names.map do |name|
+          [name, Object.const_get(name)]
+        rescue NameError
+          [name, nil]
+        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(generator_names: T::Array[String]).returns(T::Array[T.class_of(Compilers::Dsl::Base)]) }
+      def constantize_generators(generator_names)
+        generator_map = generator_names.map do |name|
+          # Try to find built-in tapioca generator first, then globally defined generator. The
+          # explicit `break` ensures the class is returned, not the `potential_name`.
+          generator_klass = ["Tapioca::Compilers::Dsl::#{name}", name].find do |potential_name|
+            break Object.const_get(potential_name)
+          rescue NameError
+            # Skip if we can't find generator by the potential name
+          end
+
+          [name, generator_klass]
+        end.to_h
+
+        unprocessable_generators = generator_map.select { |_, v| v.nil? }
+        unless unprocessable_generators.empty?
+          unprocessable_generators.each do |name, _|
+            say("Error: Cannot find generator '#{name}'", :red)
+          end
+
+          exit(1)
+        end
+
+        generator_map.values
+      end
+
+      sig do
+        params(
+          constant_name: String,
+          rbi: RBI::File,
+          outpath: Pathname,
+          quiet: T::Boolean
+        ).returns(T.nilable(Pathname))
+      end
+      def compile_dsl_rbi(constant_name, rbi, outpath: @outpath, quiet: false)
+        return if rbi.empty?
+
+        filename = outpath / rbi_filename_for(constant_name)
+
+        rbi.set_file_header(
+          generate_command_for(constant_name),
+          reason: "dynamic methods in `#{constant_name}`",
+          display_heading: @file_header
+        )
+
+        create_file(filename, rbi.transformed_string, verbose: !quiet)
+
+        filename
+      end
+
+      sig { params(dir: Pathname).void }
+      def perform_dsl_verification(dir)
+        diff = verify_dsl_rbi(tmp_dir: dir)
+
+        report_diff_and_exit_if_out_of_date(diff, "dsl")
+      ensure
+        FileUtils.remove_entry(dir)
+      end
+
+      sig { params(files: T::Set[Pathname]).void }
+      def purge_stale_dsl_rbi_files(files)
+        if files.any?
+          say("Removing stale RBI files...")
+
+          files.sort.each do |filename|
+            remove(filename)
+          end
+          say("")
+        end
+      end
+
+      sig { params(constant_name: String).returns(Pathname) }
+      def dsl_rbi_filename(constant_name)
+        @outpath / "#{underscore(constant_name)}.rbi"
+      end
+
+      sig { params(filename: Pathname).void }
+      def remove(filename)
+        return unless filename.exist?
+        say("-- Removing: #{filename}")
+        filename.unlink
+      end
+
+      sig { params(tmp_dir: Pathname).returns(T::Hash[String, Symbol]) }
+      def verify_dsl_rbi(tmp_dir:)
+        diff = {}
+
+        existing_rbis = rbi_files_in(@outpath)
+        new_rbis = rbi_files_in(tmp_dir)
+
+        added_files = (new_rbis - existing_rbis)
+
+        added_files.each do |file|
+          diff[file] = :added
+        end
+
+        removed_files = (existing_rbis - new_rbis)
+
+        removed_files.each do |file|
+          diff[file] = :removed
+        end
+
+        common_files = (existing_rbis & new_rbis)
+
+        changed_files = common_files.map do |filename|
+          filename unless FileUtils.identical?(@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|
+          @outpath / file
+        end.join("\n  - ")
+
+        "  File(s) #{cause}:\n  - #{filenames}"
+      end
+
+      sig { params(diff: T::Hash[String, Symbol], command: String).void }
+      def report_diff_and_exit_if_out_of_date(diff, command)
+        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("  `#{@default_command} #{command}`", [: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
+      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 { returns(Loader) }
+      def loader
+        @loader ||= Loader.new
+      end
+
+      sig { params(class_name: String).returns(String) }
+      def underscore(class_name)
+        return class_name unless /[A-Z-]|::/.match?(class_name)
+
+        word = class_name.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
+
+      sig { params(constant: String).returns(String) }
+      def rbi_filename_for(constant)
+        underscore(constant) + ".rbi"
+      end
+
+      sig { params(constant: String).returns(String) }
+      def generate_command_for(constant)
+        "#{@default_command} dsl #{constant}"
+      end
+    end
+  end
+end

data/lib/tapioca/generators/gem.rb

@@ -0,0 +1,345 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Generators
+    class Gem < Base
+      sig do
+        params(
+          gem_names: T::Array[String],
+          gem_excludes: T::Array[String],
+          prerequire: T.nilable(String),
+          postrequire: String,
+          typed_overrides: T::Hash[String, String],
+          default_command: String,
+          outpath: Pathname,
+          file_header: T::Boolean,
+          doc: T::Boolean,
+          file_writer: Thor::Actions
+        ).void
+      end
+      def initialize(
+        gem_names:,
+        gem_excludes:,
+        prerequire:,
+        postrequire:,
+        typed_overrides:,
+        default_command:,
+        outpath:,
+        file_header:,
+        doc:,
+        file_writer: FileWriter.new
+      )
+        @gem_names = gem_names
+        @gem_excludes = gem_excludes
+        @prerequire = prerequire
+        @postrequire = postrequire
+        @typed_overrides = typed_overrides
+        @outpath = outpath
+        @file_header = file_header
+
+        super(default_command: default_command, file_writer: file_writer)
+
+        @loader = T.let(nil, T.nilable(Loader))
+        @bundle = T.let(nil, T.nilable(Gemfile))
+        @existing_rbis = T.let(nil, T.nilable(T::Hash[String, String]))
+        @expected_rbis = T.let(nil, T.nilable(T::Hash[String, String]))
+        @doc = T.let(doc, T::Boolean)
+      end
+
+      sig { override.void }
+      def generate
+        require_gem_file
+
+        gems_to_generate(@gem_names)
+          .reject { |gem| @gem_excludes.include?(gem.name) }
+          .each do |gem|
+            say("Processing '#{gem.name}' gem:", :green)
+            shell.indent do
+              compile_gem_rbi(gem)
+              puts
+            end
+          end
+
+        say("All operations performed in working directory.", [:green, :bold])
+        say("Please review changes and commit them.", [:green, :bold])
+      end
+
+      sig { params(should_verify: T::Boolean).void }
+      def sync(should_verify: false)
+        if should_verify
+          say("Checking for out-of-date RBIs...")
+          say("")
+          perform_sync_verification
+          return
+        end
+
+        anything_done = [
+          perform_removals,
+          perform_additions,
+        ].any?
+
+        if anything_done
+          say("All operations performed in working directory.", [:green, :bold])
+          say("Please review changes and commit them.", [:green, :bold])
+        else
+          say("No operations performed, all RBIs are up-to-date.", [:green, :bold])
+        end
+
+        puts
+      end
+
+      private
+
+      sig { returns(Loader) }
+      def loader
+        @loader ||= Loader.new
+      end
+
+      sig { returns(Gemfile) }
+      def bundle
+        @bundle ||= Gemfile.new
+      end
+
+      sig { void }
+      def require_gem_file
+        say("Requiring all gems to prepare for compiling... ")
+        begin
+          loader.load_bundle(bundle, @prerequire, @postrequire)
+        rescue LoadError => e
+          explain_failed_require(@postrequire, e)
+          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
+
+      sig { params(gem_names: T::Array[String]).returns(T::Array[Gemfile::GemSpec]) }
+      def gems_to_generate(gem_names)
+        return bundle.dependencies if gem_names.empty?
+
+        gem_names.map do |gem_name|
+          gem = bundle.gem(gem_name)
+          if gem.nil?
+            say("Error: Cannot find gem '#{gem_name}'", :red)
+            exit(1)
+          end
+          gem
+        end
+      end
+
+      sig { params(gem: Gemfile::GemSpec).void }
+      def compile_gem_rbi(gem)
+        gem_name = set_color(gem.name, :yellow, :bold)
+        say("Compiling #{gem_name}, this may take a few seconds... ")
+
+        rbi = RBI::File.new(strictness: @typed_overrides[gem.name] || "true")
+        rbi.set_file_header(
+          "#{@default_command} gem #{gem.name}",
+          reason: "types exported from the `#{gem.name}` gem",
+          display_heading: @file_header
+        )
+
+        Compilers::SymbolTableCompiler.new.compile(gem, rbi, 0, @doc)
+
+        if rbi.empty?
+          rbi.set_empty_body_content
+          say("Done (empty output)", :yellow)
+        else
+          say("Done", :green)
+        end
+
+        create_file(@outpath / gem.rbi_file_name, rbi.transformed_string)
+
+        T.unsafe(Pathname).glob((@outpath / "#{gem.name}@*.rbi").to_s) do |file|
+          remove(file) unless file.basename.to_s == gem.rbi_file_name
+        end
+      end
+
+      sig { void }
+      def perform_sync_verification
+        diff = {}
+
+        removed_rbis.each do |gem_name|
+          filename = existing_rbi(gem_name)
+          diff[filename] = :removed
+        end
+
+        added_rbis.each do |gem_name|
+          filename = expected_rbi(gem_name)
+          diff[filename] = gem_rbi_exists?(gem_name) ? :changed : :added
+        end
+
+        report_diff_and_exit_if_out_of_date(diff, "gem")
+      end
+
+      sig { void }
+      def perform_removals
+        say("Removing RBI files of gems that have been removed:", [:blue, :bold])
+        puts
+
+        anything_done = T.let(false, T::Boolean)
+
+        gems = removed_rbis
+
+        shell.indent do
+          if gems.empty?
+            say("Nothing to do.")
+          else
+            gems.each do |removed|
+              filename = existing_rbi(removed)
+              remove(filename)
+            end
+
+            anything_done = true
+          end
+        end
+
+        puts
+
+        anything_done
+      end
+
+      sig { void }
+      def perform_additions
+        say("Generating RBI files of gems that are added or updated:", [:blue, :bold])
+        puts
+
+        anything_done = T.let(false, T::Boolean)
+
+        gems = added_rbis
+
+        shell.indent do
+          if gems.empty?
+            say("Nothing to do.")
+          else
+            require_gem_file
+
+            gems.each do |gem_name|
+              filename = expected_rbi(gem_name)
+
+              if gem_rbi_exists?(gem_name)
+                old_filename = existing_rbi(gem_name)
+                move(old_filename, filename) unless old_filename == filename
+              end
+
+              gem = T.must(bundle.gem(gem_name))
+              compile_gem_rbi(gem)
+              puts
+            end
+          end
+
+          anything_done = true
+        end
+
+        puts
+
+        anything_done
+      end
+
+      sig { params(file: String, error: LoadError).void }
+      def explain_failed_require(file, error)
+        say_error("\n\nLoadError: #{error}", :bold, :red)
+        say_error("\nTapioca could not load all the gems required by your application.", :yellow)
+        say_error("If you populated ", :yellow)
+        say_error("#{file} ", :bold, :blue)
+        say_error("with ", :yellow)
+        say_error("`#{@default_command} require`", :bold, :blue)
+        say_error("you should probably review it and remove the faulty line.", :yellow)
+      end
+
+      sig { params(filename: Pathname).void }
+      def remove(filename)
+        return unless filename.exist?
+        say("-- Removing: #{filename}")
+        filename.unlink
+      end
+
+      sig { returns(T::Array[String]) }
+      def removed_rbis
+        (existing_rbis.keys - expected_rbis.keys).sort
+      end
+
+      sig { params(gem_name: String).returns(Pathname) }
+      def existing_rbi(gem_name)
+        gem_rbi_filename(gem_name, T.must(existing_rbis[gem_name]))
+      end
+
+      sig { returns(T::Array[String]) }
+      def added_rbis
+        expected_rbis.select do |name, value|
+          existing_rbis[name] != value
+        end.keys.sort
+      end
+
+      sig { params(gem_name: String).returns(Pathname) }
+      def expected_rbi(gem_name)
+        gem_rbi_filename(gem_name, T.must(expected_rbis[gem_name]))
+      end
+
+      sig { params(gem_name: String).returns(T::Boolean) }
+      def gem_rbi_exists?(gem_name)
+        existing_rbis.key?(gem_name)
+      end
+
+      sig { params(diff: T::Hash[String, Symbol], command: String).void }
+      def report_diff_and_exit_if_out_of_date(diff, command)
+        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} #{command}`", [: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
+      end
+
+      sig { params(old_filename: Pathname, new_filename: Pathname).void }
+      def move(old_filename, new_filename)
+        say("-> Moving: #{old_filename} to #{new_filename}")
+        old_filename.rename(new_filename.to_s)
+      end
+
+      sig { returns(T::Hash[String, String]) }
+      def existing_rbis
+        @existing_rbis ||= Pathname.glob((@outpath / "*@*.rbi").to_s)
+          .map { |f| T.cast(f.basename(".*").to_s.split("@", 2), [String, String]) }
+          .to_h
+      end
+
+      sig { returns(T::Hash[String, String]) }
+      def expected_rbis
+        @expected_rbis ||= bundle.dependencies
+          .reject { |gem| @gem_excludes.include?(gem.name) }
+          .map { |gem| [gem.name, gem.version.to_s] }
+          .to_h
+      end
+
+      sig { params(gem_name: String, version: String).returns(Pathname) }
+      def gem_rbi_filename(gem_name, version)
+        @outpath / "#{gem_name}@#{version}.rbi"
+      end
+
+      sig { params(cause: Symbol, files: T::Array[String]).returns(String) }
+      def build_error_for_files(cause, files)
+        filenames = files.map do |file|
+          @outpath / file
+        end.join("\n  - ")
+
+        "  File(s) #{cause}:\n  - #{filenames}"
+      end
+    end
+  end
+end