kramdown-rfc2629 1.4.19 → 1.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9d0ef4b91bf819df60d48b12c30be152eab6a987ba2d88a3572bde42e180925
-  data.tar.gz: '09603840027889929894dfc79170f6f7d16a0e932cfe7b6dfc4d2d2501eb7f7d'
+  metadata.gz: 49968f621678e46d7ecde1451347a63f8a9dd93d0c7dc1f822ee7314f1c7c3fc
+  data.tar.gz: d94a74186a8be6c9880c8e15d73b7961df19ab566a55b5a3a643a34aaa1f3c5a
 SHA512:
-  metadata.gz: 35f806b212b3f6e321614752853dc73ed351f1119c208b7fd83cbd471e3d64e40145b3af19a999a2e2e403a1ff780c5b12baef21c6b44e7e4f4ed8e434610e17
-  data.tar.gz: cb0ddd23e2ced4bda22a095d08926dbbaf6f12a8605faf53289a422c8e1bd2b9d5a9a01a350d88c5843c12ff0a0be4098425403507771d5ba526126bc130bb7d
+  metadata.gz: 424d084703c00e29cad08da0ee6f4568ac6861772eef79fadf26c6f39a4747d6ec192f04abf262d3f26579d4e7fb8493d00c34f9cf01183cabec1b3ccbe1bf4a
+  data.tar.gz: f5d6cf7487ce6601bf2cb3198c9d12727d5c4cc0752c5c9b11f6f29a43304874dca36653e047812486888889bc07e0999fad89d3847b0cb1122f0c020f9f33a1

data/bin/kdrfc

@@ -1,127 +1,13 @@
 #!/usr/bin/env ruby -KU
-require 'uri'
-require 'net/http'
-require 'open3'
+require 'kramdown-rfc/kdrfc-processor'
+require 'optparse'
 
 # try to get this from gemspec.
 KDRFC_VERSION=Gem.loaded_specs["kramdown-rfc2629"].version rescue "unknown-version"
 
-KDRFC_PREPEND = [ENV["KDRFC_PREPEND"]].compact
-
-def v3_flag?
-  $options.v3 ? ["--v3"] : []
-end
-
-def process_mkd(input, output)
-  warn "* converting locally from markdown #{input} to xml #{output}" if $options.verbose
-  o, s = Open3.capture2(*KDRFC_PREPEND, "kramdown-rfc2629", *v3_flag?, input)
-  if s.success?
-    File.open(output, "w") do |fo|
-      fo.print(o)
-    end
-    warn "* #{output} written" if $options.verbose
-  else
-    warn "*** kramdown-rfc failed, status #{s.exitstatus}"
-    exit 1
-  end
-end
+kdrfc = KramdownRFC::KDRFC.new
+kdrfc.options.txt = true             # default
 
-def run_idnits(txt_fn)
-  unless system("idnits", txt_fn)
-    warn "*** problem #$? running idnits"
-  end
-end
-
-def process_xml(*args)
-  if $options.remote
-    process_xml_remotely(*args)
-  else
-    process_xml_locally(*args)
-  end
-end
-
-def process_xml_locally(input, output, *flags)
-  warn "* converting locally from xml #{input} to txt #{output}" if $options.verbose
-  begin
-    o, s = Open3.capture2(*KDRFC_PREPEND, "xml2rfc", *v3_flag?, *flags, input)
-    puts o
-    if s.success?
-      warn "* #{output} written" if $options.verbose
-    else
-      warn "*** xml2rfc failed, status #{s.exitstatus} (possibly try with -r)"
-      exit 1
-    end
-  rescue Errno::ENOENT
-    warn "*** falling back to remote processing" if $options.verbose
-    process_xml_remotely(input, output, *flags)
-  end
-end
-
-XML2RFC_WEBSERVICE = ENV["KRAMDOWN_XML2RFC_WEBSERVICE"] ||
-                     'http://xml2rfc.tools.ietf.org/cgi-bin/xml2rfc-dev.cgi'
-
-MODE_AS_FORMAT = {
-  nil => {                    # v2
-    "--text" => "txt/ascii",
-    "--html" => "html/ascii",
-  },
-  true => {                     # v3
-    "--text" => "txt/v3ascii",
-    "--html" => "html/v3ascii",
-    "--v2v3" => "v3xml/ascii",
-  }
-}
-
-def process_xml_remotely(input, output, *flags)
-  warn "* converting remotely from xml #{input} to txt #{output}" if $options.verbose
-  format = flags[0] || "--text"
-  # warn [:V3, $options.v3].inspect
-  maf = MODE_AS_FORMAT[$options.v3][format]
-  unless maf
-    warn "*** don't know how to convert remotely from xml #{input} to txt #{output}"
-    exit(1)
-  end
-  url = URI(XML2RFC_WEBSERVICE)
-  req = Net::HTTP::Post.new(url)
-  form = [["modeAsFormat", maf],
-          ["type", "binary"],
-          ["input", File.open(input),
-           {filename: "input.xml",
-            content_type: "text/plain"}]]
-  diag = ["url/form: ", url, form].inspect
-  req.set_form(form, 'multipart/form-data')
-  res = Net::HTTP::start(url.hostname, url.port,
-                         :use_ssl => url.scheme == 'https' ) {|http|
-    http.request(req)
-  }
-  case res
-  when Net::HTTPOK
-    case res.content_type
-    when 'application/octet-stream'
-      if res.body == ''
-        warn "*** HTTP response is empty with status #{res.code}, not written"
-        exit 1
-      end
-      File.open(output, "w") do |fo|
-        fo.print(res.body)
-      end
-      warn "* #{output} written" if $options.verbose
-    else
-      warn "*** HTTP response has unexpected content_type #{res.content_type} with status #{res.code}, #{diag}"
-      warn res.body
-      exit 1
-    end
-  else
-    warn "*** HTTP response: #{res.code}, #{diag}"
-    exit 1
-  end
-end
-
-require 'optparse'
-require 'ostruct'
-
-$options = OpenStruct.new
-$options.txt = true             # default
 op = OptionParser.new do |opts|
   opts.banner = <<BANNER
 Usage: kdrfc [options] file.md|file.mkd|file.xml
@@ -136,63 +22,45 @@ BANNER
     exit
   end
   opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
-    $options.verbose = v
+    kdrfc.options.verbose = v
   end
   opts.on("-r", "--[no-]remote", "Run xml2rfc remotely even if there is a local one") do |v|
-    $options.remote = v
+    kdrfc.options.remote = v
   end
   opts.on("-x", "--[no-]xml", "Convert to xml only") do |v|
-    $options.xml_only = v
+    kdrfc.options.xml_only = v
   end
   opts.on("-p", "--[no-]prep", "Convert xml to prepped xml") do |v|
-    $options.prep = v
+    kdrfc.options.prep = v
   end
   opts.on("-P", "-f", "--[no-]pdf", "Convert xml to PDF") do |v|
-    $options.pdf = v
+    kdrfc.options.pdf = v
   end
   opts.on("-c", "--[no-]convert", "Convert xml to v3 xml") do |v|
-    $options.v2v3 = v
+    kdrfc.options.v2v3 = v
   end
   opts.on("-i", "--[no-]idnits", "Run idnits on the resulting text") do |v|
-    $options.idnits = v
+    kdrfc.options.idnits = v
   end
   opts.on("-h", "--[no-]html", "Convert to html as well") do |v|
-    $options.html = v
+    kdrfc.options.html = v
   end
   opts.on("-t", "--[no-]txt", "Convert to txt as well") do |v|
-    $options.txt = v
+    kdrfc.options.txt = v
   end
   opts.on("-3", "--[no-]v3", "Use RFCXML v3 processing rules") do |v|
-    $options.v3 = v
+    kdrfc.options.v3 = v
   end
 end
 op.parse!
 
-def process_the_xml(fn, base)
-  process_xml(fn, "#{base}.prepped.xml", "--preptool") if $options.prep
-  process_xml(fn, "#{base}.v2v3.xml", "--v2v3") if $options.v2v3
-  process_xml(fn, "#{base}.txt") if $options.txt || $options.idnits
-  process_xml(fn, "#{base}.html", "--html") if $options.html
-  process_xml(fn, "#{base}.pdf", "--pdf") if $options.pdf
-  run_idnits("#{base}.txt") if $options.idnits
-end
-
 case ARGV.size
 when 1
   fn = ARGV[0]
-  case fn
-  when /(.*)\.xml\z/
-    if $options.xml_only
-      warn "*** You already have XML"
-    else                        # FIXME: copy/paste
-      process_the_xml(fn, $1)
-    end
-  when /(.*)\.mk?d\z/
-    xml = "#$1.xml"
-    process_mkd(fn, xml)
-    process_the_xml(xml, $1) unless $options.xml_only
-  else
-    warn "Unknown file type: #{fn}"
+  begin
+    kdrfc.process(fn)
+  rescue StandardError => e
+    warn e.to_s
     exit 1
   end
 else

data/data/kramdown-rfc2629.erb

@@ -69,6 +69,17 @@
 
   <middle>
 
+{:/nomarkdown}
+{:quote: gi="blockquote"}
+{:aside: gi="aside"}
+{:markers: sourcecode-markers="true"}
+{:unnumbered: numbered="false"}
+{:vspace: vspace="0"}
+{:removeinrfc: removeinrfc="true"}
+{:notoc: toc="exclude"}
+{:compact: spacing="compact"}
+{::nomarkdown}
+
 <%= sechash.delete("middle") %>
 
   </middle>

data/kramdown-rfc2629.gemspec

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

@@ -0,0 +1,154 @@
+require 'uri'
+require 'net/http'
+require 'open3'
+require 'ostruct'
+
+module KramdownRFC
+
+class KDRFC
+
+  attr_reader :options
+
+  def initialize
+    @options = OpenStruct.new
+  end
+
+  # )))
+
+KDRFC_PREPEND = [ENV["KDRFC_PREPEND"]].compact
+
+def v3_flag?
+  @options.v3 ? ["--v3"] : []
+end
+
+def process_mkd(input, output)
+  warn "* converting locally from markdown #{input} to xml #{output}" if @options.verbose
+  o, s = Open3.capture2(*KDRFC_PREPEND, "kramdown-rfc2629", *v3_flag?, input)
+  if s.success?
+    File.open(output, "w") do |fo|
+      fo.print(o)
+    end
+    warn "* #{output} written" if @options.verbose
+  else
+    raise IOError.new("*** kramdown-rfc failed, status #{s.exitstatus}")
+  end
+end
+
+def run_idnits(txt_fn)
+  unless system("idnits", txt_fn)
+    warn "*** problem #$? running idnits"
+  end
+end
+
+def process_xml(*args)
+  if @options.remote
+    process_xml_remotely(*args)
+  else
+    process_xml_locally(*args)
+  end
+end
+
+def process_xml_locally(input, output, *flags)
+  warn "* converting locally from xml #{input} to txt #{output}" if @options.verbose
+  begin
+    o, s = Open3.capture2(*KDRFC_PREPEND, "xml2rfc", *v3_flag?, *flags, input)
+    puts o
+    if s.success?
+      warn "* #{output} written" if @options.verbose
+    else
+      raise IOError.new("*** xml2rfc failed, status #{s.exitstatus} (possibly try with -r)")
+    end
+  rescue Errno::ENOENT
+    warn "*** falling back to remote xml2rfc processing (web service)" # if @options.verbose
+    process_xml_remotely(input, output, *flags)
+  end
+end
+
+XML2RFC_WEBSERVICE = ENV["KRAMDOWN_XML2RFC_WEBSERVICE"] ||
+                     'http://xml2rfc.tools.ietf.org/cgi-bin/xml2rfc-dev.cgi'
+
+MODE_AS_FORMAT = {
+  nil => {                    # v2
+    "--text" => "txt/ascii",
+    "--html" => "html/ascii",
+  },
+  true => {                     # v3
+    "--text" => "txt/v3ascii",
+    "--html" => "html/v3ascii",
+    "--v2v3" => "v3xml/ascii",
+  }
+}
+
+def process_xml_remotely(input, output, *flags)
+  warn "* converting remotely from xml #{input} to txt #{output}" if @options.verbose
+  format = flags[0] || "--text"
+  # warn [:V3, @options.v3].inspect
+  maf = MODE_AS_FORMAT[@options.v3][format]
+  unless maf
+    raise ArgumentError.new("*** don't know how to convert remotely from xml #{input} to txt #{output}")
+  end
+  url = URI(XML2RFC_WEBSERVICE)
+  req = Net::HTTP::Post.new(url)
+  form = [["modeAsFormat", maf],
+          ["type", "binary"],
+          ["input", File.open(input),
+           {filename: "input.xml",
+            content_type: "text/plain"}]]
+  diag = ["url/form: ", url, form].inspect
+  req.set_form(form, 'multipart/form-data')
+  res = Net::HTTP::start(url.hostname, url.port,
+                         :use_ssl => url.scheme == 'https' ) {|http|
+    http.request(req)
+  }
+  case res
+  when Net::HTTPOK
+    case res.content_type
+    when 'application/octet-stream'
+      if res.body == ''
+        raise IOError.new("*** HTTP response is empty with status #{res.code}, not written")
+      end
+      File.open(output, "w") do |fo|
+        fo.print(res.body)
+      end
+      warn "* #{output} written" if @options.verbose
+    else
+      warning = "*** HTTP response has unexpected content_type #{res.content_type} with status #{res.code}, #{diag}"
+      warning << "\n"
+      warning << res.body
+      raise IOError.new(warning)
+    end
+  else
+    raise IOError.new("*** HTTP response: #{res.code}, #{diag}")
+  end
+end
+
+def process_the_xml(fn, base)
+  process_xml(fn, "#{base}.prepped.xml", "--preptool") if @options.prep
+  process_xml(fn, "#{base}.v2v3.xml", "--v2v3") if @options.v2v3
+  process_xml(fn, "#{base}.txt") if @options.txt || @options.idnits
+  process_xml(fn, "#{base}.html", "--html") if @options.html
+  process_xml(fn, "#{base}.pdf", "--pdf") if @options.pdf
+  run_idnits("#{base}.txt") if @options.idnits
+end
+
+def process(fn)
+  case fn
+  when /(.*)\.xml\z/
+    if @options.xml_only
+      warn "*** You already have XML"
+    else                        # FIXME: copy/paste
+      process_the_xml(fn, $1)
+    end
+  when /(.*)\.mk?d\z/
+    xml = "#$1.xml"
+    process_mkd(fn, xml)
+    process_the_xml(xml, $1) unless @options.xml_only
+  else
+    raise ArgumentError.new("Unknown file type: #{fn}")
+  end
+end
+
+# (((
+end
+
+end

data/lib/kramdown-rfc/refxml.rb

@@ -57,17 +57,35 @@ module KramdownRFC
     aups
   end
 
+  # The below anticipates the "postalLine" changes.
+  # If a postalLine is used (abbreviated "postal" in YAML),
+  # non-postalLine elements are appended as further postalLines.
+  # This prepares for how "country" is expected to be handled
+  # specially with the next schema update.
+  # So an address is now best keyboarded as:
+  #   postal:
+  #     - Foo Street
+  #     - 28359 Bar
+  #   country: Germany
+
   PERSON_ERB = <<~ERB
     <<%= element_name%> <%=aups.attrs("initials", "surname", "fullname=name", "role")%>>
       <%= aups.ele("organization=org", aups.attrs("abbrev=orgabbrev",
                                                   *[$options.v3 && "ascii=orgascii"]), "") %>
       <address>
-<% postal = %w{street city region code country}.select{|gi| aups.has(gi)}
-   if postal != [] -%>
+<% postal_elements = %w{extaddr pobox street cityarea city region code sortingcode country postal}.select{|gi| aups.has(gi)}
+   if postal_elements != [] -%>
         <postal>
-<%   postal.each do |gi| -%>
+<% if pl = postal_elements.delete("postal") -%>
+          <%= aups.ele("postalLine=postal") %>
+<%   postal_elements.each do |gi| -%>
+          <%= aups.ele("postalLine=" << gi) %>
+<%   end -%>
+<% else -%>
+<%   postal_elements.each do |gi| -%>
           <%= aups.ele(gi) %>
 <%   end -%>
+<% end -%>
         </postal>
 <% end -%>
 <% %w{phone facsimile email uri}.select{|gi| aups.has(gi)}.each do |gi| -%>

data/lib/kramdown-rfc2629.rb

@@ -53,6 +53,9 @@ module Kramdown
 
       def self.idref_cleanup(href)
         # can't start an IDREF with a number or reserved start
+        if href =~ / /
+          warn "** space(s) in cross-reference '#{href}' -- are you trying to use section references?"
+        end
         href.gsub(/\A(?:[0-9]|section-|u-|figure-|table-|iref-)/) { "_#{$&}" }
       end
 
@@ -125,9 +128,14 @@ module Kramdown
             when /\A(.*) \((#{SECTIONS_RE})\)\z/
               href = $1
               handle_bares($2, attr, "parens", href)
-            when /\A(#{XREF_BASE})<(.+)\z/
-              href = $2
-              attr['section'] = $1
+            when /#{XREF_RE_M}<(.+)\z/
+              href = $3
+              if $2
+                attr['section'] = $2
+                attr['relative'] = "#" << $1
+              else
+                attr['section'] = $1
+              end
               attr['sectionFormat'] = 'bare'
             when /\A<<(.+)\z/
               href = $1
@@ -371,8 +379,20 @@ COLORS
         end
       end
 
+      SVG_NAMESPACES = {"xmlns"=>"http://www.w3.org/2000/svg",
+                        "xlink"=>"http://www.w3.org/1999/xlink"}
+
       def svg_clean_kgt(s)
         d = REXML::Document.new(s)
+        REXML::XPath.each(d.root, "/xmlns:svg", SVG_NAMESPACES) do |x|
+          if (w = x.attributes["width"]) && (h = x.attributes["height"])
+            x.attributes["viewBox"] = "0 0 %d %d" % [w, h]
+          end
+          if x.attributes["viewBox"]
+            x.attributes["width"] = nil
+            x.attributes["height"] = nil
+          end
+        end
         REXML::XPath.each(d.root, "//rect|//line|//path") do |x|
           x.attributes["fill"] = "none"
           x.attributes["stroke"] = "black"
@@ -545,8 +565,17 @@ COLORS
 
       def convert_blockquote(el, indent, opts)
         text = inner(el, indent, opts)
+        if $options.v3
+          gi = el.attr.delete('gi')
+          if gi && gi != 'ul'
+            "#{' '*indent}<#{gi}#{el_html_attributes(el)}>\n#{text}#{' '*indent}</#{gi}>\n"
+          else
+            "#{' '*indent}<ul#{el_html_attributes_with(el, {"empty" => 'true'})}><li>\n#{text}#{' '*indent}</li></ul>\n"
+          end
+        else
         text = "<t></t>" unless text =~ /</ # empty block quote
         "#{' '*indent}<t><list style='empty'#{el_html_attributes(el)}>\n#{text}#{' '*indent}</list></t>\n"
+        end
       end
 
       def end_sections(to_level, indent)
@@ -1032,18 +1061,30 @@ COLORS
         # this would be more like xml2rfc v3:
         # "\n#{' '*indent}<cref>\n#{inner(el.value, indent, opts).rstrip}\n#{' '*indent}</cref>"
         content = inner(el.value, indent, opts).strip
-        content = escape_html(content.sub(/\A<t>(.*)<\/t>\z/m) {$1}, :text) # text only...
+        content = content.sub(/\A<t>(.*)<\/t>\z/m) {$1}
         name = ::Kramdown::Parser::RFC2629Kramdown.idref_cleanup(el.options[:name])
+        o_name = name.dup
         while @footnote_names_in_use[name] do
-          if name =~ /:\d+\z/
+          if name =~ /_\d+\z/
             name.succ!
           else
-            name << ":1"
+            name << "_1"
           end
         end
         @footnote_names_in_use[name] = true
         attrstring = el_html_attributes_with(el, {"anchor" => name})
-        "\n#{' '*indent}<cref#{attrstring}>#{content}</cref>"
+        if $options.v3
+          if o_name[-1] == "-"
+            # Ignore HTML attributes.  Hmm.
+            content
+          else
+            # do not indent span-level so we can stick to previous word.  Good?
+            "<cref#{attrstring}>#{content}</cref>"
+          end
+        else
+          content = escape_html(content, :text) # text only...
+          "\n#{' '*indent}<cref#{attrstring}>#{content}</cref>"
+        end
       end
 
       def convert_raw(el, indent, opts)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kramdown-rfc2629
 version: !ruby/object:Gem::Version
-  version: 1.4.19
+  version: 1.5.4
 platform: ruby
 authors:
 - Carsten Bormann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-03 00:00:00.000000000 Z
+date: 2021-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kramdown
@@ -80,6 +80,7 @@ files:
 - kramdown-rfc2629.gemspec
 - lib/kramdown-rfc/erb.rb
 - lib/kramdown-rfc/gzip-clone.rb
+- lib/kramdown-rfc/kdrfc-processor.rb
 - lib/kramdown-rfc/parameterset.rb
 - lib/kramdown-rfc/refxml.rb
 - lib/kramdown-rfc2629.rb
@@ -102,7 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: Kramdown extension for generating RFC 7749 XML.