expressir 2.4.35 → 2.4.37

data/lib/expressir/lsp/workspace.rb

@@ -0,0 +1,402 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Lsp
+    # The cross-document view used by the server: open documents, schema
+    # resolution through USE/REFERENCE interfaces, diagnostics, navigation
+    # and rename computation.
+    class Workspace
+      SEVERITIES = { error: 1, warning: 2, info: 3, hint: 4 }.freeze
+
+      attr_reader :documents
+
+      def initialize
+        @documents = {}
+      end
+
+      def open(uri:, text:, path: nil)
+        @documents[uri] = Document.new(uri: uri, text: text, path: path)
+      end
+
+      def change(uri:, text:)
+        document = @documents[uri]
+        return document.update(text) if document
+
+        self.open(uri: uri, text: text)
+      end
+
+      def close(uri)
+        @documents.delete(uri)
+      end
+
+      def document(uri)
+        @documents[uri]
+      end
+
+      def symbols(uri)
+        document(uri)&.symbols || []
+      end
+
+      def diagnostics(uri)
+        document = @documents[uri]
+        return [] unless document
+
+        return [parse_diagnostic(document)] if document.parse_error
+
+        checker_notes.filter_map { |note| diagnostic_for(document, note) }
+      end
+
+      def definition(uri, position)
+        target = target_at(uri, position)
+        return nil unless target
+
+        location(target[:doc], target[:node])
+      end
+
+      def references(uri, position, include_declaration: true)
+        target = target_at(uri, position)
+        return [] unless target
+
+        declaration = target[:node]
+        results = reference_locations(declaration)
+        results << location(target[:doc], declaration) if include_declaration
+        dedupe_locations(results)
+      end
+
+      def hover(uri, position)
+        target = target_at(uri, position)
+        return nil unless target
+
+        value = Express::PrettyFormatter.new.format(target[:node])
+        {
+          "contents" => {
+            "kind" => "markdown",
+            "value" => "```express\n#{value}\n```",
+          },
+        }
+      rescue StandardError
+        nil
+      end
+
+      def prepare_rename(uri, position)
+        target = target_at(uri, position)
+        return nil unless target
+
+        document = target[:doc]
+        node = target[:node]
+        { "range" => document.range_for(node),
+          "placeholder" => node.id.to_s }
+      end
+
+      # Returns the URI→edits map for a rename, after applying the edits
+      # in memory and verifying that every affected document still parses.
+      def rename(uri, position, new_name)
+        target = target_at(uri, position)
+        return nil unless target
+
+        edits = rename_edits(target[:doc], target[:node], new_name)
+        verify_rename!(edits, target[:node], new_name)
+        { "changes" => edits }
+      end
+
+      private
+
+      def checker_notes
+        key = @documents.each_value.map { |doc| doc.text.hash }
+        return @checker_notes if key == @checker_notes_key
+
+        files = @documents.each_value.filter_map(&:file)
+        notes = if files.empty?
+                  []
+                else
+                  repository = Model::Repository.new(files: files)
+                  Express::Checker.new(repository).check.notes
+                end
+        @checker_notes = notes
+        @checker_notes_key = key
+        notes
+      rescue StandardError
+        []
+      end
+
+      def diagnostic_for(document, note)
+        schema = document.schemas.find do |candidate|
+          candidate.id.to_s.casecmp?(note.schema.to_s)
+        end
+        return nil unless schema
+        return nil if resolved_note?(document, note)
+
+        node = note.node
+        range = if node&.source_offset
+                  document.range(node.source_offset,
+                                 node.respond_to?(:id) && node.id ? node.id.to_s.bytesize : 1)
+                else
+                  document.range_for(schema)
+                end
+        {
+          "range" => range,
+          "severity" => SEVERITIES.fetch(note.severity, 3),
+          "code" => note.id,
+          "source" => "expressir",
+          "message" => note.message.to_s,
+        }
+      end
+
+      # The checker sees one file at a time; an open document that supplies
+      # the referenced schema or interfaced declaration is not unresolved.
+      def resolved_note?(document, note)
+        return false unless note.id == :check_unresolved_ref
+        return false unless note.node.is_a?(Model::References::SimpleReference)
+
+        !resolve_reference(document, note.node).nil? ||
+          !schema_by_id(note.node.id).nil?
+      rescue StandardError
+        false
+      end
+
+      def parse_diagnostic(document)
+        error = document.parse_error
+        message = error.message.to_s
+        line = message[/line (\d+)/, 1].to_i
+        character = message[/char (\d+)/, 1].to_i
+        line = 1 if line.zero?
+        character = 1 if character.zero?
+        start = { "line" => line - 1, "character" => character - 1 }
+        {
+          "range" => { "start" => start,
+                       "end" => start.merge("character" => start["character"] + 1) },
+          "severity" => 1,
+          "source" => "expressir",
+          "message" => message.lines.first.to_s.strip,
+        }
+      end
+
+      def target_at(uri, position)
+        document = @documents[uri]
+        return nil unless document&.file
+
+        token = document.token_at(position)
+        return nil unless token
+
+        declaration = document.declaration_nodes.find do |node|
+          document.name_offset(node) == token.start_byte &&
+            node.id.to_s.casecmp?(token.text)
+        end
+        return { doc: document, node: declaration, token: token } if declaration
+
+        reference = document.reference_nodes.find do |node|
+          node.source_offset == token.start_byte
+        end
+        return nil unless reference
+
+        resolved = resolve_reference(document, reference)
+        resolved && { doc: resolved[:doc], node: resolved[:node], token: token }
+      end
+
+      def resolve_reference(document, node)
+        schema = schema_of(node)
+        return nil unless schema
+
+        local = node.find(node.id)
+        if local
+          target_doc = document_for_node(local) || document
+          return { doc: target_doc, node: local }
+        end
+
+        resolve_interface(schema, node.id)
+      rescue StandardError
+        nil
+      end
+
+      def resolve_interface(schema, name)
+        Array(schema.interfaces).each do |interface|
+          interface_schema = schema_by_id(interface.schema&.id)
+          next unless interface_schema
+
+          items = Array(interface.items)
+          if items.empty?
+            node = interface_schema[:schema].find(name)
+            return { doc: interface_schema[:doc], node: node } if node
+          else
+            items.each do |item|
+              local_name = item.id || item.ref&.id
+              next unless local_name.to_s.casecmp?(name.to_s)
+
+              node = interface_schema[:schema].find(item.ref&.id)
+              return { doc: interface_schema[:doc], node: node } if node
+            end
+          end
+        end
+        nil
+      end
+
+      def schema_by_id(id)
+        return nil unless id
+
+        @documents.each_value do |document|
+          document.schemas.each do |schema|
+            next unless schema.id.to_s.casecmp?(id.to_s)
+
+            return { doc: document, schema: schema }
+          end
+        end
+        nil
+      end
+
+      def document_for_node(node)
+        schema = schema_of(node)
+        return nil unless schema
+
+        @documents.each_value do |document|
+          return document if document.schemas.any? { |candidate| candidate.equal?(schema) }
+        end
+        nil
+      end
+
+      def schema_of(node)
+        current = node
+        current = current.parent while current && !current.is_a?(Model::Declarations::Schema)
+        current
+      end
+
+      def location(document, node)
+        { "uri" => document.uri, "range" => document.range_for(node) }
+      end
+
+      def reference_locations(declaration)
+        declaring_schema = schema_of(declaration)
+        @documents.each_value.flat_map do |document|
+          document.reference_nodes.filter_map do |reference|
+            resolved = resolve_reference(document, reference)
+            next unless resolved && same_declaration?(resolved[:node], declaration)
+
+            location(document, reference)
+          end + interface_locations(document, declaring_schema, declaration)
+        end
+      end
+
+      def interface_locations(document, declaring_schema, declaration)
+        document.schemas.flat_map do |schema|
+          Array(schema.interfaces).flat_map do |interface|
+            next [] unless interface.schema&.id.to_s.casecmp?(declaring_schema.id.to_s)
+
+            Array(interface.items).filter_map do |item|
+              next unless item.ref&.id.to_s.casecmp?(declaration.id.to_s)
+
+              location(document, item.ref)
+            end
+          end
+        end
+      end
+
+      def same_declaration?(left, right)
+        left.path.to_s.casecmp?(right.path.to_s)
+      end
+
+      def rename_edits(declaring_document, declaration, new_name)
+        edits = {}
+        add_edit(edits, declaring_document, declaration, new_name)
+
+        @documents.each_value do |document|
+          document.schemas.each do |schema|
+            rename_references(document, schema, declaration, new_name, edits)
+            rename_interface_items(document, schema, declaration, new_name, edits)
+          end
+        end
+        edits
+      end
+
+      def rename_references(document, schema, declaration, new_name, edits)
+        document.reference_nodes.each do |reference|
+          next unless schema_of(reference).equal?(schema)
+          next unless reference.id.to_s.casecmp?(declaration.id.to_s)
+
+          resolved = resolve_reference(document, reference)
+          next unless resolved && same_declaration?(resolved[:node], declaration)
+
+          add_edit(edits, document, reference, new_name)
+        end
+      end
+
+      def rename_interface_items(document, schema, declaration, new_name, edits)
+        Array(schema.interfaces).each do |interface|
+          next unless interface.schema&.id.to_s.casecmp?(schema_of(declaration).id.to_s)
+
+          Array(interface.items).each do |item|
+            next unless item.ref&.id.to_s.casecmp?(declaration.id.to_s)
+
+            add_edit(edits, document, item.ref, new_name)
+          end
+        end
+      end
+
+      def add_edit(edits, document, node, new_name)
+        range = document.range_for(node)
+        list = (edits[document.uri] ||= [])
+        return if list.any? { |edit| edit["range"] == range }
+
+        list << { "range" => range, "newText" => new_name }
+      end
+
+      def verify_rename!(edits, declaration, new_name)
+        declaring_schema = schema_of(declaration)
+        edits.each do |uri, document_edits|
+          document = @documents[uri]
+          text = apply_edits(document.text, document_edits)
+          probe = Document.new(uri: uri, text: text, path: document.path)
+          raise "rename produced invalid EXPRESS in #{uri}" if probe.parse_error
+
+          verify_schema_after_rename(document, probe, declaring_schema,
+                                     declaration, new_name, uri)
+        end
+      end
+
+      # The renamed declaration may disappear under its old path; every
+      # other removal is a structure loss and aborts the rename.
+      def verify_schema_after_rename(document, probe, declaring_schema,
+                                     declaration, _new_name, uri)
+        index = document.schemas.index(declaring_schema)
+        return unless index
+
+        probe_schema = probe.schemas[index]
+        return unless probe_schema
+
+        old_path = "#{declaring_schema.id}.#{declaration.id}".downcase
+        unexpected = Express::SchemaCompare
+          .compare(declaring_schema, probe_schema)
+          .select do |delta|
+            delta.op == :removed && delta.path.to_s.downcase != old_path
+          end
+        raise "rename removed unrelated declarations in #{uri}" if unexpected.any?
+
+        formatted = Express::Formatter.format(probe_schema)
+        formatted_probe = Document.new(uri: uri, text: formatted,
+                                       path: document.path)
+        raise "renamed schema does not format in #{uri}" if formatted_probe.parse_error
+      end
+
+      def apply_edits(text, edits)
+        scratch = Document.new(uri: "file:///nonexistent", text: text)
+        source = text.b
+        offsets = edits.map do |edit|
+          start_byte = scratch.byte_offset(edit["range"]["start"]["line"],
+                                           edit["range"]["start"]["character"])
+          end_byte = scratch.byte_offset(edit["range"]["end"]["line"],
+                                         edit["range"]["end"]["character"])
+          [start_byte, end_byte, edit["newText"].b]
+        end
+        offsets.sort_by { |start_byte, _, _| -start_byte }.each do |start_byte, end_byte, replacement|
+          source[start_byte...end_byte] = replacement
+        end
+        source.force_encoding(Encoding::UTF_8)
+      end
+
+      def dedupe_locations(locations)
+        locations.uniq do |location|
+          [location["uri"], location["range"]["start"]["line"],
+           location["range"]["start"]["character"]]
+        end
+      end
+    end
+  end
+end

data/lib/expressir/lsp.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Expressir
+  # Language Server Protocol support: stdio JSON-RPC transport, open
+  # documents, and the workspace view that resolves across schemas.
+  module Lsp
+    autoload :Document, "#{__dir__}/lsp/document"
+    autoload :Workspace, "#{__dir__}/lsp/workspace"
+    autoload :Server, "#{__dir__}/lsp/server"
+  end
+end

data/lib/expressir/mapping/refpath.rb

@@ -24,10 +24,16 @@ module Expressir
     #                                          is referenced)
     #   index      := "[" ("i" | DIGITS) "]"
     #   constraint := ["!"] "{" NAME [NAME "."] "=" STRING "}"
+    #   supertype  := "||" NAME "||"          (§5 supertype entity marker)
+    #   tree       := "*" NAME "*"            (§5 relationship tree marker)
     #   MARKER     := "{" | "}" | "[" | "]" | "(" | ")" | ":" | "|" | "!"
     #               | "," | "/" | "*" | "<" | ">" (grouping/annotation;
     #                                               never breaks a
-    #                                               pending link)
+    #                                               pending link; the §5
+    #                                               required-path marker
+    #                                               "<path>" is transparent
+    #                                               — its contents validate
+    #                                               in the running context)
     #
     # Validation (ELF 5006 §8): a running path context tracks the
     # entity a path is "at"; each step must connect to it, attribute
@@ -104,7 +110,7 @@ module Expressir
       EXPRESS_LINK_PATH = /\A<<express:([^,>]+)(?:,[^>]+)?>>\z/
       private_constant :EXPRESS_LINK_PATH
 
-      TOKEN = /<<express:[^,>]+(?:,[^>]+)?>>|->|<-|<=|=>|\*>|<\*|!?\{|[{}\[\]()=:|!,*\/<>]|'(?:''|[^'])*'|\w+(?:\.\w+)?/
+      TOKEN = /<<express:[^,>]+(?:,[^>]+)?>>|->|<-|<=|=>|\*>|<\*|\|\||!?\{|[{}\[\]()=:|!,*\/<>]|'(?:''|[^'])*'|\w+(?:\.\w+)?/
       MARKERS = ["{", "}", "[", "]", "(", ")", ":", "|", "!", ",", "/",
                  "*", "<", ">", "MAPPING_OF", "!{"].freeze
       LINKS = ["->", "<-", "<=", "=>", "*>", "<*"].freeze
@@ -140,13 +146,19 @@ module Expressir
         errors = []
         pending_link = nil
         pending_type_assign = false
-        false
         i = 0
         while i < tokens.length
           token = tokens[i]
           case token
+          when "||"
+            name_token = tokens[i + 1]
+            if name_token&.match?(/\A\w+\z/) && tokens[i + 2] == "||"
+              steps << Step.new(operator: "||", name: name_token)
+              i += 2
+            else
+              errors << "supertype marker '||' without an entity name"
+            end
           when "!{"
-            true
             step, consumed = parse_constraint(tokens[i..], negated: true)
             steps << step
             i += consumed
@@ -182,6 +194,14 @@ module Expressir
             else
               steps << Step.new(operator: "[")
             end
+          when "*"
+            name_token = tokens[i + 1]
+            if name_token&.match?(/\A\w+\z/) && tokens[i + 2] == "*"
+              steps << Step.new(operator: "*", name: name_token)
+              i += 2
+            else
+              steps << Step.new(operator: token)
+            end
           when *MARKERS
             steps << Step.new(operator: token)
           when /\A<<express:/
@@ -302,6 +322,14 @@ module Expressir
           when "*>", "<*"
             issues.concat(select_extension_issues(step, pos, ctx, by_name))
             ctx = step.name&.safe_downcase
+          when "||"
+            issues.concat(supertype_marker_issues(step, pos, ctx, by_name))
+            if step.name
+              seen[step.name.safe_downcase] = true
+              ctx = step.name.safe_downcase
+            end
+          when "*"
+            issues.concat(tree_marker_issues(step, pos, by_name))
           else
             issues.concat(check_step(step, pos, ctx, last_qualified, by_name))
             if step.name
@@ -495,6 +523,39 @@ module Expressir
         end
       end
 
+      # ELF 5006 §5 supertype entity marker: `||supertype||` names an
+      # entity that must exist and, when the path has a running
+      # context, be a supertype of (or equal to) that context entity.
+      def supertype_marker_issues(step, pos, ctx, by_name)
+        issues = []
+        entity = step.name
+        check_exists(issues, pos, entity, by_name)
+        return issues if entity.nil?
+
+        decl = by_name[entity.safe_downcase]&.last
+        return issues unless decl.is_a?(Model::Declarations::Entity)
+
+        context_decl = ctx && by_name[ctx]&.last
+        if context_decl.is_a?(Model::Declarations::Entity) &&
+            !entity_reaches?(context_decl, entity.safe_downcase, by_name,
+                             {}.compare_by_identity)
+          issues << Issue.new(step: pos,
+                              message: "'#{entity}' is not a supertype of " \
+                                       "'#{ctx}'")
+        end
+        issues
+      end
+
+      # ELF 5006 §5 relationship tree marker: `*relationship*` names an
+      # entity whose instances may assemble into a tree; the path
+      # between it and the related entities is implied, so only the
+      # entity's existence is checkable.
+      def tree_marker_issues(step, pos, by_name)
+        issues = []
+        check_exists(issues, pos, step.name, by_name)
+        issues
+      end
+
       # ELF 5006 §8 navigation validation with a running context: the
       # attribute must exist on the context entity, and its type must
       # be able to reference the step's target entity.

data/lib/expressir/reference/grammar_crosswalk.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Expressir
+  module Reference
+    # Rule-by-rule cross-walk between the parsanol grammar and the
+    # ISO 10303-11 Annex A/B productions. The mapping data is generated
+    # by `rake reference:crosswalk`; the spec fails when a grammar rule
+    # has no row or the rendered guide is stale.
+    class GrammarCrosswalk
+      DATA_PATH = File.expand_path("grammar_crosswalk.yml", __dir__)
+      GRAMMAR_RULE = /rule\(:(\w+)/
+      PRODUCTION_STATUSES = %w[aligned decomposed].freeze
+
+      class << self
+        def data
+          @data ||= YAML.load_file(DATA_PATH)
+        end
+
+        def grammar_path
+          Expressir.root_path.join(data.dig("source", "grammar"))
+        end
+
+        def grammar_rules
+          File.read(grammar_path).scan(GRAMMAR_RULE).flatten.uniq.sort
+        end
+
+        def rows
+          data["rules"]
+        end
+
+        def annex_without_rule
+          data["annex_without_rule"]
+        end
+
+        def statuses
+          data["statuses"]
+        end
+
+        # Returns the list of inconsistencies; empty means in sync.
+        def validate
+          errors = []
+          declared = rows.map { |row| row["rule"] }
+          missing = grammar_rules - declared
+          unknown = declared - grammar_rules
+          duplicates = declared.tally.select { |_, count| count > 1 }.keys
+          errors << "grammar rules without a cross-walk row: #{missing.join(', ')}" if missing.any?
+          errors << "cross-walk rows without a grammar rule: #{unknown.join(', ')}" if unknown.any?
+          errors << "duplicate cross-walk rows: #{duplicates.join(', ')}" if duplicates.any?
+
+          rows.each do |row|
+            status = row["status"]
+            unless statuses.key?(status)
+              errors << "#{row['rule']}: unknown status '#{status}'"
+            end
+            if PRODUCTION_STATUSES.include?(status) && !row["production"]
+              errors << "#{row['rule']}: #{status} row needs a production"
+            end
+          end
+          errors
+        end
+
+        def render_adoc
+          lines = [
+            "= Grammar cross-walk",
+            "",
+            "// Generated by `rake reference:crosswalk` from",
+            "// #{data.dig('source', 'grammar')} and the Annex A snapshot.",
+            "// Do not edit by hand; the reference spec fails when this file is stale.",
+            "",
+            "== Purpose",
+            "",
+            "Every parsanol grammar rule is mapped to the ISO 10303-11:2004",
+            "Annex A production it implements. Divergences from the standard",
+            "grammar are classified with one of these statuses:",
+            "",
+            *statuses.map { |name, description| "* `#{name}` — #{description}" },
+            "",
+            "== Rules",
+            "",
+            '[cols="2,3,1,4", options="header"]',
+            "|===",
+            "| Parsanol rule | Annex A production | Status | Note",
+            "",
+            *rows.map { |row| rule_row(row) },
+            "|===",
+            "",
+            "== Annex A productions without a dedicated rule",
+            "",
+            "These productions are handled by supporting code rather than a",
+            "grammar rule:",
+            "",
+            '[cols="3,1,5", options="header"]',
+            "|===",
+            "| Annex A production | Status | Handled by",
+            "",
+            *annex_without_rule.map { |row| annex_row(row) },
+            "|===",
+            "",
+          ]
+          lines.join("\n")
+        end
+
+        private
+
+        def rule_row(row)
+          note = row["literal"] ? "literal `#{row['literal']}`" : row["note"]
+          "| `#{row['rule']}` | #{cell(row['production'])} | #{row['status']} | #{cell(note)}"
+        end
+
+        def annex_row(row)
+          "| `#{row['production']}` | #{row['status']} | #{cell(row['note'])}"
+        end
+
+        def cell(text)
+          text.to_s.gsub("|", "\\|")
+        end
+      end
+    end
+  end
+end