metanorma 2.1.4 → 2.2.0

data/lib/metanorma/compile/extract.rb

@@ -1,68 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "writeable"
+
 module Metanorma
   class Compile
-    def relaton_export(isodoc, options)
-      options[:relaton] or return
-      xml = Nokogiri::XML(isodoc, &:huge)
-      bibdata = xml.at("//bibdata") || xml.at("//xmlns:bibdata")
-      File.open(options[:relaton], "w:UTF-8") { |f| f.write bibdata.to_xml }
-    end
+    module Extract
+      # @param isodoc [String] the XML document
+      # @param dirname [String, nil] the directory to extract to
+      # @param extract_types [Array<Symbol>, nil] the types to extract
+      # @return [void]
+      def self.extract(isodoc, dirname, extract_types)
+        dirname or return
+        extract_types.nil? || extract_types.empty? and
+          extract_types = %i[sourcecode image requirement]
+        FileUtils.rm_rf dirname
+        FileUtils.mkdir_p dirname
+        xml = Nokogiri::XML(isodoc, &:huge)
+        extract_types.each do |type|
+          case type
+          when :sourcecode
+            export_sourcecode(xml, dirname)
+          when :image
+            export_image(xml, dirname)
+          when :requirement
+            export_requirement(xml, dirname)
+          end
+        end
+      end
 
-    def clean_sourcecode(xml)
-      xml.xpath(".//callout | .//annotation | .//xmlns:callout | "\
-                ".//xmlns:annotation").each(&:remove)
-      xml.xpath(".//br | .//xmlns:br").each { |x| x.replace("\n") }
-      a = xml.at("./body | ./xmlns:body") and xml = a
-      HTMLEntities.new.decode(xml.children.to_xml)
-    end
+      class << self
+        include Writeable
 
-    def extract(isodoc, dirname, extract_types)
-      dirname or return
-      extract_types.nil? || extract_types.empty? and
-        extract_types = %i[sourcecode image requirement]
-      FileUtils.rm_rf dirname
-      FileUtils.mkdir_p dirname
-      xml = Nokogiri::XML(isodoc, &:huge)
-      sourcecode_export(xml, dirname) if extract_types.include? :sourcecode
-      image_export(xml, dirname) if extract_types.include? :image
-      extract_types.include?(:requirement) and
-        requirement_export(xml, dirname)
-    end
+        private
 
-    def sourcecode_export(xml, dirname)
-      xml.at("//sourcecode | //xmlns:sourcecode") or return
-      FileUtils.mkdir_p "#{dirname}/sourcecode"
-      xml.xpath("//sourcecode | //xmlns:sourcecode").each_with_index do |s, i|
-        filename = s["filename"] || sprintf("sourcecode-%04d.txt", i)
-        export_output("#{dirname}/sourcecode/#{filename}",
-                      clean_sourcecode(s.dup))
-      end
-    end
+        # @param xml [Nokogiri::XML::Document] the XML document
+        # @return [String] the cleaned sourcecode
+        def clean_sourcecode(xml)
+          xml.xpath(".//callout | .//annotation | .//xmlns:callout | "\
+                    ".//xmlns:annotation").each(&:remove)
+          xml.xpath(".//br | .//xmlns:br").each { |x| x.replace("\n") }
+          a = xml.at("./body | ./xmlns:body") and xml = a
+          HTMLEntities.new.decode(xml.children.to_xml)
+        end
 
-    def image_export(xml, dirname)
-      xml.at("//image | //xmlns:image") or return
-      FileUtils.mkdir_p "#{dirname}/image"
-      xml.xpath("//image | //xmlns:image").each_with_index do |s, i|
-        next unless /^data:image/.match? s["src"]
+        def export_sourcecode(xml, dirname)
+          xml.at("//sourcecode | //xmlns:sourcecode") or return
+          FileUtils.mkdir_p "#{dirname}/sourcecode"
+          xml.xpath("//sourcecode | //xmlns:sourcecode").each_with_index do |s, i|
+            filename = s["filename"] || sprintf("sourcecode-%04d.txt", i)
+            export_output("#{dirname}/sourcecode/#{filename}",
+                          clean_sourcecode(s.dup))
+          end
+        end
 
-        %r{^data:image/(?<imgtype>[^;]+);base64,(?<imgdata>.+)$} =~ s["src"]
-        fn = s["filename"] || sprintf("image-%<num>04d.%<name>s",
-                                      num: i, name: imgtype)
-        export_output("#{dirname}/image/#{fn}", Base64.strict_decode64(imgdata),
-                      binary: true)
-      end
-    end
+        def export_image(xml, dirname)
+          xml.at("//image | //xmlns:image") or return
+          FileUtils.mkdir_p "#{dirname}/image"
+          xml.xpath("//image | //xmlns:image").each_with_index do |s, i|
+            next unless /^data:image/.match? s["src"]
+
+            %r{^data:image/(?<imgtype>[^;]+);base64,(?<imgdata>.+)$} =~ s["src"]
+            fn = s["filename"] || sprintf("image-%<num>04d.%<name>s",
+                                          num: i, name: imgtype)
+            export_output(
+              "#{dirname}/image/#{fn}",
+              Base64.strict_decode64(imgdata),
+              binary: true,
+            )
+          end
+        end
 
-    REQUIREMENT_XPATH =
-      "//requirement | //xmlns:requirement | //recommendation | "\
-      "//xmlns:recommendation | //permission | //xmlns:permission".freeze
+        REQUIREMENT_XPATH =
+          "//requirement | //xmlns:requirement | //recommendation | "\
+          "//xmlns:recommendation | //permission | //xmlns:permission"
 
-    def requirement_export(xml, dirname)
-      xml.at(REQUIREMENT_XPATH) or return
-      FileUtils.mkdir_p "#{dirname}/requirement"
-      xml.xpath(REQUIREMENT_XPATH).each_with_index do |s, i|
-        fn = s["filename"] ||
-          sprintf("%<name>s-%<num>04d.xml", name: s.name, num: i)
-        export_output("#{dirname}/requirement/#{fn}", s)
+        def export_requirement(xml, dirname)
+          xml.at(REQUIREMENT_XPATH) or return
+          FileUtils.mkdir_p "#{dirname}/requirement"
+          xml.xpath(REQUIREMENT_XPATH).each_with_index do |s, i|
+            fn = s["filename"] ||
+              sprintf("%<name>s-%<num>04d.xml", name: s.name, num: i)
+            export_output("#{dirname}/requirement/#{fn}", s)
+          end
+        end
       end
     end
   end

data/lib/metanorma/compile/flavor.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Metanorma
+  class Compile
+    module Flavor
+      # Load the flavor gem for the given standard type
+      # @param stdtype [Symbol] the standard type
+      # @return [void]
+      def load_flavor(stdtype)
+        stdtype = stdtype.to_sym
+        flavor = stdtype2flavor_gem(stdtype)
+        @registry.supported_backends.include? stdtype or
+          Util.log("[metanorma] Info: Loading `#{flavor}` gem "\
+                   "for standard type `#{stdtype}`.", :info)
+        require_flavor(flavor)
+        @registry.supported_backends.include? stdtype or
+          Util.log("[metanorma] Error: The `#{flavor}` gem does not "\
+                   "support the standard type #{stdtype}. Exiting.", :fatal)
+      end
+
+      # Convert the standard type to the flavor gem name
+      # @param stdtype [Symbol] the standard type
+      # @return [String] the flavor gem name
+      def stdtype2flavor_gem(stdtype)
+        "metanorma-#{stdtype}"
+      end
+
+      private
+
+      def require_flavor(flavor)
+        require flavor
+        Util.log("[metanorma] Info: gem `#{flavor}` loaded.", :info)
+      rescue LoadError => e
+        error_log = "#{Date.today}-error.log"
+        File.write(error_log, e)
+
+        msg = <<~MSG
+          Error: #{e.message}
+          Metanorma has encountered an exception.
+
+          If this problem persists, please report this issue at the following link:
+
+          * https://github.com/metanorma/metanorma/issues/new
+
+          Please attach the #{error_log} file.
+          Your valuable feedback is very much appreciated!
+
+          - The Metanorma team
+        MSG
+        Util.log(msg, :fatal)
+      end
+    end
+  end
+end

data/lib/metanorma/compile/output_filename.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Metanorma
+  class Compile
+    class OutputFilename
+      # Returns an instance of OutputFilename from the source filename
+      # @param source_filename [String] the source filename
+      # @param output_dir [String, nil] the output directory
+      # @param processor [Metanorma::Processor, nil] the processor
+      # @return [OutputFilename] the instance of OutputFilename
+      def self.from_filename(source_filename, output_dir = nil, processor = nil)
+        new(strip_ext(source_filename), output_dir, processor)
+      end
+
+      class << self
+        private
+
+        def strip_ext(filename)
+          filename.sub(/\.[^.]*$/, "")
+        end
+      end
+
+      # @param noext_filename [String] the path (absolute/relative) of the source file, without extension (e.g., "/a/b/c/test")
+      # @param output_dir [String, nil] the output directory
+      # @param processor [Metanorma::Processor, nil] the processor
+      # @return [OutputFilename] the instance of OutputFilename
+      def initialize(noext_filename, output_dir = nil, processor = nil)
+        @noext_filename = noext_filename
+        @output_dir = output_dir
+        @processor = processor
+      end
+
+      # Returns the full file path name with the semantic XML extension
+      # @return [String] the full file path name with the semantic XML extension
+      def semantic_xml
+        with_extension("xml")
+      end
+
+      # Returns the full file path name with the presentation XML extension
+      # @return [String] the full file path name with the presentation XML extension
+      def presentation_xml
+        with_extension("presentation.xml")
+      end
+
+      # Returns the full file path name with the given format extension
+      # @param format [Symbol] the format
+      # @return [String, nil] the full file path name with the format extension
+      def for_format(format)
+        ext = @processor&.output_formats&.[](format)
+        ext ? with_extension(ext) : nil
+      end
+
+      # Returns the full file path name with the given extension
+      # @param ext [String] the extension
+      # @return [String] the full file path name with the extension
+      def with_extension(ext)
+        file = change_output_dir
+        "#{file}.#{ext}"
+      end
+
+      private
+
+      def change_output_dir
+        File.expand_path(if !@output_dir.nil?
+                           File.join(
+                             @output_dir,
+                             File.basename(@noext_filename),
+                           )
+                         else
+                           @noext_filename
+                         end)
+      end
+    end
+  end
+end

data/lib/metanorma/compile/output_filename_config.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Metanorma
+  class Compile
+    class OutputFilenameConfig
+      DEFAULT_TEMPLATE =
+        "{{ document.docidentifier | downcase" \
+        " | replace: '/' , '-'" \
+        " | replace: ' ' , '-' }}"
+
+      attr_reader :template
+
+      def initialize(template)
+        @template = if template.nil? || template.empty?
+                      DEFAULT_TEMPLATE
+                    else
+                      template
+                    end
+      end
+
+      def generate_filename(relaton_data)
+        template = Liquid::Template.parse(@template)
+        template.render("document" => relaton_data)
+      end
+    end
+  end
+end

data/lib/metanorma/compile/relaton_drop.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "liquid"
+
+module Metanorma
+  class Compile
+    class RelatonDrop < Liquid::Drop
+      def initialize(relaton_data)
+        @relaton = relaton_data
+      end
+
+      def docidentifier
+        at("./docidentifier")
+      end
+
+      def title
+        at("./title")
+      end
+
+      def date
+        at("./date/on")
+      end
+
+      def publisher
+        at("./contributor[role/@type = 'publisher']/organization/name")
+      end
+
+      def language
+        at("./language")
+      end
+
+      def script
+        at("./script")
+      end
+
+      def version
+        at("./version")
+      end
+
+      def slugify
+        docidentifier&.downcase
+          &.gsub(/[^a-z0-9]+/, "-")
+          &.gsub(/-+/, "-")
+          &.gsub(/^-|-$/, "")
+      end
+
+      private
+
+      def at(xpath)
+        @relaton.at(xpath)&.text
+      end
+    end
+  end
+end
+
+

data/lib/metanorma/compile/render.rb

@@ -0,0 +1,178 @@
+module Metanorma
+  class Compile
+    # Generate presentation XML from semantic XML
+    def generate_presentation_xml(source_file, xml, bibdata, output_paths, opt)
+      process_ext(:presentation, source_file, xml, bibdata, output_paths, opt)
+    end
+
+    # Generate multiple output formats with parallel processing
+    def generate_outputs_parallel(
+      source_file, semantic_xml, bibdata, extensions, output_paths, options
+    )
+      @queue = ::Metanorma::Util::WorkersPool.new(
+        ENV["METANORMA_PARALLEL"]&.to_i || DEFAULT_NUM_WORKERS,
+      )
+      # Install required fonts for all extensions
+      gather_and_install_fonts(source_file, options.dup, extensions)
+      # Process each extension in order
+      process_extensions_in_order(
+        source_file, semantic_xml, bibdata, extensions, output_paths, options
+      )
+      @queue.shutdown
+    end
+
+    def process_extensions_in_order(
+      source_file, semantic_xml, bibdata, extensions, output_paths, options
+    )
+      Util.sort_extensions_execution(extensions).each do |ext|
+        process_ext(
+          ext, source_file, semantic_xml, bibdata, output_paths, options
+        ) or break
+      end
+    end
+
+    # Export given bibliographic data to Relaton XML on disk
+    # @param bibdata [Nokogiri::XML::Element] the bibliographic data element
+    # @param options [Hash] compilation options
+    def export_relaton_from_bibdata(bibdata, options)
+      options[:relaton] or return
+      export_output(options[:relaton], bibdata.to_xml)
+    end
+
+    # @param xml [Nokogiri::XML::Document] the XML document
+    # @return [Nokogiri::XML::Element] the bibliographic data element
+    def extract_relaton_metadata(xml)
+      xml.at("//bibdata") || xml.at("//xmlns:bibdata")
+    end
+
+    def wrap_html(options, file_extension, outfilename)
+      if options[:wrapper] && /html$/.match(file_extension)
+        outfilename = outfilename.sub(/\.html$/, "")
+        FileUtils.mkdir_p outfilename
+        FileUtils.mv "#{outfilename}.html", outfilename
+        FileUtils.mv "#{outfilename}_images", outfilename, force: true
+      end
+    end
+
+    # isodoc is Raw Metanorma XML
+    def gather_and_install_fonts(source_file, options, extensions)
+      Util.sort_extensions_execution(extensions).each do |ext|
+        isodoc_options = get_isodoc_options(source_file, options, ext)
+        font_install(isodoc_options.merge(options))
+      end
+    end
+
+    # Process a single extension (output format)
+    def process_ext(ext, source_file, semantic_xml, bibdata, output_paths,
+                    options)
+      output_paths[:ext] = @processor.output_formats[ext]
+      output_paths[:out] = @output_filename.for_format(ext) ||
+        output_paths[:xml].sub(/\.[^.]+$/, ".#{output_paths[:ext]}")
+      isodoc_options = get_isodoc_options(source_file, options, ext)
+
+      # Handle special cases first
+      return true if process_ext_special(
+        ext, semantic_xml, bibdata, output_paths, options, isodoc_options
+      )
+
+      # Otherwise, determine if it uses presentation XML
+      if @processor.use_presentation_xml(ext)
+        # Format requires presentation XML first, then convert to final format
+        process_via_presentation_xml(ext, output_paths, options, isodoc_options)
+      else
+        # Format can be generated directly from semantic XML
+        process_from_semantic_xml(
+          ext, output_paths, semantic_xml, isodoc_options
+        )
+      end
+    end
+
+    # Process special extensions with custom handling
+    def process_ext_special(
+      ext, sem_xml, bibdata, output_paths, options, isodoc_options
+    )
+      if ext == :rxl
+        # Special case: Relaton export
+        export_relaton_from_bibdata(
+          bibdata,
+          options.merge(relaton: output_paths[:out]),
+        )
+        true
+      elsif ext == :presentation && options[:passthrough_presentation_xml]
+        # Special case: Pass through presentation XML
+        f = if File.exist?(output_paths[:orig_filename])
+              output_paths[:orig_filename]
+            else
+              output_paths[:xml]
+            end
+        FileUtils.cp f, output_paths[:presentationxml]
+        true
+      elsif ext == :html && options[:sectionsplit]
+        # Special case: Split HTML into sections
+        sectionsplit_convert(
+          output_paths[:xml], sem_xml, output_paths[:out], isodoc_options
+        )
+        true
+      else
+        false
+      end
+    end
+
+    # Process format that requires presentation XML
+    def process_via_presentation_xml(ext, output_paths, options, isodoc_options)
+      @queue.schedule(ext, output_paths.dup, options.dup,
+                      isodoc_options.dup) do |a, b, c, d|
+                        process_output_from_presentation_xml(a, b, c, d)
+                      end
+    end
+
+    # Generate output format from presentation XML
+    def process_output_from_presentation_xml(ext, output_paths, options,
+                                             isodoc_options)
+      @processor.output(nil, output_paths[:presentationxml],
+                        output_paths[:out], ext, isodoc_options)
+      wrap_html(options, output_paths[:ext], output_paths[:out])
+    rescue StandardError => e
+      strict = ext == :presentation || isodoc_options[:strict] == true
+      isodoc_error_process(e, strict, false)
+    end
+
+    # Process format directly from semantic XML
+    def process_from_semantic_xml(ext, output_paths, sem_xml, isodoc_options)
+      @processor.output(sem_xml, output_paths[:xml], output_paths[:out],
+                        ext, isodoc_options)
+      true # Return as Thread equivalent
+    rescue StandardError => e
+      strict = ext == :presentation || isodoc_options[:strict] == "true"
+      isodoc_error_process(e, strict, true)
+      ext != :presentation
+    end
+
+    # assume we pass in Presentation XML, but we want to recover Semantic XML
+    def sectionsplit_convert(input_filename, file, output_filename = nil,
+                             opts = {})
+      @isodoc ||= IsoDoc::PresentationXMLConvert.new({})
+      input_filename += ".xml" unless input_filename.match?(/\.xml$/)
+      File.exist?(input_filename) or export_output(input_filename, file)
+      presxml = File.read(input_filename, encoding: "utf-8")
+      _xml, filename, dir = @isodoc.convert_init(presxml, input_filename, false)
+      ::Metanorma::Collection::Sectionsplit.new(
+        input: input_filename, isodoc: @isodoc, xml: presxml,
+        base: File.basename(output_filename || filename),
+        output: output_filename || filename, dir: dir, compile_opts: opts
+      ).build_collection
+    end
+
+    private
+
+    def isodoc_error_process(err, strict, must_abort)
+      if strict || err.message.include?("Fatal:")
+        @errors << err.message
+      else
+        puts err.message
+      end
+      puts err.backtrace.join("\n")
+      must_abort and 1
+    end
+  end
+end

data/lib/metanorma/compile/validator.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Metanorma
+  class Compile
+    module Validator
+      def validate_options!(options)
+        validate_type!(options)
+        validate_format!(options)
+      end
+
+      def validate_type!(options)
+        options[:type] or
+          Util.log("[metanorma] Error: Please specify a standard type: "\
+                   "#{@registry.supported_backends}.", :fatal)
+        stdtype = options[:type].to_sym
+        load_flavor(stdtype)
+      end
+
+      def validate_format!(options)
+        options[:format] == :asciidoc or
+          Util.log("[metanorma] Error: Only source file format currently "\
+                   "supported is 'asciidoc'.", :fatal)
+      end
+    end
+  end
+end

data/lib/metanorma/compile/writeable.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Metanorma
+  class Compile
+    module Writeable
+      def export_output(fname, content, **options)
+        mode = options[:binary] ? "wb" : "w:UTF-8"
+        File.open(fname, mode) { |f| f.write content }
+      end
+    end
+  end
+end

data/lib/metanorma/input/asciidoc.rb

@@ -13,8 +13,14 @@ module Metanorma
         ::Asciidoctor.convert(file, out_opts)
       end
 
+      def header(file)
+        ret = file.split("\n\n", 2) or return [nil, nil]
+        ret[0] and ret[0] += "\n"
+        [ret[0], ret[1]]
+      end
+
       def extract_metanorma_options(file)
-        hdr = file.sub(/\n\n.*$/m, "\n")
+        hdr, = header(file)
         /\n:(?:mn-)?(?:document-class|flavor):\s+(?<type>\S[^\n]*)\n/ =~ hdr
         /\n:(?:mn-)?output-extensions:\s+(?<extensions>\S[^\n]*)\n/ =~ hdr
         /\n:(?:mn-)?relaton-output-file:\s+(?<relaton>\S[^\n]*)\n/ =~ hdr
@@ -22,7 +28,7 @@ module Metanorma
         /\n(?<novalid>:novalid:[^\n]*)\n/ =~ hdr
         if defined?(asciimath)
           asciimath =
-            !asciimath.nil? && !/keep-asciimath: false/.match?(asciimath)
+            !asciimath.nil? && !/keep-asciimath:\s*false/.match?(asciimath)
         end
         asciimath = nil if asciimath == false
         {
@@ -49,6 +55,7 @@ module Metanorma
            pdf-owner-password pdf-allow-copy-content pdf-allow-edit-content
            pdf-allow-assemble-document pdf-allow-edit-annotations
            pdf-allow-print pdf-allow-print-hq pdf-allow-fill-in-forms
+           pdf-stylesheet pdf-stylesheet-override
            fonts font-license-agreement pdf-allow-access-content
            pdf-encrypt-metadata iso-word-template document-scheme
            localize-number iso-word-bg-strip-color modspec-identifier-base)
@@ -68,17 +75,17 @@ module Metanorma
       end
 
       def extract_options(file)
-        header = file.sub(/\n\n.*$/m, "\n")
+        hdr, = header(file)
         ret = ADOC_OPTIONS.each_with_object({}) do |w, acc|
-          m = /\n:#{w}:\s+([^\n]+)\n/.match(header) or next
+          m = /\n:#{w}:\s+([^\n]+)\n/.match(hdr) or next
           acc[attr_name_normalise(w)] = m[1]&.strip
         end
         ret2 = EMPTY_ADOC_OPTIONS_DEFAULT_TRUE.each_with_object({}) do |w, acc|
-          m = /\n:#{w}:([^\n]*)\n/.match(header) || [nil, "true"]
+          m = /\n:#{w}:([^\n]*)\n/.match(hdr) || [nil, "true"]
           acc[attr_name_normalise(w)] = (m[1].strip != "false")
         end
         ret3 = EMPTY_ADOC_OPTIONS_DEFAULT_FALSE.each_with_object({}) do |w, acc|
-          m = /\n:#{w}:([^\n]*)\n/.match(header) || [nil, "false"]
+          m = /\n:#{w}:([^\n]*)\n/.match(hdr) || [nil, "false"]
           acc[attr_name_normalise(w)] = !["false"].include?(m[1].strip)
         end
         ret.merge(ret2).merge(ret3).compact

data/lib/metanorma/registry/registry.rb

@@ -1,6 +1,7 @@
 # Registry of all Metanorma types and entry points
 
 require "singleton"
+require "metanorma-taste"
 
 class Error < StandardError
 end
@@ -9,11 +10,17 @@ module Metanorma
   class Registry
     include Singleton
 
-    attr_reader :processors
+    attr_reader :processors, :tastes
 
+    # TODO: make aliases configurable
     def initialize
       @processors = {}
+      @tastes = Metanorma::TasteRegister.instance
+      tastealiases = @tastes.available_tastes.each_with_object({}) do |x, m|
+        m[x] = @tastes.taste_info(x)[:base_flavor]
+      end
       @aliases = { csd: :cc, m3d: :m3aawg, mpfd: :mpfa, csand: :csa }
+        .merge tastealiases
     end
 
     def alias(flavour)
@@ -21,18 +28,14 @@ module Metanorma
     end
 
     def register(processor)
-      raise Error unless processor < ::Metanorma::Processor
-
+      processor < ::Metanorma::Processor or raise Error
       p = processor.new
       # p.short[-1] is the canonical name
       short = Array(p.short)
       @processors[short[-1]] = p
-      short.each do |s|
-        @aliases[s] = short[-1]
-      end
+      short.each { |s| @aliases[s] = short[-1] }
       Array(p.short)
-      Util.log("[metanorma] processor \"#{Array(p.short)[0]}\" registered",
-               :info)
+      Util.log("[metanorma] processor \"#{Array(p.short)[0]}\" registered", :info)
     end
 
     def find_processor(short)