lutaml-lml 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8bdefb219dd99a2335669d57b9e7a79a21d822485ebc1a3748d915dee88d2901
-  data.tar.gz: a63770177d2c8ff0b85e0d30caa6c9033529c75eee9738fbe59b25dc7c1d30eb
+  metadata.gz: c44e08a243084f376e006dfa845a878267d5867d1c07e9cb2f957cadfdf593af
+  data.tar.gz: 56b169b4f31489f51713071e48002ec2b0babc8f6b510aa6660e7b02976b0f93
 SHA512:
-  metadata.gz: 3e12f920e7b614aa4902cd953e311fdde4dae2cd93a15bd9c5fe10b1c0ca234412a8228ca6cf2f0d22956ddb67cfd681127dedac417d43cd9b0c5b962e3e777a
-  data.tar.gz: c7a727c6d617731e160d1ad6bebbba053cd6216a10c93c2d177f391881f0405f0304b3bd7a28230c18cd85cddb3383ff7639a348b36489f142d1e6c6e052ec76
+  metadata.gz: 12590d775d46b14bbefe7733610b6b60c08ddaa169e6aa3e4010b13979e565d36bde270adffc5e7ef6cdb37c9fbcadedb16d66b0bbc1e6404d74c46da5b2c1ec
+  data.tar.gz: 1dcf78fc5244594d03992cdb8dd4b2e286c0069741b3985bad2667ea1752eab19534aa16878e9e2c80ac3ab4b0c5c2381756634590a99df1070e72a0e6b7bf83

data/lib/lutaml/lml/cli.rb

@@ -30,14 +30,19 @@ module Lutaml
         'exp' => lambda { |path|
           require 'lutaml/express'
           Lutaml::Express::Parsers::Exp.parse(File.new(path))
-        }
+        },
       }.freeze
 
       FORMATTER_ATTR_TARGETS = %i[graph edge node].freeze
 
       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)
 
@@ -108,36 +115,95 @@ module Lutaml
         Parse an LML file containing model definitions and compile them
         into Ruby classes that can be used to instantiate and validate data.
 
-        The compiled classes are anonymous Serializable subclasses registered
-        in the ModelCompiler. With --namespace, classes are also registered
-        as constants in the given module.
+        With --namespace, classes are registered as constants in the given
+        module (created if absent).
+
+        With --schema, emits a JSON Schema or YAML Schema document for every
+        compiled model instead of the compile listing. Schema output requires
+        named classes, so --namespace defaults to Lutaml::Lml::Generated when omitted.
 
         Examples:
           lutaml lml compile models.lml
 
           lutaml lml compile models.lml --namespace MyModels
+
+          lutaml lml compile models.lml --schema json -o schemas/
+
+          lutaml lml compile models.lml --schema yaml -o widget.schema.yaml
       DESC
       method_option :namespace, type: :string, aliases: '-n',
-                             desc: 'Register compiled classes in a module'
+                                desc: 'Register compiled classes in a module (created if absent)'
+      method_option :schema, type: :string, enum: %w[json yaml],
+                             desc: 'Emit JSON Schema or YAML Schema for the compiled models'
+      method_option :output, type: :string, aliases: '-o',
+                             desc: 'Schema output path (file for one model, directory for many)'
       def compile(path)
         raise Thor::Error, "File does not exist: #{path}" unless File.exist?(path)
 
-        ns = options[:namespace] ? resolve_namespace(options[:namespace]) : nil
-        result = Lutaml::Lml::ModelCompiler.new(namespace: ns).compile(File.new(path))
+        ns = options[:namespace] || (::Lutaml::Lml::ModelCompiler::DEFAULT_NAMESPACE if options[:schema])
+        result = File.open(path) { |file| Lutaml::Lml::ModelCompiler.new(namespace: ns).compile(file) }
+        return emit_schemas(result) if options[:schema]
 
-        result.each_key do |name|
-          say "  compiled: #{name}", :green
-        end
-        say "\n#{result.size} class(es) compiled", :green
+        report_compilation(result)
       end
 
       no_commands do
-        def resolve_namespace(name)
-          name.split('::').reduce(Object) do |mod, const_name|
-            mod.const_get(const_name)
+        def report_compilation(result)
+          result.each_key do |name|
+            say "  compiled: #{name}", :green
+          end
+          say "\n#{result.size} class(es) compiled", :green
+        end
+
+        def emit_schemas(result)
+          require 'lutaml/model/schema'
+          if options[:output] && Pathname.new(options[:output]).directory?
+            generator = "to_#{options[:schema]}"
+            schemas = result.transform_values do |klass|
+              Lutaml::Model::Schema.public_send(generator, klass, pretty: true)
+            end
+            write_schemas(schemas)
+          else
+            # One multi-root document covers every compiled model; each
+            # root stays addressable under $defs by class name.
+            schema = generate_multi_root_schema(result)
+            return puts schema unless options[:output]
+
+            File.write(options[:output], schema)
+            say "Generated: #{options[:output]}", :green
+          end
+        end
+
+        def generate_multi_root_schema(result)
+          klass = options[:schema] == 'yaml' ? Lutaml::Model::Schema::YamlSchema : Lutaml::Model::Schema::JsonSchema
+          klass.generate_many(result.values, pretty: true)
+        end
+
+        def write_schemas(schemas)
+          target = Pathname.new(options[:output])
+          if schemas.size > 1
+            unless target.directory?
+              raise Thor::Error,
+                    'Output path must be a directory if multiple schemas ' \
+                    'are generated'
+            end
+            write_schema_files(target, schemas)
+          else
+            target.write(schemas.values.first)
+            say "Generated: #{target}", :green
           end
-        rescue NameError
-          raise Thor::Error, "Namespace '#{name}' not found"
+        end
+
+        def write_schema_files(dir, schemas)
+          schemas.each do |name, schema|
+            file = dir.join("#{schema_file_stem(name)}.#{options[:schema]}")
+            file.write(schema)
+            say "Generated: #{file}", :green
+          end
+        end
+
+        def schema_file_stem(name)
+          name.split('::').last.gsub(/[^a-zA-Z0-9]+/, '_').downcase
         end
 
         def assert_input_paths(paths)
@@ -175,7 +241,7 @@ module Lutaml
         def write_output(input_path, result)
           target = resolve_output_path(input_path)
           if target.is_a?(Pathname)
-            target.open('w+') { |f| f.write(result) }
+            target.open('wb+') { |f| f.write(result) }
             say "Generated: #{target}", :green
           else
             target.puts(result)

data/lib/lutaml/lml/data_processor/value_processing.rb

@@ -4,13 +4,14 @@ module Lutaml
   module Lml
     class DataProcessor
       module ValueProcessing
-        VALUE_TYPE_KEYS = %i[instance list string boolean key_value_map number float condition require].freeze
+        VALUE_TYPE_KEYS = %i[instance list string boolean null key_value_map number float condition require].freeze
 
         VALUE_TYPE_HANDLERS = {
           instance: :handle_instance_value,
           list: :handle_list_value,
           string: :handle_string_value,
           boolean: :handle_boolean_value,
+          null: :handle_null_value,
           key_value_map: :handle_key_value_map,
           number: :handle_number_value,
           float: :handle_float_value,
@@ -50,6 +51,10 @@ module Lutaml
           ['Boolean', value[:boolean] == 'true']
         end
 
+        def handle_null_value(_key, _value)
+          ['Null', nil]
+        end
+
         def handle_key_value_map(_key, value)
           process_key_value_map(value[:key_value_map])
         end

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/mapping.rb

@@ -12,6 +12,18 @@ module Lutaml
           def dup_instance
             self.class.new
           end
+
+          # RS 3001 §String values: a present value — including a
+          # zero-length string — is distinct from an absent one, so the
+          # lml format emits empty values. Nil stays omitted: absence is
+          # the unassigned line, not a rendered null.
+          def map(name = nil, to: nil, render_empty: true, **options, &block)
+            super(name, to: to, render_empty: render_empty, **options, &block)
+          end
+          # The parent's `alias map_element map` binds the alias to the
+          # parent method at definition time, so it bypasses the map
+          # override above; default_mappings goes through map_element.
+          alias map_element map
         end
       end
     end

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

@@ -4,9 +4,21 @@ module Lutaml
   module Lml
     module Format
       module Adapter
+        # Serializes instance data to and from LML instance syntax on
+        # behalf of the lutaml-model format registry (to_lml/from_lml on
+        # compiled classes).
         class StandardAdapter < Document
           TYPE_KEY = "__type__"
 
+          # The grammar's `word` rule is [A-Za-z0-9_] only (lml.parg) and
+          # `variable = quoted_string / 1*word` — a bare value is a run of
+          # word characters and nothing else. Anything else (a dash, a
+          # space, a digit-leading date...) commits the value parser to
+          # `number` or fails re-parsing, so it must be emitted quoted.
+          # This predicate is the single source of truth for the emit
+          # side; the parse side is pinned by the grammar itself.
+          BARE_WORD = /\A\w+\z/
+
           def self.parse(data, _options = {})
             return data if data.is_a?(Hash)
 
@@ -22,8 +34,6 @@ module Lutaml
             "instance #{type_name} {\n#{body}\n}"
           end
 
-          private
-
           def self.instance_to_hash(instance)
             return nil unless instance
 
@@ -41,20 +51,18 @@ module Lutaml
               end
             end
 
-            if instance.instance
-              hash.merge!(instance_to_hash(instance.instance))
-            end
+            hash.merge!(instance_to_hash(instance.instance)) if instance.instance
 
             hash
           end
 
           def self.primitive_value(val)
             case val
-            when TrueClass, FalseClass then val
-            when Integer, Float then val
+            when TrueClass, FalseClass, Integer, Float then val
             else val.to_s
             end
           end
+          private_class_method :primitive_value
 
           def hash_to_lml_body(hash, indent = 1)
             lines = []
@@ -70,6 +78,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 +94,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,10 +125,25 @@ 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
-            str.match?(/^[\w-]+$/) ? str : "\"#{str}\""
+            return str if str.match?(BARE_WORD)
+
+            # RS 3001 §String values: escape backslash and double quote;
+            # every value is representable in double quotes.
+            # gsub replacement strings re-interpret backslash pairs, so
+            # the backslash doubling uses the block form.
+            escaped = str.gsub('\\') { |bs| bs + bs }.gsub('"') { |q| '\\' + q }
+            "\"#{escaped}\""
           end
         end
       end

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

@@ -0,0 +1,45 @@
+# 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,
+    # PS/EPS/EMF through vectory, or PDF through the pdfrb-backed
+    # SvgPdf renderer.
+    class Elk
+      VALID_TYPES = %i[svg ps eps emf pdf].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)
+        return SvgPdf.new(svg).render if @type == :pdf
+
+        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/svg_pdf/path_parser.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Formatter
+    class SvgPdf
+      # Minimal SVG path data parser: absolute and relative M/m, L/l,
+      # H/h, V/v, C/c, Z/z — enough for ELK geometry and arrow shapes.
+      class PathParser
+        Point = Struct.new(:x, :y)
+        Line = Struct.new(:point) do
+          def last_point
+            point
+          end
+        end
+        Curve = Struct.new(:c1, :c2, :point) do
+          def last_point
+            point
+          end
+        end
+        Close = Struct.new(:last_point)
+
+        attr_reader :subpaths
+
+        def initialize(d, dx, dy)
+          @dx = dx
+          @dy = dy
+          parse(d)
+        end
+
+        private
+
+        def parse(d)
+          tokens = d.scan(/[MmLlHhVvCcZz]|-?\d*\.?\d+(?:[eE][-+]?\d+)?/)
+          current = Point.new(0.0, 0.0)
+          start = current
+          @subpaths = [[]]
+          i = 0
+          while i < tokens.size
+            cmd = tokens[i]
+            i += 1
+            case cmd
+            when 'Z', 'z'
+              @subpaths.last << Close.new(start)
+              current = start.dup
+            when 'M', 'm'
+              current, start = move_to(tokens, i, current, cmd == 'm')
+              i += 2
+              @subpaths << [] if cmd == 'm'
+            when 'L', 'l'
+              current = line_to(tokens, i, current, cmd == 'l')
+              i += 2
+            when 'H', 'h'
+              current = h_line(tokens, i, current, cmd == 'h')
+              i += 1
+            when 'V', 'v'
+              current = v_line(tokens, i, current, cmd == 'v')
+              i += 1
+            when 'C', 'c'
+              current = curve_to(tokens, i, current, cmd == 'c')
+              i += 6
+            end
+          end
+          finish
+        end
+
+        def move_to(tokens, i, current, relative)
+          x = num(tokens, i)
+          y = num(tokens, i + 1)
+          point = relative ? Point.new(current.x + x, current.y + y) : Point.new(x, y)
+          [point, point.dup]
+        end
+
+        def line_to(tokens, i, current, relative)
+          x = num(tokens, i)
+          y = num(tokens, i + 1)
+          point = relative ? Point.new(current.x + x, current.y + y) : Point.new(x, y)
+          @subpaths.last << Line.new(point.dup)
+          point
+        end
+
+        def h_line(tokens, i, current, relative)
+          x = num(tokens, i) + (relative ? current.x : 0)
+          point = Point.new(x, current.y)
+          @subpaths.last << Line.new(point.dup)
+          point
+        end
+
+        def v_line(tokens, i, current, relative)
+          y = num(tokens, i) + (relative ? current.y : 0)
+          point = Point.new(current.x, y)
+          @subpaths.last << Line.new(point.dup)
+          point
+        end
+
+        def curve_to(tokens, i, current, relative)
+          c1 = Point.new(num(tokens, i), num(tokens, i + 1))
+          c2 = Point.new(num(tokens, i + 2), num(tokens, i + 3))
+          to = Point.new(num(tokens, i + 4), num(tokens, i + 5))
+          if relative
+            c1 = Point.new(c1.x + current.x, c1.y + current.y)
+            c2 = Point.new(c2.x + current.x, c2.y + current.y)
+            to = Point.new(to.x + current.x, to.y + current.y)
+          end
+          @subpaths.last << Curve.new(c1, c2, to)
+          to
+        end
+
+        def num(tokens, i)
+          tokens[i].to_f
+        end
+
+        def finish
+          @subpaths.map { |segments| segments.map { |s| offset(s) } }
+                   .reject(&:empty?)
+        end
+
+        def offset(segment)
+          case segment
+          when Line
+            Line.new(shift(segment.point))
+          when Curve
+            Curve.new(shift(segment.c1), shift(segment.c2), shift(segment.point))
+          else
+            segment
+          end
+        end
+
+        def shift(point)
+          Point.new(point.x + @dx, point.y + @dy)
+        end
+      end
+    end
+  end
+end