metanorma-plugin-lutaml 0.7.30 → 0.7.31

data/docs/usages/lutaml-gml.adoc

@@ -0,0 +1,73 @@
+
+== Usage with LutaML GML Dictionary
+
+=== Rendering a LutaML GML Dictionary: `lutaml_gml_dictionary`
+
+This command allows to render a LutaML GML Dictionary by using Liquid Drop.
+
+GmlDictionaryDrop has the following attributes:
+
+* name
+* file_name
+* dictionary_entry
+
+Each `dictionary_entry` has the following attributes:
+
+* name
+* description
+
+[source,adoc]
+----
+lutaml_gml_dictionary::/path/to/dictionary.xml[template="/path/to/template.liquid",context=dict]
+----
+
+The command accepts the options listed below:
+
+* `/path/to/dictionary.xml` specifies the path of xml file of the
+GML Dictionary.
+
+* `template="/path/to/template.liquid"` specifies the liquid template.
+  For example, you can create a liquid template and link it by `template`.
+
+* `context=dict` define the context in the template.
+
+[source,adoc]
+----
+[cols="3a,22a"]
+|===
+| Name | {{ dict.file_name }}
+
+h| Code h| Description
+{% for entry in dict.dictionary_entry %}
+| {{ entry.name }} | {{ entry.description }}
+{% endfor %}
+|===
+
+[.source]
+<<source_link>>
+----
+
+In spite of specifying the path of the template, you can also define an inline
+template within a block by
+`[lutaml_gml_dictionary,"/path/to/dictionary.xml",context=dict]`.
+
+[source,adoc]
+----
+[lutaml_gml_dictionary,"/path/to/dictionary.xml",context=dict]
+--
+{% capture link %}https://www.test.com/{{ dict.file_name }}{% endcapture %}
+
+[cols="3a,22a"]
+|===
+| File Name | {{ dict.file_name }}
+h| URL | {{ link }}
+h| Help | Description
+{% for entry in dict.dictionary_entry %}
+| {{ entry.name }} | {{ entry.description }}
+{% endfor %}
+|===
+
+[.source]
+<<source_link>>
+--
+----

data/docs/usages/lutaml-uml.adoc

@@ -0,0 +1,73 @@
+
+== Usage with Lutaml-UML
+
+=== General
+
+The LutaML plugin supports working with LutaML UML files to render UML diagrams
+and class definitions.
+
+
+=== Rendering a LutaML view: `lutaml_diagram`
+
+This command allows to quickly render a LutaML view as an image file.
+
+Given a file `example.lutaml` file with content:
+
+[source,java]
+----
+diagram MyView {
+  title "my diagram"
+
+  enum AddressClassProfile {
+    imlicistAttributeProfile: CharacterString [0..1] {
+      definition
+        this is multiline with `asciidoc`
+      end definition
+    }
+  }
+
+  class AttributeProfile {
+    +addressClassProfile: CharacterString [0..1]
+    imlicistAttributeProfile: CharacterString [0..1] {
+      definition this is attribute definition
+    }
+  }
+}
+----
+
+The `lutaml_diagram` command will add the image to the document.
+
+[source,adoc]
+----
+lutaml_diagram::example.lutaml[]
+----
+
+The `lutaml_diagram` command can also be used to denote a block with an embedded
+LutaML view.
+
+For example:
+
+[source,java]
+----
+[lutaml_diagram]
+....
+diagram MyView {
+  title "my diagram"
+
+  enum AddressClassProfile {
+    imlicistAttributeProfile: CharacterString [0..1] {
+      definition {
+        This is multiline AsciiDoc content.
+      }
+    }
+  }
+
+  class AttributeProfile {
+    +addressClassProfile: CharacterString [0..1]
+    imlicistAttributeProfile: CharacterString [0..1] {
+      definition this is attribute definition
+    }
+  }
+}
+....
+----

data/lib/metanorma/plugin/lutaml/asciidoctor/preprocessor.rb

@@ -4,7 +4,7 @@ module Metanorma
       module Asciidoctor
         class PreprocessorNoIfdefsReader < ::Asciidoctor::PreprocessorReader
           def preprocess_conditional_directive(_keyword, _target, _delimiter,
-_text)
+            _text)
             false # decline to resolve idefs
           end
         end

data/lib/metanorma/plugin/lutaml/base_structured_text_preprocessor.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require "liquid"
+require "asciidoctor"
+require "asciidoctor/reader"
+require_relative "source_extractor"
+require_relative "utils"
+require "metanorma/plugin/lutaml/asciidoctor/preprocessor"
+
+module Metanorma
+  module Plugin
+    module Lutaml
+      # Base class for processing structured data blocks(yaml, json)
+      class BaseStructuredTextPreprocessor <
+        ::Asciidoctor::Extensions::Preprocessor
+        include Utils
+
+        BLOCK_START_REGEXP = /\{(.+?)\.\*,(.+),(.+)\}/.freeze
+        BLOCK_END_REGEXP = /\A\{[A-Z]+\}\z/.freeze
+        LOAD_FILE_REGEXP = /{% assign (.*) = (.*) \| load_file %}/.freeze
+        INCLUDE_PATH_OPTION = "include_path"
+        TEMPLATE_OPTION = "template"
+
+        def process(document, reader)
+          r = Asciidoctor::PreprocessorNoIfdefsReader
+            .new(document, reader.lines)
+          input_lines = r.readlines
+          Metanorma::Plugin::Lutaml::SourceExtractor
+            .extract(document, input_lines)
+          result_content = processed_lines(document, input_lines.to_enum)
+          Asciidoctor::PreprocessorNoIfdefsReader.new(document, result_content)
+        end
+
+        protected
+
+        def content_from_file(_document, _file_path)
+          raise ArgumentError, "Implement `content_from_file` in your class"
+        end
+
+        def content_from_anchor(_document, _file_path)
+          raise ArgumentError, "Implement `content_from_anchor` in your class"
+        end
+
+        private
+
+        def process_text_blocks(document, input_lines)
+          line = input_lines.next
+          block_match = line.match(/^\[#{config[:block_name]},(.+?)\]/)
+          return [line] if block_match.nil?
+
+          end_mark = input_lines.next
+          parse_template(
+            document,
+            collect_internal_block_lines(document, input_lines, end_mark),
+            block_match,
+          )
+        end
+
+        def collect_internal_block_lines(document, input_lines, end_mark) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          current_block = []
+          while (block_line = input_lines.next) != end_mark
+            if block_line.match?(LOAD_FILE_REGEXP)
+              load_file_match = block_line.match(LOAD_FILE_REGEXP)
+
+              # Add parent folder as argument to loadfile filter
+              block_line = "{% assign #{load_file_match[1]} = "\
+                           "#{load_file_match[2]} | loadfile: " \
+                           "\"#{document.attributes['docdir']}\" %}"
+            end
+
+            current_block.push(block_line)
+          end
+          current_block
+        end
+
+        def data_file_type
+          @config[:block_name].split("2").first
+        end
+
+        def parse_template(document, current_block, block_match) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          transformed_liquid_lines = current_block.map do |x|
+            transform_line_liquid(x)
+          end
+
+          contexts, include_path, template_path = resolve_context(
+            document, block_match
+          )
+
+          parse_context_block(
+            document: document,
+            context_lines: transformed_liquid_lines,
+            contexts: contexts,
+            include_path: include_path,
+            template_path: template_path,
+          )
+        rescue StandardError => e
+          ::Metanorma::Util.log("Failed to parse #{config[:block_name]} \
+              block: #{e.message}", :error)
+          []
+        end
+
+        def resolve_context(document, block_match) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          include_path = nil
+          template_path = nil
+
+          contexts = if block_match[1].include?("=")
+                       multiple_contexts, include_path, template_path =
+                         content_from_multiple_contexts(
+                           document, block_match[1].split(",")
+                         )
+                       multiple_contexts
+                     elsif block_match[1].start_with?("#")
+                       anchor = block_match[1].split(",").first.strip[1..-1]
+                       {
+                         block_match[1].split(",").last.strip =>
+                           content_from_anchor(document, anchor),
+                       }
+                     else
+                       path = block_match[1].split(",").first.strip
+                       {
+                         block_match[1].split(",").last.strip =>
+                           content_from_file(document, path),
+                       }
+                     end
+          [contexts, include_path, template_path]
+        end
+
+        def content_from_multiple_contexts(document, context_and_paths) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          contexts = {}
+          include_path = nil
+          template_path = nil
+
+          context_and_paths.each do |context_and_path|
+            context_and_path.strip!
+            context_name, path = context_and_path.split("=")
+
+            if context_name == INCLUDE_PATH_OPTION
+              include_path = path
+            elsif context_name == TEMPLATE_OPTION
+              template_path = path
+            else
+              context_items = content_from_file(document, path)
+              contexts[context_name] = context_items
+            end
+          end
+
+          [contexts, include_path, template_path]
+        end
+
+        def transform_line_liquid(line) # rubocop:disable Metrics/MethodLength
+          if line.match?(BLOCK_START_REGEXP)
+            line.gsub!(BLOCK_START_REGEXP, '{% keyiterator \1, \2 %}')
+          end
+
+          if line.strip.match?(BLOCK_END_REGEXP)
+            line.gsub!(BLOCK_END_REGEXP, "{% endkeyiterator %}")
+          end
+          line
+            .gsub(/(?<!{){(?!%)([^{}]{1,900})(?<!%)}(?!})/, '{{\1}}')
+            .gsub(/[a-z\.]{1,900}\#/, "index")
+            .gsub(/{{([^}]{1,900})\s+\+\s+(\d+)\s*?}}/, '{{ \1 | plus: \2 }}')
+            .gsub(/{{([^}]{1,900})\s+-\s+(\d+)\s*?}}/, '{{ \1 | minus: \2 }}')
+            .gsub(/{{([^}]{1,500})\.values([^}]{0,500})}}/,
+                  '{% assign custom_value = \1 | values %}{{custom_value\2}}')
+        end
+
+        def parse_context_block( # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          context_lines:, contexts:, document:,
+          include_path: nil, template_path: nil
+        )
+          if include_path
+            include_path = relative_file_path(document, include_path)
+          end
+
+          if template_path
+            template_path = relative_file_path(document, template_path)
+          end
+
+          render_result, errors = render_liquid_string(
+            template_string: context_lines.join("\n"),
+            contexts: contexts,
+            document: document,
+            include_path: include_path,
+            template_path: template_path,
+          )
+          notify_render_errors(document, errors)
+          render_result.split("\n")
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/plugin/lutaml/content.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+
+module Metanorma
+  module Plugin
+    module Lutaml
+      module Content
+        protected
+
+        # https://ruby-doc.org/stdlib-2.5.1/libdoc/psych/rdoc/Psych.html#method-c-safe_load
+        def yaml_content_from_file(resolved_file_path) # rubocop:disable Metrics/MethodLength
+          unless File.exist?(resolved_file_path)
+            ::Metanorma::Util.log(
+              "YAML file referenced in [yaml2text] block not found: " \
+              "#{resolved_file_path}", :error
+            )
+            return
+          end
+
+          YAML.safe_load(
+            File.read(resolved_file_path, encoding: "UTF-8"),
+            permitted_classes: [Date, Time, Symbol],
+            permitted_symbols: [],
+            aliases: true,
+          )
+        end
+
+        def yaml_content_from_anchor(document, anchor)
+          YAML.safe_load(
+            document.attributes["source_blocks"][anchor],
+            permitted_classes: [Date, Time, Symbol],
+            permitted_symbols: [],
+            aliases: true,
+          )
+        end
+
+        def json_content_from_file(resolved_file_path)
+          JSON.parse(File.read(resolved_file_path, encoding: "UTF-8"))
+        end
+
+        def json_content_from_anchor(document, anchor)
+          JSON.parse(document.attributes["source_blocks"][anchor])
+        end
+
+        def content_from_file(document, file_path)
+          resolved_file_path = relative_file_path(document, file_path)
+          load_content_from_file(resolved_file_path)
+        end
+
+        def load_content_from_file(resolved_file_path)
+          unless File.exist?(resolved_file_path)
+            ::Metanorma::Util
+              .log("Failed to load content from file: #{resolved_file_path}",
+                   :error)
+          end
+
+          if json_file?(resolved_file_path)
+            json_content_from_file(resolved_file_path)
+          else
+            yaml_content_from_file(resolved_file_path)
+          end
+        end
+
+        def content_from_anchor(document, anchor)
+          source_block = document.attributes["source_blocks"][anchor]
+          if json_content?(source_block)
+            json_content_from_anchor(document, anchor)
+          else
+            yaml_content_from_anchor(document, anchor)
+          end
+        end
+
+        def json_or_yaml_filepath?(file_path)
+          file_path.end_with?(".json", ".yaml", ".yml")
+        end
+
+        def json_file?(file_path)
+          file_path.end_with?(".json")
+        end
+
+        def json_content?(content)
+          content.start_with?("{", "[")
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/plugin/lutaml/data2_text_preprocessor.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "content"
+require_relative "base_structured_text_preprocessor"
+
+module Metanorma
+  module Plugin
+    module Lutaml
+      class Data2TextPreprocessor < BaseStructuredTextPreprocessor
+        include Content
+        # search document for block `data2text`
+        #   after that take template from block and read file into this template
+        #   example:
+        #     [data2text,my_yaml=foobar.yaml,my_json=foobar.json]
+        #     ----
+        #     === {foobar.name}
+        #     {foobar.desc}
+        #
+        #     {my_json.symbol}:: {my_json.symbol_def}
+        #     ----
+        #
+        #   with content of `foobar.yaml` file equal to:
+        #     - name: spaghetti
+        #       desc: wheat noodles of 9mm diameter
+        #
+        #   and content of `foobar.json` file equal to:
+        #     {
+        #       "symbol": "SPAG",
+        #       "symbol_def": "the situation is message like spaghetti",
+        #     }
+        #
+        #   will produce:
+        #     === spaghetti
+        #     wheat noodles of 9mm diameter
+        #
+        #     SPAG:: the situation is message like spaghetti
+
+        def initialize(config = {})
+          super
+          @config[:block_name] = "data2text"
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/plugin/lutaml/express_remarks_decorator.rb

@@ -4,7 +4,19 @@ module Metanorma
   module Plugin
     module Lutaml
       class ExpressRemarksDecorator
-        RELATIVE_PREFIX_MACRO_REGEXP = /^(link|image|video|audio|include)(:+)?(?![^\/:]+:\/\/|[A-Z]:\/|\/)([^:\[]+)(\[.*\])?$/.freeze
+        RELATIVE_PREFIX_MACRO_REGEXP = %r{
+          ^                                # Start of line
+          (link|image|video|audio|include) # Capture group 1: content type
+          (:+)?                            # Capture group 2: optional colons
+          (?!                              # Negative lookahead
+            [^\/:]+://|                    # Don't match URLs (http://, etc.)
+            [A-Z]:/|                       # Don't match Windows paths
+            /                              # Don't match absolute paths
+          )                                # End negative lookahead
+          ([^:\[]+)                        # Capture group 3: the path/name
+          (\[.*\])?                        # Capture group 4: optional attribute
+          $                                # End of line
+        }x.freeze
 
         attr_reader :remark, :options
 
@@ -21,7 +33,7 @@ module Metanorma
           result = remark
           if options["relative_path_prefix"]
             result = update_relative_paths(result,
-                                          options["relative_path_prefix"])
+                                           options["relative_path_prefix"])
           end
           result
         end
@@ -44,10 +56,11 @@ module Metanorma
         def prefix_relative_paths(line, path_prefix)
           line.gsub(RELATIVE_PREFIX_MACRO_REGEXP) do |_match|
             prefixed_path = File.join(path_prefix, $3.strip)
-            # When we are dealing with a relative path of a template:
-            # ../path/to/file we need to transform it into
-            # the absolute one because `image::` macro wont understand it other way
-            prefixed_path = File.absolute_path(prefixed_path) if prefixed_path.start_with?("../")
+            # Transform relative path (../path/to/file) into the absolute path
+            # because `image::` macro wont understand it other way
+            if prefixed_path.start_with?("../")
+              prefixed_path = File.absolute_path(prefixed_path)
+            end
             full_path = File.expand_path(prefixed_path)
             "#{$1}#{$2}#{full_path}#{$4}"
           end

data/lib/metanorma/plugin/lutaml/json2_text_preprocessor.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "content"
+require_relative "base_structured_text_preprocessor"
+
+module Metanorma
+  module Plugin
+    module Lutaml
+      class Json2TextPreprocessor < BaseStructuredTextPreprocessor
+        include Content
+        # search document for block `json2text`
+        #   after that take template from block and read file into this template
+        #   example:
+        #     [json2text,foobar.json]
+        #     ----
+        #     === {item.name}
+        #     {item.desc}
+        #
+        #     {item.symbol}:: {item.symbol_def}
+        #     ----
+        #
+        #   with content of `foobar.json` file equal to:
+        #     {
+        #       "name": "spaghetti",
+        #       "desc": "wheat noodles of 9mm diameter".
+        #       "symbol": "SPAG",
+        #       "symbol_def": "the situation is message like spaghetti",
+        #     }
+        #
+        #   will produce:
+        #     === spaghetti
+        #     wheat noodles of 9mm diameter
+        #
+        #     SPAG:: the situation is message like spaghetti
+
+        def initialize(config = {})
+          super
+          @config[:block_name] = "json2text"
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/plugin/lutaml/liquid/custom_blocks/key_iterator.rb

@@ -0,0 +1,31 @@
+module Metanorma
+  module Plugin
+    module Lutaml
+      module Liquid
+        module CustomBlocks
+          class KeyIterator < ::Liquid::Block
+            def initialize(tag_name, markup, tokens)
+              super
+              @context_name, @var_name = markup.split(",").map(&:strip)
+            end
+
+            def render(context) # rubocop:disable Metrics/MethodLength
+              res = ""
+              iterator = if context[@context_name].is_a?(Hash)
+                           context[@context_name].keys
+                         else
+                           context[@context_name]
+                         end
+              iterator.each.with_index do |key, index|
+                context["index"] = index
+                context[@var_name] = key
+                res += super
+              end
+              res
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/plugin/lutaml/liquid/custom_filters/loadfile.rb

@@ -0,0 +1,18 @@
+require_relative "../../content"
+
+module Metanorma
+  module Plugin
+    module Lutaml
+      module Liquid
+        module CustomFilters
+          include ::Metanorma::Plugin::Lutaml::Content
+
+          def loadfile(path, parent_folder = ".")
+            resolved_file_path = File.expand_path(path, parent_folder)
+            load_content_from_file(resolved_file_path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/plugin/lutaml/liquid/custom_filters/replace_regex.rb

@@ -0,0 +1,14 @@
+module Metanorma
+  module Plugin
+    module Lutaml
+      module Liquid
+        module CustomFilters
+          def replace_regex(text, regex_search, replace_value)
+            regex = /#{regex_search}/
+            text.to_s.gsub(regex, replace_value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/plugin/lutaml/liquid/custom_filters/values.rb

@@ -0,0 +1,13 @@
+module Metanorma
+  module Plugin
+    module Lutaml
+      module Liquid
+        module CustomFilters
+          def values(list)
+            list.values
+          end
+        end
+      end
+    end
+  end
+end