lutaml-lml 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8bdefb219dd99a2335669d57b9e7a79a21d822485ebc1a3748d915dee88d2901
-  data.tar.gz: a63770177d2c8ff0b85e0d30caa6c9033529c75eee9738fbe59b25dc7c1d30eb
+  metadata.gz: 41662922310b1ec54e30485a3ec783c99f385f5e80eb0e4a98277b72ac5a71dc
+  data.tar.gz: 2b6030ded9c8bb82941ceefdf5e1df9a8531af5a61888faee4ecbc23df0ca961
 SHA512:
-  metadata.gz: 3e12f920e7b614aa4902cd953e311fdde4dae2cd93a15bd9c5fe10b1c0ca234412a8228ca6cf2f0d22956ddb67cfd681127dedac417d43cd9b0c5b962e3e777a
-  data.tar.gz: c7a727c6d617731e160d1ad6bebbba053cd6216a10c93c2d177f391881f0405f0304b3bd7a28230c18cd85cddb3383ff7639a348b36489f142d1e6c6e052ec76
+  metadata.gz: 94f5275ce72d247c2842a60b265bdc8980cf82b49ce45d1970b606a0a9329505776235efb2df3247165b40cd5aaccc977b9aadcf77eb4ad044119ec71e4ea0a7
+  data.tar.gz: bfe8561322f20e76736e00a6c67ab862207e344637097f270a1111c7a5edbc540f8137989858e8fe3584dbaded200fe150c35da83523a637d26523f9cc64f8e6

data/lib/lutaml/lml/cli.rb

@@ -37,7 +37,12 @@ module Lutaml
 
       def initialize(*args)
         super
-        @formatter = ::Lutaml::Formatter::Graphviz.new if defined?(::Lutaml::Formatter::Graphviz)
+        @formatter = case options[:layout]
+                     when 'elk'
+                       ::Lutaml::Formatter::Elk.new
+                     else
+                       ::Lutaml::Formatter::Graphviz.new
+                     end
         @out_object = $stdout
       end
 
@@ -71,6 +76,8 @@ module Lutaml
                            desc: 'Node attributes (key=value,key2=value2)'
       method_option :all, type: :string, aliases: '-a',
                           desc: 'Set attributes for graph, edge, and node'
+      method_option :layout, type: :string, enum: %w[graphviz elk], default: 'graphviz',
+                             desc: 'Layout engine (elk requires the elkrb gem)'
       def generate(*paths)
         assert_input_paths(paths)
 

data/lib/lutaml/lml/document_builder.rb

@@ -72,6 +72,16 @@ module Lutaml
       def set_model(model, hash)
         hash = build_members(model, hash)
         set_model_attributes(model, hash)
+        expand_class_specializer(model, hash)
+      end
+
+      # The prefix specializer (`abstract class Foo`) expands to the
+      # canonical `abstract true` declaration (RS 3001 par. Declaration
+      # modifiers); the class-level modifier capture is not a block member.
+      def expand_class_specializer(model, hash)
+        return unless hash[:modifier].to_s == 'abstract' && model.class.attributes.key?(:is_abstract)
+
+        model.is_abstract = true
       end
 
       def set_model_attributes(model, hash)
@@ -83,12 +93,24 @@ module Lutaml
       def build_members(model, hash)
         members = hash.delete(:members)
         members.to_a.each do |member_hash|
+          record_model_version(model, member_hash)
           add_members(model, member_hash)
           set_model_attributes(model, member_hash)
         end
         hash
       end
 
+      # A `models <Name> version "x.y.z"` header travels with the block's
+      # member hash; the block itself flattens into the document, so the
+      # version is recorded on the document before the name is dropped.
+      def record_model_version(model, hash)
+        return unless model.class.attributes.key?(:model_versions)
+        return unless hash.key?(:version)
+
+        name = hash[:name].to_s
+        model.model_versions[name] = unquote(hash.delete(:version)).to_s
+      end
+
       def apply_attribute(model, key, value)
         return unless model.class.attributes.key?(key.to_sym)
 
@@ -159,9 +181,7 @@ module Lutaml
         rules = rules.filter_map do |entry|
           next nil unless entry.is_a?(Hash)
 
-          if entry[:wire] && entry[:to]
-            next { kind: 'map', wire: unquote(entry[:wire]), field: unquote(entry[:to]) }
-          end
+          next { kind: 'map', wire: unquote(entry[:wire]), field: unquote(entry[:to]) } if entry[:wire] && entry[:to]
 
           first_key = entry.keys.first
           kind = first_key.to_s
@@ -172,6 +192,7 @@ module Lutaml
 
             term = unquote(body)
             next { kind: kind_n, wire: term, field: term } if %w[element attribute map].include?(kind_n)
+
             if kind_n == 'namespace'
               mapping[:namespace_ref] = term
               next nil
@@ -237,6 +258,7 @@ module Lutaml
       # `value` members, mapping sections, class declarations, enum
       # member_fields and from_table all arrive as bare member hashes.
       def expand_declared_members(model, hash)
+        expand_abstract_declaration(model, hash)
         expand_definition_text(model, hash)
         expand_value_declaration(model, hash)
         expand_value_set_declaration(model, hash)
@@ -244,10 +266,57 @@ module Lutaml
         expand_class_declarations(model, hash)
         expand_enum_member_fields(model, hash)
         expand_from_table(model, hash)
+        expand_operation_members(model, hash)
+      end
+
+      # Operation members arrive with grammar capture names
+      # (`visibility_modifier`, `param_default`) and per-iteration
+      # stereotype hashes; normalize to the model's field names.
+      def expand_operation_members(model, hash)
+        ops = hash.delete(:operations)
+        return unless ops && model.class.attributes.key?(:operations)
+
+        Array(ops.is_a?(Hash) ? [ops] : ops).each do |op|
+          model.operations << build(:operation, normalize_operation_hash(op))
+        end
+      end
+
+      def normalize_operation_hash(op)
+        op = op.dup
+        if (vis = op.delete(:visibility_modifier))
+          op[:visibility] = Transform::VISIBILITY_MAP.fetch(vis.to_s, 'public')
+        end
+        stereo = op[:stereotype]
+        if stereo
+          items = stereo.is_a?(Array) ? stereo : [stereo]
+          op[:stereotype] = items.map { |x| x.is_a?(Hash) ? x[:stereotype].to_s : x.to_s }
+        end
+        params = op[:owned_parameter]
+        if params
+          list = params.is_a?(Array) ? params : [params]
+          op[:owned_parameter] = list.map { |param| normalize_operation_param(param) }
+        end
+        op
+      end
+
+      def normalize_operation_param(param)
+        param = param.dup
+        if (default = param.delete(:param_default))
+          param[:default] = default.is_a?(Hash) ? default[:string].to_s : default.to_s
+        end
+        param
       end
 
       # RS 3001 §Definition single-line form (`definition "text"`) arrives
       # as a quoted-string capture; unwrap it for the entity's definition.
+      # RS 3001 declaration modifiers: `abstract true` maps onto the
+      # is_abstract field (the visibility declaration flows through the
+      # generic attribute path).
+      def expand_abstract_declaration(model, hash)
+        value = hash.delete(:abstract)
+        model.is_abstract = true if value.to_s == 'true' && model.class.attributes.key?(:is_abstract)
+      end
+
       def expand_definition_text(model, hash)
         return unless hash.key?(:definition) && model.class.attributes.key?(:definition)
 

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

@@ -70,6 +70,8 @@ module Lutaml
           end
 
           def format_value(prefix, key, value, indent)
+            return "#{prefix}#{key} = ref:(#{value[:reference]})" if reference_value?(value)
+
             case value
             when Array
               format_array(prefix, key, value, indent)
@@ -84,11 +86,15 @@ module Lutaml
 
           def format_array(prefix, key, items, indent)
             elements = items.map do |item|
-              case item
-              when Hash
-                format_nested_instance(item, indent + 1)
+              if reference_value?(item)
+                "  ref:(#{item[:reference]})"
               else
-                "  #{quote_value(item)}"
+                case item
+                when Hash
+                  format_nested_instance(item, indent + 1)
+                else
+                  "  #{quote_value(item)}"
+                end
               end
             end
 
@@ -111,6 +117,13 @@ module Lutaml
             "#{prefix}instance#{type_clause} {\n#{inner}\n#{prefix}}"
           end
 
+          # RS 3001 par. Value type: a `reference` map is the wire form of a
+          # reference literal; it emits as `ref:(path)`, never as a nested
+          # instance.
+          def reference_value?(value)
+            value.is_a?(Hash) && value.keys == [:reference]
+          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

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Formatter
+    # ELK-layout diagram formatter: builds an Elkrb::Graph from the
+    # document, lays it out in-process (no external tools) and emits SVG,
+    # or converts the SVG to PS/EPS/EMF through vectory.
+    class Elk
+      VALID_TYPES = %i[svg ps eps emf].freeze
+
+      attr_reader :type
+
+      def initialize(_attributes = {})
+        @type = :svg
+      end
+
+      def type=(value)
+        @type = value.to_sym
+        return if VALID_TYPES.include?(@type)
+
+        raise ArgumentError,
+              "unsupported output type #{@type.inspect} (valid: #{VALID_TYPES.join(', ')})"
+      end
+
+      def format(document)
+        graph = Lutaml::Layout::ElkGraphBuilder.new.build(document)
+        svg = Lutaml::Layout::ElkEngine.new(input: graph).render(:svg)
+        @type == :svg ? svg : convert(svg)
+      end
+
+      private
+
+      def convert(svg)
+        require 'vectory'
+        Vectory::Svg.new(svg).public_send(:"to_#{@type}").content
+      rescue LoadError
+        raise Error, 'The vectory gem is required for PS/EPS/EMF output: ' \
+                     'add `gem "vectory"` to your Gemfile'
+      end
+    end
+  end
+end

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

@@ -7,7 +7,8 @@ module Lutaml
         ACCESS_SYMBOLS = {
           'public' => '+',
           'protected' => '#',
-          'private' => '-'
+          'private' => '-',
+          'package' => '~'
         }.freeze
 
         def format_attribute(node)

data/lib/lutaml/lml/formatter.rb

@@ -4,5 +4,6 @@ module Lutaml
   module Formatter
     autoload :Base, "lutaml/lml/formatter/base"
     autoload :Graphviz, "lutaml/lml/formatter/graphviz"
+    autoload :Elk, "lutaml/lml/formatter/elk"
   end
 end