metanorma-plugin-lutaml 0.1.0 → 0.2.4.alpha

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e854f55d18dbd63e113f74e940689320384a8840912ef16f7a6880e13672ee6
-  data.tar.gz: ebf477f3262b209fc4edad4b1908b911d7737d343c2eb42383207de0aeb30b2d
+  metadata.gz: c060a247f01300f4fe46b58671a07a8f0e3a80f53e64974ccd07208e181e0eaa
+  data.tar.gz: dcf58ee6f298d24ad2493bd65c62a549a2673717ce8a9404695caad20d32e069
 SHA512:
-  metadata.gz: e530b0648b11116825ac6f1435f5c8d533102bbd212b6e4ab4d4c81d3378d67cb2c39ce32dffe5585d8801b34e2b8a647809fd2eafbdd879e27a01b975f3888e
-  data.tar.gz: 5a216d14209e1183b19c1301c7273639f379ab1d7e025a7ded83f135a46a5834568bb154335d8bd7cfc33c967825ae5d7b38c96289d0047c8c74cee3b9b2f0ca
+  metadata.gz: 5061cc833de5a8d4742095e5491f66ab608bdac3042ecc601cdc26e89f5ff258aa34650b3b19e3eb3b38b50be01b3f866e18f15adda02000278e6a5864cf1b34
+  data.tar.gz: 3be917c68c0fd6b0157f6578e40f61da433b262629950f76d09b2b2cf9e4cc5f7955d9066a0930f337ec7beb9426790d650bfb632cf9abf570f3431360855ca6

data/.github/workflows/rake.yml

@@ -0,0 +1,65 @@
+name: rake
+
+on:
+  push:
+    branches: [ main ]
+    tags: [ v* ]
+  pull_request:
+
+jobs:
+  rake:
+    name: Test on Ruby ${{ matrix.ruby }} ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    continue-on-error: ${{ matrix.experimental }}
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [ '2.6', '2.5', '2.4' ]
+        os: [ ubuntu-latest, windows-latest, macos-latest ]
+        experimental: [ false ]
+        include:
+          - ruby: '2.7'
+            os: 'ubuntu-latest'
+            experimental: true
+          - ruby: '2.7'
+            os: 'windows-latest'
+            experimental: true
+          - ruby: '2.7'
+            os: 'macos-latest'
+            experimental: true
+    steps:
+      - uses: actions/checkout@master
+
+      - name: Use Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+
+      - name: Update gems
+        run: bundle install --jobs 4 --retry 3
+
+      - name: Install Grpahviz Ubuntu
+        if: matrix.os == 'ubuntu-latest'
+        run: sudo apt-get install graphviz
+
+      - name: Install Grpahviz macOS
+        if: matrix.os == 'macos-latest'
+        run: brew install graphviz
+
+      - name: Install Grpahviz Windows
+        if: matrix.os == 'windows-latest'
+        uses: nick-invision/retry@v1
+        with:
+          polling_interval_seconds: 5
+          timeout_minutes: 5
+          max_attempts: 3
+          command: choco install --no-progress graphviz
+
+      - name: Check dot command
+        if: matrix.os == 'windows-latest'
+        run: |
+          dot -?
+
+      - name: Run specs
+        run: bundle exec rake

data/.gitignore

@@ -1,2 +1,4 @@
 Gemfile.lock
 .rspec_status
+spec/assets/lutaml
+test.err

data/README.adoc

@@ -1,5 +1,7 @@
 = metanorma-plugin-lutaml
 
+image:https://github.com/metanorma/metanorma-plugin-lutaml/workflows/rake/badge.svg["Build Status", link="https://github.com/metanorma/metanorma-plugin-lutaml/actions?workflow=rake"]
+
 == Functionality
 
 Metanorma plugin that allows you to access lutaml objects from a Metanorma document
@@ -11,7 +13,7 @@ Metanorma plugin that allows you to access lutaml objects from a Metanorma docum
 $ gem install metanorma-plugin-lutaml
 ----
 
-=== Usage
+=== Usage, `lutaml` macro
 
 Given `example.exp` file with the content:
 
@@ -58,6 +60,14 @@ And the `lutaml` macro block:
 ----
 -----
 
+Where:
+
+* content within the block is called the "`template`";
+
+* `{example.exp}` is the location of the exp schema file that contains data to be loaded. Location of the file is computed relative to the source directory that `[lutaml]` is used (e.g., if `[lutaml,example.exp,my_context]` is invoked in an `.adoc` file located at `/foo/bar/doc.adoc`, the data file is expected to be found at `/foo/bar/example.exp`);
+
+* `{my_context}` is the name where the EXPRESS Repository read from the .exp file can be accessed with. Context object is a serialized  Expressir::Model::Repository object with all variable names available. See https://github.com/lutaml/expressir[Expressir] docs for reference. `{my_context}` has `schemas` method to access Expressir https://github.com/lutaml/expressir/blob/master/lib/expressir/model/schema.rb[schemas]
+
 Will produce this output:
 
 [source,adoc]
@@ -71,6 +81,82 @@ Will produce this output:
 === my_type5
 -----
 
+This macro also supports `.lutaml` files.
+
+=== Usage, `lutaml_uml_attributes_table` macro
+
+This macro allows to quickly render datamodel attributes/values tables. Given `example.lutaml` file with the content:
+
+[source,java]
+----
+diagram MyView {
+  title "my diagram"
+
+  enum AddressClassProfile {
+    imlicistAttributeProfile: CharacterString [0..1] {
+      definition
+        this is multiline with `ascidoc`
+      end definition
+    }
+  }
+
+  class AttributeProfile {
+    +addressClassProfile: CharacterString [0..1]
+    imlicistAttributeProfile: CharacterString [0..1] {
+      definition this is attribute definition
+    }
+  }
+}
+----
+
+And the `lutaml_uml_attributes_table` macro:
+
+[source,adoc]
+-----
+[lutaml_uml_attributes_table, example.lutaml, AttributeProfile]
+-----
+
+Will produce this output:
+
+[source,adoc]
+-----
+=== AttributeProfile
+
+
+.AttributeProfile attributes
+|===
+|Name |Definition |Mandatory/ Optional/ Conditional |Max Occur |Data Type
+
+|addressClassProfile |TODO: enum 's definition |M |1 | `CharacterString`
+
+|imlicistAttributeProfile |this is attribute definition with multiply lines |M |1 | `CharacterString`
+
+|===
+-----
+
+In case of "enumeration"(AddressClassProfile) entity:
+
+[source,adoc]
+-----
+[lutaml_uml_attributes_table, example.lutaml, AddressClassProfile]
+-----
+
+Will produce this output:
+
+[source,adoc]
+-----
+=== AddressClassProfile
+
+
+.AddressClassProfile values
+|===
+|Name |Definition
+
+|imlicistAttributeProfile |this is multiline with `ascidoc`
+
+|===
+-----
+
 == Documentation
 
 See https://www.metanorma.com.

data/lib/metanorma-plugin-lutaml.rb

@@ -1,5 +1,7 @@
 require "metanorma/plugin/lutaml/version"
 require "metanorma/plugin/lutaml/lutaml_preprocessor"
+require "metanorma/plugin/lutaml/lutaml_uml_attributes_table_preprocessor"
+require "metanorma/plugin/lutaml/lutaml_diagram_block"
 
 module Metanorma
   module Plugin

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

@@ -0,0 +1,73 @@
+module Metanorma
+  module Plugin
+    module Lutaml
+      class ExpressRemarksDecorator
+        RELATIVE_PREFIX_MACRO_REGEXP = /^(\* <<express.+?>>;|link|image|video|audio|include)(:+)?(?![^\/:]+:\/\/|[A-Z]:\/|\/)([^:\[]+)(\[.*\])?$/.freeze
+
+        attr_reader :remark, :options
+
+        def self.call(remark, options)
+          new(remark, options).call
+        end
+
+        def initialize(remark, options)
+          @remark = remark
+          @options = options
+        end
+
+        def call
+          result = remark
+          if options["leveloffset"]
+            result = process_remark_offsets(result, options["leveloffset"].to_i)
+          end
+          if options["relative_path_prefix"]
+            result = update_relative_paths(result,
+                                           options["relative_path_prefix"])
+          end
+          result
+        end
+
+        private
+
+        def update_relative_paths(string, path_prefix)
+          string
+            .split("\n")
+            .map do |line|
+              if line.match?(RELATIVE_PREFIX_MACRO_REGEXP)
+                prefix_relative_paths(line, path_prefix)
+              else
+                line
+              end
+            end
+            .join("\n")
+        end
+
+        def prefix_relative_paths(line, path_prefix)
+          line.gsub(RELATIVE_PREFIX_MACRO_REGEXP) do |_match|
+            prefixed_path = File.join(path_prefix, $3.strip)
+            "#{$1}#{$2}#{prefixed_path}#{$4}"
+          end
+        end
+
+        def process_remark_offsets(string, offset)
+          string
+            .split("\n")
+            .map do |line|
+              if line.match?(/^=/)
+                set_string_offsets(line, offset)
+              else
+                line
+              end
+            end
+            .join("\n")
+        end
+
+        def set_string_offsets(string, offset)
+          return "#{'=' * offset}#{string}" if offset.positive?
+
+          string.gsub(/^={#{offset * -1}}/, "")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "liquid"
+require "asciidoctor"
+require "asciidoctor/reader"
+require "lutaml"
+require "lutaml/uml"
+require "metanorma/plugin/lutaml/utils"
+
+module Metanorma
+  module Plugin
+    module Lutaml
+      class LutamlDiagramBlock < Asciidoctor::Extensions::BlockProcessor
+        use_dsl
+        named :lutaml_diagram
+        on_context :literal
+        parse_content_as :raw
+
+        def abort(parent, reader, attrs, msg)
+          warn(msg)
+          attrs["language"] = "lutaml"
+          create_listing_block(
+            parent,
+            reader.source,
+            attrs.reject { |k, _v| k == 1 }
+          )
+        end
+
+        def process(parent, reader, attrs)
+          uml_document = ::Lutaml::Uml::Parsers::Dsl.parse(lutaml_temp(reader))
+          filename = generate_file(parent, reader, uml_document)
+          through_attrs = generate_attrs(attrs)
+          through_attrs["target"] = filename
+          through_attrs["title"] = uml_document.caption
+          create_image_block(parent, through_attrs)
+        rescue StandardError => e
+          abort(parent, reader, attrs, e.message)
+        end
+
+        private
+
+        def lutaml_temp(reader)
+          temp_file = Tempfile.new(["lutaml", ".lutaml"])
+          temp_file.puts(reader.read)
+          temp_file.rewind
+          temp_file
+        end
+
+        # if no :imagesdir: leave image file in lutaml
+        def generate_file(parent, _reader, uml_document)
+          formatter = ::Lutaml::Uml::Formatter::Graphviz.new
+          formatter.type = :png
+
+          imagesdir = if parent.document.attr("imagesdir")
+                        File.join(parent.document.attr("imagesdir"), "lutaml")
+                      else
+                        "lutaml"
+                      end
+          result_path = Utils.relative_file_path(parent.document, imagesdir)
+          result_pathname = Pathname.new(result_path)
+          result_pathname.mkpath
+          File.writable?(result_pathname) || raise("Destination path #{result_path} not writable for Lutaml!")
+
+          outfile = Tempfile.new(["lutaml", ".png"])
+          outfile.binmode
+          outfile.puts(formatter.format(uml_document))
+
+          # Warning: metanorma/metanorma-standoc#187
+          # Windows Ruby 2.4 will crash if a Tempfile is "mv"ed.
+          # This is why we need to copy and then unlink.
+          filename = File.basename(outfile.path)
+          FileUtils.cp(outfile, result_pathname) && outfile.unlink
+
+          File.join(result_pathname, filename)
+        end
+
+        def generate_attrs(attrs)
+          %w(id align float title role width height alt)
+            .reduce({}) do |memo, key|
+              memo[key] = attrs[key] if attrs.has_key? key
+              memo
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -4,48 +4,53 @@ require "liquid"
 require "asciidoctor"
 require "asciidoctor/reader"
 require "lutaml"
+require "metanorma/plugin/lutaml/utils"
+require "metanorma/plugin/lutaml/utils"
+require "metanorma/plugin/lutaml/express_remarks_decorator"
 
 module Metanorma
   module Plugin
     module Lutaml
       # Class for processing Lutaml files
       class LutamlPreprocessor < Asciidoctor::Extensions::Preprocessor
+        REMARKS_ATTRIBUTE = "remarks".freeze
 
         def process(document, reader)
           input_lines = reader.readlines.to_enum
-          Asciidoctor::Reader.new(processed_lines(document, input_lines))
+          express_indexes = Utils.parse_document_express_indexes(
+            document,
+            input_lines
+          )
+          Asciidoctor::Reader
+            .new(processed_lines(document, input_lines, express_indexes))
         end
 
         protected
 
         def content_from_file(document, file_path)
           ::Lutaml::Parser
-            .parse(File.new(relative_file_path(document, file_path),
+            .parse(File.new(Utils.relative_file_path(document, file_path),
                             encoding: "UTF-8"))
         end
 
         private
 
-        def processed_lines(document, input_lines)
+        def processed_lines(document, input_lines, express_indexes)
           result = []
           loop do
-            result.push(*process_text_blocks(document, input_lines))
+            result
+              .push(*process_text_blocks(
+                document,
+                input_lines,
+                express_indexes
+              ))
           end
           result
         end
 
-        def relative_file_path(document, file_path)
-          docfile_directory = File.dirname(
-            document.attributes["docfile"] || "."
-          )
-          document
-            .path_resolver
-            .system_path(file_path, docfile_directory)
-        end
-
-        def process_text_blocks(document, input_lines)
+        def process_text_blocks(document, input_lines, express_indexes)
           line = input_lines.next
-          block_match = line.match(/^\[lutaml,(.+?),(.+?)\]/)
+          block_match = line.match(/^\[lutaml,([^,]+)?,?([^,]+)?,?([^,]+)?\]/)
           return [line] if block_match.nil?
 
           end_mark = input_lines.next
@@ -53,7 +58,8 @@ module Metanorma
                          collect_internal_block_lines(document,
                                                       input_lines,
                                                       end_mark),
-                         block_match)
+                         block_match,
+                         express_indexes)
         end
 
         def collect_internal_block_lines(_document, input_lines, end_mark)
@@ -64,49 +70,74 @@ module Metanorma
           current_block
         end
 
-        def parse_template(document, current_block, block_match)
-          context_items = content_from_file(document, block_match[1])
-          parse_context_block(document: document,
-                              context_lines: current_block,
-                              context_items: context_items,
-                              context_name: block_match[2].strip)
+        def contexts_items(block_match, document, express_indexes)
+          contexts_names = block_match[1].split(";").map(&:strip)
+          contexts_names.each_with_object([]) do |path, res|
+            if express_indexes[path]
+              res.push(*express_indexes[path])
+            else
+              res.push(content_from_file(document, path).to_liquid)
+            end
+          end
+        end
+
+        def parse_template(document, current_block, block_match, express_indexes)
+          options = parse_options(block_match[3])
+                      .merge("relative_path_prefix" => File.dirname(block_match[1]))
+          contexts_items(block_match, document, express_indexes)
+            .map do |context_items|
+              parse_context_block(document: document,
+                                  context_lines: current_block,
+                                  context_items: decorate_context_items(context_items, options),
+                                  context_name: block_match[2].strip)
+            end.flatten
         rescue StandardError => e
-          document.logger
-            .warn("Failed to parse lutaml \
-              block: #{e.message}")
+          document.logger.warn("Failed to parse lutaml block: #{e.message}")
           []
         end
 
+        def parse_options(options_string)
+          options_string
+            .to_s
+            .scan(/(.+?)=(\s?[^\s]+)/)
+            .map { |elem| elem.map(&:strip) }
+            .to_h
+        end
+
+        def decorate_context_items(context_items, options)
+          return context_items if !context_items.is_a?(Hash)
+
+          context_items
+            .map do |(key, val)|
+              if val.is_a?(Hash)
+                [key, decorate_context_items(val, options)]
+              elsif key == REMARKS_ATTRIBUTE
+                [key,
+                 val&.map do |remark|
+                   Metanorma::Plugin::Lutaml::ExpressRemarksDecorator
+                     .call(remark, options)
+                 end]
+              elsif val.is_a?(Array)
+                [key, val.map { |n| decorate_context_items(n, options) }]
+              else
+                [key, val]
+              end
+            end
+            .to_h
+        end
+
         def parse_context_block(context_lines:,
                                 context_items:,
                                 context_name:,
                                 document:)
-          render_result, errors = render_liquid_string(
+          render_result, errors = Utils.render_liquid_string(
             template_string: context_lines.join("\n"),
             context_items: context_items,
             context_name: context_name
           )
-          notify_render_errors(document, errors)
+          Utils.notify_render_errors(document, errors)
           render_result.split("\n")
         end
-
-        def render_liquid_string(template_string:, context_items:,
-                                 context_name:)
-          liquid_template = Liquid::Template.parse(template_string)
-          rendered_string = liquid_template
-            .render(context_name => context_items,
-                    strict_variables: true,
-                    error_mode: :warn)
-          [rendered_string, liquid_template.errors]
-        end
-
-        def notify_render_errors(document, errors)
-          errors.each do |error_obj|
-            document
-              .logger
-              .warn("Liquid render error: #{error_obj.message}")
-          end
-        end
       end
     end
   end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "liquid"
+require "asciidoctor"
+require "asciidoctor/reader"
+require "lutaml"
+require "lutaml/uml"
+require "metanorma/plugin/lutaml/utils"
+
+module Metanorma
+  module Plugin
+    module Lutaml
+      #  Macro for quick rendering of datamodel attributes/values table
+      #  @example [lutaml_uml_attributes_table,path/to/lutaml,EntityName]
+      class LutamlUmlAttributesTablePreprocessor < Asciidoctor::Extensions::Preprocessor
+        MARCO_REGEXP =
+          /\[lutaml_uml_attributes_table,([^,]+),?(.+)?,([^,]+),?(.+)?\]/
+        # search document for block `datamodel_attributes_table`
+        #  read include derectives that goes after that in block and transform
+        #  into yaml2text blocks
+        def process(document, reader)
+          input_lines = reader.readlines.to_enum
+          Asciidoctor::Reader.new(processed_lines(document, input_lines))
+        end
+
+        private
+
+        def lutaml_document_from_file(document, file_path)
+          ::Lutaml::Parser
+            .parse(File.new(Utils.relative_file_path(document, file_path),
+                            encoding: "UTF-8"))
+        end
+
+        def processed_lines(document, input_lines)
+          input_lines.each_with_object([]) do |line, result|
+            if match = line.match(MARCO_REGEXP)
+              lutaml_path = match[1]
+              entity_name = match[3]
+              result.push(*parse_marco(lutaml_path, entity_name, document))
+            else
+              result.push(line)
+            end
+          end
+        end
+
+        def parse_marco(lutaml_path, entity_name, document)
+          lutaml_document = lutaml_document_from_file(document, lutaml_path)
+            .serialized_document
+          entities = [lutaml_document["classes"], lutaml_document["enums"]]
+            .compact
+            .flatten
+          entity_definition = entities.detect do |klass|
+            klass["name"] == entity_name.strip
+          end
+          model_representation(entity_definition, document)
+        end
+
+        def model_representation(entity_definition, document)
+          render_result, errors = Utils.render_liquid_string(
+            template_string: table_template,
+            context_items: entity_definition,
+            context_name: "definition"
+          )
+          Utils.notify_render_errors(document, errors)
+          render_result.split("\n")
+        end
+
+        # rubocop:disable Layout/IndentHeredoc
+        def table_template
+          <<~TEMPLATE
+          === {{ definition.name }}
+          {{ definition.definition }}
+
+          {% if definition.attributes %}
+          {% if definition.keyword == 'enumeration' %}
+          .{{ definition.name }} values
+          |===
+          |Name |Definition
+
+          {% for item in definition.attributes %}
+          |{{ item.name }} |{{ item.definition }}
+          {% endfor %}
+          |===
+          {% else %}
+          .{{ definition.name }} attributes
+          |===
+          |Name |Definition |Mandatory/ Optional/ Conditional |Max Occur |Data Type
+
+          {% for item in definition.attributes %}
+          |{{ item.name }} |{% if item.definition %}{{ item.definition }}{% else %}TODO: enum {{ key }}'s definition{% endif %} |{% if item.cardinality.min == "0" %}O{% else %}M{% endif %} |{% if item.cardinality.max == "*" %}N{% else %}1{% endif %} |{% if item.origin %}<<{{ item.origin }}>>{% endif %} `{{ item.type }}`
+          {% endfor %}
+          |===
+          {% endif %}
+          {% endif %}
+
+          TEMPLATE
+        end
+        # rubocop:enable Layout/IndentHeredoc
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module Metanorma
+  module Plugin
+    module Lutaml
+      # Helpers for lutaml macroses
+      module Utils
+        module_function
+
+        def relative_file_path(document, file_path)
+          docfile_directory = File.dirname(
+            document.attributes["docfile"] || "."
+          )
+          document
+            .path_resolver
+            .system_path(file_path, docfile_directory)
+        end
+
+        def render_liquid_string(template_string:, context_items:,
+                                 context_name:)
+          liquid_template = Liquid::Template.parse(template_string)
+          rendered_string = liquid_template
+            .render(context_name => context_items,
+                    strict_variables: true,
+                    error_mode: :warn)
+          [rendered_string, liquid_template.errors]
+        end
+
+        def notify_render_errors(document, errors)
+          errors.each do |error_obj|
+            document
+              .logger
+              .warn("Liquid render error: #{error_obj.message}")
+          end
+        end
+
+        def process_express_index(folder, name, idxs, document)
+          idxs[name] = []
+          Dir["#{Utils.relative_file_path(document, folder)}/*"].each do |path|
+            next if [".", ".."].include?(path)
+
+            begin
+              idxs[name]
+                .push(::Lutaml::Parser.parse(File.new(path, encoding: "UTF-8")).to_liquid)
+            rescue StandardError => e
+              document.logger.warn("Failed to load #{path}: #{e.message}")
+            end
+          end
+        end
+
+        def parse_document_express_indexes(document, input_lines)
+          express_indexes = {}
+          loop do
+            line = input_lines.next
+            break if line.length.zero?
+
+            _, name, folder = line.match(/^:lutaml-express-index:(.+?);(.+?)$/)&.to_a
+            if folder && name
+              process_express_index(
+                folder.strip.gsub(";", ""),
+                name.strip,
+                express_indexes,
+                document
+              )
+            end
+          end
+          express_indexes
+        rescue StopIteration
+          express_indexes
+        ensure
+          input_lines.rewind
+        end
+      end
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
 module Metanorma
   module Plugin
     module Lutaml
-      VERSION = "0.1.0".freeze
+      VERSION = "0.2.4.alpha".freeze
     end
   end
 end

data/metanorma-plugin-lutaml.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "liquid"
-  spec.add_dependency "lutaml", "~> 0.3.0"
+  spec.add_dependency "lutaml", "0.4.1.pre.alpha"
   spec.add_dependency "lutaml-uml", "~> 0.2.0"
   spec.add_dependency "metanorma"
   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.1.0
+  version: 0.2.4.alpha
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-10-28 00:00:00.000000000 Z
+date: 2021-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: liquid
@@ -28,16 +28,16 @@ dependencies:
   name: lutaml
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.4.1.pre.alpha
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.4.1.pre.alpha
 - !ruby/object:Gem::Dependency
   name: lutaml-uml
   requirement: !ruby/object:Gem::Requirement
@@ -241,6 +241,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/rake.yml"
 - ".gitignore"
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -250,9 +251,14 @@ files:
 - bin/console
 - bin/setup
 - lib/metanorma-plugin-lutaml.rb
+- lib/metanorma/plugin/lutaml/express_remarks_decorator.rb
+- lib/metanorma/plugin/lutaml/lutaml_diagram_block.rb
 - lib/metanorma/plugin/lutaml/lutaml_preprocessor.rb
+- lib/metanorma/plugin/lutaml/lutaml_uml_attributes_table_preprocessor.rb
+- lib/metanorma/plugin/lutaml/utils.rb
 - lib/metanorma/plugin/lutaml/version.rb
 - metanorma-plugin-lutaml.gemspec
+- pkg/metanorma-plugin-lutaml-0.2.0.gem
 homepage: https://github.com/metanorma/metanorma-plugin-lutaml
 licenses:
 - BSD-2-Clause
@@ -268,9 +274,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.0.3
 signing_key: