lutaml-lml 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41662922310b1ec54e30485a3ec783c99f385f5e80eb0e4a98277b72ac5a71dc
-  data.tar.gz: 2b6030ded9c8bb82941ceefdf5e1df9a8531af5a61888faee4ecbc23df0ca961
+  metadata.gz: c44e08a243084f376e006dfa845a878267d5867d1c07e9cb2f957cadfdf593af
+  data.tar.gz: 56b169b4f31489f51713071e48002ec2b0babc8f6b510aa6660e7b02976b0f93
 SHA512:
-  metadata.gz: 94f5275ce72d247c2842a60b265bdc8980cf82b49ce45d1970b606a0a9329505776235efb2df3247165b40cd5aaccc977b9aadcf77eb4ad044119ec71e4ea0a7
-  data.tar.gz: bfe8561322f20e76736e00a6c67ab862207e344637097f270a1111c7a5edbc540f8137989858e8fe3584dbaded200fe150c35da83523a637d26523f9cc64f8e6
+  metadata.gz: 12590d775d46b14bbefe7733610b6b60c08ddaa169e6aa3e4010b13979e565d36bde270adffc5e7ef6cdb37c9fbcadedb16d66b0bbc1e6404d74c46da5b2c1ec
+  data.tar.gz: 1dcf78fc5244594d03992cdb8dd4b2e286c0069741b3985bad2667ea1752eab19534aa16878e9e2c80ac3ab4b0c5c2381756634590a99df1070e72a0e6b7bf83

data/lib/lutaml/lml/cli.rb

@@ -30,7 +30,7 @@ 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
@@ -115,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)
@@ -182,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/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 = []
@@ -126,8 +134,16 @@ module Lutaml
 
           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

@@ -4,9 +4,10 @@ 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.
+    # PS/EPS/EMF through vectory, or PDF through the pdfrb-backed
+    # SvgPdf renderer.
     class Elk
-      VALID_TYPES = %i[svg ps eps emf].freeze
+      VALID_TYPES = %i[svg ps eps emf pdf].freeze
 
       attr_reader :type
 
@@ -31,6 +32,8 @@ module Lutaml
       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

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