tapioca 0.5.1 → 0.5.5

data/lib/tapioca/config.rb

@@ -14,6 +14,7 @@ module Tapioca
     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

data/lib/tapioca/config_builder.rb

@@ -67,6 +67,7 @@ module Tapioca
       "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

@@ -17,8 +17,14 @@ module Tapioca
     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] << tp.path
+        @class_files[key] << file
       end
     end
 

data/lib/tapioca/gemfile.rb

@@ -2,6 +2,8 @@
 # frozen_string_literal: true
 
 require "bundler"
+require "logger"
+require "yard-sorbet"
 
 module Tapioca
   class Gemfile
@@ -9,10 +11,7 @@ module Tapioca
 
     Spec = T.type_alias do
       T.any(
-        T.all(
-          ::Bundler::StubSpecification,
-          ::Bundler::RemoteSpecification
-        ),
+        ::Bundler::StubSpecification,
         ::Gem::Specification
       )
     end
@@ -116,7 +115,9 @@ module Tapioca
       sig { returns(T::Array[Pathname]) }
       def files
         if default_gem?
-          @spec.files.map do |file|
+          # `Bundler::RemoteSpecification` delegates missing methods to
+          # `Gem::Specification`, so `files` actually always exists on spec.
+          T.unsafe(@spec).files.map do |file|
             ruby_lib_dir.join(file)
           end
         else
@@ -145,6 +146,11 @@ module Tapioca
         end
       end
 
+      sig { void }
+      def parse_yard_docs
+        files.each { |path| YARD.parse(path.to_s, [], Logger::Severity::FATAL) }
+      end
+
       private
 
       sig { returns(T::Boolean) }

data/lib/tapioca/generators/base.rb

@@ -0,0 +1,61 @@
+# typed: strict
+# frozen_string_literal: true
+
+# TODO: Remove me when logging logic has been abstracted.
+require "thor"
+
+module Tapioca
+  module Generators
+    class Base
+      extend T::Sig
+      extend T::Helpers
+
+      class FileWriter < Thor
+        include Thor::Actions
+      end
+
+      # TODO: Remove me when logging logic has been abstracted
+      include Thor::Base
+
+      abstract!
+
+      sig { params(default_command: String, file_writer: Thor::Actions).void }
+      def initialize(default_command:, file_writer: FileWriter.new)
+        @file_writer = file_writer
+        @default_command = default_command
+      end
+
+      sig { abstract.void }
+      def generate; end
+
+      private
+
+      # TODO: Remove me when logging logic has been abstracted
+      sig { params(message: String, color: T.any(Symbol, T::Array[Symbol])).void }
+      def say_error(message = "", *color)
+        force_new_line = (message.to_s !~ /( |\t)\Z/)
+        # NOTE: This is a hack. We're no longer subclassing from Thor::Shell::Color
+        # so we no longer have access to the prepare_message call.
+        # We should update this to remove this.
+        buffer = shell.send(:prepare_message, *T.unsafe([message, *T.unsafe(color)]))
+        buffer << "\n" if force_new_line && !message.to_s.end_with?("\n")
+
+        $stderr.print(buffer)
+        $stderr.flush
+      end
+
+      sig do
+        params(
+          path: T.any(String, Pathname),
+          content: String,
+          force: T::Boolean,
+          skip: T::Boolean,
+          verbose: T::Boolean
+        ).void
+      end
+      def create_file(path, content, force: true, skip: false, verbose: true)
+        @file_writer.create_file(path, force: force, skip: skip, verbose: verbose) { content }
+      end
+    end
+  end
+end

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