kettle-dev 1.1.60 → 1.2.1

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

data/lib/kettle/dev/prism_gemspec.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+module Kettle
+  module Dev
+    # Prism helpers for gemspec manipulation.
+    module PrismGemspec
+      module_function
+
+      # Emit a debug warning for rescued errors when kettle-dev debugging is enabled.
+      # Controlled by KETTLE_DEV_DEBUG=true (or DEBUG=true as fallback).
+      # @param error [Exception]
+      # @param context [String, Symbol, nil] optional label, often __method__
+      # @return [void]
+      def debug_error(error, context = nil)
+        Kettle::Dev.debug_error(error, context)
+      end
+
+      # Replace scalar or array assignments inside a Gem::Specification.new block.
+      # `replacements` is a hash mapping symbol field names to string or array values.
+      # Operates only inside the Gem::Specification block to avoid accidental matches.
+      def replace_gemspec_fields(content, replacements = {})
+        return content if replacements.nil? || replacements.empty?
+
+        result = PrismUtils.parse_with_comments(content)
+        stmts = PrismUtils.extract_statements(result.value.statements)
+
+        gemspec_call = stmts.find do |s|
+          s.is_a?(Prism::CallNode) && s.block && PrismUtils.extract_const_name(s.receiver) == "Gem::Specification" && s.name == :new
+        end
+        return content unless gemspec_call
+
+        call_src = gemspec_call.slice
+
+        # Try to detect block parameter name (e.g., |spec|)
+        blk_param = nil
+        begin
+          if gemspec_call.block && gemspec_call.block.params
+            # Attempt a few defensive ways to extract a param name
+            if gemspec_call.block.params.respond_to?(:parameters) && gemspec_call.block.params.parameters.respond_to?(:first)
+              p = gemspec_call.block.params.parameters.first
+              blk_param = p.name.to_s if p.respond_to?(:name)
+            elsif gemspec_call.block.params.respond_to?(:first)
+              p = gemspec_call.block.params.first
+              blk_param = p.name.to_s if p && p.respond_to?(:name)
+            end
+          end
+        rescue StandardError
+          blk_param = nil
+        end
+
+        # Fallback to crude parse of the call_src header
+        unless blk_param && !blk_param.to_s.empty?
+          hdr_m = call_src.match(/do\b[^\n]*\|([^|]+)\|/m)
+          blk_param = (hdr_m && hdr_m[1]) ? hdr_m[1].strip.split(/,\s*/).first : "spec"
+        end
+        blk_param = "spec" if blk_param.nil? || blk_param.empty?
+
+        # Extract AST-level statements inside the block body when available
+        body_node = gemspec_call.block&.body
+        body_src = ""
+        begin
+          # Try to extract the textual body from call_src using the do|...| ... end capture
+          body_src = if (m = call_src.match(/do\b[^\n]*\|[^|]*\|\s*(.*)end\s*\z/m))
+            m[1]
+          else
+            # Last resort: attempt to take slice of body node
+            body_node ? body_node.slice : ""
+          end
+        rescue StandardError
+          body_src = body_node ? body_node.slice : ""
+        end
+
+        new_body = body_src.dup
+
+        # Helper: build literal text for replacement values
+        build_literal = lambda do |v|
+          if v.is_a?(Array)
+            arr = v.compact.map(&:to_s).map { |e| '"' + e.gsub('"', '\\"') + '"' }
+            "[" + arr.join(", ") + "]"
+          else
+            '"' + v.to_s.gsub('"', '\\"') + '"'
+          end
+        end
+
+        # Extract existing statement nodes for more precise matching
+        stmt_nodes = PrismUtils.extract_statements(body_node)
+
+        replacements.each do |field_sym, value|
+          # Skip special internal keys that are not actual gemspec fields
+          next if field_sym == :_remove_self_dependency
+
+          field = field_sym.to_s
+
+          # Find an existing assignment node for this field: look for call nodes where
+          # receiver slice matches the block param and method name matches assignment
+          found_node = stmt_nodes.find do |n|
+            next false unless n.is_a?(Prism::CallNode)
+            begin
+              recv = n.receiver
+              recv_name = recv ? recv.slice.strip : nil
+              # match receiver variable name or literal slice
+              recv_name && recv_name.end_with?(blk_param) && n.name.to_s.start_with?(field)
+            rescue StandardError
+              false
+            end
+          end
+
+          if found_node
+            # Do not replace if the existing RHS is non-literal (e.g., computed expression)
+            existing_arg = found_node.arguments&.arguments&.first
+            existing_literal = begin
+              PrismUtils.extract_literal_value(existing_arg)
+            rescue
+              nil
+            end
+            if existing_literal.nil? && !value.nil?
+              # Skip replacing a non-literal RHS to avoid altering computed expressions.
+              debug_error(StandardError.new("Skipping replacement for #{field} because existing RHS is non-literal"), __method__)
+            else
+              # Replace the found node's slice in the body text with the updated assignment
+              indent = begin
+                found_node.slice.lines.first.match(/^(\s*)/)[1]
+              rescue
+                "  "
+              end
+              rhs = build_literal.call(value)
+              replacement = "#{indent}#{blk_param}.#{field} = #{rhs}"
+              new_body = new_body.sub(found_node.slice, replacement)
+            end
+          else
+            # No existing assignment; insert after spec.version if present, else append
+            version_node = stmt_nodes.find do |n|
+              n.is_a?(Prism::CallNode) && n.name.to_s.start_with?("version", "version=") && n.receiver && n.receiver.slice.strip.end_with?(blk_param)
+            end
+
+            insert_line = "  #{blk_param}.#{field} = #{build_literal.call(value)}\n"
+            new_body = if version_node
+              # Insert after the version node slice
+              new_body.sub(version_node.slice, version_node.slice + "\n" + insert_line)
+            elsif new_body.rstrip.end_with?('\n')
+              # Append before the final newline if present, else just append
+              new_body.rstrip + "\n" + insert_line
+            else
+              new_body.rstrip + "\n" + insert_line
+            end
+          end
+        end
+
+        # Handle removal of self-dependency if requested via :_remove_self_dependency
+        if replacements[:_remove_self_dependency]
+          name_to_remove = replacements[:_remove_self_dependency].to_s
+          # Find dependency call nodes to remove (add_dependency/add_development_dependency)
+          dep_nodes = stmt_nodes.select do |n|
+            next false unless n.is_a?(Prism::CallNode)
+            recv = begin
+              n.receiver
+            rescue
+              nil
+            end
+            next false unless recv && recv.slice.strip.end_with?(blk_param)
+            [:add_dependency, :add_development_dependency].include?(n.name)
+          end
+          dep_nodes.each do |dn|
+            # Check first argument literal
+            first_arg = dn.arguments&.arguments&.first
+            arg_val = begin
+              PrismUtils.extract_literal_value(first_arg)
+            rescue
+              nil
+            end
+            if arg_val && arg_val.to_s == name_to_remove
+              # Remove this node's slice from new_body
+              new_body = new_body.sub(dn.slice, "")
+            end
+          end
+        end
+
+        # Reassemble call source by replacing the captured body portion
+        new_call_src = call_src.sub(body_src, new_body)
+        content.sub(call_src, new_call_src)
+      rescue StandardError => e
+        debug_error(e, __method__)
+        content
+      end
+
+      # Remove spec.add_dependency / add_development_dependency calls that name the given gem
+      # Works by locating the Gem::Specification block and filtering out matching call lines.
+      def remove_spec_dependency(content, gem_name)
+        return content if gem_name.to_s.strip.empty?
+        replace_gemspec_fields(content, _remove_self_dependency: gem_name)
+      end
+
+      # Ensure development dependency lines in a gemspec match the desired lines.
+      # `desired` is a hash mapping gem_name => desired_line (string, without leading indentation).
+      # Returns the modified gemspec content (or original on error).
+      def ensure_development_dependencies(content, desired)
+        return content if desired.nil? || desired.empty?
+        result = PrismUtils.parse_with_comments(content)
+        stmts = PrismUtils.extract_statements(result.value.statements)
+        gemspec_call = stmts.find do |s|
+          s.is_a?(Prism::CallNode) && s.block && PrismUtils.extract_const_name(s.receiver) == "Gem::Specification" && s.name == :new
+        end
+
+        # If we couldn't locate the Gem::Specification.new block (e.g., empty or
+        # truncated gemspec), fall back to appending the desired development
+        # dependency lines to the end of the file so callers still get the
+        # expected dependency declarations.
+        unless gemspec_call
+          begin
+            out = content.dup
+            out << "\n" unless out.end_with?("\n") || out.empty?
+            desired.each do |_gem, line|
+              out << line.strip + "\n"
+            end
+            return out
+          rescue StandardError => e
+            debug_error(e, __method__)
+            return content
+          end
+        end
+
+        call_src = gemspec_call.slice
+        body_node = gemspec_call.block&.body
+        body_src = begin
+          if (m = call_src.match(/do\b[^\n]*\|[^|]*\|\s*(.*)end\s*\z/m))
+            m[1]
+          else
+            body_node ? body_node.slice : ""
+          end
+        rescue StandardError
+          body_node ? body_node.slice : ""
+        end
+
+        new_body = body_src.dup
+        stmt_nodes = PrismUtils.extract_statements(body_node)
+
+        # Find version node to choose insertion point
+        version_node = stmt_nodes.find do |n|
+          n.is_a?(Prism::CallNode) && n.name.to_s.start_with?("version") && n.receiver && n.receiver.slice.strip.end_with?("spec")
+        end
+
+        desired.each do |gem_name, desired_line|
+          # Skip commented occurrences - we only act on actual AST nodes
+          found = stmt_nodes.find do |n|
+            next false unless n.is_a?(Prism::CallNode)
+            next false unless [:add_development_dependency, :add_dependency].include?(n.name)
+            first_arg = n.arguments&.arguments&.first
+            val = begin
+              PrismUtils.extract_literal_value(first_arg)
+            rescue
+              nil
+            end
+            val && val.to_s == gem_name
+          end
+
+          if found
+            # Replace existing node slice with desired_line, preserving indent
+            indent = begin
+              found.slice.lines.first.match(/^(\s*)/)[1]
+            rescue
+              "  "
+            end
+            replacement = indent + desired_line.strip + "\n"
+            new_body = new_body.sub(found.slice, replacement)
+          else
+            # Insert after version_node if present, else append before end
+            insert_line = "  " + desired_line.strip + "\n"
+            new_body = if version_node
+              new_body.sub(version_node.slice, version_node.slice + "\n" + insert_line)
+            else
+              new_body.rstrip + "\n" + insert_line
+            end
+          end
+        end
+
+        new_call_src = call_src.sub(body_src, new_body)
+        content.sub(call_src, new_call_src)
+      rescue StandardError => e
+        debug_error(e, __method__)
+        content
+      end
+    end
+  end
+end

data/lib/kettle/dev/prism_utils.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Kettle
+  module Dev
+    # Shared utilities for working with Prism AST nodes.
+    # Provides parsing, node inspection, and source generation helpers
+    # used by both PrismMerger and AppraisalsAstMerger.
+    #
+    # Uses Prism's native methods for source generation (via .slice) to preserve
+    # original formatting and comments. For normalized output (e.g., adding parentheses),
+    # use normalize_call_node instead.
+    module PrismUtils
+      module_function
+
+      # Parse Ruby source code and return Prism parse result with comments
+      # @param source [String] Ruby source code
+      # @return [Prism::ParseResult] Parse result containing AST and comments
+      def parse_with_comments(source)
+        Prism.parse(source)
+      end
+
+      # Extract statements from a Prism body node
+      # @param body_node [Prism::Node, nil] Body node (typically StatementsNode)
+      # @return [Array<Prism::Node>] Array of statement nodes
+      def extract_statements(body_node)
+        return [] unless body_node
+
+        if body_node.is_a?(Prism::StatementsNode)
+          body_node.body.compact
+        else
+          [body_node].compact
+        end
+      end
+
+      # Generate a unique key for a statement node to identify equivalent statements
+      # Used for merge/append operations to detect duplicates
+      # @param node [Prism::Node] Statement node
+      # @param tracked_methods [Array<Symbol>] Methods to track (default: gem, source, eval_gemfile, git_source)
+      # @return [Array, nil] Key array like [:gem, "foo"] or nil if not trackable
+      def statement_key(node, tracked_methods: %i[gem source eval_gemfile git_source])
+        return unless node.is_a?(Prism::CallNode)
+        return unless tracked_methods.include?(node.name)
+
+        first_arg = node.arguments&.arguments&.first
+        arg_value = extract_literal_value(first_arg)
+
+        [node.name, arg_value] if arg_value
+      end
+
+      # Extract literal value from string or symbol nodes
+      # @param node [Prism::Node, nil] Node to extract from
+      # @return [String, Symbol, nil] Literal value or nil
+      def extract_literal_value(node)
+        return unless node
+        case node
+        when Prism::StringNode then node.unescaped
+        when Prism::SymbolNode then node.unescaped
+        else
+          # Attempt to handle array literals
+          if node.respond_to?(:elements) && node.elements
+            arr = node.elements.map do |el|
+              case el
+              when Prism::StringNode then el.unescaped
+              when Prism::SymbolNode then el.unescaped
+              end
+            end
+            return arr if arr.all?
+          end
+          nil
+        end
+      end
+
+      # Extract qualified constant name from a constant node
+      # @param node [Prism::Node, nil] Constant node
+      # @return [String, nil] Qualified name like "Gem::Specification" or nil
+      def extract_const_name(node)
+        case node
+        when Prism::ConstantReadNode
+          node.name.to_s
+        when Prism::ConstantPathNode
+          parent = extract_const_name(node.parent)
+          child = node.name || node.child&.name
+          (parent && child) ? "#{parent}::#{child}" : child.to_s
+        end
+      end
+
+      # Find leading comments for a statement node
+      # Leading comments are those that appear after the previous statement
+      # and before the current statement
+      # @param parse_result [Prism::ParseResult] Parse result with comments
+      # @param current_stmt [Prism::Node] Current statement node
+      # @param prev_stmt [Prism::Node, nil] Previous statement node
+      # @param body_node [Prism::Node] Body containing the statements
+      # @return [Array<Prism::Comment>] Leading comments
+      def find_leading_comments(parse_result, current_stmt, prev_stmt, body_node)
+        start_line = prev_stmt ? prev_stmt.location.end_line : body_node.location.start_line
+        end_line = current_stmt.location.start_line
+
+        parse_result.comments.select do |comment|
+          comment.location.start_line > start_line &&
+            comment.location.start_line < end_line
+        end
+      end
+
+      # Find inline comments for a statement node
+      # Inline comments are those that appear on the same line as the statement's end
+      # @param parse_result [Prism::ParseResult] Parse result with comments
+      # @param stmt [Prism::Node] Statement node
+      # @return [Array<Prism::Comment>] Inline comments
+      def inline_comments_for_node(parse_result, stmt)
+        parse_result.comments.select do |comment|
+          comment.location.start_line == stmt.location.end_line &&
+            comment.location.start_offset > stmt.location.end_offset
+        end
+      end
+
+      # Convert a Prism AST node to Ruby source code
+      # Uses Prism's native slice method which preserves the original source exactly.
+      # This is preferable to Unparser for Prism nodes as it maintains original formatting
+      # and comments without requiring transformation.
+      # @param node [Prism::Node] AST node
+      # @return [String] Ruby source code
+      def node_to_source(node)
+        return "" unless node
+        # Prism nodes have a slice method that returns the original source
+        node.slice
+      end
+
+      # Normalize a call node to use parentheses format
+      # Converts `gem "foo"` to `gem("foo")` style
+      # @param node [Prism::CallNode] Call node
+      # @return [String] Normalized source code
+      def normalize_call_node(node)
+        return node.slice.strip unless node.is_a?(Prism::CallNode)
+
+        method_name = node.name
+        args = node.arguments&.arguments || []
+
+        if args.empty?
+          "#{method_name}()"
+        else
+          arg_strings = args.map { |arg| normalize_argument(arg) }
+          "#{method_name}(#{arg_strings.join(", ")})"
+        end
+      end
+
+      # Normalize an argument node to canonical format
+      # @param arg [Prism::Node] Argument node
+      # @return [String] Normalized argument source
+      def normalize_argument(arg)
+        case arg
+        when Prism::StringNode
+          "\"#{arg.unescaped}\""
+        when Prism::SymbolNode
+          ":#{arg.unescaped}"
+        when Prism::KeywordHashNode
+          # Handle hash arguments like {key: value}
+          pairs = arg.elements.map do |assoc|
+            key = case assoc.key
+            when Prism::SymbolNode then "#{assoc.key.unescaped}:"
+            when Prism::StringNode then "\"#{assoc.key.unescaped}\" =>"
+            else "#{assoc.key.slice} =>"
+            end
+            value = normalize_argument(assoc.value)
+            "#{key} #{value}"
+          end.join(", ")
+          pairs
+        when Prism::HashNode
+          # Handle explicit hash syntax
+          pairs = arg.elements.map do |assoc|
+            key_part = normalize_argument(assoc.key)
+            value_part = normalize_argument(assoc.value)
+            "#{key_part} => #{value_part}"
+          end.join(", ")
+          "{#{pairs}}"
+        else
+          # For other types (numbers, arrays, etc.), use the original source
+          arg.slice.strip
+        end
+      end
+
+      # Check if a node is a specific method call
+      # @param node [Prism::Node] Node to check
+      # @param method_name [Symbol] Method name to check for
+      # @return [Boolean] True if node is a call to the specified method
+      def call_to?(node, method_name)
+        node.is_a?(Prism::CallNode) && node.name == method_name
+      end
+
+      # Check if a node is a block call to a specific method
+      # @param node [Prism::Node] Node to check
+      # @param method_name [Symbol] Method name to check for
+      # @return [Boolean] True if node is a block call to the specified method
+      def block_call_to?(node, method_name)
+        node.is_a?(Prism::CallNode) && node.name == method_name && !node.block.nil?
+      end
+    end
+  end
+end

data/lib/kettle/dev/readme_backers.rb

@@ -33,10 +33,7 @@ module Kettle
       # @param msg [String]
       # @return [void]
       def debug_log(msg)
-        return unless Kettle::Dev::DEBUGGING
-        Kernel.warn("[readme_backers] #{msg}")
-      rescue StandardError
-        # never raise from a standard error within debug logging
+        Kettle::Dev.debug_log(msg)
       end
 
       public

data/lib/kettle/dev/setup_cli.rb

@@ -197,37 +197,26 @@ module Kettle
           end
         end
 
-        modified = target.dup
-        wanted.each do |gem_name, desired_line|
-          lines = modified.lines
-          found = false
-          lines.map! do |ln|
-            if ln =~ /add_development_dependency\s*\(?\s*["']#{Regexp.escape(gem_name)}["']/
-              found = true
-              indent = ln[/^\s*/] || ""
-              "#{indent}#{desired_line.strip}\n"
-            else
-              ln
-            end
+        # Use Prism-based gemspec edit to ensure development dependencies match
+        begin
+          modified = Kettle::Dev::PrismGemspec.ensure_development_dependencies(target, wanted)
+          # Check if any actual changes were made to development dependency declarations.
+          # Extract dependency lines from both and compare sets to avoid false positives
+          # from whitespace/formatting differences.
+          extract_deps = lambda do |content|
+            content.to_s.lines.select { |ln| ln =~ /add_development_dependency\s*\(?/ }.map(&:strip).sort
           end
-          modified = lines.join
-
-          next if found
-
-          if (idx = modified.rindex(/\nend\s*\z/))
-            before = modified[0...idx]
-            after = modified[idx..-1]
-            insertion = "\n  #{desired_line.strip}\n"
-            modified = before + insertion + after
+          target_deps = extract_deps.call(target)
+          modified_deps = extract_deps.call(modified)
+          if modified_deps != target_deps
+            File.write(@gemspec_path, modified)
+            say("Updated development dependencies in #{@gemspec_path}.")
           else
-            modified << "\n#{desired_line}\n"
+            say("Development dependencies already up to date.")
           end
-        end
-
-        if modified != target
-          File.write(@gemspec_path, modified)
-          say("Updated development dependencies in #{@gemspec_path}.")
-        else
+        rescue StandardError => e
+          Kettle::Dev.debug_error(e, __method__)
+          # Fall back to previous behavior: write nothing and report up-to-date
           say("Development dependencies already up to date.")
         end
       end