lutaml-lml 0.3.3 → 0.3.5

data/lib/lutaml/lml/preprocessor.rb

@@ -2,6 +2,8 @@
 
 module Lutaml
   module Lml
+    # Expands `include` directives before parsing. Unterminated block
+    # comments are rejected here; line comments are grammar trivia.
     class Preprocessor
       attr_reader :input_file
 
@@ -16,7 +18,7 @@ module Lutaml
       end
 
       def call
-        expand_lines(@input_file.read, @input_file.base_dir, [])
+        expand_lines(@input_file.read, @input_file.base_dir, [], @input_file.path)
       end
 
       private
@@ -25,24 +27,38 @@ module Lutaml
       # skip (parsanol-ruby#134); only include directives are expanded
       # here. Line structure is preserved so parse-error positions
       # match the source.
-      def expand_lines(text, base_dir, chain)
-        validate_block_comments(text)
+      def expand_lines(text, base_dir, chain, file_path)
+        validate_block_comments(text, file_path)
         text.split(/\r?\n/)
-            .flat_map { |line| expand_line(line, base_dir, chain) }
+            .each_with_index
+            .flat_map { |line, index| expand_line(line, base_dir, chain, file_path, index + 1) }
             .join("\n")
       end
 
-      def expand_line(line, base_dir, chain)
+      def expand_line(line, base_dir, chain, file_path, line_number)
         path = include_path(line, base_dir)
         return [line] unless path
 
-        raise Error, "circular include detected: #{path}" if chain.include?(path)
+        if chain.include?(path)
+          raise Error.new(
+            "circular include detected: #{path}",
+            diagnostic: Diagnostic.build(
+              'parse/LML-003',
+              message: "circular include detected: #{path}",
+              file: file_path, line: line_number, column: 1
+            ),
+          )
+        end
 
-        expand_lines(read_included(path), File.dirname(path), chain + [path])
+        expand_lines(read_included(path, file_path, line_number),
+                     File.dirname(path), chain + [path], path)
       end
 
       def include_path(line, base_dir)
-        match = line.match(/^\s*include\s+(.+)$/)
+        # Linear-time match: `\S.*` cannot overlap the leading `[ \t]+`,
+        # so a line of spaces after `include` fails in O(n) rather than
+        # backtracking quadratically (CodeQL ReDoS).
+        match = line.match(/\A[ \t]*include[ \t]+(\S.*)\z/)
         return nil unless match
 
         File.expand_path(trim_trailing_comment(match[1].strip), base_dir)
@@ -52,17 +68,24 @@ module Lutaml
         path.sub(%r{\s+(//|/\*).*}, '')
       end
 
-      def read_included(path)
+      def read_included(path, file_path, line_number)
         File.read(path, encoding: 'UTF-8')
-      rescue Errno::ENOENT, Errno::EACCES => e
-        raise Error, "cannot read include #{path}: #{e.message}"
+      rescue SystemCallError => e
+        raise Error.new(
+          "cannot read include #{path}: #{e.message}",
+          diagnostic: Diagnostic.build(
+            'parse/LML-003',
+            message: "cannot read include: #{path}",
+            file: file_path, line: line_number, column: 1
+          ),
+        )
       end
 
       # Quote-aware scan: a `/*` opened outside a string literal or a
       # line comment must close before end of input. The grammar's
       # trivia would otherwise reject the text with an unrelated
       # expected-token error.
-      def validate_block_comments(text)
+      def validate_block_comments(text, file_path)
         quote = nil
         pos = 0
         open_index = nil
@@ -92,7 +115,15 @@ module Lutaml
         return unless open_index
 
         line = text[0...open_index].count("\n") + 1
-        raise Error, "unterminated block comment at line #{line}"
+        column = open_index - (text.rindex("\n", open_index) || -1)
+        raise Error.new(
+          "unterminated block comment at line #{line}",
+          diagnostic: Diagnostic.build(
+            'parse/LML-002',
+            message: 'unterminated block comment',
+            file: file_path, line: line, column: column
+          ),
+        )
       end
     end
   end

data/lib/lutaml/lml/quoting.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    # The single source of truth for scalar quoting on the emit side:
+    # bare only for runs of [A-Za-z0-9_] (the grammar's word rule);
+    # double quotes with the two RS 3001 escapes otherwise. Values,
+    # attribute keys, and the canonical form all emit through here.
+    module Quoting
+      BARE_WORD = /\A\w+\z/
+
+      module_function
+
+      # @param scalar [String, #to_s]
+      # @return [String] the emitted form: parseable back to scalar
+      def quote_scalar(scalar)
+        str = scalar.to_s
+        return str if str.match?(BARE_WORD)
+
+        quote_always(str)
+      end
+
+      # Double-quoted form even when the scalar is a bare word. Used
+      # where the grammar only accepts quoted strings (definitions,
+      # requires, instance data values, wire names).
+      #
+      # @param scalar [String, #to_s]
+      # @return [String] the double-quoted, escaped form
+      def quote_always(scalar)
+        escaped = scalar.to_s.gsub('\\') { |bs| bs * 2 }.gsub('"') { |q| "\\#{q}" }
+        "\"#{escaped}\""
+      end
+
+      # Float#to_s may use exponent notation, for which the language has
+      # no literal. Expand it to a plain decimal that parses back to the
+      # same Float.
+      #
+      # @param number [Numeric]
+      # @return [String] the emitted form
+      def number_scalar(number)
+        text = number.to_s
+        match = text.match(/\A(-?)(\d+)(?:\.(\d+))?[eE]([+-]?\d+)\z/)
+        return text unless match
+
+        integer = match[2]
+        digits = integer + match[3].to_s
+        point = integer.length + match[4].to_i
+        plain =
+          if point <= 0
+            "0.#{'0' * -point}#{digits}"
+          elsif point >= digits.length
+            "#{digits}#{'0' * (point - digits.length)}.0"
+          else
+            "#{digits[0...point]}.#{digits[point..]}"
+          end
+        "#{match[1]}#{plain}"
+      end
+    end
+  end
+end

data/lib/lutaml/lml/source_position.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    # A position in the parsed source: 1-based line and column, with the
+    # byte offset and captured length when the parser provides them.
+    # Attached to model objects as non-serialized metadata so diagnostics
+    # can cite it without changing the document model's wire form.
+    class SourcePosition
+      attr_reader :line, :column, :offset, :length
+
+      def initialize(line:, column:, offset: nil, length: nil)
+        @line = line
+        @column = column
+        @offset = offset
+        @length = length
+      end
+    end
+  end
+end

data/lib/lutaml/lml/symbol_index.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    # A flat, positioned index of the document's symbols and the uses
+    # that reference them. Backs navigation, hover, and completion in
+    # tooling, and is available as Document#symbols.
+    class SymbolIndex
+      Entry = Struct.new(:name, :kind, :container, :position, :detail, :record,
+                         keyword_init: true)
+
+      # LSP SymbolKind values.
+      KINDS = {
+        package: 4, class: 5, method: 6, field: 8,
+        enum: 10, instance: 19, enum_member: 22, data_type: 23
+      }.freeze
+
+      attr_reader :entries
+
+      def initialize(document)
+        @entries = []
+        return unless document
+
+        walk_document(document)
+      end
+
+      def definitions(name)
+        @entries.select { |entry| entry.name.to_s == name.to_s }
+      end
+
+      def uses(name)
+        token = name.to_s
+        @entries.select do |entry|
+          if entry.record.is_a?(TopElementAttribute)
+            reference?(entry.record, token)
+          elsif entry.record.is_a?(Instance)
+            [entry.record.type.to_s, entry.record.isa.to_s].include?(token)
+          else
+            false
+          end
+        end
+      end
+
+      def attribute_entries
+        @entries.select { |entry| entry.kind == :field }
+      end
+
+      def entity_entries
+        @entries.reject { |entry| %i[field method enum_member].include?(entry.kind) }
+      end
+
+      def names
+        @entries.map(&:name).compact.uniq
+      end
+
+      private
+
+      def walk_document(document)
+        walk_members(document, nil)
+        walk_instance(document.instance, nil) if document.instance
+        walk_collection(document.instances) if document.instances
+      end
+
+      def walk_members(owner, container)
+        Array(owner.classes).each { |klass| walk_class(klass, container) }
+        Array(owner.enums).each { |enum| walk_enum(enum, container) }
+        Array(owner.data_types).each { |type| walk_data_type(type, container) }
+        Array(owner.packages).each { |package| walk_package(package, container) }
+      end
+
+      def walk_package(package, container)
+        name = package.name.to_s
+        add(name, :package, container, package.source_position, nil, package)
+        walk_members(package, name)
+      end
+
+      def walk_class(klass, container)
+        name = klass.name.to_s
+        add(name, :class, container, klass.source_position, parent_detail(klass), klass)
+        Array(klass.attributes).each do |attribute|
+          add(attribute.name, :field, name, attribute.source_position,
+              attribute_detail(attribute), attribute)
+        end
+        Array(klass.operations).each do |operation|
+          add(operation.name, :method, name, operation.source_position,
+              operation_detail(operation), operation)
+        end
+        Array(klass.data_types).each { |type| walk_data_type(type, name) }
+      end
+
+      def walk_enum(enum, container)
+        name = enum.name.to_s
+        add(name, :enum, container, enum.source_position, nil, enum)
+        Array(enum.attributes).each do |member|
+          add(member.name, :enum_member, name, member.source_position,
+              enum_member_detail(member), member)
+        end
+        Array(enum.member_fields).each do |field|
+          add(field.name, :field, name, field.source_position,
+              field.type.to_s, field)
+        end
+      end
+
+      def walk_data_type(type, container)
+        name = type.name.to_s
+        add(name, :data_type, container, type.source_position, nil, type)
+        Array(type.attributes).each do |attribute|
+          add(attribute.name, :field, name, attribute.source_position,
+              attribute_detail(attribute), attribute)
+        end
+      end
+
+      def walk_collection(collection)
+        return unless collection.is_a?(InstanceCollection)
+
+        name = collection.name.to_s
+        add(name, :package, nil, collection.source_position, 'instances', collection)
+        Array(collection.instances).each { |instance| walk_instance(instance, name) }
+      end
+
+      def walk_instance(instance, container)
+        name = instance_label(instance)
+        add(name, :instance, container, instance.source_position, name, instance)
+        Array(instance.attributes).each do |attribute|
+          next if attribute.name.to_s.empty?
+
+          add(attribute.name, :field, name, attribute.source_position,
+              attribute_value_detail(attribute), attribute)
+          Array(attribute.instances).each { |nested| walk_instance(nested, name) }
+        end
+        walk_instance(instance.instance, name) if instance.instance
+      end
+
+      def add(name, kind, container, position, detail, record)
+        return if name.to_s.empty? || position.nil?
+
+        @entries << Entry.new(
+          name: name.to_s, kind: kind, container: container,
+          position: position, detail: detail, record: record
+        )
+      end
+
+      def parent_detail(klass)
+        klass.parent_class.to_s.empty? ? nil : "< #{klass.parent_class}"
+      end
+
+      def attribute_detail(attribute)
+        detail = attribute.type.to_s.dup
+        cardinality = attribute.cardinality
+        if cardinality
+          max = cardinality.max.to_s
+          detail << " [#{cardinality.min}#{"..#{max}" unless max.empty?}]"
+        end
+        detail.empty? ? nil : detail
+      end
+
+      def operation_detail(operation)
+        params = Array(operation.owned_parameter)
+                 .map { |param| "#{param.name}: #{param.type}" }.join(', ')
+        detail = "(#{params})"
+        detail += " : #{operation.return_type}" if operation.return_type.to_s != ''
+        detail
+      end
+
+      def enum_member_detail(member)
+        description = Array(member.attributes).find { |a| a.name == 'description' }
+        description&.type&.to_s
+      end
+
+      def attribute_value_detail(attribute)
+        value = attribute.value
+        value = value.value if value.is_a?(LiteralValue)
+        value.nil? ? attribute.type.to_s : value.to_s
+      end
+
+      def instance_label(instance)
+        type = instance.type.to_s
+        name = instance.name.to_s
+        return name unless name.empty?
+        return type unless type.empty?
+
+        'instance'
+      end
+
+      def reference?(attribute, token)
+        type = attribute.type.to_s
+        return true if type == token || type.split('[]').first == token
+
+        value = attribute.value
+        value = value.value if value.is_a?(LiteralValue)
+        return false unless value.is_a?(Hash)
+
+        reference = value[:reference] || value['reference']
+        return false unless reference
+
+        reference.to_s.split('.').include?(token)
+      end
+    end
+  end
+end

data/lib/lutaml/lml/transform.rb

@@ -4,11 +4,13 @@ require 'parsanol'
 
 module Lutaml
   module Lml
+    # Converts the raw parsanol tree into the processed hash, retaining
+    # source positions as non-serialized metadata.
     class Transform < Parsanol::Transform
       VISIBILITY_MAP = {
         '-' => 'private',
         '#' => 'protected',
-        '~' => 'package'
+        '~' => 'package',
       }.freeze
 
       rule(visibility_modifier: simple(:visibility_value)) do
@@ -50,7 +52,52 @@ module Lutaml
       BLOCK_KEYS = %i[definition comments].freeze
 
       def apply(tree, context = nil)
-        strip_block_layout(super)
+        processed = super
+        attach_positions(tree, processed)
+        strip_block_layout(processed)
+      end
+
+      # Retains the source position of name/key captures as a :position
+      # hash beside the transformed value. The document builder moves it
+      # onto the model as non-serialized metadata (see Positioned).
+      def attach_positions(raw, processed)
+        case raw
+        when Hash
+          return unless processed.is_a?(Hash)
+
+          slice = capture_slice(raw[:name]) || capture_slice(raw[:key]) ||
+                  capture_slice(raw[:value_name]) || capture_slice(raw[:lml_version])
+          processed[:position] = position_hash(slice) if slice
+
+          raw.each_key do |key|
+            attach_positions(raw[key], processed[key]) if processed.key?(key)
+          end
+        when Array
+          return unless processed.is_a?(Array)
+
+          raw.each_with_index do |item, index|
+            attach_positions(item, processed[index]) if index < processed.length
+          end
+        end
+      end
+
+      # A name capture is either a bare token (a Slice) or a quoted
+      # string (a hash holding the inner Slice).
+      def capture_slice(node)
+        return node if node.is_a?(Parsanol::Slice)
+        return node[:string] if node.is_a?(Hash) && node[:string].is_a?(Parsanol::Slice)
+
+        nil
+      end
+
+      def position_hash(slice)
+        line, column = slice.line_and_column
+        {
+          line: line,
+          column: column,
+          offset: slice.offset,
+          length: slice.content.to_s.bytesize,
+        }
       end
 
       def strip_block_layout(node)