markdown-merge 1.0.3 → 7.1.1

data/lib/markdown/merge/table_match_algorithm.rb

@@ -35,7 +35,7 @@ module Markdown
         first_column: 0.20,      # (B) First column matching
         row_content: 0.25,       # (C) Content in matching rows
         total_cells: 0.15,       # (D) Overall cell matching
-        position: 0.15,          # (E) Position distance
+        position: 0.15 # (E) Position distance
       }.freeze
 
       # Minimum similarity threshold to consider cells as potentially matching
@@ -68,7 +68,8 @@ module Markdown
       # @param total_tables_b [Integer] Total tables in second document (default: 1)
       # @param weights [Hash] Custom weights for scoring factors
       # @param backend [Symbol] Markdown backend for type normalization (default: :commonmarker)
-      def initialize(position_a: nil, position_b: nil, total_tables_a: 1, total_tables_b: 1, weights: {}, backend: :commonmarker)
+      def initialize(position_a: nil, position_b: nil, total_tables_a: 1, total_tables_b: 1, weights: {},
+                     backend: :commonmarker)
         @position_a = position_a
         @position_b = position_b
         @total_tables_a = [total_tables_a, 1].max
@@ -93,7 +94,7 @@ module Markdown
           first_column: compute_first_column_match(rows_a, rows_b),
           row_content: compute_row_content_match(rows_a, rows_b),
           total_cells: compute_total_cells_match(rows_a, rows_b),
-          position: compute_position_score,
+          position: compute_position_score
         }
 
         weighted_average(scores)
@@ -113,9 +114,7 @@ module Markdown
         return str_a.length if str_b.empty?
 
         # Ensure str_a is the shorter string for space optimization
-        if str_a.length > str_b.length
-          str_a, str_b = str_b, str_a
-        end
+        str_a, str_b = str_b, str_a if str_a.length > str_b.length
 
         m = str_a.length
         n = str_b.length
@@ -128,11 +127,11 @@ module Markdown
           curr_row[0] = j
 
           (1..m).each do |i|
-            cost = (str_a[i - 1] == str_b[j - 1]) ? 0 : 1
+            cost = str_a[i - 1] == str_b[j - 1] ? 0 : 1
             curr_row[i] = [
               curr_row[i - 1] + 1,      # insertion
               prev_row[i] + 1,          # deletion
-              prev_row[i - 1] + cost,   # substitution
+              prev_row[i - 1] + cost # substitution
             ].min
           end
 
@@ -171,9 +170,7 @@ module Markdown
         rows = []
         child = table.first_child
         while child
-          if table_row_type?(child)
-            rows << extract_cells(child)
-          end
+          rows << extract_cells(child) if table_row_type?(child)
           child = next_sibling(child)
         end
         rows
@@ -196,7 +193,7 @@ module Markdown
 
         # Normalize the type using NodeTypeNormalizer for backend portability
         canonical = NodeTypeNormalizer.canonical_type(node.type, @backend || :commonmarker)
-        canonical == :table_row || canonical == :table_header
+        %i[table_row table_header].include?(canonical)
       end
 
       # Get the next sibling of a node.
@@ -231,9 +228,7 @@ module Markdown
         while child
           if child.respond_to?(:type)
             canonical = NodeTypeNormalizer.canonical_type(child.type, @backend || :commonmarker)
-            if canonical == :table_cell
-              cells << extract_text_content(child)
-            end
+            cells << extract_text_content(child) if canonical == :table_cell
           end
           child = next_sibling(child)
         end
@@ -271,14 +266,14 @@ module Markdown
         canonical_type = NodeTypeNormalizer.canonical_type(node.type, @backend || :commonmarker)
 
         # Collect text from text and code nodes
-        if canonical_type == :text || canonical_type == :code
+        if %i[text code].include?(canonical_type)
           content = if node.respond_to?(:string_content)
-            node.string_content.to_s
-          elsif node.respond_to?(:text)
-            node.text.to_s
-          else
-            ""
-          end
+                      node.string_content.to_s
+                    elsif node.respond_to?(:text)
+                      node.text.to_s
+                    else
+                      ''
+                    end
           text_parts << content unless content.empty?
         end
 
@@ -292,10 +287,10 @@ module Markdown
           while child
             collect_text_recursive(child, text_parts)
             child = if child.respond_to?(:next_sibling)
-              child.next_sibling
-            else
-              (child.respond_to?(:next) ? child.next : nil)
-            end
+                      child.next_sibling
+                    else
+                      (child.respond_to?(:next) ? child.next : nil)
+                    end
           end
         end
       end
@@ -354,7 +349,7 @@ module Markdown
 
         # Average over total cells
         total_cells = col_a.size + col_b.size
-        (total_cells > 0) ? total_similarity / total_cells : 0.0
+        total_cells > 0 ? total_similarity / total_cells : 0.0
       end
 
       # (C) Compute average match percentage for rows with matching first column.

data/lib/markdown/merge/table_match_refiner.rb

@@ -53,7 +53,7 @@ module Markdown
       # @param dest_nodes [Array] Unmatched nodes from destination
       # @param context [Hash] Additional context (may contain :template_analysis, :dest_analysis)
       # @return [Array<MatchResult>] Array of table matches
-      def call(template_nodes, dest_nodes, context = {})
+      def call(template_nodes, dest_nodes, _context = {})
         template_tables = extract_tables(template_nodes)
         dest_tables = extract_tables(dest_nodes)
 
@@ -89,23 +89,19 @@ module Markdown
       # @return [Boolean]
       def table_node?(node)
         # Check if it's a typed wrapper node first
-        if Ast::Merge::NodeTyping.typed_node?(node)
-          return Ast::Merge::NodeTyping.merge_type_for(node) == :table
-        end
+        return Ast::Merge::NodeTyping.merge_type_for(node) == :table if Ast::Merge::NodeTyping.typed_node?(node)
 
         # Check merge_type directly (wrapped nodes from NodeTypeNormalizer)
-        if node.respond_to?(:merge_type) && node.merge_type
-          return node.merge_type == :table
-        end
+        return node.merge_type == :table if node.respond_to?(:merge_type) && node.merge_type
 
         # Check raw type (string comparison for tree_haver nodes)
         if node.respond_to?(:type)
           node_type = node.type
-          return node_type == :table || node_type == "table" || node_type.to_s == "table"
+          return [:table, 'table'].include?(node_type) || node_type.to_s == 'table'
         end
 
         # Fallback: class name check
-        return true if node.class.name.to_s.include?("Table")
+        return true if node.class.name.to_s.include?('Table')
 
         false
       end
@@ -126,7 +122,7 @@ module Markdown
           total_tables_a: total_t,
           total_tables_b: total_d,
           backend: @backend,
-          **algorithm_options,
+          **algorithm_options
         )
 
         algorithm.call(t_table, d_table)

data/lib/markdown/merge/version.rb

@@ -2,11 +2,12 @@
 
 module Markdown
   module Merge
-    # Version information for Markdown::Merge
+    # Version namespace for this gem.
     module Version
-      # Current version of the markdown-merge gem
-      VERSION = "1.0.3"
+      # Current gem version.
+      VERSION = '7.1.1'
     end
-    VERSION = Version::VERSION # traditional location
+    # Current gem version exposed at the traditional constant location.
+    VERSION = Version::VERSION # Traditional Constant Location
   end
 end

data/lib/markdown/merge/whitespace_normalizer.rb

@@ -75,9 +75,7 @@ module Markdown
         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 = remove_blank_lines_between_link_refs(result) if @mode == :link_refs || @mode == :strict
 
         result
       end
@@ -107,9 +105,9 @@ module Markdown
         when true
           :basic
         when false
-          :basic  # Still do basic normalization
+          :basic # Still do basic normalization
         when Symbol
-          raise ArgumentError, "Unknown mode: #{mode}. Valid modes: #{MODES.join(", ")}" unless MODES.include?(mode)
+          raise ArgumentError, "Unknown mode: #{mode}. Valid modes: #{MODES.join(', ')}" unless MODES.include?(mode)
 
           mode
         else
@@ -142,9 +140,7 @@ module Markdown
             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
+            result << line if consecutive_blank_count <= 1
             # Skip adding lines when consecutive_blank_count >= 2
           else
             # Record problem if we had 2+ blank lines (which means 3+ newlines)
@@ -155,7 +151,7 @@ module Markdown
                 severity: :warning,
                 line: problem_start_line,
                 newline_count: consecutive_blank_count + 1, # +1 because first line ends with \n too
-                collapsed_to: 2,
+                collapsed_to: 2
               )
             end
 
@@ -172,7 +168,7 @@ module Markdown
             severity: :warning,
             line: problem_start_line,
             newline_count: consecutive_blank_count + 1,
-            collapsed_to: 2,
+            collapsed_to: 2
           )
         end
 
@@ -204,29 +200,25 @@ module Markdown
             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
+              break unless next_line.chomp.empty?
+
+              # Check if there's a link ref definition after the blank line(s)
+              k = j + 1
+              k += 1 while k < lines.length && lines[k].chomp.empty?
+              break unless 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
+
+              # Not followed by a link ref, keep the blank line
+
             end
             i = j
           else

data/lib/markdown/merge/wrapper_support.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module Markdown
+  module Merge
+    # Shared bootstrap helpers for backend-specific Markdown wrapper gems.
+    module WrapperSupport
+      SHARED_REEXPORTS = {
+        FileAligner: Markdown::Merge::FileAligner,
+        ConflictResolver: Markdown::Merge::ConflictResolver,
+        MergeResult: Markdown::Merge::MergeResult,
+        TableMatchAlgorithm: Markdown::Merge::TableMatchAlgorithm,
+        TableMatchRefiner: Markdown::Merge::TableMatchRefiner,
+        CodeBlockMerger: Markdown::Merge::CodeBlockMerger,
+        NodeTypeNormalizer: Markdown::Merge::NodeTypeNormalizer
+      }.freeze
+
+      WRAPPER_AUTOLOADS = {
+        DebugLogger: 'debug_logger',
+        CommentTracker: 'comment_tracker',
+        FreezeNode: 'freeze_node',
+        FileAnalysis: 'file_analysis',
+        PartialTemplateMerger: 'partial_template_merger',
+        SmartMerger: 'smart_merger',
+        Backend: 'backend'
+      }.freeze
+
+      module_function
+
+      def install!(
+        wrapper_module:,
+        require_prefix:,
+        default_freeze_token:,
+        default_inner_merge_code_blocks:,
+        registry_tag:,
+        merger_class:,
+        test_source: "# Test\n\nParagraph",
+        category: :markdown
+      )
+        define_error_classes!(wrapper_module)
+        define_constant_unless_present(wrapper_module, :DEFAULT_FREEZE_TOKEN, default_freeze_token)
+        define_constant_unless_present(wrapper_module, :DEFAULT_INNER_MERGE_CODE_BLOCKS,
+                                       default_inner_merge_code_blocks)
+
+        SHARED_REEXPORTS.each do |name, value|
+          define_constant_unless_present(wrapper_module, name, value)
+        end
+
+        WRAPPER_AUTOLOADS.each do |name, suffix|
+          next if wrapper_module.const_defined?(name, false) || wrapper_module.autoload?(name)
+
+          wrapper_module.send(:autoload, name, "#{require_prefix}/#{suffix}")
+        end
+
+        install_backend_loader!(wrapper_module)
+        register_merge_gem!(
+          registry_tag: registry_tag,
+          require_path: require_prefix,
+          merger_class: merger_class,
+          test_source: test_source,
+          category: category
+        )
+      end
+
+      def configure_debug_logger!(debug_logger_module:, env_var_name:, log_prefix:)
+        debug_logger_module.extend(Ast::Merge::DebugLogger)
+        debug_logger_module.env_var_name = env_var_name
+        debug_logger_module.log_prefix = log_prefix
+      end
+
+      def configure_file_analysis_subclass!(klass, default_backend:, default_parser_options: nil)
+        install_singleton_value_method!(klass, :default_backend, default_backend)
+        return unless default_parser_options
+
+        install_singleton_value_method!(klass, :default_parser_options,
+                                        default_parser_options)
+      end
+
+      def configure_smart_merger_subclass!(
+        klass,
+        default_backend:,
+        default_freeze_token: nil,
+        default_inner_merge_code_blocks: nil,
+        default_parser_options: nil,
+        file_analysis_class: nil,
+        template_parse_error_class: nil,
+        destination_parse_error_class: nil
+      )
+        install_singleton_value_method!(klass, :default_backend, default_backend)
+        install_singleton_value_method!(klass, :default_freeze_token, default_freeze_token) if default_freeze_token
+        unless default_inner_merge_code_blocks.nil?
+          install_singleton_value_method!(klass, :default_inner_merge_code_blocks,
+                                          default_inner_merge_code_blocks)
+        end
+        if default_parser_options
+          install_singleton_value_method!(klass, :default_parser_options,
+                                          default_parser_options)
+        end
+        install_singleton_value_method!(klass, :file_analysis_class, file_analysis_class) if file_analysis_class
+        if template_parse_error_class
+          install_singleton_value_method!(klass, :template_parse_error_class,
+                                          template_parse_error_class)
+        end
+        return unless destination_parse_error_class
+
+        install_singleton_value_method!(klass, :destination_parse_error_class,
+                                        destination_parse_error_class)
+      end
+
+      def configure_partial_template_merger_subclass!(klass, default_backend:, file_analysis_class:,
+                                                      smart_merger_class:)
+        install_singleton_value_method!(klass, :default_backend, default_backend)
+        install_singleton_value_method!(klass, :file_analysis_class, file_analysis_class)
+        install_singleton_value_method!(klass, :smart_merger_class, smart_merger_class)
+      end
+
+      def install_backend_loader!(wrapper_module)
+        return if wrapper_module.respond_to?(:ensure_backend_loaded!)
+
+        wrapper_module.singleton_class.class_eval do
+          define_method(:ensure_backend_loaded!) do
+            const_get(:Backend)
+          end
+        end
+      end
+      private_class_method :install_backend_loader!
+
+      def define_error_classes!(wrapper_module)
+        define_constant_unless_present(wrapper_module, :Error, Class.new(Markdown::Merge::Error))
+        define_constant_unless_present(wrapper_module, :ParseError, Class.new(Markdown::Merge::ParseError))
+        define_constant_unless_present(
+          wrapper_module,
+          :TemplateParseError,
+          Class.new(wrapper_module.const_get(:ParseError))
+        )
+        define_constant_unless_present(
+          wrapper_module,
+          :DestinationParseError,
+          Class.new(wrapper_module.const_get(:ParseError))
+        )
+      end
+      private_class_method :define_error_classes!
+
+      def install_singleton_value_method!(klass, method_name, value)
+        klass.singleton_class.class_eval do
+          define_method(method_name) do
+            WrapperSupport.send(:resolve_config_value, value, context: self)
+          end
+        end
+      end
+      private_class_method :install_singleton_value_method!
+
+      def resolve_config_value(value, context:)
+        return context.instance_exec(&value) if value.respond_to?(:call)
+
+        duplicate_config_value(value)
+      end
+      private_class_method :resolve_config_value
+
+      def duplicate_config_value(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, nested_value), result|
+            result[key] = duplicate_config_value(nested_value)
+          end
+        when Array
+          value.map { |nested_value| duplicate_config_value(nested_value) }
+        else
+          value
+        end
+      end
+      private_class_method :duplicate_config_value
+
+      def register_merge_gem!(registry_tag:, require_path:, merger_class:, test_source:, category:)
+        return unless defined?(Ast::Merge::RSpec::MergeGemRegistry)
+
+        Ast::Merge::RSpec::MergeGemRegistry.register(
+          registry_tag,
+          require_path: require_path,
+          merger_class: merger_class,
+          test_source: test_source,
+          category: category
+        )
+      end
+      private_class_method :register_merge_gem!
+
+      def define_constant_unless_present(wrapper_module, name, value)
+        return if wrapper_module.const_defined?(name, false)
+
+        wrapper_module.const_set(name, value)
+      end
+      private_class_method :define_constant_unless_present
+    end
+  end
+end