lutaml 0.7.7 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: baef07d33c5aa163875a731b0dcbcf9de336d0bcb6c1066a17d74210e8d26d3a
-  data.tar.gz: b3b000fe77946b863f5ee539319ef777ea14b20de6c607091dcf84c059ccd732
+  metadata.gz: d6709956ec738c3ca16661750783447cc48fadcb00206ab24bbe78ea6109c716
+  data.tar.gz: 5c956576b76701da6bb95e29904bb817604c41f5efcf8210399ea6b2edd3f8cd
 SHA512:
-  metadata.gz: 6319856a0ef1833a797e5d6aba050a83d2d145e16d508f5a9c84cfe9484b958949a5c6ca906a373bbf2786c486b7e684237c49ee907ce21caa5e58c83f0d39a9
-  data.tar.gz: b96dedf55a1689f9213ab9d3add19ceae2c3110953721a99ddf74913b572bfff28406635a6d6b01b33431a8fbc3131971b2d6058aacabce132b7b3b8d1068913
+  metadata.gz: 0bf7f57aedbc5d46efda3413fb3c92137a445ef4e3666e81f440470e299144e91ba57ac714b79e2d2d2920eb525a3b6d562f70b61c687973a2288659e56d4783
+  data.tar.gz: a9faa2d0b5eb4e72f4b1bc0585542da8e47c557cfc51cee66dedf2f1bfc2c0e3ae3b762e0d5fe35fd28dfc5a691d6794243b2ad08576115ea255081873bf93e4

data/.gitignore

@@ -1,12 +1,13 @@
+
 /.bundle/
-/.yardoc
-/_yardoc/
 /coverage/
 /doc/
-/pkg/
-/spec/reports/
-/tmp/
 Gemfile.lock
-
+/ISO_DIS_10303-59
+/pkg/
 # rspec failure tracking
 .rspec_status
+/spec/reports/
+/tmp/
+/.yardoc
+/_yardoc/

data/.rubocop.yml

@@ -8,3 +8,4 @@ inherit_from:
 
 AllCops:
   TargetRubyVersion: 2.5
+  NewCops: enable

data/LUTAML.adoc

@@ -0,0 +1,372 @@
+= LutaML syntax
+
+== `diagram` syntax
+
+`diagram` is a root element for each diagram.
+
+[source,java]
+----
+diagram MyView {
+  title "My diagram"
+  caption "My custom caption"
+  fontname "Helvetica"
+}
+----
+
+where:
+
+* `fontname` - optional, configuration option to use supplied font name
+* `title` - optional, set custom title for diagram
+* `caption` - optional, set custom caption for diagram
+
+== DataTypes
+
+Lutaml supports 3 types of data_types: `data_type`, `primitive` and `enum`.
+
+Example of data types declaration:
+
+[source,java]
+----
+diagram MyView {
+  enum MyEnum {}
+
+  enum AddressClassProfile {
+    +addressClassProfile: CharacterString
+  }
+
+  data_type "Banking Information" {
+    "art code"
+    "CCT Number"
+  }
+
+  primitive Integer
+
+  enum Profile {
+    imlicistAttributeProfile: CharacterString
+    +attributeProfile: CharacterString
+    -privateAttributeProfile: CharacterString
+    ~friendlyAttributeProfile: CharacterString
+    #protectedAttributeProfile: CharacterString
+  }
+}
+----
+
+== Associations
+
+=== Explicit declaration
+
+Syntax:
+
+[source,java]
+----
+association name {
+  owned_type association|composition|aggregation|generalization|uses
+  member_type association|composition|aggregation|generalization|uses
+  owned association_name[#attribute_name] [{property_string}][cardinality]
+  member association_name[#attribute_name] [{property_string}][cardinality]
+}
+----
+
+where:
+
+* `owned_type` - optional, use to define a bidirectional association (`association`|`composition`|`aggregation`|`generalization`|`uses`)
+* `member_type` - association type (`association`|`composition`|`aggregation`|`generalization`|`uses`)
+* `owned|member` - end of association, use `\#attribute_name` to set a role name
+* `property_string` - property string for attibutes associations
+* `cardinality` - examples: '1..*', '*'
+
+Example:
+
+[source,java]
+----
+class Association {
+  +association:
+}
+class Type {
+  +endType:
+}
+
+association AssociatingTypeAndAssociation {
+  type uses
+  from Association#+association {subsets relationship}[*]
+  to Type#+/endType {readOnly, subsets relatedElement} [1..*]
+}
+----
+
+=== Undirected associations
+
+The simplest way to define relationship between two classes is to use `generalize` keyword:
+
+[source,java]
+----
+class Pet {}
+class Cat {
+  generalize Pet
+}
+----
+
+=== Attribute relationship
+
+Derived attribute `relatedElement` can have 1 to many `Element` associated with it through `union`
+
+[source,java]
+----
+class Relationship {
+   +/relatedElement: Element[1..*] {union}
+}
+class Element {}
+----
+
+== Class' multiline "definition" property
+
+=== Definition
+
+Full syntax:
+
+[source,java]
+----
+definition {
+  inner text
+}
+----
+
+
+== Attributes/entries
+
+=== Definition
+
+Full syntax:
+
+[source,java]
+----
+[visibility][/][attribute] name [:type][multiplicity][=initial value][{attribute body}]
+----
+
+where:
+
+* `visibility` can be equal to
+** `-`: private
+** `+`: public
+** `#`: protected
+** `~`: friendly
+
+* `attribute` - attrbute keyword
+* `/` - symbolizes a derived attribute.
+* `multiplicity` -  Multiplicity is in square brackets (e.g. [1..*]).
+* `initial value` - Default value specifies the initial value of the attribute.
+* `{attribute body}` - Body of attribute, additional properties for attribute
+
+
+One can use explicit or implicit syntax for attribute definition
+
+explicit syntax:
+
+[source,java]
+----
+class A {
+  attribute my_attribute
+}
+
+enum A {
+  entry my_val2
+}
+----
+
+implicit syntax:
+
+[source,java]
+----
+class A {
+  my_attribute
+}
+
+enum A {
+  my_val2
+}
+----
+
+[[attribute-visibility]]
+=== Attribute visibility
+
+Syntax for defining visibility: `[+|-|#|~] [attribute] attribute_name`.
+
+LutaML uses these modificators to define attribute (entry) visbility:
+
+`+`:: public
+`-`:: private
+`#`:: protected
+`~`:: package
+
+example:
+
+[source,java]
+----
+class Figure {
+  // Public attribute `radius`
+  + radius
+  // private attribute `filled`
+  - filled
+  // protected attribute `length`
+  # length
+}
+----
+
+=== Additional attribute' properties
+
+example:
+
+[source,java]
+----
+class Figure {
+  + radius {
+    definition {
+      Radius of the Figure
+    }
+  }
+}
+----
+
+== Methods
+
+Syntax for defining methods:
+
+[source,java]
+----
+[visbility] method-name (parameter-list): return type {property-modifier}
+----
+
+where:
+
+* `visibility` can be equal to
+** `-`: private
+** `+`: public
+** `#`: protected
+** `~`: friendly
+
+* `parameter-list`: parameter list
+
+* `property-modifier`: can be equal to
+** `redefines`
+** `query`
+** `ordered` (defaults to `unordered`)
+** `unique`(defaults to `nonunique`)
+
+Syntax for a `parameter-list`:
+
+[source,java]
+----
+[direction] name:type [multiplicity] [=default] [{property string}]
+----
+
+where:
+
+* `direction` can be equal to
+** `in`
+** `out`
+** `inout`
+** `return`
+
+== import files
+
+Use `include` special word:
+
+[source,java]
+----
+include path/to/file
+----
+
+== Package syntax
+
+Namespaces
+
+A named element is an element that can have a name and a defined visibility (public, private, protected, package):
+
+[source,java]
+----
++ => public
+- => private
+# => protected
+~ => package
+----
+
+The name of the element and its visibility are optional.
+
+[source,java]
+----
+package Customers {
+  class Insurance {}
+  - class PrivateInsurance {}
+  # class ProtectedInsurance {}
+}
+----
+
+== Code comments
+
+Use `//` notation for LutaML comments skipped by parser, example:
+
+[source,java]
+----
+// TODO: implement
+abstract class Pet {}
+----
+
+== Comment objects diagram
+
+Use `\**`(one line comment) or `*| |*`(multiline comment) to create comment object for diagram entry.
+
+If this syntax is used inside a `class`/`enum`/`association` block, it will be created for owner of this block.
+
+[source,java]
+----
+** I am a document comment
+
+*|
+  This is a
+  multiply
+  lines document comment.
+*|
+
+class A
+enum B {
+  ** one line enum comment
+  foo
+  *|
+    This is a
+    multiply
+    lines class comment.
+  *|
+  bar
+}
+----
+
+== Syntax comments
+
+Use `//` to create syntax comment, chars after `//` will be ignored during processing.
+
+[source,java]
+----
+// TODO: attributes
+class A
+enum B {
+  // Write docs
+  foo
+  bar
+}
+----
+
+== Value specification
+
+A value specification indicates one or several values in a model. Examples for value specifications include simple, mathematical expressions, such as `4+2`, and expressions with values from the object model, `Integer::MAX_INT-1`
+
+[source,java]
+----
+class {Class name, if any} {as ref name, optional} {
+  {attribute name} = {attribute value}
+  {attribute name}:{attribute class} = {attribute value}
+}
+
+instance :{Class name, if any} {as ref name, optional} {
+  {attribute name} = {attribute value}
+  {attribute name}:{attribute class} = {attribute value}
+}
+----

data/Makefile

@@ -0,0 +1,2 @@
+fix-lint-staged:
+	git status --short | egrep '^(A|M)' | awk '{ print $$2}' | grep -v db/schema.rb | xargs bundle exec rubocop -a

data/bin/console

@@ -1,7 +1,12 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require "bundler/setup"
 require "lutaml"
+require "lutaml/express"
+require "lutaml/uml"
+require "lutaml/xmi"
+require "lutaml/sysml"
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.

data/bin/folder_yaml2lutaml.sh

@@ -0,0 +1,6 @@
+script_full_path=$(dirname "$0")
+
+for i in $1/*.yml
+do
+$script_full_path/yaml2lutaml $i > "$1/$(basename -s .yml $i).lutaml"
+done

data/bin/plantuml2lutaml

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# Script to convert plantuml files into LutaML syntax
+# Usage: bin/plantuml2lutaml /path/to/plantuml.wsd
+
+file_path = ARGV[0]
+FILE_NAME = File.basename(file_path, ".wsd")
+wsd_file = File.new(ARGV[0])
+
+def sync_puts(line, level = 0)
+  $stdout.puts("#{''.rjust(level)}#{line}")
+  $stdout.flush
+end
+
+SKIPPED_LINES_REGEXP = /^(@startuml|'\*{7}|note|@enduml|\!|'\/)/
+COMMENT_START = /\/'/
+COMMENT_END = /'\//
+ASSOCIATION_MAPPINGS = {
+  /-\|>/ => ",inheritance",
+  /<\|-/ => "inheritance,",
+  /->/ => ",direct",
+  /<-/ => "direct,",
+}.freeze
+
+in_comment_block = false
+
+def transform_line(line)
+  line = line.gsub(/^\s*'/, '** ').gsub(/\|[\sa-zA-Z]+$/, '')
+  return sync_puts(line, 2) if ASSOCIATION_MAPPINGS.keys.none? { |key| line =~ key }
+
+  owner_type, member_type = ASSOCIATION_MAPPINGS.detect { |(key, _value)| line =~ key }.last.split(",")
+  blocks = line.split(" ")
+  owner = blocks.first
+  member = blocks.last
+  sync_puts("association {", 2)
+  sync_puts("owner #{owner}", 4)
+  sync_puts("member #{member}", 4)
+  sync_puts("owner_type #{owner_type}", 4) if !owner_type.to_s.empty?
+  sync_puts("member_type #{member_type}", 4) if !member_type.to_s.empty?
+  sync_puts("}", 2)
+end
+
+sync_puts("diagram #{FILE_NAME} {")
+wsd_file.readlines.each do |line|
+  if line.match?(COMMENT_START)
+    in_comment_block = true
+  end
+
+  if line.match?(COMMENT_END)
+    in_comment_block = false
+  end
+
+  next if in_comment_block || line =~ SKIPPED_LINES_REGEXP
+
+  transform_line(line)
+end
+sync_puts("}")

data/bin/yaml2lutaml

@@ -0,0 +1,144 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# Script to convert datamodel yaml files into LutaML syntax
+# Usage: bin/yaml2lutaml /path/to/datamodel/view/file.yml
+
+require "yaml"
+
+view_yaml = YAML.safe_load(File.read(ARGV[0]))
+models_path = File.expand_path("../../models", ARGV[0])
+
+def sync_puts(line, level = 0)
+  $stdout.puts("#{''.rjust(level)}#{line}")
+  $stdout.flush
+end
+
+encountered_relations = Hash.new { |h, key| h[key] = [] }
+# relations:
+# - target: AttributeProfile
+#   relationship:
+#     source:
+#       type: aggregation
+#       attribute:
+#         addressClassProfile:
+#     target:
+#       type: direct
+#       attribute:
+#         attributeProfile:
+#           cardinality:
+#             min: 0
+#             max: '*'
+def process_association(owner, values, encountered_relations)
+  target_name = values["target"]
+  return if encountered_relations[owner].include?(target_name)
+
+  encountered_relations[owner].push(target_name)
+  sync_puts("association {", 2)
+
+  relationship_block = values["relationship"] || {}
+
+  if relationship_block["source"] && relationship_block["source"]["type"]
+    source = relationship_block["source"]
+    sync_puts("owner_type #{source['type']}", 4)
+    if source["attribute"]
+      source_attribute_name = source["attribute"].keys.first
+      owner += "##{source_attribute_name}"
+      if source["attribute"][source_attribute_name] && source["attribute"][source_attribute_name]["cardinality"]
+        cardinality = source["attribute"][source_attribute_name]["cardinality"]
+        owner += " [#{cardinality['min']}..#{cardinality['max']}]"
+      end
+    end
+  end
+  sync_puts("owner #{owner}", 4)
+
+  member = target_name
+  if relationship_block["target"]
+    target = relationship_block["target"]
+    type = target["type"] || "direct"
+    sync_puts("member_type #{type}", 4)
+    if target["attribute"]
+      target_attribute_name = target["attribute"].keys.first
+      member += "##{target_attribute_name}"
+      if target["attribute"][target_attribute_name] && target["attribute"][target_attribute_name]["cardinality"]
+        cardinality = target["attribute"][target_attribute_name]["cardinality"]
+        member += " [#{cardinality['min']}..#{cardinality['max']}]"
+      end
+    end
+  else
+    sync_puts("member_type direct", 4)
+  end
+  sync_puts("member #{member}", 4)
+
+  sync_puts("}", 2)
+end
+sync_puts("diagram #{File.basename(ARGV[0], 'yml')[0..-2]} {")
+sync_puts("title '#{view_yaml['title']}'", 2)
+sync_puts("caption '#{view_yaml['caption']}'", 2)
+
+# Class associations notations
+view_yaml["relations"]&.each do |values|
+  process_association(values["source"], values, encountered_relations)
+end
+
+view_yaml["imports"].keys.each do |entry|
+  import = YAML.safe_load(File.read(File.join(models_path, "#{entry}.yml")))
+  import_name = import["name"] || File.basename(entry)
+  # Class notation
+  sync_puts("#{import['modelType']} #{import_name} {", 2)
+  if import["definition"]
+    definition = <<~TEXT
+      definition {
+        #{import['definition']}
+      }
+    TEXT
+    sync_puts(definition, 4)
+  end
+  import["values"]&.each_pair do |key, values|
+    result_string = key
+    if values["definition"]
+      result_string += <<~TEXT
+        {
+          definition {
+          #{values['definition']}
+          }
+        }
+      TEXT
+    end
+    sync_puts(result_string, 4)
+  end
+  import["attributes"]&.each_pair do |key, values|
+    definition = values["definition"]
+    cardinality = if values["cardinality"]
+                    cardinality_val = values["cardinality"]
+                    "[#{cardinality_val['min']}..#{cardinality_val['max']}]"
+                  else
+                    ""
+                  end
+    result_string = "+#{key}"
+    if values["type"]
+      result_string += ": #{values['type']}"
+    end
+    if cardinality
+      result_string += " #{cardinality}"
+    end
+    if definition
+      result_string += <<~TEXT
+        {
+          definition
+          #{definition}
+          end definition
+        }
+      TEXT
+    end
+    sync_puts(result_string, 4)
+  end
+  sync_puts("}", 2)
+
+  # Associations notations
+  import["relations"]&.each do |values|
+    process_association(import_name, values, encountered_relations)
+  end
+end
+sync_puts("}")

data/exe/lutaml-sysml

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+# resolve bin path, ignoring symlinks
+require "pathname"
+bin_file = Pathname.new(__FILE__).realpath
+
+# add self to libpath
+$:.unshift File.expand_path("../../lib", bin_file)
+
+# Fixes https://github.com/rubygems/rubygems/issues/1420
+require "rubygems/specification"
+
+class Gem::Specification
+  def this; self; end
+end
+
+# start up the CLI
+require "reeper"
+Reeper::Cli.start(ARGV)