mdlint 0.1.0

data/lib/mdlint/renderer/md_renderer.rb

@@ -0,0 +1,458 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Mdlint
+  module Renderer
+    class MdRenderer
+      BULLET_MARKERS = %w[- *].freeze
+      HORIZONTAL_RULE = "_" * 70
+
+      def initialize(options = {})
+        @options = options
+        @bullet_list_depth = 0
+        @reference_definitions = {}
+        @used_references = Set.new
+      end
+
+      def render(tokens)
+        @bullet_list_depth = 0
+        @reference_definitions = {}
+        @used_references = Set.new
+        @ordered_list_counter = 0
+
+        # First pass: collect all reference definitions
+        collect_reference_definitions(tokens)
+
+        output = []
+        render_tokens(tokens, output)
+
+        # Append used reference definitions at the end, sorted by label
+        append_reference_definitions(output)
+
+        result = output.join
+        result.gsub!(/\n{3,}/, "\n\n")
+
+        # Apply end of line setting
+        result = apply_end_of_line(result)
+
+        result.chomp!
+        result += "\n" unless result.empty?
+        result
+      end
+
+      def apply_end_of_line(text)
+        eol = @options[:end_of_line] || :lf
+        case eol
+        when :lf
+          text.gsub(/\r\n/, "\n")
+        when :crlf
+          text.gsub(/\r?\n/, "\r\n")
+        when :keep
+          text
+        else
+          text.gsub(/\r\n/, "\n")
+        end
+      end
+
+      def collect_reference_definitions(tokens)
+        tokens.each do |token|
+          next unless token.type == :reference_definition
+
+          label = token.attrs[:label]
+          # Only keep the first definition for each label (remove duplicates)
+          @reference_definitions[label] ||= {
+            url: token.attrs[:url],
+            title: token.attrs[:title]
+          }
+        end
+      end
+
+      def append_reference_definitions(output)
+        # mdformat converts reference links to inline links, so no definitions needed
+        # This method is kept for potential future use or configuration options
+      end
+
+      private
+
+      def render_tokens(tokens, output)
+        i = 0
+        while i < tokens.length
+          token = tokens[i]
+          case token.type
+          when :heading_open
+            i = render_heading(tokens, i, output)
+          when :paragraph_open
+            i = render_paragraph(tokens, i, output)
+          when :bullet_list_open
+            i = render_bullet_list(tokens, i, output)
+          when :ordered_list_open
+            i = render_ordered_list(tokens, i, output)
+          when :blockquote_open
+            i = render_blockquote(tokens, i, output)
+          when :fence
+            render_fence(token, output)
+            i += 1
+          when :code_block
+            render_code_block(token, output)
+            i += 1
+          when :hr
+            output << "#{HORIZONTAL_RULE}\n\n"
+            i += 1
+          when :html_block
+            output << token.content
+            output << "\n" unless token.content.end_with?("\n")
+            i += 1
+          when :reference_definition
+            # Skip - will be output at the end
+            i += 1
+          else
+            i += 1
+          end
+        end
+      end
+
+      def render_heading(tokens, start_index, output)
+        open_token = tokens[start_index]
+        level = open_token.tag[1].to_i
+        markup = "#" * level
+
+        inline_content = ""
+        i = start_index + 1
+        while i < tokens.length && tokens[i].type != :heading_close
+          if tokens[i].type == :inline
+            inline_content = render_inline(tokens[i])
+          end
+          i += 1
+        end
+
+        output << "#{markup} #{inline_content}\n\n"
+        i + 1
+      end
+
+      def render_paragraph(tokens, start_index, output)
+        inline_content = ""
+        i = start_index + 1
+        while i < tokens.length && tokens[i].type != :paragraph_close
+          if tokens[i].type == :inline
+            inline_content = render_inline(tokens[i])
+          end
+          i += 1
+        end
+
+        wrapped_content = wrap_text(inline_content)
+        output << "#{wrapped_content}\n\n"
+        i + 1
+      end
+
+      def wrap_text(text)
+        wrap_mode = @options[:wrap] || :keep
+
+        case wrap_mode
+        when :keep
+          text
+        when :no
+          # Remove soft line breaks, join lines
+          text.gsub(/\n(?!\n)/, " ")
+        when Integer
+          # Wrap at specified width
+          wrap_at_width(text, wrap_mode)
+        else
+          text
+        end
+      end
+
+      def wrap_at_width(text, width)
+        return text if width <= 0
+
+        lines = []
+        paragraphs = text.split(/\n\n+/)
+
+        paragraphs.each_with_index do |paragraph, idx|
+          # Join lines within paragraph
+          paragraph = paragraph.gsub(/\n(?!\n)/, " ")
+          words = paragraph.split(/\s+/)
+          current_line = ""
+
+          words.each do |word|
+            if current_line.empty?
+              current_line = word
+            elsif (current_line.length + 1 + word.length) <= width
+              current_line += " " + word
+            else
+              lines << current_line
+              current_line = word
+            end
+          end
+
+          lines << current_line unless current_line.empty?
+          lines << "" if idx < paragraphs.length - 1
+        end
+
+        lines.join("\n")
+      end
+
+      def render_bullet_list(tokens, start_index, output)
+        marker = BULLET_MARKERS[@bullet_list_depth % 2]
+        @bullet_list_depth += 1
+        i = start_index + 1
+
+        while i < tokens.length && tokens[i].type != :bullet_list_close
+          if tokens[i].type == :list_item_open
+            i = render_list_item(tokens, i, output, "#{marker} ")
+          else
+            i += 1
+          end
+        end
+
+        @bullet_list_depth -= 1
+        output << "\n" unless output.last&.end_with?("\n\n")
+        i + 1
+      end
+
+      def render_ordered_list(tokens, start_index, output)
+        open_token = tokens[start_index]
+        start_num = open_token.attrs[:start] || 1
+        current_num = start_num
+        i = start_index + 1
+
+        while i < tokens.length && tokens[i].type != :ordered_list_close
+          if tokens[i].type == :list_item_open
+            if @options[:number]
+              # Consecutive numbering mode
+              i = render_list_item(tokens, i, output, "#{current_num}. ")
+              current_num += 1
+            else
+              # mdformat default: all items use the same number (start number)
+              i = render_list_item(tokens, i, output, "#{start_num}. ")
+            end
+          else
+            i += 1
+          end
+        end
+
+        output << "\n" unless output.last&.end_with?("\n\n")
+        i + 1
+      end
+
+      def render_list_item(tokens, start_index, output, prefix)
+        i = start_index + 1
+        item_content = []
+
+        while i < tokens.length && tokens[i].type != :list_item_close
+          token = tokens[i]
+          case token.type
+          when :paragraph_open
+            i = collect_paragraph_content(tokens, i, item_content)
+          when :bullet_list_open
+            nested_output = []
+            i = render_bullet_list(tokens, i, nested_output)
+            nested = nested_output.join.split("\n").map { |l| "   #{l}" }.join("\n")
+            item_content << nested
+          when :ordered_list_open
+            nested_output = []
+            i = render_ordered_list(tokens, i, nested_output)
+            nested = nested_output.join.split("\n").map { |l| "   #{l}" }.join("\n")
+            item_content << nested
+          else
+            i += 1
+          end
+        end
+
+        content = item_content.join("\n").strip
+        output << "#{prefix}#{content}\n"
+        i + 1
+      end
+
+      def collect_paragraph_content(tokens, start_index, content_array)
+        i = start_index + 1
+        while i < tokens.length && tokens[i].type != :paragraph_close
+          if tokens[i].type == :inline
+            content_array << render_inline(tokens[i])
+          end
+          i += 1
+        end
+        i + 1
+      end
+
+      def render_blockquote(tokens, start_index, output)
+        i = start_index + 1
+        inner_output = []
+
+        while i < tokens.length && tokens[i].type != :blockquote_close
+          token = tokens[i]
+          case token.type
+          when :paragraph_open
+            i = render_paragraph(tokens, i, inner_output)
+          when :heading_open
+            i = render_heading(tokens, i, inner_output)
+          when :blockquote_open
+            i = render_blockquote(tokens, i, inner_output)
+          else
+            i += 1
+          end
+        end
+
+        quoted = inner_output.join.chomp.split("\n").map { |l| "> #{l}".rstrip }.join("\n")
+        output << "#{quoted}\n\n"
+        i + 1
+      end
+
+      def render_fence(token, output)
+        info = token.info || ""
+        content = token.content.chomp
+
+        # Determine the minimum number of backticks needed
+        backtick_count = 3
+        content.scan(/`+/) do |match|
+          backtick_count = [backtick_count, match.length + 1].max
+        end
+
+        marker = "`" * backtick_count
+
+        output << "#{marker}#{info}\n"
+        output << "#{content}\n"
+        output << "#{marker}\n\n"
+      end
+
+      def render_code_block(token, output)
+        # Convert indented code blocks to fenced code blocks (mdformat style)
+        content = token.content.chomp
+
+        # Determine the minimum number of backticks needed
+        backtick_count = 3
+        content.scan(/`+/) do |match|
+          backtick_count = [backtick_count, match.length + 1].max
+        end
+
+        marker = "`" * backtick_count
+
+        output << "#{marker}\n"
+        output << "#{content}\n"
+        output << "#{marker}\n\n"
+      end
+
+      def render_inline(token)
+        return token.content if token.children.empty?
+
+        render_inline_tokens(token.children)
+      end
+
+      def render_inline_tokens(tokens)
+        output = []
+        i = 0
+
+        while i < tokens.length
+          token = tokens[i]
+          case token.type
+          when :text
+            output << token.content
+          when :code_inline
+            content = token.content
+            # Strip unnecessary leading/trailing spaces (unless content contains backticks)
+            unless content.include?("`")
+              content = content.strip
+            end
+            # Determine minimum backticks needed
+            backtick_count = 1
+            content.scan(/`+/) do |match|
+              backtick_count = [backtick_count, match.length + 1].max
+            end
+            backticks = "`" * backtick_count
+            # Add space padding if content starts/ends with backtick
+            if content.start_with?("`") || content.end_with?("`")
+              output << "#{backticks} #{content} #{backticks}"
+            else
+              output << "#{backticks}#{content}#{backticks}"
+            end
+          when :strong_open
+            markup = token.markup.empty? ? "**" : token.markup
+            close_index = find_close_token(tokens, i, :strong_close)
+            inner = render_inline_tokens(tokens[(i + 1)...close_index])
+            output << "#{markup}#{inner}#{markup}"
+            i = close_index
+          when :em_open
+            markup = token.markup.empty? ? "*" : token.markup
+            close_index = find_close_token(tokens, i, :em_close)
+            inner = render_inline_tokens(tokens[(i + 1)...close_index])
+            output << "#{markup}#{inner}#{markup}"
+            i = close_index
+          when :link_open
+            close_index = find_close_token(tokens, i, :link_close)
+            inner = render_inline_tokens(tokens[(i + 1)...close_index])
+
+            if token.markup == "autolink"
+              href = token.attrs[:href] || ""
+              output << "<#{href}>"
+            elsif token.markup == "reference"
+              # Reference link - resolve from definitions
+              label = token.attrs[:reference_label]
+              ref = @reference_definitions[label]
+              if ref
+                @used_references << label
+                formatted_href = format_link_url(ref[:url])
+                if ref[:title]
+                  output << "[#{inner}](#{formatted_href} \"#{ref[:title]}\")"
+                else
+                  output << "[#{inner}](#{formatted_href})"
+                end
+              else
+                # Reference not found, keep as-is
+                output << "[#{inner}]"
+              end
+            else
+              href = token.attrs[:href] || ""
+              title = token.attrs[:title]
+              formatted_href = format_link_url(href)
+              if title
+                output << "[#{inner}](#{formatted_href} \"#{title}\")"
+              else
+                output << "[#{inner}](#{formatted_href})"
+              end
+            end
+            i = close_index
+          when :image
+            alt = token.attrs[:alt] || token.content || ""
+            src = token.attrs[:src] || ""
+            title = token.attrs[:title]
+            if title
+              output << "![#{alt}](#{src} \"#{title}\")"
+            else
+              output << "![#{alt}](#{src})"
+            end
+          when :softbreak
+            output << "\n"
+          when :hardbreak
+            output << "\\\n"
+          when :html_inline
+            output << token.content
+          end
+          i += 1
+        end
+
+        output.join
+      end
+
+      def find_close_token(tokens, start_index, close_type)
+        i = start_index + 1
+        while i < tokens.length
+          return i if tokens[i].type == close_type
+
+          i += 1
+        end
+        tokens.length
+      end
+
+      def format_link_url(url)
+        # Remove angle brackets if present and not needed
+        url = url.gsub(/^<|>$/, "")
+        # Add angle brackets only if URL contains spaces or parentheses
+        if url.match?(/[\s()]/)
+          "<#{url}>"
+        else
+          url
+        end
+      end
+    end
+  end
+end

data/lib/mdlint/renderer.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "renderer/md_renderer"
+
+module Mdlint
+  module Renderer
+    class << self
+      def render(tokens, options = {})
+        MdRenderer.new(options).render(tokens)
+      end
+    end
+  end
+end

data/lib/mdlint/token.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Mdlint
+  class Token
+    attr_accessor :type, :tag, :nesting, :level, :content, :markup, :info, :meta, :map, :children, :attrs
+
+    def initialize(type:, **kwargs)
+      @type = type
+      @tag = kwargs[:tag]
+      @nesting = kwargs[:nesting] || 0
+      @level = kwargs[:level] || 0
+      @content = kwargs[:content] || ""
+      @markup = kwargs[:markup] || ""
+      @info = kwargs[:info] || ""
+      @meta = kwargs[:meta] || {}
+      @map = kwargs[:map]
+      @children = kwargs[:children] || []
+      @attrs = kwargs[:attrs] || {}
+    end
+
+    def opening?
+      @nesting == 1
+    end
+
+    def closing?
+      @nesting == -1
+    end
+
+    def self_closing?
+      @nesting.zero?
+    end
+
+    def block?
+      BLOCK_TYPES.include?(@type)
+    end
+
+    def inline?
+      INLINE_TYPES.include?(@type)
+    end
+
+    BLOCK_TYPES = %i[
+      document
+      heading_open heading_close
+      paragraph_open paragraph_close
+      bullet_list_open bullet_list_close
+      ordered_list_open ordered_list_close
+      list_item_open list_item_close
+      blockquote_open blockquote_close
+      code_block fence
+      hr html_block
+      inline
+    ].freeze
+
+    INLINE_TYPES = %i[
+      text
+      strong_open strong_close
+      em_open em_close
+      code_inline
+      link_open link_close
+      image
+      softbreak hardbreak
+      html_inline
+    ].freeze
+  end
+end

data/lib/mdlint/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Mdlint
+  VERSION = "0.1.0"
+end

data/lib/mdlint.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "mdlint/version"
+require_relative "mdlint/token"
+require_relative "mdlint/parser"
+require_relative "mdlint/renderer"
+require_relative "mdlint/linter"
+
+module Mdlint
+  class Error < StandardError; end
+
+  class << self
+    def format(src, options = {})
+      tokens = Parser.parse(src)
+      Renderer.render(tokens, options)
+    end
+
+    def format_file(path, options = {})
+      src = File.read(path)
+      formatted = format(src, options)
+
+      if options[:check]
+        src != formatted
+      else
+        File.write(path, formatted) unless options[:diff]
+        formatted
+      end
+    end
+
+    def parse(src)
+      Parser.parse(src)
+    end
+
+    def lint(src, options = {})
+      Linter.check(src, options)
+    end
+
+    def lint_file(path, options = {})
+      src = File.read(path)
+      lint(src, options)
+    end
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: mdlint
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Mdlint is a Pure Ruby Markdown linter and formatter with no external
+  dependencies. It provides configurable lint rules and automatic formatting for consistent
+  Markdown files.
+email:
+- t.yudai92@gmail.com
+executables:
+- mdlint
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/mdlint
+- lib/mdlint.rb
+- lib/mdlint/cli.rb
+- lib/mdlint/config.rb
+- lib/mdlint/linter.rb
+- lib/mdlint/linter/rule.rb
+- lib/mdlint/linter/rule_engine.rb
+- lib/mdlint/linter/rules/first_line_heading.rb
+- lib/mdlint/linter/rules/heading_increment.rb
+- lib/mdlint/linter/rules/heading_style.rb
+- lib/mdlint/linter/rules/no_multiple_blanks.rb
+- lib/mdlint/linter/rules/no_trailing_spaces.rb
+- lib/mdlint/linter/violation.rb
+- lib/mdlint/parser.rb
+- lib/mdlint/parser/block_parser.rb
+- lib/mdlint/parser/inline_parser.rb
+- lib/mdlint/parser/state.rb
+- lib/mdlint/renderer.rb
+- lib/mdlint/renderer/md_renderer.rb
+- lib/mdlint/token.rb
+- lib/mdlint/version.rb
+homepage: https://github.com/ydah/mdlint
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/ydah/mdlint
+  source_code_uri: https://github.com/ydah/mdlint
+  changelog_uri: https://github.com/ydah/mdlint/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.4
+specification_version: 4
+summary: A Pure Ruby Markdown linter and formatter
+test_files: []