markdown_composer 0.7.0

data/lib/markdown_composer/transform_runner/scope_resolver.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module MarkdownComposer
+  class TransformRunner
+    module ScopeResolver
+      private
+
+      def replace_in_scope(scope, path:)
+        ranges = scope_ranges(scope, path: path)
+        lines = buffer.markdown.lines
+        ranges.sort_by(&:begin).reverse_each do |range|
+          text = lines[(range.begin - 1)..(range.end - 1)].join
+          lines[(range.begin - 1)..(range.end - 1)] = [ yield(text) ]
+        end
+        set_markdown(lines.join)
+      end
+
+      def rewrite_matching_lines(scope)
+        idx = buffer.index
+        matches = if output_scope?(scope)
+          idx.nodes
+        else
+          resolver = SelectionResolver.new(index: idx, options: options, diagnostics: diagnostics, path: "scope")
+          scope["include"] ? resolver.resolve_with_includes(scope, scope["include"]) : resolver.resolve(scope)
+        end
+        counters = Hash.new(0)
+        lines = buffer.markdown.lines
+        matches.each do |unit|
+          next unless unit.is_a?(ComposerNode)
+
+          line_index = unit.start_line - 1
+          lines[line_index] = yield(lines[line_index], unit, counters)
+        end
+        set_markdown(lines.join)
+      end
+
+      def scope_ranges(scope, path:)
+        scope_matches(scope, path: path).map(&:first)
+      end
+
+      def scope_matches(scope, path:)
+        return [ [ 1..buffer.markdown.lines.length, buffer.index.root, 1 ] ] if output_scope?(scope)
+
+        idx = buffer.index
+        scope_path = "#{path}.scope"
+        resolver = SelectionResolver.new(index: idx, options: options, diagnostics: diagnostics, path: scope_path)
+        matches = scope["include"] ? resolver.resolve_with_includes(scope, scope["include"]) : resolver.resolve(scope)
+        diagnostics.warn("transform.scope_empty", "Transform scope matched no content", path: scope_path) if matches.empty?
+        matches.each_with_index.map { |unit, index| [ unit.start_line..unit.end_line, unit, index + 1 ] }
+      end
+
+      def output_scope?(scope)
+        scope && scope["type"] == "output"
+      end
+
+      def replace_ranges(ranges, content)
+        lines = buffer.markdown.lines
+        ranges.sort_by(&:begin).reverse_each do |range|
+          lines[(range.begin - 1)..(range.end - 1)] = content.empty? ? [] : [ ensure_block(content) ]
+        end
+        set_markdown(lines.join)
+      end
+
+      def replace_matches(matches, transform)
+        lines = buffer.markdown.lines
+        matches.sort_by { |range, _unit, _index| range.begin }.reverse_each do |range, unit, index|
+          content = content_for(transform, unit: unit, index: index)
+          lines[(range.begin - 1)..(range.end - 1)] = content.empty? ? [] : [ ensure_block(content) ]
+        end
+        set_markdown(lines.join)
+      end
+
+      def nested_target_ranges(target, unit, path:)
+        return [] unless unit
+        return [ unit.start_line..unit.start_line ] if target["position"] == "start"
+        return [ unit.end_line..unit.end_line ] if target["position"] == "end"
+
+        selector = target.reject { |key, _| %w[placement start end position].include?(key) }
+        idx = buffer.index
+        resolver = SelectionResolver.new(index: idx, options: options, diagnostics: diagnostics, path: path)
+        ranges = resolver.resolve(selector, within: unit).map { |match| match.start_line..match.end_line }
+        diagnostics.warn("transform.target_empty", "Transform target matched no scoped content", path: path) if ranges.empty?
+        ranges
+      end
+    end
+  end
+end

data/lib/markdown_composer/transform_runner.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require_relative "transform_runner/field_interpolator"
+require_relative "transform_runner/heading_numbering"
+require_relative "transform_runner/scope_resolver"
+require_relative "transform_runner/content_placement"
+
+module MarkdownComposer
+  class TransformRunner
+    include FieldInterpolator
+    include HeadingNumbering
+    include ScopeResolver
+    include ContentPlacement
+
+    attr_reader :buffer, :transforms, :output, :options, :diagnostics, :stages, :path_prefix
+
+    def initialize(buffer:, transforms:, output:, options:, diagnostics:, stages:, path_prefix: "transform")
+      @buffer = buffer
+      @transforms = transforms
+      @output = output
+      @options = options
+      @diagnostics = diagnostics
+      @stages = stages
+      @path_prefix = path_prefix
+    end
+
+    def call
+      transforms.each_with_index do |transform, index|
+        path = "#{path_prefix}[#{index}]"
+        before = buffer.markdown
+        apply_transform(transform, path: path)
+        diagnostics.warn("transform.noop", "#{transform["transform"]} made no changes", path: "#{path}.transform", details: { stage: "transformed_markdown" }) if before == buffer.markdown
+        stages["transform_#{index + 1}"] = buffer.markdown if options.fetch(:stages, false)
+      end
+      stages["transformed_markdown"] = buffer.markdown if options.fetch(:stages, false)
+      stages["final"] = output == "markdown" ? buffer.markdown : nil if options.fetch(:stages, false)
+      buffer
+    end
+
+    private
+
+    def apply_transform(transform, path:)
+      case transform["transform"]
+      when "heading_numbers" then transform_heading_numbers(transform, path: path)
+      when "replace_text" then transform_replace_text(transform, path: path)
+      when "links" then transform_links(transform, path: path)
+      when "heading_levels" then transform_heading_levels(transform, path: path)
+      when "remove_empty" then transform_remove_empty(transform, path: path)
+      when "insert_before" then transform_insert(transform, :before, path: path)
+      when "insert_after" then transform_insert(transform, :after, path: path)
+      when "prepend_content" then transform_insert(transform, :prepend, path: path)
+      when "append_content" then transform_insert(transform, :append, path: path)
+      when "replace_content" then transform_replace_content(transform, path: path)
+      when "remove_content" then transform_remove_content(transform, path: path)
+      when "dedupe" then transform_dedupe(transform, path: path)
+      when "order" then transform_order(transform, path: path)
+      when "sanitise", "adapter"
+        diagnostics.warn("transform.adapter_skipped", "#{transform["transform"]} is adapter-policy gated and was not run inside the standalone gem", path: path)
+      end
+    end
+
+    def transform_heading_numbers(transform, path:)
+      mode = transform["mode"].to_s
+      levels = heading_levels(transform.dig("options", "levels"))
+      start_at = [ transform.dig("options", "start").to_i, 1 ].max
+      skip_if_present = transform.dig("options", "skip_if_present") == true
+      formats = heading_number_formats(transform.dig("options", "format"))
+      candidates = heading_number_candidates(transform["scope"], path: path)
+      counters = Hash.new(0)
+      lines = buffer.markdown.lines
+
+      buffer.index.nodes.select(&:heading?).sort_by(&:source_position).each do |node|
+        counters[node.level] = start_at - 1 if counters[node.level].zero?
+        counters[node.level] += 1
+        ((node.level + 1)..6).each { |level| counters[level] = 0 }
+
+        next unless candidates[node.id]
+        next unless levels.empty? || levels.include?(node.level)
+
+        line_index = node.start_line - 1
+        title = heading_title_from_line(lines[line_index])
+        lines[line_index] = case mode
+        when "keep"
+          lines[line_index]
+        when "strip"
+          "#{"#" * node.level} #{title}\n"
+        when "add", "rebuild"
+          next lines[line_index] if mode == "add" && skip_if_present && visible_heading_number(node) != ""
+
+          number = heading_number(counters, node.level, formats)
+          "#{"#" * node.level} #{number}#{heading_number_title_separator(number)}#{title}\n"
+        else
+          diagnostics.error("transform.mode_invalid", "Invalid heading_numbers mode #{mode}", path: path)
+          lines[line_index]
+        end
+      end
+      set_markdown(lines.join)
+    end
+
+    def transform_replace_text(transform, path:)
+      from = transform.dig("options", "from").to_s
+      to = transform.dig("options", "to").to_s
+      mode = transform["mode"].to_s
+      case_sensitive = transform.dig("options", "case_sensitive") == true
+      limit = transform.dig("options", "limit")&.to_i
+
+      replace_in_scope(transform["scope"], path: path) do |text|
+        flags = case_sensitive ? nil : Regexp::IGNORECASE
+        pattern = case mode
+        when "literal" then Regexp.new(Regexp.escape(from), flags)
+        when "word" then Regexp.new("\\b#{Regexp.escape(from)}\\b", flags)
+        when "regex"
+          Regexp.new(from, flags)
+        else
+          diagnostics.error("transform.mode_invalid", "Invalid replace_text mode #{mode}", path: path)
+          next text
+        end
+        count = 0
+        text.gsub(pattern) do
+          count += 1
+          limit && count > limit ? Regexp.last_match(0) : to
+        end
+      end
+    end
+
+    def transform_links(transform, path:)
+      mode = transform["mode"].to_s
+      replace_in_scope(transform["scope"], path: path) do |text|
+        case mode
+        when "keep"
+          text
+        when "unwrap"
+          text.gsub(/(?<!!)\[([^\]]+)\]\([^)]+\)/, "\\1")
+        when "remove"
+          text.gsub(/(?<!!)\[[^\]]+\]\([^)]+\)/, "")
+        when "rewrite_url"
+          from = transform.dig("options", "from").to_s
+          to = transform.dig("options", "to").to_s
+          text.gsub(/\[([^\]]+)\]\(([^)]+)\)/) { "[#{Regexp.last_match(1)}](#{Regexp.last_match(2).sub(from, to)})" }
+        when "nofollow", "target_blank"
+          diagnostics.warn("transform.html_only", "#{mode} is only meaningful for HTML output", path: path) if output == "markdown"
+          text
+        else
+          diagnostics.error("transform.mode_invalid", "Invalid links mode #{mode}", path: path)
+          text
+        end
+      end
+    end
+
+    def transform_heading_levels(transform, path:)
+      mode = transform["mode"].to_s
+      by = transform.dig("options", "by").to_i
+      to = heading_level(transform.dig("options", "to"))
+      rewrite_matching_lines(transform["scope"]) do |line, node, _counters|
+        next line unless node.heading?
+
+        new_level = case mode
+        when "promote" then [ node.level - by, 1 ].max
+        when "demote" then [ node.level + by, 6 ].min
+        when "normalise" then to || node.level
+        else
+          diagnostics.error("transform.mode_invalid", "Invalid heading_levels mode #{mode}", path: path)
+          node.level
+        end
+        line.sub(/\A\#{1,6}/, "#" * new_level)
+      end
+    end
+
+    def transform_remove_empty(transform, path:)
+      scope = transform["scope"]
+      ranges = scope_ranges(scope, path: path)
+      replace_ranges(ranges.select { |range| buffer.markdown.lines[(range.begin - 1)..(range.end - 1)].join.gsub(/[#>*`\-\s|]/, "").empty? }, "")
+    end
+
+    def transform_insert(transform, placement, path:)
+      matches = scope_matches(transform["scope"], path: path)
+      lines = buffer.markdown.lines
+      inserted_content = {}
+      matches.sort_by { |range, _unit, _index| range.begin }.reverse_each do |range, unit, index|
+        content = ensure_block(content_for(transform, unit: unit, index: index))
+        next if duplicate_insert?(content, transform, inserted_content)
+
+        inserted_content[content.strip] = true
+        insertion_index = insertion_index_for(transform, placement, range, unit, path: path)
+        lines.insert(insertion_index, spaced_insert_content(content, transform, lines, insertion_index))
+      end
+      set_markdown(lines.join)
+    end
+
+    def transform_replace_content(transform, path:)
+      replace_matches(scope_matches(transform["scope"], path: path), transform)
+    end
+
+    def transform_remove_content(transform, path:)
+      replace_ranges(scope_ranges(transform["scope"], path: path), "")
+    end
+
+    def transform_dedupe(transform, path:)
+      mode = transform["mode"].to_s
+      if mode == "source_node_id"
+        dedupe_current_buffer_by_origin(path: path)
+        return
+      end
+      seen = {}
+      lines = []
+      case_sensitive = transform.dig("options", "case_sensitive") == true
+      current_blocks.each do |block|
+        key = mode == "normalised_text" ? normalised_dedupe_key(block, case_sensitive: case_sensitive) : block
+        if seen[key]
+          diagnostics.info("transform.deduped", "Removed duplicate content", path: path)
+          next
+        end
+        seen[key] = true
+        lines << block
+      end
+      set_markdown(lines.join("\n"))
+    end
+
+    def transform_order(transform, path:)
+      mode = transform["mode"].to_s
+      return if mode == "action_order"
+
+      idx = buffer.index
+      ordered = case mode
+      when "source_order"
+        idx.nodes.sort_by(&:source_position).map(&:raw).join
+      when "target_order"
+        diagnostics.warn("transform.order_target_skipped", "target_order requires host-specific ordering policy", path: path)
+        buffer.markdown
+      else
+        buffer.markdown
+      end
+      set_markdown(ordered)
+    end
+
+    def dedupe_current_buffer_by_origin(path:)
+      current = buffer.index.nodes
+      return if current.empty?
+
+      origins_by_raw = buffer.origin_nodes.group_by { |node| normalised_dedupe_key(node.raw, case_sensitive: true) }
+      seen = {}
+      ranges_to_remove = []
+      current.each do |node|
+        origin = origins_by_raw[normalised_dedupe_key(node.raw, case_sensitive: true)]&.shift
+        key = origin&.attributes&.fetch("origin_id", nil) || "buffer:#{node.id}"
+        next if key.empty?
+
+        if seen[key]
+          diagnostics.info("transform.deduped", "Removed duplicate content", path: path)
+          ranges_to_remove << (node.start_line..node.end_line)
+        else
+          seen[key] = true
+        end
+      end
+      replace_ranges(ranges_to_remove, "")
+      buffer.sync_origins_to_current!
+    end
+
+    def set_markdown(markdown)
+      buffer.replace_markdown(markdown)
+    end
+
+  end
+end

data/lib/markdown_composer/transforms/default_entries.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module MarkdownComposer
+  module DefaultTransformEntries
+    private
+
+    def transform_entries
+      {
+        heading_numbers: %w[keep strip add rebuild],
+        replace_text: %w[literal word regex],
+        links: %w[keep unwrap remove rewrite_url nofollow target_blank],
+        heading_levels: %w[promote demote normalise],
+        remove_empty: %w[remove],
+        insert_before: %w[insert],
+        insert_after: %w[insert],
+        prepend_content: %w[insert],
+        append_content: %w[insert],
+        replace_content: %w[replace],
+        remove_content: %w[remove],
+        dedupe: %w[source_node_id normalised_text],
+        order: %w[action_order source_order target_order],
+        sanitise: %w[block_safe text_only links_unwrapped strict],
+        adapter: []
+      }.map do |token, modes|
+        support = %i[order sanitise adapter].include?(token) ? :advanced : :normal
+        support = :adapter_policy if %i[sanitise adapter].include?(token)
+        RegistryEntry.new(token: token.to_s, aliases: [], label: token.to_s.split("_").map(&:capitalize).join(" "), tooltip: "Run #{token} transform.", meaning: token.to_s, row_sentence: nil, support: { transform: support, modes: modes }, source_formats: [], condition_fields: [])
+      end
+    end
+  end
+end

data/lib/markdown_composer/transforms/registry.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module MarkdownComposer
+  module Transforms
+    class Registry
+      def self.default
+        MarkdownComposer::Registries.default.transforms
+      end
+    end
+  end
+end