kramdown-rfc2629 1.4.7 → 1.4.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92b7379a1d7172926d1d84ccdc5c816821a0c62c838b597dbc4e92cac91cff0d
-  data.tar.gz: b501c48e3ff1bddaca7abec20125dc360de97f67076341d2b9812a3913cbf314
+  metadata.gz: c6549880c8c2aa06b25b83e8f6fa1bf1bb13d49d99a7250d386ed625114e4ed5
+  data.tar.gz: f16be76792e4158738ff09fca7b36a211ef9fdb5e4ea82c8f2b5c26afbc7e4b7
 SHA512:
-  metadata.gz: 3ae6bd5ad655d1300c426b06b00c92a7f56c15636b990d3d0ee02e2cc2a0481a7900d002e6076baa467aa2b3dc309719bedff0fd9e85912f083e85b0a9ef332c
-  data.tar.gz: c5cce63d97840efc638bd14240f6652955bb291c46cc038426bb8209c2b65725c14ee3db850954e8ba1bf5f23781f44d388c5d9984be38a4a0f55e63eaef6b1f
+  metadata.gz: fe85445d876074a4e580d1c43016455c9cac6f17b40c3e31a635f42ef1e7eb0f5ecffc1072c7182eff7b887f8e2647aec4742e3b465292bb4e3699af0922b756
+  data.tar.gz: 9027e158afcfc98e233fbbc1a5161c8e2d066907a47fdadc01f89cf3c077035904348218faba1395a70017f6645445133e4f5780818063ea8bee7cf37ae93210

data/bin/kramdown-rfc2629

@@ -14,21 +14,29 @@ Encoding.default_external = "UTF-8" # wake up, smell the coffee
 
 def boilerplate(key)
   case key.downcase
-  when /\Abcp14(\+)?(-tagged)?\z/i
-    ret = <<RFC8174
+  when /\Abcp14(info)?(\+)?(-tagged)?\z/i
+    ret = ''
+    if $1
+      ret << <<RFC8174ise
+Although this document is not an IETF Standards Track publication it
+adopts the conventions for normative language to provide clarity of
+instructions to the implementer.
+RFC8174ise
+    end
+    ret << <<RFC8174
 The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL
 NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED",
 "MAY", and "OPTIONAL" in this document are to be interpreted as
 described in BCP 14 {{!RFC2119}} {{!RFC8174}} when, and only when, they
 appear in all capitals, as shown here.
 RFC8174
-    if $1
+    if $2
       ret << <<PLUS
 These words may also appear in this document in
 lower case as plain English words, absent their normative meanings.
 PLUS
     end
-    if $2
+    if $3
       if $options.v3
         ret << <<TAGGED
 
@@ -89,6 +97,16 @@ def yaml_load(input, *args)
  end
 end
 
+XREF_SECTIONS_RE = ::Kramdown::Parser::RFC2629Kramdown::SECTIONS_RE
+XSR_PREFIX = "#{XREF_SECTIONS_RE} of "
+XSR_SUFFIX = ", (#{XREF_SECTIONS_RE})| \\((#{XREF_SECTIONS_RE})\\)"
+XREF_TXT = ::Kramdown::Parser::RFC2629Kramdown::XREF_TXT
+XREF_TXT_SUFFIX = " \\(#{XREF_TXT}\\)"
+
+def spacify_re(s)
+  s.gsub(' ', '[\u00A0\s]+')
+end
+
 def xml_from_sections(input)
 
   unless ENV["KRAMDOWN_NO_SOURCE"]
@@ -158,11 +176,20 @@ def xml_from_sections(input)
   # collect normative/informative tagging {{!RFC2119}} {{?RFC4711}}
   sechash.each do |k, v|
     next if k == "fluff"
-    v.gsub!(/{{(?:([?!])(-)?|(-))([\w._\-]+)(?:=([\w.\/_\-]+))?}}/) do |match|
-      norminform = $1
-      replacing = $2 || $3
-      word = $4
-      bibref = $5
+    v.gsub!(/{{(#{
+      spacify_re(XSR_PREFIX)
+    })?(?:([?!])(-)?|(-))([\w._\-]+)(?:=([\w.\/_\-]+))?(#{
+      XREF_TXT_SUFFIX
+    })?(#{
+      spacify_re(XSR_SUFFIX)
+    })?}}/) do |match|
+      xsr_prefix = $1
+      norminform = $2
+      replacing = $3 || $4
+      word = $5
+      bibref = $6
+      xrt_suffix = $7
+      xsr_suffix = $8
       if replacing
         if new = ref_replacements[word]
           word = new
@@ -186,7 +213,7 @@ def xml_from_sections(input)
       if norminform
         norm_ref[word] ||= norminform == '!' # one normative ref is enough
       end
-      "{{#{word}}}"
+      "{{#{xsr_prefix}#{word}#{xrt_suffix}#{xsr_suffix}}}"
     end
   end
 

data/kramdown-rfc2629.gemspec

@@ -1,6 +1,6 @@
 spec = Gem::Specification.new do |s|
   s.name = 'kramdown-rfc2629'
-  s.version = '1.4.7'
+  s.version = '1.4.12'
   s.summary = "Kramdown extension for generating RFC 7749 XML."
   s.description = %{An RFC7749 (XML2RFC) generating backend for Thomas Leitner's
 "kramdown" markdown parser.  Mostly useful for RFC writers.}

data/lib/kramdown-rfc/parameterset.rb

@@ -34,13 +34,12 @@ module KramdownRFC
       val ||= defcontent
       Array(val).map do |val1|
         v = val1.to_s.strip
-        if markdown             # Uuh.  Heavy coupling.
-          doc = Kramdown::Document.new(v, $global_markdown_options)
-          $stderr.puts doc.warnings.to_yaml unless doc.warnings.empty?
-          contents = doc.to_rfc2629[3..-6] # skip <t>...</t>\n
-        else
-          contents = escape_html(v)
-        end
+        contents =
+          if markdown
+            ::Kramdown::Converter::Rfc2629::process_markdown(v)
+          else
+            escape_html(v)
+          end
         %{<#{[an, *Array(attr).map(&:to_s)].join(" ").strip}>#{contents}</#{an}>}
       end.join(" ")
     end

data/lib/kramdown-rfc2629.rb

@@ -42,32 +42,50 @@ module Kramdown
         @block_parsers.unshift(:block_pi)
       end
 
-      SECTIONS_RE = /Section(?:s (?:[\w.]+, )*[\w.]+,? and)? [\w.]+/
-
-      def handle_bares(s, attr, format, href)
-        sa = s.sub(/\A\S+\s/, '').split(/,? and /)
-        sa[0..0] = *sa[0].split(', ')
-        sz = sa.size
-        if sz != 1         # we have to redo xml2rfc's work here
-          @tree.children << Element.new(:text, "Sections ", {}) # XXX needs to split into Section/Appendix
-          sa.each_with_index do |sec, i|
-            attr1 = {"target" => href, "section" => sec, "sectionFormat" => "bare"}
-            @tree.children << Element.new(:xref, nil, attr1)
-            text = if i == 0 && sz == 2
-                     " and "
-                   elsif i == sz-1
-                     " of "
-                   elsif i == sz-2
-                     ", and "
-                   else
-                     ", "
-                   end
-            @tree.children << Element.new(:text, text, {})
+      XREF_BASE = /[\w.-]+/ # a token for a reference
+      XREF_TXT = /(?:[^\(]|\([^\)]*\))+/ # parenthesized text
+      XREF_RE = /#{XREF_BASE}(?: \(#{XREF_TXT}\))?/
+      XREF_RE_M = /\A(#{XREF_BASE})(?: \((#{XREF_TXT})\))?/ # matching version of XREF_RE
+      XREF_SINGLE = /(?:Section|Appendix) #{XREF_RE}/
+      XREF_MULTI = /(?:Sections|Appendices) (?:#{XREF_RE}, )*#{XREF_RE},? and #{XREF_RE}/
+      XREF_ANY = /(?:#{XREF_SINGLE}|#{XREF_MULTI})/
+      SECTIONS_RE = /(?:#{XREF_ANY} and )?#{XREF_ANY}/
+
+      def handle_bares(s, attr, format, href, last_join = nil)
+        if s.match(/\A(#{XREF_ANY}) and (#{XREF_ANY})\z/)
+          handle_bares($1, {}, nil, href, " and ")
+          handle_bares($2, {}, nil, href, " of ")
+          return
+        end
+
+        href = href.split(' ')[0] # Remove any trailing (...)
+        multi = last_join != nil
+        (sn, s) = s.split(' ', 2)
+        loop do
+          m = s.match(/\A#{XREF_RE_M}(, (?:and )?| and )?/)
+          break if not m
+
+          if not multi and not m[2] and not m[3]
+            # Modify |attr| if there is a single reference.  This can only be
+            # used if there is only one section reference and the section part
+            # has no title.
+            attr['section'] = m[1]
+            attr['sectionFormat'] = format
+            attr['text'] = m[2]
+            return
           end
-          # attr stays unchanged, no section added
-        else
-          attr['section'] = sa[-1]
-          attr['sectionFormat'] = format
+
+          if sn
+            @tree.children << Element.new(:text, "#{sn} ", {})
+            sn = nil
+          end
+
+          multi = true
+          s[m[0]] = ''
+
+          attr1 = { 'target' => href, 'section' => m[1], 'sectionFormat' => 'bare', 'text' => m[2] }
+          @tree.children << Element.new(:xref, nil, attr1)
+          @tree.children << Element.new(:text, m[3] || last_join || " of ", {})
         end
       end
 
@@ -114,6 +132,10 @@ module Kramdown
               attr['format'] = 'counter'
             end
           end
+          if href.match(XREF_RE_M)
+            href = $1
+            attr['text'] = $2
+          end
           href = href.gsub(/\A[0-9]/) { "_#{$&}" } # can't start an IDREF with a number
           attr['target'] = href
           el = Element.new(:xref, nil, attr)
@@ -288,6 +310,12 @@ module Kramdown
         generate_id(value).gsub(/-+/, '-')
       end
 
+      def self.process_markdown(v)             # Uuh.  Heavy coupling.
+        doc = ::Kramdown::Document.new(v, $global_markdown_options)
+        $stderr.puts doc.warnings.to_yaml unless doc.warnings.empty?
+        doc.to_rfc2629[3..-6] # skip <t>...</t>\n
+      end
+
       SVG_COLORS = Hash.new {|h, k| k}
       <<COLORS.each_line {|l| k, v = l.chomp.split; SVG_COLORS[k] = v}
 black	#000000
@@ -335,6 +363,19 @@ COLORS
         end
       end
 
+      def svg_clean_kgt(s)
+        d = REXML::Document.new(s)
+        REXML::XPath.each(d.root, "//rect|//line|//path") do |x|
+          x.attributes["fill"] = "none"
+          x.attributes["stroke"] = "black"
+          x.attributes["stroke-width"] = "1.5"
+        end
+        d.to_s
+      rescue => detail
+        warn "*** Can't clean SVG: #{detail}"
+        d
+      end
+
       def svg_clean(s)          # expensive, risky
         d = REXML::Document.new(s)
         REXML::XPath.each(d.root, "//*[@shape-rendering]") { |x| x.attributes["shape-rendering"] = nil }  #; warn x.inspect }
@@ -379,9 +420,12 @@ COLORS
         file = Tempfile.new("kramdown-rfc")
         file.write(result)
         file.close
+        dont_clean = false
+        dont_check = false
         case t
         when "goat"
           result1, err, _s = Open3.capture3("goat #{file.path}", stdin_data: result);
+          dont_clean = true
         when "ditaa"        # XXX: This needs some form of option-setting
           result1, err, _s = Open3.capture3("ditaa #{file.path} --svg -o -", stdin_data: result);
         when "mscgen"
@@ -396,18 +440,27 @@ COLORS
           result1, err, _s = Open3.capture3("plantuml -pipe -tsvg", stdin_data: plantuml);
           result, err1, _s = Open3.capture3("plantuml -pipe -tutxt", stdin_data: plantuml) if t == "plantuml-utxt"
           err << err1.to_s
+        when "railroad", "railroad-utf8"
+          result1, err1, _s = Open3.capture3("kgt -l abnf -e svg", stdin_data: result);
+          result1 = svg_clean_kgt(result1); dont_clean = true
+          result, err, _s = Open3.capture3("kgt -l abnf -e rr#{t == "railroad" ? "text" : "utf8"}",
+                                            stdin_data: result);
+          err << err1.to_s
         when "math"
           result1, err, _s = Open3.capture3("tex2svg --font STIX --speech=false #{Shellwords.escape(' ' << result)}");
           result, err1, _s = Open3.capture3("asciitex -f #{file.path}")
           err << err1
         end
         capture_croak(t, err)
-        # warn ["goat:", result1.inspect]
+        # warn ["text:", result.inspect]
+        # warn ["svg:", result1.inspect]
         file.unlink
-        result1 = svg_clean(result1) unless t == "goat"
-        result1, err, _s = Open3.capture3("svgcheck -Xqa", stdin_data: result1);
-        capture_croak("svgcheck", err)
-        # warn ["svgcheck:", result1.inspect]
+        result1 = svg_clean(result1) unless dont_clean
+        unless dont_check
+          result1, err, _s = Open3.capture3("svgcheck -Xqa", stdin_data: result1);
+          # warn ["svgcheck:", result1.inspect]
+          capture_croak("svgcheck", err)
+        end
         if result1 == ''
           warn "*** could not create svg for #{result.inspect[0...20]}..."
           exit 65 # EX_DATAERR
@@ -462,7 +515,8 @@ COLORS
             end
           end
           case t
-          when "goat", "ditaa", "mscgen", "plantuml", "plantuml-utxt", "mermaid", "math"
+          when "goat", "ditaa", "mscgen", "plantuml", "plantuml-utxt", 
+               "railroad", "railroad-utf8", "mermaid", "math"
             if gi
               warn "*** Can't set GI #{gi} for composite SVG artset"
             end
@@ -729,6 +783,7 @@ COLORS
 
       def convert_xref(el, indent, opts)
         gi = el.attr.delete('gi')
+        text = el.attr.delete('text')
         target = el.attr['target']
         if target[0] == "&"
           "#{target};"
@@ -738,7 +793,12 @@ COLORS
           else
             gi ||= "xref"
           end
-          "<#{gi}#{el_html_attributes(el)}/>"
+          if text
+            tail = ">#{Rfc2629::process_markdown(text)}</#{gi}>"
+          else
+            tail = "/>"
+          end
+          "<#{gi}#{el_html_attributes(el)}#{tail}"
         end
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kramdown-rfc2629
 version: !ruby/object:Gem::Version
-  version: 1.4.7
+  version: 1.4.12
 platform: ruby
 authors:
 - Carsten Bormann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-03 00:00:00.000000000 Z
+date: 2021-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kramdown