expressir 2.4.35-arm-linux → 2.4.37-arm-linux

data/docs/_guides/reference/p21.adoc

@@ -0,0 +1,30 @@
+---
+title: Part 21
+parent: Reference
+grand_parent: Guides
+nav_order: 4
+---
+
+= Part 21
+
+== Purpose
+
+`Expressir::P21` reads ISO 10303-21 exchange structures: header
+entities, simple and complex instances, nested lists, references,
+typed parameters, enumerations and binaries.
+
+== Validation
+
+`Expressir::P21::Validator.validate(population, schema, short_names:)`
+maps Part 21 records to EXPRESS attributes in clause 12 order —
+supertype attributes first, derived slots valued `*`, inverse
+attributes unmapped — and reports arity, unknown-entity,
+unknown-reference, enum-value and derived-slot notes. Short names from
+clause 12.3 are passed as a `{"CPT" => "cartesian_point"}` map.
+
+== Conformance corpus
+
+The annex examples from the ISO 10303-21 detachment live under
+`spec/fixtures/p21/conformance/`; the gate spec parses each positive
+fixture with zero notes and asserts the intended loud failure for
+ladder-excluded forms.

data/docs/_guides/reference/shtolo.adoc

@@ -0,0 +1,36 @@
+---
+title: SHTOLO and Annex G
+parent: Reference
+grand_parent: Guides
+nav_order: 5
+---
+
+= SHTOLO and Annex G
+
+== Purpose
+
+`Expressir::Express::Shtolo` converts a multi-schema shortform EXPRESS
+model into an ISO 10303-11:1994 longform. It implements the two stages
+of Annex G: multi-schema to an intermediate single artifact schema
+(stage 1), then artifact to 1994-only constructs (stage 2).
+
+== Rule coverage
+
+Every Annex G rule has a live worked example in
+`spec/expressir/express/shtolo_annex_g_rule_audit_spec.rb`. The
+extracted rule list, the fixture that exercises each rule and the
+eengine coverage verdict are in
+`spec/fixtures/shtolo/annex-g-rules.md`.
+
+Key rules: name munging (G.NM.1), USE wins over REFERENCE (G.1.2),
+original-name copying for aliases (G.1.3), dependently-instantiable
+rules (G.1.6), implicit interface closure (G.1.7), pruning (G.1.9),
+extensible enumeration/select folding (G.2.3/G.2.4) and subtype
+constraint removal (G.2.5). Where eeng and the annex disagree, the
+annex wins; eeng output is a comparison input, not the contract.
+
+== Structural safety
+
+`Expressir::Express::SchemaCompare`/`SchemaPatch` provide the
+declaration-level diff used to verify that a generated longform has
+exactly the expected structural deltas.

data/exe/expressir-lsp

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require_relative "../lib/expressir"
+
+exit Expressir::Lsp::Server.new.run

data/expressir.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |spec|
   spec.license = "BSD-2-Clause"
 
   spec.bindir = "exe"
-  spec.executables   = %w[expressir]
+  spec.executables   = %w[expressir expressir-lsp]
   spec.require_paths = ["lib"]
 
   spec.metadata["homepage_uri"] = spec.homepage
@@ -47,7 +47,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "benchmark-ips"
   spec.add_dependency "csv"
   spec.add_dependency "liquid", "~> 5"
-  spec.add_dependency "lutaml-model", "~> 0.8.76"
+  spec.add_dependency "lutaml-model", "~> 0.8.114"
   spec.add_dependency "moxml"
   spec.add_dependency "nokogiri", "~> 1.19"
   spec.add_dependency "paint"

data/lib/expressir/cli.rb

@@ -111,6 +111,24 @@ module Expressir
       Expressir::Commands::Xsd.new(options).run(path)
     end
 
+    desc "export-json-schema PATH",
+         "Write a JSON Schema rendering of the first EXPRESS schema at PATH"
+    method_option :output, type: :string, aliases: "-o",
+                           desc: "Output file path (defaults to stdout)"
+    def export_json_schema(path)
+      Expressir::Commands::ExportJsonSchema.new(options).run(path)
+    end
+
+    desc "export-owl PATH",
+         "Write an OWL/Turtle rendering of the first EXPRESS schema at PATH"
+    method_option :output, type: :string, aliases: "-o",
+                           desc: "Output file path (defaults to stdout)"
+    method_option :base_iri, type: :string,
+                             desc: "Ontology IRI base (default: expressir.org/owl/<schema>#)"
+    def export_owl(path)
+      Expressir::Commands::ExportOwl.new(options).run(path)
+    end
+
     desc "xml-index DIR", "Write the SMRL index XML for every EXPRESS schema under DIR"
     method_option :output, type: :string, aliases: "-o",
                            desc: "Output file path (defaults to stdout)"

data/lib/expressir/commands/check.rb

@@ -25,7 +25,9 @@ module Expressir
           raise Thor::Error, "#{failed} file(s) failed to parse"
         end
 
-        result = Expressir::Express::Checker.new(repository).check
+        result = Expressir::Express::Checker.new(
+          repository, dialect: options[:dialect]
+        ).check
 
         if options[:json]
           say JSON.generate(

data/lib/expressir/commands/export_json_schema.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Commands
+    # `expressir export-json-schema`: write the JSON Schema rendering of
+    # the first schema in PATH.
+    class ExportJsonSchema < Base
+      def run(path)
+        repository = Expressir::Express::Parser.from_file(path)
+        schema = repository.schemas.first
+        raise Thor::Error, "no schema in #{path}" unless schema
+
+        document = Expressir::Interop::JsonSchema.new(schema).to_json
+        write(document)
+      end
+
+      private
+
+      def write(document)
+        if options[:output]
+          File.write(options[:output], document)
+          say "written to #{options[:output]}"
+        else
+          $stdout.write(document)
+        end
+      end
+    end
+  end
+end

data/lib/expressir/commands/export_owl.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Commands
+    # `expressir export-owl`: write the OWL/Turtle rendering of the
+    # first schema in PATH.
+    class ExportOwl < Base
+      def run(path)
+        repository = Expressir::Express::Parser.from_file(path)
+        schema = repository.schemas.first
+        raise Thor::Error, "no schema in #{path}" unless schema
+
+        document = Expressir::Interop::Owl.new(
+          schema,
+          base_iri: options[:base_iri],
+        ).export
+        if options[:output]
+          File.write(options[:output], document)
+          say "written to #{options[:output]}"
+        else
+          $stdout.write(document)
+        end
+      end
+    end
+  end
+end

data/lib/expressir/commands/validate.rb

@@ -98,6 +98,9 @@ module Expressir
       method_option :stepmod, type: :string,
                               desc: "STEPmod checkout root — explicit opt-in to directory-" \
                                     "convention resolution as the fallback"
+      method_option :dialect, type: :string,
+                              desc: "ISO 10303-11 edition for dialect diagnostics: " \
+                                    "'1994' or '2004' (default: no edition notes)"
       def check(*paths)
         Check.new(options).run(*paths)
       end

data/lib/expressir/commands.rb

@@ -26,6 +26,8 @@ module Expressir
     autoload :Manifest, "#{__dir__}/commands/manifest"
     autoload :MappingValidate, "#{__dir__}/commands/mapping_validate"
     autoload :Xsd, "#{__dir__}/commands/xsd"
+    autoload :ExportJsonSchema, "#{__dir__}/commands/export_json_schema"
+    autoload :ExportOwl, "#{__dir__}/commands/export_owl"
     autoload :SmrlXmlIndex, "#{__dir__}/commands/smrl_xml_index"
   end
 end

data/lib/expressir/conformance/trend.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Expressir
+  module Conformance
+    # Trended property metrics over a corpus slice: parse rate and
+    # format idempotence rate are fractions; the diagnostic rate is the
+    # number of Checker notes per parsed file. Per-note-id counts make
+    # the report actionable. Published by the nightly conformance
+    # workflow as a JSON artifact so the numbers can be trended.
+    class Trend
+      def self.measure(files)
+        report = {
+          "files" => files.size,
+          "parsed" => 0,
+          "parse_failed" => 0,
+          "measurement_failed" => 0,
+          "idempotent" => 0,
+          "not_idempotent" => 0,
+          "notes" => 0,
+          "errors" => 0,
+          "warnings" => 0,
+          "note_ids" => {},
+        }
+        files.each do |path|
+          measure_file(path, report)
+        end
+        report.merge!(
+          "parse_rate" => rate(report["parsed"], report["files"]),
+          "idempotence_rate" => rate(report["idempotent"], report["parsed"]),
+          "diagnostic_rate" => rate(report["notes"], report["parsed"]),
+        )
+        report
+      end
+
+      def self.run(files, output:)
+        report = measure(files)
+        File.write(output, "#{JSON.pretty_generate(report)}\n")
+        report
+      end
+
+      def self.measure_file(path, report)
+        repository = parse_file(path)
+        unless repository
+          report["parse_failed"] += 1
+          return
+        end
+        report["parsed"] += 1
+        measure_properties(repository, report)
+      end
+      private_class_method :measure_file
+
+      def self.parse_file(path)
+        Expressir::Express::Parser.from_exp(File.read(path))
+      rescue StandardError
+        nil
+      end
+      private_class_method :parse_file
+
+      def self.measure_properties(repository, report)
+        schema = Array(repository.schemas).first
+        if schema && idempotent?(schema)
+          report["idempotent"] += 1
+        else
+          report["not_idempotent"] += 1
+        end
+        notes = Expressir::Express::Checker.new(
+          Expressir::Model::Repository.new(files: [repository]),
+        ).check.notes
+        report["notes"] += notes.size
+        notes.each do |note|
+          report[note.severity == :error ? "errors" : "warnings"] += 1
+          report["note_ids"][note.id.to_s] =
+            report["note_ids"].fetch(note.id.to_s, 0) + 1
+        end
+      rescue StandardError
+        report["measurement_failed"] += 1
+      end
+      private_class_method :measure_properties
+
+      def self.idempotent?(schema)
+        once = Expressir::Express::Formatter.format(schema)
+        reparsed = Expressir::Express::Parser.from_exp(once)
+        twice = Expressir::Express::Formatter.format(reparsed.schemas.first)
+        once == twice
+      rescue StandardError
+        false
+      end
+      private_class_method :idempotent?
+
+      def self.rate(numerator, denominator)
+        return 0.0 if denominator.zero?
+
+        (numerator.to_f / denominator).round(4)
+      end
+      private_class_method :rate
+    end
+  end
+end

data/lib/expressir/conformance.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Expressir
+  # Measurement tiers over the standards corpus (TODO.sota/07 part 2).
+  module Conformance
+    autoload :Trend, "#{__dir__}/conformance/trend"
+  end
+end

data/lib/expressir/eval/environment.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Eval
+    # Lexical scope chain: a name resolves to a value through the
+    # innermost scope that declares it. The schema provides type
+    # context; the population (step 3) provides instances for the
+    # instance-aware builtins.
+    class Environment
+      attr_reader :schema, :population
+
+      def initialize(schema:, population: nil, frames: [{}])
+        @schema = schema
+        @population = population
+        @frames = frames
+      end
+
+      def push(frame)
+        Environment.new(schema: @schema, population: @population,
+                        frames: @frames + [frame])
+      end
+
+      def define(name, value)
+        frame = @frames.last.dup
+        frame[name.safe_downcase] = value
+        Environment.new(schema: @schema, population: @population,
+                        frames: @frames[0..-2] + [frame])
+      end
+
+      def lookup(name)
+        key = name.safe_downcase
+        @frames.reverse_each do |frame|
+          return frame[key] if frame.key?(key)
+        end
+        nil
+      end
+
+      def bound?(name)
+        !lookup(name).nil? || @frames.any? { |f| f.key?(name.safe_downcase) }
+      end
+
+      def interpreter
+        @interpreter ||= Interpreter.new(schema: @schema,
+                                         population: @population)
+      end
+
+      # Part 21 attribute slots for an entity: inherited explicit
+      # attributes (supertype closure order) then the entity's own —
+      # the same order the P21 validator maps values by.
+      def slots_for(entity)
+        @slots ||= {}
+        @slots[entity] ||= begin
+          inherited = entity.supertype_closure.flat_map do |supertype|
+            explicit_attributes(supertype)
+          end
+          (inherited + explicit_attributes(entity)).each_with_index
+            .to_h do |attribute, index|
+            [attribute.id&.safe_downcase, index]
+          end
+        end
+      end
+
+      def explicit_attributes(entity)
+        Array(entity.attributes)
+          .select { |a| a.instance_of?(Model::Declarations::Attribute) }
+      end
+
+      def entity_for_keyword(keyword)
+        Array(@schema&.entities).find do |entity|
+          entity.id&.safe_downcase == keyword&.safe_downcase
+        end
+      end
+
+      def instance_for(reference)
+        return nil unless @population && reference.is_a?(String)
+        return nil unless reference.start_with?("#")
+
+        record = @population.instances[reference]
+        record && Values::Instance.new(id: reference[1..], record: record)
+      end
+    end
+  end
+end