lutaml 0.9.39 → 0.9.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2fb018969e853897d9a564b6352677064c33c40aa81127c8085633a07aa6574
-  data.tar.gz: 8b6aef0e65b2ecc29158aaacc4b0b2f53b6101142930f429d3489a839bef557b
+  metadata.gz: 3a25bacbf3519d5503fcd4170350b61fe5ab7eda2b375a93e4b3d1897bbe7b4b
+  data.tar.gz: 7f10420fd2ac6ef7bbb963790b935096c9767ff15fbe60561e93a86270cc99f7
 SHA512:
-  metadata.gz: '09f484c39c25ac9952b09e4c5d0463086823b19d2eb89f5b485a7eaff6582e028fee220d6b82a4215cb3cf2b2620613f4b4a02255799edc34ef910564eff32c1'
-  data.tar.gz: 5ed8da4c25558b31dce1a444ca7bf444549508e612e4d00d3250aecba369eccb72a9e6483c8115926166dae660c0ec84d57ad7be2702f5f3e478477666509c21
+  metadata.gz: 06cdd75854cf6ab4a665deafd86437d9a8e793d925ac998fd2195d7c2dbea92229844b847ac85cb9ac656b13d9aba58e3d399664a9ad80c4d5d51961ab5a9c9e
+  data.tar.gz: 6b3385b7cef67d5e7aee600c56397c0bb780676788c62b8beb388e6d6386dd6b89dcab3b9191be703a76b98c855d200a078d3618151fd751ac8d9d46a259e38b

data/lib/lutaml/command_line.rb

@@ -52,7 +52,7 @@ module Lutaml
 
     def formatter=(value)
       value = value.to_s.strip.downcase.to_sym
-      value = Lutaml::Uml::Formatter.find_by(name: value)
+      value = Lutaml::Formatter.find_by(name: value)
       raise Error, "Formatter not found: #{value}" if value.nil?
 
       @formatter = value

data/lib/lutaml/converter/dsl_to_uml.rb

@@ -0,0 +1,235 @@
+module Lutaml
+  module Converter
+    module DslToUml
+      def create_uml_document(hash)
+        ::Lutaml::Uml::Document.new.tap do |model|
+          set_uml_model(model, hash)
+        end
+      end
+
+      def create_uml_package(hash)
+        ::Lutaml::Uml::Package.new.tap do |model|
+          set_uml_model(model, hash)
+        end
+      end
+
+      def create_uml_class(hash)
+        ::Lutaml::Uml::Class.new.tap do |model|
+          set_uml_model(model, hash)
+        end
+      end
+
+      def create_uml_enum(hash)
+        ::Lutaml::Uml::Enum.new.tap do |model|
+          set_uml_model(model, hash)
+        end
+      end
+
+      def create_uml_data_type(hash)
+        ::Lutaml::Uml::DataType.new.tap do |model|
+          set_uml_model(model, hash)
+        end
+      end
+
+      def create_uml_diagram(hash)
+        ::Lutaml::Uml::Diagram.new.tap do |model|
+          set_uml_model(model, hash)
+        end
+      end
+
+      def create_uml_attribute(hash) # rubocop:disable Metrics/AbcSize
+        ::Lutaml::Uml::TopElementAttribute.new.tap do |model|
+          set_uml_model(model, hash)
+        end
+      end
+
+      def create_uml_cardinality(hash)
+        ::Lutaml::Uml::Cardinality.new.tap do |cardinality|
+          cardinality.min = hash[:min]
+          cardinality.max = hash[:max]
+        end
+      end
+
+      def create_uml_association(hash) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        ::Lutaml::Uml::Association.new.tap do |model|
+          member_end_cardinality = hash.delete(:member_end_cardinality)
+          if member_end_cardinality
+            model.member_end_cardinality = create_uml_cardinality(
+              member_end_cardinality,
+            )
+          end
+          owner_end_cardinality = hash.delete(:owner_end_cardinality)
+          if owner_end_cardinality
+            model.owner_end_cardinality = create_uml_cardinality(
+              owner_end_cardinality,
+            )
+          end
+
+          set_uml_model(model, hash)
+        end
+      end
+
+      def create_uml_operation(hash)
+        ::Lutaml::Uml::Operation.new.tap do |model|
+          set_uml_model(model, hash)
+        end
+      end
+
+      def create_uml_constraint(hash)
+        ::Lutaml::Uml::Constraint.new.tap do |model|
+          set_uml_model(model, hash)
+        end
+      end
+
+      def create_uml_value(hash)
+        ::Lutaml::Uml::Value.new.tap do |model|
+          set_uml_model(model, hash)
+        end
+      end
+
+      def set_uml_model(model, hash)
+        hash = create_uml_members(model, hash)
+        set_model_attribute(model, hash)
+      end
+
+      def set_model_attribute(model, hash) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        hash.each do |key, value|
+          if key == :definition
+            value = value.to_s.gsub(/\\}/, "}").gsub(/\\{/, "{")
+              .split("\n").map(&:strip).join("\n")
+          end
+
+          if model.respond_to?("#{key}=")
+            if model.class.attributes[key.to_sym].options[:collection]
+              values = model.send(key.to_sym).to_a
+              values << value
+              model.send("#{key}=", values)
+            else
+              model.send("#{key}=", value)
+            end
+          end
+        end
+      end
+
+      def create_uml_members(model, hash) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        members = hash.delete(:members)
+        members.to_a.each do |member_hash|
+          member_hash.each do
+            create_uml_packages(model, member_hash)
+            create_uml_classes(model, member_hash)
+            create_uml_enums(model, member_hash)
+            create_uml_data_types(model, member_hash)
+            create_uml_diagrams(model, member_hash)
+            create_uml_attributes(model, member_hash)
+            create_uml_associations(model, member_hash)
+            create_uml_operations(model, member_hash)
+            create_uml_constraints(model, member_hash)
+            create_uml_values(model, member_hash)
+            set_model_attribute(model, member_hash)
+          end
+        end
+        hash
+      end
+
+      def create_uml_packages(model, hash)
+        packages = hash.delete(:packages)
+        return [] if packages.nil?
+
+        attr = create_uml_package(packages)
+        model.packages = [] if model.packages.nil?
+        model.packages << attr
+        hash
+      end
+
+      def create_uml_classes(model, hash)
+        classes = hash.delete(:classes)
+        return [] if classes.nil?
+
+        attr = create_uml_class(classes)
+        model.classes = [] if model.classes.nil?
+        model.classes << attr
+        hash
+      end
+
+      def create_uml_enums(model, hash)
+        enums = hash.delete(:enums)
+        return [] if enums.nil?
+
+        attr = create_uml_enum(enums)
+        model.enums = [] if model.enums.nil?
+        model.enums << attr
+        hash
+      end
+
+      def create_uml_data_types(model, hash)
+        data_types = hash.delete(:data_types)
+        return [] if data_types.nil?
+
+        attr = create_uml_data_type(data_types)
+        model.data_types = [] if model.data_types.nil?
+        model.data_types << attr
+        hash
+      end
+
+      def create_uml_diagrams(model, hash)
+        diagrams = hash.delete(:diagrams)
+        return [] if diagrams.nil?
+
+        attr = create_uml_diagram(diagrams)
+        model.diagrams = [] if model.diagrams.nil?
+        model.diagrams << attr
+        hash
+      end
+
+      def create_uml_attributes(model, hash)
+        attributes = hash.delete(:attributes)
+        return [] if attributes.nil?
+
+        attr = create_uml_attribute(attributes)
+        model.attributes = [] if model.attributes.nil?
+        model.attributes << attr
+        hash
+      end
+
+      def create_uml_associations(model, hash)
+        associations = hash.delete(:associations)
+        return [] if associations.nil?
+
+        attr = create_uml_association(associations)
+        model.associations = [] if model.associations.nil?
+        model.associations << attr
+        hash
+      end
+
+      def create_uml_operations(model, hash)
+        operations = hash.delete(:operations)
+        return [] if operations.nil?
+
+        attr = create_uml_operation(operations)
+        model.operations = [] if model.operations.nil?
+        model.operations << attr
+        hash
+      end
+
+      def create_uml_constraints(model, hash)
+        constraints = hash.delete(:constraints)
+        return [] if constraints.nil?
+
+        attr = create_uml_constraint(constraints)
+        model.constraints = [] if model.constraints.nil?
+        model.constraints << attr
+        hash
+      end
+
+      def create_uml_values(model, hash)
+        values = hash.delete(:values)
+        return [] if values.nil?
+
+        attr = create_uml_value(values)
+        model.values = [] if model.values.nil?
+        model.values << attr
+        hash
+      end
+    end
+  end
+end

data/lib/lutaml/converter/xmi_hash_to_uml.rb

@@ -0,0 +1,196 @@
+module Lutaml
+  module Converter
+    module XmiHashToUml
+      def create_uml_document(hash)
+        ::Lutaml::Uml::Document.new.tap do |doc|
+          doc.name = hash[:name]
+          hash[:packages]&.each do |package_hash|
+            pkg = create_uml_package(package_hash)
+            doc.packages = [] if doc.packages.nil?
+            doc.packages << pkg
+          end
+        end
+      end
+
+      def create_uml_package(hash) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        package = ::Lutaml::Uml::Package.new
+        package.xmi_id = hash[:xmi_id]
+        package.name = hash[:name]
+        package.definition = hash[:definition]
+        package.stereotype = hash[:stereotype]
+
+        hash[:classes]&.each do |class_hash|
+          class_obj = create_uml_class(class_hash)
+          package.classes = [] if package.classes.nil?
+          package.classes << class_obj
+        end
+        hash[:enums]&.each do |enum_hash|
+          enum_obj = create_uml_enum(enum_hash)
+          package.enums = [] if package.enums.nil?
+          package.enums << enum_obj
+        end
+        hash[:data_types]&.each do |data_type_hash|
+          data_type_obj = create_uml_data_type(data_type_hash)
+          package.data_types = [] if package.data_types.nil?
+          package.data_types << data_type_obj
+        end
+        hash[:diagrams]&.each do |diagram_hash|
+          diagram_obj = create_uml_diagram(diagram_hash)
+          package.diagrams = [] if package.diagrams.nil?
+          package.diagrams << diagram_obj
+        end
+        hash[:packages]&.each do |package_hash|
+          pkg = create_uml_package(package_hash)
+          package.packages = [] if package.packages.nil?
+          package.packages << pkg
+        end
+
+        package
+      end
+
+      def create_uml_class(hash) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        ::Lutaml::Uml::Class.new.tap do |klass| # rubocop:disable Metrics/BlockLength
+          klass.xmi_id = hash[:xmi_id]
+          klass.name = hash[:name]
+          klass.type = hash[:type]
+          klass.is_abstract = hash[:is_abstract]
+          klass.definition = hash[:definition]
+          klass.stereotype = hash[:stereotype]
+          hash[:attributes]&.each do |attr_hash|
+            attr = create_uml_attribute(attr_hash)
+            klass.attributes = [] if klass.attributes.nil?
+            klass.attributes << attr
+          end
+          hash[:associations]&.each do |assoc_hash|
+            assoc = create_uml_association(assoc_hash)
+            klass.associations = [] if klass.associations.nil?
+            klass.associations << assoc
+          end
+          hash[:operations]&.each do |op_hash|
+            op = create_uml_operation(op_hash)
+            klass.operations = [] if klass.operations.nil?
+            klass.operations << op
+          end
+          hash[:constraints]&.each do |constraint_hash|
+            constraint = create_uml_constraint(constraint_hash)
+            klass.constraints = [] if klass.constraints
+            klass.constraints << constraint
+          end
+        end
+      end
+
+      def create_uml_enum(hash) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        ::Lutaml::Uml::Enum.new.tap do |enum|
+          enum.xmi_id = hash[:xmi_id]
+          enum.name = hash[:name]
+          hash[:values]&.each do |value_hash|
+            value = create_uml_value(value_hash)
+            enum.values = [] if enum.values.nil?
+            enum.values << value
+          end
+          enum.definition = hash[:definition]
+          enum.stereotype = hash[:stereotype]
+        end
+      end
+
+      def create_uml_data_type(hash) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        ::Lutaml::Uml::DataType.new.tap do |data_type|
+          data_type.xmi_id = hash[:xmi_id]
+          data_type.name = hash[:name]
+          data_type.is_abstract = hash[:is_abstract]
+          data_type.definition = hash[:definition]
+          data_type.stereotype = hash[:stereotype]
+          hash[:attributes]&.each do |attr_hash|
+            attr = create_uml_attribute(attr_hash)
+            data_type.attributes = [] if data_type.attributes.nil?
+            data_type.attributes << attr
+          end
+          hash[:operations]&.each do |op_hash|
+            op = create_uml_operation(op_hash)
+            data_type.operations = [] if data_type.operations.nil?
+            data_type.operations << op
+          end
+          hash[:associations]&.each do |assoc_hash|
+            assoc = create_uml_association(assoc_hash)
+            data_type.associations = [] if data_type.associations.nil?
+            data_type.associations << assoc
+          end
+          hash[:constraints]&.each do |constraint_hash|
+            constraint = create_uml_constraint(constraint_hash)
+            data_type.constraints = [] if data_type.constraints
+            data_type.constraints << constraint
+          end
+        end
+      end
+
+      def create_uml_diagram(hash)
+        ::Lutaml::Uml::Diagram.new.tap do |diagram|
+          diagram.xmi_id = hash[:xmi_id]
+          diagram.name = hash[:name]
+          diagram.definition = hash[:definition]
+        end
+      end
+
+      def create_uml_attribute(hash) # rubocop:disable Metrics/AbcSize
+        ::Lutaml::Uml::TopElementAttribute.new.tap do |attr|
+          attr.id = hash[:id]
+          attr.name = hash[:name]
+          attr.type = hash[:type]
+          attr.xmi_id = hash[:xmi_id]
+          attr.is_derived = hash[:is_derived]
+          attr.cardinality = create_uml_cardinality(hash[:cardinality])
+          attr.definition = hash[:definition]
+        end
+      end
+
+      def create_uml_cardinality(hash)
+        ::Lutaml::Uml::Cardinality.new.tap do |cardinality|
+          cardinality.min = hash[:min]
+          cardinality.max = hash[:max]
+        end
+      end
+
+      def create_uml_association(hash) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        ::Lutaml::Uml::Association.new.tap do |assoc|
+          assoc.xmi_id = hash[:xmi_id]
+          assoc.member_end = hash[:member_end]
+          assoc.member_end_type = hash[:member_end_type]
+          assoc.member_end_cardinality = create_uml_cardinality(
+            hash[:member_end_cardinality],
+          )
+          assoc.member_end_attribute_name = hash[:member_end_attribute_name]
+          assoc.member_end_xmi_id = hash[:member_end_xmi_id]
+          assoc.owner_end = hash[:owner_end]
+          assoc.owner_end_xmi_id = hash[:owner_end_xmi_id]
+          assoc.definition = hash[:definition]
+        end
+      end
+
+      def create_uml_operation(hash)
+        ::Lutaml::Uml::Operation.new.tap do |op|
+          op.id = hash[:id]
+          op.xmi_id = hash[:xmi_id]
+          op.name = hash[:name]
+          op.definition = hash[:definition]
+        end
+      end
+
+      def create_uml_constraint(hash)
+        ::Lutaml::Uml::Constraint.new.tap do |constraint|
+          constraint.name = hash[:name]
+          constraint.type = hash[:type]
+          constraint.weight = hash[:weight]
+          constraint.status = hash[:status]
+        end
+      end
+
+      def create_uml_value(hash)
+        ::Lutaml::Uml::Value.new.tap do |value|
+          value.name = hash[:name]
+          value.type = hash[:type]
+          value.definition = hash[:definition]
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/formatter/base.rb

@@ -40,27 +40,27 @@ module Lutaml
 
       def format(node) # rubocop:disable Metrics/CyclomaticComplexity
         case node
-        when ::Lutaml::Uml::Node::Field then format_field(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
           format_class_relationship(node)
         when ::Lutaml::Uml::Node::ClassNode then format_class(node)
-        when Lutaml::Uml::Document then format_document(node)
+        when ::Lutaml::Uml::Document then format_document(node)
         end
       end
 
-      def format_field(_node); raise NotImplementedError; end
+      def format_field(_node);              raise NotImplementedError; end
 
-      def format_method(_node); raise NotImplementedError; end
+      def format_method(_node);             raise NotImplementedError; end
 
-      def format_relationship(_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_class(_node);              raise NotImplementedError; end
 
-      def format_document(_node); raise NotImplementedError; end
+      def format_document(_node);           raise NotImplementedError; end
     end
   end
 end

data/lib/lutaml/formatter/graphviz.rb

@@ -95,7 +95,8 @@ module Lutaml
           result += " : #{keyword}#{node.type}"
         end
         if node.cardinality
-          result += "[#{node.cardinality['min']}..#{node.cardinality['max']}]"
+          result += "[#{node.cardinality.min}.." \
+                    "#{node.cardinality.max}]"
         end
         result = escape_html_chars(result)
         result = "<U>#{result}</U>" if node.static
@@ -141,7 +142,17 @@ module Lutaml
                             else
                               "direct"
                             end
-        attributes["label"] = node.action if node.action
+
+        if node&.action&.verb
+          attributes["label"] = node.action.verb
+        end
+        case node&.action&.direction
+        when "target"
+          attributes["label"] = "#{attributes['label']} \u25b6"
+        when "source"
+          attributes["label"] = "\u25c0 #{attributes['label']}"
+        end
+
         if node.owner_end_attribute_name
           attributes["headlabel"] = format_label(
             node.owner_end_attribute_name,
@@ -189,11 +200,11 @@ module Lutaml
       def format_label(name, cardinality = {})
         res = "+#{name}"
         if cardinality.nil? ||
-            (cardinality[:min].nil? || cardinality[:max].nil?)
+            (cardinality.min.nil? || cardinality.max.nil?)
           return res
         end
 
-        "#{res} #{cardinality['min']}..#{cardinality['max']}"
+        "#{res} #{cardinality.min}..#{cardinality.max}"
       end
 
       def format_member_rows(members, hide_members) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
@@ -250,8 +261,8 @@ module Lutaml
         @node["fontname"] = "#{@fontname}-bold"
 
         if node.fidelity
-          hide_members = node.fidelity["hideMembers"]
-          hide_other_classes = node.fidelity["hideOtherClasses"]
+          hide_members = node.fidelity.hideMembers
+          hide_other_classes = node.fidelity.hideOtherClasses
         end
         classes = (node.classes +
                     node.enums +
@@ -303,8 +314,8 @@ module Lutaml
 
       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|
+        groups.each do |group|
+          group.values.each do |group_name| # rubocop:disable Style/HashEachMethods
             associations
               .select { |assc| assc.owner_end == group_name }
               .each do |association|

data/lib/lutaml/formatter.rb

@@ -15,5 +15,3 @@ module Lutaml
     end
   end
 end
-
-require "lutaml/formatter/graphviz"

data/lib/lutaml/parser.rb

@@ -35,7 +35,7 @@ module Lutaml
         file_list.map { |file| Lutaml::Xml::Parsers::Xml.parse(file) }
       when "lutaml"
         file_list.map { |file| Lutaml::Uml::Parsers::Dsl.parse(file) }
-      when "yml"
+      when "yml", "yaml"
         file_list.map { |file| Lutaml::Uml::Parsers::Yaml.parse(file.path) }
       else
         raise ArgumentError, "Unsupported file format"

data/lib/lutaml/uml/action.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Uml
+    class Action < Lutaml::Model::Serializable
+      attribute :verb, :string
+      attribute :direction, :string
+
+      yaml do
+        map "verb", to: :verb
+        map "direction", to: :direction
+      end
+    end
+  end
+end

data/lib/lutaml/uml/actor.rb

@@ -3,17 +3,9 @@
 ##
 ## Behaviour metamodel
 ##
-
 module Lutaml
   module Uml
     class Actor < Classifier
-      def initialize # rubocop:disable Lint/MissingSuper
-        @name = nil
-        @xmi_id = nil
-        @stereotype = []
-        @generalization = []
-        @namespace = nil
-      end
     end
   end
 end

data/lib/lutaml/uml/association.rb

@@ -3,41 +3,32 @@
 module Lutaml
   module Uml
     class Association < TopElement
-      include HasMembers
+      attribute :owner_end, :string
+      attribute :owner_end_attribute_name, :string
+      attribute :owner_end_cardinality, Cardinality
+      attribute :owner_end_type, :string
+      attribute :owner_end_xmi_id, :string
+      attribute :member_end, :string
+      attribute :member_end_attribute_name, :string
+      attribute :member_end_xmi_id, :string
+      attribute :member_end_cardinality, Cardinality
+      attribute :member_end_type, :string
+      attribute :static, :string
+      attribute :action, Action
 
-      attr_accessor :owner_end,
-                    :owner_end_attribute_name,
-                    :owner_end_cardinality,
-                    :owner_end_type,
-                    :owner_end_xmi_id,
-                    :member_end,
-                    :member_end_attribute_name,
-                    :member_end_xmi_id,
-                    :member_end_cardinality,
-                    :member_end_type,
-                    :static,
-                    :action
-
-      # TODO: move to Parslet::Transform
-      def members=(value) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-        value.group_by { |member| member.keys.first }
-          .each do |(type, group)|
-            if %w[owner_end member_end].include?(type) # rubocop:disable Performance/CollectionLiteralInLoop
-              group.each do |member|
-                member.each_pair do |key, member_value|
-                  public_send(:"#{association_type(key)}=", member_value)
-                end
-              end
-              next
-            end
-            attribute_value = group.map(&:values).flatten
-            if attribute_value.length == 1 && !attribute_value.first.is_a?(Hash)
-              next public_send(:"#{association_type(type)}=",
-                               attribute_value.first)
-            end
-
-            public_send(:"#{association_type(type)}=", attribute_value)
-          end
+      yaml do
+        map "owner_end", to: :owner_end
+        map "owner_end_attribute_name", to: :owner_end_attribute_name
+        map "owner_end_cardinality", to: :owner_end_cardinality
+        map "owner_end_type", to: :owner_end_type
+        map "owner_end_xmi_id", to: :owner_end_xmi_id
+        map "member_end", to: :member_end
+        map "member_end_attribute_name", to: :member_end_attribute_name
+        map "member_end_xmi_id", to: :member_end_xmi_id
+        map "member_end_cardinality", to: :member_end_cardinality
+        map "member_end_type", to: :member_end_type
+        map "static", to: :static
+        map "action", to: :action
       end
     end
   end

data/lib/lutaml/uml/cardinality.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Uml
+    class Cardinality < Lutaml::Model::Serializable
+      attribute :min, :string
+      attribute :max, :string
+    end
+  end
+end