kettle-dev 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5ef625cbc6016859cd2c88105ce957e3719465cee97356df1fc77a30c8504c1
-  data.tar.gz: e18d15a0d1da90c31991b4b6601b698633dad3e377145724f8fb277ec7b2a75a
+  metadata.gz: cf48cdba2c3cbe1c95eab4c61a4073f7849fda6b7dbc41ec2dedaca59b414242
+  data.tar.gz: 171598b7227ced01474c97a14a8167d3c6c64785b08daeb6996e64d1ed42973d
 SHA512:
-  metadata.gz: 227cb01388512c937d73fddf46deac2edf2b062f93a97b8e788ac0af4e21f8bd1b3a941dc4bf8eabfd5b494401e935e08a8d28d10fc1954b728e7148953e531b
-  data.tar.gz: 336fe91aab36fd2ca958967fbc3cfaaa2d6cea7dbb5b1e4d63882526b1271561920d41c016f301b93eb533cb636d252e923882859c9be58fbe4bd586b29d870d
+  metadata.gz: 224a2b34db6d14760ae6105eb67407baebb25a67d7ac1ccad37eaa01823278d3d6c68e6822430f47d986c756f232ce637df248184ec61ca7a4394df3c4ced4c8
+  data.tar.gz: f8d133803fdbcf798e05faf1749a3e03efc539d5513142bbe76da9b3954662cf043ae868b79151c0c1cb84129f15b4e3e3af7a9764e301d14134fa352ba38ff5

checksums.yaml.gz.sig

@@ -1 +1,2 @@
-!�5å����Ԇ��,@K:�v���Fr���%�������&��lv��,j_��r��Wy��yU%GU����6�knu|�b������b�g/&��5"K������DF`t<|�q����sǩ�:5^��'B`1����*˲���hV�J�ҥ,��.��*(�y���+�im(�$-�T�W-�x>o%Psw���kt)� �~F�Ȕ�h�‡,�\	��	d̎�������A�EkH���>J�S���"9�,Y̛;�̄
C�����ZN��ƍ�$hLx`�=�U������1J�;l~
T��_��FiOm���6�dSс��o�aD^�1��/���Uw�����F|�3aX�31��A��T'$���b�N#�P{�Fz���v�
+YGZ�ܧ*٫e�.ڴ��C��G�7���QMhz�G��o����7v��<^�x��g�|2��������I@ -N�9pG}��D�^��ӓU���F�nA�|3oރ���苊E�
+Z�ff�^v���hP�xvD���ޓ���HV�~60-6���h��UM��/q�o0}�dy+���k��3����񿡤�tr:��t��$�u����%`���{�`z!XBG+�$[��z��_�Y</l�3���)�X�;	�c����U=��l$��a��<O0��q��۠�U�nr�f�1y����J޸ �V� ���T񾹈7�T���=�O��

data/CHANGELOG.md

@@ -20,6 +20,13 @@ Please file a bug if you notice a violation of semantic versioning.
 
 ### Added
 
+- Prism AST-based manipulation of ruby during templating
+  - Gemfiles
+  - gemspecs
+  - .simplecov
+- Stop rescuing Exception in certain scenarios (just StandardError)
+- Refactored logging logic and documentation
+
 ### Changed
 
 ### Deprecated
@@ -30,7 +37,7 @@ Please file a bug if you notice a violation of semantic versioning.
 
 ### Security
 
-## [1.2.0] - 2025-11-25
+## [1.2.1] - 2025-11-25
 
 - TAG: [v1.2.0][1.2.0t]
 - COVERAGE: 94.38% -- 4066/4308 lines in 26 files

data/Rakefile.example

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# kettle-dev Rakefile v1.2.0 - 2025-11-25
+# kettle-dev Rakefile v1.2.1 - 2025-11-26
 # Ruby 2.3 (Safe Navigation) or higher required
 #
 # MIT License (see License.txt)

data/lib/kettle/dev/modular_gemfiles.rb

@@ -36,9 +36,9 @@ module Kettle
           modular_gemfile = "#{base}.gemfile"
           src = helpers.prefer_example(File.join(gem_checkout_root, MODULAR_GEMFILE_DIR, modular_gemfile))
           dest = File.join(project_root, MODULAR_GEMFILE_DIR, modular_gemfile)
-          existing = File.exist?(dest) ? File.read(dest) : nil
           helpers.copy_file_with_prompt(src, dest, allow_create: true, allow_replace: true) do |content|
-            existing ? helpers.merge_gemfile_dependencies(content, existing) : content
+            # Use apply_strategy for proper AST-based merging with Prism
+            helpers.apply_strategy(content, dest)
           end
         end
 
@@ -46,7 +46,6 @@ module Kettle
         modular_gemfile = "style.gemfile"
         src = helpers.prefer_example(File.join(gem_checkout_root, MODULAR_GEMFILE_DIR, modular_gemfile))
         dest = File.join(project_root, MODULAR_GEMFILE_DIR, modular_gemfile)
-        existing_style = File.exist?(dest) ? File.read(dest) : nil
         if File.basename(src).sub(/\.example\z/, "") == "style.gemfile"
           helpers.copy_file_with_prompt(src, dest, allow_create: true, allow_replace: true) do |content|
             # Adjust rubocop-lts constraint based on min_ruby
@@ -98,11 +97,13 @@ module Kettle
               token = "{RUBOCOP|RUBY|GEM}"
               content.gsub!(token, "rubocop-ruby#{rubocop_ruby_gem_version}") if content.include?(token)
             end
-            existing_style ? helpers.merge_gemfile_dependencies(content, existing_style) : content
+            # Use apply_strategy for proper AST-based merging with Prism
+            helpers.apply_strategy(content, dest)
           end
         else
           helpers.copy_file_with_prompt(src, dest, allow_create: true, allow_replace: true) do |content|
-            existing_style ? helpers.merge_gemfile_dependencies(content, existing_style) : content
+            # Use apply_strategy for proper AST-based merging with Prism
+            helpers.apply_strategy(content, dest)
           end
         end
 

data/lib/kettle/dev/{appraisals_ast_merger.rb → prism_appraisals.rb}

@@ -1,34 +1,18 @@
 # frozen_string_literal: true
 
 require "prism"
-require "kettle/dev/prism_utils"
 
 module Kettle
   module Dev
     # AST-driven merger for Appraisals files using Prism.
     # Preserves all comments: preamble headers, block headers, and inline comments.
     # Uses PrismUtils for shared Prism AST operations.
-    module AppraisalsAstMerger
+    module PrismAppraisals
       TRACKED_METHODS = [:gem, :eval_gemfile, :gemfile].freeze
 
       module_function
 
       # Merge template and destination Appraisals files preserving comments
-      #
-      # Merges appraise blocks by name, preserving:
-      # - Preamble comments (deduplicated)
-      # - Block headers (comments before each appraise block)
-      # - Inline comments on gem/eval_gemfile statements
-      # - Leading comments before statements
-      #
-      # @param template_content [String] Template Appraisals content
-      # @param dest_content [String] Destination Appraisals content
-      # @return [String] Merged Appraisals content with preserved comments
-      # @example
-      #   AppraisalsAstMerger.merge(
-      #     'appraise "rails-7" { gem "rails", "~> 7.0" }',
-      #     'appraise "custom" { gem "foo" }'
-      #   )
       def merge(template_content, dest_content)
         template_content ||= ""
         dest_content ||= ""
@@ -36,24 +20,19 @@ module Kettle
         return template_content if dest_content.strip.empty?
         return dest_content if template_content.strip.empty?
 
-        # Parse with Prism to get AST and comments
         tmpl_result = PrismUtils.parse_with_comments(template_content)
         dest_result = PrismUtils.parse_with_comments(dest_content)
 
-        # Extract preamble and blocks with their headers
         tmpl_preamble, tmpl_blocks = extract_blocks(tmpl_result, template_content)
         dest_preamble, dest_blocks = extract_blocks(dest_result, dest_content)
 
-        # Merge preambles
         merged_preamble = merge_preambles(tmpl_preamble, dest_preamble)
-
-        # Merge blocks
         merged_blocks = merge_blocks(tmpl_blocks, dest_blocks, tmpl_result, dest_result)
 
-        # Build output
         build_output(merged_preamble, merged_blocks)
       end
 
+      # ...existing helper methods copied from original AppraisalsAstMerger...
       def extract_blocks(parse_result, source_content)
         root = parse_result.value
         return [[], []] unless root&.statements&.body
@@ -62,14 +41,12 @@ module Kettle
         blocks = []
         first_appraise_line = nil
 
-        # Find all appraise blocks
         root.statements.body.each do |node|
           if appraise_call?(node)
             first_appraise_line ||= node.location.start_line
             name = extract_appraise_name(node)
             next unless name
 
-            # Extract block header (comments immediately before this block)
             block_header = extract_block_header(node, source_lines, blocks)
 
             blocks << {
@@ -80,14 +57,12 @@ module Kettle
           end
         end
 
-        # Preamble is all comments before first appraise block
         preamble_comments = if first_appraise_line
           parse_result.comments.select { |c| c.location.start_line < first_appraise_line }
         else
           parse_result.comments
         end
 
-        # Filter out comments that are part of block headers
         block_header_lines = blocks.flat_map { |b| b[:header].lines.map { |l| l.strip } }.to_set
         preamble_comments = preamble_comments.reject { |c| block_header_lines.include?(c.slice.strip) }
 
@@ -100,7 +75,6 @@ module Kettle
 
       def extract_appraise_name(node)
         return unless node.is_a?(Prism::CallNode)
-        # Use PrismUtils for extracting literal values
         PrismUtils.extract_literal_value(node.arguments&.arguments&.first)
       end
 
@@ -108,13 +82,11 @@ module Kettle
         tmpl_lines = tmpl_comments.map { |c| c.slice.strip }
         dest_lines = dest_comments.map { |c| c.slice.strip }
 
-        # Remove magic comments from dest if template has them
         magic_pattern = /^#.*frozen_string_literal/
         if tmpl_lines.any? { |line| line.match?(magic_pattern) }
           dest_lines.reject! { |line| line.match?(magic_pattern) }
         end
 
-        # Merge unique lines (case-insensitive), template first
         merged = []
         seen = Set.new
 
@@ -130,38 +102,26 @@ module Kettle
       end
 
       def extract_block_header(node, source_lines, previous_blocks)
-        # Get the line number where this block starts (1-indexed from Prism)
         begin_line = node.location.start_line
-
-        # Find the end of the previous block or start of file
         min_line = if previous_blocks.empty?
           1
         else
           previous_blocks.last[:node].location.end_line + 1
         end
-
-        # Convert to 0-indexed and look at the line before the block
-        check_line = begin_line - 2  # e.g., if block is on line 2 (1-indexed), check line 0 (0-indexed, which is line 1 in file)
-
-        # Look backwards from the block start to find contiguous comment lines
+        check_line = begin_line - 2
         header_lines = []
-
         while check_line >= 0 && (check_line + 1) >= min_line
           line = source_lines[check_line]
           break unless line
-
-          # Stop at empty line
           if line.strip.empty?
             break
           elsif line.lstrip.start_with?("#")
             header_lines.unshift(line)
             check_line -= 1
           else
-            # Non-comment, non-blank line - stop
             break
           end
         end
-
         header_lines.join
       rescue StandardError => e
         Kettle::Dev.debug_error(e, __method__) if defined?(Kettle::Dev.debug_error)
@@ -172,27 +132,16 @@ module Kettle
         merged = []
         dest_by_name = dest_blocks.each_with_object({}) { |b, h| h[b[:name]] = b }
         template_names = template_blocks.map { |b| b[:name] }.to_set
-
-        # Track which dest blocks we've already placed
         placed_dest = Set.new
 
-        # For each template block, merge it and insert any dest-only blocks that come before it
         template_blocks.each_with_index do |tmpl_block, idx|
           name = tmpl_block[:name]
-
-          # Find dest-only blocks that should come before this template block
-          # (i.e., blocks that appear in dest before this shared block)
           if idx == 0 || dest_by_name[name]
-            # For first template block or when we have a dest version of this block,
-            # check if there are dest-only blocks to insert before it
             dest_blocks.each do |db|
               next if template_names.include?(db[:name])
               next if placed_dest.include?(db[:name])
-
-              # Check if this dest-only block comes before current shared block in dest
               dest_idx_of_shared = dest_blocks.index { |b| b[:name] == name }
               dest_idx_of_only = dest_blocks.index { |b| b[:name] == db[:name] }
-
               if dest_idx_of_only && dest_idx_of_shared && dest_idx_of_only < dest_idx_of_shared
                 merged << db
                 placed_dest << db[:name]
@@ -200,10 +149,8 @@ module Kettle
             end
           end
 
-          # Now add the template block (merged or template-only)
           dest_block = dest_by_name[name]
           if dest_block
-            # Merge this block
             merged_header = merge_block_headers(tmpl_block[:header], dest_block[:header])
             merged_statements = merge_block_statements(
               tmpl_block[:node].block.body,
@@ -218,12 +165,10 @@ module Kettle
             }
             placed_dest << name
           else
-            # Template-only block
             merged << tmpl_block
           end
         end
 
-        # Add any remaining destination-only blocks that haven't been placed
         dest_blocks.each do |dest_block|
           next if placed_dest.include?(dest_block[:name])
           next if template_names.include?(dest_block[:name])
@@ -236,11 +181,8 @@ module Kettle
       def merge_block_headers(tmpl_header, dest_header)
         tmpl_lines = tmpl_header.to_s.lines.map(&:strip).reject(&:empty?)
         dest_lines = dest_header.to_s.lines.map(&:strip).reject(&:empty?)
-
-        # Merge without duplicates (case-insensitive comparison), template first
         merged = []
         seen = Set.new
-
         (tmpl_lines + dest_lines).each do |line|
           normalized = line.downcase
           unless seen.include?(normalized)
@@ -248,7 +190,6 @@ module Kettle
             seen << normalized
           end
         end
-
         return "" if merged.empty?
         merged.join("\n") + "\n"
       end
@@ -257,7 +198,6 @@ module Kettle
         tmpl_stmts = PrismUtils.extract_statements(tmpl_body)
         dest_stmts = PrismUtils.extract_statements(dest_body)
 
-        # Build statement keys for both
         tmpl_keys = Set.new
         tmpl_key_to_node = {}
         tmpl_stmts.each do |stmt|
@@ -274,27 +214,20 @@ module Kettle
           dest_keys << key if key
         end
 
-        # Process dest statements in order, preserving their position and comments
         merged = []
         dest_stmts.each_with_index do |dest_stmt, idx|
           dest_key = statement_key(dest_stmt)
 
           if dest_key && tmpl_keys.include?(dest_key)
-            # Shared statement - use template version but preserve dest position
-            # Add it with no comments (template version is canonical)
             merged << {node: tmpl_key_to_node[dest_key], inline_comments: [], leading_comments: [], shared: true, key: dest_key}
           else
-            # Dest-only statement - preserve with all comments
             inline_comments = PrismUtils.inline_comments_for_node(dest_result, dest_stmt)
-
             prev_stmt = (idx > 0) ? dest_stmts[idx - 1] : nil
             leading_comments = PrismUtils.find_leading_comments(dest_result, dest_stmt, prev_stmt, dest_body)
-
             merged << {node: dest_stmt, inline_comments: inline_comments, leading_comments: leading_comments, shared: false}
           end
         end
 
-        # Add template-only statements (those not in dest) at the end
         tmpl_stmts.each do |tmpl_stmt|
           tmpl_key = statement_key(tmpl_stmt)
           unless tmpl_key && dest_keys.include?(tmpl_key)
@@ -302,7 +235,6 @@ module Kettle
           end
         end
 
-        # Clean up - remove the tracking fields
         merged.each do |item|
           item.delete(:shared)
           item.delete(:key)
@@ -312,69 +244,60 @@ module Kettle
       end
 
       def statement_key(node)
-        # Use PrismUtils for statement key generation with Appraisals-specific tracked methods
         PrismUtils.statement_key(node, tracked_methods: TRACKED_METHODS)
       end
 
       def build_output(preamble_lines, blocks)
         output = []
-
-        # Add preamble
         preamble_lines.each { |line| output << line }
         output << "" unless preamble_lines.empty?
 
-        # Add blocks
         blocks.each do |block|
-          # Add block header (no blank line before it)
           header = block[:header]
           if header && !header.strip.empty?
             output << header.rstrip
           end
 
-          # Add appraise call - using parentheses and curly braces format
           name = block[:name]
           output << "appraise(\"#{name}\") {"
 
-          # Add statements
           statements = block[:statements] || extract_original_statements(block[:node])
           statements.each do |stmt_info|
-            # Add any leading comments before this statement
             leading = stmt_info[:leading_comments] || []
             leading.each do |comment|
               output << "  #{comment.slice.strip}"
             end
 
             node = stmt_info[:node]
-            # Normalize the statement to use parentheses
             line = normalize_statement(node)
+            # Remove any leading whitespace/newlines from the normalized line
+            line = line.to_s.sub(/\A\s+/, "")
 
             inline = stmt_info[:inline_comments] || []
             inline_str = inline.map { |c| c.slice.strip }.join(" ")
-            output << "  #{line}#{" #{inline_str}" unless inline_str.empty?}"
+            output << "  #{line}#{" " + inline_str unless inline_str.empty?}"
           end
 
           output << "}"
           output << ""
         end
 
-        output.join("\n").strip + "\n"
+        build = output.join("\n").strip + "\n"
+        build
       end
 
       def normalize_statement(node)
-        # Use PrismUtils for normalizing call nodes
         return PrismUtils.node_to_source(node) unless node.is_a?(Prism::CallNode)
         PrismUtils.normalize_call_node(node)
       end
 
       def normalize_argument(arg)
-        # Use PrismUtils for argument normalization
         PrismUtils.normalize_argument(arg)
       end
 
       def extract_original_statements(node)
         body = node.block&.body
         return [] unless body
-
         statements = body.is_a?(Prism::StatementsNode) ? body.body : [body]
         statements.compact.map { |stmt| {node: stmt, inline_comments: [], leading_comments: []} }
       end

data/lib/kettle/dev/prism_gemfile.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Kettle
+  module Dev
+    # Prism helpers for Gemfile-like merging.
+    module PrismGemfile
+      module_function
+
+      # Merge gem calls from src_content into dest_content.
+      # - Replaces dest `source` call with src's if present.
+      # - Replaces or inserts non-comment `git_source` definitions.
+      # - Appends missing `gem` calls (by name) from src to dest preserving dest content and newlines.
+      # This is a conservative, comment-preserving approach using Prism to detect call nodes.
+      def merge_gem_calls(src_content, dest_content)
+        src_res = PrismUtils.parse_with_comments(src_content)
+        dest_res = PrismUtils.parse_with_comments(dest_content)
+
+        src_stmts = PrismUtils.extract_statements(src_res.value.statements)
+        dest_stmts = PrismUtils.extract_statements(dest_res.value.statements)
+
+        # Find source nodes
+        src_source_node = src_stmts.find { |n| PrismUtils.call_to?(n, :source) }
+        dest_source_node = dest_stmts.find { |n| PrismUtils.call_to?(n, :source) }
+
+        out = dest_content.dup
+        dest_lines = out.lines
+
+        # Replace or insert source line
+        if src_source_node
+          src_src = src_source_node.slice
+          if dest_source_node
+            out = out.sub(dest_source_node.slice, src_src)
+            dest_lines = out.lines
+          else
+            # insert after any leading comment/blank block
+            insert_idx = 0
+            while insert_idx < dest_lines.length && (dest_lines[insert_idx].strip.empty? || dest_lines[insert_idx].lstrip.start_with?("#"))
+              insert_idx += 1
+            end
+            dest_lines.insert(insert_idx, src_src.rstrip + "\n")
+            out = dest_lines.join
+            dest_lines = out.lines
+          end
+        end
+
+        # --- Handle git_source replacement/insertion ---
+        src_git_nodes = src_stmts.select { |n| PrismUtils.call_to?(n, :git_source) }
+        if src_git_nodes.any?
+          # We'll operate on dest_lines for insertion; recompute dest_stmts if we changed out
+          dest_res = PrismUtils.parse_with_comments(out)
+          dest_stmts = PrismUtils.extract_statements(dest_res.value.statements)
+
+          # Iterate in reverse when inserting so that inserting at the same index
+          # preserves the original order from the source (we insert at a fixed index).
+          src_git_nodes.reverse_each do |gnode|
+            key = PrismUtils.statement_key(gnode) # => [:git_source, name]
+            name = key && key[1]
+            replaced = false
+
+            if name
+              dest_same_idx = dest_stmts.index { |d| PrismUtils.statement_key(d) && PrismUtils.statement_key(d)[0] == :git_source && PrismUtils.statement_key(d)[1] == name }
+              if dest_same_idx
+                # Replace the matching dest node slice
+                out = out.sub(dest_stmts[dest_same_idx].slice, gnode.slice)
+                replaced = true
+              end
+            end
+
+            # If not replaced, prefer to replace an existing github entry in destination
+            # (this mirrors previous behavior in template_helpers which favored replacing
+            # a github git_source when inserting others).
+            unless replaced
+              dest_github_idx = dest_stmts.index { |d| PrismUtils.statement_key(d) && PrismUtils.statement_key(d)[0] == :git_source && PrismUtils.statement_key(d)[1] == "github" }
+              if dest_github_idx
+                out = out.sub(dest_stmts[dest_github_idx].slice, gnode.slice)
+                replaced = true
+              end
+            end
+
+            unless replaced
+              # Insert below source line if present, else at top after comments
+              dest_lines = out.lines
+              insert_idx = dest_lines.index { |ln| !ln.strip.start_with?("#") && ln =~ /^\s*source\s+/ } || 0
+              insert_idx += 1 if insert_idx
+              dest_lines.insert(insert_idx, gnode.slice.rstrip + "\n")
+              out = dest_lines.join
+            end
+
+            # Recompute dest_stmts for subsequent iterations
+            dest_res = PrismUtils.parse_with_comments(out)
+            dest_stmts = PrismUtils.extract_statements(dest_res.value.statements)
+          end
+        end
+
+        # Collect gem names present in dest (top-level only)
+        dest_res = PrismUtils.parse_with_comments(out)
+        dest_stmts = PrismUtils.extract_statements(dest_res.value.statements)
+        dest_gem_names = dest_stmts.map { |n| PrismUtils.statement_key(n) }.compact.select { |k| k[0] == :gem }.map { |k| k[1] }.to_set
+
+        # Find gem call nodes in src and append missing ones (top-level only)
+        missing_nodes = src_stmts.select do |n|
+          k = PrismUtils.statement_key(n)
+          k && k.first == :gem && !dest_gem_names.include?(k[1])
+        end
+        if missing_nodes.any?
+          out << "\n" unless out.end_with?("\n") || out.empty?
+          missing_nodes.each do |n|
+            # Preserve inline comments for the source node when appending
+            inline = begin
+              PrismUtils.inline_comments_for_node(src_res, n)
+            rescue
+              []
+            end
+            line = n.slice.rstrip
+            if inline && inline.any?
+              inline_text = inline.map { |c| c.slice.strip }.join(" ")
+              # Only append the inline text if it's not already part of the slice
+              line = line + " " + inline_text unless line.include?(inline_text)
+            end
+            out << line + "\n"
+          end
+        end
+
+        out
+      rescue StandardError => e
+        # Use debug_log if available, otherwise Kettle::Dev.debug_error
+        if defined?(Kettle::Dev) && Kettle::Dev.respond_to?(:debug_error)
+          Kettle::Dev.debug_error(e, __method__)
+        else
+          Kernel.warn("[#{__method__}] #{e.class}: #{e.message}")
+        end
+        dest_content
+      end
+    end
+  end
+end