lutaml 0.9.39 → 0.9.41

data/lib/lutaml/express/version.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Express
-    VERSION = "0.2.1"
-  end
-end

data/lib/lutaml/sysml/README.md

@@ -1,40 +0,0 @@
-# Lutaml::Sysml
-
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/lutaml/sysml`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'lutaml-sysml'
-```
-
-And then execute:
-
-    $ bundle install
-
-Or install it yourself as:
-
-    $ gem install lutaml-sysml
-
-## Usage
-
-TODO: Write usage instructions here
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/lutaml-sysml. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/lutaml-sysml/blob/master/CODE_OF_CONDUCT.md).
-
-
-## Code of Conduct
-
-Everyone interacting in the Lutaml::Sysml project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/lutaml-sysml/blob/master/CODE_OF_CONDUCT.md).

data/lib/lutaml/sysml/version.rb

@@ -1,5 +0,0 @@
-module Lutaml
-  module Sysml
-    VERSION = "0.1.0".freeze
-  end
-end

data/lib/lutaml/uml/README.adoc

@@ -1,44 +0,0 @@
-# Lutaml::Uml
-
-image:https://badge.fury.io/rb/lutaml-uml.svg["Gem Version", link="https://badge.fury.io/rb/lutaml-uml"]
-
-image:https://github.com/lutaml/lutaml-uml/actions/workflows/macos.yml/badge.svg["macos", link="https://github.com/lutaml/lutaml-uml/actions/workflows/macos.yml"]
-image:https://github.com/lutaml/lutaml-uml/actions/workflows/ubuntu.yml/badge.svg["ubuntu", link="https://github.com/lutaml/lutaml-uml/actions/workflows/ubuntu.yml"]
-image:https://github.com/lutaml/lutaml-uml/actions/workflows/windows.yml/badge.svg["windows", link="https://github.com/lutaml/lutaml-uml/actions/workflows/windows.yml"]
-
-Lutaml is a language for specifying UML class diagrams and a tool for converting it into various different formats.
-
-## Install
-
-### Bundler: `gem "lutaml-uml"`
-
-### RubyGems: `gem install lutaml-uml`
-
-## Language
-
-See link:LUTAML.adoc[LUTAML.adoc]
-
-## Usage
-
-Converter executables are available:
-
-* PlantUML WSD to LutaML UML: `lutaml-wsd2uml`
-* LutaML YAML to LutaML UML: `lutaml-yaml2uml`
-
-EXAMPLE: `lutaml-wsd2uml mn/metanorma-model-standoc/models/StandardDoc_Blocks_New.wsd`
-
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/lutaml-uml. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/lutaml-uml/blob/master/CODE_OF_CONDUCT.md).
-
-
-## Code of Conduct
-
-Everyone interacting in the Lutaml::Uml project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/lutaml-uml/blob/master/CODE_OF_CONDUCT.md).

data/lib/lutaml/uml/constructor_end.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-##
-## Behaviour metamodel
-##
-module Lutaml
-  module Uml
-    class ConnectorEnd < TopElement
-      attr_accessor :role, :part_with_port, :connector
-
-      def initialize # rubocop:disable Lint/MissingSuper
-        @role = nil
-      end
-    end
-  end
-end

data/lib/lutaml/uml/formatter/base.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/uml/formatter"
-require "lutaml/uml/has_attributes"
-
-module Lutaml
-  module Uml
-    module Formatter
-      class Base
-        class << self
-          def inherited(subclass) # rubocop:disable Lint/MissingSuper
-            Formatter.all << subclass
-          end
-
-          def format(node, attributes = {})
-            new(attributes).format(node)
-          end
-
-          def name
-            to_s.split("::").last.downcase.to_sym
-          end
-        end
-
-        include HasAttributes
-
-        # rubocop:disable Rails/ActiveRecordAliases
-        def initialize(attributes = {})
-          update_attributes(attributes)
-        end
-        # rubocop:enable Rails/ActiveRecordAliases
-
-        def name
-          self.class.name
-        end
-
-        attr_reader :type
-
-        def type=(value)
-          @type = value.to_s.strip.downcase.to_sym
-        end
-
-        def format(node) # rubocop:disable Metrics/CyclomaticComplexity
-          case node
-          when Node::Field  then format_field(node)
-          when Node::Method then format_method(node)
-          when Node::Relationship then format_relationship(node)
-          when Node::ClassRelationship then format_class_relationship(node)
-          when Node::ClassNode then format_class(node)
-          when Lutaml::Uml::Document then format_document(node)
-          end
-        end
-
-        def format_field(_node);              raise NotImplementedError; end
-
-        def format_method(_node);             raise NotImplementedError; end
-
-        def format_relationship(_node);       raise NotImplementedError; end
-
-        def format_class_relationship(_node); raise NotImplementedError; end
-
-        def format_class(_node);              raise NotImplementedError; end
-
-        def format_document(_node);           raise NotImplementedError; end
-      end
-    end
-  end
-end

data/lib/lutaml/uml/formatter/graphviz.rb

@@ -1,332 +0,0 @@
-# frozen_string_literal: true
-
-require "open3"
-require "lutaml/uml/formatter/base"
-require "lutaml/layout/graph_viz_engine"
-
-module Lutaml
-  module Uml
-    module Formatter
-      class Graphviz < Base
-        class Attributes < Hash
-          def to_s
-            to_a
-              .reject { |(_k, val)| val.nil? }
-              .map { |(a, b)| "#{a}=#{b.inspect}" }
-              .join(" ")
-          end
-        end
-
-        ACCESS_SYMBOLS = {
-          "public" => "+",
-          "protected" => "#",
-          "private" => "-",
-        }.freeze
-        DEFAULT_CLASS_FONT = "Helvetica"
-
-        VALID_TYPES = %i[
-          dot
-          xdot
-          ps
-          pdf
-          svg
-          svgz
-          fig
-          png
-          gif
-          jpg
-          jpeg
-          json
-          imap
-          cmapx
-        ].freeze
-
-        def initialize(attributes = {}) # rubocop:disable Metrics/MethodLength
-          super
-
-          @graph = Attributes.new
-          # Associations lines style, `true` gives curved lines
-          # https://graphviz.org/doc/info/attrs.html#d:splines
-          @graph["splines"] = "ortho"
-          # Padding between outside of picture and nodes
-          @graph["pad"] = 0.5
-          # Padding between levels
-          @graph["ranksep"] = "1.2.equally"
-          # Padding between nodes
-          @graph["nodesep"] = "1.2.equally"
-          # TODO: set rankdir
-          # @graph['rankdir'] = 'BT'
-
-          @edge = Attributes.new
-          @edge["color"] = "gray50"
-
-          @node = Attributes.new
-          @node["shape"] = "box"
-
-          @type = :dot
-        end
-
-        attr_reader :graph, :edge, :node
-
-        def type=(value)
-          super
-
-          @type = :dot unless VALID_TYPES.include?(@type)
-        end
-
-        def format(node)
-          dot = super.lines.map(&:rstrip).join("\n")
-
-          generate_from_dot(dot)
-        end
-
-        def escape_html_chars(text)
-          text
-            .gsub("<", "&#60;")
-            .gsub(">", "&#62;")
-            .gsub("[", "&#91;")
-            .gsub("]", "&#93;")
-        end
-
-        def format_field(node) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          symbol = ACCESS_SYMBOLS[node.visibility]
-          result = "#{symbol}#{node.name}"
-          if node.type
-            keyword = node.keyword ? "«#{node.keyword}»" : ""
-            result += " : #{keyword}#{node.type}"
-          end
-          if node.cardinality
-            result += "[#{node.cardinality[:min]}..#{node.cardinality[:max]}]"
-          end
-          result = escape_html_chars(result)
-          result = "<U>#{result}</U>" if node.static
-
-          result
-        end
-
-        def format_method(node) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
-          symbol = ACCESS_SYMBOLS[node.access]
-          result = "#{symbol} #{node.name}"
-          if node.arguments
-            arguments = node.arguments.map do |argument|
-              "#{argument.name}#{" : #{argument.type}" if argument.type}"
-            end.join(", ")
-          end
-
-          result << "(#{arguments})"
-          result << " : #{node.type}" if node.type
-          result = "<U>#{result}</U>" if node.static
-          result = "<I>#{result}</I>" if node.abstract
-
-          result
-        end
-
-        def format_relationship(node)
-          graph_parent_name = generate_graph_name(node.owner_end)
-          graph_node_name = generate_graph_name(node.member_end)
-          attributes = generate_graph_relationship_attributes(node)
-          graph_attributes = " [#{attributes}]" unless attributes.empty?
-
-          %{#{graph_parent_name} -> #{graph_node_name}#{graph_attributes}}
-        end
-
-        def generate_graph_relationship_attributes(node) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          attributes = Attributes.new
-          if %w[dependency realizes].include?(node.member_end_type)
-            attributes["style"] = "dashed"
-          end
-          attributes["dir"] = if node.owner_end_type && node.member_end_type
-                                "both"
-                              elsif node.owner_end_type
-                                "back"
-                              else
-                                "direct"
-                              end
-          attributes["label"] = node.action if node.action
-          if node.owner_end_attribute_name
-            attributes["headlabel"] = format_label(
-              node.owner_end_attribute_name,
-              node.owner_end_cardinality,
-            )
-          end
-          if node.member_end_attribute_name
-            attributes["taillabel"] = format_label(
-              node.member_end_attribute_name,
-              node.member_end_cardinality,
-            )
-          end
-
-          attributes["arrowtail"] = case node.owner_end_type
-                                    when "composition"
-                                      "diamond"
-                                    when "aggregation"
-                                      "odiamond"
-                                    when "direct"
-                                      "vee"
-                                    else
-                                      "onormal"
-                                    end
-
-          attributes["arrowhead"] = case node.member_end_type
-                                    when "composition"
-                                      "diamond"
-                                    when "aggregation"
-                                      "odiamond"
-                                    when "direct"
-                                      "vee"
-                                    else
-                                      "onormal"
-                                    end
-          # swap labels and arrows if `dir` eq to `back`
-          if attributes["dir"] == "back"
-            attributes["arrowhead"], attributes["arrowtail"] =
-              [attributes["arrowtail"], attributes["arrowhead"]]
-            attributes["headlabel"], attributes["taillabel"] =
-              [attributes["taillabel"], attributes["headlabel"]]
-          end
-          attributes
-        end
-
-        def format_label(name, cardinality = {})
-          res = "+#{name}"
-          if cardinality.nil? ||
-              (cardinality[:min].nil? || cardinality[:max].nil?)
-            return res
-          end
-
-          "#{res} #{cardinality['min']}..#{cardinality['max']}"
-        end
-
-        def format_member_rows(members, hide_members) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
-          unless !hide_members && members&.length&.positive?
-            return <<~HEREDOC.chomp
-              <TABLE BORDER="0" CELLPADDING="0" CELLSPACING="0">
-                <TR><TD ALIGN="LEFT"></TD></TR>
-              </TABLE>
-            HEREDOC
-          end
-
-          field_rows = members.map do |field|
-            %{<TR><TD ALIGN="LEFT">#{format_field(field)}</TD></TR>}
-          end
-          field_table = <<~HEREDOC.chomp
-            <TABLE BORDER="0" CELLPADDING="0" CELLSPACING="0">
-              #{field_rows.map { |row| (' ' * 10) + row }.join("\n")}
-            </TABLE>
-          HEREDOC
-          field_table << "\n" << (" " * 6)
-          field_table
-        end
-
-        def format_class(node, hide_members) # rubocop:disable Metrics/AbcSize
-          name = ["<B>#{node.name}</B>"]
-          name.unshift("«#{node.keyword}»") if node.keyword
-          name_html = <<~HEREDOC
-            <TABLE BORDER="0" CELLPADDING="0" CELLSPACING="0">
-              #{name.map { |n| %(<TR><TD ALIGN="CENTER">#{n}</TD></TR>) }.join('\n')}
-            </TABLE>
-          HEREDOC
-
-          field_table = format_member_rows(node.attributes, hide_members)
-          method_table = format_member_rows(node.methods, hide_members)
-          table_body = [name_html, field_table, method_table].map do |type|
-            next if type.nil?
-
-            <<~TEXT
-              <TR>
-                <TD>#{type}</TD>
-              </TR>
-            TEXT
-          end
-
-          <<~HEREDOC.chomp
-            <TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0" CELLPADDING="10">
-              #{table_body.compact.join("\n")}
-            </TABLE>
-          HEREDOC
-        end
-
-        def format_document(node) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          @fontname = node.fontname || DEFAULT_CLASS_FONT
-          @node["fontname"] = "#{@fontname}-bold"
-
-          if node.fidelity
-            hide_members = node.fidelity["hideMembers"]
-            hide_other_classes = node.fidelity["hideOtherClasses"]
-          end
-          classes = (node.classes +
-                      node.enums +
-                      node.data_types +
-                      node.primitives).map do |class_node|
-            graph_node_name = generate_graph_name(class_node.name)
-
-            <<~HEREDOC
-              #{graph_node_name} [
-                shape="plain"
-                fontname="#{@fontname || DEFAULT_CLASS_FONT}"
-                label=<#{format_class(class_node, hide_members)}>]
-            HEREDOC
-          end.join("\n")
-          associations = node.classes.map(&:associations).compact.flatten +
-            node.associations
-          if node.groups
-            associations = sort_by_document_grouping(node.groups,
-                                                     associations)
-          end
-          classes_names = node.classes.map(&:name)
-          associations = associations.map do |assoc_node|
-            if hide_other_classes &&
-                !classes_names.include?(assoc_node.member_end)
-              next
-            end
-
-            format_relationship(assoc_node)
-          end.join("\n")
-
-          classes = classes.lines.map { |line| "  #{line}" }.join.chomp
-          associations = associations
-            .lines.map { |line| "  #{line}" }.join.chomp
-
-          <<~HEREDOC
-            digraph G {
-              graph [#{@graph}]
-              edge [#{@edge}]
-              node [#{@node}]
-
-            #{classes}
-
-            #{associations}
-            }
-          HEREDOC
-        end
-
-        protected
-
-        def sort_by_document_grouping(groups, associations) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          result = []
-          groups.each do |batch|
-            batch.each do |group_name|
-              associations
-                .select { |assc| assc.owner_end == group_name }
-                .each do |association|
-                  result.push(association) unless result.include?(association)
-                end
-            end
-          end
-          associations.each do |association|
-            result.push(association) unless result.include?(association)
-          end
-          result
-        end
-
-        def generate_from_dot(input)
-          Lutaml::Layout::GraphVizEngine.new(input: input).render(@type)
-        end
-
-        def generate_graph_name(name)
-          name.gsub(/[^0-9a-zA-Z]/i, "")
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml/formatter.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    module Formatter
-      class << self
-        def all
-          @all ||= []
-        end
-
-        def find_by_name(name)
-          name = name.to_sym
-
-          all.detect { |formatter_class| formatter_class.name == name }
-        end
-      end
-    end
-  end
-end
-
-require "lutaml/uml/formatter/graphviz"

data/lib/lutaml/uml/serializers/association.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/uml/serializers/base"
-require "lutaml/uml/serializers/class"
-
-module Lutaml
-  module Uml
-    module Serializers
-      class Association < Base
-        property :member_end, from: :target
-        property :member_end_attribute_name,
-                 from: "relationship",
-                 transform_with: (lambda do |val|
-                   val.dig("target", "attributes")&.keys&.first ||
-                    val.dig("target", "attribute")&.keys&.first
-                 end)
-        property :member_end_cardinality,
-                 from: "relationship",
-                 transform_with: (lambda do |val|
-                   res = val.dig("source", "attributes")&.values&.first ||
-                          val.dig("source", "attribute")&.values&.first
-                   res["cardinality"] if res
-                 end)
-        property :member_end_type,
-                 from: "relationship",
-                 transform_with: (lambda do |val|
-                   val.dig("target", "type")
-                 end)
-        property :owner_end_attribute_name,
-                 from: "relationship",
-                 transform_with: (lambda do |val|
-                   val.dig("source", "attributes")&.keys&.first ||
-                     val.dig("source", "attribute")&.keys&.first
-                 end)
-        property :owner_end_cardinality,
-                 from: "relationship",
-                 transform_with: (lambda do |val|
-                   res = val.dig("source", "attributes")&.values&.first ||
-                           val.dig("source", "attribute")&.values&.first
-                   res["cardinality"] if res
-                 end)
-        property :owner_end_type,
-                 from: "relationship",
-                 transform_with: (lambda do |val|
-                   val.dig("source", "type")
-                 end)
-        property :action,
-                 transform_with: (lambda do |val|
-                   if val["direction"] == "target"
-                     "#{val['verb']} ▶"
-                   else
-                     "◀ #{val['verb']}"
-                   end
-                 end)
-      end
-    end
-  end
-end

data/lib/lutaml/uml/serializers/base.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require "hashie"
-
-module Lutaml
-  module Uml
-    module Serializers
-      class Base < Hashie::Dash
-        include Hashie::Extensions::Dash::PropertyTranslation
-        include Hashie::Extensions::Dash::IndifferentAccess
-        include Hashie::Extensions::Dash::Coercion
-        include Hashie::Extensions::IgnoreUndeclared
-      end
-    end
-  end
-end

data/lib/lutaml/uml/serializers/class.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/uml/serializers/base"
-require "lutaml/uml/serializers/top_element_attribute"
-require "lutaml/uml/serializers/association"
-
-module Lutaml
-  module Uml
-    module Serializers
-      class Class < Base
-        property :attributes,
-                 transform_with: (lambda do |entry|
-                   entry
-                    .to_a
-                    .map do |(name, attributes)|
-                      attributes.merge(name: name)
-                    end
-                 end)
-        property :associations,
-                 from: :relations,
-                 coerce: [::Lutaml::Uml::Serializers::Association]
-        property :name
-        # property :type, from: :modelType
-        # property :relations,
-        #          coerce: Array[Relation]
-      end
-    end
-  end
-end

data/lib/lutaml/uml/serializers/top_element_attribute.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/uml/serializers/base"
-
-module Lutaml
-  module Uml
-    module Serializers
-      class TopElementAttribute < Base
-        property :cardinality
-        property :type
-      end
-    end
-  end
-end

data/lib/lutaml/uml/serializers/yaml_view.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/uml/serializers/base"
-require "lutaml/uml/serializers/class"
-
-module Lutaml
-  module Uml
-    module Serializers
-      class YamlView < Base
-        property :name
-        property :title
-        property :caption
-        property :groups
-        property :fidelity
-      end
-    end
-  end
-end

data/lib/lutaml/uml/version.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    VERSION = "0.4.3"
-  end
-end