lutaml 0.9.39 → 0.9.41

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2fb018969e853897d9a564b6352677064c33c40aa81127c8085633a07aa6574
-  data.tar.gz: 8b6aef0e65b2ecc29158aaacc4b0b2f53b6101142930f429d3489a839bef557b
+  metadata.gz: 0f621771edf0e06706b47f6ae904a914c7b70e7e1aa59deb7014b0b11e78ff44
+  data.tar.gz: e73b37317621f4e795637cb720c4e909f7531a92935ae5d199e06559e97092bf
 SHA512:
-  metadata.gz: '09f484c39c25ac9952b09e4c5d0463086823b19d2eb89f5b485a7eaff6582e028fee220d6b82a4215cb3cf2b2620613f4b4a02255799edc34ef910564eff32c1'
-  data.tar.gz: 5ed8da4c25558b31dce1a444ca7bf444549508e612e4d00d3250aecba369eccb72a9e6483c8115926166dae660c0ec84d57ad7be2702f5f3e478477666509c21
+  metadata.gz: c3742c1252a487c8a8345d24c43667be8125b764c0d035c15700fa66ac3ee938055f5b5a2d2bf83888480cae399b208c6677408d7d55174ba43ff53b16987f17
+  data.tar.gz: 6e92157660f166291385ee44e55c6e37178494e98aad23e19722d486611458da06bc253c16a9bdf3f16a423a38359d9589a8eab85bcc5d89e4ef4a1170806f82

data/README.adoc

@@ -26,7 +26,7 @@ Directly:
 $ gem install lutaml
 ----
 
-== Usage
+== Usages
 
 === Parsing
 
@@ -100,6 +100,12 @@ $ lutaml -o assets -t png test.lutaml
 
 For additional info refer to `lutaml --help output`.
 
+== Other Usages
+
+* link:docs/lutaml-uml.adoc[Usage with Lutaml::Uml]
+* link:docs/lutaml-express.adoc[Usage with Lutaml::Express]
+* link:docs/lutaml-xmi.adoc[Usage with Lutaml::XMI]
+// * link:docs/lutaml-sysml.adoc[Usage with Lutaml::Sysml]
 
 == Copyright and license
 

data/docs/lutaml-express.adoc

@@ -0,0 +1,35 @@
+= Lutaml::Express
+
+Lutaml::Express provides functionality to parse and manipulate EXPRESS files,
+enabling seamless integration with the Lutaml framework.
+
+== Usages
+
+The parser `Lutaml::Express::Parsers::Exp` is used to parse EXPRESS schema file
+`.exp` into `Expressir::Model::Repository` model.
+
+=== Examples
+
+.EXPRESS schema file parsing
+[example]
+====
+
+When using the `Lutaml::Express::Parsers::Exp` parser, you can parse an EXPRESS
+schema file as follows:
+
+[source,ruby]
+----
+require "lutaml"
+
+Lutaml::Express::Parsers::Exp.parse(File.new("path/to/example.exp"))
+# => returns Expressir::Model::Repository model
+----
+
+
+`Expressir::Model::Repository` is a Lutaml model that can be further processed
+or converted to other formats.
+
+Please refer to https://github.com/lutaml/expressir[expressir] or
+https://github.com/lutaml/lutaml-model[lutaml-model] for more details.
+
+====

data/docs/lutaml-sysml.adoc

@@ -0,0 +1,10 @@
+= Lutaml::Sysml
+
+Lutaml::Sysml extends Lutaml::Uml by adding concepts relevant to systems
+engineering, supporting a Model-Based Systems Engineering (MBSE) approach
+throughout the entire system lifecycle.
+
+== Usage
+
+Lutaml::Sysml provides specialized diagram types and elements for systems engineering modeling.
+

data/docs/lutaml-uml.adoc

@@ -0,0 +1,111 @@
+= Lutaml::Uml
+
+Lutaml::Uml is a language for specifying UML class diagrams and a tool for
+converting it into various different formats.
+
+== Language
+
+See link:lutaml_syntax.adoc[LutaML syntax]
+
+== Usages
+
+Converter executables are available:
+
+* PlantUML WSD or PUML to LutaML UML: `lutaml-wsd2uml`
+* LutaML YAML to LutaML UML: `lutaml-yaml2uml`
+
+=== Examples
+
+.PlantUML to LutaML UML
+[example]
+====
+
+Given the following PlantUML PUML file `example.puml`:
+
+[source,plantuml]
+----
+@startuml
+Alice -> Bob: Authentication Request
+Bob --> Alice: Authentication Response
+@enduml
+----
+
+Running the command:
+
+```
+lutaml-wsd2uml example.puml
+```
+
+The following results will be produced:
+
+[source,lutaml]
+----
+diagram plantuml-simple.puml {
+  association {
+    owner Alice
+    member Request
+    member_type direct
+  }
+  association {
+    owner Bob
+    member Response
+    member_type direct
+  }
+}
+----
+====
+
+.LutaML YAML to LutaML UML
+[example]
+====
+
+Given the following LutaML YAML file `Address.yml`:
+
+[source,yaml]
+----
+name: Address
+modelType: class
+relations:
+  - target: AddressComponent
+    relationship:
+      source:
+        type: aggregation
+        attributes:
+          address:
+            cardinality:
+              min: 1
+              max: "*"
+      target:
+        type: direct
+        attributes:
+          addressComponent:
+            cardinality:
+              min: 1
+              max: "*"
+    action:
+      verb: comprises
+      direction: target
+----
+
+Running the command:
+
+```
+lutaml-yaml2uml Address.yml
+```
+
+The following results will be produced:
+
+[source,lutaml]
+----
+diagram Address {
+  title ''
+  caption ''
+  association {
+    owner_type aggregation
+    owner 
+    member_type direct
+    member AddressComponent
+  }
+}
+----
+====

data/docs/lutaml-xmi.adoc

@@ -0,0 +1,33 @@
+= Lutaml::XMI
+
+Lutaml::XMI provides functionality to parse and manipulate
+Enterprise Architecture XMI files.
+
+== Usages
+
+The parser `Lutaml::XMI::Parsers::XML` is used to parse XMI files into
+`Lutaml::Uml::Document` model.
+
+=== Examples
+
+.Parsing XMI file
+[example]
+====
+
+When using the `Lutaml::XMI::Parsers::XML` parser, you can parse an XMI
+file as follows:
+
+[source,ruby]
+----
+require "lutaml"
+
+Lutaml::XMI::Parsers::XML.parse(File.new("path/to/example.xmi"))
+# => returns Lutaml::Uml::Document model
+----
+
+`Lutaml::Uml::Document` model is a Lutaml model that can be further processed or
+converted to other formats.
+
+Please refer to https://github.com/lutaml/lutaml-model[lutaml-model] for more details.
+
+====

data/exe/lutaml-yaml2uml

@@ -84,7 +84,7 @@ view_yaml["relations"]&.each do |values|
   process_association(values["source"], values, encountered_relations)
 end
 
-view_yaml["imports"].each_key do |entry| # rubocop:disable Metrics/BlockLength
+view_yaml["imports"]&.each_key do |entry| # rubocop:disable Metrics/BlockLength
   import = YAML.safe_load(File.read(File.join(models_path, "#{entry}.yml")))
   import_name = import["name"] || File.basename(entry)
   # Class notation

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/express.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "lutaml/express/version"
 require "lutaml/express/parsers/exp"
 
 module Lutaml