lutaml-uml 0.4.3 → 0.5.2

data/bin/yaml2lutaml

@@ -1,144 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#
-# Script to convert datamodel yaml files into LutaML syntax
-# Usage: bin/yaml2lutaml /path/to/datamodel/view/file.yml
-
-require "yaml"
-
-view_yaml = YAML.safe_load(File.read(ARGV[0]))
-models_path = File.expand_path("../../models", ARGV[0])
-
-def sync_puts(line, level = 0)
-  $stdout.puts("#{''.rjust(level)}#{line}")
-  $stdout.flush
-end
-
-encountered_relations = Hash.new { |h, key| h[key] = [] }
-# relations:
-# - target: AttributeProfile
-#   relationship:
-#     source:
-#       type: aggregation
-#       attribute:
-#         addressClassProfile:
-#     target:
-#       type: direct
-#       attribute:
-#         attributeProfile:
-#           cardinality:
-#             min: 0
-#             max: '*'
-def process_association(owner, values, encountered_relations)
-  target_name = values["target"]
-  return if encountered_relations[owner].include?(target_name)
-
-  encountered_relations[owner].push(target_name)
-  sync_puts("association {", 2)
-
-  relationship_block = values["relationship"] || {}
-
-  if relationship_block["source"] && relationship_block["source"]["type"]
-    source = relationship_block["source"]
-    sync_puts("owner_type #{source['type']}", 4)
-    if source["attribute"]
-      source_attribute_name = source["attribute"].keys.first
-      owner += "##{source_attribute_name}"
-      if source["attribute"][source_attribute_name] && source["attribute"][source_attribute_name]["cardinality"]
-        cardinality = source["attribute"][source_attribute_name]["cardinality"]
-        owner += " [#{cardinality['min']}..#{cardinality['max']}]"
-      end
-    end
-  end
-  sync_puts("owner #{owner}", 4)
-
-  member = target_name
-  if relationship_block["target"]
-    target = relationship_block["target"]
-    type = target["type"] || "direct"
-    sync_puts("member_type #{type}", 4)
-    if target["attribute"]
-      target_attribute_name = target["attribute"].keys.first
-      member += "##{target_attribute_name}"
-      if target["attribute"][target_attribute_name] && target["attribute"][target_attribute_name]["cardinality"]
-        cardinality = target["attribute"][target_attribute_name]["cardinality"]
-        member += " [#{cardinality['min']}..#{cardinality['max']}]"
-      end
-    end
-  else
-    sync_puts("member_type direct", 4)
-  end
-  sync_puts("member #{member}", 4)
-
-  sync_puts("}", 2)
-end
-sync_puts("diagram #{File.basename(ARGV[0], 'yml')[0..-2]} {")
-sync_puts("title '#{view_yaml['title']}'", 2)
-sync_puts("caption '#{view_yaml['caption']}'", 2)
-
-# Class associations notations
-view_yaml["relations"]&.each do |values|
-  process_association(values["source"], values, encountered_relations)
-end
-
-view_yaml["imports"].keys.each do |entry|
-  import = YAML.safe_load(File.read(File.join(models_path, "#{entry}.yml")))
-  import_name = import["name"] || File.basename(entry)
-  # Class notation
-  sync_puts("#{import['modelType']} #{import_name} {", 2)
-  if import["definition"]
-    definition = <<~TEXT
-      definition {
-        #{import['definition']}
-      }
-    TEXT
-    sync_puts(definition, 4)
-  end
-  import["values"]&.each_pair do |key, values|
-    result_string = key
-    if values["definition"]
-      result_string += <<~TEXT
-        {
-          definition {
-          #{values['definition']}
-          }
-        }
-      TEXT
-    end
-    sync_puts(result_string, 4)
-  end
-  import["attributes"]&.each_pair do |key, values|
-    definition = values["definition"]
-    cardinality = if values["cardinality"]
-                    cardinality_val = values["cardinality"]
-                    "[#{cardinality_val['min']}..#{cardinality_val['max']}]"
-                  else
-                    ""
-                  end
-    result_string = "+#{key}"
-    if values["type"]
-      result_string += ": #{values['type']}"
-    end
-    if cardinality
-      result_string += " #{cardinality}"
-    end
-    if definition
-      result_string += <<~TEXT
-        {
-          definition
-          #{definition}
-          end definition
-        }
-      TEXT
-    end
-    sync_puts(result_string, 4)
-  end
-  sync_puts("}", 2)
-
-  # Associations notations
-  import["relations"]&.each do |values|
-    process_association(import_name, values, encountered_relations)
-  end
-end
-sync_puts("}")

data/lib/lutaml/layout/engine.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  class Engine
-    attr_accessor :input
-
-    def initialize(input:)
-      @input = input
-    end
-
-    def render(_type)
-      raise ArgumentError, "Implement render method"
-    end
-  end
-end

data/lib/lutaml/layout/graph_viz_engine.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require "ruby-graphviz"
-require "lutaml/layout/engine"
-
-module Lutaml
-  module Layout
-    class GraphVizEngine < Engine
-      def render(type)
-        Open3.popen3("dot -T#{type}") do |stdin, stdout, _stderr, _wait|
-          stdin.puts(input)
-          stdin.close
-          # unless (err = stderr.read).empty? then raise err end
-          stdout.read
-        end
-      end
-    end
-  end
-end

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
-        @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)
-            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

@@ -1,334 +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".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

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/node/base.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/uml/has_attributes"
-
-module Lutaml
-  module Uml
-    module Node
-      class Base
-        include HasAttributes
-
-        # rubocop:disable Rails/ActiveRecordAliases
-        def initialize(attributes = {})
-          update_attributes(attributes)
-        end
-        # rubocop:enable Rails/ActiveRecordAliases
-
-        attr_accessor :parent
-      end
-    end
-  end
-end

data/lib/lutaml/uml/node/class_node.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/uml/node/base"
-require "lutaml/uml/node/field"
-require "lutaml/uml/node/method"
-require "lutaml/uml/node/relationship"
-require "lutaml/uml/node/class_relationship"
-require "lutaml/uml/node/has_name"
-
-module Lutaml
-  module Uml
-    module Node
-      class ClassNode < Base
-        include HasName
-
-        attr_reader :modifier
-
-        def modifier=(value)
-          @modifier = value.to_s # TODO: Validate?
-        end
-
-        attr_reader :members
-
-        def members=(value)
-          @members = value.to_a.map do |member|
-            type       = member.to_a[0][0] # TODO: This is dumb
-            attributes = member.to_a[0][1]
-            attributes[:parent] = self
-
-            case type
-            when :field              then Field.new(attributes)
-            when :method             then Method.new(attributes)
-            when :relationship       then Relationship.new(attributes)
-            when :class_relationship then ClassRelationship.new(attributes)
-            end
-          end
-        end
-
-        def fields
-          @members.select { |member| member.class == Field }
-        end
-
-        def methods
-          @members.select { |member| member.class == Method }
-        end
-
-        def relationships
-          @members.select { |member| member.class == Relationship }
-        end
-
-        def class_relationships
-          @members.select { |member| member.class == ClassRelationship }
-        end
-      end
-    end
-  end
-end