lutaml-uml 0.4.3 → 1.0.0

data/lib/lutaml/uml/enum.rb

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

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

data/lib/lutaml/uml/final_state.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-##
-## Behaviour metamodel
-##
-module Lutaml
-  module Uml
-    class FinalState < State
-    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/has_attributes.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    module HasAttributes
-      def update_attributes(attributes = {})
-        attributes.to_h.each do |name, value|
-          value = value.respond_to?(:str) ? value.str : value
-          public_send("#{name}=", value)
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml/has_members.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    module HasMembers
-      class UnknownMemberTypeError < StandardError; end
-
-      # TODO: move to Parslet::Transform
-      def members=(value)
-        value.group_by { |member| member.keys.first }
-          .each do |(type, group)|
-            attribute_value = group.map(&:values).flatten
-            if attribute_value.length == 1 && !attribute_value.first.is_a?(Hash)
-              next public_send("#{associtaion_type(type)}=", attribute_value.first)
-            end
-
-            public_send("#{associtaion_type(type)}=", attribute_value)
-          end
-      end
-
-      private
-
-      def associtaion_type(type)
-        return type if respond_to?("#{type}=")
-
-        raise(UnknownMemberTypeError, "Unknown member type: #{type}")
-      end
-    end
-  end
-end

data/lib/lutaml/uml/instance.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Instance < TopElement
-      attr_accessor :classifier, :slot
-
-      def initialize
-        @name = nil
-        @xmi_id = nil
-        @xmi_uuid = nil
-        @classifier = nil
-        @slot = []
-      end
-    end
-  end
-end

data/lib/lutaml/uml/model.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Model < Package
-      attr_accessor :viewpoint
-
-      def initialize
-        @contents = []
-      end
-    end
-  end
-end

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

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

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/uml/node/relationship"
-require "lutaml/uml/node/has_name"
-
-module Lutaml
-  module Uml
-    module Node
-      class ClassRelationship < Relationship
-        include HasName
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/uml/node/base"
-require "lutaml/uml/node/class_node"
-
-module Lutaml
-  module Uml
-    module Node
-      class Document < Base
-        attr_reader :classes
-
-        def classes=(value)
-          @classes = value.to_a.map { |attributes| ClassNode.new(attributes) }
-        end
-      end
-    end
-  end
-end