lutaml 0.3.2 → 0.4.1.pre.alpha.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d1809b80de4e3e3d8ed081e31f19008e3fcb30559a8e95b6156a03bfca36aa6
-  data.tar.gz: be6fd904458828f232294f03d0cdb1fec2dbc349301449ebb3f9a1a77b375195
+  metadata.gz: 0e2accd48e5932fbf111f54429604e7709a98418d6b9c97af40f29c8547a7238
+  data.tar.gz: 6561a16f4d783ddc50812af99e3da854dc2a8673be5e2cc9e7adcffa1678099f
 SHA512:
-  metadata.gz: b58852c0e45b0ebe4bd27f7c782ee605abe4e448107c8371ddd98d5fb9f731053ec3f46565d34f43d9b6ca2363c09d7db55c6adba282db934c01a543f117b97e
-  data.tar.gz: 47326b6b3301018542b4764161e931df57e582c4e4d22d0f94961caf4fbe9a495b76fe65337fe22dd3c1e71b2c909da52e93caa000040566c36d145ae8733a63
+  metadata.gz: 3006890a278d837602f7c3149c46b7810a7f5e367100862eac17ac7e54ef2bf18623b9bb8a98483b12cec3fe52bfbef1e3f3c40b7231b7d669c31b0b5e3548f1
+  data.tar.gz: c509f969284fc89e5a4d3293426a71ff861aa8283f33193114887d55d2173427a988998db906d18ea94e1a821db07147a213f892052241dd383c6e36556fa2b0

data/.github/workflows/macos.yml

@@ -30,6 +30,8 @@ jobs:
         uses: actions/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
+      - name: Install Grpahviz macOS
+        run: brew install graphviz
       - name: Update gems
         run: |
           sudo gem install bundler --force

data/.github/workflows/ubuntu.yml

@@ -29,6 +29,8 @@ jobs:
         uses: actions/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
+      - name: Install Grpahviz Ubuntu
+        run: sudo apt-get install graphviz
       - name: Update gems
         run: |
           gem install bundler

data/.github/workflows/windows.yml

@@ -30,6 +30,13 @@ jobs:
         uses: actions/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
+      - name: Install graphviz
+        uses: nick-invision/retry@v1
+        with:
+          polling_interval_seconds: 5
+          timeout_minutes: 5
+          max_attempts: 3
+          command: choco install --no-progress graphviz --version 2.38.0.20190211
       - name: Update gems
         shell: pwsh
         run: |

data/README.adoc

@@ -30,7 +30,9 @@ $ gem install lutaml
 
 === Usage
 
-In order to parse files supported by lutaml extensions, use Lutaml::Parser.parse method(currently only .exp are supported):
+== From ruby
+
+In order to parse files supported by lutaml extensions, use Lutaml::Parser.parse method.
 
 [source,ruby]
 ----
@@ -38,6 +40,22 @@ In order to parse files supported by lutaml extensions, use Lutaml::Parser.parse
 Lutaml::Parser.parse(File.new("example.exp")) # will produce Lutaml::LutamlPath::DocumentWrapper object with serialized express repository
 ----
 
+== With cli tool
+
+There is a cli tool available for parsing lutaml/exp files(also yaml datastruct files are supported).
+
+[source,bash]
+----
+# Will generate `test.dot` file in the current directory
+$: lutaml -o . test.lutaml
+
+# Will generate `test.png` file in the `assets` directory
+$: lutaml -o assets -t png test.lutaml
+----
+
+For additional info refer to `lutaml --help output`
+
+
 == Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/exe/lutaml

@@ -0,0 +1,22 @@
+#!/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"
+require "lutaml/command_line"
+
+Lutaml::CommandLine.run(ARGV.dup, STDOUT)

data/lib/lutaml/command_line.rb

@@ -0,0 +1,262 @@
+require "optparse"
+require "pathname"
+require "lutaml/formatter"
+require "lutaml/uml/has_attributes"
+require "lutaml/uml/parsers/attribute"
+require "lutaml/uml/parsers/dsl"
+require "lutaml/uml/parsers/yaml"
+
+module Lutaml
+  class CommandLine
+    class Error < StandardError; end
+    class FileError < Error; end
+    class NotSupportedInputFormat < Error; end
+
+    include ::Lutaml::Uml::HasAttributes
+
+    SUPPORTED_FORMATS = %w[yaml lutaml exp].freeze
+    DEFAULT_INPUT_FORMAT = "lutaml".freeze
+
+    def self.run(args, out_object, attributes = {})
+      new(attributes, out_object).run(args)
+    end
+
+    def initialize(attributes = {}, out_object = STDOUT)
+      @formatter = ::Lutaml::Formatter::Graphviz.new
+      @verbose = false
+      @option_parser = OptionParser.new
+      @out_object = out_object
+
+      setup_parser_options
+
+      # rubocop:disable Rails/ActiveRecordAliases
+      update_attributes(attributes)
+      # rubocop:enable Rails/ActiveRecordAliases
+    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 = Lutaml::Uml::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(original_args)
+      args = original_args.dup
+      @option_parser.parse!(args) rescue nil
+      @paths = args
+      @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_string|
+        input_path = Pathname.new(input_path_string)
+        unless input_path.exist?
+          raise FileError, "File does not exist: #{input_path}"
+        end
+
+        document = Lutaml::Parser
+          .parse_into_document(File.new(input_path), @input_format)
+          .first
+        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
+          @out_object.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|
+        @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|
+          @output_path = Pathname.new(value)
+        end
+      @option_parser
+        .on("-i", "--input-format VALUE", "The input format") do |value|
+          @input_format = value
+        end
+      @option_parser
+        .on("-h", "--help", "Prints this help") do
+        print_help
+        exit
+      end
+      @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
+
+    def print_help
+      @out_object.puts <<~HELP
+        #{text_bold('Usage:')} lutaml [options] PATHS
+
+        #{text_bold('Overview:')} Generate output from Supplied language files if supported
+
+        #{text_bold('Options:')}
+        #{@option_parser}
+        #{text_bold('Paths:')}
+
+            LUTAML 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 project.lutaml`
+
+                    Produces DOT notation, sent to standard output
+
+                `lutaml -o . project.lutaml`
+
+                    Produces DOT notation, written to #{text_italic('./project.dot')}
+
+                `lutaml -o ./diagram.dot project.lutaml`
+
+                    Produces DOT notation, written to #{text_italic('./diagram.dot')}
+
+                `lutaml -o ./diagram.png project.lutaml`
+
+                    Produces PNG image, written to #{text_italic('./diagram.png')}
+
+                `lutaml -t png -o . project.lutaml`
+
+                    Produces PNG image, written to #{text_italic('./project.png')}
+
+                `lutaml -t png -o . project.lutaml core_ext.lutaml`
+
+                    Produces PNG images, written to #{text_italic('./project.png')} and #{text_italic('./core_ext.png')}
+
+        #{text_bold('Inputs:')}
+
+            #{text_underline('Lutaml')}
+
+              Lutaml dsl syntax files, supports diagram generation(image or dot files) with Graphviz
+
+        #{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: #{Lutaml::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

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

@@ -1,57 +1,15 @@
 require "lutaml/lutaml_path/document_wrapper"
-require "expressir/express_exp/formatter"
+require "expressir/express_exp/hyperlink_formatter"
 
 module Lutaml
   module Express
     module LutamlPath
       class DocumentWrapper < ::Lutaml::LutamlPath::DocumentWrapper
-        SCHEMA_ATTRIBUTES = %w[
-          id
-          constants
-          declarations
-          entities
-          functions
-          interfaces
-          procedures
-          remarks
-          rules
-          subtype_constraints
-          types
-          version
-        ].freeze
-        SOURCE_CODE_ATTRIBUTE_NAME = "sourcecode".freeze
-
         protected
 
         def serialize_document(repository)
-          repository.schemas.each_with_object({}) do |schema, res|
-            res["schemas"] ||= []
-            serialized_schema = SCHEMA_ATTRIBUTES
-              .each_with_object({}) do |name, nested_res|
-              attr_value = schema.send(name)
-              nested_res[name] = serialize_value(attr_value)
-              if name == "entities"
-                nested_res[name] = merge_source_code_attr(nested_res[name],
-                                                          attr_value)
-              end
-            end
-            res[schema.id] = serialized_schema
-            serialized_schema = serialized_schema
-              .merge(SOURCE_CODE_ATTRIBUTE_NAME =>
-                                          entity_source_code(schema))
-            res["schemas"].push(serialized_schema)
-          end
-        end
-
-        def merge_source_code_attr(serialized_entries, entities)
-          serialized_entries.map do |serialized|
-            entity = entities.detect { |n| n.id == serialized["id"] }
-            serialized.merge(SOURCE_CODE_ATTRIBUTE_NAME => entity_source_code(entity))
-          end
-        end
-
-        def entity_source_code(entity)
-          Expressir::ExpressExp::Formatter.format(entity)
+          repository
+            .to_hash(formatter: Expressir::ExpressExp::HyperlinkFormatter)['schemas']
         end
       end
     end

data/lib/lutaml/formatter.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lutaml
+  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
+
+require "lutaml/formatter/graphviz"

data/lib/lutaml/formatter/base.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "lutaml/formatter"
+require "lutaml/uml/has_attributes"
+
+module Lutaml
+  module Formatter
+    class Base
+      class << self
+        def inherited(subclass)
+          Formatter.all << subclass
+        end
+
+        def format(node, attributes = {})
+          new(attributes).format(node)
+        end
+
+        def name
+          to_s.split("::").last.downcase.to_sym
+        end
+      end
+
+      include ::Lutaml::Uml::HasAttributes
+
+      # rubocop:disable Rails/ActiveRecordAliases
+      def initialize(attributes = {})
+        update_attributes(attributes)
+      end
+      # rubocop:enable Rails/ActiveRecordAliases
+
+      def name
+        self.class.name
+      end
+
+      attr_reader :type
+
+      def type=(value)
+        @type = value.to_s.strip.downcase.to_sym
+      end
+
+      def format(node)
+        case node
+        when ::Lutaml::Uml::Node::Field  then format_field(node)
+        when ::Lutaml::Uml::Node::Method then format_method(node)
+        when ::Lutaml::Uml::Node::Relationship then format_relationship(node)
+        when ::Lutaml::Uml::Node::ClassRelationship
+          then format_class_relationship(node)
+        when ::Lutaml::Uml::Node::ClassNode then format_class(node)
+        when Lutaml::Uml::Document then format_document(node)
+        end
+      end
+
+      def format_field(_node); raise NotImplementedError; end
+
+      def format_method(_node); raise NotImplementedError; end
+
+      def format_relationship(_node); raise NotImplementedError; end
+
+      def format_class_relationship(_node); raise NotImplementedError; end
+
+      def format_class(_node); raise NotImplementedError; end
+
+      def format_document(_node); raise NotImplementedError; end
+    end
+  end
+end

data/lib/lutaml/formatter/graphviz.rb

@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+
+require "open3"
+require "lutaml/formatter/base"
+require "lutaml/layout/graph_viz_engine"
+
+module Lutaml
+  module Formatter
+    class Graphviz < Base
+      class Attributes < Hash
+        def to_s
+          to_a
+            .reject { |(_k, val)| val.nil? }
+            .map { |(a, b)| "#{a}=#{b.inspect}" }
+            .join(" ")
+        end
+      end
+
+      ACCESS_SYMBOLS = {
+        "public"    => "+",
+        "protected" => "#",
+        "private"   => "-",
+      }.freeze
+      DEFAULT_CLASS_FONT = "Helvetica".freeze
+
+      VALID_TYPES = %i[
+        dot
+        xdot
+        ps
+        pdf
+        svg
+        svgz
+        fig
+        png
+        gif
+        jpg
+        jpeg
+        json
+        imap
+        cmapx
+      ].freeze
+
+      def initialize(attributes = {})
+        super
+
+        @graph = Attributes.new
+        # Associations lines style, `true` gives curved lines
+        # https://graphviz.org/doc/info/attrs.html#d:splines
+        @graph["splines"] = "ortho"
+        # Padding between outside of picture and nodes
+        @graph["pad"] = 0.5
+        # Padding between levels
+        @graph["ranksep"] = "1.2.equally"
+        # Padding between nodes
+        @graph["nodesep"] = "1.2.equally"
+        # TODO: set rankdir
+        # @graph['rankdir'] = 'BT'
+
+        @edge = Attributes.new
+        @edge["color"] = "gray50"
+
+        @node = Attributes.new
+        @node["shape"] = "box"
+
+        @type = :dot
+      end
+
+      attr_reader :graph
+      attr_reader :edge
+      attr_reader :node
+
+      def type=(value)
+        super
+
+        @type = :dot unless VALID_TYPES.include?(@type)
+      end
+
+      def format(node)
+        dot = super.lines.map(&:rstrip).join("\n")
+
+        generate_from_dot(dot)
+      end
+
+      def escape_html_chars(text)
+        text
+          .gsub(/</, "&#60;")
+          .gsub(/>/, "&#62;")
+          .gsub(/\[/, "&#91;")
+          .gsub(/\]/, "&#93;")
+      end
+
+      def format_field(node)
+        symbol = ACCESS_SYMBOLS[node.visibility]
+        result = "#{symbol}#{node.name}"
+        if node.type
+          keyword = node.keyword ? "«#{node.keyword}»" : ""
+          result += " : #{keyword}#{node.type}"
+        end
+        if node.cardinality
+          result += "[#{node.cardinality[:min]}..#{node.cardinality[:max]}]"
+        end
+        result = escape_html_chars(result)
+        result = "<U>#{result}</U>" if node.static
+
+        result
+      end
+
+      def format_method(node)
+        symbol = ACCESS_SYMBOLS[node.access]
+        result = "#{symbol} #{node.name}"
+        if node.arguments
+          arguments = node.arguments.map do |argument|
+            "#{argument.name}#{" : #{argument.type}" if argument.type}"
+          end.join(", ")
+        end
+
+        result << "(#{arguments})"
+        result << " : #{node.type}" if node.type
+        result = "<U>#{result}</U>" if node.static
+        result = "<I>#{result}</I>" if node.abstract
+
+        result
+      end
+
+      def format_relationship(node)
+        graph_parent_name = generate_graph_name(node.owner_end)
+        graph_node_name = generate_graph_name(node.member_end)
+        attributes = generate_graph_relationship_attributes(node)
+        graph_attributes = " [#{attributes}]" unless attributes.empty?
+
+        %{#{graph_parent_name} -> #{graph_node_name}#{graph_attributes}}
+      end
+
+      def generate_graph_relationship_attributes(node)
+        attributes = Attributes.new
+        if %w[dependency realizes].include?(node.member_end_type)
+          attributes["style"] = "dashed"
+        end
+        attributes["dir"] = if node.owner_end_type && node.member_end_type
+                              "both"
+                            elsif node.owner_end_type
+                              "back"
+                            else
+                              "direct"
+                            end
+        attributes["label"] = node.action if node.action
+        if node.owner_end_attribute_name
+          attributes["headlabel"] = format_label(
+            node.owner_end_attribute_name,
+            node.owner_end_cardinality
+          )
+        end
+        if node.member_end_attribute_name
+          attributes["taillabel"] = format_label(
+            node.member_end_attribute_name,
+            node.member_end_cardinality
+          )
+        end
+
+        attributes["arrowtail"] = case node.owner_end_type
+                                  when "composition"
+                                    "diamond"
+                                  when "aggregation"
+                                    "odiamond"
+                                  when "direct"
+                                    "vee"
+                                  else
+                                    "onormal"
+                                  end
+
+        attributes["arrowhead"] = case node.member_end_type
+                                  when "composition"
+                                    "diamond"
+                                  when "aggregation"
+                                    "odiamond"
+                                  when "direct"
+                                    "vee"
+                                  else
+                                    "onormal"
+                                  end
+        # swap labels and arrows if `dir` eq to `back`
+        if attributes["dir"] == "back"
+          attributes["arrowhead"], attributes["arrowtail"] =
+            [attributes["arrowtail"], attributes["arrowhead"]]
+          attributes["headlabel"], attributes["taillabel"] =
+            [attributes["taillabel"], attributes["headlabel"]]
+        end
+        attributes
+      end
+
+      def format_label(name, cardinality = {})
+        res = "+#{name}"
+        if cardinality.nil? ||
+            (cardinality["min"].nil? || cardinality["max"].nil?)
+          return res
+        end
+
+        "#{res} #{cardinality['min']}..#{cardinality['max']}"
+      end
+
+      def format_member_rows(members, hide_members)
+        unless !hide_members && members && members.length.positive?
+          return <<~HEREDOC.chomp
+            <TABLE BORDER="0" CELLPADDING="0" CELLSPACING="0">
+              <TR><TD ALIGN="LEFT"></TD></TR>
+            </TABLE>
+          HEREDOC
+        end
+
+        field_rows = members.map do |field|
+          %{<TR><TD ALIGN="LEFT">#{format_field(field)}</TD></TR>}
+        end
+        field_table = <<~HEREDOC.chomp
+          <TABLE BORDER="0" CELLPADDING="0" CELLSPACING="0">
+            #{field_rows.map { |row| ' ' * 10 + row }.join("\n")}
+          </TABLE>
+        HEREDOC
+        field_table << "\n" << " " * 6
+        field_table
+      end
+
+      def format_class(node, hide_members)
+        name = ["<B>#{node.name}</B>"]
+        name.unshift("«#{node.keyword}»") if node.keyword
+        name_html = <<~HEREDOC
+          <TABLE BORDER="0" CELLPADDING="0" CELLSPACING="0">
+            #{name.map { |n| %(<TR><TD ALIGN="CENTER">#{n}</TD></TR>) }.join('\n')}
+          </TABLE>
+        HEREDOC
+
+        field_table = format_member_rows(node.attributes, hide_members)
+        method_table = format_member_rows(node.methods, hide_members)
+        table_body = [name_html, field_table, method_table].map do |type|
+          next if type.nil?
+
+          <<~TEXT
+            <TR>
+              <TD>#{type}</TD>
+            </TR>
+          TEXT
+        end
+
+        <<~HEREDOC.chomp
+          <TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0" CELLPADDING="10">
+            #{table_body.compact.join("\n")}
+          </TABLE>
+        HEREDOC
+      end
+
+      def format_document(node)
+        @fontname = node.fontname || DEFAULT_CLASS_FONT
+        @node["fontname"] = "#{@fontname}-bold"
+
+        if node.fidelity
+          hide_members = node.fidelity["hideMembers"]
+          hide_other_classes = node.fidelity["hideOtherClasses"]
+        end
+        classes = (node.classes +
+                    node.enums +
+                    node.data_types +
+                    node.primitives).map do |class_node|
+          graph_node_name = generate_graph_name(class_node.name)
+
+          <<~HEREDOC
+            #{graph_node_name} [
+              shape="plain"
+              fontname="#{@fontname || DEFAULT_CLASS_FONT}"
+              label=<#{format_class(class_node, hide_members)}>]
+          HEREDOC
+        end.join("\n")
+        associations = node.classes.map(&:associations).compact.flatten +
+          node.associations
+        if node.groups
+          associations = sort_by_document_groupping(node.groups,
+                                                    associations)
+        end
+        classes_names = node.classes.map(&:name)
+        associations = associations.map do |assoc_node|
+          if hide_other_classes &&
+              !classes_names.include?(assoc_node.member_end)
+            next
+          end
+
+          format_relationship(assoc_node)
+        end.join("\n")
+
+        classes = classes.lines.map { |line| "  #{line}" }.join.chomp
+        associations = associations
+          .lines.map { |line| "  #{line}" }.join.chomp
+
+        <<~HEREDOC
+          digraph G {
+            graph [#{@graph}]
+            edge [#{@edge}]
+            node [#{@node}]
+
+          #{classes}
+
+          #{associations}
+          }
+        HEREDOC
+      end
+
+      protected
+
+      def sort_by_document_groupping(groups, associations)
+        result = []
+        groups.each do |batch|
+          batch.each do |group_name|
+            associations
+              .select { |assc| assc.owner_end == group_name }
+              .each do |association|
+                result.push(association) unless result.include?(association)
+              end
+          end
+        end
+        associations.each do |association|
+          result.push(association) unless result.include?(association)
+        end
+        result
+      end
+
+      def generate_from_dot(input)
+        Lutaml::Layout::GraphVizEngine.new(input: input).render(@type)
+      end
+
+      def generate_graph_name(name)
+        name.gsub(/[^0-9a-zA-Z]/i, "")
+      end
+    end
+  end
+end

data/lib/lutaml/layout/engine.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Lutaml
+  class Engine
+    attr_accessor :input
+
+    def initialize(input:)
+      @input = input
+    end
+
+    def render(_type)
+      raise ArgumentError, "Implement render method"
+    end
+  end
+end

data/lib/lutaml/layout/graph_viz_engine.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "ruby-graphviz"
+require "lutaml/layout/engine"
+
+module Lutaml
+  module Layout
+    class GraphVizEngine < Engine
+      def render(type)
+        Open3.popen3("dot -T#{type}") do |stdin, stdout, _stderr, _wait|
+          stdin.puts(input)
+          stdin.close
+          stdout.read
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/lutaml_path/document_wrapper.rb

@@ -22,18 +22,24 @@ module Lutaml
           return attr_value.map(&method(:serialize_to_hash))
         end
 
-        attr_value
+        serialize_to_hash(attr_value)
       end
 
       def serialize_to_hash(object)
-        return object if [String, Integer, Float].include?(object.class)
+        return object if [String, Integer, Float, FalseClass, TrueClass, Symbol, NilClass].include?(object.class)
 
         object.instance_variables.each_with_object({}) do |var, res|
           variable = object.instance_variable_get(var)
           res[var.to_s.gsub("@", "")] = if variable.is_a?(Array)
-                                          variable.map { |n| serialize_to_hash(n) }
+                                          variable.map do |n|
+                                            serialize_to_hash(n)
+                                          end
                                         else
-                                          variable
+                                          if [String, Integer, Float, FalseClass, TrueClass, Symbol, NilClass].include?(variable.class) || var == :@parent
+                                            variable
+                                          else
+                                            serialize_to_hash(variable)
+                                          end
                                         end
         end
       end

data/lib/lutaml/parser.rb

@@ -4,20 +4,54 @@ require "lutaml/uml/lutaml_path/document_wrapper"
 require "lutaml/express/lutaml_path/document_wrapper"
 
 module Lutaml
-  module Parser
-    module_function
+  class Parser
+    attr_reader :parse_type, :file_list
 
-    def parse(file)
-      case File.extname(file.path)[1..-1]
+    class << self
+      def parse(file_list, input_type = nil)
+        file_list = file_list.is_a?(Array) ? file_list : [file_list]
+        new(Array(file_list), input_type).parse
+      end
+
+      def parse_into_document(file_list, input_type = nil)
+        file_list = file_list.is_a?(Array) ? file_list : [file_list]
+        new(Array(file_list), input_type).parse_into_document
+      end
+    end
+
+    def initialize(file_list, input_type)
+      @parse_type = input_type ? input_type : File.extname(file_list.first.path)[1..-1]
+      @file_list = file_list
+    end
+
+    def parse
+      documents = parse_into_document
+      return [document_wrapper(documents)] if parse_type == "exp"
+
+      documents.map { |doc| document_wrapper(doc) }
+    end
+
+    def parse_into_document
+      case parse_type
       when "exp"
-        Lutaml::Express::LutamlPath::DocumentWrapper
-          .new(Lutaml::Express::Parsers::Exp.parse(file))
+        Expressir::ExpressExp::Parser.from_files(file_list.map(&:path))
       when "lutaml"
-        Lutaml::Uml::LutamlPath::DocumentWrapper
-          .new(Lutaml::Uml::Parsers::Dsl.parse(file))
+        file_list.map { |file| Lutaml::Uml::Parsers::Dsl.parse(file) }
+      when "yml"
+        file_list.map { |file| Lutaml::Uml::Parsers::Yaml.parse(file.path) }
       else
         raise ArgumentError, "Unsupported file format"
       end
     end
+
+    private
+
+    def document_wrapper(document)
+      if parse_type == "exp"
+        return Lutaml::Express::LutamlPath::DocumentWrapper.new(document)
+      end
+
+      Lutaml::Uml::LutamlPath::DocumentWrapper.new(document)
+    end
   end
 end

data/lib/lutaml/version.rb

@@ -1,3 +1,3 @@
 module Lutaml
-  VERSION = "0.3.2".freeze
+  VERSION = "0.4.1-alpha.2".freeze
 end

data/lutaml.gemspec

@@ -16,9 +16,12 @@ Gem::Specification.new do |spec|
   spec.metadata["changelog_uri"] = "https://github.com/lutaml/lutaml/releases"
 
   # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  # The `git ls-files -z` loads the files in the RubyGem
+  # that have been added into git.
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+    `git ls-files -z`
+      .split("\x0")
+      .reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.1.pre.alpha.2
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-01 00:00:00.000000000 Z
+date: 2021-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-express
@@ -153,7 +153,8 @@ dependencies:
 description: 'LutaML: data models in textual form'
 email:
 - open.source@ribose.com'
-executables: []
+executables:
+- lutaml
 extensions: []
 extra_rdoc_files: []
 files:
@@ -169,8 +170,15 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- exe/lutaml
 - lib/lutaml.rb
+- lib/lutaml/command_line.rb
 - lib/lutaml/express/lutaml_path/document_wrapper.rb
+- lib/lutaml/formatter.rb
+- lib/lutaml/formatter/base.rb
+- lib/lutaml/formatter/graphviz.rb
+- lib/lutaml/layout/engine.rb
+- lib/lutaml/layout/graph_viz_engine.rb
 - lib/lutaml/lutaml_path/document_wrapper.rb
 - lib/lutaml/parser.rb
 - lib/lutaml/uml/lutaml_path/document_wrapper.rb
@@ -194,9 +202,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.0.3
 signing_key: