mmmd 0.1.0

data/lib/mmmd/renderers/plainterm.rb

@@ -0,0 +1,452 @@
+# frozen_string_literal: true
+
+# Attempt to source a provider for the wide char width calculator
+# (TODO)
+
+module MMMD
+  # Module for managing terminal output
+  module TextManager
+    # ANSI SGR escape code for bg color
+    # @param text [String]
+    # @param options [Hash]
+    # @return [String]
+    def bg(text, options)
+      color = options['bg']
+      if color.is_a? Integer
+        "\e[48;5;#{color}m#{text}\e[49m"
+      elsif color.is_a? String and color.match?(/\A#[A-Fa-f0-9]{6}\Z/)
+        vector = color.scan(/[A-Fa-f0-9]{2}/).map { |x| x.to_i(16) }
+        "\e[48;2;#{vector[0]};#{vector[1]};#{vector[2]}\e[49m"
+      else
+        Kernel.warn "WARNING: Invalid color - #{color}"
+        text
+      end
+    end
+
+    # ANSI SGR escape code for fg color
+    # @param text [String]
+    # @param options [Hash]
+    # @return [String]
+    def fg(text, options)
+      color = options['fg']
+      if color.is_a? Integer
+        "\e[38;5;#{color}m#{text}\e[39m"
+      elsif color.is_a? String and color.match?(/\A#[A-Fa-f0-9]{6}\Z/)
+        vector = color.scan(/[A-Fa-f0-9]{2}/).map { |x| x.to_i(16) }
+        "\e[38;2;#{vector[0]};#{vector[1]};#{vector[2]}\e[39m"
+      else
+        Kernel.warn "WARNING: Invalid color - #{color}"
+        text
+      end
+    end
+
+    # ANSI SGR escape code for bold text
+    # @param text [String]
+    # @param options [Hash]
+    # @return [String]
+    def bold(text, _options)
+      "\e[1m#{text}\e[22m"
+    end
+
+    # ANSI SGR escape code for italics text
+    # @param text [String]
+    # @param options [Hash]
+    # @return [String]
+    def italics(text, _options)
+      "\e[3m#{text}\e[23m"
+    end
+
+    # ANSI SGR escape code for underline text
+    # @param text [String]
+    # @param options [Hash]
+    # @return [String]
+    def underline(text, _options)
+      "\e[4m#{text}\e[24m"
+    end
+
+    # ANSI SGR escape code for strikethrough text
+    # @param text [String]
+    # @param options [Hash]
+    # @return [String]
+    def strikethrough(text, _options)
+      "\e[9m#{text}\e[29m"
+    end
+
+    # Word wrapping algorithm
+    # @param text [String]
+    # @param width [Integer]
+    # @return [String]
+    def wordwrap(text, width)
+      words = text.split(/( +)/)
+      output = []
+      line = ""
+      length = 0
+      until words.empty?
+        word = words.shift
+        wordlength = smort_length(word)
+        if wordlength > width
+          words.prepend(word[width..])
+          word = word[..width - 1]
+        end
+        if length + wordlength + 1 > width
+          output.append(line.lstrip)
+          line = word
+          length = wordlength
+          next
+        end
+        length += wordlength
+        line += word
+      end
+      output.append(line.lstrip)
+      output.join("\n")
+    end
+
+    # (TODO: smorter stronger better faster)
+    # SmЯt™ word length
+    # @param text [String]
+    # @return [Integer]
+    def smort_length(text)
+      text.gsub(/\e\[[^m]+m/, '').length
+    end
+
+    # Left-justify a line while ignoring terminal control codes
+    # @param text [String]
+    # @param size [Integer]
+    # @return [String]
+    def ljust_cc(text, size)
+      text.lines.map do |line|
+        textlength = smort_length(line)
+        textlength < size ? line + " " * (size - textlength) : line
+      end.join("\n")
+    end
+
+    # Right-justify a line while ignoring terminal control codes
+    # @param text [String]
+    # @param size [Integer]
+    # @return [String]
+    def rjust_cc(text, size)
+      text.lines.map do |line|
+        textlength = smort_length(line)
+        textlength < size ? " " * (size - textlength) + line : line
+      end.join("\n")
+    end
+
+    # Center-justify a line while ignoring terminal control codes
+    # @param text [String]
+    # @param size [Integer]
+    # @return [String]
+    def center_cc(text, size)
+      text.lines.map do |line|
+        textlength = smort_length(line)
+        if textlength < size
+          freelength = size - textlength
+          rightlength = freelength / 2
+          leftlength = freelength - rightlength
+          " " * leftlength + line + " " * rightlength
+        else
+          line
+        end
+      end.join("\n")
+    end
+
+    # Draw a screen-width box around text
+    # @param text [String]
+    # @param options [Hash]
+    # @return [String]
+    def box(text, options)
+      size = options[:hsize] - 2
+      text = wordwrap(text, (size * 0.8).floor).lines.filter_map do |line|
+        "│#{ljust_cc(line, size)}│" unless line.empty?
+      end.join("\n")
+      <<~TEXT
+        ╭#{'─' * size}╮
+        #{text}
+        ╰#{'─' * size}╯
+      TEXT
+    end
+
+    # Draw text right-justified
+    def rjust(text, options)
+      size = options[:hsize]
+      wordwrap(text, (size * 0.8).floor).lines.filter_map do |line|
+        rjust_cc(line, size) unless line.empty?
+      end.join("\n")
+    end
+
+    # Draw text centered
+    def center(text, options)
+      size = options[:hsize]
+      wordwrap(text, (size * 0.8).floor).lines.filter_map do |line|
+        center_cc(line, size) unless line.empty?
+      end.join("\n")
+    end
+
+    # Underline the last line of the text piece
+    def underline_block(text, options)
+      textlines = text.lines
+      last = "".match(/()()()/)
+      textlines.each do |x|
+        current = x.match(/\A(\s*)(.+?)(\s*)\Z/)
+        last = current if smort_length(current[2]) > smort_length(last[2])
+      end
+      ltxt = last[1]
+      ctxt = textlines.last.slice(last.offset(2)[0]..last.offset(2)[1] - 1)
+      rtxt = last[3]
+      textlines[-1] = [ltxt, underline(ctxt, options), rtxt].join('')
+      textlines.join("")
+    end
+
+    # Add extra newlines around the text
+    def extra_newlines(text, options)
+      size = options[:hsize]
+      textlines = text.lines
+      textlines.prepend("#{' ' * size}\n")
+      textlines.append("\n#{' ' * size}\n")
+      textlines.join("")
+    end
+
+    # Underline last line edge to edge
+    def underline_full_block(text, options)
+      textlines = text.lines
+      last_line = textlines.last.match(/^.*$/)[0]
+      textlines[-1] = "#{underline(last_line, options)}\n"
+      textlines.join("")
+    end
+
+    # Indent all lines
+    def indent(text, _options)
+      _indent(text)
+    end
+
+    # Indent all lines (inner)
+    def _indent(text)
+      text.lines.map do |line|
+        "    #{line}"
+      end.join("")
+    end
+
+    # Left overline all lines
+    def leftline(text, _options)
+      text.lines.map do |line|
+        " │  #{line}"
+      end.join("")
+    end
+
+    # Bulletpoints
+    def bullet(text, _options)
+      "-#{_indent(text)[1..]}"
+    end
+
+    # Numbers
+    def numbered(text, options)
+      number = options[:number]
+      length = number.to_s.length + 1
+      (length / 4 + 1).times { text = _indent(text) }
+      "#{number}.#{text[length..]}"
+    end
+  end
+
+  module Renderers
+    module PlaintermConstants
+      DEFAULT_STYLE = {
+        "PointBlank::DOM::Paragraph" => {
+          indent: true,
+          increase_level: true
+        },
+        "PointBlank::DOM::Text" => {},
+        "PointBlank::DOM::SetextHeading1" => {
+          center: true,
+          bold: true,
+          extra_newlines: true,
+          underline_full_block: true
+        },
+        "PointBlank::DOM::SetextHeading2" => {
+          center: true,
+          underline_block: true
+        },
+        "PointBlank::DOM::ATXHeading1" => {
+          center: true,
+          bold: true,
+          extra_newlines: true,
+          underline_full_block: true
+        },
+        "PointBlank::DOM::ATXHeading2" => {
+          center: true,
+          underline_block: true
+        },
+        "PointBlank::DOM::ATXHeading3" => {
+          underline: true,
+          bold: true
+        },
+        "PointBlank::DOM::ATXHeading4" => {
+          bold: true,
+          underline: true
+        },
+        "PointBlank::DOM::ATXHeading5" => {
+          underline: true
+        },
+        "PointBlank::DOM::ATXHeading6" => {
+          underline: true
+        },
+        "PointBlank::DOM::InlineImage" => {
+          underline: true
+        },
+        "PointBlank::DOM::InlineLink" => {
+          underline: true
+        },
+        "PointBlank::DOM::InlinePre" => {},
+        "PointBlank::DOM::InlineEmphasis" => {
+          italics: true
+        },
+        "PointBlank::DOM::InlineStrong" => {
+          bold: true
+        },
+        "PointBlank::DOM::ULListElement" => {
+          bullet: true,
+          increase_level: true
+        },
+        "PointBlank::DOM::OLListElement" => {
+          numbered: true,
+          increase_level: true
+        },
+        "PointBlank::DOM::QuoteBlock" => {
+          leftline: true,
+          increase_level: true
+        },
+        "PointBlank::DOM::HorizontalRule" => {
+          underline_full_block: true
+        }
+      }.freeze
+
+      DEFAULT_EFFECT_PRIORITY = {
+        numbered: 10_000,
+        leftline: 9500,
+        bullet: 9000,
+        indent: 8500,
+        underline_full_block: 8000,
+        underline_block: 7500,
+        extra_newlines: 7000,
+        center: 6000,
+        rjust: 5500,
+        box: 5000,
+        underline: 4000,
+        italics: 3500,
+        bold: 3000,
+        fg: 2500,
+        bg: 2000,
+        strikethrough: 1500
+      }.freeze
+
+      # Class for managing styles and style overrides
+      class StyleManager
+        class << self
+          # Define a default style for specified class
+          # @param key [String] class name
+          # @param style [Hash] style
+          # @return [void]
+          def define_style(key, style)
+            @style ||= DEFAULT_STYLE.dup
+            @style[key] = style
+          end
+
+          # Define an effect priority value
+          # @param key [String] effect name
+          # @param priority [Integer] value of the priority
+          # @return [void]
+          def define_effect_priority(key, priority)
+            @effect_priority ||= DEFAULT_EFFECT_PRIORITY.dup
+            @effect_priority[key] = priority
+          end
+
+          # Get computed style
+          # @return [Hash]
+          def style
+            @style ||= DEFAULT_STYLE.dup
+          end
+
+          # Get computed effect priority
+          # @return [Hash]
+          def effect_priority
+            @effect_priority ||= DEFAULT_EFFECT_PRIORITY.dup
+          end
+        end
+
+        def initialize(overrides)
+          @style = self.class.style
+          @effect_priority = self.class.effect_priority
+          @style = @style.merge(overrides["style"]) if overrides["style"]
+        end
+
+        attr_reader :style, :effect_priority
+      end
+    end
+
+    # Primary document renderer
+    class Plainterm
+      include ::MMMD::TextManager
+
+      # @param input [String]
+      # @param options [Hash]
+      def initialize(input, options)
+        @doc = input
+        @color_mode = options.fetch("color", true)
+        @ansi_mode = options.fetch("ansi", true)
+        style_manager = PlaintermConstants::StyleManager.new(options)
+        @style = style_manager.style
+        @effect_priority = style_manager.effect_priority
+        @effects = @effect_priority.to_a.sort_by(&:last).map(&:first)
+        @options = options
+        @options["hsize"] ||= 80
+      end
+
+      # Return rendered text
+      # @return [String]
+      def render
+        _render(@doc, @options)
+      end
+
+      private
+
+      def _render(element, options, inline: false, level: 0, index: 0)
+        modeswitch = element.is_a?(::PointBlank::DOM::LeafBlock) ||
+                     element.is_a?(::PointBlank::DOM::Paragraph)
+        inline ||= modeswitch
+        level += calculate_level_increase(element)
+        text = if element.children.empty?
+                 element.content
+               else
+                 element.children.map.with_index do |child, index|
+                   _render(child, options, inline: inline,
+                                           level: level,
+                                           index: index)
+                 end.join(inline ? '' : "\n\n")
+               end
+        run_filters(text, element, level: level,
+                                   modeswitch: modeswitch,
+                                   index: index)
+      end
+
+      def run_filters(text, element, level:, modeswitch:, index:)
+        element_style = @style[element.class.name]
+        return text unless element_style
+
+        hsize = @options["hsize"] - (4 * level)
+        text = wordwrap(text, hsize) if modeswitch
+        params = element_style.dup
+        params[:hsize] = hsize
+        params[:number] = index + 1
+        @effects.each do |effect|
+          text = method(effect).call(text, params) if element_style[effect]
+        end
+        text
+      end
+
+      def calculate_level_increase(element)
+        level = 0
+        element_style = @style[element.class.name]
+        level += 1 if element_style && element_style[:increase_level]
+        level
+      end
+    end
+  end
+end

data/lib/mmmd/renderers.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.append(__dir__)
+
+module MMMD
+  # Renderers from Markdown to expected output format
+  module Renderers
+    autoload :HTML, 'renderers/html'
+    autoload :Plainterm, 'renderers/plainterm'
+  end
+end

data/lib/mmmd/util.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module MMMD
+  # Utils for working with entities in strings
+  module EntityUtils
+    ENTITY_DATA = JSON.parse(File.read("#{__dir__}/entities.json"))
+
+    # Decode html entities in string
+    # @param string [String]
+    # @return [String]
+    def self.decode_entities(string)
+      string = string.gsub(/&#\d{1,7};/) do |match|
+        match[1..-2].to_i.chr("UTF-8")
+      end
+      string = string.gsub(/&#[xX][\dA-Fa-f]{1,6};/) do |match|
+        match[3..-2].to_i(16).chr("UTF-8")
+      end
+      string.gsub(/&\w+;/) do |match|
+        ENTITY_DATA[match] ? ENTITY_DATA[match]["characters"] : match
+      end
+    end
+
+    # Encode unsafe html entities in string (ASCII-compatible)
+    # @param string [String]
+    # @return [String]
+    # @sg-ignore
+    def self.encode_entities_ascii(string)
+      string.gsub("&", "&")
+            .gsub("<", "&lt;")
+            .gsub(">", "&gt;")
+            .gsub('"', "&quot;")
+            .gsub("'", "&#39;")
+            .gsub(/[^\x00-\x7F]/) do |match|
+              "&#x#{match.codepoints[0]};"
+            end
+    end
+
+    # Encode unsafe html entities in string
+    # @param string [String]
+    # @return [String]
+    # @sg-ignore
+    def self.encode_entities(string)
+      string.gsub("&", "&amp;")
+            .gsub("<", "&lt;")
+            .gsub(">", "&gt;")
+            .gsub('"', "&quot;")
+            .gsub("'", "&#39;")
+    end
+
+    # Encode uri components that may break HTML syntax
+    # @param string [String]
+    # @return [String]
+    def self.encode_uri(string)
+      string.gsub('"', "%22")
+            .gsub("'", "%27")
+            .gsub(" ", "%20")
+    end
+  end
+end

data/lib/mmmd.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'mmmd/blankshell'
+require_relative 'mmmd/renderers'
+
+# Extensible, multi-format markdown processor
+module MMMD
+  # Parse a Markdown document into a DOM form
+  # @param doc [String]
+  # @return [::PointBlank::DOM::Document]
+  def self.parse(doc)
+    ::PointBlank::DOM::Document.parse(doc)
+  end
+end

data/security.md

@@ -0,0 +1,21 @@
+Security acknowledgements
+=========================
+
+While special care has been taken to prevent some of the more common common
+vulnerabilities that might arise from using this parser, it does not prevent
+certain issues which **which should be acknowledged**.
+
+- It is possible to inject a form of one-click XSS into the website. In
+  particular, there are no restrictions placed on urls embedded within the links
+  (as per the description of CommonMark specification). As such, something as
+  simple as `[test](<javascript:dangerous code here>)` would be more than enough
+  to employ such an exploit.
+- While generally speaking the parser acts stable on most tests, and precents
+  stray HTML tokens from occuring in the output text where appropriate, due to
+  the nontrivial nature of the task some form of XSS injection may or may not
+  occur. If such an incident occurs, please report it to the current maintainer
+  of the project.
+- User input should NOT be trusted when it comes to applying options to
+  rendering. Some renderers, such as the HTML renderer, allow modifying the
+  style parameter for rendered tags, which when passed control of to an
+  untrusted party may become an XSS attack vector.

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: mmmd
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yessiest
+autorequire:
+bindir:
+- bin
+cert_chain: []
+date: 2025-03-08 00:00:00.000000000 Z
+dependencies: []
+description: |
+  MMMD (short for Mark My Manuscript Down) is a Markdown processor
+  (as in "parser and translator") with a CLI interface utility and
+  multiple modes of output (currently HTML and terminal).
+email: yessiest@text.512mb.org
+executables:
+- mmmdpp
+extensions: []
+extra_rdoc_files:
+- README.md
+- architecture.md
+- security.md
+files:
+- README.md
+- architecture.md
+- bin/mmmdpp
+- lib/mmmd.rb
+- lib/mmmd/blankshell.rb
+- lib/mmmd/entities.json
+- lib/mmmd/renderers.rb
+- lib/mmmd/renderers/html.rb
+- lib/mmmd/renderers/plainterm.rb
+- lib/mmmd/util.rb
+- security.md
+homepage: https://adastra7.net/git/Yessiest/rubymark
+licenses:
+- AGPL-3.0-or-later
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Modular, compliant Markdown processor
+test_files: []