markdown-merge 1.0.3 → 7.0.0

data/lib/markdown/merge/whitespace_normalizer.rb

@@ -1,251 +0,0 @@
-# frozen_string_literal: true
-
-module Markdown
-  module Merge
-    # Normalizes whitespace in markdown documents.
-    #
-    # Supports multiple normalization modes:
-    # - `:basic` (or `true`) - Collapse excessive blank lines (3+ → 2)
-    # - `:link_refs` - Also remove blank lines between consecutive link reference definitions
-    # - `:strict` - All of the above normalizations
-    #
-    # Uses {LinkParser} for detecting link reference definitions, which supports:
-    # - Standard definitions: `[label]: url`
-    # - Definitions with titles: `[label]: url "title"`
-    # - Angle-bracketed URLs: `[label]: <url>`
-    # - Emoji in labels: `[🎨logo]: url`
-    #
-    # @example Basic normalization (default)
-    #   content = "Hello\n\n\n\nWorld"
-    #   normalized = WhitespaceNormalizer.normalize(content)
-    #   # => "Hello\n\nWorld"
-    #
-    # @example With link_refs mode
-    #   content = "[link1]: url1\n\n[link2]: url2"
-    #   normalized = WhitespaceNormalizer.normalize(content, mode: :link_refs)
-    #   # => "[link1]: url1\n[link2]: url2"
-    #
-    # @example With problem tracking
-    #   normalizer = WhitespaceNormalizer.new(content, mode: :link_refs)
-    #   result = normalizer.normalize
-    #   normalizer.problems.by_category(:link_ref_spacing)
-    #
-    class WhitespaceNormalizer
-      # Valid normalization modes
-      MODES = %i[basic link_refs strict].freeze
-
-      # @return [String] The original content
-      attr_reader :content
-
-      # @return [Symbol] The normalization mode
-      attr_reader :mode
-
-      # @return [DocumentProblems] Problems found during normalization
-      attr_reader :problems
-
-      class << self
-        # Normalize whitespace in content (class method for convenience).
-        #
-        # @param content [String] Content to normalize
-        # @param mode [Symbol, Boolean] Normalization mode (:basic, :link_refs, :strict, or true for :basic)
-        # @return [String] Normalized content
-        def normalize(content, mode: :basic)
-          new(content, mode: mode).normalize
-        end
-      end
-
-      # Initialize a new normalizer.
-      #
-      # @param content [String] Content to normalize
-      # @param mode [Symbol, Boolean] Normalization mode (:basic, :link_refs, :strict, or true for :basic)
-      def initialize(content, mode: :basic)
-        @content = content
-        @mode = normalize_mode(mode)
-        @problems = DocumentProblems.new
-        @link_parser = LinkParser.new
-      end
-
-      # Normalize whitespace based on the configured mode.
-      #
-      # @return [String] Normalized content
-      def normalize
-        result = content.dup
-
-        # Always collapse excessive blank lines (3+ → 2)
-        result = collapse_excessive_blank_lines(result)
-
-        # Remove blank lines between link refs if mode requires it
-        if @mode == :link_refs || @mode == :strict
-          result = remove_blank_lines_between_link_refs(result)
-        end
-
-        result
-      end
-
-      # Check if normalization made any changes.
-      #
-      # @return [Boolean] true if content had whitespace issues
-      def changed?
-        !@problems.empty?
-      end
-
-      # Get count of normalizations performed.
-      #
-      # @return [Integer] Number of whitespace issues fixed
-      def normalization_count
-        @problems.count
-      end
-
-      private
-
-      # Normalize mode parameter to a symbol.
-      #
-      # @param mode [Symbol, Boolean] Input mode
-      # @return [Symbol] Normalized mode
-      def normalize_mode(mode)
-        case mode
-        when true
-          :basic
-        when false
-          :basic  # Still do basic normalization
-        when Symbol
-          raise ArgumentError, "Unknown mode: #{mode}. Valid modes: #{MODES.join(", ")}" unless MODES.include?(mode)
-
-          mode
-        else
-          raise ArgumentError, "Mode must be a Symbol or Boolean, got: #{mode.class}"
-        end
-      end
-
-      # Collapse 3+ consecutive newlines to 2.
-      #
-      # This detects runs of blank lines (empty lines) and collapses them.
-      # Note: A blank line is a line containing only whitespace.
-      # 3+ consecutive newlines means 2+ blank lines.
-      #
-      # @param text [String] Text to process
-      # @return [String] Processed text
-      def collapse_excessive_blank_lines(text)
-        lines = text.lines
-        result = []
-        consecutive_blank_count = 0
-        problem_start_line = nil
-        line_number = 0
-
-        lines.each do |line|
-          line_number += 1
-
-          if line.chomp.empty?
-            consecutive_blank_count += 1
-            # The problem starts at the line BEFORE the first blank line
-            # (i.e., the line that ends with the first \n of the excessive sequence)
-            problem_start_line ||= line_number - 1
-
-            # Only add up to 1 blank line (which creates the standard paragraph gap)
-            if consecutive_blank_count <= 1
-              result << line
-            end
-            # Skip adding lines when consecutive_blank_count >= 2
-          else
-            # Record problem if we had 2+ blank lines (which means 3+ newlines)
-            # consecutive_blank_count is the count of blank lines, so >= 2 means excessive
-            if consecutive_blank_count >= 2
-              @problems.add(
-                :excessive_whitespace,
-                severity: :warning,
-                line: problem_start_line,
-                newline_count: consecutive_blank_count + 1, # +1 because first line ends with \n too
-                collapsed_to: 2,
-              )
-            end
-
-            consecutive_blank_count = 0
-            problem_start_line = nil
-            result << line
-          end
-        end
-
-        # Handle trailing blank lines
-        if consecutive_blank_count >= 2
-          @problems.add(
-            :excessive_whitespace,
-            severity: :warning,
-            line: problem_start_line,
-            newline_count: consecutive_blank_count + 1,
-            collapsed_to: 2,
-          )
-        end
-
-        result.join
-      end
-
-      # Remove blank lines between consecutive link reference definitions.
-      #
-      # Uses {LinkParser} to detect link definitions, supporting:
-      # - Standard: `[label]: url`
-      # - With title: `[label]: url "title"`
-      # - Angle-bracketed: `[label]: <url>`
-      # - Emoji labels: `[🎨logo]: url`
-      #
-      # @param text [String] Text to process
-      # @return [String] Processed text
-      def remove_blank_lines_between_link_refs(text)
-        lines = text.lines
-        result = []
-        i = 0
-
-        while i < lines.length
-          line = lines[i]
-          result << line
-
-          # Check if current line is a link ref definition using LinkParser
-          if link_definition_line?(line)
-            # Look ahead for blank lines followed by another link ref
-            j = i + 1
-            while j < lines.length
-              next_line = lines[j]
-              if next_line.chomp.empty?
-                # Check if there's a link ref definition after the blank line(s)
-                k = j + 1
-                while k < lines.length && lines[k].chomp.empty?
-                  k += 1
-                end
-                if k < lines.length && link_definition_line?(lines[k])
-                  # Skip all blank lines between link refs
-                  blanks_skipped = k - j
-                  @problems.add(
-                    :link_ref_spacing,
-                    severity: :info,
-                    line: j + 1,
-                    blank_lines_removed: blanks_skipped,
-                  )
-                  j = k
-                else
-                  # Not followed by a link ref, keep the blank line
-                  break
-                end
-              else
-                break
-              end
-            end
-            i = j
-          else
-            i += 1
-          end
-        end
-
-        result.join
-      end
-
-      # Check if a line is a link reference definition using LinkParser.
-      #
-      # @param line [String] Line to check
-      # @return [Boolean] true if line is a link definition
-      def link_definition_line?(line)
-        # Use LinkParser to attempt parsing the line as a definition
-        result = @link_parser.parse_definition_line(line.chomp)
-        !result.nil?
-      end
-    end
-  end
-end

data/sig/markdown/merge.rbs

@@ -1,341 +0,0 @@
-module Markdown
-  module Merge
-    VERSION: String
-
-    # Base error class for Markdown::Merge
-    class Error < Ast::Merge::Error
-    end
-
-    # Raised when a Markdown file has parsing errors
-    class ParseError < Ast::Merge::ParseError
-      def initialize: (?String? message, ?content: String?, ?errors: Array[untyped]) -> void
-    end
-
-    # Raised when the template file has syntax errors
-    class TemplateParseError < ParseError
-    end
-
-    # Raised when the destination file has syntax errors
-    class DestinationParseError < ParseError
-    end
-
-    # Debug logging utility for Markdown::Merge operations
-    module DebugLogger
-      extend Ast::Merge::DebugLogger
-
-      def self.env_var_name: () -> String
-      def self.env_var_name=: (String name) -> String
-      def self.log_prefix: () -> String
-      def self.log_prefix=: (String prefix) -> String
-      def self.enabled?: () -> bool
-      def self.debug: (*untyped args) -> void
-      def self.info: (*untyped args) -> void
-      def self.warning: (*untyped args) -> void
-      def self.time: [T] (String label) { () -> T } -> T
-      def self.log_node: (untyped node, ?label: String) -> void
-    end
-
-    # Represents a frozen block of Markdown content
-    class FreezeNode < Ast::Merge::FreezeNodeBase
-      def initialize: (
-        start_line: Integer,
-        end_line: Integer,
-        content: String,
-        start_marker: String,
-        end_marker: String,
-        ?nodes: Array[untyped],
-        ?reason: String?
-      ) -> void
-
-      def signature: () -> Array[Symbol | String]
-      def full_text: () -> String
-      def line_count: () -> Integer
-      def contains_type?: (Symbol type_symbol) -> bool
-      def inspect: () -> String
-    end
-
-    # Base class for file analysis for Markdown files
-    class FileAnalysisBase
-      include Ast::Merge::FileAnalyzable
-
-      DEFAULT_FREEZE_TOKEN: String
-
-      attr_reader document: untyped
-      attr_reader statements: Array[untyped]
-
-      def initialize: (
-        String source,
-        ?freeze_token: String,
-        ?signature_generator: (^(untyped) -> (Array[untyped] | untyped | nil))?,
-        **untyped parser_options
-      ) -> void
-
-      # Abstract methods - subclasses must implement
-      def parse_document: (String source) -> untyped
-      def next_sibling: (untyped node) -> untyped?
-
-      def valid?: () -> bool
-      def compute_node_signature: (untyped node) -> Array[untyped]?
-      def fallthrough_node?: (untyped value) -> bool
-      def parser_node?: (untyped value) -> bool
-      def compute_parser_signature: (untyped node) -> Array[untyped]?
-      def safe_string_content: (untyped node) -> String
-      def extract_text_content: (untyped node) -> String
-      def extract_table_header_content: (untyped node) -> String
-      def source_range: (Integer start_line, Integer end_line) -> String
-      def count_children: (untyped node) -> Integer
-
-      private
-
-      def extract_and_integrate_all_nodes: () -> Array[untyped]
-      def collect_top_level_nodes: () -> Array[untyped]
-      def build_freeze_blocks: (Array[untyped] nodes) -> Array[FreezeNode]
-      def integrate_freeze_blocks: (Array[untyped] nodes, Array[FreezeNode] freeze_blocks) -> Array[untyped]
-    end
-
-    # Aligns Markdown block elements between template and destination files
-    class FileAligner
-      attr_reader template_analysis: FileAnalysisBase
-      attr_reader dest_analysis: FileAnalysisBase
-      attr_reader match_refiner: (^(Array[untyped], Array[untyped], Hash[Symbol, untyped]) -> Array[MatchResult])?
-
-      def initialize: (
-        FileAnalysisBase template_analysis,
-        FileAnalysisBase dest_analysis,
-        ?match_refiner: (^(Array[untyped], Array[untyped], Hash[Symbol, untyped]) -> Array[MatchResult])?
-      ) -> void
-
-      def align: () -> Array[Hash[Symbol, untyped]]
-
-      private
-
-      def build_signature_map: (Array[untyped] statements, FileAnalysisBase analysis) -> Hash[Array[untyped], Array[Integer]]
-    end
-
-    # Match result from refiners
-    class MatchResult
-      attr_reader template_node: untyped
-      attr_reader dest_node: untyped
-      attr_reader score: Float
-
-      def initialize: (
-        template_node: untyped,
-        dest_node: untyped,
-        score: Float
-      ) -> void
-    end
-
-    # Resolves conflicts between matching Markdown elements
-    class ConflictResolver < Ast::Merge::ConflictResolverBase
-      def initialize: (
-        preference: Symbol,
-        template_analysis: FileAnalysisBase,
-        dest_analysis: FileAnalysisBase
-      ) -> void
-
-      private
-
-      def resolve_node_pair: (
-        untyped template_node,
-        untyped dest_node,
-        template_index: Integer,
-        dest_index: Integer
-      ) -> Hash[Symbol, untyped]
-
-      def content_identical?: (untyped template_node, untyped dest_node) -> bool
-      def node_to_text: (untyped node, FileAnalysisBase analysis) -> String
-    end
-
-    # Represents the result of a Markdown merge operation
-    class MergeResult < Ast::Merge::MergeResultBase
-      def initialize: (
-        content: String?,
-        ?conflicts: Array[Hash[Symbol, untyped]],
-        ?frozen_blocks: Array[Hash[Symbol, untyped]],
-        ?stats: Hash[Symbol, untyped]
-      ) -> void
-
-      def content: () -> String?
-      def content?: () -> bool
-      def content_string: () -> String?
-      def success?: () -> bool
-      def conflicts?: () -> bool
-      def has_frozen_blocks?: () -> bool
-      def nodes_added: () -> Integer
-      def nodes_removed: () -> Integer
-      def nodes_modified: () -> Integer
-      def merge_time_ms: () -> Float?
-      def frozen_count: () -> Integer
-      def inspect: () -> String
-      def to_s: () -> String
-
-      private
-
-      def default_stats: () -> Hash[Symbol, untyped]
-    end
-
-    # Algorithm for computing match scores between two Markdown tables
-    class TableMatchAlgorithm
-      DEFAULT_WEIGHTS: Hash[Symbol, Float]
-      FIRST_COLUMN_SIMILARITY_THRESHOLD: Float
-
-      attr_reader position_a: Integer?
-      attr_reader position_b: Integer?
-      attr_reader total_tables_a: Integer
-      attr_reader total_tables_b: Integer
-      attr_reader weights: Hash[Symbol, Float]
-
-      def initialize: (
-        ?position_a: Integer?,
-        ?position_b: Integer?,
-        ?total_tables_a: Integer,
-        ?total_tables_b: Integer,
-        ?weights: Hash[Symbol, Float]
-      ) -> void
-
-      def call: (untyped table_a, untyped table_b) -> Float
-
-      private
-
-      def levenshtein_distance: (String a, String b) -> Integer
-      def levenshtein_similarity: (String a, String b) -> Float
-      def extract_rows: (untyped table) -> Array[Array[String]]
-      def extract_cell_text: (untyped cell) -> String
-      def compute_header_match: (Array[Array[String]] rows_a, Array[Array[String]] rows_b) -> Float
-      def compute_first_column_match: (Array[Array[String]] rows_a, Array[Array[String]] rows_b) -> Float
-      def compute_row_content_match: (Array[Array[String]] rows_a, Array[Array[String]] rows_b) -> Float
-      def compute_total_cells_match: (Array[Array[String]] rows_a, Array[Array[String]] rows_b) -> Float
-      def compute_position_score: () -> Float
-      def weighted_average: (Hash[Symbol, Float] scores) -> Float
-    end
-
-    # Match refiner for Markdown tables that didn't match by exact signature
-    class TableMatchRefiner < Ast::Merge::MatchRefinerBase
-      attr_reader algorithm_options: Hash[Symbol, untyped]
-
-      def initialize: (
-        ?threshold: Float,
-        ?algorithm_options: Hash[Symbol, untyped],
-        **untyped options
-      ) -> void
-
-      def call: (
-        Array[untyped] template_nodes,
-        Array[untyped] dest_nodes,
-        ?Hash[Symbol, untyped] context
-      ) -> Array[MatchResult]
-
-      private
-
-      def extract_tables: (Array[untyped] nodes) -> Array[untyped]
-      def table_node?: (untyped node) -> bool
-      def compute_table_similarity: (
-        untyped t_table,
-        untyped d_table,
-        Integer t_idx,
-        Integer d_idx,
-        Integer total_t,
-        Integer total_d
-      ) -> Float
-    end
-
-    # Merges fenced code blocks using language-specific *-merge gems
-    class CodeBlockMerger
-      DEFAULT_MERGERS: Hash[String, ^(String, String, Symbol, **untyped) -> Hash[Symbol, untyped]]
-
-      attr_reader mergers: Hash[String, ^(String, String, Symbol, **untyped) -> Hash[Symbol, untyped]]
-      attr_reader enabled: bool
-
-      def initialize: (
-        ?mergers: Hash[String, ^(String, String, Symbol, **untyped) -> Hash[Symbol, untyped]],
-        ?enabled: bool
-      ) -> void
-
-      def supports_language?: (String? language) -> bool
-      def merge_code_blocks: (
-        untyped template_node,
-        untyped dest_node,
-        preference: Symbol,
-        **untyped opts
-      ) -> Hash[Symbol, untyped]
-
-      # Class methods for specific mergers
-      def self.merge_with_prism: (String template, String dest, Symbol preference, **untyped opts) -> Hash[Symbol, untyped]
-      def self.merge_with_psych: (String template, String dest, Symbol preference, **untyped opts) -> Hash[Symbol, untyped]
-      def self.merge_with_json: (String template, String dest, Symbol preference, **untyped opts) -> Hash[Symbol, untyped]
-      def self.merge_with_toml: (String template, String dest, Symbol preference, **untyped opts) -> Hash[Symbol, untyped]
-
-      private
-
-      def extract_language: (untyped node) -> String?
-      def extract_content: (untyped node) -> String
-      def rebuild_code_block: (String language, String content, untyped reference_node) -> String
-      def not_merged: (String reason) -> Hash[Symbol, untyped]
-    end
-
-    # Builds markdown output from merge operations
-    class OutputBuilder
-      @parts: Array[String]
-      @preserve_formatting: bool
-
-      def initialize: (?preserve_formatting: bool) -> void
-      def add_node_source: (untyped node, FileAnalysisBase analysis) -> void
-      def add_link_definition: (LinkDefinitionNode node) -> void
-      def add_gap_line: (?count: Integer) -> void
-      def add_raw: (String text) -> void
-      def to_s: () -> String
-      def empty?: () -> bool
-      def clear: () -> void
-
-      private
-
-      def extract_source: (untyped node, FileAnalysisBase analysis) -> String?
-      def extract_parser_node_source: (untyped node, FileAnalysisBase analysis) -> String?
-    end
-
-    # Formats link reference definitions for output
-    module LinkDefinitionFormatter
-      def self.format: (LinkDefinitionNode node) -> String
-      def self.format_all: (Array[LinkDefinitionNode] nodes, ?separator: String) -> String
-    end
-
-    # Base class for smart Markdown file merging
-    class SmartMergerBase
-      attr_reader template_analysis: FileAnalysisBase
-      attr_reader dest_analysis: FileAnalysisBase
-      attr_reader aligner: FileAligner
-      attr_reader resolver: ConflictResolver
-      attr_reader code_block_merger: CodeBlockMerger?
-
-      def initialize: (
-        String template_content,
-        String dest_content,
-        ?signature_generator: (^(untyped) -> (Array[untyped] | untyped | nil))?,
-        ?preference: Symbol,
-        ?add_template_only_nodes: bool,
-        ?inner_merge_code_blocks: (bool | CodeBlockMerger),
-        ?freeze_token: String,
-        ?match_refiner: (^(Array[untyped], Array[untyped], Hash[Symbol, untyped]) -> Array[MatchResult])?,
-        **untyped parser_options
-      ) -> void
-
-      # Abstract methods - subclasses must implement
-      def create_file_analysis: (String content, **untyped options) -> FileAnalysisBase
-      def node_to_source: (untyped node, FileAnalysisBase analysis) -> String
-
-      def template_parse_error_class: () -> Class
-      def destination_parse_error_class: () -> Class
-
-      def merge: () -> String
-      def merge_result: () -> MergeResult
-
-      private
-
-      def build_result_content: (Array[Hash[Symbol, untyped]] alignment) -> String
-      def process_alignment_entry: (Hash[Symbol, untyped] entry) -> String?
-      def handle_match: (Hash[Symbol, untyped] entry) -> String?
-      def handle_template_only: (Hash[Symbol, untyped] entry) -> String?
-      def handle_dest_only: (Hash[Symbol, untyped] entry) -> String?
-    end
-  end
-end