mdom 0.1.0 → 0.3.0

data/lib/mdom/nodes.rb

@@ -1,214 +0,0 @@
-# frozen_string_literal: true
-
-module MDOM
-  # Node type constants, shared across the code base.
-  module Types
-    DOCUMENT   = :document
-    HEADING    = :heading
-    PARAGRAPH  = :paragraph
-    LIST       = :list
-    LIST_ITEM  = :list_item
-    LIST_ITEM_LINE = :list_item_line
-    BLOCKQUOTE = :blockquote
-    CODE_BLOCK = :code_block
-    HRULE      = :hrule
-
-    TEXT       = :text
-    EMPHASIS   = :emphasis
-    STRONG     = :strong
-    CODE       = :code
-    LINK       = :link
-    IMAGE      = :image
-    SOFTBREAK  = :softbreak
-    HARDBREAK  = :hardbreak
-  end
-
-  # -- Block nodes ----------------------------------------------------------
-
-  # Each concrete node class fixes its +type+ and declares which children it
-  # accepts. Subclassing Node keeps everything a Node so traversal is uniform.
-  class BlockNode < Node
-  end
-
-  class Document < BlockNode
-    def initialize(children: [])
-      super(Types::DOCUMENT, children: children)
-    end
-  end
-
-  class Heading < BlockNode
-    attr_reader :level
-
-    def initialize(level, children: [], attributes: {})
-      @level = level.to_i
-      super(Types::HEADING, attributes: attributes.merge(level: @level), children: children)
-    end
-  end
-
-  class Paragraph < BlockNode
-    def initialize(children: [])
-      super(Types::PARAGRAPH, children: children)
-    end
-  end
-
-  class List < BlockNode
-    # ordered: true/false, tight: true/false, start: integer for ordered lists
-    def initialize(ordered: false, tight: true, start: nil, children: [], attributes: {})
-      attrs = { ordered: ordered, tight: tight }.merge(attributes)
-      attrs[:start] = start unless start.nil?
-      super(Types::LIST, attributes: attrs, children: children)
-    end
-
-    def ordered?
-      attributes[:ordered]
-    end
-  end
-
-  class ListItem < BlockNode
-    def initialize(children: [])
-      super(Types::LIST_ITEM, children: children)
-    end
-  end
-
-  class Blockquote < BlockNode
-    def initialize(children: [])
-      super(Types::BLOCKQUOTE, children: children)
-    end
-  end
-
-  class CodeBlock < BlockNode
-    # lang: language string (may be nil), fenced: true/false, literal: source text
-    def initialize(literal, lang: nil, fenced: true, attributes: {})
-      attrs = { fenced: fenced }.merge(attributes)
-      attrs[:lang] = lang unless lang.nil?
-      super(Types::CODE_BLOCK, attributes: attrs)
-      # Code block text is kept as a raw string, not child nodes.
-      @literal = literal
-    end
-
-    attr_reader :literal
-
-    def lang
-      attributes[:lang]
-    end
-
-    def fenced?
-      attributes[:fenced]
-    end
-
-    def to_s
-      "#<MDOM::CodeBlock fenced=#{fenced?} lang=#{lang.inspect}>"
-    end
-  end
-
-  class Hrule < BlockNode
-    def initialize(attributes: {})
-      super(Types::HRULE, attributes: attributes)
-    end
-  end
-
-  def self.allocate_node(type, **attrs)
-    case type
-    when Types::HEADING then Heading.new(attrs.fetch(:level, 1), attributes: attrs[:attributes])
-    when Types::PARAGRAPH then Paragraph.new
-    when Types::LIST then List.new(**attrs)
-    when Types::LIST_ITEM then ListItem.new
-    when Types::BLOCKQUOTE then Blockquote.new
-    when Types::HRULE then Hrule.new
-    else
-      BlockNode.new(type, attributes: attrs)
-    end
-  end
-
-  # -- Inline nodes ---------------------------------------------------------
-
-  class InlineNode < Node
-  end
-
-  class Text < InlineNode
-    def initialize(value)
-      @value = value
-      super(Types::TEXT)
-    end
-
-    attr_reader :value
-
-    def to_s
-      @value
-    end
-  end
-
-  class Emphasis < InlineNode
-    def initialize(children: [])
-      super(Types::EMPHASIS, children: children)
-    end
-  end
-
-  class Strong < InlineNode
-    def initialize(children: [])
-      super(Types::STRONG, children: children)
-    end
-  end
-
-  class Code < InlineNode
-    def initialize(value)
-      @value = value
-      super(Types::CODE)
-    end
-
-    attr_reader :value
-
-    def to_s
-      @value
-    end
-  end
-
-  class Link < InlineNode
-    def initialize(dest, title: nil, children: [])
-      attrs = { destination: dest }
-      attrs[:title] = title unless title.nil?
-      super(Types::LINK, attributes: attrs, children: children)
-    end
-
-    def destination
-      attributes[:destination]
-    end
-
-    def title
-      attributes[:title]
-    end
-  end
-
-  class Image < InlineNode
-    def initialize(dest, alt: nil, title: nil)
-      attrs = { destination: dest }
-      attrs[:alt] = alt unless alt.nil?
-      attrs[:title] = title unless title.nil?
-      super(Types::IMAGE, attributes: attrs)
-    end
-
-    def destination
-      attributes[:destination]
-    end
-
-    def alt
-      attributes[:alt]
-    end
-
-    def title
-      attributes[:title]
-    end
-  end
-
-  class Softbreak < InlineNode
-    def initialize
-      super(Types::SOFTBREAK)
-    end
-  end
-
-  class Hardbreak < InlineNode
-    def initialize
-      super(Types::HARDBREAK)
-    end
-  end
-end

data/lib/mdom/serializer.rb

@@ -1,165 +0,0 @@
-# frozen_string_literal: true
-
-module MDOM
-  # Serializes an MDOM tree back to a Markdown string. Traversal is driven by
-  # node type; the context (indentation level, in-blockquote flag, list marker)
-  # flows downward so nested lists and blockquotes render correctly.
-  class Serializer
-    # Serialize +node+ to Markdown. Returns a String.
-    def self.serialize(node, indent: 0, blockquote: false)
-      new.serialize(node, indent: indent, blockquote: blockquote)
-    end
-
-    def serialize(node, indent: 0, blockquote: false)
-      case node.type
-      when Types::DOCUMENT then serialize_document(node)
-      when Types::HEADING then serialize_heading(node, indent: indent, blockquote: blockquote)
-      when Types::PARAGRAPH then serialize_paragraph(node, indent: indent, blockquote: blockquote)
-      when Types::LIST then serialize_list(node, indent: indent, blockquote: blockquote)
-      when Types::LIST_ITEM then serialize_list_item(node, indent: indent, blockquote: blockquote)
-      when Types::BLOCKQUOTE then serialize_blockquote(node, indent: indent)
-      when Types::CODE_BLOCK then serialize_code_block(node, indent: indent, blockquote: blockquote)
-      when Types::HRULE then serialize_hrule(indent: indent, blockquote: blockquote)
-      else serialize_inline(node)
-      end
-    end
-
-    private
-
-    def serialize_document(node)
-      blocks = node.children.map { |c| serialize(c) }
-      join_blocks(blocks)
-    end
-
-    def serialize_heading(node, indent:, blockquote:)
-      prefix = spaces(indent)
-      text = serialize_inline_children(node.children)
-      line = "#{'#' * node.level} #{text}"
-      wrap(prefix + line, blockquote)
-    end
-
-    def serialize_paragraph(node, indent:, blockquote:)
-      prefix = spaces(indent)
-      inner = serialize_inline_children(node.children)
-      inner_lines = inner.split("\n").map { |l| prefix + l }
-      # Hard breaks (two trailing spaces) were captured as soft/hardbreak nodes;
-      # join preserved '\n' and treat each line under the same prefix.
-      wrap_inline_lines(inner_lines.join("\n"), blockquote)
-    end
-
-    def serialize_list(node, indent:, blockquote:)
-      marker = node.ordered? ? nil : "-"
-      start = node.ordered? ? (node.attributes[:start] || 1) : nil
-      lines = node.children.each_with_index.map do |item, idx|
-        num = start ? "#{start + idx}." : marker
-        serialize_list_item(item, marker: num, indent: indent, blockquote: blockquote)
-      end
-      wrap(lines.join("\n"), blockquote)
-    end
-
-    def serialize_list_item(node, indent:, blockquote:, marker:)
-      head = marker || "-"
-      prefix = spaces(indent)
-      marker_col = indent + head.length + 1
-      task = node.attributes[:task] ? "[#{node.attributes[:checked] ? 'x' : ' '}] " : ""
-
-      first = node.children.first
-      first_line =
-        if first && first.type == Types::PARAGRAPH
-          "#{prefix}#{head} #{task}#{first.plain_text}"
-        elsif first
-          "#{prefix}#{head} #{task}#{serialize(first, indent: marker_col, blockquote: blockquote).strip}"
-        else
-          "#{prefix}#{head} #{task}"
-        end
-
-      rest = node.children[1..] || []
-      rest_lines = rest.map { |c| serialize(c, indent: marker_col, blockquote: blockquote) }
-      [first_line, *rest_lines].join("\n")
-    end
-
-    def serialize_blockquote(node, indent:)
-      inner = node.children.map { |c| serialize(c) }.join("\n\n")
-      inner.lines.map(&:chomp).map { |l| l.strip.empty? ? ">" : "#{spaces(indent)}> #{l}" }.join("\n")
-    end
-
-    def serialize_code_block(node, indent:, blockquote:)
-      prefix = spaces(indent)
-      if node.fenced?
-        fence = "```"
-        lang = node.lang ? node.lang : ""
-        content = node.literal.to_s.lines.map { |l| prefix + l.chomp }.join("\n")
-        wrap("#{prefix}#{fence}#{lang}\n#{content}\n#{prefix}#{fence}", blockquote)
-      else
-        # Indented code: 4 spaces.
-        lines = node.literal.to_s.split("\n").map { |l| prefix + "    " + l }
-        wrap(lines.join("\n"), blockquote)
-      end
-    end
-
-    def serialize_hrule(indent:, blockquote:)
-      wrap(spaces(indent) + "---", blockquote)
-    end
-
-    # -- inline -------------------------------------------------------------
-
-    def serialize_inline(node)
-      serialize_inline_children(node.children)
-    end
-
-    def serialize_inline_children(children)
-      children.map { |c| serialize_inline_node(c) }.join
-    end
-
-    def serialize_inline_node(node)
-      case node.type
-      when Types::TEXT then node.value.to_s
-      when Types::EMPHASIS then "*#{serialize_inline_children(node.children)}*"
-      when Types::STRONG then "**#{serialize_inline_children(node.children)}**"
-      when Types::CODE then "`#{node.value}`"
-      when Types::LINK then serialize_link(node)
-      when Types::IMAGE then serialize_image(node)
-      when Types::SOFTBREAK then "\n"
-      when Types::HARDBREAK then "  \n"
-      when Types::DOCUMENT, Types::PARAGRAPH, Types::HEADING
-        serialize_inline_children(node.children)
-      else node.respond_to?(:value) ? node.value.to_s : ""
-      end
-    end
-
-    def serialize_link(node)
-      label = serialize_inline_children(node.children)
-      title = node.title ? %( "#{node.title}") : ""
-      "[#{label}](#{node.destination}#{title})"
-    end
-
-    def serialize_image(node)
-      title = node.title ? %( "#{node.title}") : ""
-      "![#{node.alt}](#{node.destination}#{title})"
-    end
-
-    # -- helpers ------------------------------------------------------------
-
-    def spaces(n)
-      " " * n
-    end
-
-    # Join top-level blocks with a single blank line between them.
-    def join_blocks(blocks)
-      blocks.map { |b| b.sub(/\A\n+|\n+\z/, "") }.join("\n\n")
-    end
-
-    # Prefix already-indented block content with a blockquote marker per line.
-    def wrap(content, blockquote)
-      return content unless blockquote
-
-      content.lines.map { |l| l.strip.empty? ? ">" : "> #{l}" }.join
-    end
-
-    def wrap_inline_lines(content, blockquote)
-      return content unless blockquote
-
-      content.lines.map { |l| l.strip.empty? ? ">" : "> #{l}" }.join
-    end
-  end
-end