kettle-dev 1.2.0 → 1.2.1

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

@@ -53,9 +53,22 @@ module Kettle
       # @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
 

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

data/lib/kettle/dev/source_merger.rb

@@ -3,7 +3,6 @@
 require "yaml"
 require "set"
 require "prism"
-require "kettle/dev/prism_utils"
 
 module Kettle
   module Dev
@@ -235,12 +234,68 @@ module Kettle
         src_result = PrismUtils.parse_with_comments(src_content)
         dest_result = PrismUtils.parse_with_comments(dest_content)
 
+        # If src parsing failed, return src unchanged to avoid losing content
+        unless src_result.success?
+          puts "WARNING: Source content parse failed, returning unchanged"
+          return src_content
+        end
+
         src_nodes = extract_nodes_with_comments(src_result)
         dest_nodes = extract_nodes_with_comments(dest_result)
 
         merged_nodes = yield(src_nodes, dest_nodes, src_result, dest_result)
 
-        build_source_from_nodes(merged_nodes)
+        # Extract magic comments from source (frozen_string_literal, etc.)
+        magic_comments = extract_magic_comments(src_result)
+
+        # Extract file-level leading comments (comments before first statement)
+        file_leading_comments = extract_file_leading_comments(src_result)
+
+        build_source_from_nodes(merged_nodes, magic_comments: magic_comments, file_leading_comments: file_leading_comments)
+      end
+
+      def extract_magic_comments(parse_result)
+        return [] unless parse_result.success?
+
+        magic_comments = []
+        source_lines = parse_result.source.lines
+
+        # Magic comments appear at the very top of the file (possibly after shebang)
+        # They must be on the first or second line
+        source_lines.first(2).each do |line|
+          stripped = line.strip
+          # Check for shebang
+          if stripped.start_with?("#!")
+            magic_comments << line.rstrip
+          # Check for magic comments like frozen_string_literal, encoding, etc.
+          elsif stripped.start_with?("#") &&
+              (stripped.include?("frozen_string_literal:") ||
+               stripped.include?("encoding:") ||
+               stripped.include?("warn_indent:") ||
+               stripped.include?("shareable_constant_value:"))
+            magic_comments << line.rstrip
+          end
+        end
+
+        magic_comments
+      end
+
+      def extract_file_leading_comments(parse_result)
+        return [] unless parse_result.success?
+
+        statements = PrismUtils.extract_statements(parse_result.value.statements)
+        return [] if statements.empty?
+
+        first_stmt = statements.first
+        first_stmt_line = first_stmt.location.start_line
+
+        # Extract file-level comments that appear after magic comments (line 1-2)
+        # but before the first executable statement. These are typically documentation
+        # comments describing the file's purpose.
+        parse_result.comments.select do |comment|
+          comment.location.start_line > 2 &&
+            comment.location.start_line < first_stmt_line
+        end.map { |comment| comment.slice.rstrip }
       end
 
       def extract_nodes_with_comments(parse_result)
@@ -249,23 +304,81 @@ module Kettle
         statements = PrismUtils.extract_statements(parse_result.value.statements)
         return [] if statements.empty?
 
+        source_lines = parse_result.source.lines
+
         statements.map.with_index do |stmt, idx|
           prev_stmt = (idx > 0) ? statements[idx - 1] : nil
           body_node = parse_result.value.statements
 
+          # Count blank lines before this statement
+          blank_lines_before = count_blank_lines_before(source_lines, stmt, prev_stmt, body_node)
+
           {
             node: stmt,
             leading_comments: PrismUtils.find_leading_comments(parse_result, stmt, prev_stmt, body_node),
             inline_comments: PrismUtils.inline_comments_for_node(parse_result, stmt),
+            blank_lines_before: blank_lines_before,
           }
         end
       end
 
-      def build_source_from_nodes(node_infos)
+      def count_blank_lines_before(source_lines, current_stmt, prev_stmt, body_node)
+        # Determine the starting line to search from
+        start_line = if prev_stmt
+          prev_stmt.location.end_line
+        else
+          # For the first statement, start from the beginning of the body
+          body_node.location.start_line
+        end
+
+        end_line = current_stmt.location.start_line
+
+        # Count consecutive blank lines before the current statement
+        # (after any comments and the previous statement)
+        blank_count = 0
+        (start_line...end_line).each do |line_num|
+          line_idx = line_num - 1
+          next if line_idx < 0 || line_idx >= source_lines.length
+
+          line = source_lines[line_idx]
+          # Skip comment lines (they're handled separately)
+          next if line.strip.start_with?("#")
+
+          # Count blank lines
+          if line.strip.empty?
+            blank_count += 1
+          else
+            # Reset count if we hit a non-blank, non-comment line
+            # This ensures we only count consecutive blank lines immediately before the statement
+            blank_count = 0
+          end
+        end
+
+        blank_count
+      end
+
+      def build_source_from_nodes(node_infos, magic_comments: [], file_leading_comments: [])
         return "" if node_infos.empty?
 
         lines = []
+
+        # Add magic comments at the top (frozen_string_literal, etc.)
+        if magic_comments.any?
+          lines.concat(magic_comments)
+          lines << "" # Add blank line after magic comments
+        end
+
+        # Add file-level leading comments (comments before first statement)
+        if file_leading_comments.any?
+          lines.concat(file_leading_comments)
+          lines << "" # Add blank line after file-level comments
+        end
+
         node_infos.each do |node_info|
+          # Add blank lines before this statement (for visual grouping)
+          blank_lines = node_info[:blank_lines_before] || 0
+          blank_lines.times { lines << "" }
+
           # Add leading comments
           node_info[:leading_comments].each do |comment|
             lines << comment.slice.rstrip

data/lib/kettle/dev/tasks/template_task.rb

@@ -282,88 +282,28 @@ module Kettle
                 end
 
                 if orig_meta
-                  # Replace a scalar string assignment like: spec.field = "..."
-                  replace_string_field = lambda do |txt, field, value|
-                    v = value.to_s
-                    txt.gsub(/(\bspec\.#{Regexp.escape(field)}\s*=\s*)(["']).*?(\2)/) do
-                      pre = Regexp.last_match(1)
-                      q = '"'
-                      pre + q + v.gsub('"', '\\"') + q
-                    end
+                  # Build replacements using AST-aware helper to carry over fields
+                  repl = {}
+                  if (name = orig_meta[:gem_name]) && !name.to_s.empty?
+                    repl[:name] = name.to_s
                   end
-
-                  # Replace an array assignment like: spec.field = ["a", "b"]
-                  replace_array_field = lambda do |txt, field, ary|
-                    ary = Array(ary).compact.map(&:to_s).reject(&:empty?).uniq
-                    # literal = "[" + arr.map { |e| '"' + e.gsub('"', '\\"') + '"' }.join(", ") + "]"
-                    literal = ary.inspect
-                    if txt =~ /(\bspec\.#{Regexp.escape(field)}\s*=\s*)\[[^\]]*\]/
-                      txt.gsub(/(\bspec\.#{Regexp.escape(field)}\s*=\s*)\[[^\]]*\]/, "\\1#{literal}")
-                    else
-                      # If no existing assignment, insert a new line after spec.version if possible
-                      insert_after = (txt =~ /^\s*spec\.version\s*=.*$/) ? :version : nil
-                      if insert_after == :version
-                        txt.sub(/^(\s*spec\.version\s*=.*$)/) { |line| line + "\n  spec.#{field} = #{literal}" }
-                      else
-                        txt + "\n  spec.#{field} = #{literal}\n"
-                      end
-                    end
+                  repl[:authors] = Array(orig_meta[:authors]).map(&:to_s) if orig_meta[:authors]
+                  repl[:email] = Array(orig_meta[:email]).map(&:to_s) if orig_meta[:email]
+                  repl[:summary] = orig_meta[:summary].to_s if orig_meta[:summary]
+                  repl[:description] = orig_meta[:description].to_s if orig_meta[:description]
+                  repl[:licenses] = Array(orig_meta[:licenses]).map(&:to_s) if orig_meta[:licenses]
+                  if orig_meta[:required_ruby_version]
+                    repl[:required_ruby_version] = orig_meta[:required_ruby_version].to_s
                   end
+                  repl[:require_paths] = Array(orig_meta[:require_paths]).map(&:to_s) if orig_meta[:require_paths]
+                  repl[:bindir] = orig_meta[:bindir].to_s if orig_meta[:bindir]
+                  repl[:executables] = Array(orig_meta[:executables]).map(&:to_s) if orig_meta[:executables]
 
                   begin
-                    # 1. spec.name — retain original
-                    if (name = orig_meta[:gem_name]) && !name.to_s.empty?
-                      c = replace_string_field.call(c, "name", name)
-                    end
-
-                    # 2. spec.authors — retain original, normalize to array
-                    orig_auth = orig_meta[:authors]
-                    c = replace_array_field.call(c, "authors", orig_auth)
-
-                    # 3. spec.email — retain original, normalize to array
-                    orig_email = orig_meta[:email]
-                    c = replace_array_field.call(c, "email", orig_email)
-
-                    # 4. spec.summary — retain original; grapheme emoji prefix handled by "install" task
-                    if (sum = orig_meta[:summary]) && !sum.to_s.empty?
-                      c = replace_string_field.call(c, "summary", sum)
-                    end
-
-                    # 5. spec.description — retain original; grapheme emoji prefix handled by "install" task
-                    if (desc = orig_meta[:description]) && !desc.to_s.empty?
-                      c = replace_string_field.call(c, "description", desc)
-                    end
-
-                    # 6. spec.licenses — retain original, normalize to array
-                    lic = orig_meta[:licenses]
-                    if lic && !lic.empty?
-                      c = replace_array_field.call(c, "licenses", lic)
-                    end
-
-                    # 7. spec.required_ruby_version — retain original
-                    if (rrv = orig_meta[:required_ruby_version].to_s) && !rrv.empty?
-                      c = replace_string_field.call(c, "required_ruby_version", rrv)
-                    end
-
-                    # 8. spec.require_paths — retain original, normalize to array
-                    req_paths = orig_meta[:require_paths]
-                    unless req_paths.empty?
-                      c = replace_array_field.call(c, "require_paths", req_paths)
-                    end
-
-                    # 9. spec.bindir — retain original
-                    if (bd = orig_meta[:bindir]) && !bd.to_s.empty?
-                      c = replace_string_field.call(c, "bindir", bd)
-                    end
-
-                    # 10. spec.executables — retain original, normalize to array
-                    exes = orig_meta[:executables]
-                    unless exes.empty?
-                      c = replace_array_field.call(c, "executables", exes)
-                    end
+                    c = Kettle::Dev::PrismGemspec.replace_gemspec_fields(c, repl)
                   rescue StandardError => e
                     Kettle::Dev.debug_error(e, __method__)
-                    # Best-effort carry-over; ignore any individual failure
+                    # Best-effort carry-over; ignore failure and keep c as-is
                   end
                 end
 
@@ -373,15 +313,11 @@ module Kettle
                 # Strip any dependency lines that name the destination gem.
                 begin
                   if gem_name && !gem_name.to_s.empty?
-                    name_escaped = Regexp.escape(gem_name)
-                    # Matches both runtime and development dependency lines, with or without parentheses.
-                    # Examples matched:
-                    #   spec.add_dependency("my-gem", "~> 1.0")
-                    #   spec.add_dependency 'my-gem'
-                    #   spec.add_development_dependency "my-gem"
-                    #   spec.add_development_dependency 'my-gem', ">= 0"
-                    self_dep_re = /\A\s*spec\.add_(?:development_)?dependency(?:\s*\(|\s+)\s*["']#{name_escaped}["'][^\n]*\)?\s*\z/
-                    c = c.lines.reject { |ln| self_dep_re =~ ln }.join
+                    begin
+                      c = Kettle::Dev::PrismGemspec.remove_spec_dependency(c, gem_name)
+                    rescue StandardError => e
+                      Kettle::Dev.debug_error(e, __method__)
+                    end
                   end
                 rescue StandardError => e
                   Kettle::Dev.debug_error(e, __method__)