bash-merge 2.0.5 → 7.1.1

data/lib/bash/merge/comment_tracker.rb

@@ -5,6 +5,10 @@ module Bash
     # Extracts and tracks comments with their line numbers from Bash source.
     # Bash comments use the # syntax, making freeze block detection straightforward.
     #
+    # Inherits shared lookup, query, region-building, and attachment API from
+    # +Ast::Merge::Comment::HashTrackerBase+. Only format-specific comment
+    # extraction, shebang detection, and owner resolution are overridden here.
+    #
     # @example Basic usage
     #   tracker = CommentTracker.new(bash_source)
     #   tracker.comments # => [{line: 1, indent: 0, text: "This is a comment"}]
@@ -13,91 +17,14 @@ module Bash
     # @example Comment types
     #   # Full-line comment
     #   command # Inline comment
-    class CommentTracker
-      # Regex to match full-line comments (line is only whitespace + comment)
-      FULL_LINE_COMMENT_REGEX = /\A(\s*)#\s?(.*)\z/
-
-      # Regex to match inline comments (comment after Bash content)
-      # Note: This is simplified and doesn't handle all edge cases like comments in strings
-      INLINE_COMMENT_REGEX = /\s+#\s?(.*)$/
-
-      # @return [Array<Hash>] All extracted comments with metadata
-      attr_reader :comments
-
-      # @return [Array<String>] Source lines
-      attr_reader :lines
-
+    class CommentTracker < Ast::Merge::Comment::HashTrackerBase
       # Initialize comment tracker by scanning the source
       #
       # @param source [String] Bash source code
       def initialize(source)
         @source = source
-        @lines = source.lines.map(&:chomp)
-        @comments = extract_comments
-        @comments_by_line = @comments.group_by { |c| c[:line] }
-      end
-
-      # Get comment at a specific line
-      #
-      # @param line_num [Integer] 1-based line number
-      # @return [Hash, nil] Comment info or nil
-      def comment_at(line_num)
-        @comments_by_line[line_num]&.first
-      end
-
-      # Get all comments in a line range
-      #
-      # @param range [Range] Range of 1-based line numbers
-      # @return [Array<Hash>] Comments in the range
-      def comments_in_range(range)
-        @comments.select { |c| range.cover?(c[:line]) }
-      end
-
-      # Get leading comments before a line (consecutive comment lines immediately above)
-      #
-      # @param line_num [Integer] 1-based line number
-      # @return [Array<Hash>] Leading comments
-      def leading_comments_before(line_num)
-        leading = []
-        current = line_num - 1
-
-        while current >= 1
-          comment = comment_at(current)
-          break unless comment && comment[:full_line]
-
-          leading.unshift(comment)
-          current -= 1
-        end
-
-        leading
-      end
-
-      # Get trailing comment on the same line (inline comment)
-      #
-      # @param line_num [Integer] 1-based line number
-      # @return [Hash, nil] Inline comment or nil
-      def inline_comment_at(line_num)
-        comment = comment_at(line_num)
-        comment if comment && !comment[:full_line]
-      end
-
-      # Check if a line is a full-line comment
-      #
-      # @param line_num [Integer] 1-based line number
-      # @return [Boolean]
-      def full_line_comment?(line_num)
-        comment = comment_at(line_num)
-        comment&.dig(:full_line) || false
-      end
-
-      # Check if a line is blank
-      #
-      # @param line_num [Integer] 1-based line number
-      # @return [Boolean]
-      def blank_line?(line_num)
-        return false if line_num < 1 || line_num > @lines.length
-
-        @lines[line_num - 1].strip.empty?
+        @line_parser = Ast::Merge::Comment::QuotedHashLineParser.new
+        super(source.lines.map(&:chomp))
       end
 
       # Check if a line is a shebang
@@ -107,7 +34,19 @@ module Bash
       def shebang?(line_num)
         return false if line_num < 1 || line_num > @lines.length
 
-        @lines[line_num - 1].start_with?("#!")
+        @lines[line_num - 1].start_with?('#!')
+      end
+
+      def augment(owners: [], **options)
+        Ast::Merge::Comment::Augmenter.new(
+          lines: @lines,
+          comments: @comments,
+          owners: owners,
+          style: :hash_comment,
+          total_comment_count: @comments.size,
+          inline_comment_count: @comments.count { |comment| !comment[:full_line] },
+          **options
+        )
       end
 
       private
@@ -119,30 +58,27 @@ module Bash
           line_num = idx + 1
 
           # Skip shebang lines
-          next if line.start_with?("#!")
+          next if line.start_with?('#!')
+
+          parsed = @line_parser.parse(line)
+          next unless parsed
 
-          # Check for full-line comment
-          if (match = line.match(FULL_LINE_COMMENT_REGEX))
+          if parsed.full_line?
             comments << {
               line: line_num,
-              indent: match[1].length,
-              text: match[2],
+              indent: parsed.indent,
+              text: parsed.text,
               full_line: true,
-              raw: line,
+              raw: parsed.raw
+            }
+          elsif parsed.inline?
+            comments << {
+              line: line_num,
+              indent: 0,
+              text: parsed.text,
+              full_line: false,
+              raw: parsed.raw
             }
-          # Check for inline comment (simplified - doesn't handle quotes)
-          elsif line.include?(" #") && !line.strip.start_with?("#")
-            # Try to extract inline comment, but be careful with strings
-            # This is a simplified approach
-            if (inline_match = line.match(INLINE_COMMENT_REGEX))
-              comments << {
-                line: line_num,
-                indent: 0,
-                text: inline_match[1],
-                full_line: false,
-                raw: "# #{inline_match[1]}",
-              }
-            end
           end
         end
 

data/lib/bash/merge/debug_logger.rb

@@ -15,25 +15,25 @@ module Bash
       extend Ast::Merge::DebugLogger
 
       # Bash-specific configuration
-      self.env_var_name = "BASH_MERGE_DEBUG"
-      self.log_prefix = "[Bash::Merge]"
+      self.env_var_name = 'BASH_MERGE_DEBUG'
+      self.log_prefix = '[Bash::Merge]'
 
       class << self
         # Override log_node to handle Bash-specific node types.
         #
         # @param node [Object] Node to log information about
         # @param label [String] Label for the node
-        def log_node(node, label: "Node")
+        def log_node(node, label: 'Node')
           return unless enabled?
 
           info = case node
-          when Bash::Merge::FreezeNode
-            {type: "FreezeNode", lines: "#{node.start_line}..#{node.end_line}"}
-          when Bash::Merge::NodeWrapper
-            {type: node.type.to_s, lines: "#{node.start_line}..#{node.end_line}"}
-          else
-            extract_node_info(node)
-          end
+                 when Bash::Merge::FreezeNode
+                   { type: 'FreezeNode', lines: "#{node.start_line}..#{node.end_line}" }
+                 when Bash::Merge::NodeWrapper
+                   { type: node.type.to_s, lines: "#{node.start_line}..#{node.end_line}" }
+                 else
+                   extract_node_info(node)
+                 end
 
           debug(label, info)
         end

data/lib/bash/merge/emitter.rb

@@ -13,21 +13,27 @@ module Bash
     #   emitter.emit_comment("This is a comment")
     #   emitter.emit_line("echo 'hello'")
     class Emitter < Ast::Merge::EmitterBase
+      include Ast::Merge::EmitterLineMetadataSupport
+
       # Initialize subclass-specific state
-      def initialize_subclass_state(**options)
-        # Bash doesn't need separator tracking like JSON
+      def initialize_subclass_state(**_options)
+        initialize_line_metadata_state
       end
 
       # Clear subclass-specific state
       def clear_subclass_state
-        # Nothing to clear for Bash
+        clear_line_metadata_state
+      end
+
+      def emit_blank_line
+        append_line('')
       end
 
       # Emit a tracked comment from CommentTracker
       # @param comment [Hash] Comment with :text, :indent
       def emit_tracked_comment(comment)
-        indent = " " * (comment[:indent] || 0)
-        @lines << "#{indent}# #{comment[:text]}"
+        indent = ' ' * (comment[:indent] || 0)
+        append_line("#{indent}# #{comment[:text]}")
       end
 
       # Emit a comment line
@@ -41,15 +47,15 @@ module Bash
 
           @lines[-1] = "#{@lines[-1]} # #{text}"
         else
-          @lines << "#{current_indent}# #{text}"
+          append_line("#{current_indent}# #{text}")
         end
       end
 
       # Emit a shebang line
       #
       # @param interpreter [String] Interpreter path (e.g., "/bin/bash")
-      def emit_shebang(interpreter = "/bin/bash")
-        @lines << "#!#{interpreter}"
+      def emit_shebang(interpreter = '/bin/bash', metadata: nil)
+        append_line("#!#{interpreter}", metadata)
       end
 
       # Emit a variable assignment
@@ -58,113 +64,119 @@ module Bash
       # @param value [String] Variable value
       # @param export [Boolean] Whether to export the variable
       # @param inline_comment [String, nil] Optional inline comment
-      def emit_variable_assignment(name, value, export: false, inline_comment: nil)
-        prefix = export ? "export " : ""
+      def emit_variable_assignment(name, value, export: false, inline_comment: nil, metadata: nil)
+        prefix = export ? 'export ' : ''
         line = "#{current_indent}#{prefix}#{name}=#{value}"
         line += " # #{inline_comment}" if inline_comment
-        @lines << line
+        append_line(line, metadata)
       end
 
       # Emit a function definition start
       #
       # @param name [String] Function name
-      def emit_function_start(name)
-        @lines << "#{current_indent}#{name}() {"
+      def emit_function_start(name, metadata: nil)
+        append_line("#{current_indent}#{name}() {", metadata)
         indent
       end
 
       # Emit a function definition end
       def emit_function_end
         dedent
-        @lines << "#{current_indent}}"
+        append_line("#{current_indent}}")
       end
 
       # Emit an if statement start
       #
       # @param condition [String] Condition expression
-      def emit_if_start(condition)
-        @lines << "#{current_indent}if #{condition}; then"
+      def emit_if_start(condition, metadata: nil)
+        append_line("#{current_indent}if #{condition}; then", metadata)
         indent
       end
 
       # Emit an elif clause
       #
       # @param condition [String] Condition expression
-      def emit_elif(condition)
+      def emit_elif(condition, metadata: nil)
         dedent
-        @lines << "#{current_indent}elif #{condition}; then"
+        append_line("#{current_indent}elif #{condition}; then", metadata)
         indent
       end
 
       # Emit an else clause
       def emit_else
         dedent
-        @lines << "#{current_indent}else"
+        append_line("#{current_indent}else")
         indent
       end
 
       # Emit an if statement end
       def emit_fi
         dedent
-        @lines << "#{current_indent}fi"
+        append_line("#{current_indent}fi")
       end
 
       # Emit a for loop start
       #
       # @param var [String] Loop variable name
       # @param items [String] Items to iterate over
-      def emit_for_start(var, items)
-        @lines << "#{current_indent}for #{var} in #{items}; do"
+      def emit_for_start(var, items, metadata: nil)
+        append_line("#{current_indent}for #{var} in #{items}; do", metadata)
         indent
       end
 
       # Emit a for/while loop end
       def emit_done
         dedent
-        @lines << "#{current_indent}done"
+        append_line("#{current_indent}done")
       end
 
       # Emit a while loop start
       #
       # @param condition [String] Condition expression
-      def emit_while_start(condition)
-        @lines << "#{current_indent}while #{condition}; do"
+      def emit_while_start(condition, metadata: nil)
+        append_line("#{current_indent}while #{condition}; do", metadata)
         indent
       end
 
       # Emit a case statement start
       #
       # @param expression [String] Expression to match
-      def emit_case_start(expression)
-        @lines << "#{current_indent}case #{expression} in"
+      def emit_case_start(expression, metadata: nil)
+        append_line("#{current_indent}case #{expression} in", metadata)
         indent
       end
 
       # Emit a case pattern
       #
       # @param pattern [String] Pattern to match
-      def emit_case_pattern(pattern)
-        @lines << "#{current_indent}#{pattern})"
+      def emit_case_pattern(pattern, metadata: nil)
+        append_line("#{current_indent}#{pattern})", metadata)
         indent
       end
 
       # Emit a case pattern terminator
       def emit_case_pattern_end
         dedent
-        @lines << "#{current_indent};;"
+        append_line("#{current_indent};;")
       end
 
       # Emit a case statement end
       def emit_esac
         dedent
-        @lines << "#{current_indent}esac"
+        append_line("#{current_indent}esac")
       end
 
       # Emit a raw line of code
       #
       # @param line [String] Line to emit
-      def emit_line(line)
-        @lines << "#{current_indent}#{line}"
+      def emit_line(line, metadata: nil)
+        append_line("#{current_indent}#{line}", metadata)
+      end
+
+      def emit_raw_lines(raw_lines, metadata: nil)
+        raw_lines.each_with_index do |line, idx|
+          append_line(line.chomp, expanded_line_metadata(metadata, idx))
+        end
       end
 
       # Get the output as a Bash string

data/lib/bash/merge/file_analysis.rb

@@ -14,7 +14,7 @@ module Bash
       include Ast::Merge::FileAnalyzable
 
       # Default freeze token for identifying freeze blocks
-      DEFAULT_FREEZE_TOKEN = "bash-merge"
+      DEFAULT_FREEZE_TOKEN = 'bash-merge'
 
       # @return [CommentTracker] Comment tracker for this file
       attr_reader :comment_tracker
@@ -42,12 +42,12 @@ module Bash
       # @param signature_generator [Proc, nil] Custom signature generator
       # @param parser_path [String, nil] Path to tree-sitter-bash parser library
       # @param options [Hash] Additional options (forward compatibility - ignored by FileAnalysis)
-      def initialize(source, freeze_token: DEFAULT_FREEZE_TOKEN, signature_generator: nil, parser_path: nil, **options)
+      def initialize(source, freeze_token: DEFAULT_FREEZE_TOKEN, signature_generator: nil, parser_path: nil, **_options)
         @source = source
         @lines = source.lines.map(&:chomp)
         @freeze_token = freeze_token
         @signature_generator = signature_generator
-        @parser_path = parser_path || self.class.find_parser_path
+        @parser_path = parser_path
         @errors = []
         # **options captures any additional parameters (e.g., node_typing) for forward compatibility
 
@@ -55,18 +55,18 @@ module Bash
         @comment_tracker = CommentTracker.new(source)
 
         # Parse the Bash script
-        DebugLogger.time("FileAnalysis#parse_bash") { parse_bash }
+        DebugLogger.time('FileAnalysis#parse_bash') { parse_bash }
 
         # Extract freeze blocks and integrate with nodes
         @freeze_blocks = extract_freeze_blocks
         @nodes = integrate_nodes_and_freeze_blocks
 
-        DebugLogger.debug("FileAnalysis initialized", {
-          signature_generator: signature_generator ? "custom" : "default",
-          nodes_count: @nodes.size,
-          freeze_blocks: @freeze_blocks.size,
-          valid: valid?,
-        })
+        DebugLogger.debug('FileAnalysis initialized', {
+                            signature_generator: signature_generator ? 'custom' : 'default',
+                            nodes_count: @nodes.size,
+                            freeze_blocks: @freeze_blocks.size,
+                            valid: valid?
+                          })
       end
 
       # Check if parse was successful
@@ -75,14 +75,102 @@ module Bash
         @errors.empty? && !@ast.nil?
       end
 
+      # Get shared comment capability information for this analysis.
+      #
+      # @return [Ast::Merge::Comment::Capability]
+      def comment_capability
+        @comment_capability ||= comment_tracker.augment(owners: []).capability
+      end
+
+      # Describe how Bash merges currently own and emit comments.
+      #
+      # Bash comment handling is fully source-augmented and emitted through the
+      # synthetic merge layer.
+      #
+      # @return [Ast::Merge::Comment::SupportStyle]
+      def comment_support_style
+        @comment_support_style ||= shared_comment_support_style(
+          source: :bash_source,
+          style: :hash_comment,
+          read_strategy: :source_augmented_portable_write
+        )
+      end
+
+      # Get all tracked comments converted to shared Ast::Merge comment nodes.
+      #
+      # @return [Array<Ast::Merge::Comment::Line>]
+      def comment_nodes
+        comment_tracker.comment_nodes
+      end
+
+      # Get a shared Ast::Merge comment node at a specific line.
+      #
+      # @param line_num [Integer] 1-based line number
+      # @return [Ast::Merge::Comment::Line, nil]
+      def comment_node_at(line_num)
+        comment_tracker.comment_node_at(line_num)
+      end
+
+      # Get comments in a line range converted to a shared comment region.
+      #
+      # @param range [Range] Range of 1-based line numbers
+      # @param kind [Symbol] Region kind (:leading, :inline, :orphan, etc.)
+      # @param full_line_only [Boolean] Whether to keep only full-line comments
+      # @return [Ast::Merge::Comment::Region]
+      def comment_region_for_range(range, kind:, full_line_only: false)
+        comment_tracker.comment_region_for_range(
+          range,
+          kind: kind,
+          full_line_only: full_line_only
+        )
+      end
+
+      # Build a passive shared comment attachment for an owner.
+      #
+      # @param owner [Object] Structural owner for the attachment
+      # @param options [Hash] Additional metadata / lookup overrides
+      # @return [Ast::Merge::Comment::Attachment]
+      def comment_attachment_for(owner, **options)
+        shared_comment_attachment_for(
+          owner,
+          tracker_attachment: comment_tracker.comment_attachment_for(owner, **options),
+          **options
+        )
+      end
+
+      # @return [Symbol]
+      def comment_attachment_strategy
+        :augmenter_preferred_tracker_layout
+      end
+
+      def ruleset_owner_selector
+        :line_bound_statements
+      end
+
+      def ruleset_render_family
+        :bash_script_statements
+      end
+
+      # Build a passive shared comment augmenter for this analysis.
+      #
+      # @param owners [Array<#start_line,#end_line>, nil] Owners used for attachment inference
+      # @param options [Hash] Additional augmenter options
+      # @return [Ast::Merge::Comment::Augmenter]
+      def comment_augmenter(owners: nil, **options)
+        comment_tracker.augment(
+          owners: owners || comment_augmenter_default_owners,
+          **options
+        )
+      end
+
       # The base module uses 'statements' - provide both names for compatibility
       # @return [Array<NodeWrapper, FreezeNodeBase>]
       def statements
-        @nodes ||= []
+        @nodes || []
       end
 
       # Alias for convenience - bash-merge prefers "nodes" terminology
-      alias_method :nodes, :statements
+      alias nodes statements
 
       # Check if a line is within a freeze block.
       #
@@ -120,30 +208,42 @@ module Bash
       def top_level_statements
         return [] unless valid?
 
-        root = @ast.root_node
-        return [] unless root
-
-        statements = []
-        root.each do |child|
-          next if child.type.to_s == "comment" # Comments handled separately
-
-          statements << NodeWrapper.new(child, lines: @lines, source: @source)
+        @top_level_statements ||= begin
+          root = @ast.root_node
+          if root
+            statements = []
+            root.each do |child|
+              next if child.type.to_s == 'comment' # Comments handled separately
+
+              statements << NodeWrapper.new(child, lines: @lines, source: @source)
+            end
+            statements
+          else
+            []
+          end
         end
-        statements
       end
 
       private
 
       def parse_bash
-        # TreeHaver handles grammar discovery and backend selection
+        # TreeHaver handles backend selection against the grammars Bash::Merge
+        # has already registered during bootstrap.
         # Set TREE_HAVER_BACKEND=ffi for bash (MRI/Rust have compatibility issues)
-        parser = TreeHaver.parser_for(:bash, library_path: @parser_path)
+        parser = if @parser_path
+                   TreeHaver.with_language_registration(
+                     :bash,
+                     :tree_sitter,
+                     path: @parser_path,
+                     symbol: TreeHaver::GrammarFinder.new(:bash).symbol_name
+                   ) { TreeHaver.parser_for(:bash, backend_type: :tree_sitter) }
+                 else
+                   TreeHaver.parser_for(:bash, backend_type: :tree_sitter)
+                 end
         @ast = parser.parse(@source)
 
         # Check for parse errors in the tree
-        if @ast&.root_node&.has_error?
-          collect_parse_errors(@ast.root_node)
-        end
+        collect_parse_errors(@ast.root_node) if @ast&.root_node&.has_error?
       rescue TreeHaver::Error => e
         # TreeHaver::Error inherits from Exception, not StandardError.
         # This also catches TreeHaver::NotAvailable (subclass of Error).
@@ -156,12 +256,12 @@ module Bash
 
       def collect_parse_errors(node)
         # Collect ERROR and MISSING nodes from the tree
-        if node.type.to_s == "ERROR" || node.missing?
+        if node.type.to_s == 'ERROR' || node.missing?
           @errors << {
             type: node.type.to_s,
             start_point: node.start_point,
             end_point: node.end_point,
-            text: node.to_s,
+            text: node.to_s
           }
         end
 
@@ -180,10 +280,10 @@ module Bash
           next unless (match = line.match(freeze_pattern))
 
           marker_type = match[1]&.downcase # 'freeze' or 'unfreeze'
-          if marker_type == "freeze"
-            freeze_starts << {line: line_num, marker: line}
-          elsif marker_type == "unfreeze"
-            freeze_ends << {line: line_num, marker: line}
+          if marker_type == 'freeze'
+            freeze_starts << { line: line_num, marker: line }
+          elsif marker_type == 'unfreeze'
+            freeze_ends << { line: line_num, marker: line }
           end
         end
 
@@ -202,7 +302,7 @@ module Bash
             end_line: matching_end[:line],
             lines: @lines,
             start_marker: start_info[:marker],
-            end_marker: matching_end[:marker],
+            end_marker: matching_end[:marker]
           )
         end