lutaml-lml 0.1.0

data/lib/lutaml/lml/format/adapter/mapping.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    module Format
+      module Adapter
+        class Mapping < Lutaml::KeyValue::Mapping
+          def initialize
+            super(:lml)
+          end
+
+          def dup_instance
+            self.class.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/lml/format/adapter/standard_adapter.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    module Format
+      module Adapter
+        class StandardAdapter < Document
+          TYPE_KEY = "__type__"
+
+          def self.parse(data, _options = {})
+            return data if data.is_a?(Hash)
+
+            input = data.is_a?(IO) ? data : StringIO.new(data.to_s)
+            doc = Lutaml::Lml::Pipeline.call(input, resolve: false)
+            instance_to_hash(doc.instance)
+          end
+
+          def initialize(attributes = {}, **options)
+            super
+          end
+
+          def to_lml(_options = {})
+            attrs = @attributes.dup
+            type_name = attrs.delete(TYPE_KEY) || "Data"
+            body = hash_to_lml_body(attrs)
+            "instance #{type_name} {\n#{body}\n}"
+          end
+
+          private
+
+          def self.instance_to_hash(instance)
+            return nil unless instance
+
+            hash = {}
+            hash[TYPE_KEY] = instance.type if instance.type
+
+            Array(instance.attributes).each do |attr|
+              if attr.instances.any?
+                hashes = attr.instances.map { |i| instance_to_hash(i) }
+                hash[attr.name] = attr.instances.one? ? hashes.first : hashes
+              elsif attr.value.is_a?(Array)
+                hash[attr.name] = attr.value.map { |v| primitive_value(v) }
+              elsif !attr.value.nil?
+                hash[attr.name] = primitive_value(attr.value)
+              end
+            end
+
+            if instance.instance
+              hash.merge!(instance_to_hash(instance.instance))
+            end
+
+            hash
+          end
+
+          def self.primitive_value(val)
+            case val
+            when TrueClass, FalseClass then val
+            when Integer, Float then val
+            else val.to_s
+            end
+          end
+
+          def hash_to_lml_body(hash, indent = 1)
+            lines = []
+            prefix = "  " * indent
+
+            hash.each do |key, value|
+              next if key == TYPE_KEY
+
+              lines << format_value(prefix, key, value, indent)
+            end
+
+            lines.join("\n")
+          end
+
+          def format_value(prefix, key, value, indent)
+            case value
+            when Array
+              format_array(prefix, key, value, indent)
+            when Hash
+              format_nested(prefix, key, value, indent)
+            when TrueClass, FalseClass, Integer, Float
+              "#{prefix}#{key} = #{value}"
+            else
+              "#{prefix}#{key} = #{quote_value(value)}"
+            end
+          end
+
+          def format_array(prefix, key, items, indent)
+            elements = items.map do |item|
+              case item
+              when Hash
+                format_nested_instance(item, indent + 1)
+              else
+                "  #{quote_value(item)}"
+              end
+            end
+
+            inner = elements.join(",\n")
+            "#{prefix}#{key} = [\n#{inner}\n#{prefix}]"
+          end
+
+          def format_nested(prefix, key, hash, indent)
+            type_name = hash.fetch(TYPE_KEY, "")
+            inner = hash_to_lml_body(hash, indent + 1)
+            type_clause = type_name.empty? ? "" : " #{type_name}"
+            "#{prefix}#{key} = instance#{type_clause} {\n#{inner}\n#{prefix}}"
+          end
+
+          def format_nested_instance(hash, indent)
+            prefix = "  " * indent
+            type_name = hash.fetch(TYPE_KEY, "")
+            inner = hash_to_lml_body(hash, indent + 1)
+            type_clause = type_name.empty? ? "" : " #{type_name}"
+            "#{prefix}instance#{type_clause} {\n#{inner}\n#{prefix}}"
+          end
+
+          def quote_value(val)
+            return val.to_s if val.is_a?(Numeric) || val.is_a?(TrueClass) || val.is_a?(FalseClass)
+            str = val.to_s
+            str.match?(/^[\w-]+$/) ? str : "\"#{str}\""
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/lml/format/adapter/transform.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    module Format
+      module Adapter
+        class Transform < Lutaml::KeyValue::Transform; end
+      end
+    end
+  end
+end

data/lib/lutaml/lml/format.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    module Format
+      module Adapter
+        autoload :Document, "lutaml/lml/format/adapter/document"
+        autoload :Mapping, "lutaml/lml/format/adapter/mapping"
+        autoload :Transform, "lutaml/lml/format/adapter/transform"
+        autoload :StandardAdapter, "lutaml/lml/format/adapter/standard_adapter"
+      end
+    end
+  end
+end
+
+# ExportTransformer is defined at Lutaml::Model::ExportTransformer but
+# referenced as bare ExportTransformer from KeyValue::Transform. Bridge the gap
+# so constant resolution succeeds for the :lml format's to_lml path.
+unless Lutaml::KeyValue.const_defined?(:ExportTransformer)
+  Lutaml::KeyValue::ExportTransformer = Lutaml::Model::ExportTransformer
+end
+
+Lutaml::Model::FormatRegistry.register(
+  :lml,
+  mapping_class: Lutaml::Lml::Format::Adapter::Mapping,
+  adapter_class: Lutaml::Lml::Format::Adapter::StandardAdapter,
+  transformer: Lutaml::Lml::Format::Adapter::Transform,
+  key_value: true,
+)

data/lib/lutaml/lml/formatter/base.rb

@@ -0,0 +1,79 @@
+# 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
+
+    class Base
+      FORMAT_HANDLERS = {
+        Lml::TopElementAttribute => :format_attribute,
+        Lml::Operation => :format_operation,
+        Lml::Association => :format_relationship,
+        Lml::Document => :format_document,
+        Lml::DataType => :format_class,
+        Lml::UmlClass => :format_class,
+        Lml::Enum => :format_class
+      }.freeze
+
+      class << self
+        def inherited(subclass)
+          super
+          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 Lml::HasAttributes
+
+      def initialize(attributes = {})
+        update_attributes(attributes)
+      end
+
+      def name
+        self.class.name
+      end
+
+      attr_reader :type
+
+      def type=(value)
+        @type = value.to_s.strip.downcase.to_sym
+      end
+
+      def format(node)
+        result = dispatch_format(node)
+        return unless result
+
+        result
+      end
+
+      def dispatch_format(node)
+        handler = FORMAT_HANDLERS.find { |type, _| node.is_a?(type) }&.last
+        return unless handler
+
+        public_send(handler, node)
+      end
+
+      def format_attribute(_node) = raise(NotImplementedError)
+      def format_operation(_node) = raise(NotImplementedError)
+      def format_relationship(_node) = raise(NotImplementedError)
+      def format_class(_node) = raise(NotImplementedError)
+      def format_document(_node) = raise(NotImplementedError)
+    end
+  end
+end

data/lib/lutaml/lml/formatter/graphviz/document_formatter.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Formatter
+    class Graphviz < Base
+      module DocumentFormatter
+        def format_document(node)
+          @fontname = node.fontname || DEFAULT_CLASS_FONT
+          @node['fontname'] = "#{@fontname}-bold"
+
+          hide_members, hide_other_classes = extract_fidelity_options(node)
+          classes = format_all_classes(node, hide_members)
+          associations = build_associations(node, hide_other_classes)
+
+          build_digraph(classes, associations)
+        end
+
+        def extract_fidelity_options(node)
+          if node.fidelity
+            [node.fidelity.hideMembers, node.fidelity.hideOtherClasses]
+          else
+            [nil, nil]
+          end
+        end
+
+        def format_all_classes(node, hide_members)
+          node.all_classes.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")
+        end
+
+        def build_associations(node, hide_other_classes)
+          associations = collect_all_associations(node)
+          associations = sort_by_document_grouping(node.groups, associations) if node.groups
+          classes_names = node.classes.map(&:name)
+          format_filtered_associations(associations, classes_names, hide_other_classes)
+        end
+
+        def collect_all_associations(node)
+          class_level = node.classifiable_classes
+          seen = Set.new
+          all = class_level.filter_map(&:associations).flatten + node.associations
+          all.uniq { |a| association_key(a) }
+        end
+
+        def format_filtered_associations(associations, classes_names, hide_other_classes)
+          associations.filter_map do |assoc_node|
+            next if hide_other_classes && !classes_names.include?(assoc_node.member_end)
+
+            format_relationship(assoc_node)
+          end.join("\n")
+        end
+
+        def build_digraph(classes, associations)
+          indented_classes = indent_lines(classes)
+          indented_assocs = indent_lines(associations)
+
+          <<~HEREDOC
+            digraph G {
+              graph [#{@graph}]
+              edge [#{@edge}]
+              node [#{@node}]
+
+            #{indented_classes}
+
+            #{indented_assocs}
+            }
+          HEREDOC
+        end
+
+        def indent_lines(text)
+          text.lines.map { |line| "  #{line}" }.join.chomp
+        end
+
+        private
+
+        def association_key(assoc)
+          [assoc.owner_end.to_s, assoc.member_end.to_s, assoc.name.to_s]
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/lml/formatter/graphviz/html_builder.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Formatter
+    class Graphviz < Base
+      module HtmlBuilder
+        EMPTY_MEMBER_TABLE = <<~HEREDOC.chomp
+          <TABLE BORDER="0" CELLPADDING="0" CELLSPACING="0">
+            <TR><TD ALIGN="LEFT"></TD></TR>
+          </TABLE>
+        HEREDOC
+
+        def escape_html_chars(text)
+          text
+            .gsub('&', '&amp;')
+            .gsub('<', '&#60;')
+            .gsub('>', '&#62;')
+            .gsub('[', '&#91;')
+            .gsub(']', '&#93;')
+        end
+
+        def format_member_rows(members, hide_members, &formatter)
+          return EMPTY_MEMBER_TABLE if hide_members || !members&.any?
+
+          formatter ||= method(:dispatch_format)
+          field_rows = members.map do |member|
+            %(<TR><TD ALIGN="LEFT">#{formatter.call(member)}</TD></TR>)
+          end
+          build_member_table(field_rows)
+        end
+
+        def format_enum_member(member)
+          enum_literal?(member) ? format_enum_literal(member) : dispatch_format(member)
+        end
+
+        def enum_literal?(node)
+          node.is_a?(Lml::TopElementAttribute) &&
+            node.type.nil? && node.cardinality.nil?
+        end
+
+        def build_member_table(field_rows)
+          indented = field_rows.map { |row| (' ' * 10) + row }.join("\n")
+          <<~HEREDOC.chomp
+            <TABLE BORDER="0" CELLPADDING="0" CELLSPACING="0">
+              #{indented}
+            </TABLE>
+          HEREDOC
+            .concat("\n")
+            .concat(' ' * 6)
+        end
+
+        def build_name_table(name_parts)
+          <<~HEREDOC
+            <TABLE BORDER="0" CELLPADDING="0" CELLSPACING="0">
+              #{name_parts.map { |n| %(<TR><TD ALIGN="CENTER">#{n}</TD></TR>) }.join("\n")}
+            </TABLE>
+          HEREDOC
+        end
+
+        def build_table_body(name_html, field_table, method_table)
+          [name_html, field_table, method_table].compact.filter_map do |type|
+            <<~TEXT
+              <TR>
+                <TD>#{type}</TD>
+              </TR>
+            TEXT
+          end.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/lml/formatter/graphviz/node_formatter.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Formatter
+    class Graphviz < Base
+      module NodeFormatter
+        ACCESS_SYMBOLS = {
+          'public' => '+',
+          'protected' => '#',
+          'private' => '-'
+        }.freeze
+
+        def format_attribute(node)
+          symbol = ACCESS_SYMBOLS[node.visibility]
+          result = "#{symbol}#{node.name}"
+          if node.type
+            keyword = node.keyword ? "«#{node.keyword}»" : ''
+            result += " : #{keyword}#{node.type}"
+          end
+          result += format_cardinality_bounds(node.cardinality) if node.cardinality
+          result = escape_html_chars(result)
+          result = "<U>#{result}</U>" if node.static
+          result
+        end
+
+        def format_cardinality_bounds(cardinality)
+          min = cardinality.min || '*'
+          max = cardinality.max || '*'
+          "[#{min}..#{max}]"
+        end
+
+        def format_operation(node)
+          symbol = ACCESS_SYMBOLS[node.visibility]
+          params = format_operation_params(node.owned_parameter)
+          result = "#{symbol} #{node.name}(#{params})"
+          result << " : #{node.return_type}" if node.return_type
+          result = escape_html_chars(result)
+          result = "<U>#{result}</U>" if node.is_static
+          result = "<I>#{result}</I>" if node.is_abstract
+          result
+        end
+
+        def format_operation_params(params)
+          return '' unless params&.any?
+
+          params.map do |param|
+            param.type ? "#{param.name} : #{param.type}" : param.name.to_s
+          end.join(', ')
+        end
+
+        def format_class(node, hide_members = nil)
+          name = ["<B>#{escape_html_chars(node.name)}</B>"]
+          name.unshift("«#{escape_html_chars(node.keyword)}»") if node.keyword
+          name_html = build_name_table(name)
+
+          member_formatter = node.is_a?(Lml::Enum) ? method(:format_enum_member) : nil
+          field_table = format_member_rows(node.attributes, hide_members, &member_formatter)
+          method_table = format_member_rows(node.operations, hide_members) if node.operations&.any?
+          table_body = build_table_body(name_html, field_table, method_table)
+
+          <<~HEREDOC.chomp
+            <TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0" CELLPADDING="10">
+              #{table_body}
+            </TABLE>
+          HEREDOC
+        end
+
+        def format_enum_literal(node)
+          "<I>#{escape_html_chars(node.name.to_s)}</I>"
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/lml/formatter/graphviz/relationship_formatter.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Formatter
+    class Graphviz < Base
+      module RelationshipFormatter
+        ARROW_TYPES = {
+          'composition' => 'diamond',
+          'aggregation' => 'odiamond',
+          'direct' => 'vee'
+        }.freeze
+
+        DASHED_TYPES = %w[dependency realizes].freeze
+
+        DIRECTION_LABELS = {
+          'target' => '%s ▶',
+          'source' => '◀ %s'
+        }.freeze
+
+        def format_relationship(node)
+          graph_parent_name = generate_graph_name(node.owner_end)
+          graph_node_name = generate_graph_name(node.member_end)
+          attributes = build_edge_attributes(node)
+          graph_attributes = " [#{attributes}]" unless attributes.empty?
+
+          "#{graph_parent_name} -> #{graph_node_name}#{graph_attributes}"
+        end
+
+        def build_edge_attributes(node)
+          attrs = Attributes.new
+
+          apply_edge_style(attrs, node)
+          apply_edge_direction(attrs, node)
+          apply_edge_labels(attrs, node)
+          apply_arrow_types(attrs, node)
+          maybe_swap_labels(attrs)
+
+          attrs
+        end
+
+        def format_label(name, cardinality = nil)
+          res = "+#{name}"
+          return res if cardinality.nil? || cardinality.min.nil? || cardinality.max.nil?
+
+          "#{res} #{cardinality.min}..#{cardinality.max}"
+        end
+
+        private
+
+        def sort_by_document_grouping(groups, associations)
+          result = []
+          seen = Set.new
+
+          groups.each do |group|
+            group.values.each do |group_name|
+              matches = associations.select { |a| a.owner_end == group_name }
+              matches.each { |a| add_unseen(a, result, seen) }
+            end
+          end
+          associations.each { |a| add_unseen(a, result, seen) }
+          result
+        end
+
+        def add_unseen(association, result, seen)
+          return if seen.include?(association)
+
+          result.push(association)
+          seen.add(association)
+        end
+
+        def apply_edge_style(attrs, node)
+          attrs['style'] = 'dashed' if DASHED_TYPES.include?(node.member_end_type)
+        end
+
+        def apply_edge_direction(attrs, node)
+          attrs['dir'] = if node.owner_end_type && node.member_end_type
+                           'both'
+                         elsif node.owner_end_type
+                           'back'
+                         else
+                           'direct'
+                         end
+        end
+
+        def apply_edge_labels(attrs, node)
+          apply_verb_label(attrs, node)
+          apply_direction_label(attrs, node)
+          apply_endpoint_labels(attrs, node)
+        end
+
+        def apply_verb_label(attrs, node)
+          attrs['label'] = node.action.verb if node&.action&.verb
+        end
+
+        def apply_direction_label(attrs, node)
+          return unless node&.action&.direction
+
+          template = DIRECTION_LABELS[node.action.direction]
+          attrs['label'] = template % attrs['label'] if template
+        end
+
+        def apply_endpoint_labels(attrs, node)
+          if node.owner_end_attribute_name
+            attrs['headlabel'] = format_label(
+              node.owner_end_attribute_name, node.owner_end_cardinality
+            )
+          end
+
+          return unless node.member_end_attribute_name
+
+          attrs['taillabel'] = format_label(
+            node.member_end_attribute_name, node.member_end_cardinality
+          )
+        end
+
+        def apply_arrow_types(attrs, node)
+          attrs['arrowtail'] = ARROW_TYPES.fetch(node.owner_end_type, 'onormal')
+          attrs['arrowhead'] = ARROW_TYPES.fetch(node.member_end_type, 'onormal')
+        end
+
+        def maybe_swap_labels(attrs)
+          return unless attrs['dir'] == 'back' && attrs['arrowtail'] != 'vee'
+
+          attrs['arrowhead'], attrs['arrowtail'] = [attrs['arrowtail'], attrs['arrowhead']]
+          attrs['headlabel'], attrs['taillabel'] = [attrs['taillabel'], attrs['headlabel']]
+        end
+      end
+    end
+  end
+end