lutaml 0.9.28 → 0.9.29

data/lib/lutaml/sysml.rb

@@ -1,6 +1,6 @@
 require "lutaml/sysml/version"
 require "lutaml/uml"
-require 'nokogiri'
+require "nokogiri"
 
 module Lutaml
   module Sysml

data/lib/lutaml/uml/association.rb

@@ -25,17 +25,18 @@ module Lutaml
             if %w[owner_end member_end].include?(type)
               group.each do |member|
                 member.each_pair do |key, member_value|
-                  public_send("#{associtaion_type(key)}=", member_value)
+                  public_send(:"#{associtaion_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("#{associtaion_type(type)}=", attribute_value.first)
+              next public_send(:"#{associtaion_type(type)}=",
+                               attribute_value.first)
             end
 
-            public_send("#{associtaion_type(type)}=", attribute_value)
+            public_send(:"#{associtaion_type(type)}=", attribute_value)
           end
       end
     end

data/lib/lutaml/uml/data_type.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "lutaml/uml/classifier"
 
 module Lutaml

data/lib/lutaml/uml/document.rb

@@ -26,6 +26,7 @@ module Lutaml
       def initialize(attributes = {})
         update_attributes(attributes)
       end
+
       # rubocop:enable Rails/ActiveRecordAliases
       def classes=(value)
         @classes = value.to_a.map { |attributes| Class.new(attributes) }
@@ -44,7 +45,9 @@ module Lutaml
       end
 
       def primitives=(value)
-        @primitives = value.to_a.map { |attributes| PrimitiveType.new(attributes) }
+        @primitives = value.to_a.map do |attributes|
+          PrimitiveType.new(attributes)
+        end
       end
 
       def associations=(value)

data/lib/lutaml/uml/formatter/graphviz.rb

@@ -18,11 +18,11 @@ module Lutaml
         end
 
         ACCESS_SYMBOLS = {
-          "public"    => "+",
+          "public" => "+",
           "protected" => "#",
-          "private"   => "-",
+          "private" => "-",
         }.freeze
-        DEFAULT_CLASS_FONT = "Helvetica".freeze
+        DEFAULT_CLASS_FONT = "Helvetica"
 
         VALID_TYPES = %i[
           dot
@@ -66,9 +66,7 @@ module Lutaml
           @type = :dot
         end
 
-        attr_reader :graph
-        attr_reader :edge
-        attr_reader :node
+        attr_reader :graph, :edge, :node
 
         def type=(value)
           super
@@ -84,10 +82,10 @@ module Lutaml
 
         def escape_html_chars(text)
           text
-            .gsub(/</, "&#60;")
-            .gsub(/>/, "&#62;")
-            .gsub(/\[/, "&#91;")
-            .gsub(/\]/, "&#93;")
+            .gsub("<", "&#60;")
+            .gsub(">", "&#62;")
+            .gsub("[", "&#91;")
+            .gsub("]", "&#93;")
         end
 
         def format_field(node)
@@ -200,7 +198,7 @@ module Lutaml
         end
 
         def format_member_rows(members, hide_members)
-          unless !hide_members && members && members.length.positive?
+          unless !hide_members && members&.length&.positive?
             return <<~HEREDOC.chomp
               <TABLE BORDER="0" CELLPADDING="0" CELLSPACING="0">
                 <TR><TD ALIGN="LEFT"></TD></TR>
@@ -213,10 +211,10 @@ module Lutaml
           end
           field_table = <<~HEREDOC.chomp
             <TABLE BORDER="0" CELLPADDING="0" CELLSPACING="0">
-              #{field_rows.map { |row| ' ' * 10 + row }.join("\n")}
+              #{field_rows.map { |row| (' ' * 10) + row }.join("\n")}
             </TABLE>
           HEREDOC
-          field_table << "\n" << " " * 6
+          field_table << "\n" << (" " * 6)
           field_table
         end
 

data/lib/lutaml/uml/has_attributes.rb

@@ -5,8 +5,8 @@ module Lutaml
     module HasAttributes
       def update_attributes(attributes = {})
         attributes.to_h.each do |name, value|
-          value = value.respond_to?(:str) ? value.str : value
-          public_send("#{name}=", value)
+          value = value.str if value.respond_to?(:str)
+          public_send(:"#{name}=", value)
         end
       end
     end

data/lib/lutaml/uml/has_members.rb

@@ -11,17 +11,18 @@ module Lutaml
           .each do |(type, group)|
             attribute_value = group.map(&:values).flatten
             if attribute_value.length == 1 && !attribute_value.first.is_a?(Hash)
-              next public_send("#{associtaion_type(type)}=", attribute_value.first)
+              next public_send(:"#{associtaion_type(type)}=",
+                               attribute_value.first)
             end
 
-            public_send("#{associtaion_type(type)}=", attribute_value)
+            public_send(:"#{associtaion_type(type)}=", attribute_value)
           end
       end
 
       private
 
       def associtaion_type(type)
-        return type if respond_to?("#{type}=")
+        return type if respond_to?(:"#{type}=")
 
         raise(UnknownMemberTypeError, "Unknown member type: #{type}")
       end

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

@@ -13,14 +13,12 @@ module Lutaml
       class ClassNode < Base
         include HasName
 
-        attr_reader :modifier
+        attr_reader :modifier, :members
 
         def modifier=(value)
           @modifier = value.to_s # TODO: Validate?
         end
 
-        attr_reader :members
-
         def members=(value)
           @members = value.to_a.map do |member|
             type       = member.to_a[0][0] # TODO: This is dumb
@@ -37,19 +35,19 @@ module Lutaml
         end
 
         def fields
-          @members.select { |member| member.class == Field }
+          @members.select { |member| member.instance_of?(Field) }
         end
 
         def methods
-          @members.select { |member| member.class == Method }
+          @members.select { |member| member.instance_of?(Method) }
         end
 
         def relationships
-          @members.select { |member| member.class == Relationship }
+          @members.select { |member| member.instance_of?(Relationship) }
         end
 
         def class_relationships
-          @members.select { |member| member.class == ClassRelationship }
+          @members.select { |member| member.instance_of?(ClassRelationship) }
         end
       end
     end

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

@@ -17,14 +17,12 @@ module Lutaml
           super
         end
 
-        attr_reader :static
+        attr_reader :static, :access
 
         def static=(value)
           @static = !!value
         end
 
-        attr_reader :access
-
         def access=(value)
           @access = value.to_s # TODO: Validate?
         end

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

@@ -10,14 +10,12 @@ module Lutaml
       class Method < Field
         include HasName
 
-        attr_reader :abstract
+        attr_reader :abstract, :arguments
 
         def abstract=(value)
           @abstract = !!value
         end
 
-        attr_reader :arguments
-
         def arguments=(value)
           @arguments = value.to_a.map do |attributes|
             MethodArgument.new(attributes)

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

@@ -11,14 +11,12 @@ module Lutaml
         include HasName
         include HasType
 
-        attr_reader :from
+        attr_reader :from, :to
 
         def from=(value)
           @from = value.to_s
         end
 
-        attr_reader :to
-
         def to=(value)
           @to = value.to_s
         end

data/lib/lutaml/uml/operation.rb

@@ -19,12 +19,12 @@ module Lutaml
 
       def definition=(value)
         @definition = value
-                        .to_s
-                        .gsub(/\\}/, '}')
-                        .gsub(/\\{/, '{')
-                        .split("\n")
-                        .map(&:strip)
-                        .join("\n")
+          .to_s
+          .gsub(/\\}/, "}")
+          .gsub(/\\{/, "{")
+          .split("\n")
+          .map(&:strip)
+          .join("\n")
       end
     end
   end

data/lib/lutaml/uml/package.rb

@@ -10,7 +10,9 @@ module Lutaml
 
       def initialize(attributes)
         update_attributes(attributes)
-        @children_packages ||= packages.map { |pkg| [pkg, pkg.packages, pkg.packages.map(&:children_packages)] }.flatten.uniq
+        @children_packages ||= packages.map do |pkg|
+          [pkg, pkg.packages, pkg.packages.map(&:children_packages)]
+        end.flatten.uniq
       end
 
       def classes=(value)

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

@@ -18,11 +18,9 @@ module Lutaml
 
         def parse(io, options = {})
           tree = Transform.new.apply(super)
-          tree = tree[:assignments].each_with_object({}) do |assignment, memo|
+          tree[:assignments].each_with_object({}) do |assignment, memo|
             memo[assignment[:name].to_s] = assignment[:value]
           end
-
-          tree
         end
 
         rule(:spaces) { match("\s").repeat(1) }

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

@@ -10,6 +10,7 @@ module Lutaml
   module Uml
     module Parsers
       class ParsingError < StandardError; end
+
       # Class for parsing LutaML dsl into Lutaml::Uml::Document
       class Dsl < Parslet::Parser
         # @param [String] io - LutaML string representation
@@ -92,9 +93,9 @@ module Lutaml
               str(")")).maybe
         end
         rule(:cardinality_body_definition) do
-          match['0-9\*'].as('min') >>
+          match['0-9\*'].as("min") >>
             str("..").maybe >>
-            match['0-9\*'].as('max').maybe
+            match['0-9\*'].as("max").maybe
         end
         rule(:cardinality) do
           str("[") >>
@@ -210,11 +211,11 @@ module Lutaml
             spaces? >>
               str("[") >>
               cardinality_body_definition
-              .as("#{association_end_type}_end_cardinality") >>
+                .as("#{association_end_type}_end_cardinality") >>
               str("]")
           end
           rule("#{association_end_type}_cardinality?") do
-            send("#{association_end_type}_cardinality").maybe
+            send(:"#{association_end_type}_cardinality").maybe
           end
           rule("#{association_end_type}_attribute_name") do
             str("#") >>
@@ -222,17 +223,17 @@ module Lutaml
               name.as("#{association_end_type}_end_attribute_name")
           end
           rule("#{association_end_type}_attribute_name?") do
-            send("#{association_end_type}_attribute_name").maybe
+            send(:"#{association_end_type}_attribute_name").maybe
           end
           rule("#{association_end_type}_definition") do
-            send("kw_#{association_end_type}") >>
+            send(:"kw_#{association_end_type}") >>
               spaces >>
               name.as("#{association_end_type}_end") >>
-              send("#{association_end_type}_attribute_name?") >>
-              send("#{association_end_type}_cardinality?")
+              send(:"#{association_end_type}_attribute_name?") >>
+              send(:"#{association_end_type}_cardinality?")
           end
           rule("#{association_end_type}_type") do
-            send("kw_#{association_end_type}_type") >>
+            send(:"kw_#{association_end_type}_type") >>
               spaces >>
               name.as("#{association_end_type}_end_type")
           end
@@ -303,7 +304,7 @@ module Lutaml
             whitespace? >>
             str("{") >>
             ((str("\\") >> any) | (str("}").absent? >> any)).repeat.maybe.as(:definition) >>
-            str('}')
+            str("}")
         end
 
         # -- Enum

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

@@ -43,12 +43,13 @@ module Lutaml
           return line if include_path_match.nil? || line =~ /^\s\*\*/
 
           path_to_file = include_path_match[1].strip
-          path_to_file = if path_to_file.match?(/^\//)
-                           path_to_file
-                         else
-                           File.join(include_root, path_to_file)
-                         end
-          File.read(path_to_file).split("\n").map { |line| process_comment_line(line) }
+          unless path_to_file.match?(/^\//)
+            path_to_file = File.join(include_root,
+                                     path_to_file)
+          end
+          File.read(path_to_file).split("\n").map do |line|
+            process_comment_line(line)
+          end
         rescue Errno::ENOENT
           puts("No such file or directory @ rb_sysopen - #{path_to_file}, \
             include file paths need to be supplied relative to the main document")

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

@@ -33,8 +33,8 @@ module Lutaml
           yaml_content["imports"].map do |(klass_name, _)|
             klass_attrs = YAML.safe_load(
               File.read(
-                File.join(models_path, "#{klass_name}.yml")
-              )
+                File.join(models_path, "#{klass_name}.yml"),
+              ),
             )
             klass_attrs["name"] = klass_name if klass_attrs["name"].nil?
             Lutaml::Uml::Serializers::Class.new(klass_attrs)

data/lib/lutaml/uml/serializers/class.rb

@@ -18,7 +18,7 @@ module Lutaml
                  end)
         property :associations,
                  from: :relations,
-                 coerce: Array[::Lutaml::Uml::Serializers::Association]
+                 coerce: [::Lutaml::Uml::Serializers::Association]
         property :name
         # property :type, from: :modelType
         # property :relations,

data/lib/lutaml/uml/top_element.rb

@@ -33,10 +33,10 @@ module Lutaml
         next_namespace = namespace
 
         while !next_namespace.nil?
-          the_name = if !next_namespace.name.nil?
-                       next_namespace.name + "::" + the_name
+          the_name = if next_namespace.name.nil?
+                       "::#{the_name}"
                      else
-                       "::" + the_name
+                       "#{next_namespace.name}::#{the_name}"
                      end
           next_namespace = next_namespace.namespace
         end
@@ -46,12 +46,12 @@ module Lutaml
 
       def definition=(value)
         @definition = value
-                        .to_s
-                        .gsub(/\\}/, '}')
-                        .gsub(/\\{/, '{')
-                        .split("\n")
-                        .map(&:strip)
-                        .join("\n")
+          .to_s
+          .gsub(/\\}/, "}")
+          .gsub(/\\{/, "{")
+          .split("\n")
+          .map(&:strip)
+          .join("\n")
       end
     end
   end

data/lib/lutaml/uml/top_element_attribute.rb

@@ -27,12 +27,12 @@ module Lutaml
 
       def definition=(value)
         @definition = value
-                        .to_s
-                        .gsub(/\\}/, '}')
-                        .gsub(/\\{/, '{')
-                        .split("\n")
-                        .map(&:strip)
-                        .join("\n")
+          .to_s
+          .gsub(/\\}/, "}")
+          .gsub(/\\{/, "{")
+          .split("\n")
+          .map(&:strip)
+          .join("\n")
       end
     end
   end

data/lib/lutaml/uml/value.rb

@@ -19,12 +19,12 @@ module Lutaml
 
       def definition=(value)
         @definition = value
-                        .to_s
-                        .gsub(/\\}/, '}')
-                        .gsub(/\\{/, '{')
-                        .split("\n")
-                        .map(&:strip)
-                        .join("\n")
+          .to_s
+          .gsub(/\\}/, "}")
+          .gsub(/\\{/, "{")
+          .split("\n")
+          .map(&:strip)
+          .join("\n")
       end
     end
   end

data/lib/lutaml/version.rb

@@ -1,3 +1,3 @@
 module Lutaml
-  VERSION = "0.9.28".freeze
+  VERSION = "0.9.29".freeze
 end

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

@@ -3,44 +3,64 @@
 module Lutaml
   module XMI
     class AssociationDrop < Liquid::Drop
-      def initialize(model) # rubocop:disable Lint/MissingSuper
-        @model = model
+      include Parsers::XMIBase
+
+      def initialize( # rubocop:disable Lint/MissingSuper,Metrics/ParameterLists
+        xmi_id:,
+        member_end:,
+        member_end_type:,
+        member_end_cardinality:,
+        member_end_attribute_name:,
+        member_end_xmi_id:,
+        owner_end:,
+        owner_end_xmi_id:,
+        definition:
+      )
+        @xmi_id = xmi_id
+        @member_end = member_end
+        @member_end_type = member_end_type
+        @member_end_cardinality = member_end_cardinality
+        @member_end_attribute_name = member_end_attribute_name
+        @member_end_xmi_id = member_end_xmi_id
+        @owner_end = owner_end
+        @owner_end_xmi_id = owner_end_xmi_id
+        @definition = definition
       end
 
       def xmi_id
-        @model[:xmi_id]
+        @xmi_id
       end
 
       def member_end
-        @model[:member_end]
+        @member_end
       end
 
       def member_end_type
-        @model[:member_end_type]
+        @member_end_type
       end
 
       def member_end_cardinality
-        ::Lutaml::XMI::CardinalityDrop.new(@model[:member_end_cardinality])
+        ::Lutaml::XMI::CardinalityDrop.new(@member_end_cardinality)
       end
 
       def member_end_attribute_name
-        @model[:member_end_attribute_name]
+        @member_end_attribute_name
       end
 
       def member_end_xmi_id
-        @model[:member_end_xmi_id]
+        @member_end_xmi_id
       end
 
       def owner_end
-        @model[:owner_end]
+        @owner_end
       end
 
       def owner_end_xmi_id
-        @model[:owner_end_xmi_id]
+        @owner_end_xmi_id
       end
 
       def definition
-        @model[:definition]
+        @definition
       end
     end
   end

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

@@ -3,44 +3,62 @@
 module Lutaml
   module XMI
     class AttributeDrop < Liquid::Drop
-      def initialize(model) # rubocop:disable Lint/MissingSuper
+      include Parsers::XMIBase
+
+      def initialize(model, options = {}) # rubocop:disable Lint/MissingSuper
         @model = model
+        @options = options
+        @xmi_root_model = options[:xmi_root_model]
+        @xmi_cache = options[:xmi_cache]
+
+        uml_type = @model.uml_type
+        @uml_type_idref = uml_type.idref if uml_type
       end
 
       def id
-        @model[:id]
+        @model.id
       end
 
       def name
-        @model[:name]
+        @model.name
       end
 
       def type
-        @model[:type]
+        lookup_entity_name(@uml_type_idref) || @uml_type_idref
       end
 
       def xmi_id
-        @model[:xmi_id]
+        @uml_type_idref
       end
 
-      def is_derived
-        @model[:is_derived]
+      def is_derived # rubocop:disable Naming/PredicateName
+        @model.is_derived
       end
 
       def cardinality
-        ::Lutaml::XMI::CardinalityDrop.new(@model[:cardinality])
+        ::Lutaml::XMI::CardinalityDrop.new(@model)
       end
 
       def definition
-        @model[:definition]
+        definition = lookup_attribute_documentation(@model.id)
+
+        if @options[:with_assoc] && @model.association
+          definition = loopup_assoc_def(@model.association)
+        end
+
+        definition
       end
 
       def association
-        @model[:association]
+        if @options[:with_assoc] && @model.association
+          @model.association
+        end
       end
 
       def type_ns
-        @model[:type_ns]
+        if @options[:with_assoc] && @model.association
+          get_ns_by_xmi_id(xmi_id)
+        end
       end
     end
   end

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

@@ -3,16 +3,22 @@
 module Lutaml
   module XMI
     class CardinalityDrop < Liquid::Drop
+      include Parsers::XMIBase
+
       def initialize(model) # rubocop:disable Lint/MissingSuper
         @model = model
       end
 
       def min
-        @model[:min]
+        return @model[:min] if @model.is_a?(Hash)
+
+        @model.lower_value&.value
       end
 
       def max
-        @model[:max]
+        return @model[:max] if @model.is_a?(Hash)
+
+        @model.upper_value&.value
       end
     end
   end