lutaml 0.9.39 → 0.9.41

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 = {})

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