metanorma-plugin-lutaml 0.7.10 → 0.7.11

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

@@ -8,6 +8,7 @@ require "lutaml/uml"
 require "lutaml/xmi"
 require "metanorma/plugin/lutaml/utils"
 require "metanorma/plugin/lutaml/asciidoctor/preprocessor"
+require "metanorma/plugin/lutaml/lutaml_ea_xmi_base"
 
 module Metanorma
   module Plugin
@@ -16,288 +17,15 @@ module Metanorma
       #  @example [lutaml_uml_attributes_table,path/to/lutaml,EntityName]
       class LutamlUmlDatamodelDescriptionPreprocessor <
           ::Asciidoctor::Extensions::Preprocessor
+        include LutamlEaXmiBase
+
         MACRO_REGEXP =
           /\[lutaml_uml_datamodel_description,([^,]+),?(.+)?\]/.freeze
-        LIQUID_INCLUDE_PATH = File.join(
-          Gem.loaded_specs["metanorma-plugin-lutaml"].full_gem_path,
-          "lib", "metanorma", "plugin", "lutaml", "liquid_templates"
-        )
-        DEFAULT_RENDER_INCLUDE = "packages"
-        RENDER_STYLES_INCLUDES = {
-          "default" => "packages",
-          "entity_list" => "packages_entity_list",
-          "entity_list_class" => "packages_entity_list_class",
-          "data_dictionary" => "packages_data_dictionary",
-        }.freeze
-        RENDER_STYLE_ATTRIBUTE = "render_style"
-        SUPPORTED_NESTED_MACRO = %w[
-          before diagram_include_block after include_block package_text
-        ].freeze
-        # search document for block `lutaml_uml_datamodel_description`
-        #  read include derectives that goes after that in block and transform
-        #  into yaml2text blocks
-        def process(document, reader)
-          r = Asciidoctor::PreprocessorNoIfdefsReader.new document, reader.lines
-          input_lines = r.readlines.to_enum
-          Asciidoctor::PreprocessorNoIfdefsReader
-            .new(document, processed_lines(document, input_lines))
-        end
 
         private
 
-        def lutaml_document_from_file_or_cache(document, file_path, yaml_config)
-          full_path = Utils.relative_file_path(document, file_path)
-          if document.attributes["lutaml_xmi_cache"] &&
-              document.attributes["lutaml_xmi_cache"][full_path]
-            return document.attributes["lutaml_xmi_cache"][full_path]
-          end
-
-          yaml_config["ea_extension"]&.each do |ea_extension_path|
-            ea_extension_full_path = File.expand_path(
-              ea_extension_path, File.dirname(file_path)
-            )
-            Xmi::EaRoot.load_extension(ea_extension_full_path)
-          end
-
-          result_document = ::Lutaml::Parser
-            .parse(File.new(full_path, encoding: "UTF-8")).first
-          document.attributes["lutaml_xmi_cache"] ||= {}
-          document.attributes["lutaml_xmi_cache"][full_path] = result_document
-          result_document
-        end
-
-        def parse_yaml_config_file(document, file_path)
-          return {} if file_path.nil?
-
-          relative_file_path = Utils.relative_file_path(document, file_path)
-          YAML.safe_load(File.read(relative_file_path, encoding: "UTF-8"))
-        end
-
-        def processed_lines(document, input_lines)
-          result = []
-          loop do
-            result.push(*process_text_blocks(document, input_lines))
-          end
-          result
-        end
-
-        def process_text_blocks(document, input_lines)
-          line = input_lines.next
-          block_match = line.match(MACRO_REGEXP)
-          return [line] if block_match.nil?
-
-          yaml_config = parse_yaml_config_file(document, block_match[2])
-          lutaml_document = lutaml_document_from_file_or_cache(document,
-                                                               block_match[1],
-                                                               yaml_config)
-          fill_in_diagrams_attributes(document, lutaml_document)
-          model_representation(
-            lutaml_document, document,
-            collect_additional_context(document, input_lines, input_lines.next),
-            yaml_config
-          )
-        end
-
-        def fill_in_entities_refs_attributes(document, lutaml_document_wrapper,
-options)
-          lutaml_document = lutaml_document_wrapper.original_document
-          render_style = options.fetch(RENDER_STYLE_ATTRIBUTE, "default")
-          all_children_packages = lutaml_document.packages
-            .map(&:children_packages).flatten
-          package_flat_packages = lambda do |pks|
-            pks.each_with_object({}) do |package, res|
-              res[package.name] = package.xmi_id
-            end
-          end
-          children_pks = package_flat_packages.call(all_children_packages)
-          ref_dictionary = package_flat_packages.call(lutaml_document.packages)
-            .merge(children_pks)
-          %w[class enum data_type].each do |type|
-            package_flat = lambda do |pks|
-              pks.each_with_object({}) do |package, res|
-                plural = type == "class" ? "classes" : "#{type}s"
-                package.send(plural).map do |entity|
-                  res["#{type}:#{package.name}:#{entity.name}"] = entity.xmi_id
-                end
-              end
-            end
-            children_pks_diags = package_flat.call(all_children_packages)
-            ref_dictionary = ref_dictionary
-              .merge(package_flat.call(lutaml_document.packages)
-                                      .merge(children_pks_diags))
-          end
-          document.attributes["lutaml_entity_id"] = ref_dictionary
-        end
-
-        def fill_in_diagrams_attributes(document, lutaml_document_wrapper)
-          lutaml_document = lutaml_document_wrapper.original_document
-          package_flat_diagrams = lambda do |pks|
-            pks.each_with_object({}) do |package, res|
-              package.diagrams.map do |diag|
-                res["#{package.name}:#{diag.name}"] = diag.xmi_id
-              end
-            end
-          end
-          children_pks_diags = package_flat_diagrams.call(
-            lutaml_document.packages.map(&:children_packages).flatten,
-          )
-          document.attributes["lutaml_figure_id"] = package_flat_diagrams
-            .call(lutaml_document.packages)
-            .merge(children_pks_diags)
-        end
-
-        def collect_additional_context(document, input_lines, end_mark)
-          additional_context = Hash.new { |hash, key| hash[key] = [] }
-          additional_context["all_macros"] = []
-          block_lines = []
-          while (block_line = input_lines.next) != end_mark
-            block_lines.push(block_line)
-          end
-          processed_lines =
-            process(document, ::Asciidoctor::PreprocessorReader.new(
-                                document, block_lines
-                              ))
-              .read_lines
-          block_document = ::Asciidoctor::Document
-            .new(processed_lines, {}).parse
-          block_document.blocks.each do |block|
-            next unless SUPPORTED_NESTED_MACRO.include?(block.attributes["role"])
-
-            attrs = block.attributes
-            name = attrs.delete("role")
-            package = attrs.delete("package")
-            macro_keyword = [name, package].compact.join(";")
-            block_text = block.lines.length.positive? ? block.lines.join("\n") : ""
-            additional_context[macro_keyword]
-              .push({ "text" => block_text }.merge(attrs))
-            additional_context["all_macros"]
-              .push({ "text" => block_text,
-                      "type" => name, "package" => package }.merge(attrs))
-          end
-          additional_context
-        end
-
-        def package_level(lutaml_document, level)
-          return lutaml_document if level <= 0
-
-          package_level(lutaml_document["packages"].first, level - 1)
-        end
-
-        def create_context_object(lutaml_document, additional_context, options)
-          root_package = package_level(lutaml_document.to_liquid,
-                                       options["package_root_level"] || 1)
-          if options.empty? || options["packages"].nil?
-            return {
-              "render_nested_packages" => true,
-              "packages" => root_package["packages"],
-              "root_packages" => [root_package],
-              "additional_context" => additional_context
-                  .merge("external_classes" => options["external_classes"]),
-              "name" => root_package["name"],
-            }
-          end
-
-          all_packages = [root_package, *root_package["children_packages"]]
-          {
-            "packages" => sort_and_filter_out_packages(all_packages, options),
-            "package_entities" => package_entities(options),
-            "package_skip_sections" => package_skip_sections(options),
-            "additional_context" => additional_context
-              .merge("external_classes" => options["external_classes"]),
-            "root_packages" => [root_package],
-            "render_nested_packages" => options["render_nested_packages"] ||
-              false,
-            "name" => root_package["name"],
-          }
-        end
-
-        def package_entities(options)
-          return {} unless options["packages"]
-
-          options["packages"]
-            .find_all { |entity| entity.is_a?(Hash) && entity.values.first["render_entities"] }
-            .map do |entity|
-            [entity.keys.first,
-             entity.values.first["render_entities"].map { |n| [n, true] }.to_h]
-          end.to_h
-        end
-
-        def package_skip_sections(options)
-          return {} unless options["packages"]
-
-          options["packages"]
-            .find_all { |entity| entity.is_a?(Hash) && entity.values.first["skip_tables"] }
-            .map do |entity|
-            [entity.keys.first, entity.values.first["skip_tables"].map do |n|
-                                  [n, true]
-                                end.to_h]
-          end.to_h
-        end
-
-        def sort_and_filter_out_packages(all_packages, options)
-          return all_packages if options["packages"].nil?
-
-          result = []
-          # Step one - filter out all skipped packages
-          options["packages"]
-            .find_all { |entity| entity.is_a?(Hash) && entity["skip"] }
-            .each do |entity|
-              entity_regexp = config_entity_regexp(entity["skip"])
-              all_packages
-                .delete_if { |package| package["name"] =~ entity_regexp }
-            end
-          # Step two - select supplied packages by pattern
-          options["packages"]
-            .find_all { |entity| entity.is_a?(String) || (entity.is_a?(Hash) && !entity["skip"]) }
-            .each do |entity_obj|
-              entity = entity_obj.is_a?(String) ? entity_obj : entity_obj.keys.first
-              entity_regexp = config_entity_regexp(entity)
-              all_packages.each do |package|
-                if package["name"]&.match?(entity_regexp)
-                  result.push(package)
-                  all_packages
-                    .delete_if { |nest_package| nest_package["name"] == package["name"] }
-                end
-              end
-            end
-          result
-        end
-
-        def config_entity_regexp(entity)
-          additional_sym = ".*" if /\*$/.match?(entity)
-          %r{^#{Regexp.escape(entity.delete('*'))}#{additional_sym}$}
-        end
-
-        def model_representation(lutaml_document, document, additional_context,
-options)
-          fill_in_entities_refs_attributes(document, lutaml_document, options)
-          render_result, errors = Utils.render_liquid_string(
-            template_string: template(options["section_depth"] || 2,
-                                      options["render_style"],
-                                      options["include_root"]),
-            context_items: create_context_object(lutaml_document,
-                                                 additional_context,
-                                                 options),
-            context_name: "context",
-            document: document,
-            include_path: LIQUID_INCLUDE_PATH,
-          )
-          Utils.notify_render_errors(document, errors)
-          render_result.split("\n")
-        end
-
-        def template(section_depth, render_style, include_root)
-          include_name = RENDER_STYLES_INCLUDES.fetch(render_style,
-                                                      DEFAULT_RENDER_INCLUDE)
-          result = ""
-          if include_root
-            result += <<~LIQUID
-              {% include "#{include_name}", package_skip_sections: context.package_skip_sections, package_entities: context.package_entities, context: context.root_packages, additional_context: context.additional_context, render_nested_packages: false %}
-            LIQUID
-          end
-          result + <<~LIQUID
-            {% include "#{include_name}", depth: #{section_depth}, package_skip_sections: context.package_skip_sections, package_entities: context.package_entities, context: context, additional_context: context.additional_context, render_nested_packages: context.render_nested_packages %}
-          LIQUID
+        def parse_result_document(full_path)
+          ::Lutaml::Parser.parse(File.new(full_path, encoding: "UTF-8")).first
         end
       end
     end

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

@@ -56,8 +56,15 @@ module Metanorma
           end
         end
 
-        def load_express_repositories(path:, cache_path:, document:, force_read: false)
+        def get_original_document(wrapper)
+          doc = wrapper
+          return doc if doc.instance_of?(::Lutaml::XMI::RootDrop)
 
+          doc.original_document
+        end
+
+        def load_express_repositories(path:, cache_path:, document:,
+force_read: false)
           cache_full_path = cache_path &&
             Utils.relative_file_path(document, cache_path)
 
@@ -73,7 +80,7 @@ module Metanorma
           if cache_full_path && !File.file?(cache_full_path)
             save_express_repo_to_cache(
               cache_full_path,
-              lutaml_wrapper.original_document,
+              get_original_document(lutaml_wrapper),
               document,
             )
           end

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

@@ -1,7 +1,7 @@
 module Metanorma
   module Plugin
     module Lutaml
-      VERSION = "0.7.10".freeze
+      VERSION = "0.7.11".freeze
     end
   end
 end

data/metanorma-plugin-lutaml.gemspec

@@ -29,7 +29,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "coradoc", "~> 1.1.1"
   spec.add_dependency "expressir", "~> 1.4.0"
   spec.add_dependency "liquid"
-  spec.add_dependency "lutaml", ">= 0.9.4"
+  spec.add_dependency "lutaml", ">= 0.9.14"
   spec.add_dependency "ogc-gml"
   spec.add_dependency "relaton-cli"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metanorma-plugin-lutaml
 version: !ruby/object:Gem::Version
-  version: 0.7.10
+  version: 0.7.11
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-09-23 00:00:00.000000000 Z
+date: 2024-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: asciidoctor
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.4
+        version: 0.9.14
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.4
+        version: 0.9.14
 - !ruby/object:Gem::Dependency
   name: ogc-gml
   requirement: !ruby/object:Gem::Requirement
@@ -332,13 +332,7 @@ files:
 - lib/metanorma/plugin/lutaml/liquid/multiply_local_file_system.rb
 - lib/metanorma/plugin/lutaml/liquid_drops/gml_dictionary_drop.rb
 - lib/metanorma/plugin/lutaml/liquid_drops/gml_dictionary_entry_drop.rb
-- lib/metanorma/plugin/lutaml/liquid_drops/klass_table_attribute_drop.rb
-- lib/metanorma/plugin/lutaml/liquid_drops/klass_table_content_drop.rb
-- lib/metanorma/plugin/lutaml/liquid_drops/klass_table_drop.rb
-- lib/metanorma/plugin/lutaml/liquid_drops/klass_table_general_drop.rb
 - lib/metanorma/plugin/lutaml/liquid_templates/_diagrams_block.liquid
-- lib/metanorma/plugin/lutaml/liquid_templates/_klass_assoc_row.liquid
-- lib/metanorma/plugin/lutaml/liquid_templates/_klass_row.liquid
 - lib/metanorma/plugin/lutaml/liquid_templates/_klass_table.liquid
 - lib/metanorma/plugin/lutaml/liquid_templates/_packages.liquid
 - lib/metanorma/plugin/lutaml/liquid_templates/_packages_class.liquid
@@ -355,6 +349,7 @@ files:
 - lib/metanorma/plugin/lutaml/lutaml_diagram_block.rb
 - lib/metanorma/plugin/lutaml/lutaml_diagram_block_macro.rb
 - lib/metanorma/plugin/lutaml/lutaml_ea_diagram_block_macro.rb
+- lib/metanorma/plugin/lutaml/lutaml_ea_xmi_base.rb
 - lib/metanorma/plugin/lutaml/lutaml_ea_xmi_preprocessor.rb
 - lib/metanorma/plugin/lutaml/lutaml_figure_inline_macro.rb
 - lib/metanorma/plugin/lutaml/lutaml_gml_dictionary_base.rb

data/lib/metanorma/plugin/lutaml/liquid_drops/klass_table_attribute_drop.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-class KlassTableAttributeDrop < Liquid::Drop
-  LOWER_VALUE_MAPPINGS = {
-    "C" => "0",
-    "M" => "1",
-  }.freeze
-
-  def initialize(attr) # rubocop:disable Lint/MissingSuper
-    @attr = attr
-  end
-
-  def id
-    @attr[:id]
-  end
-
-  def name
-    @attr[:name]
-  end
-
-  def type
-    @attr[:type]
-  end
-
-  def xmi_id
-    @attr[:xmi_id]
-  end
-
-  def is_derived
-    @attr[:is_derived]
-  end
-
-  def cardinality
-    min = @attr[:cardinality]["min"]
-    min = min.nil? ? nil : LOWER_VALUE_MAPPINGS[min]
-
-    "#{min}..#{@attr[:cardinality]['max']}"
-  end
-
-  def definition
-    @attr[:definition]
-  end
-
-  def association
-    @attr[:association]
-  end
-
-  def has_association?
-    !!@attr[:association]
-  end
-
-  def upper_klass
-    @attr[:upper_klass]
-  end
-
-  def name_ns
-    @attr[:name_ns]
-  end
-
-  def type_ns
-    @attr[:type_ns]
-  end
-
-  def gen_name
-    @attr[:gen_name]
-  end
-end

data/lib/metanorma/plugin/lutaml/liquid_drops/klass_table_content_drop.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-class KlassTableContentDrop < Liquid::Drop
-  def initialize(content) # rubocop:disable Lint/MissingSuper
-    @content = content
-  end
-
-  def owned_props
-    @content[:owned_props]
-  end
-
-  def assoc_props
-    @content[:assoc_props]
-  end
-
-  def inherited_props
-    @content[:inherited_props]
-  end
-
-  def inherited_assoc_props
-    @content[:inherited_assoc_props]
-  end
-end

data/lib/metanorma/plugin/lutaml/liquid_drops/klass_table_drop.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-class KlassTableDrop < Liquid::Drop
-  def initialize(klass) # rubocop:disable Lint/MissingSuper
-    @klass = klass
-  end
-
-  def id
-    @klass[:general_id]
-  end
-
-  def name
-    @klass[:name]
-  end
-
-  def stereotype
-    @klass[:stereotype]
-  end
-
-  def definition
-    @klass[:definition]
-  end
-
-  def type
-    @klass[:type]
-  end
-
-  def upper_klass
-    @klass[:general_upper_klass]
-  end
-
-  def general
-    KlassTableGeneralDrop.new(@klass[:general]) if @klass[:general]
-  end
-
-  def has_general?
-    !!@klass[:general]
-  end
-
-  def attributes
-    @klass[:general_attributes].map do |attr|
-      KlassTableAttributeDrop.new(attr)
-    end
-  end
-end

data/lib/metanorma/plugin/lutaml/liquid_drops/klass_table_general_drop.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-class KlassTableGeneralDrop < Liquid::Drop
-  def initialize(gen) # rubocop:disable Lint/MissingSuper
-    @gen = gen
-  end
-
-  def id
-    @gen[:general_id]
-  end
-
-  def name
-    @gen[:general_name]
-  end
-
-  def upper_klass
-    @gen[:general_upper_klass]
-  end
-
-  def general
-    KlassTableGeneralDrop.new(@gen[:general]) if @gen[:general]
-  end
-
-  def has_general?
-    !!@gen[:general]
-  end
-
-  def attributes
-    @gen[:general_attributes].map do |attr|
-      KlassTableAttributeDrop.new(attr)
-    end
-  end
-end

data/lib/metanorma/plugin/lutaml/liquid_templates/_klass_assoc_row.liquid

@@ -1,11 +0,0 @@
-{%- for attr in attributes -%}
-  {%- if attr.has_association? != false -%}
-    {%- capture name_col -%}
-      {{ attr.name_ns }}:{{ attr.name }}
-      ({{ attr.gen_name }})
-    {%- endcapture -%}
-    | {{ name_col | newline_to_br }}
-    | {{ attr.type_ns }}:{{ attr.type }} [{{ attr.cardinality }}] 
-    | {{ attr.definition }}
-  {%- endif -%}
-{%- endfor -%}

data/lib/metanorma/plugin/lutaml/liquid_templates/_klass_row.liquid

@@ -1,11 +0,0 @@
-{%- for attr in attributes -%}
-  {%- if attr.has_association? == false -%}
-    {%- capture name_col -%}
-      {{ attr.name_ns }}:{{ attr.name }}
-      ({{ attr.gen_name }})
-    {%- endcapture -%}
-    | {{ name_col | newline_to_br }}
-    | {{ attr.type }} [{{ attr.cardinality }}] 
-    | {{ attr.definition }}
-  {%- endif -%}
-{%- endfor -%}