lutaml 0.2.0 → 0.4.0

data/lib/lutaml/express/lutaml_path/document_wrapper.rb

@@ -0,0 +1,59 @@
+require "lutaml/lutaml_path/document_wrapper"
+require "expressir/express_exp/formatter"
+
+module Lutaml
+  module Express
+    module LutamlPath
+      class DocumentWrapper < ::Lutaml::LutamlPath::DocumentWrapper
+        SCHEMA_ATTRIBUTES = %w[
+          id
+          constants
+          declarations
+          entities
+          functions
+          interfaces
+          procedures
+          remarks
+          rules
+          subtype_constraints
+          types
+          version
+        ].freeze
+        SOURCE_CODE_ATTRIBUTE_NAME = "sourcecode".freeze
+
+        protected
+
+        def serialize_document(repository)
+          repository.schemas.each_with_object({}) do |schema, res|
+            res["schemas"] ||= []
+            serialized_schema = SCHEMA_ATTRIBUTES
+              .each_with_object({}) do |name, nested_res|
+              attr_value = schema.send(name)
+              nested_res[name] = serialize_value(attr_value)
+              if name == "entities"
+                nested_res[name] = merge_source_code_attr(nested_res[name],
+                                                          attr_value)
+              end
+            end
+            res[schema.id] = serialized_schema
+            serialized_schema = serialized_schema
+              .merge(SOURCE_CODE_ATTRIBUTE_NAME =>
+                                          entity_source_code(schema))
+            res["schemas"].push(serialized_schema)
+          end
+        end
+
+        def merge_source_code_attr(serialized_entries, entities)
+          serialized_entries.map do |serialized|
+            entity = entities.detect { |n| n.id == serialized["id"] }
+            serialized.merge(SOURCE_CODE_ATTRIBUTE_NAME => entity_source_code(entity))
+          end
+        end
+
+        def entity_source_code(entity)
+          Expressir::ExpressExp::Formatter.format(entity)
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/formatter.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lutaml
+  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
+
+require "lutaml/formatter/graphviz"

data/lib/lutaml/formatter/base.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "lutaml/formatter"
+require "lutaml/uml/has_attributes"
+
+module Lutaml
+  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 ::Lutaml::Uml::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 ::Lutaml::Uml::Node::Field  then format_field(node)
+        when ::Lutaml::Uml::Node::Method then format_method(node)
+        when ::Lutaml::Uml::Node::Relationship then format_relationship(node)
+        when ::Lutaml::Uml::Node::ClassRelationship
+          then format_class_relationship(node)
+        when ::Lutaml::Uml::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

data/lib/lutaml/formatter/graphviz.rb

@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+
+require "open3"
+require "lutaml/formatter/base"
+require "lutaml/layout/graph_viz_engine"
+
+module Lutaml
+  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