spoom 1.2.0 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 323ebe199d0efed57d5e92af12eb377c3c5af35e468c83db851b27f86b44117b
-  data.tar.gz: c0fb24e2af1af3c0e460bb7c06ba9f3cff9cda471ec829ba00742b40dd67ab84
+  metadata.gz: 5154e37a81129c70e93925cc2a545a0d7861fd645a3ec2422e6549efc0cb76b5
+  data.tar.gz: 30c9ecdc3599a37309180fea890a7888d53b430c8701e0970f503bf5731979f9
 SHA512:
-  metadata.gz: faa5f86d378dd4cf56aa6e680cdee5717c59069b464b823bebfc63e7c8a7a40aeb7a75d86ec4dd0c69e025c4ad397eff740fdfa2ac134f49868736197836790a
-  data.tar.gz: 67f7d4bc72282ff4bea575e85c2eed80f7195f94d3b518e3a84af57085bed90c757aedab5cfe33fb6d14dc96b62f21c6e8aa8cb56b79d4e9b148318a7c713e98
+  metadata.gz: a3246a42fa965e3ef75d0178ffe958a8cc5723812ecb86799b5e2e406d5da7487ffd738696ccb3f6d76ae140de281dab73dba3ec3d8af9fdef696820654ed869
+  data.tar.gz: ba4c8ab2d87ff4451f420e2d062c7cebdd19202bc91226fd131ff9ab9f838e7494fa43560ffa317fc0565d023ecceef184c02f762e215ba6451d3ec164e3c75a

data/Gemfile

@@ -7,7 +7,6 @@ gemspec
 
 group :development do
   gem "debug"
-  gem "ruby-lsp"
   gem "rubocop-shopify", require: false
   gem "rubocop-sorbet", require: false
   gem "tapioca", require: false

data/lib/spoom/cli/bump.rb

@@ -54,6 +54,7 @@ module Spoom
         dry = options[:dry]
         only = options[:only]
         cmd = options[:suggest_bump_command]
+        directory = File.expand_path(directory)
         exec_path = File.expand_path(self.exec_path)
 
         unless Sorbet::Sigils.valid_strictness?(from)
@@ -73,11 +74,9 @@ module Spoom
 
         say("Checking files...")
 
-        directory = File.expand_path(directory)
-        files_to_bump = Sorbet::Sigils.files_with_sigil_strictness(directory, from)
-
-        files_from_config = context.srb_files.map { |file| File.expand_path(file) }
-        files_to_bump.select! { |file| files_from_config.include?(file) }
+        files_to_bump = context.srb_files_with_strictness(from, include_rbis: false)
+          .map { |file| File.expand_path(file, context.absolute_path) }
+          .select { |file| file.start_with?(directory) }
 
         if only
           list = File.read(only).lines.map { |file| File.expand_path(file.strip) }

data/lib/spoom/cli.rb

@@ -39,23 +39,19 @@ module Spoom
 
       desc "files", "List all the files typechecked by Sorbet"
       option :tree, type: :boolean, default: true, desc: "Display list as an indented tree"
-      option :rbi, type: :boolean, default: true, desc: "Show RBI files"
+      option :rbi, type: :boolean, default: false, desc: "Show RBI files"
       def files
         context = context_requiring_sorbet!
-        files = context.srb_files
-
-        unless options[:rbi]
-          files = files.reject { |file| file.end_with?(".rbi") }
-        end
 
+        files = context.srb_files(include_rbis: options[:rbi])
         if files.empty?
           say_error("No file matching `#{Sorbet::CONFIG_PATH}`")
           exit(1)
         end
 
         if options[:tree]
-          tree = FileTree.new(files, strip_prefix: exec_path)
-          tree.print(colors: options[:color], indent_level: 0)
+          tree = FileTree.new(files)
+          tree.print_with_strictnesses(context, colors: options[:color])
         else
           puts files
         end

data/lib/spoom/context/bundle.rb

@@ -10,12 +10,18 @@ module Spoom
 
       requires_ancestor { Context }
 
-      # Read the `contents` of the Gemfile in this context directory
+      # Read the contents of the Gemfile in this context directory
       sig { returns(T.nilable(String)) }
       def read_gemfile
         read("Gemfile")
       end
 
+      # Read the contents of the Gemfile.lock in this context directory
+      sig { returns(T.nilable(String)) }
+      def read_gemfile_lock
+        read("Gemfile.lock")
+      end
+
       # Set the `contents` of the Gemfile in this context directory
       sig { params(contents: String, append: T::Boolean).void }
       def write_gemfile!(contents, append: false)
@@ -41,17 +47,20 @@ module Spoom
         bundle("exec #{command}", version: version, capture_err: capture_err)
       end
 
+      sig { returns(T::Hash[String, Bundler::LazySpecification]) }
+      def gemfile_lock_specs
+        return {} unless file?("Gemfile.lock")
+
+        parser = Bundler::LockfileParser.new(read_gemfile_lock)
+        parser.specs.map { |spec| [spec.name, spec] }.to_h
+      end
+
       # Get `gem` version from the `Gemfile.lock` content
       #
       # Returns `nil` if `gem` cannot be found in the Gemfile.
       sig { params(gem: String).returns(T.nilable(String)) }
       def gem_version_from_gemfile_lock(gem)
-        return nil unless file?("Gemfile.lock")
-
-        content = read("Gemfile.lock").match(/^    #{gem} \(.*(\d+\.\d+\.\d+).*\)/)
-        return nil unless content
-
-        content[1]
+        gemfile_lock_specs[gem]&.version&.to_s
       end
     end
   end

data/lib/spoom/context/file_system.rb

@@ -43,6 +43,23 @@ module Spoom
         glob("*")
       end
 
+      sig do
+        params(
+          allow_extensions: T::Array[String],
+          allow_mime_types: T::Array[String],
+          exclude_patterns: T::Array[String],
+        ).returns(T::Array[String])
+      end
+      def collect_files(allow_extensions: [], allow_mime_types: [], exclude_patterns: [])
+        collector = FileCollector.new(
+          allow_extensions: allow_extensions,
+          allow_mime_types: allow_mime_types,
+          exclude_patterns: exclude_patterns,
+        )
+        collector.visit_path(absolute_path)
+        collector.files.map { |file| file.delete_prefix("#{absolute_path}/") }
+      end
+
       # Does `relative_path` point to an existing file in this context directory?
       sig { params(relative_path: String).returns(T::Boolean) }
       def file?(relative_path)

data/lib/spoom/context/git.rb

@@ -63,8 +63,18 @@ module Spoom
         git("checkout #{ref}")
       end
 
+      # Run `git checkout -b <branch-name> <ref>` in this context directory
+      sig { params(branch_name: String, ref: T.nilable(String)).returns(ExecResult) }
+      def git_checkout_new_branch!(branch_name, ref: nil)
+        if ref
+          git("checkout -b #{branch_name} #{ref}")
+        else
+          git("checkout -b #{branch_name}")
+        end
+      end
+
       # Run `git add . && git commit` in this context directory
-      sig { params(message: String, time: Time, allow_empty: T::Boolean).void }
+      sig { params(message: String, time: Time, allow_empty: T::Boolean).returns(ExecResult) }
       def git_commit!(message: "message", time: Time.now.utc, allow_empty: false)
         git("add --all")
 
@@ -106,6 +116,12 @@ module Spoom
         git("log #{arg.join(" ")}")
       end
 
+      # Run `git push <remote> <ref>` in this context directory
+      sig { params(remote: String, ref: String, force: T::Boolean).returns(ExecResult) }
+      def git_push!(remote, ref, force: false)
+        git("push #{force ? "-f" : ""} #{remote} #{ref}")
+      end
+
       sig { params(arg: String).returns(ExecResult) }
       def git_show(*arg)
         git("show #{arg.join(" ")}")

data/lib/spoom/context/sorbet.rb

@@ -61,14 +61,49 @@ module Spoom
       end
 
       # List all files typechecked by Sorbet from its `config`
-      sig { params(with_config: T.nilable(Spoom::Sorbet::Config)).returns(T::Array[String]) }
-      def srb_files(with_config: nil)
+      sig { params(with_config: T.nilable(Spoom::Sorbet::Config), include_rbis: T::Boolean).returns(T::Array[String]) }
+      def srb_files(with_config: nil, include_rbis: true)
         config = with_config || sorbet_config
-        regs = config.ignore.map { |string| Regexp.new(Regexp.escape(string)) }
-        exts = config.allowed_extensions.empty? ? [".rb", ".rbi"] : config.allowed_extensions
-        glob("**/*{#{exts.join(",")}}").reject do |f|
-          regs.any? { |re| re.match?(f) }
-        end.sort
+
+        allowed_extensions = config.allowed_extensions
+        allowed_extensions = Spoom::Sorbet::Config::DEFAULT_ALLOWED_EXTENSIONS if allowed_extensions.empty?
+        allowed_extensions -= [".rbi"] unless include_rbis
+
+        excluded_patterns = config.ignore.map do |string|
+          # We need to simulate the behavior of Sorbet's `--ignore` flag.
+          #
+          # From Sorbet docs on `--ignore`:
+          # > Ignores input files that contain the given string in their paths (relative to the input path passed to
+          # > Sorbet). Strings beginning with / match against the prefix of these relative paths; others are substring
+          # > matchs. Matches must be against whole folder and file names, so `foo` matches `/foo/bar.rb` and
+          # > `/bar/foo/baz.rb` but not `/foo.rb` or `/foo2/bar.rb`.
+          string = if string.start_with?("/")
+            # Strings beginning with / match against the prefix of these relative paths
+            File.join(absolute_path, string)
+          else
+            # Others are substring matchs
+            File.join(absolute_path, "**", string)
+          end
+          # Matches must be against whole folder and file names
+          "#{string.delete_suffix("/")}{,/**}"
+        end
+
+        collector = FileCollector.new(allow_extensions: allowed_extensions, exclude_patterns: excluded_patterns)
+        collector.visit_paths(config.paths.map { |path| absolute_path_to(path) })
+        collector.files.map { |file| file.delete_prefix("#{absolute_path}/") }.sort
+      end
+
+      # List all files typechecked by Sorbet from its `config` that matches `strictness`
+      sig do
+        params(
+          strictness: String,
+          with_config: T.nilable(Spoom::Sorbet::Config),
+          include_rbis: T::Boolean,
+        ).returns(T::Array[String])
+      end
+      def srb_files_with_strictness(strictness, with_config: nil, include_rbis: true)
+        srb_files(with_config: with_config, include_rbis: include_rbis)
+          .select { |file| read_file_strictness(file) == strictness }
       end
 
       sig { params(arg: String, sorbet_bin: T.nilable(String), capture_err: T::Boolean).returns(T.nilable(String)) }

data/lib/spoom/coverage/d3/circle_map.rb

@@ -148,48 +148,34 @@ module Spoom
         class Sigils < CircleMap
           extend T::Sig
 
-          sig { params(id: String, sigils_tree: FileTree).void }
-          def initialize(id, sigils_tree)
-            @scores = T.let({}, T::Hash[FileTree::Node, Float])
-            @strictnesses = T.let({}, T::Hash[FileTree::Node, T.nilable(String)])
-            @sigils_tree = sigils_tree
-            super(id, sigils_tree.roots.map { |r| tree_node_to_json(r) })
+          sig do
+            params(
+              id: String,
+              file_tree: FileTree,
+              nodes_strictnesses: T::Hash[FileTree::Node, T.nilable(String)],
+              nodes_scores: T::Hash[FileTree::Node, Float],
+            ).void
+          end
+          def initialize(id, file_tree, nodes_strictnesses, nodes_scores)
+            @nodes_strictnesses = nodes_strictnesses
+            @nodes_scores = nodes_scores
+            super(id, file_tree.roots.map { |r| tree_node_to_json(r) })
           end
 
           sig { params(node: FileTree::Node).returns(T::Hash[Symbol, T.untyped]) }
           def tree_node_to_json(node)
             if node.children.empty?
-              return { name: node.name, strictness: tree_node_strictness(node) }
-            end
-
-            {
-              name: node.name,
-              children: node.children.values.map { |n| tree_node_to_json(n) },
-              score: tree_node_score(node),
-            }
-          end
-
-          sig { params(node: FileTree::Node).returns(T.nilable(String)) }
-          def tree_node_strictness(node)
-            prefix = @sigils_tree.strip_prefix
-            path = node.path
-            path = "#{prefix}/#{path}" if prefix
-            @strictnesses[node] ||= Spoom::Sorbet::Sigils.file_strictness(path)
-          end
-
-          sig { params(node: FileTree::Node).returns(Float) }
-          def tree_node_score(node)
-            unless @scores.key?(node)
-              if node.name =~ /\.rbi?$/
-                case tree_node_strictness(node)
-                when "true", "strict", "strong"
-                  @scores[node] = 1.0
-                end
-              elsif !node.children.empty?
-                @scores[node] = node.children.values.sum { |n| tree_node_score(n) } / node.children.size.to_f
-              end
+              {
+                name: node.name,
+                strictness: @nodes_strictnesses.fetch(node, "false"),
+              }
+            else
+              {
+                name: node.name,
+                children: node.children.values.map { |n| tree_node_to_json(n) },
+                score: @nodes_scores.fetch(node, 0.0),
+              }
             end
-            @scores[node] || 0.0
           end
         end
       end

data/lib/spoom/coverage/report.rb

@@ -153,9 +153,24 @@ module Spoom
       class Map < Card
         extend T::Sig
 
-        sig { params(sigils_tree: FileTree, title: String).void }
-        def initialize(sigils_tree:, title: "Strictness Map")
-          super(title: title, body: D3::CircleMap::Sigils.new("map_sigils", sigils_tree).html)
+        sig do
+          params(
+            file_tree: FileTree,
+            nodes_strictnesses: T::Hash[FileTree::Node, T.nilable(String)],
+            nodes_strictness_scores: T::Hash[FileTree::Node, Float],
+            title: String,
+          ).void
+        end
+        def initialize(file_tree:, nodes_strictnesses:, nodes_strictness_scores:, title: "Strictness Map")
+          super(
+            title: title,
+            body: D3::CircleMap::Sigils.new(
+              "map_sigils",
+              file_tree,
+              nodes_strictnesses,
+              nodes_strictness_scores,
+            ).html
+          )
         end
       end
 
@@ -246,27 +261,14 @@ module Spoom
     class Report < Page
       extend T::Sig
 
-      sig { returns(String) }
-      attr_reader :project_name
-
-      sig { returns(T.nilable(String)) }
-      attr_reader :sorbet_intro_commit
-
-      sig { returns(T.nilable(Time)) }
-      attr_reader :sorbet_intro_date
-
-      sig { returns(T::Array[Snapshot]) }
-      attr_reader :snapshots
-
-      sig { returns(FileTree) }
-      attr_reader :sigils_tree
-
       sig do
         params(
           project_name: String,
           palette: D3::ColorPalette,
           snapshots: T::Array[Snapshot],
-          sigils_tree: FileTree,
+          file_tree: FileTree,
+          nodes_strictnesses: T::Hash[FileTree::Node, T.nilable(String)],
+          nodes_strictness_scores: T::Hash[FileTree::Node, Float],
           sorbet_intro_commit: T.nilable(String),
           sorbet_intro_date: T.nilable(Time),
         ).void
@@ -275,24 +277,28 @@ module Spoom
         project_name:,
         palette:,
         snapshots:,
-        sigils_tree:,
+        file_tree:,
+        nodes_strictnesses:,
+        nodes_strictness_scores:,
         sorbet_intro_commit: nil,
         sorbet_intro_date: nil
       )
         super(title: project_name, palette: palette)
         @project_name = project_name
         @snapshots = snapshots
-        @sigils_tree = sigils_tree
+        @file_tree = file_tree
+        @nodes_strictnesses = nodes_strictnesses
+        @nodes_strictness_scores = nodes_strictness_scores
         @sorbet_intro_commit = sorbet_intro_commit
         @sorbet_intro_date = sorbet_intro_date
       end
 
       sig { override.returns(String) }
       def header_html
-        last = T.must(snapshots.last)
+        last = T.must(@snapshots.last)
         <<~ERB
           <h1 class="display-3">
-            #{project_name}
+            #{@project_name}
             <span class="badge badge-pill badge-dark" style="font-size: 20%;">#{last.commit_sha}</span>
           </h1>
         ERB
@@ -300,17 +306,24 @@ module Spoom
 
       sig { override.returns(T::Array[Cards::Card]) }
       def cards
-        last = T.must(snapshots.last)
+        last = T.must(@snapshots.last)
         cards = []
         cards << Cards::Snapshot.new(snapshot: last)
-        cards << Cards::Map.new(sigils_tree: sigils_tree)
-        cards << Cards::Timeline::Sigils.new(snapshots: snapshots)
-        cards << Cards::Timeline::Calls.new(snapshots: snapshots)
-        cards << Cards::Timeline::Sigs.new(snapshots: snapshots)
-        cards << Cards::Timeline::RBIs.new(snapshots: snapshots)
-        cards << Cards::Timeline::Versions.new(snapshots: snapshots)
-        cards << Cards::Timeline::Runtimes.new(snapshots: snapshots)
-        cards << Cards::SorbetIntro.new(sorbet_intro_commit: sorbet_intro_commit, sorbet_intro_date: sorbet_intro_date)
+        cards << Cards::Map.new(
+          file_tree: @file_tree,
+          nodes_strictnesses: @nodes_strictnesses,
+          nodes_strictness_scores: @nodes_strictness_scores,
+        )
+        cards << Cards::Timeline::Sigils.new(snapshots: @snapshots)
+        cards << Cards::Timeline::Calls.new(snapshots: @snapshots)
+        cards << Cards::Timeline::Sigs.new(snapshots: @snapshots)
+        cards << Cards::Timeline::RBIs.new(snapshots: @snapshots)
+        cards << Cards::Timeline::Versions.new(snapshots: @snapshots)
+        cards << Cards::Timeline::Runtimes.new(snapshots: @snapshots)
+        cards << Cards::SorbetIntro.new(
+          sorbet_intro_commit: @sorbet_intro_commit,
+          sorbet_intro_date: @sorbet_intro_date,
+        )
         cards
       end
     end

data/lib/spoom/coverage.rb

@@ -83,29 +83,29 @@ module Spoom
       def report(context, snapshots, palette:)
         intro_commit = context.sorbet_intro_commit
 
+        file_tree = file_tree(context)
+        v = FileTree::CollectScores.new(context)
+        v.visit_tree(file_tree)
+
         Report.new(
           project_name: File.basename(context.absolute_path),
           palette: palette,
           snapshots: snapshots,
-          sigils_tree: sigils_tree(context),
+          file_tree: file_tree,
+          nodes_strictnesses: v.strictnesses,
+          nodes_strictness_scores: v.scores,
           sorbet_intro_commit: intro_commit&.sha,
           sorbet_intro_date: intro_commit&.time,
         )
       end
 
       sig { params(context: Context).returns(FileTree) }
-      def sigils_tree(context)
-        files = context.srb_files
-
-        extensions = context.sorbet_config.allowed_extensions
-        extensions = [".rb"] if extensions.empty?
-        extensions -= [".rbi"]
-
-        pattern = /\.(#{Regexp.union(extensions.map { |ext| ext[1..-1] })})$/
-        files.select! { |file| file =~ pattern }
-        files.reject! { |file| file =~ %r{/test/} }
+      def file_tree(context)
+        config = context.sorbet_config
+        config.ignore += ["test"]
 
-        FileTree.new(files, strip_prefix: context.absolute_path)
+        files = context.srb_files(with_config: config, include_rbis: false)
+        FileTree.new(files)
       end
     end
   end

data/lib/spoom/deadcode/definition.rb

@@ -0,0 +1,98 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    # A definition is a class, module, method, constant, etc. being defined in the code
+    class Definition < T::Struct
+      extend T::Sig
+
+      class Kind < T::Enum
+        enums do
+          AttrReader = new("attr_reader")
+          AttrWriter = new("attr_writer")
+          Class = new("class")
+          Constant = new("constant")
+          Method = new("method")
+          Module = new("module")
+        end
+      end
+
+      class Status < T::Enum
+        enums do
+          # A definition is marked as `ALIVE` if it has at least one reference with the same name
+          ALIVE = new
+          # A definition is marked as `DEAD` if it has no reference with the same name
+          DEAD = new
+          # A definition can be marked as `IGNORED` if it is not relevant for the analysis
+          IGNORED = new
+        end
+      end
+
+      const :kind, Kind
+      const :name, String
+      const :full_name, String
+      const :location, Location
+      const :status, Status, default: Status::DEAD
+
+      # Kind
+
+      sig { returns(T::Boolean) }
+      def attr_reader?
+        kind == Kind::AttrReader
+      end
+
+      sig { returns(T::Boolean) }
+      def attr_writer?
+        kind == Kind::AttrWriter
+      end
+
+      sig { returns(T::Boolean) }
+      def class?
+        kind == Kind::Class
+      end
+
+      sig { returns(T::Boolean) }
+      def constant?
+        kind == Kind::Constant
+      end
+
+      sig { returns(T::Boolean) }
+      def method?
+        kind == Kind::Method
+      end
+
+      sig { returns(T::Boolean) }
+      def module?
+        kind == Kind::Module
+      end
+
+      # Status
+
+      sig { returns(T::Boolean) }
+      def alive?
+        status == Status::ALIVE
+      end
+
+      sig { void }
+      def alive!
+        @status = Status::ALIVE
+      end
+
+      sig { returns(T::Boolean) }
+      def dead?
+        status == Status::DEAD
+      end
+
+      sig { returns(T::Boolean) }
+      def ignored?
+        status == Status::IGNORED
+      end
+
+      sig { void }
+      def ignored!
+        @status = Status::IGNORED
+      end
+    end
+  end
+end

data/lib/spoom/deadcode/erb.rb

@@ -0,0 +1,103 @@
+# typed: true
+# frozen_string_literal: true
+
+# Copied from https://github.com/rails/rails/blob/main/actionview/lib/action_view/template/handlers/erb/erubi.rb.
+#
+# Copyright (c) David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+module Spoom
+  module Deadcode
+    # Custom engine to handle ERB templates as used by Rails
+    class ERB < ::Erubi::Engine
+      extend T::Sig
+
+      sig { params(input: T.untyped, properties: T.untyped).void }
+      def initialize(input, properties = {})
+        @newline_pending = 0
+
+        properties = Hash[properties]
+        properties[:bufvar]     ||= "@output_buffer"
+        properties[:preamble]   ||= ""
+        properties[:postamble]  ||= "#{properties[:bufvar]}.to_s"
+        properties[:escapefunc] = ""
+
+        super
+      end
+
+      private
+
+      sig { params(text: T.untyped).void }
+      def add_text(text)
+        return if text.empty?
+
+        if text == "\n"
+          @newline_pending += 1
+        else
+          src << bufvar << ".safe_append='"
+          src << "\n" * @newline_pending if @newline_pending > 0
+          src << text.gsub(/['\\]/, '\\\\\&')
+          src << "'.freeze;"
+
+          @newline_pending = 0
+        end
+      end
+
+      BLOCK_EXPR = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
+
+      sig { params(indicator: T.untyped, code: T.untyped).void }
+      def add_expression(indicator, code)
+        flush_newline_if_pending(src)
+
+        src << bufvar << if (indicator == "==") || @escape
+          ".safe_expr_append="
+        else
+          ".append="
+        end
+
+        if BLOCK_EXPR.match?(code)
+          src << " " << code
+        else
+          src << "(" << code << ");"
+        end
+      end
+
+      sig { params(code: T.untyped).void }
+      def add_code(code)
+        flush_newline_if_pending(src)
+        super
+      end
+
+      sig { params(_: T.untyped).void }
+      def add_postamble(_)
+        flush_newline_if_pending(src)
+        super
+      end
+
+      sig { params(src: T.untyped).void }
+      def flush_newline_if_pending(src)
+        if @newline_pending > 0
+          src << bufvar << ".safe_append='#{"\n" * @newline_pending}'.freeze;"
+          @newline_pending = 0
+        end
+      end
+    end
+  end
+end