lutaml-uml 0.2.7 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: caa272840dbf2e26c09465e9fc43ce87e27264d1304f3e517177e1c2aeb5ddd5
-  data.tar.gz: 63accfb7dc6651f7df5a2fa16e1f3049efeac98f2b7c45ab33797e5589955011
+  metadata.gz: 3436e32ef66aba3d38cf8418de2ecef7bd475a1379e62e787aaddb0701397b55
+  data.tar.gz: da160c6b5ffaa013cb0d4bc4df8a23175acdff14da402c15b883c96a424cbd83
 SHA512:
-  metadata.gz: 60f0496d0d68e7ec42f96d2dea4e28b2f48be4ff46f079afc0a0041a31e9a0a32d6353f8a208a7194585c4e95a31a7fdaeb5e8bc21e94752b9ce8953d8b4655e
-  data.tar.gz: f1c58b701b5eff18c42c4fb8a38c9beab572663a345ea048abc112993f671b38e17ff8af9852951cc7650969715130996639bb4cb1eb517ba3cae83a023ee30e
+  metadata.gz: f76a00663fa9a4a8167930d4114ef4995ce7b488034336dd1134953ca9ed09ab4fd2da6e32a425082b6cf212b97bf47493e0b3f45c4b181fa93966f581ad7265
+  data.tar.gz: 85f1fd71d5df7d0e673a5c4994f7d524dbaa915afca26bdacd483e384889003114e3f91ac1d7c0a28bc9a649b675036458c4fcc685b9e8534b6a49c346bb269d

data/.github/workflows/ubuntu.yml

@@ -18,7 +18,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ '2.6', '2.5', '2.4' ]
+        ruby: [ '2.6', '2.5' ]
         experimental: [false]
         include:
           - ruby: '2.7'

data/LUTAML.adoc

@@ -7,13 +7,18 @@
 [source,java]
 ----
 diagram MyView {
-  import Relationship, Element
-  render_option typed_as_associations
-  file "my_view.png"
+  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:

data/README.adoc

@@ -8,20 +8,19 @@ Lutaml is a language for specifying UML class diagrams and a tool for converting
 
 ### RubyGems: `gem install lutaml-uml`
 
-## Executable
+## Language
 
-[source,sh]
---
-# Convert example.lutaml to example.png
-$ lutaml-uml --type png --output . example.lutaml
+See link:LUTAML.adoc[LUTAML.adoc]
 
-# Display detailed help message
-$ lutaml-uml --help
---
+## Usage
 
-## Language
+Converter executables are available:
+
+* PlantUML WSD to LutaML UML: `lutaml-wsd2uml`
+* LutaML YAML to LutaML UML: `lutaml-yaml2uml`
+
+EXAMPLE: `lutaml-wsd2uml mn/metanorma-model-standoc/models/StandardDoc_Blocks_New.wsd`
 
-See link:LUTAML.adoc[LUTAML.adoc]
 
 ## Development
 

data/bin/plantuml2lutaml

@@ -27,6 +27,7 @@ ASSOCIATION_MAPPINGS = {
 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(",")

data/bin/yaml2lutaml

@@ -100,9 +100,9 @@ view_yaml["imports"].keys.each do |entry|
     if values["definition"]
       result_string += <<~TEXT
         {
-          definition
+          definition {
           #{values['definition']}
-          end definition
+          }
         }
       TEXT
     end

data/exe/lutaml-wsd2uml

@@ -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/exe/lutaml-yaml2uml

@@ -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/lib/lutaml/uml.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
 require "lutaml/uml/version"
-require "lutaml/uml/interface/command_line"
+require "lutaml/uml/parsers/dsl"
+require "lutaml/uml/parsers/yaml"
+require "lutaml/uml/parsers/attribute"
+require "lutaml/uml/formatter"
 
 module Lutaml
   module Uml
     class Error < StandardError; end
-    # Your code goes here...
   end
 end

data/lib/lutaml/uml/class.rb

@@ -16,7 +16,6 @@ module Lutaml
 
       attr_reader :associations,
                   :attributes,
-                  :definition,
                   :members,
                   :modifier
 
@@ -32,10 +31,6 @@ module Lutaml
         @modifier = value.to_s # TODO: Validate?
       end
 
-      def definition=(value)
-        @definition = value.to_s
-      end
-
       def attributes=(value)
         @attributes = value.to_a.map do |attr|
           TopElementAttribute.new(attr)

data/lib/lutaml/uml/document.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
 require "lutaml/uml/class"
-require "lutaml/uml/enum"
 require "lutaml/uml/data_type"
+require "lutaml/uml/enum"
+require "lutaml/uml/package"
 require "lutaml/uml/primitive_type"
 
 module Lutaml
@@ -18,23 +19,27 @@ module Lutaml
                     :fidelity,
                     :fontname,
                     :comments
+      attr_reader :packages
 
       # rubocop:disable Rails/ActiveRecordAliases
       def initialize(attributes = {})
         update_attributes(attributes)
       end
       # rubocop:enable Rails/ActiveRecordAliases
-
       def classes=(value)
         @classes = value.to_a.map { |attributes| Class.new(attributes) }
       end
 
+      def data_types=(value)
+        @data_types = value.to_a.map { |attributes| DataType.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) }
+      def packages=(value)
+        @packages = value.to_a.map { |attributes| Package.new(attributes) }
       end
 
       def primitives=(value)
@@ -59,6 +64,10 @@ module Lutaml
         @data_types || []
       end
 
+      def packages
+        @packages || []
+      end
+
       def primitives
         @primitives || []
       end

data/lib/lutaml/uml/enum.rb

@@ -27,10 +27,6 @@ module Lutaml
         end
       end
 
-      def definition=(value)
-        @definition = value.to_s
-      end
-
       # TODO: reserved name, change
       def methods
         []

data/lib/lutaml/uml/package.rb

@@ -3,16 +3,37 @@
 module Lutaml
   module Uml
     class Package < TopElement
+      include HasAttributes
+
       attr_accessor :imports, :contents
+      attr_reader :classes, :enums
+
+      def initialize(attributes)
+        update_attributes(attributes)
+      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 packages=(value)
+        @packages = value.to_a.map { |attributes| Package.new(attributes) }
+      end
+
+      def classes
+        @classes || []
+      end
+
+      def enums
+        @enums || []
+      end
 
-      def initialize
-        @imports = []
-        @contents = []
-        @name = nil
-        @xmi_id = nil
-        @xmi_uuid = nil
-        @namespace = nil
-        @href = nil
+      def packages
+        @packages || []
       end
     end
   end

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

@@ -63,7 +63,7 @@ module Lutaml
         rule(:spaces) { match("\s").repeat(1) }
         rule(:spaces?) { spaces.maybe }
         rule(:whitespace) do
-          (match("\s") | match("\r?\n") | match("\r") | str(";")).repeat(1)
+          (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) }
@@ -82,9 +82,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("[") >>
@@ -117,7 +117,7 @@ module Lutaml
             attribute_keyword? >>
             spaces? >>
             match['"\''].maybe >>
-            match['a-zA-Z0-9_\- '].repeat(1).as(:type) >>
+            match['a-zA-Z0-9_\- \/\+'].repeat(1).as(:type) >>
             match['"\''].maybe >>
             spaces?
           )
@@ -126,7 +126,7 @@ module Lutaml
           attribute_type.maybe
         end
 
-        rule(:attribute_name) { name.as(:name) }
+        rule(:attribute_name) { match['a-zA-Z0-9_\- \/\+'].repeat(1).as(:name) }
         rule(:attribute_definition) do
           (visibility?.as(:visibility) >>
             match['"\''].maybe >>
@@ -293,9 +293,9 @@ module Lutaml
             whitespace? >>
             str("{") >>
             whitespace? >>
-            (str("}").absent? >> any).repeat.as(:definition) >>
+            (match("[\n\s]}").absent? >> any).repeat.as(:definition) >>
             whitespace? >>
-            str("}")
+            str('}')
         end
 
         # -- Enum
@@ -322,13 +322,17 @@ module Lutaml
             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
-          attribute_definition
+          definition_body |
+            attribute_definition |
+            comment_definition |
+            comment_multiline_definition
         end
         rule(:data_type_inner_definition) do
           data_type_inner_definitions >> whitespace?
@@ -346,6 +350,7 @@ module Lutaml
             match['"\''].maybe >>
             class_name.as(:name) >>
             match['"\''].maybe >>
+            attribute_keyword? >>
             data_type_body?
         end
 

data/lib/lutaml/uml/top_element.rb

@@ -6,6 +6,7 @@ module Lutaml
       include HasAttributes
 
       attr_accessor :name,
+                    :definition,
                     :xmi_id,
                     :xmi_uuid,
                     :namespace,
@@ -42,6 +43,16 @@ module Lutaml
 
         the_name
       end
+
+      def definition=(value)
+        @definition = value
+                        .to_s
+                        .gsub(/\\}/, '}')
+                        .gsub(/\\{/, '{')
+                        .split("\n")
+                        .map(&:strip)
+                        .join("\n")
+      end
     end
   end
 end

data/lib/lutaml/uml/top_element_attribute.rb

@@ -21,6 +21,16 @@ module Lutaml
         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/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Uml
-    VERSION = "0.2.7"
+    VERSION = "0.3.0"
   end
 end

data/lutaml-uml.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
 
   spec.bindir        = "exe"
   spec.require_paths = ["lib"]
-  spec.executables   = %w[lutaml-uml]
+  spec.executables   = %w[lutaml-wsd2uml lutaml-yaml2uml]
 
   spec.add_runtime_dependency "hashie", "~> 4.1.0"
   spec.add_runtime_dependency "parslet", "~> 1.7.1"

data/spec/fixtures/dsl/diagram_class_fields.lutaml

@@ -15,5 +15,11 @@ diagram MyView {
     ~friendlyAttributeProfile: <<Type>> "CharacterString" [1..*]
     ~friendlyAttributeProfile1: <<Type>> "CharacterString"
     #protectedAttributeProfile: CharacterString
+    type/text: String
+    slashType: slash/type
+    application/docbook+xml
+    application/tei+xml
+    text/x-asciidoc
+    application/x-isodoc+xml
   }
 }

data/spec/fixtures/dsl/diagram_data_types.lutaml

@@ -3,15 +3,35 @@ diagram MyView {
 
   enum MyEnum {}
 
-  enum AddressClassProfile {
+  enum AddressClassProfile <<my_keyword>> {
     +addressClassProfile: CharacterString
   }
 
   data_type "Banking Information" {
-    "art code"
+    definition {
+      Common code types used in banking.
+    }
+    "art code" {
+      definition {
+        The bank ART code.
+      }
+    }
     "CCT Number"
   }
 
+  data_type DateTimeType {
+    definition {
+      Type of date time value.
+    }
+    year {
+      definition {
+        The value only provides year.
+      }
+    }
+    monthYear
+    dayMonthYear
+  }
+
   primitive Integer
 
   enum Profile {

data/spec/fixtures/dsl/diagram_definitions.lutaml

@@ -6,6 +6,7 @@ diagram MyView {
       this is multiline with `ascidoc`
       comments
       and list
+      \{foo\} \{name\}
     }
     +addressClassProfile: CharacterString [0..1]
   }
@@ -16,6 +17,7 @@ diagram MyView {
       {
         this is attribute definition
         with multiply lines
+        \{foo\} \{name\}
         end definition
       }
     }

data/spec/lutaml/uml/parsers/dsl_spec.rb

@@ -68,7 +68,22 @@ RSpec.describe Lutaml::Uml::Parsers::Dsl do
         expect(by_name(classes, "AddressClassProfile")
                 .attributes.length).to eq(1)
         expect(by_name(classes, "AttributeProfile")
-                .attributes.length).to eq(7)
+                .attributes.length).to eq(13)
+        expect(by_name(classes, "AttributeProfile")
+                .attributes.map(&:name))
+              .to(eq(["imlicistAttributeProfile",
+                "attributeProfile",
+                "attributeProfile1",
+                "privateAttributeProfile",
+                "friendlyAttributeProfile",
+                "friendlyAttributeProfile1",
+                "protectedAttributeProfile",
+                "type/text",
+                "slashType",
+                "application/docbook+xml",
+                "application/tei+xml",
+                "text/x-asciidoc",
+                "application/x-isodoc+xml"]))
       end
 
       it "creates the correct attributes with the correct visibility" do
@@ -121,7 +136,7 @@ RSpec.describe Lutaml::Uml::Parsers::Dsl do
           expect(association.member_end).to(eq("AttributeProfile"))
           expect(association.member_end_attribute_name)
             .to(eq("attributeProfile"))
-          expect(association.member_end_cardinality).to(eq(min: "0", max: "*"))
+          expect(association.member_end_cardinality).to(eq("min" => "0", "max" => "*"))
         end
       end
 
@@ -254,10 +269,10 @@ RSpec.describe Lutaml::Uml::Parsers::Dsl do
         File.new(fixtures_path("dsl/diagram_definitions.lutaml"))
       end
       let(:class_definition) do
-        "this is multiline with `ascidoc`\n      comments\n      and list"
+        "this is multiline with `ascidoc`\ncomments\nand list\n{foo} {name}"
       end
       let(:attribute_definition) do
-        "this is attribute definition\n        with multiply lines\n        end definition"
+        "this is attribute definition\nwith multiply lines\n{foo} {name}\nend definition"
       end
 
       it "create comments for document and classes" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-uml
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.3.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-11-27 00:00:00.000000000 Z
+date: 2021-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashie
@@ -168,7 +168,8 @@ description: UML model module for LutaML.
 email:
 - open.source@ribose.com'
 executables:
-- lutaml-uml
+- lutaml-wsd2uml
+- lutaml-yaml2uml
 extensions: []
 extra_rdoc_files: []
 files:
@@ -188,7 +189,8 @@ files:
 - bin/plantuml2lutaml
 - bin/setup
 - bin/yaml2lutaml
-- exe/lutaml-uml
+- exe/lutaml-wsd2uml
+- exe/lutaml-yaml2uml
 - lib/lutaml/layout/engine.rb
 - lib/lutaml/layout/graph_viz_engine.rb
 - lib/lutaml/uml.rb
@@ -214,8 +216,6 @@ files:
 - lib/lutaml/uml/has_attributes.rb
 - lib/lutaml/uml/has_members.rb
 - lib/lutaml/uml/instance.rb
-- lib/lutaml/uml/interface/base.rb
-- lib/lutaml/uml/interface/command_line.rb
 - lib/lutaml/uml/model.rb
 - lib/lutaml/uml/node/base.rb
 - lib/lutaml/uml/node/class_node.rb
@@ -319,7 +319,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.0.3
 signing_key:
 specification_version: 4
 summary: UML model module for LutaML.

data/exe/lutaml-uml

@@ -1,21 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-# frozen_string_literal: true
-
-# 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
-
-require "lutaml/uml/interface/command_line"
-
-Lutaml::Uml::Interface::CommandLine.run

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

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require "optparse"
-require "lutaml/uml/has_attributes"
-
-module Lutaml
-  module Uml
-    module Interface
-      class Base
-        def self.run(attributes = {})
-          new(attributes).run
-        end
-
-        include HasAttributes
-
-        # rubocop:disable Rails/ActiveRecordAliases
-        def initialize(attributes = {})
-          update_attributes(attributes)
-        end
-        # rubocop:enable Rails/ActiveRecordAliases
-
-        def run
-          raise NotImplementedError
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml/interface/command_line.rb

@@ -1,265 +0,0 @@
-require "optparse"
-require "pathname"
-require "lutaml/uml/interface/base"
-require "lutaml/uml/parsers/dsl"
-require "lutaml/uml/parsers/yaml"
-require "lutaml/uml/parsers/attribute"
-require "lutaml/uml/formatter"
-
-module Lutaml
-  module Uml
-    module Interface
-      class CommandLine < Base
-        class Error < StandardError; end
-        class FileError < Error; end
-        class NotSupportedInputFormat < Error; end
-
-        SUPPORTED_FORMATS = %w[yaml dsl].freeze
-        DEFAULT_INPUT_FORMAT = "dsl".freeze
-
-        def initialize(attributes = {})
-          @formatter     = Formatter::Graphviz.new
-          @verbose       = false
-          @option_parser = OptionParser.new
-
-          setup_parser_options
-
-          super
-        end
-
-        def output_path=(value)
-          @output_path = determine_output_path_value(value)
-        end
-
-        def determine_output_path_value(value)
-          unless value.nil? || @output_path = value.is_a?(Pathname)
-            return Pathname.new(value.to_s)
-          end
-
-          value
-        end
-
-        def paths=(values)
-          @paths = values.to_a.map { |path| Pathname.new(path) }
-        end
-
-        def formatter=(value)
-          value = value.to_s.strip.downcase.to_sym
-          value = Formatter.find_by(name: value)
-          raise Error, "Formatter not found: #{value}" if value.nil?
-
-          @formatter = value
-        end
-
-        def input_format=(value)
-          if value.nil?
-            @input_format = DEFAULT_INPUT_FORMAT
-            return
-          end
-
-          @input_format = SUPPORTED_FORMATS.detect { |n| n == value }
-          raise(NotSupportedInputFormat, value) if @input_format.nil?
-        end
-
-        def run
-          args = ARGV.dup # TODO: This is hacky
-          begin
-            @option_parser.parse!(args)
-          rescue StandardError
-            nil
-          end
-          setup_parser_formatter_options
-          @option_parser.parse!
-
-          self.paths      = ARGV
-          @formatter.type = @type
-
-          if @output_path&.file? && @paths.length > 1
-            raise Error,
-                  'Output path must be a directory \
-                  if multiple input files are given'
-          end
-
-          @paths.each do |input_path|
-            unless input_path.exist?
-              raise FileError, "File does not exist: #{input_path}"
-            end
-
-            document = if @input_format == "yaml"
-                         Parsers::Yaml.parse(input_path)
-                       else
-                         Parsers::Dsl.parse(File.new(input_path))
-                       end
-            result = @formatter.format(document)
-
-            if @output_path
-              output_path = @output_path
-              if output_path.directory?
-                output_path = output_path.join(input_path
-                                                .basename(".*").to_s +
-                                              ".#{@formatter.type}")
-              end
-
-              output_path.open("w+") { |file| file.write(result) }
-            else
-              puts result
-            end
-          end
-        end
-
-        protected
-
-        def text_bold(body = nil)
-          text_effect(1, body)
-        end
-
-        def text_italic(body = nil)
-          text_effect(3, body)
-        end
-
-        def text_bold_italic(body = nil)
-          text_bold(text_italic(body))
-        end
-
-        def text_underline(body = nil)
-          text_effect(4, body)
-        end
-
-        def text_effect(num, body = nil)
-          result = "\e[#{num}m"
-          result << "#{body}#{text_reset}" unless body.nil?
-
-          result
-        end
-
-        def text_reset
-          "\e[0m"
-        end
-
-        def setup_parser_options
-          @option_parser.banner = ""
-          format_desc = "The output formatter (Default: '#{@formatter.name}')"
-          @option_parser
-            .on("-f",
-                "--formatter VALUE",
-                format_desc) do |value|
-            self.formatter = value
-          end
-          @option_parser
-            .on("-t", "--type VALUE", "The output format type") do |value|
-              @type = value
-            end
-          @option_parser
-            .on("-o", "--output VALUE", "The output path") do |value|
-              self.output_path = value
-            end
-          @option_parser
-            .on("-i", "--input-format VALUE", "The input format") do |value|
-              self.input_format = value
-            end
-          @option_parser
-            .on("-h", "--help", "Prints this help") do
-            print_help
-            exit
-          end
-        end
-
-        def setup_parser_formatter_options
-          case @formatter.name
-          when :graphviz
-            @option_parser.on("-g", "--graph VALUE") do |value|
-              Parsers::Attribute.parse(value).each do |key, attr_value|
-                @formatter.graph[key] = attr_value
-              end
-            end
-
-            @option_parser.on("-e", "--edge VALUE") do |value|
-              Parsers::Attribute.parse(value).each do |key, attr_value|
-                @formatter.edge[key] = attr_value
-              end
-            end
-
-            @option_parser.on("-n", "--node VALUE") do |value|
-              Parsers::Attribute.parse(value).each do |key, attr_value|
-                @formatter.node[key] = attr_value
-              end
-            end
-
-            @option_parser.on("-a", "--all VALUE") do |value|
-              Parsers::Attribute.parse(value).each do |key, attr_value|
-                @formatter.graph[key] = attr_value
-                @formatter.edge[key] = attr_value
-                @formatter.node[key] = attr_value
-              end
-            end
-          end
-        end
-
-        def print_help
-          puts <<~HELP
-            #{text_bold('Usage:')} lutaml-uml [options] PATHS
-
-            #{text_bold('Overview:')} Generate output from UML Class Diagram language files
-
-            #{text_bold('Options:')}
-            #{@option_parser}
-            #{text_bold('Paths:')}
-
-                UCD can accept multiple paths for parsing for easier batch processing.
-
-                The location of the output by default is standard output.
-
-                The output can be directed to a path with #{text_bold_italic('--output')}, which can be a file or a directory.
-                If the output path is a directory, then the filename will be the same as the input filename,
-                  with it's file extension substituted with the #{text_bold_italic('--type')}.
-
-                #{text_underline('Examples')}
-
-                    `lutaml-uml project.lutaml`
-
-                        Produces DOT notation, sent to standard output
-
-                    `lutaml-uml -o . project.lutaml`
-
-                        Produces DOT notation, written to #{text_italic('./project.dot')}
-
-                    `lutaml-uml -o ./diagram.dot project.lutaml`
-
-                        Produces DOT notation, written to #{text_italic('./diagram.dot')}
-
-                    `lutaml-uml -o ./diagram.png project.lutaml`
-
-                        Produces PNG image, written to #{text_italic('./diagram.png')}
-
-                    `lutaml-uml -t png -o . project.lutaml`
-
-                        Produces PNG image, written to #{text_italic('./project.png')}
-
-                    `lutaml-uml -t png -o . project.lutaml-uml core_ext.lutaml`
-
-                        Produces PNG images, written to #{text_italic('./project.png')} and #{text_italic('./core_ext.png')}
-
-            #{text_bold('Formatters:')}
-
-                #{text_underline('Graphviz')}
-
-                  Generates DOT notation and can use the DOT notation to generate any format Graphviz can produce.
-
-                  The output format is based on #{text_bold_italic('--type')}, which by default is "dot".
-                  If #{text_bold_italic('--type')} is not given and #{text_bold_italic('--output')} is, the file extension of the #{text_bold_italic('--output')} path will be used.
-
-                  Valid types/extensions are: #{Formatter::Graphviz::VALID_TYPES.join(', ')}
-
-                  #{text_bold('Options:')}
-
-                      -g, --graph VALUE                The graph attributes
-                      -e, --edge VALUE                 The edge attributes
-                      -n, --node VALUE                 The node attributes
-                      -a, --all VALUE                  Set attributes for graph, edge, and node
-
-          HELP
-        end
-      end
-    end
-  end
-end