lutaml-uml 0.1.0 → 0.2.4

data/lib/lutaml/uml/lutaml_path/document_wrapper.rb

@@ -0,0 +1,15 @@
+require "lutaml/lutaml_path/document_wrapper"
+
+module Lutaml
+  module Uml
+    module LutamlPath
+      class DocumentWrapper < ::Lutaml::LutamlPath::DocumentWrapper
+        protected
+
+        def serialize_document(document)
+          serialize_to_hash(document)
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/uml/model.rb

@@ -1,10 +1,13 @@
-module Lutaml::Uml
+# frozen_string_literal: true
 
-class Model < Package
-	attr_accessor :viewpoint
-	def initialize
-		@contents = []
-	end
-end
+module Lutaml
+  module Uml
+    class Model < Package
+      attr_accessor :viewpoint
 
-end
+      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

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

data/lib/lutaml/uml/package.rb

@@ -1,16 +1,19 @@
-module Lutaml::Uml
+# frozen_string_literal: true
 
-  class Package < TopElement
-  	attr_accessor :imports, :contents
-  	def initialize
-  		@imports = []
-  		@contents = []
-  		@name = nil
-  		@xmi_id = nil
-  		@xmi_uuid = nil
-  		@namespace = nil
-  		@href = nil
-  	end
-  end
+module Lutaml
+  module Uml
+    class Package < TopElement
+      attr_accessor :imports, :contents
 
+      def initialize
+        @imports = []
+        @contents = []
+        @name = nil
+        @xmi_id = nil
+        @xmi_uuid = nil
+        @namespace = nil
+        @href = nil
+      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

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

@@ -0,0 +1,399 @@
+# frozen_string_literal: true
+
+require "parslet"
+require "lutaml/uml/parsers/dsl_preprocessor"
+require "lutaml/uml/parsers/dsl_transform"
+require "lutaml/uml/node/document"
+
+module Lutaml
+  module Uml
+    module Parsers
+      # Class for parsing LutaML dsl into Lutaml::Uml::Document
+      class Dsl < Parslet::Parser
+        # @param [String] io - LutaML string representation
+        #        [Hash] options - options for parsing
+        #
+        # @return [Lutaml::Uml::Document]
+        def self.parse(io, options = {})
+          new.parse(io, options)
+        end
+
+        def parse(input_file, _options = {})
+          data = Lutaml::Uml::Parsers::DslPreprocessor.call(input_file)
+          ::Lutaml::Uml::Document.new(DslTransform.new.apply(super(data)))
+        end
+
+        KEYWORDS = %w[
+          abstract
+          aggregation
+          association
+          association
+          attribute
+          bidirectional
+          class
+          composition
+          data_type
+          dependency
+          diagram
+          directional
+          enum
+          fontname
+          generalizes
+          include
+          interface
+          member
+          member_type
+          method
+          owner
+          owner_type
+          primitive
+          private
+          protected
+          public
+          realizes
+          static
+          title
+          caption
+        ].freeze
+
+        KEYWORDS.each do |keyword|
+          rule("kw_#{keyword}") { str(keyword) }
+        end
+
+        rule(:spaces) { match("\s").repeat(1) }
+        rule(:spaces?) { spaces.maybe }
+        rule(:whitespace) do
+          (match("\s") | match("\r?\n") | match("\r") | str(";")).repeat(1)
+        end
+        rule(:whitespace?) { whitespace.maybe }
+        rule(:name) { match["a-zA-Z0-9 _-"].repeat(1) }
+        rule(:newline) { str("\n") >> str("\r").maybe }
+        rule(:comment_definition) do
+          spaces? >> str("**") >> (newline.absent? >> any).repeat.as(:comments)
+        end
+        rule(:comment_multiline_definition) do
+          spaces? >> str("*|") >> (str("|*").absent? >> any).repeat.as(:comments) >> whitespace? >> str("|*")
+        end
+        rule(:class_name_chars) { match('(?:[a-zA-Z0-9 _-]|\:|\.)').repeat(1) }
+        rule(:class_name) do
+          class_name_chars >>
+            (str("(") >>
+              class_name_chars >>
+              str(")")).maybe
+        end
+        rule(:cardinality_body_definition) do
+          match['0-9\*'].as(:min) >>
+            str("..").maybe >>
+            match['0-9\*'].as(:max).maybe
+        end
+        rule(:cardinality) do
+          str("[") >>
+            cardinality_body_definition.as(:cardinality) >>
+            str("]")
+        end
+        rule(:cardinality?) { cardinality.maybe }
+
+        # -- attribute/Method
+        rule(:kw_visibility_modifier) do
+          str("+") | str("-") | str("#") | str("~")
+        end
+
+        rule(:member_static) { (kw_static.as(:static) >> spaces).maybe }
+        rule(:visibility) do
+          kw_visibility_modifier.as(:visibility_modifier)
+        end
+        rule(:visibility?) { visibility.maybe }
+
+        rule(:method_abstract) { (kw_abstract.as(:abstract) >> spaces).maybe }
+        rule(:attribute_keyword) do
+          str("<<") >>
+            match['a-zA-Z0-9_\-\/'].repeat(1).as(:keyword) >>
+            str(">>")
+        end
+        rule(:attribute_keyword?) { attribute_keyword.maybe }
+        rule(:attribute_type) do
+          (str(":") >>
+            spaces? >>
+            attribute_keyword? >>
+            spaces? >>
+            match['"\''].maybe >>
+            match['a-zA-Z0-9_\- '].repeat(1).as(:type) >>
+            match['"\''].maybe >>
+            spaces?
+          )
+        end
+        rule(:attribute_type?) do
+          attribute_type.maybe
+        end
+
+        rule(:attribute_name) { name.as(:name) }
+        rule(:attribute_definition) do
+          (visibility?.as(:visibility) >>
+            match['"\''].maybe >>
+            attribute_name >>
+            match['"\''].maybe >>
+            attribute_type? >>
+            cardinality? >>
+            class_body?)
+            .as(:attributes)
+        end
+
+        rule(:title_keyword) { kw_title >> spaces }
+        rule(:title_text) do
+          match['"\''].maybe >>
+            match['a-zA-Z0-9_\- '].repeat(1).as(:title) >>
+            match['"\''].maybe
+        end
+        rule(:title_definition) { title_keyword >> title_text }
+        rule(:caption_keyword) { kw_caption >> spaces }
+        rule(:caption_text) do
+          match['"\''].maybe >>
+            match['a-zA-Z0-9_\- '].repeat(1).as(:caption) >>
+            match['"\''].maybe
+        end
+        rule(:caption_definition) { caption_keyword >> caption_text }
+
+        rule(:fontname_keyword) { kw_fontname >> spaces }
+        rule(:fontname_text) do
+          match['"\''].maybe >>
+            match['a-zA-Z0-9_\- '].repeat(1).as(:fontname) >>
+            match['"\''].maybe
+        end
+        rule(:fontname_definition) { fontname_keyword >> fontname_text }
+
+        # Method
+        # rule(:method_keyword) { kw_method >> spaces }
+        # rule(:method_argument) { name.as(:name) >> member_type }
+        # rule(:method_arguments_inner) do
+        #   (method_argument >>
+        #     (spaces? >> str(",") >> spaces? >> method_argument).repeat)
+        #     .repeat.as(:arguments)
+        # end
+        # rule(:method_arguments) do
+        #   (str("(") >>
+        #     spaces? >>
+        #     method_arguments_inner >>
+        #     spaces? >>
+        #     str(")"))
+        #     .maybe
+        # end
+
+        # rule(:method_name) { name.as(:name) }
+        # rule(:method_return_type) { member_type.maybe }
+        # rule(:method_definition) do
+        #   (method_abstract >>
+        #     member_static >>
+        #     visibility >>
+        #     method_keyword >>
+        #     method_name >>
+        #     method_arguments >>
+        #     method_return_type)
+        #     .as(:method)
+        # end
+
+        # -- Association
+
+        rule(:association_keyword) { kw_association >> spaces }
+
+        %w[owner member].each do |association_end_type|
+          rule("#{association_end_type}_cardinality") do
+            spaces? >>
+              str("[") >>
+              cardinality_body_definition
+              .as("#{association_end_type}_end_cardinality") >>
+              str("]")
+          end
+          rule("#{association_end_type}_cardinality?") do
+            send("#{association_end_type}_cardinality").maybe
+          end
+          rule("#{association_end_type}_attribute_name") do
+            str("#") >>
+              visibility? >>
+              name.as("#{association_end_type}_end_attribute_name")
+          end
+          rule("#{association_end_type}_attribute_name?") do
+            send("#{association_end_type}_attribute_name").maybe
+          end
+          rule("#{association_end_type}_definition") do
+            send("kw_#{association_end_type}") >>
+              spaces >>
+              name.as("#{association_end_type}_end") >>
+              send("#{association_end_type}_attribute_name?") >>
+              send("#{association_end_type}_cardinality?")
+          end
+          rule("#{association_end_type}_type") do
+            send("kw_#{association_end_type}_type") >>
+              spaces >>
+              name.as("#{association_end_type}_end_type")
+          end
+        end
+
+        rule(:association_inner_definitions) do
+          owner_type |
+            member_type |
+            owner_definition |
+            member_definition |
+            comment_definition |
+            comment_multiline_definition
+        end
+        rule(:association_inner_definition) do
+          association_inner_definitions >> whitespace?
+        end
+        rule(:association_body) do
+          spaces? >>
+            str("{") >>
+            whitespace? >>
+            association_inner_definition.repeat.as(:members) >>
+            str("}")
+        end
+        rule(:association_definition) do
+          association_keyword >>
+            name.as(:name).maybe >>
+            association_body
+        end
+
+        # -- Class
+
+        rule(:kw_class_modifier) { kw_abstract | kw_interface }
+
+        rule(:class_modifier) do
+          (kw_class_modifier.as(:modifier) >> spaces).maybe
+        end
+        rule(:class_keyword) { kw_class >> spaces }
+        rule(:class_inner_definitions) do
+          definition_body |
+            attribute_definition |
+            comment_definition |
+            comment_multiline_definition
+        end
+        rule(:class_inner_definition) do
+          class_inner_definitions >> whitespace?
+        end
+        rule(:class_body) do
+          spaces? >>
+            str("{") >>
+            whitespace? >>
+            class_inner_definition.repeat.as(:members) >>
+            str("}")
+        end
+        rule(:class_body?) { class_body.maybe }
+        rule(:class_definition) do
+          class_modifier >>
+            class_keyword >>
+            class_name.as(:name) >>
+            spaces? >>
+            attribute_keyword? >>
+            class_body?
+        end
+
+        # -- Definition
+        rule(:definition_body) do
+          spaces? >>
+            str("definition") >>
+            whitespace? >>
+            (str("end definition").absent? >> any).repeat.as(:definition) >>
+            whitespace? >>
+            str("end definition")
+        end
+
+        # -- Enum
+        rule(:enum_keyword) { kw_enum >> spaces }
+        rule(:enum_inner_definitions) do
+          definition_body |
+            attribute_definition |
+            comment_definition |
+            comment_multiline_definition
+        end
+        rule(:enum_inner_definition) do
+          enum_inner_definitions >> whitespace?
+        end
+        rule(:enum_body) do
+          spaces? >>
+            str("{") >>
+            whitespace? >>
+            enum_inner_definition.repeat.as(:members) >>
+            str("}")
+        end
+        rule(:enum_body?) { enum_body.maybe }
+        rule(:enum_definition) do
+          enum_keyword >>
+            match['"\''].maybe >>
+            class_name.as(:name) >>
+            match['"\''].maybe >>
+            enum_body?
+        end
+
+        # -- data_type
+        rule(:data_type_keyword) { kw_data_type >> spaces }
+        rule(:data_type_inner_definitions) do
+          attribute_definition
+        end
+        rule(:data_type_inner_definition) do
+          data_type_inner_definitions >> whitespace?
+        end
+        rule(:data_type_body) do
+          spaces? >>
+            str("{") >>
+            whitespace? >>
+            data_type_inner_definition.repeat.as(:members) >>
+            str("}")
+        end
+        rule(:data_type_body?) { data_type_body.maybe }
+        rule(:data_type_definition) do
+          data_type_keyword >>
+            match['"\''].maybe >>
+            class_name.as(:name) >>
+            match['"\''].maybe >>
+            data_type_body?
+        end
+
+        # -- primitive
+        rule(:primitive_keyword) { kw_primitive >> spaces }
+        rule(:primitive_definition) do
+          primitive_keyword >>
+            match['"\''].maybe >>
+            class_name.as(:name) >>
+            match['"\''].maybe
+        end
+
+        # -- Diagram
+        rule(:diagram_keyword) { kw_diagram >> spaces? }
+        rule(:diagram_inner_definitions) do
+          title_definition |
+            caption_definition |
+            fontname_definition |
+            class_definition.as(:classes) |
+            enum_definition.as(:enums) |
+            primitive_definition.as(:primitives) |
+            data_type_definition.as(:data_types) |
+            association_definition.as(:associations) |
+            comment_definition |
+            comment_multiline_definition
+        end
+        rule(:diagram_inner_definition) do
+          diagram_inner_definitions >> whitespace?
+        end
+        rule(:diagram_body) do
+          spaces? >>
+            str("{") >>
+            whitespace? >>
+            diagram_inner_definition.repeat.as(:members) >>
+            str("}")
+        end
+        rule(:diagram_body?) { diagram_body.maybe }
+        rule(:diagram_definition) do
+          diagram_keyword >>
+            spaces? >>
+            class_name.as(:name) >>
+            diagram_body? >>
+            whitespace?
+        end
+        rule(:diagram_definitions) { diagram_definition >> whitespace? }
+        rule(:diagram) { whitespace? >> diagram_definition }
+        # -- Root
+
+        root(:diagram)
+      end
+    end
+  end
+end