lutaml 0.7.7 → 0.8.0

data/lib/lutaml/uml/formatter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Uml
+    module Formatter
+      class << self
+        def all
+          @all ||= []
+        end
+
+        def find_by_name(name)
+          name = name.to_sym
+
+          all.detect { |formatter_class| formatter_class.name == name }
+        end
+      end
+    end
+  end
+end
+
+require "lutaml/uml/formatter/graphviz"

data/lib/lutaml/uml/has_attributes.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Uml
+    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)
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/uml/has_members.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Uml
+    module HasMembers
+      class UnknownMemberTypeError < StandardError; end
+
+      # TODO: move to Parslet::Transform
+      def members=(value)
+        value.group_by { |member| member.keys.first }
+          .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)
+            end
+
+            public_send("#{associtaion_type(type)}=", attribute_value)
+          end
+      end
+
+      private
+
+      def associtaion_type(type)
+        return type if respond_to?("#{type}=")
+
+        raise(UnknownMemberTypeError, "Unknown member type: #{type}")
+      end
+    end
+  end
+end

data/lib/lutaml/uml/instance.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Uml
+    class Instance < TopElement
+      attr_accessor :classifier, :slot
+
+      def initialize
+        @name = nil
+        @xmi_id = nil
+        @xmi_uuid = nil
+        @classifier = nil
+        @slot = []
+      end
+    end
+  end
+end

data/lib/lutaml/uml/model.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Uml
+    class Model < Package
+      attr_accessor :viewpoint
+
+      def initialize
+        @contents = []
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "lutaml/uml/has_attributes"
+
+module Lutaml
+  module Uml
+    module Node
+      class Base
+        include HasAttributes
+
+        # rubocop:disable Rails/ActiveRecordAliases
+        def initialize(attributes = {})
+          update_attributes(attributes)
+        end
+        # rubocop:enable Rails/ActiveRecordAliases
+
+        attr_accessor :parent
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "lutaml/uml/node/base"
+require "lutaml/uml/node/field"
+require "lutaml/uml/node/method"
+require "lutaml/uml/node/relationship"
+require "lutaml/uml/node/class_relationship"
+require "lutaml/uml/node/has_name"
+
+module Lutaml
+  module Uml
+    module Node
+      class ClassNode < Base
+        include HasName
+
+        attr_reader :modifier
+
+        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
+            attributes = member.to_a[0][1]
+            attributes[:parent] = self
+
+            case type
+            when :field              then Field.new(attributes)
+            when :method             then Method.new(attributes)
+            when :relationship       then Relationship.new(attributes)
+            when :class_relationship then ClassRelationship.new(attributes)
+            end
+          end
+        end
+
+        def fields
+          @members.select { |member| member.class == Field }
+        end
+
+        def methods
+          @members.select { |member| member.class == Method }
+        end
+
+        def relationships
+          @members.select { |member| member.class == Relationship }
+        end
+
+        def class_relationships
+          @members.select { |member| member.class == ClassRelationship }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "lutaml/uml/node/relationship"
+require "lutaml/uml/node/has_name"
+
+module Lutaml
+  module Uml
+    module Node
+      class ClassRelationship < Relationship
+        include HasName
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "lutaml/uml/node/base"
+require "lutaml/uml/node/class_node"
+
+module Lutaml
+  module Uml
+    module Node
+      class Document < Base
+        attr_reader :classes
+
+        def classes=(value)
+          @classes = value.to_a.map { |attributes| ClassNode.new(attributes) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "lutaml/uml/node/base"
+require "lutaml/uml/node/has_name"
+require "lutaml/uml/node/has_type"
+
+module Lutaml
+  module Uml
+    module Node
+      class Field < Base
+        include HasName
+        include HasType
+
+        def initialize(attributes = {})
+          @access = "public"
+
+          super
+        end
+
+        attr_reader :static
+
+        def static=(value)
+          @static = !!value
+        end
+
+        attr_reader :access
+
+        def access=(value)
+          @access = value.to_s # TODO: Validate?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Uml
+    module Node
+      module HasName
+        attr_reader :name
+
+        def name=(value)
+          @name = value.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Uml
+    module Node
+      module HasType
+        attr_reader :type
+
+        def type=(value)
+          @type = value.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "lutaml/uml/node/field"
+require "lutaml/uml/node/method_argument"
+require "lutaml/uml/node/has_name"
+
+module Lutaml
+  module Uml
+    module Node
+      class Method < Field
+        include HasName
+
+        attr_reader :abstract
+
+        def abstract=(value)
+          @abstract = !!value
+        end
+
+        attr_reader :arguments
+
+        def arguments=(value)
+          @arguments = value.to_a.map do |attributes|
+            MethodArgument.new(attributes)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "lutaml/uml/node/base"
+require "lutaml/uml/node/has_name"
+require "lutaml/uml/node/has_type"
+
+module Lutaml
+  module Uml
+    module Node
+      class MethodArgument < Base
+        include HasName
+        include HasType
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "lutaml/uml/node/base"
+require "lutaml/uml/node/has_name"
+require "lutaml/uml/node/has_type"
+
+module Lutaml
+  module Uml
+    module Node
+      class Relationship < Base
+        include HasName
+        include HasType
+
+        attr_reader :from
+
+        def from=(value)
+          @from = value.to_s
+        end
+
+        attr_reader :to
+
+        def to=(value)
+          @to = value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/uml/opaque_behavior.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+##
+## Behaviour metamodel
+##
+module Lutaml
+  module Uml
+    class OpaqueBehavior < Behavior
+    end
+  end
+end

data/lib/lutaml/uml/operation.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Uml
+    class Operation
+      include HasAttributes
+      include HasMembers
+
+      attr_accessor :definition,
+                    :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")
+      end
+    end
+  end
+end

data/lib/lutaml/uml/package.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Uml
+    class Package < TopElement
+      include HasAttributes
+
+      attr_accessor :imports, :contents
+      attr_reader :classes, :enums, :data_types, :children_packages
+
+      def initialize(attributes)
+        update_attributes(attributes)
+        @children_packages ||= packages.map { |pkg| [pkg, pkg.packages, pkg.packages.map(&:children_packages)] }.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/attribute.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Lutaml
+  module Uml
+    module Parsers
+      class Attribute < Parslet::Parser
+        class Transform < Parslet::Transform
+          rule(integer: simple(:x)) { Integer(x) }
+          rule(float: simple(:x)) { Float(x) }
+          rule(string: simple(:x)) { String(x) }
+        end
+
+        def self.parse(io, options = {})
+          new.parse(io, options)
+        end
+
+        def parse(io, options = {})
+          tree = Transform.new.apply(super)
+          tree = tree[:assignments].each_with_object({}) do |assignment, memo|
+            memo[assignment[:name].to_s] = assignment[:value]
+          end
+
+          tree
+        end
+
+        rule(:spaces) { match("\s").repeat(1) }
+        rule(:spaces?) { spaces.maybe }
+
+        rule(:digits) { match["0-9"].repeat(1) }
+
+        rule(:integer) do
+          (str("-").maybe >> digits >> str(".").absent?).as(:integer)
+        end
+        rule(:float) do
+          (str("-").maybe >> digits >> str(".") >> digits).as(:float)
+        end
+
+        rule(:string_single_quoted) do
+          str("'") >>
+            (str("'").absent? >> any).repeat.as(:string) >>
+            str("'")
+        end
+        rule(:string_double_quoted) do
+          str('"') >>
+            (str('"').absent? >> any).repeat.as(:string) >>
+            str('"')
+        end
+
+        rule(:string) { string_single_quoted | string_double_quoted }
+
+        rule(:assignment_name) do
+          (match["=\s"].absent? >> any).repeat.as(:name)
+        end
+        rule(:assignment_value) { (integer | float | string).as(:value) }
+        rule(:assignment) do
+          assignment_name >> spaces? >> str("=") >> spaces? >> assignment_value
+        end
+
+        rule(:attribute) { spaces? >> assignment >> spaces? }
+        rule(:attributes) do
+          (attribute >> (str(",") >> attribute).repeat).repeat.as(:assignments)
+        end
+
+        root(:attributes)
+      end
+    end
+  end
+end