asciidoctor_vaped 0.1.0

data/lib/asciidoctor_vaped/parser/blocks/admonition.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "common/base_node"
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class Admonition < BaseNode
+        PATTERN = /\A(NOTE|TIP|IMPORTANT|WARNING|CAUTION):\s+(.+)\z/
+
+        def parse(context)
+          name, text = context.reader.read.match(PATTERN).captures
+          context.append AST::Element.new(:admonition, attributes: { name: }, children: Inline.parse(text))
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks/common/base_node.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class BaseNode
+        def initialize(successor = nil)
+          @successor = successor
+        end
+
+        def handle(context)
+          return parse(context) if match?(context)
+
+          @successor&.handle(context)
+        end
+
+        def match?(context)
+          context.reader.peek&.match?(self.class::PATTERN)
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks/common/blank_line.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "base_node"
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class BlankLine < BaseNode
+        def match?(context)
+          context.reader.peek&.strip == ""
+        end
+
+        def parse(context)
+          context.reader.skip_blank_lines
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks/common/comment.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "base_node"
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class Comment < BaseNode
+        def match?(context)
+          context.reader.peek&.start_with?("//")
+        end
+
+        def parse(context)
+          context.reader.peek == "////" ? context.reader.read_delimited("////") : context.reader.read
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks/delimited/delimited_node.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "../common/base_node"
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class DelimitedNode < BaseNode
+        def match?(context)
+          delimiters.include?(context.reader.peek)
+        end
+
+        def parse(context)
+          lines = context.reader.read_delimited(context.reader.peek)
+          node = build_node(context, lines)
+          context.append node
+        end
+
+        def delimiters
+          [delimiter]
+        end
+
+        def attributes(context)
+          return {} unless admonition?(context)
+
+          { name: context.pending_attributes[:style].to_s.upcase }
+        end
+
+        def context_name(context)
+          admonition?(context) ? :admonition : default_context_name
+        end
+
+        private
+
+        def build_node(context, lines)
+          text = lines.join("\n")
+          return AST::Element.new(context_name(context), attributes: attributes(context), children: parse_children(context, lines)) if compound?(context)
+
+          AST::Element.new(context_name(context), attributes: attributes(context), children: [Inline.text_node(text)])
+        end
+
+        def parse_children(context, lines)
+          node = AST::Element.new(context_name(context), attributes: attributes(context))
+          Parser.parse_nodes context.nested(node, Reader.new(lines.join("\n")))
+          node.children
+        end
+
+        def compound?(context)
+          admonition?(context)
+        end
+
+        def admonition?(context)
+          context.pending_attributes[:style]&.to_s&.match?(/\A(?:NOTE|TIP|IMPORTANT|WARNING|CAUTION)\z/i)
+        end
+
+        def default_context_name
+          raise NotImplementedError, "#{self.class} must implement #default_context_name"
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks/delimited/example.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "delimited_node"
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class Example < DelimitedNode
+        def delimiter = "===="
+        def default_context_name = :example
+
+        private
+
+        def compound?(_context) = true
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks/delimited/listing.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "delimited_node"
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class Listing < DelimitedNode
+        def delimiter = "----"
+        def default_context_name = :listing
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks/delimited/literal.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "delimited_node"
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class Literal < DelimitedNode
+        def delimiter = "...."
+        def default_context_name = :literal
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks/delimited/open.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "delimited_node"
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class Open < DelimitedNode
+        def delimiter = "--"
+        def default_context_name = :open
+
+        private
+
+        def compound?(_context) = true
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks/delimited/passthrough.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "delimited_node"
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class Passthrough < DelimitedNode
+        def delimiters = %w[+++ ++++]
+        def default_context_name = :pass
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks/delimited/quote.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "delimited_node"
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class Quote < DelimitedNode
+        def delimiter = "____"
+        def default_context_name = :quote
+
+        private
+
+        def compound?(_context) = true
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks/delimited/sidebar.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "delimited_node"
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class Sidebar < DelimitedNode
+        def delimiter = "****"
+        def default_context_name = :sidebar
+
+        private
+
+        def compound?(_context) = true
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks/heading.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "common/base_node"
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class Heading < BaseNode
+        PATTERN = /\A(=+)\s+(.+)\z/
+
+        def parse(context)
+          markers, title = context.reader.read.match(PATTERN).captures
+          level = [markers.length - 1, 1].max
+          context.open_section AST::Element.new(:section, attributes: { level: }, children: Inline.parse(title))
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks/lists/list_base.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../common/base_node"
+require_relative "list_item"
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class ListBase < BaseNode
+        def match?(context)
+          context.reader.peek&.match?(pattern)
+        end
+
+        def parse(context)
+          list = AST::Element.new(list_context)
+          item_context = context.nested(list)
+          item_chain.handle(item_context) while match?(context)
+          context.append(list)
+        end
+
+        private
+
+        def item_chain
+          Blocks.chain([[ListItem, { pattern: }]])
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks/lists/list_item.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "../common/base_node"
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class ListItem < BaseNode
+        def initialize(successor = nil, pattern:)
+          super(successor)
+          @pattern = pattern
+        end
+
+        def match?(context)
+          context.reader.peek&.match?(@pattern)
+        end
+
+        def parse(context)
+          context.append AST::Element.new(:list_item, children: Inline.parse(context.reader.read.sub(@pattern, "")))
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks/lists/ordered_list.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "list_base"
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class OrderedList < ListBase
+        private
+
+        def list_context = :olist
+        def pattern = /\A\.\s+/
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks/lists/unordered_list.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "list_base"
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class UnorderedList < ListBase
+        private
+
+        def list_context = :ulist
+        def pattern = /\A[*-]\s+/
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks/metadata/caption.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "../common/base_node"
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class Caption < BaseNode
+        PATTERN = /\A\.([^.\s].*)\z/
+
+        def parse(context)
+          context.pending_title = context.reader.read.match(PATTERN)[1]
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks/metadata/document_attribute.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../common/base_node"
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class DocumentAttribute < BaseNode
+        PATTERN = /\A:([^:\s][^:]*):\s*(.*)\z/
+
+        def parse(context)
+          name, value = context.reader.read.match(PATTERN).captures
+          context.document.register_attribute(name, value)
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks/metadata/element_attributes.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative "../common/base_node"
+require "strscan"
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class ElementAttributes < BaseNode
+        PATTERN = /\A\[(.+)\]\z/
+
+        def parse(context)
+          context.add_pending_attributes parse_attributes(context.reader.read.match(PATTERN)[1])
+        end
+
+        private
+
+        def parse_attributes(value)
+          split_attributes(value).each_with_object({ positional: [] }) do |part, attributes|
+            parse_attribute(part, attributes)
+          end.then { |attributes| normalize_attributes(attributes) }
+        end
+
+        def split_attributes(value)
+          value.scan(/(?:"[^"]*"|'[^']*'|[^,])+/).map(&:strip).reject(&:empty?)
+        end
+
+        def parse_attribute(part, attributes)
+          name, value = part.split("=", 2)
+          return attributes[:positional] << unquote(part) unless value
+
+          assign_named_attribute(attributes, name.strip, unquote(value.strip))
+        end
+
+        def assign_named_attribute(attributes, name, value)
+          key = normalize_name(name)
+          return parse_options(value, attributes) if key == :opts
+
+          attributes[key] = value
+        end
+
+        def normalize_attributes(attributes)
+          positional = attributes.delete(:positional)
+          parse_shorthand(positional.shift, attributes)
+          attributes[:language] = positional.shift if attributes[:style] == :source && positional.any?
+          positional.each { |part| attributes[normalize_name(part)] = true }
+          attributes
+        end
+
+        def parse_shorthand(value, attributes)
+          return unless value
+
+          scanner = StringScanner.new(value)
+          attributes[:style] = scanner.scan(/[^\s#.%]+/)&.to_sym
+          parse_shorthand_marks(scanner.rest, attributes)
+        end
+
+        def parse_shorthand_marks(value, attributes)
+          value.scan(/([#.%])([^#.%]+)/).each do |mark, name|
+            case mark
+            when "#" then attributes[:id] = name
+            when "." then append_role(attributes, name)
+            when "%" then attributes[normalize_name(name)] = true
+            end
+          end
+        end
+
+        def append_role(attributes, name)
+          attributes[:role] = [attributes[:role], name].compact.join(" ")
+        end
+
+        def parse_options(value, attributes)
+          value.split(",").map(&:strip).each { |option| attributes[normalize_name(option)] = true }
+        end
+
+        def normalize_name(value)
+          value.tr("-", "_").to_sym
+        end
+
+        def unquote(value)
+          value.sub(/\A(["'])(.*)\1\z/, "\\2")
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks/paragraph.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "common/base_node"
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class Paragraph < BaseNode
+        def match?(_context)
+          true
+        end
+
+        def parse(context)
+          lines = context.reader.read_until_blank
+          context.append AST::Element.new(:paragraph, children: Inline.parse(lines.join("\n")))
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks/tables/table.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "../delimited/delimited_node"
+require_relative "table_row"
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class Table < DelimitedNode
+        def delimiter = "|==="
+
+        def parse(context)
+          table = AST::Element.new(:table)
+          rows(context.reader.read_delimited(delimiter)).each { |cells| table << TableRow.build(cells) }
+          context.append(table)
+        end
+
+        private
+
+        def rows(lines)
+          columns = nil
+          pending = []
+          rows = []
+
+          lines.each do |line|
+            cells = cells_for(line)
+            next if cells.empty?
+
+            if cells.length > 1
+              columns ||= cells.length
+              flush_pending(rows, pending, columns)
+              cells.each_slice(columns) { |row| rows << row }
+            elsif columns
+              pending.concat(cells)
+              flush_pending(rows, pending, columns)
+            else
+              rows << cells
+            end
+          end
+
+          rows << pending unless pending.empty?
+          rows
+        end
+
+        def flush_pending(rows, pending, columns)
+          rows << pending.shift(columns) while pending.length >= columns
+        end
+
+        def cells_for(line)
+          return [] if line.strip == ""
+
+          line.sub(/\A\|/, "").split(/\s+\|/).map(&:strip)
+        end
+
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks/tables/table_cell.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class TableCell
+        def self.build(text)
+          AST::Element.new(:table_cell, children: Inline.parse(text))
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks/tables/table_row.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "table_cell"
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      class TableRow
+        def self.build(cells)
+          AST::Element.new(:table_row, children: cells.map { |cell| TableCell.build(cell) })
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor_vaped/parser/blocks.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "blocks/common/base_node"
+require_relative "blocks/common/blank_line"
+require_relative "blocks/common/comment"
+require_relative "blocks/metadata/document_attribute"
+require_relative "blocks/metadata/caption"
+require_relative "blocks/metadata/element_attributes"
+require_relative "blocks/heading"
+require_relative "blocks/delimited/delimited_node"
+require_relative "blocks/delimited/listing"
+require_relative "blocks/delimited/literal"
+require_relative "blocks/delimited/example"
+require_relative "blocks/delimited/quote"
+require_relative "blocks/delimited/sidebar"
+require_relative "blocks/delimited/open"
+require_relative "blocks/delimited/passthrough"
+require_relative "blocks/tables/table_cell"
+require_relative "blocks/tables/table_row"
+require_relative "blocks/tables/table"
+require_relative "blocks/admonition"
+require_relative "blocks/lists/list_item"
+require_relative "blocks/lists/list_base"
+require_relative "blocks/lists/unordered_list"
+require_relative "blocks/lists/ordered_list"
+require_relative "blocks/paragraph"
+
+module AsciidoctorVaped
+  module Parser
+    module Blocks
+      def self.chain(handlers)
+        handlers.reverse.inject(nil) do |successor, handler|
+          handler, kwargs = handler
+          handler.new(successor, **(kwargs || {}))
+        end
+      end
+    end
+  end
+end