expressir 2.4.29-arm-linux

data/lib/expressir/cli.rb

@@ -0,0 +1,148 @@
+require "thor"
+require "yaml"
+
+module Expressir
+  class Cli < Thor
+    # Exit with error code on command failures
+    def self.exit_on_failure?
+      true
+    end
+
+    desc "format PATH", "pretty print EXPRESS schema located at PATH"
+    method_option :profile, type: :string,
+                            desc: "Formatting profile: 'iso' (ISO/TC 184/SC 4) or 'elf' (ELF Pretty Print)",
+                            default: "iso"
+    method_option :indent, type: :numeric,
+                           desc: "Indentation width (ELF profile only)",
+                           default: 4
+    method_option :provenance, type: :boolean,
+                               desc: "Include provenance information (ELF profile only)",
+                               default: true
+    def format(path, _thor_options = nil)
+      Expressir::Commands::Format.new(options).run(path)
+    end
+
+    desc "clean PATH", "Strip remarks and prettify EXPRESS schema at PATH"
+    method_option :output, type: :string,
+                           desc: "Output file path (defaults to stdout)"
+    def clean(path, _thor_options = nil)
+      Expressir::Commands::Clean.new(options).run(path)
+    end
+
+    desc "fix PATH",
+         "Rewrite self-schema-qualified references (#125) in the EXPRESS schema at PATH"
+    method_option :output, type: :string,
+                           aliases: "-o",
+                           desc: "Output file path (defaults to stdout)"
+    def fix(path, _thor_options = nil)
+      Expressir::Commands::Fix.new(options).run(path)
+    end
+
+    desc "expand PATH",
+         "Concatenate the interface closure of PATH into one .exp artifact"
+    method_option :output, type: :string,
+                           aliases: "-o",
+                           desc: "Output file path (defaults to stdout)"
+    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 expand(path, _thor_options = nil)
+      Expressir::Commands::Expand.new(options).run(path)
+    end
+
+    desc "flatten PATH",
+         "Flatten the interface closure of PATH into an ISO 10303-11:1994 longform schema"
+    method_option :output, type: :string,
+                           aliases: "-o",
+                           desc: "Output file path (defaults to stdout)"
+    method_option :longform_name, type: :string,
+                                  desc: "Longform SCHEMA id (default: <root>_lf)"
+    method_option :extenders, type: :string,
+                              desc: "Extensible type handling: 'all' (default, fold every " \
+                                    "extender in the closure per Annex G.2.3/G.2.4) or " \
+                                    "'none' (leave extensible types as declared)"
+    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 flatten(path, _thor_options = nil)
+      Expressir::Commands::Flatten.new(options).run(path)
+    end
+
+    desc "benchmark FILE_OR_YAML",
+         "Benchmark schema loading performance for a file or list of files from YAML"
+    method_option :ips, type: :boolean,
+                        desc: "Use benchmark-ips for detailed statistics"
+    method_option :verbose, type: :boolean, desc: "Show verbose output"
+    method_option :save, type: :boolean, desc: "Save benchmark results to file"
+    method_option :format, type: :string,
+                           desc: "Output format (json, csv, default)"
+    def benchmark(path, _thor_options = nil)
+      Expressir::Commands::Benchmark.new(options).run(path)
+    end
+
+    desc "benchmark-cache FILE_OR_YAML", "Benchmark schema loading with caching"
+    method_option :ips, type: :boolean,
+                        desc: "Use benchmark-ips for detailed statistics"
+    method_option :verbose, type: :boolean, desc: "Show verbose output"
+    method_option :save, type: :boolean, desc: "Save benchmark results to file"
+    method_option :format, type: :string,
+                           desc: "Output format (json, csv, default)"
+    method_option :cache_path, type: :string,
+                               desc: "Path to store the cache file"
+    def benchmark_cache(path, _thor_options = nil)
+      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
+
+    desc "coverage *PATH",
+         "List EXPRESS entities and check documentation coverage"
+    method_option :format, type: :string,
+                           desc: "Output format (text, json, yaml)", default: "text"
+    method_option :exclude, type: :string,
+                            desc: "Comma-separated list of EXPRESS entity types to skip from coverage (e.g., TYPE,CONSTANT,TYPE:SELECT)"
+    method_option :output, type: :string,
+                           desc: "Output file path for JSON/YAML formats (defaults to coverage_report.json/yaml)"
+    method_option :ignore_files, type: :string,
+                                 desc: "Path to YAML file containing array of files to ignore from overall coverage calculation"
+    method_option :max_processes, type: :numeric,
+                                  default: Expressir::Express::ParallelFiles::DEFAULT_MAX_PROCESSES,
+                                  desc: "Parallel parse workers (1 = sequential; falls back to sequential where fork is unavailable)"
+    def coverage(*paths)
+      Expressir::Commands::Coverage.new(options).run(paths)
+    end
+
+    desc "changes SUBCOMMAND", "Commands for EXPRESS Changes files"
+    subcommand "changes", Expressir::Commands::Changes
+
+    desc "manifest SUBCOMMAND", "Schema manifest management commands"
+    subcommand "manifest", Expressir::Commands::Manifest
+
+    desc "package SUBCOMMAND", "LER package management commands"
+    subcommand "package", Expressir::Commands::Package
+
+    desc "version", "Expressir Version"
+    def version
+      Expressir::Commands::Version.new(options).run
+    end
+  end
+end

data/lib/expressir/commands/base.rb

@@ -0,0 +1,25 @@
+module Expressir
+  module Commands
+    class Base
+      attr_reader :options
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      # Common utilities that all commands might need
+      def say(message)
+        # Use instance variable for testability - if output is set, use it
+        if defined?(@output) && @output
+          @output.puts(message)
+        else
+          puts(message)
+        end
+      end
+
+      def exit_with_error(message, _exit_code = 1)
+        raise Expressir::CommandError.new(message)
+      end
+    end
+  end
+end

data/lib/expressir/commands/benchmark.rb

@@ -0,0 +1,59 @@
+module Expressir
+  module Commands
+    class Benchmark < Base
+      def run(path)
+        configure_benchmarking
+
+        if [".yml", ".yaml"].include?(File.extname(path).downcase)
+          benchmark_from_manifest(path)
+        else
+          benchmark_file(path)
+        end
+      end
+
+      private
+
+      def configure_benchmarking
+        Expressir.configuration.benchmark_enabled = true
+        Expressir.configuration.benchmark_ips = options[:ips]
+        Expressir.configuration.benchmark_verbose = options[:verbose]
+        Expressir.configuration.benchmark_save = options[:save]
+        Expressir.configuration.benchmark_format = options[:format] if options[:format]
+      end
+
+      def benchmark_file(path)
+        say "Express Schema Loading Benchmark"
+        say "--------------------------------"
+
+        repository = Expressir::Benchmark.measure_file(path) do
+          Expressir::Express::Parser.from_file(path)
+        end
+
+        if repository
+          say "Loaded #{repository.schemas.size} schemas"
+        else
+          say "Failed to load schema"
+        end
+      end
+
+      def benchmark_from_manifest(manifest_path)
+        say "Express Schema Loading Benchmark from Manifest"
+        say "--------------------------------"
+
+        # Load schema manifest
+        manifest = Expressir::SchemaManifest.from_file(manifest_path)
+        schema_files = manifest.schemas.map(&:path)
+
+        say "Manifest File: #{manifest_path}"
+        say "Number of schemas in list: #{schema_files.size}"
+        say "--------------------------------"
+
+        # Load the schemas
+        Expressir::Benchmark.measure_collection(schema_files) do |file|
+          repository = Expressir::Express::Parser.from_file(file)
+          repository.schemas
+        end
+      end
+    end
+  end
+end

data/lib/expressir/commands/benchmark_cache.rb

@@ -0,0 +1,80 @@
+module Expressir
+  module Commands
+    class BenchmarkCache < Base
+      def run(path)
+        configure_benchmarking
+
+        # Run benchmarks with cache
+        cache_path = options[:cache_path] || generate_temp_cache_path
+
+        if [".yml", ".yaml"].include?(File.extname(path).downcase)
+          benchmark_cache_from_manifest(path, cache_path)
+        else
+          benchmark_cache_file(path, cache_path)
+        end
+      end
+
+      private
+
+      def configure_benchmarking
+        Expressir.configuration.benchmark_enabled = true
+        Expressir.configuration.benchmark_ips = options[:ips]
+        Expressir.configuration.benchmark_verbose = options[:verbose]
+        Expressir.configuration.benchmark_save = options[:save]
+        Expressir.configuration.benchmark_format = options[:format] if options[:format]
+      end
+
+      def benchmark_cache_file(path, cache_path)
+        say "Express Schema Loading Benchmark with Caching"
+        say "--------------------------------"
+        say "Schema: #{path}"
+        say "Cache: #{cache_path}"
+        say "--------------------------------"
+
+        # Benchmark with caching
+        results = Expressir::Benchmark.measure_with_cache(path,
+                                                          cache_path) do |file|
+          Expressir::Express::Parser.from_file(file)
+        end
+
+        if results[:repository]
+          schema_count = results[:repository].schemas.size
+          say "Loaded #{schema_count} schemas"
+        else
+          say "Failed to load schema"
+        end
+      end
+
+      def benchmark_cache_from_manifest(manifest_path, cache_path)
+        say "Express Schema Loading Benchmark with Caching from Manifest"
+        say "--------------------------------"
+
+        # Load schema manifest
+        manifest = Expressir::SchemaManifest.from_file(manifest_path)
+        schema_files = manifest.schemas.map(&:path)
+
+        say "Manifest File: #{manifest_path}"
+        say "Number of schemas in list: #{schema_files.size}"
+        say "Cache: #{cache_path}"
+        say "--------------------------------"
+
+        # Process each file with caching
+        schema_files.each_with_index do |file, index|
+          say "Processing file #{index + 1}/#{schema_files.size}: #{file}"
+
+          # Benchmark with caching
+          Expressir::Benchmark.measure_with_cache(file, cache_path) do |path|
+            Expressir::Express::Parser.from_file(path)
+          end
+
+          say "--------------------------------"
+        end
+      end
+
+      def generate_temp_cache_path
+        require "tempfile"
+        Tempfile.new(["expressir_cache", ".bin"]).path
+      end
+    end
+  end
+end

data/lib/expressir/commands/changes.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Expressir
+  module Commands
+    # Thor subcommand for EXPRESS Changes file operations
+    class Changes < Thor
+      desc "validate PATH", "Validate EXPRESS Changes YAML file"
+      method_option :normalize, type: :boolean,
+                                desc: "Normalize file through round-trip serialization"
+      method_option :in_place, type: :boolean,
+                               desc: "Update file in place (requires --normalize)"
+      method_option :output, type: :string,
+                             desc: "Output file path (for normalized output)"
+      method_option :verbose, type: :boolean,
+                              desc: "Show verbose output"
+      def validate(path)
+        ChangesValidate.new(options).run(path)
+      end
+
+      desc "import-eengine INPUT_XML SCHEMA_NAME VERSION",
+           "Import eengine comparison XML to EXPRESS Changes YAML"
+      method_option :output, type: :string, aliases: "-o",
+                             desc: "Output YAML file path (stdout if not specified)"
+      method_option :verbose, type: :boolean,
+                              desc: "Show verbose output"
+      def import_eengine(input_xml, schema_name, version)
+        ChangesImportEengine.call(input_xml, options[:output], schema_name,
+                                  version, **options)
+      end
+    end
+  end
+end

data/lib/expressir/commands/changes_import_eengine.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Commands
+    # Command to import eengine comparison XML to EXPRESS Changes YAML
+    class ChangesImportEengine < Base
+      # Parse XML string and convert to SchemaChange
+      #
+      # @param xml_content [String] Eengine XML content
+      # @param schema_name [String] Schema name
+      # @param version [String] Version identifier
+      # @param options [Hash] Additional options
+      # @return [Expressir::Changes::SchemaChange]
+      def self.from_xml(xml_content, schema_name, version, **)
+        # Parse into CompareReport using Lutaml::Model
+        compare_report = Expressir::Eengine::CompareReport.from_xml(xml_content)
+
+        # Convert to SchemaChange
+        convert_to_schema_change(compare_report, schema_name, version,
+                                 xml_content: xml_content, **)
+      end
+
+      # File-based workflow (backward compatible)
+      def self.call(input_file, output_file, schema_name, version, **options)
+        xml_content = File.read(input_file)
+
+        # Load existing schema if output file exists
+        existing_schema = if output_file && File.exist?(output_file) && File.size(output_file).positive?
+                            Expressir::Changes::SchemaChange.from_file(output_file)
+                          end
+
+        change_schema = from_xml(xml_content, schema_name, version,
+                                 existing_schema: existing_schema, **options)
+
+        if output_file
+          change_schema.to_file(output_file)
+          puts "Change YAML file written to: #{output_file}" if options[:verbose]
+        else
+          puts change_schema.to_yaml
+        end
+
+        change_schema
+      end
+
+      class << self
+        private
+
+        def convert_to_schema_change(compare_report, schema_name, version,
+**options)
+          # Extract changes from CompareReport
+          changes = {
+            additions: extract_items(compare_report.additions,
+                                     options[:xml_content]),
+            modifications: extract_items(compare_report.modifications,
+                                         options[:xml_content]),
+            deletions: extract_items(compare_report.deletions,
+                                     options[:xml_content]),
+          }
+
+          # Use existing schema or create new one
+          change_schema = options[:existing_schema] ||
+            Expressir::Changes::SchemaChange.new(schema: schema_name)
+
+          # No version-level description from eengine (only item-level)
+          change_schema.add_or_update_version(version, nil, changes)
+
+          change_schema
+        end
+
+        def extract_items(changes_section, xml_content)
+          return [] unless changes_section&.modified_objects
+
+          # Extract descriptions from XML as arrays
+          descriptions = extract_descriptions_from_xml(xml_content)
+
+          changes_section.modified_objects.map do |obj|
+            Expressir::Changes::ItemChange.new(
+              type: obj.type,
+              name: obj.name,
+              interfaced_items: obj.interfaced_items,
+              description: descriptions[obj.name],
+            )
+          end
+        end
+
+        def extract_descriptions_from_xml(xml_content)
+          return {} unless xml_content
+
+          require "nokogiri"
+          doc = Nokogiri::XML(xml_content)
+
+          doc.xpath("//modified.object").each_with_object({}) do |node, result|
+            name = node["name"]
+            desc_node = node.at_xpath("description")
+            next unless desc_node
+
+            html = desc_node.inner_html.strip
+            next if html.empty?
+
+            # Extract <li> elements or use text content
+            li_elements = Nokogiri::HTML.fragment(html).css("li")
+            result[name] = if li_elements.any?
+                             li_elements.map do |li|
+                               li.text.strip
+                             end.reject(&:empty?)
+                           else
+                             [Nokogiri::HTML.fragment(html).text.strip]
+                           end
+          end
+        end
+
+        def normalize_description(description)
+          # Handle both String and Array (when XML has nested elements)
+          case description
+          when String
+            description
+          when Array
+            # Join array elements, handling nested structures
+            description.map { |elem| normalize_description(elem) }.join("\n")
+          when Hash
+            # Handle hash elements (from XML parsing)
+            if description.key?("__text__")
+              description["__text__"]
+            else
+              description.values.map { |v| normalize_description(v) }.join("\n")
+            end
+          else
+            description.to_s
+          end
+        end
+
+        def convert_html_to_asciidoc(text)
+          # Convert <ul><li>...</li></ul> to AsciiDoc list format
+          text = text.gsub(%r{<ul>\s*}i, "")
+          text = text.gsub(%r{\s*</ul>}i, "")
+          text = text.gsub(%r{<li>(.*?)</li>}im) do
+            "* #{Regexp.last_match(1).strip}"
+          end
+
+          # Clean up any extra whitespace
+          text.strip
+        end
+      end
+    end
+  end
+end

data/lib/expressir/commands/changes_validate.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Commands
+    # Command to validate and normalize EXPRESS Changes YAML files
+    class ChangesValidate < Base
+      def run(path)
+        # Check if file exists
+        unless File.exist?(path)
+          exit_with_error("File not found: #{path}")
+        end
+
+        # Validate --in-place requires --normalize
+        if options[:in_place] && !options[:normalize]
+          exit_with_error("--in-place requires --normalize flag")
+        end
+
+        # Validate --in-place and --output are mutually exclusive
+        if options[:in_place] && options[:output]
+          exit_with_error("Cannot use both --in-place and --output")
+        end
+
+        begin
+          # Load and validate the file
+          say "Validating #{path}..." if options[:verbose]
+          schema_change = Expressir::Changes::SchemaChange.from_file(path)
+
+          say "✓ File is valid" if options[:verbose]
+          say "  Schema: #{schema_change.schema}" if options[:verbose]
+          say "  Versions: #{schema_change.versions.length}" if options[:verbose]
+
+          # Normalize if requested
+          if options[:normalize]
+            say "Normalizing through round-trip serialization..." if options[:verbose]
+
+            output_path = if options[:in_place]
+                            path
+                          elsif options[:output]
+                            options[:output]
+                          else
+                            # Output to stdout
+                            nil
+                          end
+
+            if output_path
+              schema_change.to_file(output_path)
+              say "✓ Normalized file written to: #{output_path}"
+            else
+              # Output to stdout
+              puts schema_change.to_yaml
+            end
+          else
+            say "✓ File is valid"
+          end
+        rescue Psych::SyntaxError => e
+          exit_with_error("Invalid YAML syntax: #{e.message}")
+        rescue StandardError => e
+          exit_with_error("Validation failed: #{e.message}")
+        end
+      end
+    end
+  end
+end

data/lib/expressir/commands/check.rb

@@ -0,0 +1,56 @@
+require "json"
+
+module Expressir
+  module Commands
+    # `validate check` — semantic checks modeled on eeng check-p11 note
+    # subset (expressir#282). Exits 1 when any :error notes are emitted.
+    # Loads the interface closure of each input file so USE FROM targets
+    # are visible — matches Concatenator/Shtolo expectations.
+    class Check < Base
+      def run(*paths)
+        files = Array(paths).flat_map do |p|
+          if File.directory?(p)
+            Dir["#{p}/**/*.exp"]
+          else
+            ParityInputs.closure_paths(
+              p, manifest: options[:manifest], stepmod: options[:stepmod]
+            ).select { |f| File.exist?(f) }
+          end
+        end.uniq
+        repository = Expressir::Express::Parser.from_files(files)
+        # A file that failed to parse is a nil entry: it must fail the run,
+        # not pass silently as a "clean" schema (#413).
+        failed = repository.files.count(&:nil?)
+        if failed.positive?
+          raise Thor::Error, "#{failed} file(s) failed to parse"
+        end
+
+        result = Expressir::Express::Checker.new(repository).check
+
+        if options[:json]
+          say JSON.generate(
+            valid: result.valid?,
+            errors: serialize(result.errors),
+            warnings: serialize(result.warnings),
+          )
+        else
+          result.notes.each { |n| say "[#{n.severity}] #{n.id}: #{n.message}" }
+          say "#{result.errors.size} error(s), #{result.warnings.size} warning(s)"
+        end
+
+        return if result.valid?
+
+        raise Thor::Error, "schema check produced #{result.errors.size} error(s)"
+      end
+
+      private
+
+      def serialize(notes)
+        notes.map do |n|
+          { id: n.id.to_s, severity: n.severity.to_s, schema: n.schema,
+            message: n.message }
+        end
+      end
+    end
+  end
+end

data/lib/expressir/commands/clean.rb

@@ -0,0 +1,20 @@
+module Expressir
+  module Commands
+    class Clean < Base
+      def run(path)
+        repository = Expressir::Express::Parser.from_file(path)
+        formatted_schemas = repository.schemas.map do |schema|
+          # Format schema without remarks
+          schema.format(no_remarks: true)
+        end.join("\n\n")
+
+        if options[:output]
+          File.write(options[:output], formatted_schemas)
+          say "Cleaned schema written to #{options[:output]}"
+        else
+          say formatted_schemas
+        end
+      end
+    end
+  end
+end