expressir 2.4.11 → 2.4.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29d1099f121d8528e495476328a9388278187589c0358db455d57e231055a6dc
-  data.tar.gz: 6cadd85e6d2b1184ff1cc53883857698f5c3b0d8985ac2f6f962986ceeb84326
+  metadata.gz: e3cf38ff1a09f95805cc5a6dc8c074832e47eeb8ceb7e62c79f503d521d775ac
+  data.tar.gz: a308605c1d7c97d33f766d08e8262e6e2039104ff7362e36a0fa5bd8e3839ccf
 SHA512:
-  metadata.gz: 82bd2f4cd92180180f6c9b831dd0964950cc8be5a71e51bd5e737a6538289dad0a7e7b0e91902e6462f7df5aa6878fa0b6ec58c99b019a88e8e8145322eec935
-  data.tar.gz: 6c60ea124de34b72f42107538fce8d527488361957eeec4b42e0b7a1b769ac2e4254e17f292fd1be151902ee8a0dab2328d583c71e9290582019f28fc92987ac
+  metadata.gz: 4c97b4d258e50604fba0bdc0365c3f8272d6944dc225755e6408c6b585324b917448134352a4ffb4da445ca21ef910858283931abef43625d0b4138c90ecf694
+  data.tar.gz: d268fd6aef2e11bdafe5f81845931e91742dcd33ff48f3a2f6bb0076a6f9bad440045609a501b81fcc2130fef6dcd565d972ebc6634861d0341f9efa2649b5b5

data/README.adoc

@@ -215,6 +215,8 @@ Commands:
   expressir flatten PATH                       # Flatten the interface closure into an ISO 10303-11:1994 longform schema
   expressir fix PATH                           # Rewrite self-schema-qualified references (#125)
   expressir format PATH                        # pretty print EXPRESS schema located at PATH
+  expressir mapping_validate PATH              # Validate <<express:...>> links in a module mapping.yaml against its ARM/MIM closure
+  expressir xsd PATH -o OUT.xsd                # Write an XML Schema rendering of the EXPRESS schema at PATH
   expressir help [COMMAND]                     # Describe available commands or one specific command
   expressir validate load *PATH                # validate EXPRESS schema located at PATH
   expressir validate ascii PATH                # Validate EXPRESS files for ASCII-only content (excluding remarks)
@@ -1266,7 +1268,38 @@ The default text output displays:
 This helps identify areas of your EXPRESS schemas that need documentation
 improvement.
 
-=== EXPRESS Changes files
+=== Schema hyperlinked source faces
+
+`Schema#source`, `Schema#source_hyperlinked`, and
+`Schema#formatted_hyperlinked(_adoc)` render a schema head or the full
+schema with cross-references either verbatim or as links (the adoc
+variant emits `<<schema.item,item>>` xref macros — render inside a
+`[source,subs="+macros"]` block for live links; see the
+`Expressir::Express::SmrlXml` and `Expressir::Express::Xsd` writers
+for the XML faces).
+
+== MIM mapping validation (mapping.yaml)
+
+`expressir mapping_validate PATH` loads a module `mapping.yaml`
+(lutaml-model typed: `Expressir::Mapping::Document`) and resolves every
+`<<express:SCHEMA.ITEM,ITEM>>` link against the ARM/MIM interface
+closure, reporting links whose schema or item is unknown.
+
+== XML faces
+
+- `Expressir::Express::SmrlXml.format(repository)` — the SMRL index
+  block per schema (eeng wo-smrl-xml shape).
+- `Expressir::Express::Xsd.format(schema)` — an XML Schema rendering
+  (entities as element/complexType, substitutionGroup for subtypes,
+  enumeration facets).
+
+== Lazy compiled-set access
+
+`Expressir::Express::Core.lazy_set(artifact)` lists a compiled set's
+wire paths without hydrating and hydrates individual files on demand —
+renderers that touch one schema per page hydrate one schema per page.
+
+== EXPRESS Changes files
 
 Expressir provides commands for working with EXPRESS Changes files that track
 schema modifications across versions.

data/ext/expressir_core/src/lib.rs

@@ -304,6 +304,45 @@ fn set_count(_ruby: &Ruby, reader: &SetReader) -> usize {
     reader.set.files.len()
 }
 
+/// Every wire path in the artifact, in artifact order — no hydration.
+fn set_wire_paths(_ruby: &Ruby, reader: &SetReader) -> Result<magnus::Value, Error> {
+    let paths = RArray::with_capacity(reader.set.files.len());
+    for file in &reader.set.files {
+        paths.push(ruby_str(_ruby, &file.wire_path))?;
+    }
+    Ok(paths.as_value())
+}
+
+fn ruby_str(ruby: &Ruby, s: &str) -> magnus::Value {
+    ruby.str_new(s).as_value()
+}
+
+/// `[wire_path, model]` for ONE file, addressed by wire path — the
+/// lazy-access path (M2): callers hydrate only the schemas a render
+/// touches instead of the whole set.
+fn set_hydrate_one(ruby: &Ruby, reader: &SetReader, wire_path: String) -> Result<magnus::Value, Error> {
+    let file = reader
+        .set
+        .files
+        .iter()
+        .find(|f| f.wire_path == wire_path)
+        .ok_or_else(|| {
+            Error::new(
+                ruby.exception_runtime_error(),
+                format!("wire path {wire_path} not in compiled set"),
+            )
+        })?;
+    let wire = file.wire().map_err(|e| {
+        Error::new(ruby.exception_runtime_error(), format!("{}: {e}", file.wire_path))
+    })?;
+    let mut cache = reader.cache.lock().expect("class cache");
+    let model = value_to_ruby(ruby, &mut cache, &wire)?;
+    let pair = RArray::with_capacity(2);
+    pair.push(ruby.str_new(&file.wire_path))?;
+    pair.push(model)?;
+    Ok(pair.as_value())
+}
+
 /// `[wire_path, model]` for the next file in artifact order, nil at
 /// the end.
 fn set_next(ruby: &Ruby, reader: &SetReader) -> Result<magnus::Value, Error> {
@@ -441,6 +480,8 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     set_class.define_method("digest", method!(set_digest, 0))?;
     set_class.define_method("count", method!(set_count, 0))?;
     set_class.define_method("next", method!(set_next, 0))?;
+    set_class.define_method("wire_paths", method!(set_wire_paths, 0))?;
+    set_class.define_method("hydrate_one", method!(set_hydrate_one, 1))?;
     set_class.define_method("matches_sources", method!(set_matches_sources, 1))?;
     Ok(())
 }

data/lib/expressir/cli.rb

@@ -99,6 +99,18 @@ module Expressir
       Expressir::Commands::BenchmarkCache.new(options).run(path)
     end
 
+    desc "mapping_validate PATH", "Validate <<express:...>> links in a module mapping.yaml against its ARM/MIM closure"
+    def mapping_validate(path)
+      Expressir::Commands::MappingValidate.new(options).run(path)
+    end
+
+    desc "xsd PATH", "Write an XML Schema rendering of the EXPRESS schema at PATH"
+    method_option :output, type: :string, aliases: "-o",
+                           desc: "Output file path (defaults to stdout)"
+    def xsd(path)
+      Expressir::Commands::Xsd.new(options).run(path)
+    end
+
     desc "validate SUBCOMMAND", "EXPRESS schema validation commands"
     subcommand "validate", Expressir::Commands::Validate
 

data/lib/expressir/commands/mapping_validate.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Commands
+    # `expressir mapping validate` (#88): load a module mapping.yaml
+    # and resolve every <<express:...>> link against the ARM/MIM
+    # interface closure. Exits 1 when unknown links remain.
+    class MappingValidate < Base
+      def run(path)
+        document = Expressir::Mapping.load_file(path)
+        unknown = Expressir::Mapping.unknown_links(document, repository_for(path))
+
+        if unknown.empty?
+          say "all links resolve"
+          return
+        end
+
+        unknown.each do |link|
+          say "unknown: #{link.text}"
+        end
+        raise Thor::Error, "#{unknown.size} unknown link(s)"
+      end
+
+      private
+
+      def repository_for(path)
+        dir = File.dirname(File.expand_path(path))
+        arm = Dir[File.join(dir, "arm.exp")].first
+        mim = Dir[File.join(dir, "mim.exp")].first
+        roots = [arm, mim].compact
+        raise Thor::Error, "no arm.exp/mim.exp next to #{path}" if roots.empty?
+
+        files = roots.flat_map do |root|
+          ParityInputs.closure_paths(root)
+        end.uniq.select { |f| File.exist?(f) }
+        Expressir::Express::Parser.from_files(files)
+      end
+    end
+  end
+end

data/lib/expressir/commands/parity_inputs.rb

@@ -5,58 +5,92 @@ module Expressir
     # Common parser/discovery helpers shared by parity CLI commands
     # (expand, flatten, check) — they all need: list of files in the
     # interface closure of a root file, and the root schema parsed.
+    #
+    # Schema resolution order (per the ELF schema manifest directive):
+    #   1. `--manifest PATH` — an ELF schema manifest explicitly defines
+    #      where each schema lives; this is the primary mode.
+    #   2. `--stepmod DIR` — explicit opt-in to the STEPmod directory
+    #      convention (`schemas/**/<name>.exp`) as the fallback.
+    #   3. Otherwise the file's own directory is used; a lookup failure
+    #      warns and points at the two explicit modes.
     module ParityInputs
       module_function
 
-      # Resolve the transitive interface closure of +root_path+. Deps are
-      # looked up by schema name: first in the file's own directory, then
-      # across the enclosing STEPmod checkout (the nearest ancestor holding
-      # a `schemas/` directory, e.g. resources/ and modules/ trees).
+      # Resolve the transitive interface closure of +root_path+. The queue
+      # holds paths and `seen` guards by schema name: mutual USE FROM
+      # cycles must terminate (this loop once span rounds forever on them,
+      # re-reading the same files).
       def closure_paths(root_path, manifest: nil, stepmod: nil)
-        index = schema_index(root_path)
+        index = schema_index(root_path, manifest: manifest, stepmod: stepmod)
         seen = { File.basename(root_path, ".exp").downcase => root_path }
-        queue = [File.basename(root_path, ".exp").downcase]
+        missing = []
+        queue = [root_path]
         until queue.empty?
-          name = queue.shift
-          path = seen[name] || index[name]
-          next unless path
-          next if seen.key?(name) && seen[name] != root_path
+          closure_names(File.read(queue.shift)).each do |dep|
+            name = dep.downcase
+            next if seen.key?(name)
 
-          seen[name] = path
-          closure_names(File.read(path)).each { |d| queue << d.downcase }
+            path = index&.[](name)
+            unless path
+              missing << name
+              seen[name] = nil
+              next
+            end
+
+            seen[name] = path
+            queue << path
+          end
+        end
+        unless missing.empty?
+          warn "expressir: schema(s) not found: #{missing.uniq.join(', ')}" \
+               "#{resolver_hint(manifest, stepmod)}"
         end
-        seen.values.uniq
+        seen.values.compact.uniq
       end
 
-      # Schema-name → path map for the STEPmod checkout around +root_path+,
-      # built once per invocation. The index root is the nearest ancestor
-      # directory NAMED `schemas` (wg12-step layout:
-      # `schemas/modules/<module>/mim.exp`), and entries key on the schema
-      # name declared inside each file — module files are `arm.exp` /
-      # `mim.exp`, so basenames cannot be the key. Falls back to the file's
-      # own directory when there is no schemas/ ancestor.
-      def schema_index(root_path)
-        dir = File.dirname(File.expand_path(root_path))
-        until dir == "/" || File.basename(dir) == "schemas"
-          parent = File.dirname(dir)
-          break if parent == dir
+      def resolver_hint(manifest, stepmod)
+        if manifest
+          " (not in schema manifest #{manifest})"
+        elsif stepmod
+          " (not found under STEPmod root #{stepmod})"
+        else
+          " - provide --manifest PATH (ELF schema manifest) or " \
+            "--stepmod DIR to resolve them"
+        end
+      end
 
-          dir = parent
+      # Schema-name → path index from the ELF schema manifest.
+      def manifest_index(manifest_path)
+        manifest = Expressir::SchemaManifest.from_file(manifest_path)
+        manifest.schemas.to_h do |entry|
+          [entry.id.downcase, entry.path]
         end
-        return same_dir_index(root_path) unless File.basename(dir) == "schemas"
+      rescue StandardError => e
+        warn "expressir: could not load schema manifest #{manifest_path}: #{e.message}"
+        nil
+      end
 
-        @@indexes ||= {}
-        @@indexes[dir] ||= begin
-          h = {}
-          Find.find(dir) do |path|
-            next unless path.end_with?(".exp")
+      # Schema-name → path index over a STEPmod checkout root (the
+      # directory holding `schemas/`, or that directory itself).
+      def stepmod_index(stepmod_dir)
+        root = File.join(File.expand_path(stepmod_dir), "schemas")
+        root = File.expand_path(stepmod_dir) unless File.directory?(root)
+        h = {}
+        Find.find(root) do |path|
+          next unless path.end_with?(".exp")
 
-            declared = File.read(path)[/\bSCHEMA\s+(\w+)/i, 1]
-            h[declared.downcase] = path if declared
-            h[File.basename(path, ".exp").downcase] ||= path
-          end
-          h
+          declared = File.read(path)[/\bSCHEMA\s+(\w+)/i, 1]
+          h[declared.downcase] = path if declared
+          h[File.basename(path, ".exp").downcase] ||= path
         end
+        h
+      end
+
+      def schema_index(root_path, manifest: nil, stepmod: nil)
+        return manifest_index(manifest) if manifest
+        return stepmod_index(stepmod) if stepmod
+
+        same_dir_index(root_path)
       end
 
       def same_dir_index(root_path)
@@ -66,19 +100,26 @@ module Expressir
         end
       end
 
+      # Interface names declared by +source+. Remark text is stripped
+      # first: prose like "use from the main schema" must not spawn
+      # phantom dependencies.
       def closure_names(source)
-        source.scan(/\bUSE\s+FROM\s+(\w+)/i).flatten.uniq +
-          source.scan(/\bREFERENCE\s+FROM\s+(\w+)/i).flatten.uniq
+        code = source.gsub(/--[^\n]*/, "").gsub(/\(\*.*?\*\)/m, "")
+        code.scan(/\bUSE\s+FROM\s+(\w+)/i).flatten.uniq +
+          code.scan(/\bREFERENCE\s+FROM\s+(\w+)/i).flatten.uniq
       end
 
-      # manifest:/stepmod: are accepted for the ELF-manifest resolver
-      # contract; the directory-index fallback ignores them until that
-      # resolver lands.
       def root_schema(root_path, manifest: nil, stepmod: nil)
         name = File.read(root_path)[/\bSCHEMA\s+(\w+)/, 1]
-        cp = closure_paths(root_path)
-        repo = Expressir::Express::Parser.from_files(cp, max_processes: 1)
-        [repo.schemas.find { |s| s.id == name }, repo]
+        # skip_references: longform generation and checking run their own
+        # resolution; resolving every reference of a large closure here made
+        # flatten crawl (minutes vs seconds).
+        repo = Expressir::Express::Parser.from_files(
+          closure_paths(root_path, manifest: manifest, stepmod: stepmod),
+          skip_references: true,
+          max_processes: 1,
+        )
+        [repo.schemas.find { |s| s.id&.downcase == name&.downcase }, repo]
       end
     end
   end

data/lib/expressir/commands/xsd.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Commands
+    # `expressir xsd` (#276): write the XML Schema rendering of the
+    # schema at PATH.
+    class Xsd < Base
+      def run(path)
+        repo = Expressir::Express::Parser.from_file(path)
+        schema = repo.schemas.first
+        raise Thor::Error, "no schema in #{path}" unless schema
+
+        xml = Expressir::Express::Xsd.format(schema)
+        if options[:output]
+          File.write(options[:output], xml)
+          say "written to #{options[:output]}"
+        else
+          $stdout.write(xml)
+        end
+      end
+    end
+  end
+end

data/lib/expressir/commands.rb

@@ -24,5 +24,7 @@ module Expressir
     autoload :Version, "#{__dir__}/commands/version"
     autoload :Package, "#{__dir__}/commands/package"
     autoload :Manifest, "#{__dir__}/commands/manifest"
+    autoload :MappingValidate, "#{__dir__}/commands/mapping_validate"
+    autoload :Xsd, "#{__dir__}/commands/xsd"
   end
 end

data/lib/expressir/express/checker.rb

@@ -307,20 +307,32 @@ module Expressir
 
         Array(type.underlying_type.items).each do |item|
           next if item.id.nil?
-          next if find_type(schema, item.id)
-          next if find_entity(schema, item.id).nil? # unresolved handled elsewhere
+          next if select_item_resolves?(schema, item.id)
 
           note!(:check_select_named_type, :error, schema,
-                "TYPE #{type.id}: select item '#{item.id}' is an entity, " \
-                "not a named type", type)
+                "In the SELECT TYPE #{type.id}, '#{item.id}' does not " \
+                "name an existing TYPE or ENTITY", type)
         end
       end
 
       def find_type(schema, id)
         key = id.safe_downcase
-        return schema.types.find { |t| t.id.safe_downcase == key } if schema
+        schema.types.find { |t| t.id.safe_downcase == key }
+      end
+
+      # ISO 10303-11 rule 258: select_list items are named_types —
+      # entity_ref | type_ref. The item is fine when it names either,
+      # in this schema or any repository schema (interface-visible).
+      def select_item_resolves?(schema, id)
+        return true if find_entity(schema, id)
+        return true if schema.types.to_a.any? { |t| t.id.safe_downcase == id.safe_downcase }
 
-        nil
+        @by_name.each_value.any? do |group|
+          group.any? do |other|
+            other.types.to_a.any? { |t| t.id.safe_downcase == id.safe_downcase } ||
+              other.entities.to_a.any? { |e| e.id.safe_downcase == id.safe_downcase }
+          end
+        end
       end
 
       # eeng declared-kind probe: :type when a TYPE of that name is

data/lib/expressir/express/core.rb

@@ -43,6 +43,24 @@ module Expressir
         ::Expressir::Core.parse_to_model(source, path)
       end
 
+      # Lazy handle over a compiled-set artifact (M2): `wire_paths`
+      # lists the set's files without hydrating anything; `hydrate_one`
+      # builds a single file's model on demand. Renderers that touch
+      # one schema per page hydrate one schema per page instead of the
+      # whole repository.
+      def self.lazy_set(path)
+        unless NATIVE_AVAILABLE
+          raise NotImplementedError,
+                "lazy set unavailable without the native extension"
+        end
+        unless ::Expressir::Core.const_defined?(:Set) &&
+            ::Expressir::Core::Set.method_defined?(:hydrate_one)
+          raise NotImplementedError, "lazy set unavailable; ext too old"
+        end
+
+        ::Expressir::Core::Set.open(path)
+      end
+
       # Compile many files concurrently: jobs are [read_path,
       # wire_path] pairs; the block receives (wire_path, model, error)
       # per job in completion order. Workers run on native threads, so

data/lib/expressir/express/shtolo.rb

@@ -351,15 +351,22 @@ module Expressir
         end
       end
 
-      # Every identifier a FunctionCall site names, across the
-      # artifact's surviving declarations.
+      # Every identifier a call site names, across the artifact's
+      # surviving declarations: FunctionCall for functions and
+      # ProcedureCall statements for procedures. (A zero-argument
+      # function reference written bare is not represented as a
+      # FunctionCall by the parser and is counted via any SimpleReference
+      # miss — accepted v1 blind spot, see tranche notes.)
       def called_ids(schema)
         called = {}
         each_node(schema) do |node|
-          next unless node.is_a?(Model::Expressions::FunctionCall)
-
-          ref = node.function
-          id = ref.is_a?(String) ? ref : ref&.id
+          id = nil
+          case node
+          when Expressir::Model::Expressions::FunctionCall
+            id = node.function.is_a?(String) ? node.function : node.function&.id
+          when Expressir::Model::Statements::ProcedureCall
+            id = node.procedure.is_a?(String) ? node.procedure : node.procedure&.id
+          end
           called[id.safe_downcase] = true if id
         end
         called
@@ -392,19 +399,28 @@ module Expressir
       def reduce_supertype_expression(expr, visible_ids)
         case expr
         when Model::SupertypeExpressions::OneofSupertypeExpression
-          refs = Array(expr.operands).select do |ref|
-            id = ref.is_a?(String) ? ref : ref.id
-            id.nil? || visible_ids.key?(id.safe_downcase)
+          reduced = expr.operands.filter_map do |operand|
+            reduce_supertype_expression(operand, visible_ids)
           end
-          return nil if refs.empty?
+          return nil if reduced.empty?
 
-          refs.one? ? refs.first : reset_oneof(expr, refs)
+          reduced.one? ? reduced.first : reset_oneof(expr, reduced)
         when Model::SupertypeExpressions::BinarySupertypeExpression
-          left = reduce_supertype_expression(expr.operands[0], visible_ids)
-          right = reduce_supertype_expression(expr.operands[1], visible_ids)
-          return nil if left.nil? && right.nil?
+          left = reduce_supertype_expression(expr.operand1, visible_ids)
+          right = reduce_supertype_expression(expr.operand2, visible_ids)
+          if left.nil?
+            return right
+          end
+          if right.nil?
+            return left
+          end
+
+          rebuild_binary(expr, left, right)
+        when Model::References::SimpleReference
+          id = expr.id
+          return nil if id && !visible_ids.key?(id.safe_downcase)
 
-          left || right
+          expr
         else
           expr
         end
@@ -416,6 +432,13 @@ module Expressir
         copy
       end
 
+      def rebuild_binary(expr, left, right)
+        copy = deep_copy(expr)
+        copy.operand1 = left
+        copy.operand2 = right
+        copy
+      end
+
       def resolve_extensible_enumerations!(schema)
         schema.types.select do |t|
           t.underlying_type.is_a?(Model::DataTypes::Enumeration) && t.underlying_type.extensible

data/lib/expressir/version.rb

@@ -3,6 +3,6 @@ module Expressir
   # autoload it (Ruby autoload only works for module/class constants, not
   # for string constants like `Expressir::VERSION`).
   module Version
-    VERSION = "2.4.11".freeze
+    VERSION = "2.4.13".freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: expressir
 version: !ruby/object:Gem::Version
-  version: 2.4.11
+  version: 2.4.13
 platform: ruby
 authors:
 - Ribose Inc.
@@ -425,6 +425,7 @@ files:
 - lib/expressir/commands/flatten.rb
 - lib/expressir/commands/format.rb
 - lib/expressir/commands/manifest.rb
+- lib/expressir/commands/mapping_validate.rb
 - lib/expressir/commands/non_ascii_character.rb
 - lib/expressir/commands/non_ascii_violation_collection.rb
 - lib/expressir/commands/package.rb
@@ -433,6 +434,7 @@ files:
 - lib/expressir/commands/validate_ascii.rb
 - lib/expressir/commands/validate_load.rb
 - lib/expressir/commands/version.rb
+- lib/expressir/commands/xsd.rb
 - lib/expressir/config.rb
 - lib/expressir/coverage.rb
 - lib/expressir/eengine.rb