lutaml 0.7.6 → 0.8.0

data/lib/lutaml/uml/constraint.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+##
+## Behaviour metamodel
+##
+module Lutaml
+  module Uml
+    class Constraint < TopElement
+      attr_accessor :body
+    end
+  end
+end

data/lib/lutaml/uml/constructor_end.rb

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

data/lib/lutaml/uml/data_type.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+require "lutaml/uml/classifier"
+
+module Lutaml
+  module Uml
+    class DataType < Classifier
+      include HasMembers
+
+      attr_accessor :nested_classifier,
+                    :is_abstract,
+                    :type
+
+      attr_reader :associations,
+                  :attributes,
+                  :members,
+                  :modifier,
+                  :constraints,
+                  :operations,
+                  :data_types
+
+      def initialize(attributes = {})
+        @nested_classifier = []
+        @stereotype = []
+        @generalization = []
+        @is_abstract = false
+        super
+        @keyword = "dataType"
+      end
+
+      def modifier=(value)
+        @modifier = value.to_s # TODO: Validate?
+      end
+
+      def attributes=(value)
+        @attributes = value.to_a.map do |attr|
+          TopElementAttribute.new(attr)
+        end
+      end
+
+      def associations=(value)
+        @associations = value.to_a.map do |attr|
+          Association.new(attr.to_h.merge(owner_end: name))
+        end
+      end
+
+      def constraints=(value)
+        @constraints = value.to_a.map do |attr|
+          Constraint.new(attr)
+        end
+      end
+
+      def operations=(value)
+        @operations = value.to_a.map do |attr|
+          Operation.new(attr)
+        end
+      end
+
+      def data_types=(value)
+        @data_types = value.to_a.map do |attr|
+          DataType.new(attr)
+        end
+      end
+
+      def methods
+        # @members&.select { |member| member.class == Method }
+        []
+      end
+
+      def relationships
+        # @members&.select { |member| member.class == ClassRelationship }
+        []
+      end
+    end
+  end
+end

data/lib/lutaml/uml/dependency.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+##
+## Behaviour metamodel
+##
+module Lutaml
+  module Uml
+    class Dependency < TopElement
+      attr_accessor :client, :supplier
+
+      def initialize
+        @name = nil
+        @xmi_id = nil
+        @xmi_uuid = nil
+        @client = []
+        @supplier = []
+        @namespace = nil
+      end
+    end
+  end
+end

data/lib/lutaml/uml/diagram.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Uml
+    class Diagram < TopElement
+    end
+  end
+end

data/lib/lutaml/uml/document.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "lutaml/uml/class"
+require "lutaml/uml/data_type"
+require "lutaml/uml/enum"
+require "lutaml/uml/diagram"
+require "lutaml/uml/package"
+require "lutaml/uml/primitive_type"
+
+module Lutaml
+  module Uml
+    class Document
+      include HasAttributes
+      include HasMembers
+
+      attr_accessor :name,
+                    :title,
+                    :caption,
+                    :groups,
+                    :fidelity,
+                    :fontname,
+                    :comments
+      attr_reader :packages
+
+      # rubocop:disable Rails/ActiveRecordAliases
+      def initialize(attributes = {})
+        update_attributes(attributes)
+      end
+      # rubocop:enable Rails/ActiveRecordAliases
+      def classes=(value)
+        @classes = value.to_a.map { |attributes| Class.new(attributes) }
+      end
+
+      def data_types=(value)
+        @data_types = value.to_a.map { |attributes| DataType.new(attributes) }
+      end
+
+      def enums=(value)
+        @enums = value.to_a.map { |attributes| Enum.new(attributes) }
+      end
+
+      def packages=(value)
+        @packages = value.to_a.map { |attributes| Package.new(attributes) }
+      end
+
+      def primitives=(value)
+        @primitives = value.to_a.map { |attributes| PrimitiveType.new(attributes) }
+      end
+
+      def associations=(value)
+        @associations = value.to_a.map do |attributes|
+          Association.new(attributes)
+        end
+      end
+
+      def classes
+        @classes || []
+      end
+
+      def enums
+        @enums || []
+      end
+
+      def data_types
+        @data_types || []
+      end
+
+      def packages
+        @packages || []
+      end
+
+      def primitives
+        @primitives || []
+      end
+
+      def associations
+        @associations || []
+      end
+    end
+  end
+end

data/lib/lutaml/uml/enum.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "lutaml/uml/has_members"
+require "lutaml/uml/classifier"
+require "lutaml/uml/association"
+require "lutaml/uml/top_element_attribute"
+require "lutaml/uml/value"
+
+module Lutaml
+  module Uml
+    class Enum < Classifier
+      include HasMembers
+
+      attr_reader :attributes,
+                  :members,
+                  :modifier,
+                  :definition,
+                  :keyword,
+                  :values
+
+      def initialize(attributes = {})
+        super
+        @keyword = "enumeration"
+      end
+
+      # TODO: delete?
+      def attributes=(value)
+        @attributes = value.to_a.map do |attr|
+          TopElementAttribute.new(attr)
+        end
+      end
+
+      def values=(value)
+        @values = value.to_a.map do |attr|
+          Value.new(attr)
+        end
+      end
+
+      # TODO: reserved name, change
+      def methods
+        []
+      end
+    end
+  end
+end

data/lib/lutaml/uml/event.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+##
+## Behaviour metamodel
+##
+
+module Lutaml
+  module Uml
+    class Event < TopElement
+    end
+  end
+end

data/lib/lutaml/uml/final_state.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+##
+## Behaviour metamodel
+##
+module Lutaml
+  module Uml
+    class FinalState < State
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# 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)
+            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)
+          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

@@ -0,0 +1,334 @@
+# 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".freeze
+
+        VALID_TYPES = %i[
+          dot
+          xdot
+          ps
+          pdf
+          svg
+          svgz
+          fig
+          png
+          gif
+          jpg
+          jpeg
+          json
+          imap
+          cmapx
+        ].freeze
+
+        def initialize(attributes = {})
+          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
+        attr_reader :edge
+        attr_reader :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)
+          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)
+          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)
+          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)
+          unless !hide_members && 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)
+          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)
+          @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_groupping(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_groupping(groups, associations)
+          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