lutaml-uml 0.1.0 → 0.2.4

data/lib/lutaml/uml/formatter/graphviz.rb

@@ -0,0 +1,334 @@
+# frozen_string_literal: true
+
+require "open3"
+require "lutaml/uml/formatter/base"
+require "lutaml/layout/graph_viz_engine"
+
+module Lutaml
+  module Uml
+    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
+end

data/lib/lutaml/uml/has_attributes.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Uml
+    module HasAttributes
+      def update_attributes(attributes = {})
+        attributes.to_h.each do |name, value|
+          value = value.respond_to?(:str) ? value.str : value
+          public_send("#{name}=", value)
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/uml/has_members.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Uml
+    module HasMembers
+      class UnknownMemberTypeError < StandardError; end
+
+      # TODO: move to Parslet::Transform
+      def members=(value)
+        value.group_by { |member| member.keys.first }
+          .each do |(type, group)|
+            attribute_value = group.map(&:values).flatten
+            if attribute_value.length == 1 && !attribute_value.first.is_a?(Hash)
+              next public_send("#{associtaion_type(type)}=", attribute_value.first)
+            end
+
+            public_send("#{associtaion_type(type)}=", attribute_value)
+          end
+      end
+
+      private
+
+      def associtaion_type(type)
+        return type if respond_to?("#{type}=")
+
+        raise(UnknownMemberTypeError, "Unknown member type: #{type}")
+      end
+    end
+  end
+end

data/lib/lutaml/uml/instance.rb

@@ -1,12 +1,17 @@
-module Lutaml::Uml
+# frozen_string_literal: true
 
-class Instance < TopElement
-	attr_accessor :classifier, :slot
-	def initialize
-		@name = nil
-		@xmi_id = nil
-		@xmi_uuid = nil
-		@classifier = nil
-		@slot = []
-	end
+module Lutaml
+  module Uml
+    class Instance < TopElement
+      attr_accessor :classifier, :slot
+
+      def initialize
+        @name = nil
+        @xmi_id = nil
+        @xmi_uuid = nil
+        @classifier = nil
+        @slot = []
+      end
+    end
+  end
 end

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

@@ -0,0 +1,28 @@
+# 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

@@ -0,0 +1,265 @@
+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