metanorma-plugin-lutaml 0.7.10 → 0.7.11

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

@@ -4,11 +4,11 @@ require "liquid"
 require "asciidoctor"
 require "asciidoctor/reader"
 require "lutaml"
-# require "lutaml/uml"
 require "xmi"
 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
@@ -17,292 +17,17 @@ module Metanorma
       #  from liquid drop object
       class LutamlEaXmiPreprocessor <
           ::Asciidoctor::Extensions::Preprocessor
+        include LutamlEaXmiBase
+
         MACRO_REGEXP =
           /\[lutaml_ea_xmi,([^,]+),?(.+)?\]/.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_ea_xmi`
-        #  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::XMI::Parsers::XML.serialize_xmi_to_liquid(
-            File.new(
-              full_path, encoding: "UTF-8"
-            ),
-          )
-
-          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, options)
-          # 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)
-          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,
+        def parse_result_document(full_path)
+          ::Lutaml::XMI::Parsers::XML.serialize_xmi_to_liquid(
+            File.new(full_path, encoding: "UTF-8"),
           )
-          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
         end
       end
     end

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

@@ -1,17 +1,13 @@
 # frozen_string_literal: true
 
-require_relative "liquid_drops/klass_table_drop"
-require_relative "liquid_drops/klass_table_attribute_drop"
-require_relative "liquid_drops/klass_table_general_drop"
-require_relative "liquid_drops/klass_table_content_drop"
-
 module Metanorma
   module Plugin
     module Lutaml
       class LutamlKlassTableBlockMacro < ::Asciidoctor::Extensions::BlockMacroProcessor
-        DEFAULT_TEMPLATE_PATH = File.join(
+        DEFAULT_TEMPLATE = File.join(
           Gem::Specification.find_by_name("metanorma-plugin-lutaml").gem_dir,
-          "lib", "metanorma", "plugin", "lutaml", "liquid_templates"
+          "lib", "metanorma", "plugin", "lutaml", "liquid_templates",
+          "_klass_table.liquid"
         )
 
         use_dsl
@@ -20,154 +16,46 @@ module Metanorma
         def process(parent, target, attrs)
           xmi_path = Utils.relative_file_path(parent.document, target)
 
-          if attrs["tmpl_folder"]
-            attrs["tmpl_folder"] = Utils.relative_file_path(
-              parent.document, attrs["tmpl_folder"]
+          if attrs["template"]
+            attrs["template"] = Utils.relative_file_path(
+              parent.document, attrs["template"]
             )
           end
 
-          gen = ::Lutaml::XMI::Parsers::XML.serialize_generalization_by_name(
+          klass = ::Lutaml::XMI::Parsers::XML.serialize_generalization_by_name(
             xmi_path, attrs["name"]
           )
 
-          render(gen, parent, attrs)
+          render(klass, parent, attrs)
         end
 
         private
 
-        def render(gen, parent, attrs) # rubocop:disable Metrics/MethodLength
-          content = {}
-
-          content[:owned_props] = render_owned_props(
-            gen, parent, attrs
-          )
-          content[:assoc_props] = render_assoc_props(
-            gen, parent, attrs
-          )
-          content[:inherited_props] = render_inherited_props(
-            gen, parent, attrs
-          )
-          content[:inherited_assoc_props] = render_inherited_assoc_props(
-            gen, parent, attrs
-          )
-
-          rendered_table = render_table(gen, parent, attrs, content)
+        def render(klass, parent, attrs)
+          rendered_table = render_table(klass, parent, attrs)
 
           block = create_open_block(parent, "", attrs)
           parse_content(block, rendered_table, attrs)
         end
 
-        def render_table(gen, parent, attrs, content)
-          table_tmpl = get_template(
-            parent.document, attrs, :table
-          )
-
-          table_tmpl.assigns["root"] = KlassTableDrop.new(gen)
-          table_tmpl.assigns["content"] =
-            KlassTableContentDrop.new(content)
-
+        def render_table(klass, parent, attrs)
+          table_tmpl = get_template(parent.document, attrs)
+          table_tmpl.assigns["klass"] = klass
           table_tmpl.render
         end
 
-        def render_general_rows(general_item, parent, attrs)
-          row_tmpl = get_template(
-            parent.document, attrs, :row
-          )
-          render_rows(general_item, row_tmpl)
-        end
-
-        def render_assoc_rows(general_item, parent, attrs)
-          row_tmpl = get_template(
-            parent.document, attrs, :assoc_row
-          )
-          render_rows(general_item, row_tmpl)
-        end
-
-        def render_rows(general_item, row_tmpl)
-          gen_attrs = general_item[:general_attributes]
-          upper_klass = general_item[:general_upper_klass]
-          gen_name = general_item[:general_name]
-          attributes = prepare_row_drops(gen_attrs, upper_klass, gen_name)
-          row_tmpl.assigns["attributes"] = attributes
-          row_tmpl.render
-        end
-
-        def prepare_row_drops(gen_attrs, upper_klass, gen_name) # rubocop:disable Metrics/MethodLength
-          gen_attrs.map do |attr|
-            attr[:gen_name] = gen_name
-            attr[:upper_klass] = upper_klass
-            attr[:name_ns] = case attr[:type_ns]
-                             when "core", "gml"
-                               upper_klass
-                             else
-                               attr[:type_ns]
-                             end
-
-            attr[:name_ns] = upper_klass if attr[:name_ns].nil?
-
-            KlassTableAttributeDrop.new(attr)
+        def get_template(document, attrs)
+          template = DEFAULT_TEMPLATE
+          if attrs["template"]
+            template = attrs["template"]
           end
-        end
-
-        def render_owned_props(gen, parent, attrs)
-          render_general_rows(gen, parent, attrs)
-        end
-
-        def render_assoc_props(gen, parent, attrs)
-          render_assoc_rows(gen, parent, attrs)
-        end
-
-        def render_inherited_props(gen, parent, attrs)
-          render_inherited_rows(gen, parent, attrs, assoc: false)
-        end
-
-        def render_inherited_assoc_props(gen, parent, attrs)
-          render_inherited_rows(gen, parent, attrs, assoc: true)
-        end
-
-        def render_inherited_rows(gen, parent, attrs, assoc: false) # rubocop:disable Metrics/MethodLength
-          rendered_rows = ""
-          general_item = gen[:general]
-
-          while general_item && !general_item.empty?
-            rendered_rows += if assoc
-                               render_assoc_rows(general_item, parent, attrs)
-                             else
-                               render_general_rows(general_item, parent, attrs)
-                             end
-            general_item = general_item[:general]
-          end
-
-          rendered_rows
-        end
-
-        def get_template(document, attrs, tmpl_type)
-          tmpl_folder = DEFAULT_TEMPLATE_PATH
-          if attrs["tmpl_folder"]
-            tmpl_folder = attrs["tmpl_folder"]
-          end
-          template_path = get_default_template_path(tmpl_type, tmpl_folder,
-                                                    attrs)
 
           rel_tmpl_path = Utils.relative_file_path(
-            document, template_path
+            document, template
           )
 
           ::Liquid::Template.parse(File.read(rel_tmpl_path))
         end
-
-        def get_default_template_path(tmpl_type, tmpl_folder, attrs)
-          liquid_template = case tmpl_type
-                            when :row
-                              attrs["row_tmpl_name"] || "_klass_row"
-                            when :assoc_row
-                              attrs["assoc_row_tmpl_name"] || "_klass_assoc_row"
-                            else
-                              attrs["table_tmpl_name"] || "_klass_table"
-                            end
-
-          File.join(tmpl_folder, "#{liquid_template}.liquid")
-        end
       end
     end
   end

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

@@ -167,18 +167,21 @@ module Metanorma
           options
         end
 
-        def decorate_schema_object(schema:, document:, indexes:, index_names:, selected:, options:)
+        def decorate_schema_object(schema:, document:, indexes:, index_names:, # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/ParameterLists
+selected:, options:)
           # Mark a schema as "selected" with `.selected`
           schema["selected"] = true if selected
 
           # Provide pretty-formatted code under `.formatted`
-          index_found_key, index_found_value = indexes.detect do |k,v|
-            found = v[:wrapper].original_document.schemas.detect do |s|
+          _index_found_key, index_found_value = indexes.detect do |k, v|
+            _found = get_original_document(v[:wrapper]).schemas.detect do |s|
               s.id == schema["id"]
             end
           end
 
-          schema["formatted"] = index_found_value[:wrapper].original_document.schemas.detect do |s|
+          schema["formatted"] = get_original_document(
+            index_found_value[:wrapper],
+          ).schemas.detect do |s|
             s.id == schema["id"]
           end.to_s(no_remarks: true)
 
@@ -193,8 +196,15 @@ module Metanorma
           ) || {}
         end
 
-        def render_template(document:, lines:, context_name:, index_names:, options:, indexes:)
+        def get_original_document(wrapper)
+          doc = wrapper
+          return doc if doc.instance_of?(::Lutaml::XMI::RootDrop)
 
+          doc.original_document
+        end
+
+        def render_template(document:, lines:, context_name:, index_names:, # rubocop:disable Metrics/ParameterLists,Metrics/AbcSize,Metrics/MethodLength
+options:, indexes:)
           config_yaml_path = options.delete("config_yaml")
           config = read_config_yaml_file(document, config_yaml_path)
           selected_schemas = config["selected_schemas"]
@@ -204,21 +214,19 @@ module Metanorma
             document: document,
             indexes: indexes,
           ).map do |items|
-
             serialized_hash = items[:serialized_hash]
 
-            if serialized_hash["schemas"]
-              serialized_hash["schemas"].map! do |schema|
-
-                decorate_schema_object(
-                  schema: schema,
-                  document: document,
-                  index_names: index_names,
-                  indexes: indexes,
-                  selected: selected_schemas && selected_schemas.include?(schema["id"]),
-                  options: options
-                )
-              end
+            serialized_hash["schemas"]&.map! do |schema|
+              decorate_schema_object(
+                schema: schema,
+                document: document,
+                index_names: index_names,
+                indexes: indexes,
+                selected: selected_schemas && selected_schemas.include?(
+                  schema["id"],
+                ),
+                options: options,
+              )
             end
 
             render_block(