lutaml 0.9.39 → 0.9.40

data/lib/lutaml/uml/class.rb

@@ -1,82 +1,57 @@
 # frozen_string_literal: true
 
-require "lutaml/uml/classifier"
-
-require "lutaml/uml/has_members"
+require "lutaml/uml/package"
 require "lutaml/uml/association"
 require "lutaml/uml/constraint"
-require "lutaml/uml/data_type"
 require "lutaml/uml/operation"
-require "lutaml/uml/top_element_attribute"
+require "lutaml/uml/data_type"
 
 module Lutaml
   module Uml
     class Class < Classifier
-      include HasMembers
-
-      attr_accessor :nested_classifier,
-                    :is_abstract,
-                    :type,
-                    :package
-
-      attr_reader :associations,
-                  :attributes,
-                  :members,
-                  :modifier,
-                  :constraints,
-                  :operations,
-                  :data_types
-
-      def initialize(attributes = {})
-        @nested_classifier = []
-        @stereotype = []
-        @generalization = []
-        @is_abstract = false
-        super
-      end
-
-      def modifier=(value)
-        @modifier = value.to_s # TODO: Validate?
-      end
-
-      def attributes=(value)
-        @attributes = value.to_a.map do |attr|
-          TopElementAttribute.new(attr)
-        end
-      end
-
-      def associations=(value)
-        @associations = value.to_a.map do |attr|
-          Association.new(attr.to_h.merge(owner_end: name))
+      attribute :nested_classifier, :string, collection: true,
+                                             default: -> { [] }
+      attribute :is_abstract, :boolean, default: false
+      attribute :type, :string
+      attribute :package, Package
+      attribute :attributes, TopElementAttribute, collection: true
+      attribute :modifier, :string
+      attribute :constraints, Constraint, collection: true
+      attribute :operations, Operation, collection: true
+      attribute :data_types, DataType, collection: true
+      attribute :methods, :string, collection: true, default: -> { [] }
+
+      attribute :associations, Association, collection: true
+
+      yaml do
+        map "nested_classifier", to: :nested_classifier
+        map "is_abstract", to: :is_abstract
+        map "type", to: :type
+        map "package", to: :package
+        map "attributes", to: :attributes
+        map "modifier", to: :modifier
+        map "constraints", to: :constraints
+        map "operations", to: :operations
+        map "data_types", to: :data_types
+        map "methods", to: :methods
+
+        map "associations", to: :associations, with: {
+          to: :associations_to_yaml, from: :associations_from_yaml
+        }
+      end
+
+      def associations_to_yaml(model, doc)
+        associations = model.associations.map(&:to_hash)
+        doc["associations"] = associations unless associations.empty?
+      end
+
+      def associations_from_yaml(model, values)
+        associations = values.map do |value|
+          value["owner_end"] = model.name if value["owner_end"].nil?
+          Association.from_yaml(value.to_yaml)
         end
-      end
-
-      def constraints=(value)
-        @constraints = value.to_a.map do |attr|
-          Constraint.new(attr)
-        end
-      end
-
-      def operations=(value)
-        @operations = value.to_a.map do |attr|
-          Operation.new(attr)
-        end
-      end
-
-      def data_types=(value)
-        @data_types = value.to_a.map do |attr|
-          DataType.new(attr)
-        end
-      end
-
-      def methods
-        # @members&.select { |member| member.class == Method }
-        []
-      end
 
-      def relationships
-        # @members&.select { |member| member.class == ClassRelationship }
-        []
+        model.associations = associations
       end
     end
   end

data/lib/lutaml/uml/classifier.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
-require "lutaml/uml/top_element"
-
 module Lutaml
   module Uml
     class Classifier < TopElement
-      attr_accessor :generalization
+      attribute :generalization, :string, collection: true, default: -> { [] }
+
+      yaml do
+        map "generalization", to: :generalization
+      end
     end
   end
 end

data/lib/lutaml/uml/connector.rb

@@ -6,15 +6,12 @@
 module Lutaml
   module Uml
     class Connector < TopElement
-      attr_accessor :kind, :connector_end
+      attribute :kind, :string
+      attribute :connector_end, :string, collection: true, default: -> { [] }
 
-      def initialize # rubocop:disable Lint/MissingSuper
-        @name = nil
-        @xmi_id = nil
-        @xmi_uuid = nil
-        @connector_end = []
-        @namespace = nil
-        @kind = nil
+      yaml do
+        map "kind", to: :kind
+        map "connector_end", to: :connector_end
       end
     end
   end

data/lib/lutaml/uml/connector_end.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+##
+## Behaviour metamodel
+##
+module Lutaml
+  module Uml
+    class ConnectorEnd < TopElement
+      attribute :role, :string
+      attribute :part_with_port, :string
+      attribute :connector, :string
+
+      yaml do
+        map "role", to: :role
+        map "part_with_port", to: :part_with_port
+        map "connector", to: :connector
+      end
+    end
+  end
+end

data/lib/lutaml/uml/constraint.rb

@@ -6,7 +6,17 @@
 module Lutaml
   module Uml
     class Constraint < TopElement
-      attr_accessor :body
+      attribute :body, :string
+      attribute :type, :string
+      attribute :weight, :string
+      attribute :status, :string
+
+      yaml do
+        map "body", to: :body
+        map "type", to: :type
+        map "weight", to: :weight
+        map "status", to: :status
+      end
     end
   end
 end

data/lib/lutaml/uml/data_type.rb

@@ -1,75 +1,59 @@
 # frozen_string_literal: true
 
-require "lutaml/uml/classifier"
+require "lutaml/uml/association"
+require "lutaml/uml/constraint"
+require "lutaml/uml/operation"
+require "lutaml/uml/data_type"
 
 module Lutaml
   module Uml
     class DataType < Classifier
-      include HasMembers
-
-      attr_accessor :nested_classifier,
-                    :is_abstract,
-                    :type
-
-      attr_reader :associations,
-                  :attributes,
-                  :members,
-                  :modifier,
-                  :constraints,
-                  :operations,
-                  :data_types
-
-      def initialize(attributes = {})
-        @nested_classifier = []
-        @stereotype = []
-        @generalization = []
-        @is_abstract = false
-        super
-        @keyword = "dataType"
-      end
-
-      def modifier=(value)
-        @modifier = value.to_s # TODO: Validate?
-      end
-
-      def attributes=(value)
-        @attributes = value.to_a.map do |attr|
-          TopElementAttribute.new(attr)
-        end
-      end
-
-      def associations=(value)
-        @associations = value.to_a.map do |attr|
-          Association.new(attr.to_h.merge(owner_end: name))
-        end
-      end
-
-      def constraints=(value)
-        @constraints = value.to_a.map do |attr|
-          Constraint.new(attr)
-        end
-      end
-
-      def operations=(value)
-        @operations = value.to_a.map do |attr|
-          Operation.new(attr)
+      attribute :nested_classifier, :string, collection: true,
+                                             default: -> { [] }
+      attribute :is_abstract, :boolean, default: false
+      attribute :type, :string
+      attribute :attributes, TopElementAttribute, collection: true
+      attribute :modifier, :string
+      attribute :constraints, Constraint, collection: true
+      attribute :operations, Operation, collection: true
+      attribute :data_types, DataType, collection: true
+      attribute :methods, :string, collection: true, default: -> { [] }
+      attribute :relationships, :string, collection: true, default: -> { [] }
+      attribute :keyword, :string, default: "dataType"
+
+      attribute :associations, Association, collection: true
+
+      yaml do
+        map "nested_classifier", to: :nested_classifier
+        map "is_abstract", to: :is_abstract
+        map "type", to: :type
+
+        map "attributes", to: :attributes
+        map "modifier", to: :modifier
+        map "constraints", to: :constraints
+        map "operations", to: :operations
+        map "data_types", to: :data_types
+
+        map "methods", to: :methods
+        map "relationships", to: :relationships
+
+        map "associations", to: :associations, with: {
+          to: :associations_to_yaml, from: :associations_from_yaml
+        }
+      end
+
+      def associations_to_yaml(model, doc)
+        associations = model.associations.map(&:to_hash)
+        doc["associations"] = associations unless associations.empty?
+      end
+
+      def associations_from_yaml(model, values)
+        associations = values.map do |value|
+          value["owner_end"] = model.name if value["owner_end"].nil?
+          Association.from_yaml(value.to_yaml)
         end
-      end
-
-      def data_types=(value)
-        @data_types = value.to_a.map do |attr|
-          DataType.new(attr)
-        end
-      end
-
-      def methods
-        # @members&.select { |member| member.class == Method }
-        []
-      end
 
-      def relationships
-        # @members&.select { |member| member.class == ClassRelationship }
-        []
+        model.associations = associations
       end
     end
   end

data/lib/lutaml/uml/dependency.rb

@@ -6,15 +6,12 @@
 module Lutaml
   module Uml
     class Dependency < TopElement
-      attr_accessor :client, :supplier
+      attribute :client, :string, collection: true, default: -> { [] }
+      attribute :supplier, :string, collection: true, default: -> { [] }
 
-      def initialize # rubocop:disable Lint/MissingSuper
-        @name = nil
-        @xmi_id = nil
-        @xmi_uuid = nil
-        @client = []
-        @supplier = []
-        @namespace = nil
+      yaml do
+        map "client", to: :client
+        map "supplier", to: :supplier
       end
     end
   end

data/lib/lutaml/uml/document.rb

@@ -1,82 +1,55 @@
 # frozen_string_literal: true
 
-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"
-
 module Lutaml
   module Uml
-    class Document
-      include HasAttributes
-      include HasMembers
-
-      attr_accessor :name,
-                    :title,
-                    :caption,
-                    :groups,
-                    :fidelity,
-                    :fontname,
-                    :comments
-
-      # rubocop:disable Rails/ActiveRecordAliases
-      def initialize(attributes = {})
-        update_attributes(attributes)
-      end
-
-      # rubocop:enable Rails/ActiveRecordAliases
-      def classes=(value)
-        @classes = value.to_a.map { |attributes| Class.new(attributes) }
-      end
-
-      def data_types=(value)
-        @data_types = value.to_a.map { |attributes| DataType.new(attributes) }
-      end
-
-      def enums=(value)
-        @enums = value.to_a.map { |attributes| Enum.new(attributes) }
-      end
-
-      def packages=(value)
-        @packages = value.to_a.map { |attributes| Package.new(attributes) }
-      end
-
-      def primitives=(value)
-        @primitives = value.to_a.map do |attributes|
-          PrimitiveType.new(attributes)
+    class Document < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :title, :string
+      attribute :caption, :string
+      attribute :groups, Group, collection: true
+      attribute :fidelity, Fidelity
+      attribute :fontname, :string
+      attribute :comments, :string, collection: true
+
+      attribute :classes, Class, collection: true, default: -> { [] }
+      attribute :data_types, DataType, collection: true, default: -> { [] }
+      attribute :enums, Enum, collection: true, default: -> { [] }
+      attribute :packages, Package, collection: true, default: -> { [] }
+      attribute :primitives, PrimitiveType, collection: true, default: -> { [] }
+      attribute :associations, Association, collection: true, default: -> { [] }
+
+      yaml do
+        map "name", to: :name
+        map "title", to: :title
+        map "caption", to: :caption
+        map "groups", to: :groups
+        map "fidelity", to: :fidelity
+        map "fontname", to: :fontname
+        map "comments", to: :comments
+
+        map "classes", to: :classes
+        map "data_types", to: :data_types
+        map "enums", to: :enums
+        map "packages", to: :packages
+        map "primitives", to: :primitives
+
+        map "associations", to: :associations, with: {
+          to: :associations_to_yaml, from: :associations_from_yaml
+        }
+      end
+
+      def associations_to_yaml(model, doc)
+        associations = model.associations.map(&:to_hash)
+        doc["associations"] = associations unless associations.empty?
+      end
+
+      def associations_from_yaml(model, values)
+        associations = values.map do |value|
+          value["owner_end"] = model.name if value["owner_end"].nil?
+          Association.from_yaml(value.to_yaml)
         end
-      end
-
-      def associations=(value)
-        @associations = value.to_a.map do |attributes|
-          Association.new(attributes)
-        end
-      end
-
-      def classes
-        @classes || []
-      end
-
-      def enums
-        @enums || []
-      end
-
-      def data_types
-        @data_types || []
-      end
-
-      def packages
-        @packages || []
-      end
-
-      def primitives
-        @primitives || []
-      end
 
-      def associations
-        @associations || []
+        model.associations = associations
       end
     end
   end

data/lib/lutaml/uml/enum.rb

@@ -1,44 +1,21 @@
 # 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
+      attribute :attributes, TopElementAttribute, collection: true,
+                                                  default: -> { [] }
+      attribute :modifier, :string
+      attribute :keyword, :string, default: "enumeration"
+      attribute :values, Value, collection: true, default: -> { [] }
+      attribute :methods, :string, collection: true, default: -> { [] }
 
-      # TODO: reserved name, change
-      def methods
-        []
+      yaml do
+        map "attributes", to: :attributes
+        map "modifier", to: :modifier
+        map "keyword", to: :keyword
+        map "values", to: :values
+        map "methods", to: :methods
       end
     end
   end

data/lib/lutaml/uml/event.rb

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

data/lib/lutaml/uml/fidelity.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Uml
+    class Fidelity < Lutaml::Model::Serializable
+      attribute :hideMembers, :boolean
+      attribute :hideOtherClasses, :boolean
+    end
+  end
+end

data/lib/lutaml/uml/group.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Uml
+    class Group < Lutaml::Model::Serializable
+      attribute :id, :string
+      attribute :values, :string, collection: true
+      attribute :groups, Group, collection: true
+
+      yaml do
+        map "id", to: :id
+        map "values", to: :values
+        map "groups", to: :groups
+      end
+    end
+  end
+end

data/lib/lutaml/uml/instance.rb

@@ -3,14 +3,12 @@
 module Lutaml
   module Uml
     class Instance < TopElement
-      attr_accessor :classifier, :slot
+      attribute :classifier, :string
+      attribute :slot, :string, collection: true, default: -> { [] }
 
-      def initialize # rubocop:disable Lint/MissingSuper
-        @name = nil
-        @xmi_id = nil
-        @xmi_uuid = nil
-        @classifier = nil
-        @slot = []
+      yaml do
+        map "classifier", to: :classifier
+        map "slot", to: :slot
       end
     end
   end

data/lib/lutaml/uml/model.rb

@@ -3,10 +3,10 @@
 module Lutaml
   module Uml
     class Model < Package
-      attr_accessor :viewpoint
+      attribute :viewpoint, :string
 
-      def initialize # rubocop:disable Lint/MissingSuper
-        @contents = []
+      yaml do
+        map "viewpoint", to: :viewpoint
       end
     end
   end

data/lib/lutaml/uml/namespace.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Uml
+    class NameSpace < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :namespace, NameSpace
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module Lutaml
   module Uml
     module Node
       class Base
-        include HasAttributes
+        include ::Lutaml::Uml::HasAttributes
 
         # rubocop:disable Rails/ActiveRecordAliases
         def initialize(attributes = {})