mmmd 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f64700645c2b97717469cd6da2ecd780138d0722f43f1503375e367f9574b718
-  data.tar.gz: 153b9712bdb5ed0fe66681f64105152360bd50abf9aa907e97e5ef2f33ca3f2b
+  metadata.gz: 98817fd73ed29d5b59ed440706d868c6a627632b072b39e8f0b41ade4d7253c6
+  data.tar.gz: f60b756923a31d9194aa574ddadc6d46f75f1de564b1e59198f8706fb88a1f2f
 SHA512:
-  metadata.gz: dfe1a17ba166b8eb2076ef3097552d40fba6f1ea040b85d741ab650fe0794320ec20528b9887ac83c9b7620d5b6844805d0b12c0c7a8c547fd2cad889af1b046
-  data.tar.gz: cd476ec80f1022b99115b3e6a0213ceca078d736fe3c3dce47aa3acd7404f15766d41e1324d2d90f84781b82a7f3a959df2c479584a02d28a3bf73b9f5ea5c81
+  metadata.gz: 16a7da77e52b739ae8b40be7a5010731d4ddc8dde05388d4626477bfead344bdc9e52fcf6280684004d55d33a18477ec45aae083a962a839f5e62699951fff3f
+  data.tar.gz: 45efe890c613a4e0fd19805d7ae585200b3c89f24b217feffafe88c6a742d0e5e33870e72de138ffa3b4ca080cf89784e85406cf5e8d51dadbd84970b99f1448

data/README.md

@@ -1,3 +1,59 @@
-# rubymark
+MMMD (Mark My Message Down)
+============
+
+(Originally titled Rubymark)
 
 Modular, compliant Markdown parser in Ruby
+
+Installation
+------------
+
+This package is available as a gem over at
+[rubygems.org](https://rubygems.org/gems/mmmd).
+
+Installing it is as simple as executing `gem install mmmd`
+
+Usage
+-----
+
+This package is generally intended as a library, but it also
+includes a CLI tool which permits the usage of the library
+for simple document translation tasks.
+
+Examples:
+```sh
+# Render the file in a terminal-oriented format
+$ mmmdpp file.md -
+
+# Read the markdown contents directly from input, output to stdout
+$ external-program | mmmdpp - -
+
+# Render file.md to a complete webpage
+$ mmmdpp -r HTML file.md file.html
+
+# Render file.md into a complete webpage and add extra tags to head and
+# wrap all images with a figure tag with figcaption containing image title
+$ mmmdpp -r HTML -o '"head": ["<meta charset=\"UTF-8\">", "<style>img { max-width: 90%; }</style>"]' -o '"mapping"."PointBlank::DOM::InlineImage".figcaption: true' - -
+
+# Render file.md into a set of HTML tags, without anything extra
+$ mmmdpp -r HTML -o '"nowrap": true' file.md file.html
+```
+
+A lot more usage options are documented on the Wiki page for the project
+
+License
+-------
+
+    Copyright 2025 yessiest@text.512mb.org
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.

data/bin/mmmdpp

@@ -17,11 +17,8 @@ class OptionNavigator
   # Read a definition
   # @param define [String]
   def read_definition(define)
-    define.split(";").each do |part|
-      locstring, _, value = part.partition(":")
-      locstring = deconstruct(locstring.strip)
-      assign(locstring, JSON.parse(value))
-    end
+    locstring, value = deconstruct(define)
+    assign(locstring, JSON.parse(value))
   end
 
   attr_reader :options
@@ -83,6 +80,9 @@ class OptionNavigator
         buffer = locstring[0..closepart]
         part = locstring[1..-2].to_i
         locstring = locstring.delete_prefix(buffer)
+      when ':'
+        locstring = locstring.delete_prefix(':')
+        break
       else
         raise ParserError, 'separator missing' unless buffer.empty?
 
@@ -92,7 +92,7 @@ class OptionNavigator
       end
     end
     parts.append(part) if part
-    parts
+    [parts, locstring]
   end
 
   def assign(keys, value)

data/lib/mmmd/blankshell.rb

@@ -367,7 +367,7 @@ module PointBlank
 
       # (see ::PointBlank::Parsing::NullParser#consume)
       def consume(line, parent = nil, lazy: false)
-        @lazy_triggered = lazy || @lazy_triggered
+        @lazy_triggered = lazy || @lazy_triggered unless line.strip.empty?
         return [nil, nil] if line.match?(/\A {0,3}\Z/)
         return [nil, nil] if @closed
         return [nil, nil] if check_candidates(line, parent)
@@ -957,9 +957,9 @@ module PointBlank
         parts = tokens
         @valid_parsers.each do |parser|
           newparts = []
-          parts.each do |x|
+          parts.each_with_index do |x, i|
             if x.is_a? String
-              newparts.append(*parser.tokenize(x))
+              newparts.append(*parser.tokenize(x, newparts.last, parts[i + 1]))
             else
               newparts.append(x)
             end
@@ -1013,8 +1013,10 @@ module PointBlank
 
       # Tokenize a string
       # @param string [String]
+      # @param before [String, ::PointBlank::DOM::DOMObject]
+      # @param after [String, ::PointBlank::DOM::DOMObject]
       # @return [Array<Array(String, Class, Symbol), String>]
-      def self.tokenize(string)
+      def self.tokenize(string, _before, _after)
         [string]
       end
 
@@ -1142,18 +1144,11 @@ module PointBlank
     # Code inline parser
     class CodeInline < NullInline
       # (see ::PointBlank::Parsing::NullInline#tokenize)
-      def self.tokenize(string)
-        open = {}
+      def self.tokenize(string, *_lookaround)
         iterate_tokens(string, "`") do |_before, current_text, matched|
           if matched
             match = current_text.match(/^`+/)[0]
-            if open[match]
-              open[match] = nil
-              [match, self, :close]
-            else
-              open[match] = true
-              [match, self, :open]
-            end
+            [match, self, :open]
           else
             current_text[0]
           end
@@ -1170,9 +1165,9 @@ module PointBlank
           text = (part.is_a?(Array) ? part.first : part)
           buffer += text
           next unless part.is_a? Array
+          next if idx.zero?
 
-          break (cutoff = idx) if part.first == opening &&
-                                  part.last == :close
+          break (cutoff = idx) if part.first == opening
         end
         buffer = construct_literal(buffer[opening.length..(-1 - opening.length)])
         [cutoff.positive? ? build([buffer]) : opening, parts[(cutoff + 1)..]]
@@ -1182,7 +1177,7 @@ module PointBlank
     # Autolink inline parser
     class AutolinkInline < NullInline
       # (see ::PointBlank::Parsing::NullInline#tokenize)
-      def self.tokenize(string)
+      def self.tokenize(string, *_lookaround)
         iterate_tokens(string, /[<>]/) do |_before, current_text, matched|
           if matched
             if current_text.start_with?("<")
@@ -1238,11 +1233,10 @@ module PointBlank
         linkinfo = capture[-1][2]
         obj = build(capture[1..-2])
         if linkinfo[:label]
-          if (props = doc.root.properties[:linkdefs][linkinfo[:label]])
-            linkinfo = props
-          else
+          unless (props = doc.root.properties[:linkdefs][linkinfo[:label]])
             return nil
           end
+          linkinfo = props
         end
         obj.properties = linkinfo
         obj
@@ -1277,7 +1271,7 @@ module PointBlank
       end
 
       # (see ::PointBlank::Parsing::NullInline#tokenize)
-      def self.tokenize(string)
+      def self.tokenize(string, *_lookaround)
         iterate_tokens(string, /(?:!\[|\]\()/) do |_before, text, matched|
           next text[0] unless matched
           next ["![", self, :open] if text.start_with? "!["
@@ -1296,7 +1290,7 @@ module PointBlank
       end
 
       # (see ::PointBlank::Parsing::NullInline#tokenize)
-      def self.tokenize(string)
+      def self.tokenize(string, *_lookaround)
         iterate_tokens(string, /(?:\[|\][(\[])/) do |_before, text, matched|
           next text[0] unless matched
           next ["[", self, :open] if text.start_with? "["
@@ -1308,20 +1302,61 @@ module PointBlank
       end
     end
 
+    # TODO: this seems way too complicated for something that's supposed
+    # to be a goddamn emphasis markup parser. i'd blame it on commonmark's
+    # convoluted specs.
+    # (P.S: it could be possible to make this easier for implementers by
+    # making a claims system with pointers that do not modify the string
+    # while it's being parsed. however that would just move complexity from
+    # the parser into the scanner instead. and it does not resolve the
+    # problem of overlapping claims as efficiently as simply splitting text
+    # into tokens and remaining string bits.)
+
     # Emphasis and strong emphasis inline parser
     class EmphInline < NullInline
       INFIX_TOKENS = /^[^\p{S}\p{P}\p{Zs}_]_++[^\p{S}\p{P}\p{Zs}_]$/
       # (see ::PointBlank::Parsing::NullInline#tokenize)
-      def self.tokenize(string)
+      def self.tokenize(string, before, after)
+        bfrb = extract_left(before)
+        afra = extract_right(after)
         iterate_tokens(string, /(?:_++|\*++)/) do |bfr, text, matched|
           token, afr = text.match(/^(_++|\*++)(.?)/)[1..2]
-          left = left_token?(bfr[-1] || "", token, afr)
-          right = right_token?(bfr[-1] || "", token, afr)
+          bfr = bfr[-1] || bfrb || ""
+          afr = afr.empty? ? afra || "" : afr
+          left = left_token?(bfr, token, afr)
+          right = right_token?(bfr, token, afr)
           break_into_elements(token, [bfr[-1] || "", token, afr].join(''),
                               left, right, matched)
         end
       end
 
+      # Extract left-flanking token from before the tokenized string
+      # @param bfr [String, ::PointBlank::DOM::DOMObject, Array(String, Class, Symbol)]
+      # @return [String]
+      def self.extract_left(bfr)
+        case bfr
+        when String
+          bfr[-1]
+        when ::PointBlank::DOM::DOMObject
+          "."
+        when Array
+          bfr.first[-1]
+        end
+      end
+
+      # Extract right-flanking token from after the tokenized string
+      # @param afr [String, ::PointBlank::DOM::DOMObject, Array(String, Class, Symbol)]
+      # @return [String]
+      def self.extract_right(afr)
+        case afr
+        when String
+          afr[0]
+        when ::PointBlank::DOM::DOMObject
+          "."
+        when Array
+          afr.first[0]
+        end
+      end
       # Is this token, given these surrounding characters, left-flanking?
       # @param bfr [String]
       # @param token [String]
@@ -1386,8 +1421,9 @@ module PointBlank
                                ((blk.first.length % 3).zero? &&
                                 (closer.first.length % 3).zero?))
             (open ? capture : before).prepend(blk)
-            next unless blk.is_a?(Array)
-            return backlog unless blk[1].check_contents(capture)
+            next unless blk.is_a?(Array) && !open
+
+            return backlog unless closer[1].check_contents(capture)
           end
           return backlog if open
 
@@ -1431,7 +1467,7 @@ module PointBlank
     # Hard break
     class HardBreakInline < NullInline
       # (see ::PointBlank::Parsing::NullInline#tokenize)
-      def self.tokenize(string)
+      def self.tokenize(string, *_lookaround)
         iterate_tokens(string, /(?:  \n|\\\n)/) do |_before, token, matched|
           next ["\n", self, :close] if token.start_with?("  \n")
           next ["\n", self, :close] if matched

data/lib/mmmd/renderers/html.rb

@@ -45,7 +45,8 @@ module MMMD
           tag: "ol"
         },
         "PointBlank::DOM::IndentBlock" => {
-          tag: "pre"
+          tag: "pre",
+          codeblock: true
         },
         "PointBlank::DOM::ULListElement" => {
           tag: "li"
@@ -87,7 +88,8 @@ module MMMD
           tag: "pre",
           outer: {
             tag: "code"
-          }
+          },
+          codeblock: true
         },
         "PointBlank::DOM::QuoteBlock" => {
           tag: "blockquote"
@@ -126,7 +128,11 @@ module MMMD
 
         def initialize(overrides)
           @mapping = self.class.mapping
-          @mapping = @mapping.merge(overrides["mapping"]) if overrides["mapping"]
+          overrides["mapping"]&.each do |key, value|
+            next unless @mapping[key]
+
+            @mapping[key] = @mapping[key].merge(value)
+          end
         end
 
         attr_reader :mapping
@@ -154,7 +160,7 @@ module MMMD
         text = _render(@document, @options, level: @options["init_level"])
         @options["init_level"].times { text = indent(text) }
         if @options["nowrap"]
-          text
+          remove_pre_spaces(text)
         else
           [
             preambule,
@@ -226,8 +232,7 @@ module MMMD
       end
 
       def _render(element, options, inline: false, level: 0, literaltext: false)
-        modeswitch = element.is_a?(::PointBlank::DOM::LeafBlock) ||
-                     element.is_a?(::PointBlank::DOM::Paragraph)
+        modeswitch = figure_out_modeswitch(element)
         inline ||= modeswitch
         level += 1 unless inline
         text = if element.children.empty?
@@ -248,21 +253,29 @@ module MMMD
                                    literaltext: literaltext)
       end
 
+      def figure_out_modeswitch(element)
+        element.is_a?(::PointBlank::DOM::LeafBlock) ||
+          element.is_a?(::PointBlank::DOM::Paragraph)
+      end
+
       def run_filters(text, element, level:, inline:, modeswitch:,
                                      literaltext:)
         element_style = @mapping[element.class.name]
         return text unless element_style
         return text if literaltext
 
+        codeblock = element_style[:codeblock]
         hsize = @options["linewrap"] - (level * @options["indent"])
-        text = wordwrap(text, hsize) if modeswitch
+        text = wordwrap(text, hsize) if modeswitch && !codeblock
+
         if element_style[:sanitize]
           text = MMMD::EntityUtils.encode_entities(text)
         end
         if element_style[:inline]
           innerclose(element, element_style, text)
         else
-          openclose(text, element, element_style, inline)
+          openclose(text, element, element_style,
+                    codeblock ? false : inline)
         end
       end
 
@@ -272,20 +285,25 @@ module MMMD
           opentag + text + closetag
         else
           [opentag,
-           indent(text),
+           indent(text.rstrip),
            closetag].join("\n")
         end
       end
 
       def innerclose(element, style, text)
         props = element.properties
-        tag = "<#{style[:tag]}"
+        tag = ""
+        tag += "<figure>" if style[:figcaption]
+        tag += "<#{style[:tag]}"
         tag += " style=#{style[:style].inspect}" if style[:style]
         tag += " href=#{read_link(element)}" if style[:href]
         tag += " alt=#{text.inspect}" if style[:alt]
         tag += " src=#{read_link(element)}" if style[:src]
         tag += " title=#{read_title(element)}" if style[:title] && props[:title]
         tag += ">"
+        if style[:figcaption]
+          tag += "<figcaption>#{text}</figcaption></figure>"
+        end
         if style[:outer]
           outeropen, outerclose = construct_tags(style[:outer], element)
           tag = outeropen + tag + outerclose
@@ -298,7 +316,11 @@ module MMMD
 
         props = element.properties
         opentag = "<#{style[:tag]}"
+        opentag += "<figure>#{opentag}" if style[:figcaption]
         closetag = "</#{style[:tag]}>"
+        if style[:figcaption]
+          closetag += "<figcaption>#{text}</figcaption></figure>"
+        end
         opentag += " style=#{style[:style].inspect}" if style[:style]
         opentag += " href=#{read_link(element)}" if style[:href]
         opentag += " src=#{read_link(element)}" if style[:src]
@@ -326,7 +348,7 @@ module MMMD
 
       def indent(text)
         text.lines.map do |line|
-          "#{' ' * @options["indent"]}#{line}"
+          "#{' ' * @options['indent']}#{line}"
         end.join('')
       end
 
@@ -334,7 +356,7 @@ module MMMD
         head = @options['head']
         headinfo = "#{indent(<<~HEAD.rstrip)}\n  " if head
           <head>
-            #{head.is_a?(Array) ? head.join("\n") : head}
+          #{indent(head.is_a?(Array) ? head.join("\n") : head)}
           </head>
         HEAD
         headinfo ||= "  "

data/lib/mmmd/renderers/plainterm.rb

@@ -381,7 +381,11 @@ module MMMD
         def initialize(overrides)
           @style = self.class.style
           @effect_priority = self.class.effect_priority
-          @style = @style.merge(overrides["style"]) if overrides["style"]
+          overrides["style"]&.each do |key, value|
+            next unless @style[key]
+
+            @style[key] = @style[key].merge(value)
+          end
         end
 
         attr_reader :style, :effect_priority

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mmmd
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Yessiest
@@ -9,7 +9,7 @@ autorequire:
 bindir:
 - bin
 cert_chain: []
-date: 2025-03-09 00:00:00.000000000 Z
+date: 2025-04-03 00:00:00.000000000 Z
 dependencies: []
 description: |
   MMMD (short for Mark My Manuscript Down) is a Markdown processor
@@ -21,12 +21,8 @@ executables:
 extensions: []
 extra_rdoc_files:
 - README.md
-- architecture.md
-- security.md
-- test.md
 files:
 - README.md
-- architecture.md
 - bin/mmmdpp
 - lib/mmmd.rb
 - lib/mmmd/blankshell.rb
@@ -35,8 +31,6 @@ files:
 - lib/mmmd/renderers/html.rb
 - lib/mmmd/renderers/plainterm.rb
 - lib/mmmd/util.rb
-- security.md
-- test.md
 homepage: https://adastra7.net/git/Yessiest/rubymark
 licenses:
 - AGPL-3.0-or-later

data/architecture.md

@@ -1,278 +0,0 @@
-Architecture of madness
-=======================
-
-Prelude
--------
-
-It needs to be stressed that making the parser modular while keeping it
-relatively simple was a laborous undertaking. There has not been a standard
-more hostile towards the people who dare attempt to implement it than
-CommonMark. It should also be noted, that despite it being titled a
-"Standard" in this document, it is less widely adopted than the Github
-Flavored Markdown syntax. Github Flavored Markdown, however, is only but
-a mere subset of this parser's model, albeit requiring a few extensions.
-
-Current state (as of March 02, 2025)
-------------------------------------
-
-This parser processes text in what can be boiled down to three phases.
-
-- Block/Line phase
-- Overlay phase
-- Inline phase
-
-It should be noted that all phases have their own related parser
-classes, and a shared behaviour system, where each parser takes control
-at some point, and may win ambiguous cases by having higher priority
-(see `#define_child`, `#define_overlay` methods for priority parameter)
-
-### Block/Line phase ###
-
-The first phase breaks down blocks, line by line, into block structures.
-Blocks (preferably inherited from the Block class) can contain other blocks.
-(i.e. QuoteBlock, ULBlock, OLBlock). Other blocks (known as leaf blocks)
-may not contain anything else (except inline content, more on that later).
-
-Blocks are designed to be parsed independently. This means that it *should*
-be possible to tear out any standard block and make it not get parsed.
-This, however, isn't thoroughly tested for.
-
-Blocks as proper, real classes have a certain lifecycle to follow when
-being constructed:
-
-1. Open condition
-    - A block needs to find its first marker on the current line to open
-      (see `#begin?` method)
-    - Once it's open, it's immediately initialized and fed the line it just
-      read (but now as an object, not as a class) (see `#consume` method)
-2. Marker/Line consumption
-    - While it should be kept open, the block parser instance will
-      keep reading inupt through `#consume` method, returning a pair
-      of modified line (after consuming its tokens from it) and
-      a boolean value indicating permission of lazy continuation
-      (if it's a block like a QuoteBlock or ULBlock that can be lazily
-      overflowed).
-      Every line the parser needs to record needs to be pushed
-      through the `#push` method.
-3. Closure
-    - If the current line no longer belongs to the current block
-      (if the block should have been closed on the previous line),
-      it simply needs to `return` a pair of `nil`, and a boolean value for
-      permission of lazy continuation
-    - If a block should be closed on the current line, it should capture it,
-      keep track of the "closed" state, then `return` `nil` on the next call
-      of `#consume`
-    - Once a block is closed, it:
-        1. Receives its content from the parser
-        2. Parser receives the "close" method call
-        3. (optional) Parser may have a callable method `#applyprops`. If
-           it exists, it gets called with the current constructed block.
-        4. (optional) All overlays assigned to this block's class are
-           processed on the contents of this block (more on that in
-           Overlay phase)
-        5. (optional) Parser may return a different class, which
-           the current block should be cast into (Overlays may change
-           the class as well)
-        6. (optional) If a block can respond to `#parse_inner` method, it
-           will get called, allowing the block to parse its own contents.
-    - After this point, the block is no longer touched until the document
-      fully gets processed.
-4. Inline processing
-    - (Applies only to Paragraph and any child of LeafBlock)
-      When the document gets fully processed, the contents of the current
-      block are taken, assigned to an InlineRoot instance, and then parsed
-      in Inline mode
-5. Completion
-    - The resulting document is then returned.
-
-While there is a lot of functionality available in desgining blocks, it is
-not necessary for the simplest of the block kinds available. The simplest
-example of a block parser is likely the ThematicBreakParser class, which
-implements the only 2 methods needed for a block parser to function.
-
-While parsing text, a block may use additional info:
-
-- In consume method: `lazy` hasharg, if the current line is being processed
-  in lazy continuation mode (likely only ever matters for Paragraph); and
-  `parent` - the parent block containing this block.
-
-Block interpretations are tried in decreasing order of their priority
-value, as applied using the `#define_child` method.
-
-For blocks to be properly indexed, they need to be a valid child or
-a valid descendant (meaning reachable through child chain) of the 
-Document class.
-
-### Overlay phase ###
-
-Overlay phase doesn't start at some specific point in time. Rather,
-Overlay phase happens for every block individually - when that block
-closes.
-
-Overlay mechanism can be applied to any DOMObject type, so long as its
-close method is called at some point (this may not be of interest to
-people that do not implement custom syntax, as it generally translates
-to "only block level elements get their overlays processed")
-
-Overlay mechanism provides the ability to perform some action on the block
-right after it gets closed and right before it gets interpreted by the
-inline phase. Overlays may do the following:
-
-- Change the block's class
-  (by returning a class from the `#process` method)
-- Change the block's content (by directly editing it)
-- Change the block's properties (by modifying its `properties` hash)
-
-Overlay interpretations are tried in decreasing order of their priority
-value, as defined using the `#define_overlay` method.
-
-### Inline phase ###
-
-Once all blocks have been processed, and all overlays have been applied
-to their respective block types, the hook in the Document class's
-`#parser` method executes inline parsing phase of all leaf blocks
-(descendants of the `Leaf` class) and paragraphs.
-
-The outer class encompassing all inline children of a block is
-`InlineRoot`. As such, if an inline element is to ever appear within the
-text, it needs to be reachable as a child or a descendant of InlineRoot.
-
-Inline parsing works in three parts:
-
-- First, the contens are tokenized (every parser marks its own tokens)
-- Second, the forward walk procedure is called
-- Third, the reverse walk procedure is called
-
-This process is repeated for every group of parsers with equal priority.
-At one point in time, only all the parsers of equal priority may run in
-the same step. Then, the process goes to the next step, of parsers of
-higher priority value. As counter-intuitive as this is, this means that
-it goes to the parsers of _lower_ priority.
-
-At the very end of the process, the remaining strings are concatenated
-within the mixed array of inlines and strings, and turned into Text
-nodes, after which the contents of the array are appended as children to
-the root node.
-
-This process is recursively applied to all elements which may have child
-elements. This is ensured when an inline parser calls the "build"
-utility method.
-
-The inline parser is a class that implements static methods `tokenize`
-and either `forward_walk` or `reverse_walk`. Both may be implemented at
-the same time, but this isn't advisable.
-
-The tokenization process is characterized by calling every parser in the
-current group with every string in tokens array using the `tokenize`
-method. It is expected that the parser breaks the string down into an
-array of other strings and tokens. A token is an array where the first
-element is the literal text representation of the token, the second
-value is the class of the parser, and the _last_ value (_not third_) is
-the `:close` or `:open` symbol (though functionally it may hold any
-symbol value). Any additional information the parser may need in later
-stages may be stored between the last element and the second element.
-
-Example:
-
-    Input:
-    
-    "_this _is a string of_ tokens_"
-
-    Output:
-
-    [["_", ::PointBlank::Parsing::EmphInline, :open],
-     "this ",
-     ["_", ::PointBlank::Parsing::EmphInline, :open],
-     "is a string of",
-     ["_", ::PointBlank::Parsing::EmphInline, :close],
-     " tokens",
-     ["_", ::PointBlank::Parsing::EmphInline, :close]]
-
-The forward walk is characterized by calling parsers which implement the
-`#forward_walk` method. When the main class encounters an opening token
-in `forward_walk`, it will call the `#forward_walk` method of the class
-that represents this token. It is expected that the parser class will
-then attempt to build the first available occurence of the inline
-element it represents, after which it will return the array of all
-tokens and strings that it was passed where the first element will be
-the newly constructed inline element. If it is unable to close the
-block, it should simply return the original contents, unmodified.
-
-Example:
-
-    Original text:
-
-    this is outside the inline `this is inside the inline` and this
-    is right after the inline `and this is the next inline`
-
-    Input:
-
-    [["`", ::PointBlank::Parsing::CodeInline, :open],
-     "this is inside the inline"
-     ["`", ::PointBlank::Parsing::CodeInline, :close],
-     " and this is right after the inline ",
-     ["`", ::PointBlank::Parsing::CodeInline, :open],
-     "and this is the next inline"
-     ["`", ::PointBlank::Parsing::CodeInline, :close]]
-
-    Output:
-
-    [<::PointBlank::DOM::InlineCode
-      @content = "this is inside the inline">,
-     " and this is right after the inline ",
-     ["`", ::PointBlank::Parsing::CodeInline, :open],
-     "and this is the next inline"
-     ["`", ::PointBlank::Parsing::CodeInline, :close]]
-
-The reverse walk is characterized by calling parsers which implement the
-`#reverse_walk` method when the main class encounters a closing token
-for this class (the one that contains the `:close` symbol in the last
-position of the token information array). After that the main class will
-call the parser's `#reverse_walk` method with the current list of
-tokens, inlines and strings. It is expected that the parser will then
-collect all the blocks, strings and inlines that fit within the block
-closed by the last element in the list, and once it encounters the
-appropriate opening token for the closing token in the last position of
-the array, it will then replace the elements fitting within that inline
-with a class containing all the collected elements. If it is unable to
-find a matching opening token for the closing token in the last
-position, it should simply return the original contents, unmodified.
-
-Example:
-
-    Original text:
-
-    blah blah something something lots of text before the emphasis
-    _this is emphasized `and this is an inline` but it's still
-    emphasized_
-
-
-    Input:
-
-    ["blah blah something something lots of text before the emphasis",
-     ["_", ::PointBlank::Parsing::EmphInline, :open],
-     "this is emphasized",
-     <::PointBlank::DOM::InlineCode,
-      @content = "and this is an inline">,
-     " but it's still emphasized",
-     ["_", ::PointBlank::Parsing::EmphInline, :close]]
-
-    Output:
-
-    ["blah blah something something lots of text before the emphasis",
-     <::PointBlank::DOM::InlineEmphasis,
-      children = [...,
-      <::PointBlank::DOM::InlineCode ...>
-      ...]>]
-
-Both `#forward_walk` and `#reverse_walk` are not restricted to making
-just the changes discussed above, and can arbitrarily modify the token
-arrays. That, however, should be done with great care, so as to not
-accidentally break compatibility with other parsers.
-
-To ensure that the collected tokens in the `#reverse_walk` and
-`#forward_walk` are processes correctly, the colllected arrays of
-tokens, blocks and inlines should be built into an object that
-represents this parser using the `build` method (it will automatically
-attempt to find the correct class to construct using the
-`#define_parser` directive in the DOMObject subclass definition)

data/security.md

@@ -1,21 +0,0 @@
-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.

data/test.md

@@ -1,15 +0,0 @@
-Jabronicle Mitch's wild ride
-============================
-
-crusty cocks
-
--------------
-
-- DIIIIICKS
-- - let
-  - me
-  - smell
-  - your
-  - dick
-- [anime feet](https://google.com)
-- [goog](https://goog.com 'goog')