kettle-dev 1.2.3 → 2.0.0

data/lib/kettle/dev/prism_gemspec.rb

@@ -1,284 +0,0 @@
-# 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

@@ -1,201 +0,0 @@
-# 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/rakelib/install.rake

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-namespace :kettle do
-  namespace :dev do
-    desc "Install kettle-dev GitHub automation and setup hints into the current project"
-    task :install do
-      Kettle::Dev::Tasks::InstallTask.run
-    end
-  end
-end

data/lib/kettle/dev/rakelib/template.rake

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-namespace :kettle do
-  namespace :dev do
-    desc "Template kettle-dev files into the current project"
-    task :template do
-      Kettle::Dev::Tasks::TemplateTask.run
-    end
-  end
-end