kramdown-rfc2629 1.4.10 → 1.4.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e94ef372b40394892134b787b7deb9a1c69060622452f6d7eb41d0165346de14
-  data.tar.gz: 55e0579bc857461d2ca7502957853264e4b176f5760b79e0dacdd3245a9f132c
+  metadata.gz: 92062f28c5c76b9a5492c88c4f55fc2a426a25b44d344ea4a98f035d67de2c26
+  data.tar.gz: e17d3fce5cd6fe0bf2dd0364336b49b8de92de6e85bfbb09a90d365ae2605989
 SHA512:
-  metadata.gz: 53a957d89977260a054963342c8ef5d2aa9e270689fc6f78e1abed296489a18cb12a66c1b8ddfad6404599180c3cc61cd271e83a969064e272d39ec3b1a5373d
-  data.tar.gz: 6f2af11238cb255f3f1506fa6bf31264dc8224972a68c41a33a99e0722e3e91db5f7296d37d460dddf301d90a8ec400ba14d9b8d04938415832c93089cdef8c5
+  metadata.gz: 84185943775453981c67205b8364c7d3179612633cd31e86bd61c680bc95a7c12f6380fefd19068659e36d2a1ee51b5e2be659dc7ca1f09b514793075d22bf5a
+  data.tar.gz: bb345c9bde88d532d938efa61edf2163463b573197288a2c4e32e81e3ee4c5318b50ddf3bb5f077deb08cad61d0b16ccc65062af082e2a4d644fc444dedffd03

data/bin/kdrfc

@@ -127,7 +127,7 @@ BANNER
   opts.on("-p", "--[no-]prep", "Convert xml to prepped xml") do |v|
     $options.prep = v
   end
-  opts.on("-P", "--[no-]pdf", "Convert xml to PDF") do |v|
+  opts.on("-P", "-f", "--[no-]pdf", "Convert xml to PDF") do |v|
     $options.pdf = v
   end
   opts.on("-c", "--[no-]convert", "Convert xml to v3 xml") do |v|

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
 
@@ -83,10 +91,68 @@ NORMINFORM = { "!" => :normative, "?" => :informative }
 
 def yaml_load(input, *args)
   if YAML.respond_to?(:safe_load)
-    YAML.safe_load(input, *args)
+    begin
+      YAML.safe_load(input, *args)
+    rescue ArgumentError
+      YAML.safe_load(input, permitted_classes: args[0], permitted_symbols: args[1], aliases: args[2])
+    end
   else
     YAML.load(input)
- end
+  end
+end
+
+def process_kramdown_options(coding_override = nil,
+                             smart_quotes = nil, typographic_symbols = nil,
+                             header_kramdown_options = nil)
+
+  ascii_target = coding_override && coding_override =~ /ascii/
+  suppress_typography = ascii_target || $options.v3
+  entity_output = ascii_target ? :numeric : :as_char;
+
+  options = {input: 'RFC2629Kramdown', entity_output: entity_output, link_defs: {}}
+
+  if smart_quotes.nil? && suppress_typography
+    smart_quotes = false
+  end
+  if smart_quotes == false
+    smart_quotes = ["'".ord, "'".ord, '"'.ord, '"'.ord]
+  end
+  case smart_quotes
+  when Array
+    options[:smart_quotes] = smart_quotes
+  when nil, true
+    # nothin
+  else
+    warn "*** Can't deal with smart_quotes value #{smart_quotes.inspect}"
+  end
+
+  if typographic_symbols.nil? && suppress_typography
+    typographic_symbols = false
+  end
+  if typographic_symbols == false
+    typographic_symbols = Hash[::Kramdown::Parser::Kramdown::TYPOGRAPHIC_SYMS.map { |k, v|
+                                 if Symbol === v
+                                   [v.intern, k]
+                                 end
+                               }.compact]
+  end
+  # warn [:TYPOGRAPHIC_SYMBOLS, typographic_symbols].to_yaml
+  case typographic_symbols
+  when Hash
+    options[:typographic_symbols] = typographic_symbols
+  when nil, true
+    # nothin
+  else
+    warn "*** Can't deal with typographic_symbols value #{typographic_symbols.inspect}"
+  end
+
+  if header_kramdown_options
+    options.merge! header_kramdown_options
+  end
+
+  $global_markdown_options = options   # For nested calls in bibref annotation processing and xref text
+
+  options
 end
 
 XREF_SECTIONS_RE = ::Kramdown::Parser::RFC2629Kramdown::SECTIONS_RE
@@ -115,10 +181,15 @@ def xml_from_sections(input)
   # We put back the "---" plus gratuitous blank lines to hack the line number in errors
   yaml_in = input[/---\s*/] << sections.shift[2]
   ps = KramdownRFC::ParameterSet.new(yaml_load(yaml_in, [Date], [], true))
+
   coding_override = ps.has(:coding)
   smart_quotes = ps[:smart_quotes]
   typographic_symbols = ps[:typographic_symbols]
-  kramdown_options = ps[:kramdown_options]
+  header_kramdown_options = ps[:kramdown_options]
+
+  kramdown_options = process_kramdown_options(coding_override,
+                                              smart_quotes, typographic_symbols,
+                                              header_kramdown_options)
 
   # all the other sections are put in a Hash, possibly concatenated from parts there
   sechash = Hash.new{ |h,k| h[k] = ""}
@@ -231,13 +302,12 @@ def xml_from_sections(input)
   end
 
   stand_alone = ps[:stand_alone]
-  link_defs = {}
 
   [:normative, :informative].each do |sn|
     if refs = ps[sn]
       refs.each do |k, v|
         href = k.gsub(/\A[0-9]/) { "_#{$&}" } # can't start an IDREF with a number
-        link_defs[k] = ["##{href}", nil]            # allow [RFC2119] in addition to {{RFC2119}}
+        kramdown_options[:link_defs][k] = ["##{href}", nil]   # allow [RFC2119] in addition to {{RFC2119}}
 
         bibref = anchor_to_bibref[k] || k
         bts, url = bibtagsys(bibref, k, stand_alone)
@@ -258,9 +328,7 @@ def xml_from_sections(input)
           if bts && !v.delete("override")
             warn "*** warning: explicit settings completely override canned bibxml in reference #{k}"
           end
-          options = {input: 'RFC2629Kramdown', entity_output: coding_override, link_defs: link_defs}
-          $global_markdown_options = options # For recursive calls in bibref annotation processing.
-          sechash[sn.to_s] << KramdownRFC::ref_to_xml(k, v)
+          sechash[sn.to_s] << KramdownRFC::ref_to_xml(href, v)
         end
       end
     end
@@ -277,7 +345,7 @@ def xml_from_sections(input)
     warn "*** sections left #{sechash.keys.inspect}!"
   end
 
-  [input, coding_override, link_defs, smart_quotes, typographic_symbols, kramdown_options]
+  [input, kramdown_options, coding_override]
 end
 
 XML_RESOURCE_ORG_PREFIX = Kramdown::Converter::Rfc2629::XML_RESOURCE_ORG_PREFIX
@@ -359,7 +427,6 @@ if $options.verbose && $options.v3
   warn "*** not much RFCXMLv3 stuff implemented yet"
 end
 
-coding_override = :as_char
 input = ARGF.read
 if input[0] == "\uFEFF"
    warn "*** There is a leading byte order mark. Ignored."
@@ -380,59 +447,18 @@ if input =~ /[\t]/
    input = expand_tabs(input)
 end
 
-link_defs = {}
 if input =~ /\A---/        # this is a sectionized file
   do_the_tls_dance unless ENV["KRAMDOWN_DONT_VERIFY_HTTPS"]
-  input, target_coding, link_defs, smart_quotes, typographic_symbols, kramdown_options = xml_from_sections(input)
+  input, options, coding_override = xml_from_sections(input)
+else
+  options = process_kramdown_options # all default
 end
 if input =~ /\A<\?xml/          # if this is a whole XML file, protect it
   input = "{::nomarkdown}\n#{input}\n{:/nomarkdown}\n"
 end
-options = {input: 'RFC2629Kramdown', entity_output: coding_override, link_defs: link_defs}
-if smart_quotes.nil?
-  if (target_coding && target_coding =~ /ascii/) || $options.v3
-     smart_quotes = false
-  end
-end
-if smart_quotes == false
-  smart_quotes = ["'".ord, "'".ord, '"'.ord, '"'.ord]
-end
-case smart_quotes
-when Array
-  options[:smart_quotes] = smart_quotes
-when nil, true
-  # nothin
-else
-  warn "*** Can't deal with smart_quotes value #{smart_quotes.inspect}"
-end
-if typographic_symbols.nil?
-  if (target_coding && target_coding =~ /ascii/) || $options.v3
-     typographic_symbols = false
-  end
-end
-if typographic_symbols == false
-  typographic_symbols = Hash[::Kramdown::Parser::Kramdown::TYPOGRAPHIC_SYMS.map { |k, v|
-                               if Symbol === v
-                                 [v.intern, k]
-                               end
-                             }.compact]
-end
-# warn [:TYPOGRAPHIC_SYMBOLS, typographic_symbols].to_yaml
-case typographic_symbols
-when Hash
-  options[:typographic_symbols] = typographic_symbols
-when nil, true
-  # nothin
-else
-  warn "*** Can't deal with typographic_symbols value #{typographic_symbols.inspect}"
-end
-
-if kramdown_options
-  options.merge! kramdown_options
-end
 
-if target_coding
-  input = input.encode(Encoding.find(target_coding), fallback: FALLBACK)
+if coding_override
+  input = input.encode(Encoding.find(coding_override), fallback: FALLBACK)
 end
 
 # warn "options: #{options.inspect}"

data/kramdown-rfc2629.gemspec

@@ -1,6 +1,6 @@
 spec = Gem::Specification.new do |s|
   s.name = 'kramdown-rfc2629'
-  s.version = '1.4.10'
+  s.version = '1.4.14'
   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-rfc2629.rb

@@ -363,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 }
@@ -407,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"
@@ -424,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
@@ -490,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
@@ -891,6 +917,7 @@ COLORS
                  ],
         "W3C" => "bibxml4",
         "3GPP" => "bibxml5",
+        "SDO-3GPP" => "bibxml5",
         "ANSI" => "bibxml2",
         "CCITT" => "bibxml2",
         "FIPS" => "bibxml2",

metadata

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