markdown_composer 0.7.0

data/lib/markdown_composer/composition_buffer.rb

@@ -0,0 +1,378 @@
+# frozen_string_literal: true
+
+module MarkdownComposer
+  class CompositionBuffer
+    attr_reader :diagnostics, :origin_nodes
+
+    def initialize(markdown = +"", diagnostics: Diagnostics.new)
+      @markdown = markdown.dup
+      @diagnostics = diagnostics
+      @origin_nodes = []
+    end
+
+    def markdown
+      @markdown.dup
+    end
+
+    def empty?
+      @markdown.strip.empty?
+    end
+
+    def set(units)
+      @markdown = units_to_markdown(units)
+      @origin_nodes = origin_units(units)
+      self
+    end
+
+    def append(units)
+      @origin_nodes.concat(origin_units(units))
+      insert_at_end(units_to_markdown(units))
+    end
+
+    def prepend(units)
+      @origin_nodes = origin_units(units) + @origin_nodes
+      insert_at_start(units_to_markdown(units))
+    end
+
+    def insert_before(target, units, options: {})
+      insert_relative(target, units, :before, options: options)
+    end
+
+    def insert_after(target, units, options: {})
+      insert_relative(target, units, :after, options: options)
+    end
+
+    def replace(target, units, options: {})
+      if target && target["position"] == "output"
+        return set(units)
+      end
+
+      ranges = target_ranges(target, options: options)
+      return warn_empty_destructive_target("replace", path: "target") if ranges.empty?
+
+      @origin_nodes.concat(origin_units(units))
+      replace_ranges(ranges, units_to_markdown(units))
+    end
+
+    def remove(target, options: {})
+      ranges = target_ranges(target, options: options)
+      return warn_empty_destructive_target("remove_buffer_target", path: "target") if ranges.empty?
+
+      replace_ranges(ranges, "")
+    end
+
+    def copy(target, units, options: {})
+      placement = target&.fetch("placement", nil) || "after"
+      placement == "before" ? insert_before(target, units, options: options) : insert_after(target, units, options: options)
+    end
+
+    def place_markdown(target, markdown, origin_nodes: [], options: {})
+      target ||= { "position" => "end" }
+      content = normalize_markdown_fragment(markdown)
+      origins = Array(origin_nodes).compact
+
+      case target["position"]
+      when "output"
+        @origin_nodes = origins
+        @markdown = trim_outer_blank_lines(content)
+        @markdown = normalize_markdown_fragment(@markdown) unless @markdown.empty?
+      when "start"
+        @origin_nodes = origins + @origin_nodes
+        insert_at_start(content)
+      when "end"
+        @origin_nodes.concat(origins)
+        insert_at_end(content)
+      when nil
+        place_markdown_relative(target, content, origins, target["placement"] == "before" ? :before : :after, options: options)
+      end
+
+      self
+    end
+
+    def insert_between(start_target, end_target, units, options: {})
+      start_ranges = target_ranges(start_target, options: options)
+      end_ranges = target_ranges(end_target, options: options)
+      return diagnostics.warn("target.empty", "Between target matched no buffer content", path: "target") if start_ranges.empty? || end_ranges.empty?
+
+      start_range = start_ranges.first
+      end_range = end_ranges.first
+      if start_range.end >= end_range.begin
+        diagnostics.error("target.order_invalid", "Between start anchor must resolve before end anchor", path: "target")
+        return self
+      end
+
+      @origin_nodes.concat(origin_units(units))
+      buffer_lines = lines
+      @markdown = join_markdown_fragments(
+        buffer_lines[0...start_range.end].to_a.join,
+        units_to_markdown(units),
+        buffer_lines[start_range.end..].to_a.join
+      )
+      self
+    end
+
+    def move(selector, target, units = nil, options: {})
+      ranges = units ? unit_ranges(units) : target_ranges(selector, options: options)
+      return warn_empty_destructive_target("move", path: "select") if ranges.empty?
+      return warn_empty_destructive_target("move", path: "target") if target_ranges(target, options: options).empty?
+
+      moved = units ? units_to_markdown(units) : ranges.map { |range| lines[(range.begin - 1)..(range.end - 1)].join }.join("\n")
+      replace_ranges(ranges, "")
+      unit = ComposerNode.new(id: "buffer:moved", source_key: "buffer", type: "paragraph", source_position: 0, level: nil, text: moved, attributes: {}, children: [], raw: moved, start_line: 1, end_line: moved.lines.length)
+      copy(target, [ unit ], options: options)
+    end
+
+    def index
+      DocumentIndex.from_markdown(@markdown, source_key: "buffer", diagnostics: diagnostics)
+    end
+
+    def replace_markdown(markdown)
+      @markdown = markdown.to_s
+      self
+    end
+
+    def replace_markdown_ranges(replacements)
+      buffer_lines = lines
+      Array(replacements).sort_by { |replacement| replacement.fetch(:range).begin }.reverse_each do |replacement|
+        range = replacement.fetch(:range)
+        content = replacement.fetch(:markdown).to_s
+        start = [ range.begin - 1, 0 ].max
+        finish = [ range.end - 1, buffer_lines.length - 1 ].min
+        replacement_lines = content.empty? ? [] : [ normalize_markdown_fragment(content) ]
+        buffer_lines[start..finish] = replacement_lines
+      end
+      @markdown = buffer_lines.join
+      sync_origins_to_current!
+      self
+    end
+
+    def dedupe_by_origin!
+      seen = {}
+      deduped = []
+      origin_nodes.each do |node|
+        key = node.attributes["origin_id"] || node.id
+        next if seen[key]
+
+        seen[key] = true
+        deduped << node
+      end
+      set(deduped)
+    end
+
+    def sync_origins_to_current!
+      @origin_nodes = index.nodes
+      self
+    end
+
+    def to_h
+      {
+        type: "composition_buffer",
+        markdown: markdown,
+        origins: origin_nodes.map { |node| { id: node.id, origin_id: node.attributes["origin_id"], source_key: node.source_key, source_position: node.source_position } },
+        nodes: index.nodes.map(&:to_h),
+        sections: index.sections.map(&:to_h)
+      }
+    end
+
+    private
+
+    def insert_relative(target, units, placement, options:)
+      ranges = target_ranges(target, options: options)
+      content = units_to_markdown(units)
+      return diagnostics.warn("target.empty", "Target matched no buffer content", path: "target") if ranges.empty?
+
+      range = ranges.first
+      buffer_lines = lines
+      insertion_index = placement == :before ? range.begin - 1 : range.end
+      @markdown = join_markdown_fragments(
+        buffer_lines[0...insertion_index].to_a.join,
+        content,
+        buffer_lines[insertion_index..].to_a.join
+      )
+      @origin_nodes.concat(origin_units(units))
+      self
+    end
+
+    def place_markdown_relative(target, content, origins, placement, options:)
+      if target["placement"] == "between"
+        return place_markdown_between(target["start"], target["end"], content, origins, options: options)
+      end
+
+      ranges = target_ranges(target, options: options)
+      return diagnostics.warn("target.empty", "Target matched no buffer content", path: "target") if ranges.empty?
+
+      range = ranges.first
+      buffer_lines = lines
+      insertion_index = placement == :before ? range.begin - 1 : range.end
+      @markdown = join_markdown_fragments(
+        buffer_lines[0...insertion_index].to_a.join,
+        content,
+        buffer_lines[insertion_index..].to_a.join
+      )
+      @origin_nodes.concat(origins)
+      self
+    end
+
+    def place_markdown_between(start_target, end_target, content, origins, options:)
+      start_ranges = target_ranges(start_target, options: options)
+      end_ranges = target_ranges(end_target, options: options)
+      return diagnostics.warn("target.empty", "Between target matched no buffer content", path: "target") if start_ranges.empty? || end_ranges.empty?
+
+      start_range = start_ranges.first
+      end_range = end_ranges.first
+      if start_range.end >= end_range.begin
+        diagnostics.error("target.order_invalid", "Between start anchor must resolve before end anchor", path: "target")
+        return self
+      end
+
+      buffer_lines = lines
+      @markdown = join_markdown_fragments(
+        buffer_lines[0...start_range.end].to_a.join,
+        content,
+        buffer_lines[start_range.end..].to_a.join
+      )
+      @origin_nodes.concat(origins)
+      self
+    end
+
+    def insert_at_end(content)
+      @markdown = join_markdown_fragments(@markdown, content)
+      self
+    end
+
+    def insert_at_start(content)
+      @markdown = join_markdown_fragments(content, @markdown)
+      self
+    end
+
+    def target_ranges(target, options:)
+      target ||= { "position" => "output" }
+      return [ 1..[ lines.length, 1 ].max ] if target["position"] == "output"
+      return [ 1..0 ] if target["position"] == "start"
+      return [ (lines.length + 1)..lines.length ] if target["position"] == "end"
+
+      idx = index
+      resolver = SelectionResolver.new(index: idx, options: options, diagnostics: diagnostics, path: "target")
+      selector = target.reject { |key, _| %w[placement start end position].include?(key) }
+      resolver.resolve(selector).map { |unit| unit.start_line..unit.end_line }
+    end
+
+    def unit_ranges(units)
+      Array(units).compact
+        .reject { |unit| unit.respond_to?(:attributes) && unit.attributes["derived"] }
+        .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 warn_empty_destructive_target(action, path:)
+      diagnostics.warn(
+        "target.empty_destructive",
+        "#{action} matched no buffer content and made no destructive change",
+        path: path,
+        details: { action: action }
+      )
+      self
+    end
+
+    def replace_ranges(ranges, content)
+      buffer_lines = lines
+      ranges.sort_by(&:begin).reverse_each do |range|
+        start = [ range.begin - 1, 0 ].max
+        finish = [ range.end - 1, buffer_lines.length - 1 ].min
+        replacement = content.empty? ? [] : [ normalize_markdown_fragment(content) ]
+        buffer_lines[start..finish] = replacement
+      end
+      @markdown = buffer_lines.join
+      self
+    end
+
+    def units_to_markdown(units)
+      serialize_units(origin_units(units))
+    end
+
+    def origin_units(units)
+      Array(units).compact.uniq(&:id).sort_by(&:source_position).map { |unit| clone_origin(unit) }
+    end
+
+    def clone_origin(unit)
+      attrs = unit.attributes.merge("origin_id" => unit.attributes["origin_id"] || unit.id, "origin_source_key" => unit.attributes["origin_source_key"] || unit.source_key)
+      unit.with(id: "buffer:#{unit.id}:#{object_id}:#{unit.source_position}", source_key: "buffer", attributes: attrs)
+    end
+
+    def serialize_units(units)
+      result = +""
+      previous = nil
+      Array(units).each do |unit|
+        text = normalize_markdown_fragment(unit.raw)
+        next if text.strip.empty?
+
+        if result.empty?
+          result << text
+        elsif tight_continuation?(previous, unit)
+          result = result.sub(/\n+\z/, "\n")
+          result << text.sub(/\A\n+/, "")
+        else
+          result = result.sub(/\n+\z/, "\n\n")
+          result << text.sub(/\A\n+/, "")
+        end
+        previous = unit
+      end
+      result
+    end
+
+    def join_markdown_fragments(*fragments)
+      text = fragments.map { |fragment| trim_outer_blank_lines(fragment) }
+        .reject(&:empty?)
+        .join("\n\n")
+      text.empty? ? +"" : "#{text}\n"
+    end
+
+    def normalize_markdown_fragment(content)
+      text = content.to_s
+      text = "#{text}\n" unless text.end_with?("\n")
+      text
+    end
+
+    def trim_outer_blank_lines(content)
+      fragment_lines = normalize_markdown_fragment(content).lines
+      fragment_lines.shift while fragment_lines.first&.strip&.empty?
+      fragment_lines.pop while fragment_lines.last&.strip&.empty?
+      fragment_lines.join.sub(/\n\z/, "")
+    end
+
+    def tight_continuation?(previous, current)
+      return false unless previous && current
+      return false unless previous.source_key == current.source_key
+
+      contiguous_list_items?(previous, current) || contiguous_table_fragments?(previous, current)
+    end
+
+    def contiguous_list_items?(previous, current)
+      return false unless previous.type == "list_item" && current.type == "list_item"
+      return false unless previous.attributes["ordered"] == current.attributes["ordered"]
+
+      current.start_line == previous.end_line + 1
+    end
+
+    def contiguous_table_fragments?(previous, current)
+      return false unless table_fragment?(previous) && table_fragment?(current)
+
+      current.start_line <= previous.end_line + 1
+    end
+
+    def table_fragment?(unit)
+      %w[table_head table_body table_row table_header table_cell].include?(unit.type)
+    end
+
+    def lines
+      @markdown.lines
+    end
+  end
+end

data/lib/markdown_composer/data_path.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+module MarkdownComposer
+  module DataPath
+    module_function
+
+    def resolve(data_block, path, diagnostics:, diagnostic_path:)
+      unless data_block.type == "data_block"
+        diagnostics.error("data_path.scope_invalid", "data_path is only valid inside data_block include scope", path: diagnostic_path)
+        return []
+      end
+
+      data = parse_data(data_block, diagnostics: diagnostics, path: diagnostic_path)
+      return [] if data.nil?
+
+      evaluated = evaluate(data, path.to_s, diagnostics: diagnostics, diagnostic_path: diagnostic_path)
+      values = evaluated.is_a?(Array) ? evaluated : [ evaluated ].compact
+      diagnostics.warn("data_path.empty", "Data path matched no values", path: diagnostic_path) if values.empty?
+      values.each_with_index.map { |value, index| node_for(data_block, path, value, index) }
+    end
+
+    def parse_data(data_block, diagnostics:, path:)
+      format = data_block.attributes.fetch("format", "auto").to_s
+      source = data_block.text.to_s
+      case format
+      when "json"
+        JSON.parse(source)
+      when "yaml", "yml"
+        YAML.safe_load(source, permitted_classes: [ Symbol ], aliases: false)
+      else
+        parse_auto(source)
+      end
+    rescue JSON::ParserError, Psych::Exception => e
+      diagnostics.error("data_path.invalid_data", "Invalid #{format} data: #{e.message}", path: path)
+      nil
+    end
+
+    def parse_auto(source)
+      JSON.parse(source)
+    rescue JSON::ParserError
+      YAML.safe_load(source, permitted_classes: [ Symbol ], aliases: false)
+    end
+
+    def evaluate(data, expression, diagnostics:, diagnostic_path:)
+      current = data
+      segments = split_path(expression)
+      index = 0
+      while index < segments.length
+        segment = segments[index]
+        if segment == "**" && segments[index + 1]
+          current = recursive_project(current, segments[index + 1])
+          index += 2
+          next
+        end
+
+        current = apply_segment(current, segment, diagnostics: diagnostics, diagnostic_path: diagnostic_path)
+        index += 1
+      end
+      current
+    end
+
+    def split_path(expression)
+      split_top_level(expression.to_s, ".").map(&:strip).reject(&:empty?)
+    end
+
+    def apply_segment(current, segment, diagnostics:, diagnostic_path:)
+      key, filter = parse_segment(segment)
+      current = project(current, key, diagnostics: diagnostics, diagnostic_path: diagnostic_path) unless key.empty?
+      if filter
+        current = quoted?(filter) ? project(current, unquote(filter), diagnostics: diagnostics, diagnostic_path: diagnostic_path) : apply_filter(current, filter, diagnostics: diagnostics, diagnostic_path: diagnostic_path)
+      end
+      current
+    end
+
+    def parse_segment(segment)
+      if segment =~ /\A([^\[]*)\[(.+)\]\z/
+        [ normalize_key(Regexp.last_match(1).strip), Regexp.last_match(2).strip ]
+      else
+        [ normalize_key(segment.strip), nil ]
+      end
+    end
+
+    def project(current, key, diagnostics:, diagnostic_path:)
+      keys = split_key_list(key)
+      if keys.length > 1
+        return Array(current).map { |item| project_keys(item, keys, diagnostics: diagnostics, diagnostic_path: diagnostic_path) }.compact if current.is_a?(Array)
+        return project_keys(current, keys, diagnostics: diagnostics, diagnostic_path: diagnostic_path)
+      end
+
+      key = keys.first
+      case current
+      when Hash
+        fetch_key(current, key, diagnostics: diagnostics, diagnostic_path: diagnostic_path)
+      when Array
+        current.map { |item| project(item, key, diagnostics: diagnostics, diagnostic_path: diagnostic_path) }.flatten.compact
+      else
+        diagnostics.warn("data_path.type_mismatch", "Cannot read #{key.inspect} from #{current.class}", path: diagnostic_path)
+        nil
+      end
+    end
+
+    def project_keys(item, keys, diagnostics:, diagnostic_path:)
+      unless item.is_a?(Hash)
+        diagnostics.warn("data_path.type_mismatch", "Cannot project keys from #{item.class}", path: diagnostic_path)
+        return nil
+      end
+
+      keys.each_with_object({}) do |key, hash|
+        value = fetch_key(item, key, diagnostics: diagnostics, diagnostic_path: diagnostic_path)
+        hash[key] = value unless value.nil?
+      end
+    end
+
+    def fetch_key(hash, key, diagnostics:, diagnostic_path:)
+      return hash[key] if hash.key?(key)
+      return hash[key.to_sym] if hash.key?(key.to_sym)
+
+      diagnostics.warn("data_path.missing_key", "Missing data key #{key.inspect}", path: diagnostic_path)
+      nil
+    end
+
+    def apply_filter(current, filter, diagnostics:, diagnostic_path:)
+      if take_filter?(filter)
+        errors = Take.validate(Take.parse(filter))
+        errors.each { |message| diagnostics.error("data_path.take_invalid", message, path: diagnostic_path) }
+        return [] if errors.any?
+
+        return Take.apply(Array(current), Take.parse(filter), diagnostics: diagnostics, path: diagnostic_path)
+      end
+
+      Array(current).select { |item| filter_match?(item, filter) }
+    end
+
+    def take_filter?(filter)
+      filter.match?(/\A(?:all|odd|even)\z/) ||
+        filter.match?(/\A(?:first|last|position|range|ranges|skip|skip_last|every|except|top_percent|bottom_percent|middle|middle_percent|alternate|random):/)
+    end
+
+    def filter_match?(item, filter)
+      return false unless item.is_a?(Hash)
+
+      split_top_level(filter, "|").any? do |or_group|
+        split_top_level(or_group, ";").all? { |atom| filter_atom_match?(item, atom.strip) }
+      end
+    end
+
+    def filter_atom_match?(item, atom)
+      negated = atom.start_with?("!") && !atom.start_with?("!=")
+      atom = atom[1..-1].to_s.strip if negated
+
+      matched = if atom =~ /\A([^!<>=~]+)(!?=|>=|<=|>|<|~=)(.+)\z/
+        key = Regexp.last_match(1).strip
+        operator = Regexp.last_match(2)
+        expected = cast(unquote(Regexp.last_match(3).strip))
+        actual = cast(item[key] || item[key.to_sym])
+        compare(actual, operator, expected)
+      else
+        !!(item[atom] || item[atom.to_sym])
+      end
+      negated ? !matched : matched
+    end
+
+    def compare(actual, operator, expected)
+      case operator
+      when "=" then actual.to_s == expected.to_s
+      when "!=" then actual.to_s != expected.to_s
+      when ">" then numeric(actual) > numeric(expected)
+      when ">=" then numeric(actual) >= numeric(expected)
+      when "<" then numeric(actual) < numeric(expected)
+      when "<=" then numeric(actual) <= numeric(expected)
+      when "~=" then actual.to_s.include?(expected.to_s)
+      else false
+      end
+    end
+
+    def unquote(value)
+      value.sub(/\A["']/, "").sub(/["']\z/, "")
+    end
+
+    def quoted?(value)
+      value.to_s.match?(/\A(["']).*\1\z/)
+    end
+
+    def normalize_key(key)
+      unquote(key.to_s).gsub("\\.", ".").gsub("\\,", ",")
+    end
+
+    def split_key_list(key)
+      split_top_level(key.to_s, ",").map { |part| normalize_key(part.strip) }.reject(&:empty?)
+    end
+
+    def split_top_level(text, delimiter)
+      parts = []
+      current = +""
+      quote = nil
+      bracket_depth = 0
+      escaped = false
+      text.to_s.each_char do |char|
+        if escaped
+          current << char
+          escaped = false
+          next
+        end
+
+        if char == "\\"
+          escaped = true
+          next
+        end
+
+        if quote
+          quote = nil if char == quote
+          current << char
+          next
+        end
+
+        if char == '"' || char == "'"
+          quote = char
+          current << char
+          next
+        end
+
+        bracket_depth += 1 if char == "["
+        bracket_depth -= 1 if char == "]" && bracket_depth.positive?
+
+        if char == delimiter && bracket_depth.zero?
+          parts << current
+          current = +""
+        else
+          current << char
+        end
+      end
+      parts << current
+      parts
+    end
+
+    def recursive_project(current, key)
+      key = normalize_key(key)
+      values = []
+      collect_recursive_values(current, key, values)
+      values
+    end
+
+    def collect_recursive_values(current, key, values)
+      case current
+      when Hash
+        values << current[key] if current.key?(key)
+        values << current[key.to_sym] if current.key?(key.to_sym)
+        current.each_value { |value| collect_recursive_values(value, key, values) }
+      when Array
+        current.each { |value| collect_recursive_values(value, key, values) }
+      end
+    end
+
+    def cast(value)
+      return value if value.is_a?(Numeric) || value == true || value == false
+      return value.to_i if value.to_s.match?(/\A-?\d+\z/)
+      return value.to_f if value.to_s.match?(/\A-?\d+\.\d+\z/)
+
+      value.to_s
+    end
+
+    def numeric(value)
+      value.is_a?(Numeric) ? value : value.to_s.to_f
+    end
+
+    def node_for(data_block, path, value, index)
+      type = value.is_a?(Hash) ? "data_record" : "data_value"
+      value_text = render_value(value)
+      ComposerNode.new(
+        id: "#{data_block.id}:data:#{index + 1}",
+        source_key: data_block.source_key,
+        type: type,
+        source_position: data_block.source_position * 1000 + index + 1,
+        level: nil,
+        text: value_text.strip,
+        attributes: data_block.attributes.merge(
+          "path" => path.to_s,
+          "source_type" => "data_block",
+          "value" => value,
+          "value_type" => value_type(value)
+        ),
+        children: [],
+        raw: value_text.end_with?("\n") ? value_text : "#{value_text}\n",
+        start_line: data_block.start_line,
+        end_line: data_block.end_line
+      )
+    end
+
+    def render_value(value)
+      case value
+      when Hash
+        YAML.dump(value).sub(/\A---\s*\n/, "")
+      when Array
+        value.map { |item| render_value(item).strip }.join("\n")
+      else
+        value.to_s
+      end
+    end
+
+    def value_type(value)
+      case value
+      when Hash then "object"
+      when Array then "array"
+      when String then "string"
+      when Integer then "integer"
+      when Float then "float"
+      when TrueClass, FalseClass then "boolean"
+      when NilClass then "null"
+      else value.class.name
+      end
+    end
+  end
+end