markdown_composer 0.7.0

data/lib/markdown_composer/executor.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+module MarkdownComposer
+  class Executor
+    attr_reader :sources, :plan, :options, :diagnostics, :stages
+
+    def initialize(sources:, plan:, options: {})
+      @sources = Array(sources).map { |source| Source.build(source) }
+      @plan = plan
+      @options = options
+      @diagnostics = Diagnostics.new
+      @stages = {}
+    end
+
+    def call
+      Validator.new(plan, sources: sources, options: options, diagnostics: diagnostics).call
+      return result(CompositionBuffer.new(diagnostics: diagnostics), html: nil) if diagnostics.any_errors?
+
+      buffer = CompositionBuffer.new(initial_buffer, diagnostics: diagnostics)
+      return result(buffer, html: nil) if diagnostics.any_errors?
+
+      indexes = {}
+      previous_source = nil
+
+      plan.steps.each_with_index do |step, index|
+        row_path = "compose[#{index}]"
+        source_ref = effective_source_ref(step["source"], previous_source)
+        source_index = source_index_for(source_ref, buffer, indexes, path: "#{row_path}.source")
+        next unless source_index
+
+        resolver = SelectionResolver.new(index: source_index, options: options, diagnostics: diagnostics, path: "#{row_path}.select")
+        units = if step["action"] == "remove_buffer_target"
+          []
+        else
+          resolver.resolve_with_includes(step["select"], step["include"])
+        end
+        diagnostics.warn("selection.empty", "Step selected no content", path: row_path) if units.empty? && step["action"] != "remove_buffer_target"
+        apply_action(buffer, step, units, row_path: row_path)
+        stages["step_#{index + 1}"] = buffer.markdown if options.fetch(:stages, false)
+        previous_source = source_ref
+      end
+
+      stages["composed"] = buffer.markdown if options.fetch(:stages, false)
+      TransformRunner.new(buffer: buffer, transforms: plan.transforms, output: plan.output, options: options, diagnostics: diagnostics, stages: stages).call
+      html = if plan.output == "html"
+        rendered = MarkdownRenderer.to_html(buffer.markdown, diagnostics: diagnostics)
+        MarkdownRenderer.apply_link_modes(rendered, html_link_modes, diagnostics: diagnostics)
+      end
+      result(buffer, html: html)
+    end
+
+    private
+
+    def initial_buffer
+      return options.fetch(:initial_buffer) if options.key?(:initial_buffer)
+      return +"" unless plan.steps.empty?
+
+      current_sources = sources.select { |source| source.type == "current" }
+      return +"" if current_sources.empty?
+      if current_sources.length > 1
+        diagnostics.error("source.current_ambiguous", "current source is ambiguous; provide a key", path: "source")
+        return +""
+      end
+
+      current_sources.first.content
+    end
+
+    def effective_source_ref(source_ref, previous_source)
+      return source_ref unless source_ref["type"] == "previous"
+
+      previous_source || { "type" => "current" }
+    end
+
+    def source_index_for(source_ref, buffer, indexes, path:)
+      if source_ref["type"] == "buffer"
+        return buffer.index
+      end
+
+      if source_ref["type"] == "inline"
+        source = Source.new(
+          key: source_ref["key"] || "inline",
+          type: "inline",
+          markdown: source_ref["markdown"],
+          html: source_ref["html"],
+          preferred_format: source_ref["preferred_format"] || :markdown,
+          metadata: source_ref["metadata"] || {}
+        )
+        return DocumentIndex.build(source, diagnostics: diagnostics)
+      end
+
+      source = resolve_source(source_ref)
+      unless source
+        diagnostics.error("source.missing", "Missing source for #{source_ref.inspect}", path: path)
+        return nil
+      end
+      indexes[source.key] ||= DocumentIndex.build(source, diagnostics: diagnostics)
+    end
+
+    def resolve_source(source_ref)
+      type = source_ref["type"]
+      key = source_ref["key"] || source_ref["id"] || source_ref["slug"]
+      return sources.find { |source| source.type == type } if type == "current" && !key
+      return sources.find { |source| source.key == key.to_s } if key
+
+      sources.find { |source| source.type == type } || sources.find { |source| source.key == type }
+    end
+
+    def apply_action(buffer, step, units, row_path:)
+      target = step["target"] || default_target(step["action"])
+      case step["action"]
+      when "set" then buffer.set(units)
+      when "append" then buffer.append(units)
+      when "prepend" then buffer.prepend(units)
+      when "insert_before" then buffer.insert_before(target, units, options: options)
+      when "insert_after" then buffer.insert_after(target, units, options: options)
+      when "insert_between" then buffer.insert_between(target["start"], target["end"], units, options: options)
+      when "replace" then buffer.replace(target, units, options: options)
+      when "copy" then buffer.copy(target, units, options: options)
+      when "move" then buffer.move(step["select"], target, units, options: options)
+      when "modify" then modify_source_fragment(buffer, step, units, target, row_path: row_path)
+      when "remove_buffer_target" then buffer.remove(target, options: options)
+      when "transform_buffer_target"
+        transforms = Array(step["transforms"])
+        transforms = transforms.map { |transform| transform["_scope_missing"] ? transform.merge("scope" => target) : transform }
+        TransformRunner.new(
+          buffer: buffer,
+          transforms: transforms,
+          output: plan.output,
+          options: options,
+          diagnostics: diagnostics,
+          stages: stages,
+          path_prefix: "#{row_path}.transforms"
+        ).call
+      end
+    end
+
+    def modify_source_fragment(buffer, step, units, target, row_path:)
+      return modify_source_fragment_in_place(buffer, step, units, row_path: row_path) if target&.dig("position") == "in_place"
+
+      fragment = CompositionBuffer.new(diagnostics: diagnostics)
+      fragment.set(units)
+      TransformRunner.new(
+        buffer: fragment,
+        transforms: Array(step["transforms"]),
+        output: plan.output,
+        options: options,
+        diagnostics: diagnostics,
+        stages: stages,
+        path_prefix: "#{row_path}.transforms"
+      ).call
+      buffer.place_markdown(target, fragment.markdown, origin_nodes: fragment.origin_nodes, options: options)
+    end
+
+    def modify_source_fragment_in_place(buffer, step, units, row_path:)
+      if buffer.empty?
+        diagnostics.error("target.in_place_buffer_empty", "target in_place requires existing buffer content", path: "#{row_path}.target")
+        return
+      end
+      if units.empty?
+        diagnostics.error("target.in_place_selection_empty", "target in_place matched no buffer content", path: row_path)
+        return
+      end
+
+      ranges = in_place_replacement_ranges(buffer, step, units)
+      if ranges.empty?
+        diagnostics.error("target.in_place_selection_empty", "target in_place matched no replaceable buffer content", path: row_path)
+        return
+      end
+
+      replacements = in_place_replacements(buffer, step, ranges, row_path: row_path)
+      return if diagnostics.any_errors?
+
+      buffer.replace_markdown_ranges(replacements)
+    end
+
+    def in_place_replacement_ranges(buffer, step, units)
+      if include_all?(step["include"])
+        resolver = SelectionResolver.new(index: buffer.index, options: options, diagnostics: diagnostics, path: "select")
+        return line_ranges(resolver.resolve(step["select"]))
+      end
+
+      line_ranges(units)
+    end
+
+    def in_place_replacements(buffer, step, ranges, row_path:)
+      fragment = CompositionBuffer.new(marked_in_place_fragment(buffer, ranges), diagnostics: diagnostics)
+      TransformRunner.new(
+        buffer: fragment,
+        transforms: Array(step["transforms"]),
+        output: plan.output,
+        options: options,
+        diagnostics: diagnostics,
+        stages: stages,
+        path_prefix: "#{row_path}.transforms"
+      ).call
+
+      ranges.map.with_index do |range, index|
+        { range: range, markdown: in_place_fragment_content(fragment.markdown, index, row_path: row_path) }
+      end
+    end
+
+    def marked_in_place_fragment(buffer, ranges)
+      idx = buffer.index
+      ranges.each_with_index.map do |range, index|
+        [
+          in_place_marker(index, "start"),
+          idx.markdown_for_range(range.begin, range.end),
+          in_place_marker(index, "end")
+        ].join
+      end.join("\n")
+    end
+
+    def in_place_fragment_content(markdown, index, row_path:)
+      pattern = /
+        <!--\ markdown-composer-in-place-start-#{index}\ -->\n?
+        (?<content>.*?)
+        \n?<!--\ markdown-composer-in-place-end-#{index}\ -->
+      /mx
+      match = markdown.match(pattern)
+      unless match
+        diagnostics.error("target.in_place_marker_missing", "target in_place could not map transformed content back to buffer range", path: row_path)
+        return ""
+      end
+
+      trim_outer_blank_lines(match[:content])
+    end
+
+    def in_place_marker(index, position)
+      "<!-- markdown-composer-in-place-#{position}-#{index} -->\n"
+    end
+
+    def include_all?(include_config)
+      Array(include_config).all? { |item| item["type"] == "all" && item.keys == [ "type" ] }
+    end
+
+    def line_ranges(units)
+      Array(units).compact
+        .select { |unit| unit.respond_to?(:start_line) && unit.respond_to?(:end_line) }
+        .map { |unit| unit.start_line..unit.end_line }
+        .sort_by(&:begin)
+        .each_with_object([]) do |range, merged|
+          if merged.any? && range.begin <= merged.last.end + 1
+            merged[-1] = merged.last.begin..[ merged.last.end, range.end ].max
+          else
+            merged << range
+          end
+        end
+    end
+
+    def trim_outer_blank_lines(content)
+      lines = content.to_s.lines
+      lines.shift while lines.first&.strip&.empty?
+      lines.pop while lines.last&.strip&.empty?
+      lines.join
+    end
+
+    def default_target(action)
+      case action
+      when "set" then { "position" => "output" }
+      when "append" then { "position" => "end" }
+      when "prepend" then { "position" => "start" }
+      when "modify" then { "position" => "end" }
+      end
+    end
+
+    def result(buffer, html:)
+      errors = diagnostics.errors
+      Result.new(
+        output: plan.output,
+        buffer: buffer,
+        markdown: buffer.markdown,
+        html: html,
+        diagnostics: diagnostics.to_a - errors,
+        errors: errors,
+        stages: stages
+      )
+    end
+
+    def html_link_modes
+      plan.transforms.select { |transform| transform["transform"] == "links" && %w[nofollow target_blank].include?(transform["mode"].to_s) }
+        .map { |transform| transform["mode"].to_s }
+    end
+  end
+end

data/lib/markdown_composer/markdown_renderer.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module MarkdownComposer
+  module MarkdownRenderer
+    module_function
+
+    def to_html(markdown, diagnostics: Diagnostics.new)
+      begin
+        require "commonmarker"
+        return render_with_commonmarker(markdown)
+      rescue LoadError, StandardError
+        diagnostics.warn("output.html_fallback", "CommonMarker HTML rendering unavailable; using simple fallback", path: "output")
+      end
+
+      fallback_html(markdown)
+    end
+
+    def apply_link_modes(html, modes, diagnostics: Diagnostics.new)
+      modes = Array(modes).map(&:to_s)
+      return html if html.to_s.empty? || modes.empty?
+
+      require "nokogiri"
+      fragment = Nokogiri::HTML5.fragment(html)
+      fragment.css("a[href]").each do |link|
+        href = link["href"].to_s
+        next if href.empty? || href.start_with?("#")
+
+        merge_rel(link, "nofollow") if modes.include?("nofollow")
+        if modes.include?("target_blank")
+          link["target"] = "_blank"
+          merge_rel(link, "noopener")
+          merge_rel(link, "noreferrer")
+        end
+      end
+      fragment.to_html
+    rescue LoadError, StandardError => e
+      diagnostics.warn("transform.html_link_postprocess_failed", "HTML link transform skipped: #{e.message}", path: "transform")
+      html
+    end
+
+    def render_with_commonmarker(markdown)
+      return CommonMarker.render_html(markdown) if defined?(CommonMarker) && CommonMarker.respond_to?(:render_html)
+      return Commonmarker.to_html(markdown) if defined?(Commonmarker) && Commonmarker.respond_to?(:to_html)
+      return CommonMarker.render_doc(markdown).to_html if defined?(CommonMarker) && CommonMarker.respond_to?(:render_doc)
+
+      raise "unsupported CommonMarker API"
+    end
+
+    def fallback_html(markdown)
+      html = []
+      list_items = []
+      markdown.lines.each do |line|
+        case line
+        when /\A\s*[-*+]\s+(.+)/
+          list_items << "<li>#{render_inline(Regexp.last_match(1).strip)}</li>"
+        when /\A(\#{1,6})\s+(.+)/
+          flush_list(html, list_items)
+          level = Regexp.last_match(1).length
+          html << "<h#{level}>#{render_inline(Regexp.last_match(2).strip)}</h#{level}>"
+        when /\A\s*$/
+          flush_list(html, list_items)
+        else
+          flush_list(html, list_items)
+          html << "<p>#{render_inline(line.strip)}</p>"
+        end
+      end
+      flush_list(html, list_items)
+      html.join("\n")
+    end
+
+    def render_inline(text)
+      rendered = +""
+      last_index = 0
+      text.to_s.to_enum(:scan, /(?<!!)\[([^\]]+)\]\(([^)\s]+)\)/).each do
+        match = Regexp.last_match
+        rendered << escape(text.to_s[last_index...match.begin(0)].to_s)
+        rendered << "<a href=\"#{escape_attribute(match[2])}\">#{escape(match[1])}</a>"
+        last_index = match.end(0)
+      end
+      rendered << escape(text.to_s[last_index..].to_s)
+      rendered
+    end
+
+    def flush_list(html, list_items)
+      return if list_items.empty?
+
+      html << "<ul>#{list_items.join}</ul>"
+      list_items.clear
+    end
+
+    def escape(text)
+      text.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;")
+    end
+
+    def escape_attribute(text)
+      escape(text.to_s).gsub('"', "&quot;")
+    end
+
+    def merge_rel(link, value)
+      rel_values = link["rel"].to_s.split(/\s+/).reject(&:empty?)
+      rel_values << value unless rel_values.include?(value)
+      link["rel"] = rel_values.join(" ")
+    end
+  end
+end