kettle-jem 7.1.1 → 7.1.3

data/lib/kettle/jem.rb

@@ -38,7 +38,7 @@ module Kettle
     CONTENT_RECIPE_TRANSPORT_VERSION = Ast::Merge::STRUCTURED_EDIT_TRANSPORT_VERSION
     TEMPLATE_SOURCE_APPLICATION_FINGERPRINT_VERSION = 1
     APPRAISALS_TEMPLATE_POLICY_FINGERPRINT_VERSION = 2
-    GEMSPEC_TEMPLATE_POLICY_FINGERPRINT_VERSION = 1
+    GEMSPEC_TEMPLATE_POLICY_FINGERPRINT_VERSION = 2
     SPEC_HELPER_TEMPLATE_POLICY_FINGERPRINT_VERSION = 1
     VERSION_NAMESPACE_TEMPLATE_POLICY_FINGERPRINT_VERSION = 2
     KETTLE_CONFIG_PATH = ".structuredmerge/kettle-jem.yml"
@@ -50,6 +50,9 @@ module Kettle
     GEMSPEC_DEPENDENCY_MINIMUM_REQUIREMENTS = {
       "rspec-stubbed_env" => ">= 1.0.6"
     }.freeze
+    DEFAULT_GEMSPEC_METADATA_VALUES = {
+      "allowed_push_host" => "TODO: Set to your gem server 'https://example.com'"
+    }.freeze
     OBSOLETE_GITHUB_WORKFLOWS = %w[
       ancient.yml
       legacy.yml
@@ -439,6 +442,7 @@ module Kettle
       KJ|MAIN_GEMFILE_NOMONO_BOOTSTRAP
       KJ|MIN_DIVERGENCE_THRESHOLD
       KJ|MIN_RUBY
+      KJ|KETTLE_CHANGELOG_GEMFILE_DEPENDENCY
       KJ|OPENCOLLECTIVE_ORG
       KJ|README:COPYRIGHT_NOTICE
       KJ|README:CORPORATE_SPONSORS
@@ -848,6 +852,9 @@ module Kettle
             label = owner.label.to_s
             label if patterns.fetch(:ref_prefixes).any? { |pattern| pattern.match?(label) }
           end
+          ref_labels.each do |label|
+            processed = remove_markdown_inline_references(processed, label)
+          end
           processed = delete_markdown_link_definitions(processed, ref_labels)
         end
 
@@ -1399,6 +1406,7 @@ module Kettle
       "🖇osc-sponsors-bottom-img"
     ].freeze
     README_INTEGRATIONS = %w[codecov coveralls qlty codeql skywalking-eyes].freeze
+    README_STAR_HISTORY_MIN_STARS = 150
     README_DISCOVERED_INTEGRATIONS = (README_INTEGRATIONS - [SKYWALKING_EYES_INTEGRATION]).freeze
     COVERAGE_INTEGRATIONS = %w[codecov coveralls qlty].freeze
     MANAGED_INTEGRATIONS = (COVERAGE_INTEGRATIONS + [SKYWALKING_EYES_INTEGRATION]).freeze
@@ -4790,6 +4798,10 @@ module Kettle
     end
 
     def post_apply_steps(project_root, report)
+      selection = report.fetch(:template_selection, {})
+      scoped_template = Array(selection[:only]).any?
+      return [kettle_jem_state_sync_step(project_root, report)].compact if scoped_template
+
       [
         *[template_version_gem_bootstrap_step(project_root, report)].flatten,
         executable_version_entrypoint_sync_step(project_root, report),
@@ -5164,6 +5176,7 @@ module Kettle
         updated.insert(profile_index + 1, *entries_lines)
       end
       sync_kettle_config_gemspec_strategy_lines!(updated, gemspec_path)
+      sync_kettle_config_rakefile_strategy_lines!(updated)
       ensure_trailing_newline(updated.join("\n"))
     end
 
@@ -5194,6 +5207,33 @@ module Kettle
       end
     end
 
+    def sync_kettle_config_rakefile_strategy_lines!(lines)
+      files_index = lines.index("files:")
+      return unless files_index
+
+      rakefile_index = ((files_index + 1)...lines.length).find do |index|
+        line = lines.fetch(index)
+        break nil if top_level_yaml_key_line?(line)
+
+        line == "  Rakefile:"
+      end
+      unless rakefile_index
+        insertion_index = kettle_config_gemspec_override_insertion_index(lines, files_index)
+        lines.insert(insertion_index, "  Rakefile:", "    strategy: accept_template")
+        return
+      end
+
+      block_end = kettle_config_file_override_block_end(lines, rakefile_index)
+      strategy_index = ((rakefile_index + 1)...block_end).find do |index|
+        lines.fetch(index).start_with?("    strategy:")
+      end
+      if strategy_index
+        lines[strategy_index] = "    strategy: accept_template"
+      else
+        lines.insert(rakefile_index + 1, "    strategy: accept_template")
+      end
+    end
+
     def remove_stale_gemspec_file_override_blocks!(lines, files_index, gemspec)
       index = files_index + 1
       while index < lines.length
@@ -5278,15 +5318,15 @@ module Kettle
       [
         {name: "appraisal2", source: %(gem "appraisal2", "~> 3.2", ">= 3.2.2"\n)},
         {name: "bundler-audit", source: %(gem "bundler-audit", "~> 0.9.3"\n)},
-        {name: "kettle-dev", source: %(gem "kettle-dev", "~> 2.5", ">= 2.5.24"\n)},
+        {name: "kettle-dev", source: %(gem "kettle-dev", "~> 3.0", ">= 3.0.0"\n)},
         {name: "kettle-drift", source: %(gem "kettle-drift", "~> 1.0", ">= 1.0.12"\n)},
-        {name: "kettle-family", source: %(gem "kettle-family", "~> 1.2", ">= 1.2.41"\n)},
-        {name: "kettle-jem", source: %(gem "kettle-jem", "~> 7.0", ">= 7.0.0"\n)},
+        {name: "kettle-family", source: %(gem "kettle-family", "~> 1.2", ">= 1.2.44"\n)},
+        {name: "kettle-jem", source: %(gem "kettle-jem", "~> 7.1", ">= 7.1.1"\n)},
         {name: "kettle-test", source: %(gem "kettle-test", "~> 2.0", ">= 2.0.19"\n)},
         {name: "rake", source: %(gem "rake", "~> 13.0"\n)},
         {name: "rspec", source: %(gem "rspec", "~> 3.0"\n)},
         {name: "stone_checksums", source: %(gem "stone_checksums", "~> 1.0", ">= 1.0.8"\n)},
-        {name: "turbo_tests2", source: %(gem "turbo_tests2", "~> 3.2", ">= 3.2.4"\n)}
+        {name: "turbo_tests2", source: %(gem "turbo_tests2", "~> 3.2", ">= 3.2.5"\n)}
       ].freeze
     end
 
@@ -6988,7 +7028,13 @@ module Kettle
           destination_content: original
         )
         return with_readme_timing("readme.append_used_link_definitions") do
-          append_used_markdown_link_definitions(processed, resolved)
+          appended = append_used_markdown_link_definitions(processed, resolved)
+          postprocess_readme_content(
+            appended,
+            facts,
+            project_root: project_root,
+            destination_content: original
+          )
         end
       end
       if strategy.empty? || strategy == "merge"
@@ -7164,7 +7210,9 @@ module Kettle
 
     def delete_yaml_top_level_mapping_entries(content, parent_key:, child_keys:)
       document = Psych.parse(content.to_s)
-      root = document&.root
+      # Psych returns `false` for a comment-only document under some versions.
+      # Such content has no mapping to prune and must pass through unchanged.
+      root = document.root if document.respond_to?(:root)
       return content unless root.is_a?(Psych::Nodes::Mapping)
 
       parent = yaml_mapping_value(root, parent_key)
@@ -7174,7 +7222,7 @@ module Kettle
       ranges = parent.children.each_slice(2).filter_map do |key_node, value_node|
         next unless child_key_set.include?(key_node.value.to_s)
 
-        key_node.start_line..value_node.end_line
+        key_node.start_line...value_node.end_line
       end
       return content if ranges.empty?
 
@@ -7232,6 +7280,13 @@ module Kettle
           engines: facts.dig(:rubygems, :engines)
         )
       end
+      processed = with_readme_timing("postprocess.compatibility_summary") do
+        normalize_readme_compatibility_summary(
+          processed,
+          facts.dig(:rubygems, :engines),
+          minimum_ruby_token(facts.dig(:rubygems, :min_ruby))
+        )
+      end
       processed = with_readme_timing("postprocess.project_heading") { normalize_readme_project_heading(processed, facts) }
       processed = with_readme_timing("postprocess.synopsis_heading") { normalize_readme_synopsis_heading(processed, facts) }
       processed = with_readme_timing("postprocess.conditional_blocks") { apply_readme_conditional_blocks(processed, facts) }
@@ -7334,7 +7389,17 @@ module Kettle
     def apply_readme_conditional_blocks(content, facts)
       open_collective_enabled = !facts.dig(:funding, :open_collective_disabled)
       processed = apply_markdown_conditional_block(content, "OPEN_COLLECTIVE", keep: open_collective_enabled)
-      apply_markdown_conditional_block(processed, "NO_OPEN_COLLECTIVE", keep: !open_collective_enabled)
+      processed = apply_markdown_conditional_block(processed, "NO_OPEN_COLLECTIVE", keep: !open_collective_enabled)
+      star_history_enabled = facts.dig(:repository, :star_history, :enabled) == true
+      return processed if star_history_enabled
+
+      delete_markdown_with_ast_crispr(
+        processed,
+        Ast::Crispr::Markdown::Markly::Selectors.html_details(
+          summary_text: "⭐️ Star History",
+          limit: {at_least: 0}
+        )
+      )
     end
 
     def apply_readme_badge_policy(content, facts)
@@ -7364,9 +7429,31 @@ module Kettle
           )
         end
       end
+      Array(facts.dig(:readme_style, :disabled_integrations)).each do |integration|
+        patterns = README_INTEGRATION_BADGE_PATTERNS.fetch(integration.to_s, [])
+        labels = README_INTEGRATION_LINK_LABELS.fetch(integration.to_s, [])
+        processed = patterns.reduce(processed) { |content, pattern| content.gsub(pattern, "") }
+        processed = ReadmePostProcessor.delete_markdown_link_definitions(processed, labels)
+      end
       processed
     end
 
+    def normalize_readme_compatibility_summary(content, engines, min_ruby = "")
+      enabled = Array(engines).map { |engine| engine.to_s.strip.downcase }.reject(&:empty?).uniq
+      return content if enabled.empty?
+
+      runtime_floor = min_ruby.to_s.strip
+      runtime_floor = " #{runtime_floor}+" unless runtime_floor.empty?
+      runtime_engines = ["MRI Ruby#{runtime_floor}"]
+      runtime_engines << "JRuby" if enabled.include?("jruby")
+      runtime_engines << "TruffleRuby" if enabled.include?("truffleruby") || enabled.include?("truby")
+      description = runtime_engines.one? ? runtime_engines.first : runtime_engines[0...-1].join(", ") + ", and #{runtime_engines.last}"
+      content.to_s.sub(
+        /Compatible with MRI Ruby [^\n]+\./,
+        "Compatible with #{description}."
+      )
+    end
+
     def remove_readme_badge_and_refs(content, badge_source, link_labels)
       ensure_runtime_dependencies!
       processed = content.to_s.gsub(badge_source, "").lines.map(&:rstrip).join("\n")
@@ -9646,7 +9733,7 @@ module Kettle
         replacement = if record.fetch(:source).lines.one?
           "%w[#{kept.join(" ")}]"
         else
-          ruby_multiline_word_array_source(kept, indent: record.fetch(:start_column))
+          ruby_multiline_word_array_source(kept, indent: record.fetch(:line_indent))
         end
         {start_offset: record.fetch(:start_offset), end_offset: record.fetch(:end_offset), replacement: replacement}
       end
@@ -9657,13 +9744,15 @@ module Kettle
     end
 
     def ruby_word_array_records(content)
+      lines = content.to_s.lines
       ruby_word_array_nodes(content).map do |node|
+        source_line = lines.fetch(node.location.start_line - 1)
         {
           names: ruby_word_array_names(node),
           source: node.location.slice,
           start_line: node.location.start_line,
           end_line: node.location.end_line,
-          start_column: node.location.start_column,
+          line_indent: source_line.length - source_line.lstrip.length,
           start_offset: node.location.start_offset,
           end_offset: node.location.end_offset
         }
@@ -9690,9 +9779,9 @@ module Kettle
     end
 
     def ruby_multiline_word_array_source(names, indent:)
-      prefix = " " * indent.to_i
-      element_prefix = "#{prefix}  "
-      (["#{prefix}%w["] + names.map { |name| "#{element_prefix}#{name}" } + ["#{prefix}]"]).join("\n")
+      element_prefix = " " * (indent.to_i + 2)
+      closing_prefix = " " * indent.to_i
+      (["%w["] + names.map { |name| "#{element_prefix}#{name}" } + ["#{closing_prefix}]"]).join("\n")
     end
 
     def replace_source_offsets(content, replacements)
@@ -10259,6 +10348,13 @@ module Kettle
       merged = apply_configured_gemspec_licenses(merged, facts, receiver: template_receiver)
       merged = apply_configured_gemspec_required_ruby_version(merged, facts, receiver: template_receiver)
       merged = apply_configured_gemspec_metadata(merged, facts, receiver: template_receiver)
+      merged = preserve_destination_only_gemspec_metadata(
+        merged,
+        template_content: template_content,
+        destination_content: destination_content,
+        template_receiver: template_receiver,
+        destination_receiver: destination_receiver
+      )
       merged = remove_duplicate_gemspec_assignments(merged, receiver: template_receiver, fields: %w[homepage])
       merged = remove_gemspec_self_dependency_lines(merged, package_name, receiver: template_receiver)
       merged = remove_gemspec_version_gem_dependency_when_disabled(
@@ -10527,6 +10623,36 @@ module Kettle
       content
     end
 
+    def preserve_destination_only_gemspec_metadata(
+      content,
+      template_content:,
+      destination_content:,
+      template_receiver:,
+      destination_receiver:
+    )
+      template_keys = gemspec_metadata_assignment_records(template_content, receiver: template_receiver).map do |record|
+        record.fetch(:key)
+      end
+      merged_keys = gemspec_metadata_assignment_records(content, receiver: template_receiver).map do |record|
+        record.fetch(:key)
+      end
+      destination_records = gemspec_metadata_assignment_records(destination_content, receiver: destination_receiver).select do |record|
+        !template_keys.include?(record.fetch(:key)) &&
+          !merged_keys.include?(record.fetch(:key)) &&
+          !default_gemspec_metadata_assignment?(record)
+      end
+      return content if destination_records.empty?
+
+      insertion = destination_records.map do |record|
+        normalize_gemspec_receiver(record.fetch(:source).rstrip, from: destination_receiver, to: template_receiver)
+      end.join("\n") + "\n"
+      anchor = gemspec_metadata_assignment_records(content, receiver: template_receiver).last
+      anchor ||= gemspec_assignment_records(content, receiver: template_receiver).find { |record| record.fetch(:field) == "homepage" }
+      return content unless anchor
+
+      insert_lines_after(content, anchor.fetch(:end_line), insertion)
+    end
+
     def gemspec_metadata_assignment_records(content, receiver:)
       lines = content.to_s.lines
       ruby_call_records(content, :[]=).filter_map do |call|
@@ -10540,6 +10666,7 @@ module Kettle
         end_line = ruby_node_source_end_line(call)
         {
           key: key,
+          value: ruby_static_string_value(args[1]),
           start_line: start_line,
           end_line: end_line,
           source: lines[(start_line - 1)..(end_line - 1)].to_a.join
@@ -10549,6 +10676,10 @@ module Kettle
       []
     end
 
+    def default_gemspec_metadata_assignment?(record)
+      DEFAULT_GEMSPEC_METADATA_VALUES[record.fetch(:key)] == record[:value]
+    end
+
     def remove_gemspec_version_gem_dependency_when_disabled(content, facts, receiver:, template_declares_version_gem: false)
       return content if version_gem_enabled?(facts)
       return content if template_declares_version_gem && !version_gem_explicitly_disabled?(facts) && version_gem_runtime_compatible?(facts)
@@ -12576,7 +12707,9 @@ module Kettle
     def add_monorepo_subgem_file_overrides(content, gemspec_path, profile = MONOREPO_SUBGEM_TEMPLATE_PROFILE)
       override_lines = [
         "  README.md:",
-        "    strategy: merge"
+        "    strategy: merge",
+        "  Rakefile:",
+        "    strategy: accept_template"
       ]
       gemspec = gemspec_path.to_s.strip
       unless gemspec.empty?
@@ -13768,6 +13901,9 @@ module Kettle
         "KJ|MIN_RUBY" => minimum_ruby_token(rubygems[:min_ruby]),
         "KJ|MIN_DEV_RUBY" => facts.dig(:project_runtime, :test_min_ruby).to_s,
         "KJ|MIN_TEST_RUBY" => facts.dig(:project_runtime, :test_min_ruby).to_s,
+        "KJ|KETTLE_CHANGELOG_GEMFILE_DEPENDENCY" => kettle_changelog_gemfile_dependency_token(
+          package.fetch(:name).to_s
+        ),
         "KJ|CI:EXEC_CMD" => facts.dig(:ci, :exec_cmd).to_s,
         "KJ|GITHUB_ACTIONS:COVERAGE_UPLOAD_STEPS" => github_actions_coverage_steps(disabled_integrations: facts.dig(:integrations, :disabled))
       }.merge(
@@ -13806,6 +13942,28 @@ module Kettle
       tokens.reject { |key, value| value.empty? && !EMPTY_TEMPLATE_TOKENS.include?(key) }
     end
 
+    def kettle_changelog_gemfile_dependency_token(package_name)
+      return "" if package_name == "kettle-changelog"
+
+      <<~RUBY.chomp
+        kettle_changelog_local = ENV.fetch("KETTLE_DEV_DEV", "false").downcase
+        kettle_changelog_local = !%w[false 0 no off].include?(kettle_changelog_local)
+        if kettle_changelog_local
+          require "nomono/bundler"
+          eval_nomono_gems(
+            gems: ["kettle-changelog"],
+            prefix: "KETTLE_DEV",
+            path_env: "KETTLE_DEV_DEV",
+            root: ["src", "my", "kettle-dev"]
+          )
+        else
+          if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("4.0.0")
+            gem "kettle-changelog", "~> 1.0", ">= 1.0.0"
+          end
+        end
+      RUBY
+    end
+
     def readme_title_token(package, rubygems)
       package_name = package.fetch(:name).to_s.strip
       default_entrypoint = package_name.tr("-", "/")
@@ -14760,7 +14918,7 @@ module Kettle
     def main_gemfile_kettle_family_gem(package_name)
       return "" if package_name.to_s == "kettle-family"
 
-      %(gem "kettle-family", "~> 1.2", ">= 1.2.41"\n)
+      %(gem "kettle-family", "~> 1.2", ">= 1.2.44"\n)
     end
 
     def main_gemfile_nomono_bootstrap(package_name)
@@ -15870,8 +16028,10 @@ module Kettle
       topology = normalize_repository_topology(repository_topology)
       monorepo_subproject = topology == REPOSITORY_TOPOLOGY_MONOREPO_SUBPROJECT
       local_root = monorepo_subproject ? git_worktree_root(project_root) : nil
+      repository_root = local_root || project_root
+      git_source_url = git_remote_source_url(repository_root)
       repo_url = if monorepo_subproject
-        repository_root_url(git_remote_source_url(local_root || project_root) || source_url)
+        repository_root_url(git_source_url || source_url)
       else
         repository_root_url(source_url)
       end
@@ -15883,7 +16043,8 @@ module Kettle
         topology: topology,
         url: repo_url,
         name: repo_name,
-        slug: slug
+        slug: slug,
+        star_history: readme_star_history_facts(repository_root, git_source_url)
       )
       return facts unless monorepo_subproject
 
@@ -16030,6 +16191,54 @@ module Kettle
       nil
     end
 
+    def readme_star_history_facts(project_root, git_source_url)
+      repository_slug = github_repository_slug(git_source_url)
+      return {enabled: false, reason: "no_github_remote"} if repository_slug.to_s.empty?
+
+      stars = github_repository_star_count(project_root, repository_slug)
+      unless stars
+        return {
+          enabled: false,
+          repository: repository_slug,
+          reason: "star_count_unavailable"
+        }
+      end
+
+      {
+        enabled: stars >= README_STAR_HISTORY_MIN_STARS,
+        repository: repository_slug,
+        stars: stars,
+        minimum_stars: README_STAR_HISTORY_MIN_STARS
+      }
+    end
+
+    def github_repository_slug(url)
+      normalized = normalize_git_source_url(url)
+      match = normalized.to_s.match(%r{\Ahttps?://github\.com/([^/]+)/([^/?#]+)})
+      return unless match
+
+      repository = match[2].delete_suffix(".git")
+      return if match[1].empty? || repository.empty?
+
+      "#{match[1]}/#{repository}"
+    end
+
+    def github_repository_star_count(project_root, repository_slug)
+      stdout, _stderr, status = Open3.capture3(
+        "gh",
+        "api",
+        "repos/#{repository_slug}",
+        "--jq",
+        ".stargazers_count",
+        chdir: project_root.to_s
+      )
+      return unless status.success?
+
+      Integer(stdout.to_s.strip)
+    rescue ArgumentError, IOError, SystemCallError
+      nil
+    end
+
     def normalize_git_source_url(url)
       value = url.to_s.strip
       return if value.empty?
@@ -16040,6 +16249,11 @@ module Kettle
       end
 
       uri = URI.parse(value)
+      if uri.scheme == "ssh" && uri.host == "github.com"
+        slug = uri.path.to_s.delete_prefix("/").delete_suffix(".git")
+        return "https://github.com/#{slug}" if slug.split("/").length >= 2
+      end
+
       if %w[http https].include?(uri.scheme) && uri.host == "github.com"
         slug = uri.path.to_s.delete_prefix("/").delete_suffix(".git")
         return "https://github.com/#{slug}" if slug.split("/").length >= 2
@@ -17614,7 +17828,7 @@ module Kettle
         relative_path = path.delete_prefix("#{project_root}/")
         next unless preferred_template_source(PACKAGED_TEMPLATE_ROOT, relative_path)
 
-        {target_path: relative_path} if skip_packaged_gemfile_template?(relative_path, config)
+        {target_path: relative_path} if skip_packaged_gemfile_template?(relative_path, config, project_root: project_root)
       end
       (gemfile_cleanups + disabled_integration_config_cleanups(project_root, config)).sort_by { |cleanup| cleanup.fetch(:target_path) }
     end
@@ -17697,7 +17911,7 @@ module Kettle
       return if source_path.to_s.empty? || target_path.to_s.empty?
       return if skip_packaged_workflow_template?(target_path, config, include_patterns: include_patterns)
       return if skip_disabled_integration_template?(target_path, config)
-      return if skip_packaged_gemfile_template?(target_path, config)
+      return if skip_packaged_gemfile_template?(target_path, config, project_root: project_root, template_root_path: template_root.fetch(:path))
       return if skip_packaged_license_template?(target_path, config)
       return if skip_packaged_version_gem_entrypoint_template?(project_root, source_path, target_path, config)
       return if template_root.fetch(:kind) == "packaged" && opencollective_disabled && opencollective_disabled_file?(target_path)
@@ -17933,9 +18147,11 @@ module Kettle
       Gem::Version.new(version) < min_ruby
     end
 
-    def skip_packaged_gemfile_template?(target_path, config)
+    def skip_packaged_gemfile_template?(target_path, config, project_root: nil, template_root_path: PACKAGED_TEMPLATE_ROOT)
       return true if target_path.to_s.include?("gemfiles/modular/recording/") && !appraisal_recording_enabled?(config)
 
+      return false if packaged_gemfile_referenced_by_x_std_libs?(target_path, project_root: project_root, template_root_path: template_root_path)
+
       version = packaged_gemfile_template_ruby_floor(target_path)
       return false unless version
 
@@ -17945,6 +18161,21 @@ module Kettle
       Gem::Version.new(version) < min_ruby
     end
 
+    def packaged_gemfile_referenced_by_x_std_libs?(target_path, project_root:, template_root_path:)
+      relative_path = target_path.to_s.delete_prefix("gemfiles/modular/")
+      return false unless relative_path.start_with?("x_std_libs/")
+
+      aggregate_paths = [
+        File.join(template_root_path.to_s, "gemfiles/modular/x_std_libs.gemfile.example"),
+        File.join(project_root.to_s, "gemfiles/modular/x_std_libs.gemfile")
+      ].select { |path| File.file?(path) }
+      aggregate_paths.any? do |path|
+        gemfile_eval_paths(File.read(path)).include?(relative_path)
+      end
+    rescue
+      false
+    end
+
     def skip_disabled_integration_template?(target_path, config)
       disabled_integration_template_path?(target_path, config)
     end