lutaml 0.9.39 → 0.9.40

data/lib/lutaml/uml/operation.rb

@@ -2,29 +2,13 @@
 
 module Lutaml
   module Uml
-    class Operation
-      include HasAttributes
-      include HasMembers
+    class Operation < TopElement
+      attribute :return_type, :string
+      attribute :parameter_type, :string
 
-      attr_reader :definition
-      attr_accessor :name,
-                    :return_type,
-                    :parameter_type
-
-      # rubocop:disable Rails/ActiveRecordAliases
-      def initialize(attributes = {})
-        update_attributes(attributes)
-      end
-      # rubocop:enable Rails/ActiveRecordAliases
-
-      def definition=(value)
-        @definition = value
-          .to_s
-          .gsub(/\\}/, "}")
-          .gsub(/\\{/, "{")
-          .split("\n")
-          .map(&:strip)
-          .join("\n")
+      yaml do
+        map "return_type", to: :return_type
+        map "parameter_type", to: :parameter_type
       end
     end
   end

data/lib/lutaml/uml/package.rb

@@ -1,55 +1,34 @@
 # frozen_string_literal: true
 
+require "lutaml/uml/class"
+require "lutaml/uml/enum"
+require "lutaml/uml/data_type"
+require "lutaml/uml/diagram"
+
 module Lutaml
   module Uml
     class Package < TopElement
-      include HasAttributes
-
-      attr_accessor :imports, :contents
-      attr_reader :data_types, :children_packages
-
-      def initialize(attributes) # rubocop:disable Lint/MissingSuper
-        update_attributes(attributes)
-        @children_packages ||= packages.map do |pkg|
+      attribute :contents, :string, collection: true, default: -> { [] }
+      attribute :classes, Class, collection: true, default: -> { [] }
+      attribute :enums, Enum, collection: true, default: -> { [] }
+      attribute :data_types, DataType, collection: true, default: -> { [] }
+      attribute :packages, Package, collection: true, default: -> { [] }
+      attribute :diagrams, Diagram, collection: true, default: -> { [] }
+
+      yaml do
+        map "contents", to: :contents
+        map "classes", to: :classes
+        map "enums", to: :enums
+        map "data_types", to: :data_types
+        map "packages", to: :packages
+        map "diagrams", to: :diagrams
+      end
+
+      def children_packages
+        packages.map do |pkg|
           [pkg, pkg.packages, pkg.packages.map(&:children_packages)]
         end.flatten.uniq
       end
-
-      def classes=(value)
-        @classes = value.to_a.map { |attributes| Class.new(attributes) }
-      end
-
-      def enums=(value)
-        @enums = value.to_a.map { |attributes| Enum.new(attributes) }
-      end
-
-      def data_types=(value)
-        @data_types = value.to_a.map { |attributes| DataType.new(attributes) }
-      end
-
-      def packages=(value)
-        @packages = value.to_a.map { |attributes| Package.new(attributes) }
-      end
-
-      def diagrams=(value)
-        @diagrams = value.to_a.map { |attributes| Diagram.new(attributes) }
-      end
-
-      def classes
-        @classes || []
-      end
-
-      def enums
-        @enums || []
-      end
-
-      def packages
-        @packages || []
-      end
-
-      def diagrams
-        @diagrams || []
-      end
     end
   end
 end

data/lib/lutaml/uml/parsers/dsl.rb

@@ -5,6 +5,7 @@ require "parslet/convenience"
 require "lutaml/uml/parsers/dsl_preprocessor"
 require "lutaml/uml/parsers/dsl_transform"
 require "lutaml/uml/node/document"
+require "lutaml/converter/dsl_to_uml"
 
 module Lutaml
   module Uml
@@ -13,6 +14,8 @@ module Lutaml
 
       # Class for parsing LutaML dsl into Lutaml::Uml::Document
       class Dsl < Parslet::Parser
+        include Lutaml::Converter::DslToUml
+
         # @param [String] io - LutaML string representation
         #        [Hash] options - options for parsing
         #
@@ -27,8 +30,8 @@ module Lutaml
           # Parslet::ErrorReporter::Deepest allows more
           # detailed display of error
           reporter = Parslet::ErrorReporter::Deepest.new
-          ::Lutaml::Uml::Document
-            .new(DslTransform.new.apply(super(data, reporter: reporter)))
+          hash = DslTransform.new.apply(super(data, reporter: reporter))
+          create_uml_document(hash)
         rescue Parslet::ParseFailed => e
           raise(ParsingError,
                 "#{e.message}\ncause: #{e.parse_failure_cause.ascii_tree}")

data/lib/lutaml/uml/parsers/yaml.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
 require "yaml"
-require "lutaml/uml/class"
-require "lutaml/uml/document"
-require "lutaml/uml/serializers/yaml_view"
+require "lutaml/uml"
 
 module Lutaml
   module Uml
@@ -14,31 +12,7 @@ module Lutaml
         end
 
         def parse(yaml_path, _options = {})
-          yaml_parse(yaml_path)
-        end
-
-        def yaml_parse(yaml_path)
-          yaml_content = YAML.safe_load(File.read(yaml_path))
-          serialized_yaml = Lutaml::Uml::Serializers::YamlView
-            .new(yaml_content)
-          result = Lutaml::Uml::Document.new(serialized_yaml)
-          result.classes = imports_to_classes(yaml_content, yaml_path)
-          result
-        end
-
-        private
-
-        def imports_to_classes(yaml_content, yaml_path)
-          models_path = File.join(File.dirname(yaml_path), "..", "models")
-          yaml_content["imports"].map do |(klass_name, _)|
-            klass_attrs = YAML.safe_load(
-              File.read(
-                File.join(models_path, "#{klass_name}.yml"),
-              ),
-            )
-            klass_attrs["name"] = klass_name if klass_attrs["name"].nil?
-            Lutaml::Uml::Serializers::Class.new(klass_attrs)
-          end
+          Lutaml::Uml::Document.from_yaml(File.read(yaml_path))
         end
       end
     end

data/lib/lutaml/uml/primitive_type.rb

@@ -3,11 +3,10 @@
 module Lutaml
   module Uml
     class PrimitiveType < DataType
-      attr_reader :keyword
+      attribute :keyword, :string, default: "primitive"
 
-      def initialize(attributes = {})
-        super
-        @keyword = "primitive"
+      yaml do
+        map "keyword", to: :keyword
       end
     end
   end

data/lib/lutaml/uml/property.rb

@@ -3,24 +3,22 @@
 module Lutaml
   module Uml
     class Property < TopElement
-      attr_accessor :type, # rubocop:disable Naming/MethodName
-                    :aggregation,
-                    :association,
-                    :is_derived,
-                    :lowerValue,
-                    :upperValue
+      attribute :type, :string
+      attribute :aggregation, :string
+      attribute :association, :string
+      attribute :is_derived, :boolean, default: false
+      attribute :visibility, :string, default: "public"
+      attribute :lowerValue, :string, default: "1"
+      attribute :upperValue, :string, default: "1"
 
-      def initialize # rubocop:disable Lint/MissingSuper
-        @name = nil
-        @xmi_id = nil
-        @xmi_uuid = nil
-        @aggregation = nil
-        @association = nil
-        @namespace = nil
-        @is_derived = false
-        @visibility = "public"
-        @lowerValue = "1" # rubocop:disable Naming/VariableName
-        @upperValue = "1" # rubocop:disable Naming/VariableName
+      yaml do
+        map "type", to: :type
+        map "aggregation", to: :aggregation
+        map "association", to: :association
+        map "is_derived", to: :is_derived
+        map "visibility", to: :visibility
+        map "lowerValue", to: :lowerValue
+        map "upperValue", to: :upperValue
       end
     end
   end

data/lib/lutaml/uml/region.rb

@@ -3,7 +3,6 @@
 ##
 ## Behaviour metamodel
 ##
-
 module Lutaml
   module Uml
     class Region < TopElement

data/lib/lutaml/uml/state.rb

@@ -6,7 +6,15 @@
 module Lutaml
   module Uml
     class State < Vertex
-      attr_accessor :exit, :entry, :do_activity
+      attribute :exit, :string
+      attribute :entry, :string
+      attribute :do_activity, :string
+
+      yaml do
+        map "exit", to: :exit
+        map "entry", to: :entry
+        map "do_activity", to: :do_activity
+      end
     end
   end
 end

data/lib/lutaml/uml/state_machine.rb

@@ -3,7 +3,6 @@
 ##
 ## Behaviour metamodel
 ##
-
 module Lutaml
   module Uml
     class StateMachine < Behavior

data/lib/lutaml/uml/top_element.rb

@@ -2,57 +2,79 @@
 
 module Lutaml
   module Uml
-    class TopElement
-      include HasAttributes
-
-      attr_reader :definition
-      attr_accessor :name,
-                    :xmi_id,
-                    :xmi_uuid,
-                    :namespace,
-                    :keyword,
-                    :stereotype,
-                    :href,
-                    :visibility,
-                    :comments
-
-      # rubocop:disable Rails/ActiveRecordAliases
-      def initialize(attributes = {})
-        @visibility = "public"
-        @name = attributes["name"]
-        update_attributes(attributes)
-      end
-      # rubocop:enable Rails/ActiveRecordAliases
+    class TopElement < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :xmi_id, :string
+      attribute :xmi_uuid, :string
+      attribute :namespace, NameSpace
+      attribute :keyword, :string
+      attribute :stereotype, :string, collection: true, default: -> { [] }
+      attribute :href, :string
+      attribute :visibility, :string, default: "public"
+      attribute :comments, :string, collection: true
 
-      def full_name # rubocop:disable Metrics/MethodLength
-        if name == nil
-          return nil
-        end
+      attribute :definition, :string
+      attribute :full_name, :string
 
-        the_name = name
-        next_namespace = namespace
+      yaml do
+        map "name", to: :name
+        map "xmi_id", to: :xmi_id
+        map "xmi_uuid", to: :xmi_uuid
+        map "namespace", to: :namespace
+        map "keyword", to: :keyword
+        map "stereotype", to: :stereotype
+        map "href", to: :href
+        map "visibility", to: :visibility
+        map "comments", to: :comments
 
-        while !next_namespace.nil?
-          the_name = if next_namespace.name.nil?
-                       "::#{the_name}"
-                     else
-                       "#{next_namespace.name}::#{the_name}"
-                     end
-          next_namespace = next_namespace.namespace
-        end
+        map "definition", to: :definition, with: {
+          to: :definition_to_yaml, from: :definition_from_yaml
+        }
+        map "full_name", with: {
+          to: :full_name_to_yaml, from: :full_name_from_yaml
+        }
+      end
 
-        the_name
+      def definition_to_yaml(model, doc)
+        doc["definition"] = model.definition if model.definition
       end
 
-      def definition=(value)
-        @definition = value
-          .to_s
+      def definition_from_yaml(model, value)
+        model.definition = value.to_s
           .gsub(/\\}/, "}")
           .gsub(/\\{/, "{")
           .split("\n")
           .map(&:strip)
           .join("\n")
       end
+
+      def full_name_to_yaml(model, doc) # rubocop:disable Metrics/MethodLength
+        return model.full_name if model.full_name
+
+        # If full_name is not set, calculate it
+        full_name = nil
+        if model.name == nil
+          return full_name
+        end
+
+        full_name = model.name
+        next_namespace = model.namespace
+
+        while !next_namespace.nil?
+          full_name = if next_namespace.name.nil?
+                        "::#{full_name}"
+                      else
+                        "#{next_namespace.name}::#{full_name}"
+                      end
+          next_namespace = next_namespace.namespace
+        end
+
+        doc["full_name"] = full_name
+      end
+
+      def full_name_from_yaml(model, value)
+        model.full_name = value
+      end
     end
   end
 end

data/lib/lutaml/uml/top_element_attribute.rb

@@ -2,32 +2,43 @@
 
 module Lutaml
   module Uml
-    class TopElementAttribute
-      include HasAttributes
-      include HasMembers
+    class TopElementAttribute < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :visibility, :string, default: "public"
+      attribute :type, :string
+      attribute :id, :string
+      attribute :xmi_id, :string
+      attribute :contain, :string
+      attribute :static, :string
+      attribute :cardinality, Cardinality
+      attribute :keyword, :string
+      attribute :is_derived, :boolean, default: false
 
-      attr_reader :definition
-      attr_accessor :name,
-                    :visibility,
-                    :type,
-                    :id,
-                    :xmi_id,
-                    :contain,
-                    :static,
-                    :cardinality,
-                    :keyword,
-                    :is_derived
+      attribute :definition, :string
 
-      # rubocop:disable Rails/ActiveRecordAliases
-      def initialize(attributes = {})
-        @visibility = "public"
-        update_attributes(attributes)
+      yaml do
+        map "name", to: :name
+        map "visibility", to: :visibility
+        map "type", to: :type
+        map "id", to: :id
+        map "xmi_id", to: :xmi_id
+        map "contain", to: :contain
+        map "static", to: :static
+        map "cardinality", to: :cardinality
+        map "keyword", to: :keyword
+        map "is_derived", to: :is_derived
+
+        map "definition", to: :definition, with: {
+          to: :definition_to_yaml, from: :definition_from_yaml
+        }
+      end
+
+      def definition_to_yaml(model, doc)
+        doc["definition"] = model.definition if model.definition
       end
-      # rubocop:enable Rails/ActiveRecordAliases
 
-      def definition=(value)
-        @definition = value
-          .to_s
+      def definition_from_yaml(model, value)
+        model.definition = value.to_s
           .gsub(/\\}/, "}")
           .gsub(/\\{/, "{")
           .split("\n")

data/lib/lutaml/uml/transition.rb

@@ -6,7 +6,17 @@
 module Lutaml
   module Uml
     class Transition < TopElement
-      attr_accessor :source, :target, :guard, :effect
+      attribute :source, :string
+      attribute :target, :string
+      attribute :guard, :string
+      attribute :effect, :string
+
+      yaml do
+        map "source", to: :source
+        map "target", to: :target
+        map "guard", to: :guard
+        map "effect", to: :effect
+      end
     end
   end
 end

data/lib/lutaml/uml/trigger.rb

@@ -6,7 +6,11 @@
 module Lutaml
   module Uml
     class Trigger < TopElement
-      attr_accessor :event
+      attribute :event, :string
+
+      yaml do
+        map "event", to: :event
+      end
     end
   end
 end

data/lib/lutaml/uml/value.rb

@@ -2,24 +2,28 @@
 
 module Lutaml
   module Uml
-    class Value
-      include HasAttributes
-      include HasMembers
+    class Value < Lutaml::Model::Serializable
+      attribute :definition, :string
+      attribute :name, :string
+      attribute :id, :string
+      attribute :type, :string
 
-      attr_reader :definition
-      attr_accessor :name,
-                    :id,
-                    :type
+      yaml do
+        map "name", to: :name
+        map "id", to: :id
+        map "type", to: :type
 
-      # rubocop:disable Rails/ActiveRecordAliases
-      def initialize(attributes = {})
-        update_attributes(attributes)
+        map "definition", to: :definition, with: {
+          to: :definition_to_yaml, from: :definition_from_yaml
+        }
       end
-      # rubocop:enable Rails/ActiveRecordAliases
 
-      def definition=(value)
-        @definition = value
-          .to_s
+      def definition_to_yaml(model, doc)
+        doc["definition"] = model.definition if model.definition
+      end
+
+      def definition_from_yaml(model, value)
+        model.definition = value.to_s
           .gsub(/\\}/, "}")
           .gsub(/\\{/, "{")
           .split("\n")

data/lib/lutaml/uml.rb

@@ -1,10 +1,48 @@
 # frozen_string_literal: true
 
-require "lutaml/uml/version"
+require "lutaml/model"
+
+require "lutaml/uml/has_attributes"
+require "lutaml/uml/has_members"
+require "lutaml/uml/namespace"
+require "lutaml/uml/cardinality"
+require "lutaml/uml/fidelity"
+require "lutaml/uml/top_element"
+require "lutaml/uml/top_element_attribute"
+require "lutaml/uml/value"
+require "lutaml/uml/action"
+require "lutaml/uml/classifier"
+require "lutaml/uml/dependency"
+require "lutaml/uml/association"
+require "lutaml/uml/constraint"
+require "lutaml/uml/operation"
+require "lutaml/uml/class"
+require "lutaml/uml/data_type"
+require "lutaml/uml/enum"
+require "lutaml/uml/diagram"
+require "lutaml/uml/package"
+require "lutaml/uml/primitive_type"
+require "lutaml/uml/group"
+require "lutaml/uml/connector"
+require "lutaml/uml/connector_end"
+require "lutaml/uml/behavior"
+require "lutaml/uml/activity"
+require "lutaml/uml/vertex"
+require "lutaml/uml/state"
+require "lutaml/uml/final_state"
+require "lutaml/uml/property"
+require "lutaml/uml/port"
+require "lutaml/uml/document"
+
 require "lutaml/uml/parsers/dsl"
 require "lutaml/uml/parsers/yaml"
 require "lutaml/uml/parsers/attribute"
-require "lutaml/uml/formatter"
+require "lutaml/formatter"
+require "lutaml/formatter/graphviz"
+
+Dir.glob(File.expand_path("./uml/**/*.rb", __dir__)).sort.each do |file|
+  require file
+end
 
 module Lutaml
   module Uml

data/lib/lutaml/version.rb

@@ -1,3 +1,3 @@
 module Lutaml
-  VERSION = "0.9.39".freeze
+  VERSION = "0.9.40".freeze
 end

data/lib/lutaml/xmi/liquid_drops/enum_drop.rb

@@ -46,7 +46,7 @@ module Lutaml
       end
 
       def subtype_of
-        find_subtype_of(@model.id)
+        find_subtype_of_from_owned_attribute_type(@model.id)
       end
     end
   end

data/lib/lutaml/xmi/liquid_drops/klass_drop.rb

@@ -186,7 +186,8 @@ module Lutaml
       end
 
       def subtype_of
-        find_subtype_of(@model.id)
+        find_subtype_of_from_generalization(@model.id) ||
+          find_subtype_of_from_owned_attribute_type(@model.id)
       end
 
       def has_guidance?

data/lib/lutaml/xmi/parsers/xmi_base.rb

@@ -297,7 +297,7 @@ module Lutaml
           @upper_level_cache[klass_id]
         end
 
-        def find_subtype_of(id) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        def find_subtype_of_from_owned_attribute_type(id) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
           @pkg_elements_owned_attributes ||= all_packaged_elements.map do |e|
             {
               name: e.name,
@@ -306,7 +306,6 @@ module Lutaml
                       end || [],
             }
           end
-
           result = @pkg_elements_owned_attributes.find do |e|
             e[:idrefs].include?(id)
           end
@@ -314,6 +313,25 @@ module Lutaml
           result[:name] if result
         end
 
+        def find_subtype_of_from_generalization(id) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          matched_element = @xmi_root_model.extension.elements.element
+            .find { |e| e.idref == id }
+
+          return if !matched_element || !matched_element.links
+
+          matched_generalization = nil
+          matched_element.links.each do |link|
+            matched_generalization = link&.generalization&.find do |g|
+              g.start == id
+            end
+            break if matched_generalization
+          end
+
+          return if matched_generalization&.end.nil?
+
+          lookup_entity_name(matched_generalization.end)
+        end
+
         # Build cache once for all packaged elements
         def build_upper_level_cache
           @upper_level_cache = {}