expressir 1.2.10-aarch64-linux → 2.4.29-aarch64-linux

data/lib/expressir/commands/parity_inputs.rb

@@ -0,0 +1,160 @@
+require "find"
+require "thor"
+
+module Expressir
+  module Commands
+    # 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+. 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, manifest: manifest, stepmod: stepmod)
+        seen = { File.basename(root_path, ".exp").downcase => root_path }
+        missing = []
+        queue = [root_path]
+        until queue.empty?
+          closure_names(File.read(queue.shift)).each do |dep|
+            name = dep.downcase
+            next if seen.key?(name)
+
+            path = index&.[](name)
+            unless path
+              missing << name
+              seen[name] = nil
+              next
+            end
+
+            seen[name] = path
+            queue << path
+          end
+        end
+        unless missing.empty?
+          raise Thor::Error,
+                "expressir: schema(s) not found: #{missing.uniq.join(', ')}" \
+                "#{resolver_hint(manifest, stepmod)}"
+        end
+        seen.values.compact.uniq
+      end
+
+      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
+
+      # Schema-name → path index from the ELF schema manifest. An
+      # explicitly given manifest that cannot be loaded is fatal (#455):
+      # when the root has no interface dependencies the lookup would
+      # never consult the index, so a typo'd --manifest would exit 0.
+      def manifest_index(manifest_path)
+        manifest = Expressir::SchemaManifest.from_file(manifest_path)
+        manifest.schemas.to_h do |entry|
+          [entry.id.downcase, entry.path]
+        end
+      rescue StandardError => e
+        raise Thor::Error,
+              "expressir: could not load schema manifest #{manifest_path}: #{e.message}"
+      end
+
+      # 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
+      end
+
+      def schema_index(root_path, manifest: nil, stepmod: nil)
+        return manifest_index(manifest) if manifest
+        return stepmod_index(stepmod) if stepmod
+
+        # Default: the file's own directory plus, when the root sits
+        # inside a STEPmod checkout, its enclosing `schemas/` tree —
+        # the layout wg12-step modules live in. Same-directory
+        # declarations win over tree hits for the same schema name:
+        # the file next to the root is the intentional one (#455).
+        index = same_dir_index(root_path)
+        ancestor = ancestor_schemas_dir(root_path)
+        if ancestor
+          tree = stepmod_index(File.dirname(ancestor))
+          tree.update(index)
+          index = tree
+        end
+        index
+      end
+
+      # Nearest ancestor directory NAMED `schemas`, or nil.
+      def ancestor_schemas_dir(root_path)
+        dir = File.dirname(File.expand_path(root_path))
+        until dir == "/"
+          return dir if File.basename(dir) == "schemas"
+
+          dir = File.dirname(dir)
+        end
+        nil
+      end
+
+      def same_dir_index(root_path)
+        dir = File.dirname(File.expand_path(root_path))
+        h = {}
+        Dir.glob(File.join(dir, "*.exp")).each do |path|
+          # index by DECLARED schema name first (a file named arm.exp
+          # may declare schema m_arm), basename as fallback
+          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
+
+      # 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)
+        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
+
+      def root_schema(root_path, manifest: nil, stepmod: nil)
+        name = File.read(root_path)[/\bSCHEMA\s+(\w+)/, 1]
+        # 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
+end

data/lib/expressir/commands/validate.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Expressir
+  module Commands
+    # Thor subcommand for EXPRESS validation operations
+    class Validate < Thor
+      desc "load PATH_OR_MANIFEST",
+           "Validate EXPRESS schema loading and version strings"
+      long_desc <<~DESC
+        Validate EXPRESS schema(s) for parsing errors and version string presence.
+
+        Accepts either:
+        - Individual EXPRESS file paths (*.exp)
+        - A Schema Manifest YAML file (*.yaml) containing schema definitions
+
+        When using a Schema Manifest, all schemas in the manifest will be validated.
+
+        Examples:
+          # Validate individual EXPRESS files
+          expressir validate load schema1.exp schema2.exp
+
+          # Validate schemas from a manifest
+          expressir validate load manifest.yaml
+
+          # Validate with verbose output
+          expressir validate load manifest.yaml --verbose
+      DESC
+      method_option :verbose, type: :boolean, default: false,
+                              desc: "Show verbose output"
+      def load(*paths)
+        ValidateLoad.new(options).run(paths)
+      end
+
+      desc "ascii PATH_OR_MANIFEST",
+           "Validate EXPRESS files for ASCII-only content"
+      long_desc <<~DESC
+        Validate EXPRESS file(s) for non-ASCII characters and provide replacement suggestions.
+
+        Accepts either:
+        - Individual EXPRESS file path (*.exp)
+        - A directory path (with --recursive option)
+        - A Schema Manifest YAML file (*.yaml) containing schema definitions
+
+        When using a Schema Manifest, all schemas in the manifest will be validated.
+
+        This command:
+        - Scans each line for non-ASCII characters
+        - Reports detailed information about each violation
+        - Provides specific replacement suggestions (AsciiMath or ISO 10303-11)
+        - Displays a summary table showing all violations
+        - Optionally outputs structured data in YAML format
+
+        Examples:
+          # Validate a single EXPRESS file
+          expressir validate ascii schema.exp
+
+          # Validate all EXPRESS files in a directory recursively
+          expressir validate ascii ../iso-10303/schemas -r
+
+          # Validate schemas from a manifest
+          expressir validate ascii manifest.yaml
+
+          # Output results in YAML format
+          expressir validate ascii manifest.yaml -y
+
+          # Include remarks in validation (default: false)
+          expressir validate ascii schema.exp --check-remarks
+      DESC
+      method_option :recursive, type: :boolean, default: false, aliases: "-r",
+                                desc: "Validate EXPRESS files under the specified path recursively"
+      method_option :yaml, type: :boolean, default: false, aliases: "-y",
+                           desc: "Output results in YAML format"
+      method_option :check_remarks, type: :boolean, default: false,
+                                    desc: "Include remarks in ASCII validation (default: false, remarks are excluded)"
+      method_option :verbose, type: :boolean, default: false,
+                              desc: "Show verbose output"
+      def ascii(path)
+        ValidateAscii.new(options).run(path)
+      end
+
+      desc "check *PATHS", "Run eeng check-p11 semantic checks"
+      long_desc <<~DESC
+        Walks one or more EXPRESS files (or directories of .exp) and
+        reports the eeng check-p11 note subset covered by Checker:
+        redundant interfaces, duplicate resources, unresolved interface
+        schema/ref, SUBTYPE OF targets, SELECT/ENUM BASED_ON, and
+        WHERE/UNIQUE label patterns.
+
+        Exits 1 when any error-severity note fires.
+      DESC
+      method_option :json, type: :boolean, default: false,
+                           desc: "Emit the report as JSON (errors + warnings)"
+      method_option :manifest, type: :string,
+                               desc: "ELF schema manifest YAML defining where schemas live " \
+                                     "(primary resolution mode)"
+      method_option :stepmod, type: :string,
+                              desc: "STEPmod checkout root — explicit opt-in to directory-" \
+                                    "convention resolution as the fallback"
+      def check(*paths)
+        Check.new(options).run(*paths)
+      end
+    end
+  end
+end

data/lib/expressir/commands/validate_ascii.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "paint"
+require "table_tennis"
+
+module Expressir
+  module Commands
+    class ValidateAscii < Base
+      def run(express_file_path) # rubocop:disable Metrics/AbcSize
+        # Check if input is a manifest file
+        if File.file?(express_file_path) && File.extname(express_file_path) == ".yaml"
+          validate_from_manifest(express_file_path)
+          return
+        end
+
+        # Original file/directory validation logic
+        if File.file?(express_file_path)
+          unless File.exist?(express_file_path)
+            raise Errno::ENOENT, "Specified EXPRESS file " \
+                                 "`#{express_file_path}` not found."
+          end
+
+          if File.extname(express_file_path) != ".exp"
+            raise ArgumentError, "Specified file `#{express_file_path}` is " \
+                                 "not an EXPRESS file."
+          end
+
+          exp_files = [express_file_path]
+        elsif options[:recursive]
+          # Support the relative path with glob pattern
+          base_path = File.expand_path(express_file_path)
+          exp_files = Dir.glob("#{base_path}/**/*.exp")
+        else
+          # Non-recursive option
+          base_path = File.expand_path(express_file_path)
+          exp_files = Dir.glob("#{base_path}/*.exp")
+        end
+
+        if exp_files.empty?
+          raise Errno::ENOENT, "No EXPRESS files found in " \
+                               "`#{express_file_path}`."
+        end
+
+        process_files(exp_files)
+      end
+
+      private
+
+      def validate_from_manifest(manifest_path)
+        unless File.exist?(manifest_path)
+          raise Expressir::ManifestNotFoundError.new(manifest_path)
+        end
+
+        say "Loading manifest: #{manifest_path}..." if options[:verbose]
+
+        # Load manifest
+        manifest = Expressir::SchemaManifest.from_file(manifest_path)
+
+        # Extract paths from manifest
+        exp_files = manifest.schemas.map(&:path).reject do |p|
+          p.nil? || p.empty?
+        end
+
+        if exp_files.empty?
+          raise Expressir::NoValidSchemaPathsError.new("No valid schema paths found in manifest")
+        end
+
+        say "Validating #{exp_files.size} schema(s) from manifest for ASCII compliance..." if options[:verbose]
+
+        process_files(exp_files)
+      end
+
+      def process_files(exp_files)
+        # Process all files and collect violations
+        collection = NonAsciiViolationCollection.new(
+          check_remarks: options[:check_remarks],
+        )
+
+        exp_files.each do |exp_file|
+          collection.process_file(exp_file)
+        end
+
+        # Output results based on format
+        if options[:yaml]
+          require "yaml"
+          puts collection.to_yaml_data.to_yaml
+        else
+          collection.print_text_output
+          collection.print_table_output if collection.files_with_violations.positive?
+        end
+      end
+    end
+  end
+end

data/lib/expressir/commands/validate_load.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Commands
+    class ValidateLoad < Base
+      def run(paths)
+        # Determine if input is a manifest or direct paths
+        if paths.size == 1 && File.extname(paths.first) == ".yaml"
+          validate_from_manifest(paths.first)
+        else
+          validate_from_paths(paths)
+        end
+      end
+
+      private
+
+      def validate_from_manifest(manifest_path)
+        unless File.exist?(manifest_path)
+          raise Expressir::ManifestNotFoundError.new(manifest_path)
+        end
+
+        say "Loading manifest: #{manifest_path}..." if options[:verbose]
+
+        # Load manifest
+        manifest = Expressir::SchemaManifest.from_file(manifest_path)
+
+        # Extract paths from manifest
+        paths = manifest.schemas.map(&:path).reject { |p| p.nil? || p.empty? }
+
+        if paths.empty?
+          raise Expressir::NoValidSchemaPathsError.new("No valid schema paths found in manifest")
+        end
+
+        say "Validating #{paths.size} schema(s) from manifest..." if options[:verbose]
+
+        validate_from_paths(paths)
+      end
+
+      def validate_from_paths(paths)
+        no_version = []
+        no_valid = []
+
+        paths.each do |path|
+          x = Pathname.new(path).realpath.relative_path_from(Dir.pwd)
+          say "Validating #{x}"
+          ret = validate_schema(path)
+
+          if ret.nil?
+            no_valid << "Failed to parse: #{x}"
+            next
+          end
+
+          ret.each do |schema_id|
+            no_version << "Missing version string: schema `#{schema_id}` | #{x}"
+          end
+        end
+
+        print_validation_errors(:failed_to_parse, no_valid)
+        print_validation_errors(:missing_version_string, no_version)
+
+        unless [no_valid, no_version].all?(&:empty?)
+          raise Expressir::SchemaValidationError.new(
+            "Schema validation failed",
+            errors: no_valid + no_version,
+          )
+        end
+
+        say "Validation passed for all EXPRESS schemas."
+      end
+
+      def validate_schema(path)
+        repository = Expressir::Express::Parser.from_file(path)
+        repository.schemas.inject([]) do |acc, schema|
+          acc << schema.id unless schema.version&.value
+          acc
+        end
+      rescue StandardError
+        nil
+      end
+
+      def print_validation_errors(type, array)
+        return if array.empty?
+
+        say "#{'*' * 20} RESULTS: #{type.to_s.upcase.tr('_', ' ')} #{'*' * 20}"
+        array.each do |msg|
+          say msg
+        end
+      end
+    end
+  end
+end

data/lib/expressir/commands/version.rb

@@ -0,0 +1,9 @@
+module Expressir
+  module Commands
+    class Version < Base
+      def run
+        say Expressir::Version::VERSION
+      end
+    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

@@ -0,0 +1,30 @@
+# lib/expressir/commands.rb
+module Expressir
+  module Commands
+    autoload :Base, "#{__dir__}/commands/base"
+    autoload :Benchmark, "#{__dir__}/commands/benchmark"
+    autoload :BenchmarkCache, "#{__dir__}/commands/benchmark_cache"
+    autoload :Check, "#{__dir__}/commands/check"
+    autoload :Clean, "#{__dir__}/commands/clean"
+    autoload :Coverage, "#{__dir__}/commands/coverage"
+    autoload :Expand, "#{__dir__}/commands/expand"
+    autoload :Fix, "#{__dir__}/commands/fix"
+    autoload :Flatten, "#{__dir__}/commands/flatten"
+    autoload :Format, "#{__dir__}/commands/format"
+    autoload :ParityInputs, "#{__dir__}/commands/parity_inputs"
+    autoload :Validate, "#{__dir__}/commands/validate"
+    autoload :ValidateLoad, "#{__dir__}/commands/validate_load"
+    autoload :ValidateAscii, "#{__dir__}/commands/validate_ascii"
+    autoload :NonAsciiCharacter, "#{__dir__}/commands/non_ascii_character"
+    autoload :FileViolations, "#{__dir__}/commands/file_violations"
+    autoload :NonAsciiViolationCollection, "#{__dir__}/commands/non_ascii_violation_collection"
+    autoload :Changes, "#{__dir__}/commands/changes"
+    autoload :ChangesValidate, "#{__dir__}/commands/changes_validate"
+    autoload :ChangesImportEengine, "#{__dir__}/commands/changes_import_eengine"
+    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/config.rb

@@ -12,12 +12,49 @@ module Expressir
   end
 
   class Configuration
-    attr_accessor :logs
+    attr_accessor :logs, :benchmark_enabled, :benchmark_ips, :benchmark_verbose,
+                  :benchmark_save, :benchmark_iterations, :benchmark_warmup, :benchmark_parallel,
+                  :benchmark_format
 
     def initialize
       @logs = %i(error)
+      # Enable benchmarking via environment variable
+      @benchmark_enabled = ENV["EXPRESSIR_BENCHMARK"] == "true"
+      # Use benchmark-ips for detailed statistics
+      @benchmark_ips = ENV["EXPRESSIR_BENCHMARK_IPS"] == "true"
+      # Show verbose output for benchmarking
+      @benchmark_verbose = ENV["EXPRESSIR_BENCHMARK_VERBOSE"] == "true"
+      # Save benchmark results to file
+      @benchmark_save = ENV["EXPRESSIR_BENCHMARK_SAVE"] == "true"
+      # Number of iterations for benchmark-ips
+      @benchmark_iterations = (ENV["EXPRESSIR_BENCHMARK_ITERATIONS"] || "3").to_i
+      # Warmup time for benchmark-ips in seconds
+      @benchmark_warmup = (ENV["EXPRESSIR_BENCHMARK_WARMUP"] || "1").to_i
+      # Enable parallel processing (for future implementation)
+      @benchmark_parallel = ENV["EXPRESSIR_BENCHMARK_PARALLEL"] == "true"
+      # Output format for benchmark results (default, json, csv)
+      @benchmark_format = ENV["EXPRESSIR_BENCHMARK_FORMAT"] || "default"
+    end
+
+    # Helper methods for checking benchmark settings
+    def benchmark_enabled?
+      @benchmark_enabled
     end
-  end
 
-  extend Config
+    def benchmark_ips?
+      @benchmark_enabled && @benchmark_ips
+    end
+
+    def benchmark_verbose?
+      @benchmark_enabled && @benchmark_verbose
+    end
+
+    def benchmark_save?
+      @benchmark_enabled && @benchmark_save
+    end
+
+    def benchmark_parallel?
+      @benchmark_enabled && @benchmark_parallel
+    end
+  end
 end