lutaml-lml 0.3.3 → 0.3.5

data/lib/lutaml/lml/lsp/store.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    module Lsp
+      # The open-document store. Every change reparses the full text
+      # (full-document sync) and recomputes diagnostics.
+      class Store
+        Entry = Struct.new(:uri, :text, :version, :model, :diagnostics,
+                           keyword_init: true)
+
+        def initialize
+          @entries = {}
+        end
+
+        def open(uri:, text:, version: nil)
+          entry = Entry.new(uri: uri, text: text, version: version)
+          parse(entry)
+          @entries[uri] = entry
+        end
+
+        def change(uri:, text:, version: nil)
+          entry = @entries[uri]
+          return nil unless entry
+
+          entry.text = text
+          entry.version = version
+          parse(entry)
+          entry
+        end
+
+        def close(uri)
+          @entries.delete(uri)
+        end
+
+        def [](uri)
+          @entries[uri]
+        end
+
+        private
+
+        def parse(entry)
+          path = Conversions.uri_to_path(entry.uri)
+          entry.model = Lutaml::Lml.parse_document(entry.text)
+          entry.model.source_path = path
+          entry.diagnostics = Validator.diagnostics(entry.model)
+        rescue Lutaml::Lml::Error => e
+          entry.model = nil
+          entry.diagnostics = [diagnostic_for(e, path)]
+        end
+
+        def diagnostic_for(error, path)
+          record = error.diagnostic
+          return record if record&.file
+
+          Diagnostic.build(
+            record&.code || 'parse/LML-001',
+            message: record&.message || error.message.lines.first.to_s.strip,
+            file: path,
+            line: record&.line,
+            column: record&.column,
+            length: record&.length,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/lml/lsp/transport.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Lutaml
+  module Lml
+    module Lsp
+      # LSP base protocol framing: `Content-Length: N\r\n\r\n<json>`.
+      # Reads one message at a time and writes responses to the output
+      # stream. stdout is the protocol channel; stderr is for logging.
+      class Transport
+        def initialize(input: $stdin, output: $stdout)
+          @input = input
+          @output = output
+        end
+
+        def read_message
+          headers = read_headers
+          return nil unless headers
+
+          length = headers["content-length"]
+          return nil unless length
+
+          body = @input.read(length.to_i)
+          body.nil? || body.empty? ? nil : JSON.parse(body)
+        end
+
+        def write_message(payload)
+          body = JSON.generate(payload)
+          @output.write("Content-Length: #{body.bytesize}\r\n\r\n#{body}")
+          @output.flush
+        end
+
+        private
+
+        def read_headers
+          headers = {}
+          loop do
+            line = @input.gets
+            return nil if line.nil?
+
+            line = line.chomp
+            break if line.empty?
+
+            key, value = line.split(":", 2)
+            headers[key.to_s.strip.downcase] = value.to_s.strip
+          end
+          headers
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/lml/lsp.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    # Language Server Protocol support: a stdio JSON-RPC server exposing
+    # diagnostics, symbols, navigation, hover, completion, and canonical
+    # formatting over the parsed document model.
+    module Lsp
+      autoload :Transport, "lutaml/lml/lsp/transport"
+      autoload :Server, "lutaml/lml/lsp/server"
+      autoload :Store, "lutaml/lml/lsp/store"
+      autoload :Keywords, "lutaml/lml/lsp/keywords"
+      autoload :Conversions, "lutaml/lml/lsp/conversions"
+    end
+  end
+end

data/lib/lutaml/lml/model_compiler/serialization_mappings.rb

@@ -49,18 +49,40 @@ module Lutaml
           end
         end
 
+        # Default XML mapping: every attribute an element, except those
+        # declared `as :attribute`; an in-class `namespace "uri"` becomes
+        # the class's XML namespace (issue #49).
         def apply_xml_mapping(klass, root_name)
           attr_names = klass.attributes.keys
-          return if attr_names.empty?
-
+          def_obj = @class_defs[root_name]
+          roles = xml_roles_of(def_obj)
+          ns_class = inline_namespace_class(def_obj)
           klass.xml do |mapping|
             mapping.element(root_name)
+            mapping.namespace(ns_class) if ns_class
             attr_names.each do |attr_name|
-              mapping.map_element(attr_name.to_s, to: attr_name)
+              if roles[attr_name] == 'attribute'
+                mapping.map_attribute(attr_name.to_s, to: attr_name)
+              else
+                mapping.map_element(attr_name.to_s, to: attr_name)
+              end
             end
           end
         end
 
+        def xml_roles_of(def_obj)
+          Array(def_obj&.attributes).each_with_object({}) do |attr, roles|
+            roles[attr.name.to_sym] = attr.xml_role if attr.xml_role
+          end
+        end
+
+        def inline_namespace_class(def_obj)
+          decl = def_obj.xml_namespace if def_obj.is_a?(UmlClass)
+          return nil unless decl&.uri
+
+          build_namespace_class("#{decl.uri}|#{decl.prefix}", decl.uri, decl.prefix.to_s)
+        end
+
         # RS 3010 extension: key-value mapping blocks for the declared
         # formats (yaml/json/toml share lutaml-model's key_value model).
 
@@ -89,7 +111,7 @@ module Lutaml
           check_namespace_ambiguity(mapping)
           ns_class = namespace_class_for(mapping.namespace_ref) if mapping.namespace_ref
           rule_ns = mapping.rules.select { |r| r.kind == 'namespace' }
-                                 .to_h { |r| [r.field, namespace_class_for(r.field)] }
+                           .to_h { |r| [r.field, namespace_class_for(r.field)] }
           klass.xml do |m|
             m.element(mapping.element_name) if mapping.element_name
             m.namespace(ns_class) if ns_class
@@ -149,12 +171,16 @@ module Lutaml
           declared = @declared_namespaces.find { |ns| ns.name.to_s == ref }
           raise ArgumentError, "unknown namespace '#{ref}'" unless declared
 
-          ns_class = Class.new(Lutaml::Xml::Namespace)
-          uri = declared.uri
-          prefix = declared.prefix.to_s
-          ns_class.define_singleton_method(:uri) { uri }
-          ns_class.define_singleton_method(:prefix_default) { prefix }
-          @namespace_classes[ref] = ns_class
+          build_namespace_class(ref, declared.uri, declared.prefix.to_s)
+        end
+
+        def build_namespace_class(key, uri, prefix)
+          require 'lutaml/xml/namespace' unless defined?(Lutaml::Xml::Namespace)
+
+          @namespace_classes[key] ||= Class.new(Lutaml::Xml::Namespace).tap do |ns_class|
+            ns_class.define_singleton_method(:uri) { uri }
+            ns_class.define_singleton_method(:prefix_default) { prefix }
+          end
         end
       end
     end

data/lib/lutaml/lml/model_compiler.rb

@@ -59,6 +59,7 @@ module Lutaml
         @declared_namespaces = []
         @serialization_mappings = []
         @namespace_classes = {}
+        @class_defs = {}
       end
 
       def compile(input)
@@ -73,6 +74,17 @@ module Lutaml
         return {} unless doc.instance
 
         hydrate_instance(doc.instance)
+      rescue Lutaml::Lml::Error
+        raise
+      rescue StandardError => e
+        raise HydrationError.new(
+          "hydration failed: #{e.message}",
+          diagnostic: Diagnostic.build(
+            'hydration/LML-H01',
+            message: e.message,
+            file: input.is_a?(Document) ? input.source_path : nil,
+          ),
+        )
       end
 
       def compiled_classes
@@ -129,6 +141,7 @@ module Lutaml
 
       def compile_class(klass_def)
         name = klass_def.name.to_s
+        @class_defs[name] = klass_def
         compiled_klass = build_compiled_class(klass_def)
         apply_declared_mappings(compiled_klass, klass_def)
         declare_derived_fields(compiled_klass, klass_def)
@@ -236,7 +249,11 @@ module Lutaml
         return Float::INFINITY if UNBOUNDED_TOKENS.include?(val.to_s)
         return val.to_i if val.to_s.match?(/\A\d+\z/)
 
-        raise ValidationError, "Unrecognized cardinality token: #{val.inspect}"
+        message = "Unrecognized cardinality token: #{val.inspect}"
+        raise ValidationError.new(
+          message,
+          diagnostic: Diagnostic.build('contract/LML-C04', message: message),
+        )
       end
 
       def declare_derived_fields(compiled_klass, def_obj)
@@ -278,11 +295,17 @@ module Lutaml
 
       def register(name, klass)
         @compiled[name] = klass
-        return unless @namespace
+        return name_anonymous_class(klass, name) unless @namespace
 
         namespace_module.const_set(name, klass)
       end
 
+      # Without a target namespace the class stays anonymous, and
+      # lutaml-model's schema generators need a class name for $defs/$ref.
+      def name_anonymous_class(klass, name)
+        klass.define_singleton_method(:name) { name }
+      end
+
       def namespace_module
         return @namespace if @namespace.is_a?(Module)
 

data/lib/lutaml/lml/models/association.rb

@@ -2,7 +2,10 @@
 
 module Lutaml
   module Lml
+    # A relationship between two class ends.
     class Association < Lutaml::Model::Serializable
+      include Lutaml::Lml::Positioned
+
       # From TopElement
       attribute :name, :string
       attribute :definition, Lutaml::Lml::Types::TextType

data/lib/lutaml/lml/models/constraint.rb

@@ -2,7 +2,10 @@
 
 module Lutaml
   module Lml
+    # A named constraint on a class.
     class Constraint < Lutaml::Model::Serializable
+      include Lutaml::Lml::Positioned
+
       # From TopElement
       attribute :name, :string
       attribute :definition, Lutaml::Lml::Types::TextType

data/lib/lutaml/lml/models/data_type.rb

@@ -2,7 +2,10 @@
 
 module Lutaml
   module Lml
+    # A user-defined data type declaration.
     class DataType < Lutaml::Model::Serializable
+      include Lutaml::Lml::Positioned
+
       # From TopElement
       attribute :name, :string
       attribute :wire_mappings, "Lutaml::Lml::Mapping", collection: true, default: -> { [] }

data/lib/lutaml/lml/models/diagram.rb

@@ -2,7 +2,10 @@
 
 module Lutaml
   module Lml
+    # A diagram declaration.
     class Diagram < Lutaml::Model::Serializable
+      include Lutaml::Lml::Positioned
+
       attribute :name, :string
       attribute :definition, Lutaml::Lml::Types::TextType
       attribute :keyword, :string

data/lib/lutaml/lml/models/document.rb

@@ -2,9 +2,18 @@
 
 module Lutaml
   module Lml
+    # The parsed LML document model.
     class Document < Lutaml::Model::Serializable
+      include Lutaml::Lml::Positioned
+
+      # Non-serialized navigation index (definitions and uses).
+      def symbols
+        @symbols ||= SymbolIndex.new(self)
+      end
+
       # Core attributes
       attribute :name, :string
+      attribute :lml_version, :string
       attribute :title, :string
       attribute :caption, :string
       attribute :groups, "Lutaml::Lml::Group", collection: true, default: -> { [] }
@@ -47,9 +56,7 @@ module Lutaml
       def merge_instances(incoming)
         names = @instances.collections.map(&:name)
         incoming.collections.each do |collection|
-          if names.include?(collection.name)
-            raise Lutaml::Lml::Error, "duplicate collection name '#{collection.name}'"
-          end
+          raise Lutaml::Lml::Error, "duplicate collection name '#{collection.name}'" if names.include?(collection.name)
         end
         @instances.instances.concat(incoming.instances)
         @instances.imports.concat(incoming.imports)

data/lib/lutaml/lml/models/enum.rb

@@ -2,7 +2,10 @@
 
 module Lutaml
   module Lml
+    # An enumeration declaration with its value members.
     class Enum < Lutaml::Model::Serializable
+      include Lutaml::Lml::Positioned
+
       # From TopElement
       attribute :name, :string
       attribute :definition, Lutaml::Lml::Types::TextType
@@ -15,7 +18,7 @@ module Lutaml
 
       # From Enum
       attribute :attributes, "Lutaml::Lml::TopElementAttribute", collection: true,
-                                                                   default: -> { [] }
+                                                                 default: -> { [] }
       attribute :modifier, :string
       attribute :member_fields, "Lutaml::Lml::MemberField", collection: true, default: -> { [] }
       attribute :from_table_name, :string

data/lib/lutaml/lml/models/instance.rb

@@ -2,7 +2,10 @@
 
 module Lutaml
   module Lml
+    # An instance with attribute assignments.
     class Instance < Lutaml::Model::Serializable
+      include Lutaml::Lml::Positioned
+
       attribute :name, :string
       attribute :type, :string
       attribute :isa, :string

data/lib/lutaml/lml/models/instance_collection.rb

@@ -2,7 +2,10 @@
 
 module Lutaml
   module Lml
+    # A named instances collection with its instances and imports/exports.
     class InstanceCollection < Lutaml::Model::Serializable
+      include Lutaml::Lml::Positioned
+
       attribute :name, :string
       attribute :instances, "Lutaml::Lml::Instance", collection: true, default: []
       attribute :imports, "Lutaml::Lml::InstancesImport", collection: true, default: []

data/lib/lutaml/lml/models/member_field.rb

@@ -5,6 +5,8 @@ module Lutaml
     # A typed payload field declared on an enum:
     #   member_fields { abbreviation String  urn_segment String }
     class MemberField < Lutaml::Model::Serializable
+      include Lutaml::Lml::Positioned
+
       attribute :name, :string
       attribute :type, :string
     end

data/lib/lutaml/lml/models/namespace.rb

@@ -6,6 +6,8 @@ module Lutaml
     # The compiler generates the corresponding Lutaml::Model::XmlNamespace
     # subclass for the compiled model namespace.
     class Namespace < Lutaml::Model::Serializable
+      include Lutaml::Lml::Positioned
+
       attribute :name, :string
       attribute :uri, :string
       attribute :prefix, :string

data/lib/lutaml/lml/models/operation.rb

@@ -2,7 +2,10 @@
 
 module Lutaml
   module Lml
+    # A class operation with parameters and a return type.
     class Operation < Lutaml::Model::Serializable
+      include Lutaml::Lml::Positioned
+
       # From TopElement
       attribute :name, :string
       attribute :definition, Lutaml::Lml::Types::TextType
@@ -17,7 +20,7 @@ module Lutaml
       attribute :is_static, :boolean, default: false
       attribute :is_abstract, :boolean, default: false
       attribute :owned_parameter, "Lutaml::Lml::OperationParameter", collection: true,
-                                                                          default: -> { [] }
+                                                                     default: -> { [] }
     end
   end
 end

data/lib/lutaml/lml/models/package.rb

@@ -2,7 +2,10 @@
 
 module Lutaml
   module Lml
+    # A package grouping model definitions.
     class Package < Lutaml::Model::Serializable
+      include Lutaml::Lml::Positioned
+
       # From TopElement
       attribute :name, :string
       attribute :definition, Lutaml::Lml::Types::TextType

data/lib/lutaml/lml/models/primitive_type.rb

@@ -2,7 +2,10 @@
 
 module Lutaml
   module Lml
+    # A primitive type declaration.
     class PrimitiveType < Lutaml::Model::Serializable
+      include Lutaml::Lml::Positioned
+
       # Primitives in LML are name-only entities, but the formatter
       # accesses the same attributes as DataType via format_class.
       attribute :name, :string
@@ -12,11 +15,11 @@ module Lutaml
       attribute :visibility, :string, default: "public"
       attribute :is_abstract, :boolean, default: false
       attribute :attributes, "Lutaml::Lml::TopElementAttribute", collection: true,
-                                                                   default: -> { [] }
+                                                                 default: -> { [] }
       attribute :operations, "Lutaml::Lml::Operation", collection: true,
-                                                         default: -> { [] }
+                                                       default: -> { [] }
       attribute :associations, "Lutaml::Lml::Association", collection: true,
-                                                             default: -> { [] }
+                                                           default: -> { [] }
 
       def self.entity_type
         :primitives

data/lib/lutaml/lml/models/serialization_mapping.rb

@@ -6,6 +6,8 @@ module Lutaml
     # its class and linked by target name —
     #   mapping xml Ceramic { element "ceramic" … }
     class SerializationMapping < Lutaml::Model::Serializable
+      include Lutaml::Lml::Positioned
+
       attribute :format, :string
       attribute :target, :string
       attribute :element_name, :string

data/lib/lutaml/lml/models/top_element_attribute.rb

@@ -2,7 +2,10 @@
 
 module Lutaml
   module Lml
+    # An attribute declaration or instance assignment entry.
     class TopElementAttribute < Lutaml::Model::Serializable
+      include Lutaml::Lml::Positioned
+
       # Core attributes
       attribute :name, :string
       attribute :visibility, :string, default: "public"
@@ -21,6 +24,8 @@ module Lutaml
       attribute :default, :string
       attribute :value_set, :string, collection: true, default: -> { [] }
       attribute :pattern, :string
+      # `as :element` / `as :attribute`: the XML node kind (issue #49)
+      attribute :xml_role, :string
 
       # LML-specific attributes
       attribute :properties, "Lutaml::Lml::TopElementAttribute", collection: true, default: -> { [] }
@@ -57,6 +62,7 @@ module Lutaml
         map "default", to: :default
         map "value_set", to: :value_set
         map "pattern", to: :pattern
+        map "xml_role", to: :xml_role
         map "properties", to: :properties
         map "value", to: :value, with: { to: :value_to, from: :value_from }
         map "attributes", to: :attributes

data/lib/lutaml/lml/models/uml_class.rb

@@ -2,7 +2,10 @@
 
 module Lutaml
   module Lml
+    # A class declaration with its members.
     class UmlClass < Lutaml::Model::Serializable
+      include Lutaml::Lml::Positioned
+
       # From TopElement. TextType unescapes \{ \} and normalizes lines
       # on every assignment (builder, yaml, direct).
       attribute :name, :string
@@ -29,6 +32,8 @@ module Lutaml
       attribute :serialization_mappings, "Lutaml::Lml::SerializationMapping", collection: true, default: -> { [] }
 
       # LML-specific
+      # In-class `namespace "uri"` declaration (issue #49)
+      attribute :xml_namespace, "Lutaml::Lml::Namespace"
       attribute :parent_class, :string
 
       yaml do
@@ -39,6 +44,7 @@ module Lutaml
         map "stereotype", to: :stereotype
         map "visibility", to: :visibility
         map "type", to: :type
+        map "xml_namespace", to: :xml_namespace
         map "attributes", to: :attributes
         map "operations", to: :operations
         map "constraints", to: :constraints

data/lib/lutaml/lml/models/value.rb

@@ -2,7 +2,10 @@
 
 module Lutaml
   module Lml
+    # A value construct member.
     class Value < Lutaml::Model::Serializable
+      include Lutaml::Lml::Positioned
+
       attribute :name, :string
       attribute :id, :string
       attribute :type, :string

data/lib/lutaml/lml/pipeline.rb

@@ -29,7 +29,18 @@ module Lutaml
       def parse_raw(data)
         Transform.new.apply(Parser.new.parse(data))
       rescue Parsanol::ParseFailed => e
-        raise(ParsingError, failure_message(e))
+        raise ParsingError.new(failure_message(e), diagnostic: parse_diagnostic(e))
+      end
+
+      def parse_diagnostic(error)
+        line, column = failure_location(error)
+        Diagnostic.build(
+          'parse/LML-001',
+          message: error.message.lines.first.to_s.strip,
+          file: @input.path,
+          line: line,
+          column: column,
+        )
       end
 
       # Parsanol releases up to 1.3.57 annotate native failures with a
@@ -38,18 +49,24 @@ module Lutaml
       # rebuild the location when the marker is present.
       def failure_message(error)
         detail = error.message.lines.first.to_s.strip
+        line, column = failure_location(error)
+        location = (" at line #{line} char #{column}." if line && !detail.match?(/at line \d+ char \d+/))
+        "#{detail}#{location}\ncause: #{error.parse_failure_cause&.ascii_tree}"
+      end
+
+      def failure_location(error)
         cause = error.parse_failure_cause
         offset = error.message[/@@parsanol_pos:(\d+)/, 1]&.to_i
-        location =
-          if offset && cause&.source
-            line, column = cause.source.line_and_column(offset)
-            " at line #{line} char #{column}."
-          end
-        "#{detail}#{location}\ncause: #{cause&.ascii_tree}"
+        return cause.source.line_and_column(offset) if offset && cause&.source
+
+        match = error.message.match(/at line (\d+) char (\d+)/)
+        match ? [match[1].to_i, match[2].to_i] : [nil, nil]
       end
 
       def build_document(hash)
-        DocumentBuilder.new(DocumentBuilder::DEFAULT_REGISTRY).build(:document, hash)
+        document = DocumentBuilder.new(DocumentBuilder::DEFAULT_REGISTRY).build(:document, hash)
+        document.source_path = @input.path
+        document
       end
     end
   end

data/lib/lutaml/lml/positioned.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    # Non-serialized source metadata carried by parsed entities. These
+    # accessors are deliberately not lutaml-model attributes: positions
+    # and the source path are diagnostics metadata, not document data,
+    # and must not appear in to_hash/YAML/JSON output.
+    module Positioned
+      attr_accessor :source_position, :source_path
+    end
+  end
+end