lutaml-uml 0.4.3 → 1.0.0

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

@@ -1,413 +0,0 @@
-# frozen_string_literal: true
-
-require "parslet"
-require "parslet/convenience"
-require "lutaml/uml/parsers/dsl_preprocessor"
-require "lutaml/uml/parsers/dsl_transform"
-require "lutaml/uml/node/document"
-
-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
-        #        [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)
-          # https://kschiess.github.io/parslet/tricks.html#Reporter engines
-          # 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)))
-        rescue Parslet::ParseFailed => e
-          raise(ParsingError,
-                "#{e.message}\ncause: #{e.parse_failure_cause.ascii_tree}")
-        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("	") | 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) { match['a-zA-Z0-9_\- \/\+'].repeat(1).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("{") >>
-            ((str("\\") >> any) | (str("}").absent? >> any)).repeat.maybe.as(:definition) >>
-            str('}')
-        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 >>
-            attribute_keyword? >>
-            enum_body?
-        end
-
-        # -- data_type
-        rule(:data_type_keyword) { kw_data_type >> spaces }
-        rule(:data_type_inner_definitions) do
-          definition_body |
-            attribute_definition |
-            comment_definition |
-            comment_multiline_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 >>
-            attribute_keyword? >>
-            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_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

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

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    module Parsers
-      # Class for preprocessing dsl ascii file special directives:
-      # - include
-      class DslPreprocessor
-        attr_reader :input_file
-
-        def initialize(input_file)
-          @input_file = input_file
-        end
-
-        class << self
-          def call(input_file)
-            new(input_file).call
-          end
-        end
-
-        def call
-          include_root = File.dirname(input_file.path)
-          input_file.read.split("\n").reduce([]) do |res, line|
-            res.push(*process_dsl_line(include_root, line))
-          end.join("\n")
-        end
-
-        private
-
-        def process_dsl_line(include_root, line)
-          process_include_line(include_root, process_comment_line(line))
-        end
-
-        def process_comment_line(line)
-          has_comment = line.match(Regexp.new("//.+"))
-          return line if has_comment.nil?
-
-          line.gsub(Regexp.new("//.+"), "")
-        end
-
-        def process_include_line(include_root, line)
-          include_path_match = line.match(/^\s*include\s+(.+)/)
-          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")
-        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")
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require "parslet"
-
-module Lutaml
-  module Uml
-    module Parsers
-      # Class for additional transformations of LutaML syntax:
-      # visibility modifier etc
-      class DslTransform < Parslet::Transform
-        rule(visibility_modifier: simple(:visibility_value)) do
-          case visibility_value
-          when "-"
-            "private"
-          when "#"
-            "protected"
-          when "~"
-            "friendly"
-          else
-            "public"
-          end
-        end
-        rule(simple(:member)) { member.nil? ? member : member.to_s.strip }
-      end
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require "yaml"
-require "lutaml/uml/class"
-require "lutaml/uml/document"
-require "lutaml/uml/serializers/yaml_view"
-
-module Lutaml
-  module Uml
-    module Parsers
-      class Yaml
-        def self.parse(yaml_path, options = {})
-          new.parse(yaml_path, options)
-        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
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml/port.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Port < Property
-    end
-  end
-end

data/lib/lutaml/uml/primitive_type.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class PrimitiveType < DataType
-      attr_reader :keyword
-
-      def initialize(attributes = {})
-        super
-        @keyword = "primitive"
-      end
-    end
-  end
-end

data/lib/lutaml/uml/property.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Property < TopElement
-      attr_accessor :type,
-                    :aggregation,
-                    :association,
-                    :is_derived,
-                    :lowerValue,
-                    :upperValue
-
-      def initialize
-        @name = nil
-        @xmi_id = nil
-        @xmi_uuid = nil
-        @aggregation = nil
-        @association = nil
-        @namespace = nil
-        @is_derived = false
-        @visibility = "public"
-        @lowerValue = "1"
-        @upperValue = "1"
-      end
-    end
-  end
-end

data/lib/lutaml/uml/pseudostate.rb

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

data/lib/lutaml/uml/realization.rb

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

data/lib/lutaml/uml/region.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-##
-## Behaviour metamodel
-##
-
-module Lutaml
-  module Uml
-    class Region < TopElement
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/uml/serializers/base"
-require "lutaml/uml/serializers/class"
-
-module Lutaml
-  module Uml
-    module Serializers
-      class Association < Base
-        property :member_end, from: :target
-        property :member_end_attribute_name,
-                 from: "relationship",
-                 transform_with: (lambda do |val|
-                   val.dig("target", "attributes")&.keys&.first ||
-                    val.dig("target", "attribute")&.keys&.first
-                 end)
-        property :member_end_cardinality,
-                 from: "relationship",
-                 transform_with: (lambda do |val|
-                   res = val.dig("source", "attributes")&.values&.first ||
-                          val.dig("source", "attribute")&.values&.first
-                   res["cardinality"] if res
-                 end)
-        property :member_end_type,
-                 from: "relationship",
-                 transform_with: (lambda do |val|
-                   val.dig("target", "type")
-                 end)
-        property :owner_end_attribute_name,
-                 from: "relationship",
-                 transform_with: (lambda do |val|
-                   val.dig("source", "attributes")&.keys&.first ||
-                     val.dig("source", "attribute")&.keys&.first
-                 end)
-        property :owner_end_cardinality,
-                 from: "relationship",
-                 transform_with: (lambda do |val|
-                   res = val.dig("source", "attributes")&.values&.first ||
-                           val.dig("source", "attribute")&.values&.first
-                   res["cardinality"] if res
-                 end)
-        property :owner_end_type,
-                 from: "relationship",
-                 transform_with: (lambda do |val|
-                   val.dig("source", "type")
-                 end)
-        property :action,
-                 transform_with: (lambda do |val|
-                   if val["direction"] == "target"
-                     "#{val['verb']} ▶"
-                   else
-                     "◀ #{val['verb']}"
-                   end
-                 end)
-      end
-    end
-  end
-end