expressir 2.4.29-arm-linux-musl

data/lib/expressir/express/remark_overlay.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    # Remarks are deterministic given the sources, so the batch path
+    # persists them as an overlay next to the compiled-set artifact;
+    # warm loads re-apply the overlay instead of re-running the
+    # {RemarkAttacher}.
+    #
+    # Nodes are keyed structurally — attribute path plus array index —
+    # because {Model::ModelElement#path} is empty for id-less nodes
+    # (statements), and the wire is byte-identical between the cold
+    # write and the warm apply, so structural keys match exactly.
+    module RemarkOverlay
+      CAPTURED = %w[remarks remark_items informal_propositions untagged_remarks header].freeze
+
+      class << self
+        def write(set_path, models)
+          overlay = {}
+          ModelTraversal.each_model(models) do |node, key|
+            entry = {}
+            CAPTURED.each do |attr|
+              next unless node.respond_to?(attr)
+
+              value = node.public_send(attr)
+              entry[attr] = value if attr == "header" ? value : value&.any?
+            end
+            overlay[key] = entry if entry.any?
+          end
+          return if overlay.empty?
+
+          require "json"
+          File.write("#{set_path}.remarks.json", JSON.generate(overlay))
+        end
+
+        # Recursively parent restored nodes and invalidate id-memos so
+        # find()/resolve_path_in_scope sees them, exactly as the
+        # RemarkAttacher's own bookkeeping does.
+        def wire_overlay_value(parent, value)
+          case value
+          when Array
+            value.each { |item| wire_overlay_value(parent, item) }
+          when Model::ModelElement
+            parent_value = parent.is_a?(Model::ModelElement) ? parent : nil
+            value.parent = parent_value if value.respond_to?(:parent=)
+            if parent_value.respond_to?(:reset_children_by_id)
+              parent_value.reset_children_by_id
+            end
+            value.class.attributes.each_key do |attr|
+              next if Model::ModelElement::SKIP_ATTRIBUTES.include?(attr) || attr == :parent
+
+              inner = value.public_send(attr)
+              next unless inner.is_a?(Model::ModelElement) || inner.is_a?(Array)
+
+              wire_overlay_value(value, inner)
+            end
+          end
+        end
+
+        def apply(set_path, models)
+          overlay_path = "#{set_path}.remarks.json"
+          return unless File.exist?(overlay_path)
+
+          require "json"
+          overlay = JSON.parse(File.read(overlay_path))
+          ModelTraversal.each_model(models) do |node, key|
+            entry = overlay[key]
+            next unless entry
+
+            CAPTURED.each do |attr|
+              setter = :"#{attr}="
+              next unless entry[attr] && node.respond_to?(setter)
+
+              node.public_send(setter, entry[attr])
+              # The writer casts JSON hashes into model objects; wire
+              # the cast collection (the attacher parents every
+              # created node and resets the child-id memo — reference
+              # resolution relies on both).
+              wire_overlay_value(node, node.public_send(attr))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/expressir/express/remark_scanner.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    # Scans EXPRESS source text and extracts all remarks (tail and embedded),
+    # correctly tracking embedded-remark nesting so that inline `--` inside
+    # a `(* ... *)` documentation block is NOT mistaken for a tail remark.
+    #
+    # Single responsibility: source string -> Array<Remark>. The scanner has
+    # no knowledge of the model; attaching remarks to model elements is the
+    # job of {RemarkAttacher}.
+    #
+    # Reference: ISO 10303-11 §7.1.6.
+    #   tail_remark     = '--' [ remark_tag ] { <any char except newline> } '\n'
+    #   embedded_remark = '(*' [ remark_tag ]
+    #                       { <any char> | nested embedded_remark } '*)'
+    #
+    # The scanner is a single-pass state machine with four states:
+    #   :top          — outside any remark/string; look for `--`, `(*`, or `'`.
+    #   :in_tail       — inside a tail remark; look only for the next newline.
+    #   :in_embedded   — inside one or more nested embedded remarks; look
+    #                    for the matching `*)` or a nested `(*`, ignoring `--`.
+    #   :in_string     — inside a simple string literal; look for the closing
+    #                    `'`, treating `''` as an escaped quote (ISO 10303-11
+    #                    §7.1.6.5). `--` and `(*` inside a string are content.
+    class RemarkScanner
+      # Immutable value object describing a single extracted remark.
+      # `position` is the byte offset of the opener (`--` or `(*`).
+      # `end_position` is the byte offset one past the closer (the newline
+      # byte for tail remarks, the byte after `*)` for embedded remarks).
+      # `[position, end_position)` is the full byte range the remark
+      # occupied in the original source.
+      Remark = Struct.new(:position, :end_position, :line, :text, :tag,
+                          :format, keyword_init: true) do
+        def tail?
+          format == Model::RemarkFormat::TAIL
+        end
+
+        def embedded?
+          format == Model::RemarkFormat::EMBEDDED
+        end
+
+        def tagged?
+          !tag.nil? && !tag.empty?
+        end
+
+        # Byte length of the full remark (opener + content + closer).
+        def bytesize
+          end_position - position
+        end
+      end
+
+      # Lexical markers recognised by EXPRESS.
+      TAIL_MARKER = "--"
+      EMBEDDED_OPEN = "(*"
+      EMBEDDED_CLOSE = "*)"
+      STRING_QUOTE = "'"
+
+      # Byte value of `)` — used to detect the `(*)` overlap pattern where
+      # the embedded-remark opener `(*` and closer `*)` share the `*`.
+      RPAREN_BYTE = ")".ord
+
+      # Tag forms (see ISO 10303-11 §7.1.6.3 Remark tag).
+      # IP-style informal-proposition tags are recognised only in tail remarks
+      # (matching historic behaviour); embedded remarks use the quoted form.
+      INFORMAL_PROPOSITION_TAG = /\A(IP\d+):\s*(.*)\z/m
+      QUOTED_TAG = /\A"([^"]*)"\s*(.*)\z/m
+
+      # @param source [String] EXPRESS source text (any encoding).
+      def initialize(source)
+        @source = source
+        @source_bytes = source.b
+        @line_map = LineMap.new(@source_bytes)
+      end
+
+      # Returns an Array of {Remark}, in source order (by byte position).
+      # @return [Array<Remark>]
+      def scan
+        run_state_machine
+      end
+
+      alias call scan
+
+      private
+
+      # Detects the `(*)` overlap pattern: opener `(*` (positions pos, pos+1)
+      # and closer `*)` (positions pos+1, pos+2) share the `*` character.
+      # Per strict ISO 10303-11 §7.1.6 grammar the opener and closer are
+      # distinct tokens that cannot share characters, so `(*)` is technically
+      # invalid; we accept it as a 3-character empty embedded remark for
+      # robustness (issue #126).
+      def empty_overlap_remark?(pos)
+        pos + 2 < @source_bytes.bytesize &&
+          @source_bytes.getbyte(pos + 2) == RPAREN_BYTE
+      end
+
+      def run_state_machine
+        remarks = []
+        src = @source_bytes
+        pos = 0
+
+        state = :top
+        embedded_depth = 0
+        tail_start = nil      # byte position of first content char after "--"
+        tail_line = nil
+        embedded_start = nil  # byte position of first content char after "(*"
+        embedded_line = nil
+
+        while pos < src.bytesize
+          case state
+          when :in_tail
+            nl = src.index("\n", pos)
+            if nl
+              emit_tail(remarks, tail_start, nl, tail_line)
+              pos = nl + 1
+              state = :top
+            else
+              emit_tail(remarks, tail_start, src.bytesize, tail_line)
+              return remarks
+            end
+          when :in_embedded
+            closing = src.index(EMBEDDED_CLOSE, pos)
+            nesting = src.index(EMBEDDED_OPEN, pos)
+            if nesting && (!closing || nesting < closing)
+              if empty_overlap_remark?(nesting)
+                # `(*)` opens and closes immediately; depth unchanged.
+                pos = nesting + 3
+              else
+                embedded_depth += 1
+                pos = nesting + EMBEDDED_OPEN.bytesize
+              end
+            elsif closing
+              embedded_depth -= 1
+              pos = closing + EMBEDDED_CLOSE.bytesize
+              if embedded_depth.zero?
+                emit_embedded(remarks, embedded_start, closing, embedded_line)
+                state = :top
+              end
+            else
+              # Unclosed embedded remark — terminate scan gracefully.
+              return remarks
+            end
+          when :in_string
+            # ISO 10303-11 §7.1.6.5: `''` inside a string is an escaped quote.
+            # Find the next `'`; if followed by another `'`, skip both; else
+            # the string closes.
+            quote_pos = src.index(STRING_QUOTE, pos)
+            if quote_pos.nil?
+              # Unclosed string — malformed EXPRESS; terminate scan gracefully.
+              return remarks
+            end
+
+            if quote_pos + 1 < src.bytesize && src.getbyte(quote_pos + 1) == STRING_QUOTE.ord
+              pos = quote_pos + 2
+            else
+              pos = quote_pos + 1
+              state = :top
+            end
+          else # :top
+            next_embed = src.index(EMBEDDED_OPEN, pos)
+            next_tail = src.index(TAIL_MARKER, pos)
+            next_quote = src.index(STRING_QUOTE, pos)
+            if next_embed.nil? && next_tail.nil? && next_quote.nil?
+              return remarks
+            elsif next_quote && (next_embed.nil? || next_quote < next_embed) &&
+                (next_tail.nil? || next_quote < next_tail)
+              # String opener wins — enter :in_string and skip the quote.
+              pos = next_quote + STRING_QUOTE.bytesize
+              state = :in_string
+            elsif next_embed && (next_tail.nil? || next_embed <= next_tail)
+              if empty_overlap_remark?(next_embed)
+                # Standalone `(*)`: empty embedded remark, opener and closer
+                # share the `*`. Emit with empty content and continue.
+                emit_embedded(remarks, next_embed + EMBEDDED_OPEN.bytesize,
+                              next_embed + EMBEDDED_OPEN.bytesize,
+                              @line_map.line_number(next_embed))
+                pos = next_embed + 3
+                state = :top
+              else
+                embedded_start = next_embed + EMBEDDED_OPEN.bytesize
+                embedded_line = @line_map.line_number(next_embed)
+                embedded_depth = 1
+                state = :in_embedded
+                pos = next_embed + EMBEDDED_OPEN.bytesize
+              end
+            else
+              tail_start = next_tail + TAIL_MARKER.bytesize
+              tail_line = @line_map.line_number(next_tail)
+              state = :in_tail
+              pos = next_tail + TAIL_MARKER.bytesize
+            end
+          end
+        end
+
+        remarks
+      end
+
+      def emit_tail(remarks, content_start, content_end, line)
+        # Slice content from the original (UTF-8) source so the returned text
+        # preserves the source encoding. Byte offsets come from the BINARY copy.
+        raw = @source.byteslice(content_start...content_end)
+        tag, content = parse_tail(raw.strip)
+        remarks << Remark.new(
+          position: content_start - TAIL_MARKER.bytesize,
+          end_position: content_end,
+          line: line,
+          text: content,
+          tag: tag,
+          format: Model::RemarkFormat::TAIL,
+        )
+      end
+
+      def emit_embedded(remarks, content_start, content_end, line)
+        raw = @source.byteslice(content_start...content_end)
+        tag, content = parse_embedded(raw)
+        remarks << Remark.new(
+          position: content_start - EMBEDDED_OPEN.bytesize,
+          end_position: content_end + EMBEDDED_CLOSE.bytesize,
+          line: line,
+          text: content,
+          tag: tag,
+          format: Model::RemarkFormat::EMBEDDED,
+        )
+      end
+
+      # Tail remarks support both quoted tags ("schema.entity" ...) and the
+      # shorthand IP-tag form (IP1: ...). Returns [tag, content]; for untagged
+      # remarks tag is nil and content is the stripped text.
+      def parse_tail(text)
+        match = text.match(INFORMAL_PROPOSITION_TAG) || text.match(QUOTED_TAG)
+        match ? match.captures : [nil, text]
+      end
+
+      # Embedded remarks only use the quoted tag form.
+      def parse_embedded(content)
+        stripped = content.strip
+        if (m = stripped.match(QUOTED_TAG))
+          [m[1], m[2]]
+        else
+          [nil, stripped]
+        end
+      end
+    end
+  end
+end

data/lib/expressir/express/resolve_references_model_visitor.rb

@@ -0,0 +1,29 @@
+module Expressir
+  module Express
+    class ResolveReferencesModelVisitor < ModelVisitor
+      def visit(node)
+        if node.is_a? Model::References::SimpleReference
+          visit_references_simple_reference(node)
+        end
+
+        super
+      end
+
+      private
+
+      def visit_references_simple_reference(node)
+        return if node.parent.is_a? Model::References::AttributeReference
+        return unless node.id # Skip if no id to resolve
+
+        base_item = if node.parent.is_a? Model::Declarations::InterfaceItem
+                      node.find("#{node.parent.parent.schema.id}.#{node.parent.ref.id}")
+                    else
+                      node.find(node.id)
+                    end
+        return unless base_item
+
+        node.base_path = base_item.path
+      end
+    end
+  end
+end

data/lib/expressir/express/schema_block_scanner.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    # Splits multi-schema EXPRESS source into individual schema blocks.
+    #
+    # A hand-rolled state machine that skips comments (`(* ... *)`) and
+    # string literals, tracks SCHEMA/END_SCHEMA depth, and returns one
+    # block per schema declaration. Retained for the future streaming
+    # parse path (see TODO.max-perf/02) that parses each schema
+    # independently with a fresh memory arena.
+    #
+    # Extracted from the outer Parser class (TODO.bugs/09) so block-
+    # scanning logic lives in one focused module behind one interface.
+    module SchemaBlockScanner
+      END_SCHEMA_KEYWORD = "END_SCHEMA"
+      SCHEMA_KEYWORD = "SCHEMA"
+      WHITESPACE_CHARS = [" ", "\t", "\n", "\r"].freeze
+
+      module_function
+
+      # Extract individual schema blocks from EXPRESS source.
+      #
+      # Uses a state machine to properly handle nested comments and strings.
+      #
+      # @param source [String] EXPRESS source
+      # @return [Array<Hash>] Array of {name:, source:, start_pos:, end_pos:}
+      #   for each schema block found.
+      def extract_schema_blocks(source)
+        blocks = []
+        pos = 0
+        len = source.length
+
+        while pos < len
+          pos = skip_ws_and_comments(source, pos)
+          break if pos >= len
+
+          if source[pos..].start_with?(SCHEMA_KEYWORD)
+            result = parse_schema_block(source, pos)
+            if result
+              blocks << result
+              pos = result[:end_pos]
+              next
+            end
+          end
+
+          pos += 1
+        end
+
+        blocks
+      end
+
+      def parse_schema_block(source, start_pos)
+        return nil unless source[start_pos..].start_with?(SCHEMA_KEYWORD)
+
+        pos = start_pos + SCHEMA_KEYWORD.length
+        pos = skip_spaces(source, pos)
+
+        name_start = pos
+        while pos < source.length && (source[pos] =~ /[a-zA-Z0-9_]/ || source[pos] == "_")
+          pos += 1
+        end
+        schema_name = source[name_start...pos]
+        return nil if schema_name.empty?
+
+        depth = 1
+        search_pos = pos
+        end_pos = nil
+
+        while search_pos < source.length
+          if source[search_pos] == '"'
+            search_pos += 1
+            while search_pos < source.length && source[search_pos] != '"'
+              search_pos += 1
+            end
+            search_pos += 1
+          elsif source[search_pos] == "(" && source[search_pos + 1] == "*"
+            search_pos += 2
+            while search_pos < source.length && !(source[search_pos] == "*" && source[search_pos + 1] == ")")
+              search_pos += 1
+            end
+            search_pos += 2
+          elsif source[search_pos..].start_with?(END_SCHEMA_KEYWORD)
+            depth -= 1
+            if depth.zero?
+              end_pos = search_pos + END_SCHEMA_KEYWORD.length
+              pos = end_pos
+              pos = skip_spaces(source, pos)
+              pos += 1 if source[pos] == ";"
+              break
+            end
+            search_pos += END_SCHEMA_KEYWORD.length
+          else
+            search_pos += 1
+          end
+        end
+
+        return nil unless end_pos
+
+        {
+          name: schema_name,
+          source: source[start_pos...end_pos],
+          start_pos: start_pos,
+          end_pos: pos,
+        }
+      end
+
+      def skip_spaces(source, pos)
+        while pos < source.length && WHITESPACE_CHARS.include?(source[pos])
+          pos += 1
+        end
+        pos
+      end
+
+      def skip_ws_and_comments(source, pos)
+        len = source.length
+        while pos < len
+          c = source[pos]
+          if WHITESPACE_CHARS.include?(c)
+            pos += 1
+          elsif c == "(" && source[pos + 1] == "*"
+            pos += 2
+            while pos < len - 1 && !(source[pos] == "*" && source[pos + 1] == ")")
+              pos += 1
+            end
+            pos += 2
+          else
+            break
+          end
+        end
+        pos
+      end
+
+      private_class_method :parse_schema_block, :skip_spaces, :skip_ws_and_comments
+    end
+  end
+end

data/lib/expressir/express/schema_head_formatter.rb

@@ -0,0 +1,22 @@
+module Expressir
+  module Express
+    # Formatter module - format schema as schema head only
+    # @example Include into Formatter subclass
+    #   formatter = Class.new(Expressir::Express::Formatter) do
+    #     include Expressir::Express::SchemaHeadFormatter
+    #   end
+    module SchemaHeadFormatter
+      # @!visibility private
+      def self.included(mod)
+        unless mod.superclass <= Expressir::Express::Formatter
+          raise Error::FormatterMethodMissingError.new("SchemaHeadFormatter",
+                                                       "format_declarations_schema/format_declarations_schema_head")
+        end
+      end
+
+      def format_declarations_schema(node)
+        format_declarations_schema_head(node)
+      end
+    end
+  end
+end

data/lib/expressir/express/schema_plain_source_formatter.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    # Pre-built Formatter subclass rendering the schema head without
+    # hyperlinks — the plain `source` face of Schema (#255).
+    class SchemaPlainSourceFormatter < Formatter
+      include SchemaHeadFormatter
+    end
+  end
+end

data/lib/expressir/express/schema_source_formatter.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    # Pre-built Formatter subclass rendering the schema head with
+    # hyperlinks: SchemaHeadFormatter + HyperlinkFormatter. Allocated
+    # once at load time rather than per call. It backs
+    # Schema#source_hyperlinked; Schema#source uses
+    # SchemaPlainSourceFormatter, the unlinked counterpart (#255).
+    class SchemaSourceFormatter < Formatter
+      include SchemaHeadFormatter
+      include HyperlinkFormatter
+    end
+  end
+end