mdlint 0.1.0

data/lib/mdlint/parser/inline_parser.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+module Mdlint
+  module Parser
+    class InlineParser
+      ESCAPE_CHARS = '!"#$%&\'()*+,\\-./:;<=>?@[\\\\\\]^_`{|}~'
+      ESCAPE_REGEXP = /\\([#{Regexp.escape(ESCAPE_CHARS)}])/
+      BACKTICK_REGEXP = /(`+)(.+?)\1(?!`)/
+      AUTOLINK_REGEXP = %r{<((?:https?|ftp)://[^>]+)>}
+      EMAIL_AUTOLINK_REGEXP = /<([a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>/
+      HTML_INLINE_REGEXP = %r{</?[a-zA-Z][a-zA-Z0-9]*(?:\s+[^>]*)?>}
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def parse(content)
+        tokens = []
+        parse_inline(content, tokens)
+        tokens
+      end
+
+      def parse_inline(content, tokens)
+        pos = 0
+        text_buffer = ""
+
+        while pos < content.length
+          remaining = content[pos..]
+
+          if (match = remaining.match(/\A\\([\\`*_\[\]()#+\-.!{}<>])/))
+            flush_text(text_buffer, tokens)
+            text_buffer = ""
+            tokens << Token.new(type: :text, content: match[1])
+            pos += match[0].length
+          elsif remaining.start_with?("![")
+            if (match = remaining.match(/\A!\[([^\]]*)\]\(([^)\s]*)(?:\s+"([^"]*)")?\)/))
+              flush_text(text_buffer, tokens)
+              text_buffer = ""
+              tokens << Token.new(
+                type: :image,
+                tag: "img",
+                attrs: {
+                  src: match[2],
+                  alt: match[1],
+                  title: match[3]
+                }.compact,
+                content: match[1]
+              )
+              pos += match[0].length
+            else
+              text_buffer += remaining[0]
+              pos += 1
+            end
+          elsif remaining.start_with?("[")
+            # Inline link: [text](url "title")
+            if (match = remaining.match(/\A\[([^\]]*)\]\(([^)\s]*)(?:\s+"([^"]*)")?\)/))
+              flush_text(text_buffer, tokens)
+              text_buffer = ""
+              tokens << Token.new(
+                type: :link_open,
+                tag: "a",
+                nesting: 1,
+                attrs: {
+                  href: match[2],
+                  title: match[3]
+                }.compact
+              )
+              parse_inline(match[1], tokens)
+              tokens << Token.new(
+                type: :link_close,
+                tag: "a",
+                nesting: -1
+              )
+              pos += match[0].length
+            # Full reference link: [text][label]
+            elsif (match = remaining.match(/\A\[([^\]]*)\]\[([^\]]*)\]/))
+              flush_text(text_buffer, tokens)
+              text_buffer = ""
+              label = match[2].empty? ? match[1] : match[2]
+              tokens << Token.new(
+                type: :link_open,
+                tag: "a",
+                nesting: 1,
+                attrs: { reference_label: label.downcase },
+                markup: "reference"
+              )
+              parse_inline(match[1], tokens)
+              tokens << Token.new(
+                type: :link_close,
+                tag: "a",
+                nesting: -1,
+                markup: "reference"
+              )
+              pos += match[0].length
+            # Shortcut reference link: [label]
+            elsif (match = remaining.match(/\A\[([^\]]+)\](?!\(|\[)/))
+              flush_text(text_buffer, tokens)
+              text_buffer = ""
+              label = match[1]
+              tokens << Token.new(
+                type: :link_open,
+                tag: "a",
+                nesting: 1,
+                attrs: { reference_label: label.downcase },
+                markup: "reference"
+              )
+              tokens << Token.new(type: :text, content: label)
+              tokens << Token.new(
+                type: :link_close,
+                tag: "a",
+                nesting: -1,
+                markup: "reference"
+              )
+              pos += match[0].length
+            else
+              text_buffer += remaining[0]
+              pos += 1
+            end
+          elsif remaining.start_with?("`")
+            if (match = remaining.match(/\A(`+)(.+?)\1(?!`)/m))
+              flush_text(text_buffer, tokens)
+              text_buffer = ""
+              code_content = match[2]
+              code_content = code_content.strip if code_content.start_with?(" ") && code_content.end_with?(" ")
+              tokens << Token.new(
+                type: :code_inline,
+                tag: "code",
+                content: code_content,
+                markup: match[1]
+              )
+              pos += match[0].length
+            else
+              text_buffer += remaining[0]
+              pos += 1
+            end
+          elsif remaining.start_with?("**")
+            if (match = remaining.match(/\A\*\*(?!\s)(.+?)(?<!\s)\*\*/m))
+              flush_text(text_buffer, tokens)
+              text_buffer = ""
+              tokens << Token.new(type: :strong_open, tag: "strong", nesting: 1, markup: "**")
+              parse_inline(match[1], tokens)
+              tokens << Token.new(type: :strong_close, tag: "strong", nesting: -1, markup: "**")
+              pos += match[0].length
+            else
+              text_buffer += remaining[0]
+              pos += 1
+            end
+          elsif remaining.start_with?("__")
+            if (match = remaining.match(/\A__(?!\s)(.+?)(?<!\s)__/m))
+              flush_text(text_buffer, tokens)
+              text_buffer = ""
+              tokens << Token.new(type: :strong_open, tag: "strong", nesting: 1, markup: "__")
+              parse_inline(match[1], tokens)
+              tokens << Token.new(type: :strong_close, tag: "strong", nesting: -1, markup: "__")
+              pos += match[0].length
+            else
+              text_buffer += remaining[0]
+              pos += 1
+            end
+          elsif remaining.start_with?("*")
+            if (match = remaining.match(/\A\*(?!\s)(.+?)(?<!\s)\*/m))
+              flush_text(text_buffer, tokens)
+              text_buffer = ""
+              tokens << Token.new(type: :em_open, tag: "em", nesting: 1, markup: "*")
+              parse_inline(match[1], tokens)
+              tokens << Token.new(type: :em_close, tag: "em", nesting: -1, markup: "*")
+              pos += match[0].length
+            else
+              text_buffer += remaining[0]
+              pos += 1
+            end
+          elsif remaining.start_with?("_")
+            if (match = remaining.match(/\A_(?!\s)(.+?)(?<!\s)_/m))
+              flush_text(text_buffer, tokens)
+              text_buffer = ""
+              tokens << Token.new(type: :em_open, tag: "em", nesting: 1, markup: "_")
+              parse_inline(match[1], tokens)
+              tokens << Token.new(type: :em_close, tag: "em", nesting: -1, markup: "_")
+              pos += match[0].length
+            else
+              text_buffer += remaining[0]
+              pos += 1
+            end
+          elsif remaining.start_with?("<")
+            if (match = remaining.match(/\A#{AUTOLINK_REGEXP}/))
+              flush_text(text_buffer, tokens)
+              text_buffer = ""
+              tokens << Token.new(
+                type: :link_open,
+                tag: "a",
+                nesting: 1,
+                attrs: { href: match[1] },
+                markup: "autolink"
+              )
+              tokens << Token.new(type: :text, content: match[1])
+              tokens << Token.new(
+                type: :link_close,
+                tag: "a",
+                nesting: -1,
+                markup: "autolink"
+              )
+              pos += match[0].length
+            elsif (match = remaining.match(/\A#{EMAIL_AUTOLINK_REGEXP}/))
+              flush_text(text_buffer, tokens)
+              text_buffer = ""
+              tokens << Token.new(
+                type: :link_open,
+                tag: "a",
+                nesting: 1,
+                attrs: { href: "mailto:#{match[1]}" },
+                markup: "autolink"
+              )
+              tokens << Token.new(type: :text, content: match[1])
+              tokens << Token.new(
+                type: :link_close,
+                tag: "a",
+                nesting: -1,
+                markup: "autolink"
+              )
+              pos += match[0].length
+            elsif (match = remaining.match(/\A#{HTML_INLINE_REGEXP}/))
+              flush_text(text_buffer, tokens)
+              text_buffer = ""
+              tokens << Token.new(type: :html_inline, content: match[0])
+              pos += match[0].length
+            else
+              text_buffer += remaining[0]
+              pos += 1
+            end
+          elsif remaining.start_with?("  \n")
+            flush_text(text_buffer, tokens)
+            text_buffer = ""
+            tokens << Token.new(type: :hardbreak, tag: "br")
+            pos += 3
+          elsif remaining[0] == "\n"
+            flush_text(text_buffer, tokens)
+            text_buffer = ""
+            tokens << Token.new(type: :softbreak)
+            pos += 1
+          else
+            text_buffer += remaining[0]
+            pos += 1
+          end
+        end
+
+        flush_text(text_buffer, tokens)
+      end
+
+      private
+
+      def flush_text(buffer, tokens)
+        return if buffer.empty?
+
+        tokens << Token.new(type: :text, content: buffer)
+      end
+    end
+  end
+end

data/lib/mdlint/parser/state.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Mdlint
+  module Parser
+    class State
+      attr_reader :src, :lines, :line_offsets
+      attr_accessor :line, :pos, :tokens, :level
+
+      def initialize(src)
+        @src = src
+        @lines = src.split("\n", -1)
+        @line_offsets = build_line_offsets
+        @line = 0
+        @pos = 0
+        @tokens = []
+        @level = 0
+      end
+
+      def eof?
+        @line >= @lines.length
+      end
+
+      def current_line
+        @lines[@line]
+      end
+
+      def next_line
+        @line += 1
+      end
+
+      def skip_blank_lines
+        while !eof? && blank_line?(@line)
+          @line += 1
+        end
+      end
+
+      def blank_line?(line_num = @line)
+        return true if line_num >= @lines.length
+
+        @lines[line_num].match?(/\A\s*\z/)
+      end
+
+      def remaining_lines
+        @lines[@line..]
+      end
+
+      def peek_line(offset = 1)
+        @lines[@line + offset]
+      end
+
+      private
+
+      def build_line_offsets
+        offsets = [0]
+        @lines.each do |line|
+          offsets << offsets.last + line.length + 1
+        end
+        offsets
+      end
+    end
+  end
+end

data/lib/mdlint/parser.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "parser/state"
+require_relative "parser/block_parser"
+require_relative "parser/inline_parser"
+
+module Mdlint
+  module Parser
+    class << self
+      def parse(src)
+        block_parser = BlockParser.new
+        tokens = block_parser.parse(src)
+        parse_inline_tokens(tokens)
+        tokens
+      end
+
+      private
+
+      def parse_inline_tokens(tokens)
+        inline_parser = InlineParser.new
+        tokens.each do |token|
+          next unless token.type == :inline
+
+          token.children = inline_parser.parse(token.content)
+        end
+      end
+    end
+  end
+end