markdown_composer 0.7.0

data/lib/markdown_composer/source_list_builder.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module MarkdownComposer
+  class SourceListBuilder
+    def initialize
+      @sources = []
+    end
+
+    def current(markdown = nil, key: "current", html: nil, title: nil, preferred_format: :markdown, metadata: {})
+      add(type: "current", key: key, markdown: markdown, html: html, title: title, preferred_format: preferred_format, metadata: metadata)
+    end
+
+    def explicit(key, markdown = nil, html: nil, title: nil, preferred_format: :markdown, metadata: {})
+      add(type: "explicit", key: key, markdown: markdown, html: html, title: title, preferred_format: preferred_format, metadata: metadata)
+    end
+
+    def inherited(key, markdown = nil, html: nil, title: nil, preferred_format: :markdown, metadata: {})
+      add(type: "inherited", key: key, markdown: markdown, html: html, title: title, preferred_format: preferred_format, metadata: metadata)
+    end
+
+    def to_a
+      @sources.map(&:dup)
+    end
+
+    private
+
+    def add(type:, key:, markdown:, html:, title:, preferred_format:, metadata:)
+      normalized_key = normalize_key(key, type)
+      @sources << {
+        "key" => normalized_key,
+        "type" => type.to_s,
+        "title" => title,
+        "markdown" => markdown,
+        "html" => html,
+        "preferred_format" => preferred_format,
+        "metadata" => metadata
+      }.compact
+    end
+
+    def normalize_key(key, type)
+      normalized = key.to_s
+      raise ArgumentError, "#{type} source requires a key" if normalized.empty?
+
+      normalized
+    end
+  end
+end

data/lib/markdown_composer/take.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module MarkdownComposer
+  module Take
+    module_function
+
+    def parse(value)
+      text = value.to_s.strip
+      text = text[1..-2] if text.start_with?("[") && text.end_with?("]")
+      return { "all" => true } if text.empty? || text == "all"
+
+      clauses = text.split(";").map(&:strip)
+      clauses.each_with_object({}) do |clause, hash|
+        case clause
+        when /\Aodd\z/
+          hash["odd"] = true
+        when /\Aeven\z/
+          hash["even"] = true
+        when /\A(\d+|-?\d+)\.\.(last|-?\d+|\d+)\z/
+          (hash["ranges"] ||= []) << { "from" => integer(Regexp.last_match(1)), "to" => integer(Regexp.last_match(2)) }
+        when /\A([^:]+):(.+)\z/
+          key = Regexp.last_match(1).strip
+          raw = Regexp.last_match(2).strip
+          case key
+          when "position", "except"
+            hash[key] = raw.split(",").map { |part| integer(part.strip) }
+          when "range"
+            from, to = raw.split("..", 2)
+            (hash["ranges"] ||= []) << { "from" => integer(from), "to" => integer(to) }
+          else
+            hash[key] = integer(raw)
+          end
+        else
+          hash[clause] = true
+        end
+      end
+    end
+
+    def apply(items, take, diagnostics: nil, path: nil, seed: 0)
+      take = parse(take) if take.is_a?(String) || take.is_a?(Symbol)
+      take ||= { "all" => true }
+      errors = validate(take)
+      errors.each { |message| diagnostics&.error("take.invalid", message, path: path) }
+      return [] if errors.any?
+      return items.dup if take.empty? || take["all"]
+
+      selected_indexes = []
+      count = items.length
+
+      selected_indexes.concat((0...[take["first"].to_i, count].min).to_a) if take["first"]
+      selected_indexes.concat(((count - take["last"].to_i)...count).to_a) if take["last"]
+      selected_indexes.concat(Array(take["position"]).map { |position| resolve_position(position, count) }.compact) if take["position"]
+      Array(take["ranges"]).each do |range|
+        from = resolve_position(range["from"], count)
+        to = resolve_position(range["to"], count)
+        selected_indexes.concat((from..to).to_a) if from && to && from <= to
+      end
+
+      if take["skip"]
+        selected_indexes = (take["skip"].to_i...count).to_a
+      end
+      if take["skip_last"]
+        selected_indexes = (0...[count - take["skip_last"].to_i, 0].max).to_a
+      end
+      selected_indexes = (0...count).select { |index| (index + 1) % take["every"].to_i == 0 } if take["every"]
+      selected_indexes = (0...count).select { |index| (index + 1).odd? } if take["odd"]
+      selected_indexes = (0...count).select { |index| (index + 1).even? } if take["even"]
+      selected_indexes = (0...count).to_a - Array(take["except"]).map { |position| resolve_position(position, count) }.compact if take["except"]
+      selected_indexes = percent_indexes(count, take["top_percent"].to_i, :top) if take["top_percent"]
+      selected_indexes = percent_indexes(count, take["bottom_percent"].to_i, :bottom) if take["bottom_percent"]
+      selected_indexes = middle_indexes(count, take["middle"].to_i) if take["middle"]
+      selected_indexes = middle_indexes(count, (count * take["middle_percent"].to_i / 100.0).ceil) if take["middle_percent"]
+      selected_indexes = alternate_indexes(count, take["alternate"].to_i) if take["alternate"]
+      selected_indexes = (0...count).to_a.sample(take["random"].to_i, random: Random.new(seed)).sort if take["random"]
+
+      selected_indexes.uniq.sort.map { |index| items[index] }.compact
+    end
+
+    def validate(take)
+      errors = []
+      take.each do |key, value|
+        unless Registries.default.take.key?(key.to_sym)
+          errors << "Unknown take operator #{key.inspect}"
+          next
+        end
+
+        case key
+        when "first", "last", "skip", "skip_last", "every", "top_percent", "bottom_percent", "middle", "middle_percent", "alternate", "random"
+          errors << "#{key} must be positive" if value.to_i <= 0
+        when "position", "except"
+          Array(value).each { |position| errors << "#{key} cannot include 0" if position.to_i.zero? }
+        when "ranges"
+          Array(value).each do |range|
+            errors << "range is missing from/to" unless range.key?("from") && range.key?("to")
+            errors << "range cannot include 0" if range["from"].to_i.zero? || range["to"].to_i.zero?
+          end
+        end
+      end
+      errors
+    end
+
+    def integer(value)
+      value.to_s == "last" ? -1 : value.to_i
+    end
+
+    def resolve_position(position, count)
+      value = position.to_i
+      return nil if value.zero?
+
+      index = value.positive? ? value - 1 : count + value
+      index if index >= 0 && index < count
+    end
+
+    def percent_indexes(count, percent, direction)
+      selected_count = (count * percent / 100.0).ceil
+      direction == :top ? (0...selected_count).to_a : ((count - selected_count)...count).to_a
+    end
+
+    def middle_indexes(count, selected_count)
+      selected_count = [ selected_count, count ].min
+      start = [(count - selected_count) / 2, 0].max
+      (start...(start + selected_count)).to_a
+    end
+
+    def alternate_indexes(count, group_size)
+      (0...count).select { |index| ((index / group_size) % 2).zero? }
+    end
+  end
+end

data/lib/markdown_composer/transform_options.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module MarkdownComposer
+  module TransformOptions
+    module_function
+
+    def required(transform, mode)
+      case [ transform.to_s, mode.to_s ]
+      when [ "replace_text", "literal" ], [ "replace_text", "word" ], [ "replace_text", "regex" ]
+        %w[from to]
+      when [ "links", "rewrite_url" ]
+        %w[from to]
+      when [ "heading_numbers", "add" ], [ "heading_numbers", "rebuild" ]
+        %w[levels]
+      when [ "heading_levels", "promote" ], [ "heading_levels", "demote" ]
+        %w[by]
+      when [ "heading_levels", "normalise" ]
+        %w[to]
+      when [ "remove_empty", "remove" ]
+        %w[unit]
+      when [ "insert_before", "insert" ], [ "insert_after", "insert" ], [ "prepend_content", "insert" ], [ "append_content", "insert" ], [ "replace_content", "replace" ]
+        %w[content as]
+      when [ "order", "target_order" ]
+        %w[target]
+      else
+        []
+      end
+    end
+
+    def optional(transform, mode, adapter_option_keys: [])
+      base = case [ transform.to_s, mode.to_s ]
+      when [ "heading_numbers", "keep" ] then %w[levels format]
+      when [ "heading_numbers", "strip" ] then %w[levels pattern]
+      when [ "heading_numbers", "add" ] then %w[start format skip_if_present]
+      when [ "heading_numbers", "rebuild" ] then %w[start format exclude restart_at]
+      when [ "replace_text", "literal" ] then %w[case_sensitive limit whole_node]
+      when [ "replace_text", "word" ] then %w[case_sensitive limit]
+      when [ "replace_text", "regex" ] then %w[case_sensitive limit]
+      when [ "links", "keep" ] then []
+      when [ "links", "unwrap" ] then %w[keep_text]
+      when [ "links", "remove" ] then %w[keep_text]
+      when [ "links", "rewrite_url" ] then %w[match case_sensitive]
+      when [ "links", "nofollow" ], [ "links", "target_blank" ] then []
+      when [ "heading_levels", "promote" ], [ "heading_levels", "demote" ] then %w[min_level max_level]
+      when [ "heading_levels", "normalise" ] then []
+      when [ "remove_empty", "remove" ] then %w[trim ignore_nbsp ignore_comments]
+      when [ "insert_before", "insert" ], [ "insert_after", "insert" ] then %w[dedupe parse_as]
+      when [ "prepend_content", "insert" ], [ "append_content", "insert" ] then %w[target dedupe parse_as]
+      when [ "replace_content", "replace" ] then %w[parse_as]
+      when [ "remove_content", "remove" ] then []
+      when [ "dedupe", "normalised_text" ] then %w[case_sensitive]
+      when [ "dedupe", "source_node_id" ] then []
+      when [ "order", "action_order" ], [ "order", "source_order" ] then []
+      when [ "order", "target_order" ] then []
+      when [ "sanitise", "block_safe" ], [ "sanitise", "text_only" ], [ "sanitise", "links_unwrapped" ], [ "sanitise", "strict" ] then %w[profile]
+      else
+        %w[levels from to by unit profile name content as target parse_as case_sensitive limit dedupe format pattern start skip_if_present exclude restart_at keep_text match min_level max_level trim ignore_nbsp ignore_comments whole_node]
+      end
+      transform.to_s == "adapter" ? base + Array(adapter_option_keys).map(&:to_s) : base
+    end
+
+    def allowed(transform, mode, adapter_option_keys: [])
+      (required(transform, mode) + optional(transform, mode, adapter_option_keys: adapter_option_keys)).uniq
+    end
+  end
+end

data/lib/markdown_composer/transform_runner/content_placement.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module MarkdownComposer
+  class TransformRunner
+    module ContentPlacement
+      private
+
+      def current_blocks
+        buffer.markdown.split(/\n{2,}/).map { |block| "#{block.strip}\n" }.reject { |block| block.strip.empty? }
+      end
+
+      def duplicate_insert?(content, transform, inserted_content)
+        return false unless transform.dig("options", "dedupe")
+
+        inserted_content[content.strip] || buffer.markdown.include?(content.strip)
+      end
+
+      def insertion_index_for(transform, placement, range, unit, path:)
+        target = transform.dig("options", "target")
+        if target && %i[prepend append].include?(placement)
+          target_range = nested_target_ranges(target, unit, path: path).yield_self { |ranges| placement == :prepend ? ranges.first : ranges.last }
+          return placement == :prepend ? target_range.begin - 1 : target_range.end if target_range
+        end
+
+        case placement
+        when :before then range.begin - 1
+        when :after then range.end
+        when :prepend then range.begin
+        when :append then range.end
+        end
+      end
+
+      def normalised_dedupe_key(value, case_sensitive:)
+        key = value.to_s.gsub(/\s+/, " ").strip
+        case_sensitive ? key : key.downcase
+      end
+
+      def spaced_insert_content(content, transform, lines, insertion_index)
+        return content unless paragraph_like_insert?(content, transform)
+
+        text = content.dup
+        previous_line = lines[insertion_index - 1].to_s
+        next_line = lines[insertion_index].to_s
+        text = "\n#{text}" if !previous_line.empty? && !previous_line.strip.empty? && !previous_line.match?(/\A\s{0,3}\#{1,6}\s+/)
+        text = "#{text}\n" if !next_line.empty? && !next_line.strip.empty?
+        text
+      end
+
+      def paragraph_like_insert?(content, transform)
+        as = transform.dig("options", "as").to_s
+        return false if as.start_with?("heading_") || as == "comment"
+
+        !raw_markdown_block?(content)
+      end
+
+      def ensure_block(content)
+        text = content.to_s
+        text = "#{text}\n" unless text.end_with?("\n")
+        text
+      end
+    end
+  end
+end

data/lib/markdown_composer/transform_runner/field_interpolator.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module MarkdownComposer
+  class TransformRunner
+    module FieldInterpolator
+      private
+
+      def content_for(transform, unit: nil, index: nil)
+        content = render_content_template(transform.dig("options", "content").to_s, unit, index: index)
+        as = transform.dig("options", "as").to_s
+        parse_as = transform.dig("options", "parse_as").to_s
+        parse_as = "markdown" if parse_as.empty?
+        content = escape_text_content(content) if parse_as == "text"
+        return content if parse_as == "markdown" && raw_markdown_block?(content)
+        return "#{content}\n" unless as.start_with?("heading_")
+
+        level = as[/heading_(\d)/, 1].to_i
+        "#{"#" * level} #{content}\n"
+      end
+
+      def raw_markdown_block?(content)
+        content.start_with?("#", "-", ">", "|", "```", "<!--")
+      end
+
+      def escape_text_content(content)
+        content.to_s.lines.map do |line|
+          line.sub(/\A(\s*)([#>\-|]|```)/, "\\1\\\\\\2")
+        end.join
+      end
+
+      def render_content_template(content, unit, index: nil)
+        return content unless unit
+
+        content.gsub(/field\[([a-z_][a-z0-9_]*(?::[a-z0-9_]+)?(?:\.[a-z_][a-z0-9_]*(?::[a-z0-9_]+)?)*(?:\[[^\]]+\])?)\]/) do
+          field_value(Regexp.last_match(1), unit, index: index).to_s
+        end
+      end
+
+      def template_title(unit)
+        raw = unit.respond_to?(:raw) ? unit.raw.to_s.lines.first.to_s : ""
+        if raw.match?(/\A\#{1,6}\s+/)
+          return raw.sub(/\A\#{1,6}\s+/, "").strip.sub(/\A\d+(?:\.\d+)*\.?\s+/, "")
+        end
+
+        unit.respond_to?(:title_text) ? unit.title_text.to_s : unit.text.to_s
+      end
+
+      def field_value(reference, unit, index: nil)
+        reference, take = split_field_take(reference)
+        parts = reference.to_s.split(".")
+        value = if parts.length == 1
+          unit_field(unit, parts.first, index: index)
+        else
+          scoped_unit_field(parts, unit, index: index)
+        end
+        take ? apply_field_take(value, take) : value
+      end
+
+      def split_field_take(reference)
+        text = reference.to_s
+        return [ text, nil ] unless text =~ /\A(.+)\[([^\]]+)\]\z/
+
+        [ Regexp.last_match(1), Regexp.last_match(2) ]
+      end
+
+      def apply_field_take(value, take)
+        words = value.to_s.scan(/\S+/)
+        Take.apply(words, Take.parse(take), diagnostics: diagnostics, path: "field").join(" ")
+      end
+
+      def scoped_unit_field(parts, unit, index: nil)
+        case parts.first
+        when "current"
+          unit_field(unit, parts[1], index: index)
+        when "section"
+          section = section_reference(parts[1..], unit)
+          unit_field(section, parts.last, index: index)
+        when "parent_section"
+          section = containing_section(unit)
+          unit_field(parent_section(section), parts[1], index: index)
+        else
+          ""
+        end
+      end
+
+      def section_reference(parts, unit)
+        section = containing_section(unit)
+        return section if parts.empty? || !parts.first
+
+        remaining = parts.dup
+        while remaining.first == "parent"
+          section = parent_section(section)
+          remaining.shift
+        end
+        if remaining.first&.start_with?("ancestor:")
+          heading_token = remaining.first.split(":", 2).last
+          section = ancestor_section(section, heading_token)
+        end
+        section
+      end
+
+      def unit_field(unit, field, index: nil)
+        return "" unless unit
+
+        case field.to_s
+        when "title"
+          return unit.attributes["title"].to_s if unit.respond_to?(:attributes) && unit.attributes["title"]
+
+          template_title(unit)
+        when "text"
+          unit.is_a?(ComposerSection) && unit.level.to_i.positive? ? unit.title_text.to_s : unit.text.to_s
+        when "source_text"
+          unit.respond_to?(:raw) ? unit.raw.to_s : unit_field(unit, "text", index: index)
+        when "type"
+          unit.respond_to?(:type) ? unit.type.to_s : section_type(unit)
+        when "index", "item_index"
+          attribute = attribute_field(unit, field.to_s)
+          attribute.empty? ? index.to_s : attribute
+        when "start_line"
+          unit.respond_to?(:start_line) ? unit.start_line.to_s : ""
+        when "end_line"
+          unit.respond_to?(:end_line) ? unit.end_line.to_s : ""
+        when "level"
+          unit.respond_to?(:level) ? unit.level.to_s : ""
+        when "number"
+          visible_heading_number(unit)
+        when "item_count"
+          attribute = attribute_field(unit, "item_count")
+          attribute.empty? ? item_count(unit).to_s : attribute
+        when "ordered"
+          value = attribute_field(unit, "ordered")
+          value == "" ? (unit.respond_to?(:type) && unit.type == "ordered_list").to_s : value.to_s
+        when "row_count"
+          attribute = attribute_field(unit, "row_count")
+          attribute.empty? ? table_row_count(unit).to_s : attribute
+        when "column_count"
+          attribute = attribute_field(unit, "column_count")
+          attribute.empty? ? table_column_count(unit).to_s : attribute
+        when "row_index", "column_index"
+          unit.respond_to?(:attributes) ? unit.attributes[field.to_s].to_s : ""
+        when "section"
+          unit.respond_to?(:attributes) ? unit.attributes["section"].to_s : ""
+        else
+          unit.respond_to?(:attributes) ? unit.attributes[field.to_s].to_s : ""
+        end
+      end
+
+      def attribute_field(unit, field)
+        unit.respond_to?(:attributes) ? unit.attributes[field].to_s : ""
+      end
+
+      def containing_section(unit)
+        return unit if unit.is_a?(ComposerSection)
+        return nil unless unit.respond_to?(:start_line)
+
+        buffer.index.sections.select { |section| section.start_line <= unit.start_line && section.end_line >= unit.end_line }
+          .max_by(&:level)
+      end
+
+      def parent_section(section)
+        return nil unless section&.parent_section_id
+
+        buffer.index.sections.find { |candidate| candidate.id == section.parent_section_id }
+      end
+
+      def ancestor_section(section, heading_token)
+        level = heading_level(heading_token)
+        current = section
+        while current
+          return current if current.level == level
+
+          current = parent_section(current)
+        end
+        nil
+      end
+
+      def section_type(section)
+        return "" unless section.respond_to?(:level)
+
+        section.level.to_i.positive? ? "heading_#{section.level}_section" : "output"
+      end
+
+      def visible_heading_number(unit)
+        return "" unless unit.respond_to?(:raw)
+
+        unit.raw.to_s.lines.first.to_s.sub(/\A\#{1,6}\s+/, "")[/\A\d+(?:\.\d+)*\.?/].to_s
+      end
+
+      def item_count(unit)
+        return 0 unless unit.respond_to?(:raw)
+
+        unit.raw.to_s.lines.count { |line| line.match?(/\A\s*(?:[-*+]|\d+\.)\s+/) }
+      end
+
+      def table_row_count(unit)
+        return 0 unless unit.respond_to?(:raw)
+
+        unit.raw.to_s.lines.count do |line|
+          line.match?(/\A\|.*\|\s*$/) && !line.match?(/\A\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$/)
+        end
+      end
+
+      def table_column_count(unit)
+        return 0 unless unit.respond_to?(:raw)
+
+        row = unit.raw.to_s.lines.find { |line| line.match?(/\A\|.*\|\s*$/) }
+        return 0 unless row
+
+        row.strip.sub(/\A\|/, "").sub(/\|\z/, "").split("|").length
+      end
+    end
+  end
+end

data/lib/markdown_composer/transform_runner/heading_numbering.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module MarkdownComposer
+  class TransformRunner
+    module HeadingNumbering
+      private
+
+      def heading_levels(value)
+        Array(value).map { |item| heading_level(item) }.compact
+      end
+
+      def heading_level(value)
+        token = Registries.default.unit_tokens.normalise(value.to_s) || value.to_s
+        token[/heading_(\d)/, 1]&.to_i
+      end
+
+      def heading_number_candidates(scope, path:)
+        return buffer.index.nodes.select(&:heading?).to_h { |node| [ node.id, true ] } if output_scope?(scope)
+
+        resolver = SelectionResolver.new(index: buffer.index, options: options, diagnostics: diagnostics, path: path)
+        matches = scope["include"] ? resolver.resolve_with_includes(scope, scope["include"]) : resolver.resolve(scope)
+        matches.select { |unit| unit.is_a?(ComposerNode) && unit.heading? }.to_h { |node| [ node.id, true ] }
+      end
+
+      def heading_title_from_line(line)
+        line.to_s.sub(/\A\#{1,6}\s+/, "").strip.sub(/\A(?:\d+(?:\.[[:alnum:]]+)*\.?|[[:alpha:]]+\.)(?:\s+)/, "")
+      end
+
+      def heading_number(counters, level, formats)
+        (1..level).map do |counter_level|
+          next unless counters[counter_level].positive?
+
+          format_number(counters[counter_level], formats.fetch(counter_level, "decimal"))
+        end.compact.join(".")
+      end
+
+      def heading_number_title_separator(number)
+        number.include?(".") ? " " : ". "
+      end
+
+      def heading_number_formats(value)
+        default = Hash.new("decimal")
+        case value
+        when Hash
+          value.each_with_object(default.dup) do |(level, format), formats|
+            heading_level_value = heading_level(level)
+            formats[heading_level_value] = format.to_s if heading_level_value
+          end
+        when Array
+          value.each_with_index.with_object(default.dup) do |(format, index), formats|
+            formats[index + 1] = format.to_s
+          end
+        else
+          text = value.to_s.strip
+          return default if text.empty?
+
+          text.split(",").each_with_object(default.dup) do |part, formats|
+            level, format = part.split(":", 2).map(&:strip)
+            if format
+              heading_level_value = heading_level(level)
+              formats[heading_level_value] = format if heading_level_value
+            else
+              formats[formats.length + 1] = level
+            end
+          end
+        end
+      end
+
+      def format_number(number, format)
+        case format.to_s
+        when "alpha", "letter" then alpha_number(number)
+        when "roman" then roman_number(number)
+        when "upper_alpha" then alpha_number(number).upcase
+        when "upper_roman" then roman_number(number).upcase
+        else number.to_s
+        end
+      end
+
+      def alpha_number(number)
+        value = number.to_i
+        result = +""
+        while value.positive?
+          value -= 1
+          result.prepend((97 + (value % 26)).chr)
+          value /= 26
+        end
+        result
+      end
+
+      def roman_number(number)
+        value = number.to_i
+        numerals = [
+          [ 1000, "m" ], [ 900, "cm" ], [ 500, "d" ], [ 400, "cd" ],
+          [ 100, "c" ], [ 90, "xc" ], [ 50, "l" ], [ 40, "xl" ],
+          [ 10, "x" ], [ 9, "ix" ], [ 5, "v" ], [ 4, "iv" ], [ 1, "i" ]
+        ]
+        numerals.each_with_object(+"") do |(amount, numeral), result|
+          while value >= amount
+            result << numeral
+            value -= amount
+          end
+        end
+      end
+    end
+  end
+end