metanorma 2.1.4 → 2.1.6

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,57 @@
+# 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(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(stdtype)
+        flavor = STDTYPE2FLAVOR[stdtype] || stdtype
+        "metanorma-#{flavor}"
+      end
+
+      private
+
+      STDTYPE2FLAVOR = {}.freeze
+
+      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/validator.rb

@@ -0,0 +1,28 @@
+# 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)
+        unless options[:type]
+          Util.log("[metanorma] Error: Please specify a standard type: "\
+                   "#{@registry.supported_backends}.", :fatal)
+        end
+        stdtype = options[:type].to_sym
+        load_flavor(stdtype)
+      end
+
+      def validate_format!(options)
+        unless options[:format] == :asciidoc
+          Util.log("[metanorma] Error: Only source file format currently "\
+                   "supported is 'asciidoc'.", :fatal)
+        end
+      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/version.rb

@@ -1,3 +1,3 @@
 module Metanorma
-  VERSION = "2.1.4".freeze
+  VERSION = "2.1.6".freeze
 end

data/metanorma.gemspec

@@ -45,7 +45,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "rspec-command", "~> 1.0"
   spec.add_development_dependency "rubocop", "~> 1"
-spec.add_development_dependency "rubocop-performance"
+  spec.add_development_dependency "rubocop-performance"
   spec.add_development_dependency "sassc-embedded", "~> 1"
   spec.add_development_dependency "simplecov", "~> 0.15"
   spec.add_development_dependency "xml-c14n"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metanorma
 version: !ruby/object:Gem::Version
-  version: 2.1.4
+  version: 2.1.6
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-04 00:00:00.000000000 Z
+date: 2025-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: asciidoctor
@@ -340,8 +340,13 @@ files:
 - lib/metanorma/collection/xrefprocess/xrefprocess.rb
 - lib/metanorma/compile/compile.rb
 - lib/metanorma/compile/compile_options.rb
-- lib/metanorma/compile/compile_validate.rb
 - lib/metanorma/compile/extract.rb
+- lib/metanorma/compile/flavor.rb
+- lib/metanorma/compile/output_filename.rb
+- lib/metanorma/compile/output_filename_config.rb
+- lib/metanorma/compile/relaton_drop.rb
+- lib/metanorma/compile/validator.rb
+- lib/metanorma/compile/writeable.rb
 - lib/metanorma/config/config.rb
 - lib/metanorma/input.rb
 - lib/metanorma/input/asciidoc.rb

data/lib/metanorma/compile/compile_validate.rb

@@ -1,68 +0,0 @@
-module Metanorma
-  class Compile
-    def validate_options(options)
-      validate_type(options)
-      validate_format(options)
-    end
-
-    def validate_type(options)
-      unless options[:type]
-        Util.log("[metanorma] Error: Please specify a standard type: "\
-                 "#{@registry.supported_backends}.", :fatal)
-      end
-      stdtype = options[:type].to_sym
-      load_flavor(stdtype)
-    end
-
-    def validate_format(options)
-      unless options[:format] == :asciidoc
-        Util.log("[metanorma] Error: Only source file format currently "\
-                 "supported is 'asciidoc'.", :fatal)
-      end
-    end
-
-    def load_flavor(stdtype)
-      stdtype = stdtype.to_sym
-      flavor = stdtype2flavor(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
-
-    def stdtype2flavor(stdtype)
-      flavor = STDTYPE2FLAVOR[stdtype] || stdtype
-      "metanorma-#{flavor}"
-    end
-
-    private
-
-    STDTYPE2FLAVOR = {}.freeze
-
-    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