expressir 2.4.29-arm-linux

data/exe/expressir-format-test

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+require "yaml"
+require "tempfile"
+require_relative "../lib/expressir/express/parser"
+require_relative "../lib/expressir/express/formatter"
+require_relative "../lib/expressir/express/schema_head_formatter"
+require_relative "../lib/expressir/express/hyperlink_formatter"
+require_relative "../lib/expressir/express/cache"
+
+exp_files = [
+  # basic test
+  # '../iso-10303-stepmod/data/resources/action_schema/action_schema_annotated.exp',
+  # '../iso-10303-stepmod/data/resources/basic_attribute_schema/basic_attribute_schema_annotated.exp',
+  # '../iso-10303-stepmod/data/resources/support_resource_schema/support_resource_schema_annotated.exp',
+  # cyclic reference test
+  # '../iso-10303-stepmod/data/modules/analysis/mim_annotated.exp',
+  # '../iso-10303-stepmod/data/modules/analysis_product_relationships/mim_annotated.exp',
+  # cyclic reference test 2
+  # '../iso-10303-stepmod/data/resources/product_property_definition_schema/product_property_definition_schema_annotated.exp',
+  # '../iso-10303-stepmod/data/resources/product_property_representation_schema/product_property_representation_schema_annotated.exp',
+  # renamed reference test (36s)
+  # '../iso-10303-stepmod/ballots/ballots/ap210_wg12/express/resources/mathematical_functions_schema.exp',
+  # '../iso-10303-stepmod/data/resources/iso13584_expressions_schema/iso13584_expressions_schema.exp',
+  # annotated-express test (12s)
+  # see https://github.com/metanorma/annotated-express/blob/master/data/documents/resources/fundamentals_of_product_description_and_support/sections/04-schemas.adoc
+  "../iso-10303-stepmod/data/resources/action_schema/action_schema_annotated.exp",
+  "../iso-10303-stepmod/data/resources/application_context_schema/application_context_schema_annotated.exp",
+  "../iso-10303-stepmod/data/resources/approval_schema/approval_schema_annotated.exp",
+  "../iso-10303-stepmod/data/resources/basic_attribute_schema/basic_attribute_schema_annotated.exp",
+  "../iso-10303-stepmod/data/resources/certification_schema/certification_schema_annotated.exp",
+  "../iso-10303-stepmod/data/resources/contract_schema/contract_schema_annotated.exp",
+  "../iso-10303-stepmod/data/resources/date_time_schema/date_time_schema_annotated.exp",
+  "../iso-10303-stepmod/data/resources/document_schema/document_schema.exp",
+  "../iso-10303-stepmod/data/resources/effectivity_schema/effectivity_schema_annotated.exp",
+  "../iso-10303-stepmod/data/resources/experience_schema/experience_schema_annotated.exp",
+  "../iso-10303-stepmod/data/resources/external_reference_schema/external_reference_schema_annotated.exp",
+  "../iso-10303-stepmod/data/resources/group_schema/group_schema_annotated.exp",
+  "../iso-10303-stepmod/data/resources/language_schema/language_schema_annotated.exp",
+  "../iso-10303-stepmod/data/resources/location_schema/location_schema_annotated.exp",
+  "../iso-10303-stepmod/data/resources/management_resources_schema/management_resources_schema_annotated.exp",
+  "../iso-10303-stepmod/data/resources/measure_schema/measure_schema_annotated.exp",
+  "../iso-10303-stepmod/data/resources/person_organization_schema/person_organization_schema_annotated.exp",
+  "../iso-10303-stepmod/data/resources/process_property_schema/process_property_schema_annotated.exp",
+  "../iso-10303-stepmod/data/resources/product_definition_schema/product_definition_schema_annotated.exp",
+  "../iso-10303-stepmod/data/resources/product_property_definition_schema/product_property_definition_schema_annotated.exp",
+  "../iso-10303-stepmod/data/resources/product_property_representation_schema/product_property_representation_schema_annotated.exp",
+  "../iso-10303-stepmod/data/resources/qualifications_schema/qualifications_schema_annotated.exp",
+  "../iso-10303-stepmod/data/resources/security_classification_schema/security_classification_schema_annotated.exp",
+  "../iso-10303-stepmod/data/resources/support_resource_schema/support_resource_schema_annotated.exp",
+  # full test (6m18s + 8s = 6m26s)
+  # *`bundle exec ../stepmod-utils/exe/stepmod-find-express-files ../iso-10303-stepmod`.strip
+  #   .split("\n").map{|file| File.exists?(file.sub(/\.exp$/, '_annotated.exp')) ? file.sub(/\.exp$/, '_annotated.exp') : file}
+]
+
+start = Time.now
+repository = Expressir::Express::Parser.from_files(exp_files)
+puts "Parser.from_files time:  #{(Time.now - start).round(2)}s"
+
+temp_file = Tempfile.new
+begin
+  start = Time.now
+  Expressir::Express::Cache.to_file(temp_file, repository)
+  puts "Cache.to_file time:      #{(Time.now - start).round(2)}s"
+
+  start = Time.now
+  repository = Expressir::Express::Cache.from_file(temp_file)
+  puts "Cache.from_file time:    #{(Time.now - start).round(2)}s"
+ensure
+  temp_file.close
+  temp_file.unlink
+end
+
+start = Time.now
+formatter = Class.new(Expressir::Express::Formatter) do
+  include Expressir::Express::SchemaHeadFormatter
+  include Expressir::Express::HyperlinkFormatter
+end
+repository.to_hash(formatter: formatter)
+puts "Repository.to_hash time: #{(Time.now - start).round(2)}s"
+
+# puts YAML.dump(result)

data/expressir.gemspec

@@ -0,0 +1,61 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "expressir/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "expressir"
+  spec.version = Expressir::Version::VERSION
+  spec.authors = ["Ribose Inc."]
+  spec.email = ["open.source@ribose.com"]
+
+  spec.summary = "EXPRESS parser and toolkit for Ruby"
+  spec.description = 'Expressir ("EXPRESS in Ruby") is a Ruby parser for EXPRESS and a set of tools for accessing EXPRESS data models.'
+
+  spec.homepage = "https://github.com/lutaml/expressir"
+  spec.license = "BSD-2-Clause"
+
+  spec.bindir = "exe"
+  spec.executables   = %w[expressir]
+  spec.require_paths = ["lib"]
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "https://github.com/lutaml/expressir/releases"
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.2.0")
+  # Source gem builds on the ruby platform; declaring it keeps
+  # rake-compiler's `gem` task from rebuilding the extension for the
+  # host ruby during cross builds (rb-sys then sees a windows
+  # CARGO_BUILD_TARGET with linux headers and refuses).
+  spec.platform = Gem::Platform::RUBY
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{^(test|spec|features)/})
+    end
+  end
+
+  # Build the Rust core extension at install time. extconf.rb fails
+  # soft (dummy Makefile) wherever cargo is unavailable, so installs
+  # without a Rust toolchain fall back to the pure-Ruby parser.
+  spec.extensions = ["ext/expressir_core/extconf.rb"]
+  spec.add_dependency "rb_sys", "~> 0.9.130"
+
+  spec.add_dependency "base64"
+  spec.add_dependency "benchmark"
+  spec.add_dependency "benchmark-ips"
+  spec.add_dependency "csv"
+  spec.add_dependency "liquid"
+  spec.add_dependency "lutaml-model", "~> 0.8.76"
+  spec.add_dependency "moxml"
+  spec.add_dependency "nokogiri"
+  spec.add_dependency "paint"
+  spec.add_dependency "parsanol", "~> 1.3.9", ">= 1.3.9"
+  spec.add_dependency "ruby-progressbar", "~> 1.11"
+  spec.add_dependency "rubyzip"
+  spec.add_dependency "table_tennis"
+  spec.add_dependency "thor", "~> 1.0"
+  # Native YAML/JSON engine (lutaml-model opt-in by bundle contents)
+  spec.add_dependency "yeptris", "~> 0.6.1"
+end

data/lib/expressir/benchmark.rb

@@ -0,0 +1,310 @@
+module Expressir
+  module Benchmark
+    require "benchmark"
+    require "json"
+    require "csv"
+
+    class << self
+      # Measures the execution time of schema loading and optionally reports it
+      # @param file [String] File being processed
+      # @param options [Hash] Options for benchmarking
+      # @return The result of the block
+      def measure_file(file)
+        return yield unless Expressir.configuration.benchmark_enabled?
+
+        if Expressir.configuration.benchmark_ips?
+          require "benchmark/ips"
+
+          result = nil
+          ::Benchmark.ips do |x|
+            x.config(time: Expressir.configuration.benchmark_iterations,
+                     warmup: Expressir.configuration.benchmark_warmup)
+
+            x.report("Loading #{file}") do
+              result = yield
+            end
+
+            if Expressir.configuration.benchmark_save?
+              x.save! "expressir_benchmark_#{File.basename(file)}"
+            end
+          end
+
+          # Calculate objects per second
+          if result.is_a?(Model::Repository)
+            objects_per_second = calculate_objects_per_second(result)
+            puts "Objects per second: #{objects_per_second}" if Expressir.configuration.benchmark_verbose?
+          end
+
+        else
+          # Standard benchmarking
+          result = nil
+          time = ::Benchmark.measure do
+            result = yield
+          end
+
+          if result.is_a?(Model::Repository)
+            objects_per_second = calculate_objects_per_second(result, time.real)
+            output_benchmark_result(file, time.real, objects_per_second)
+          else
+            output_benchmark_result(file, time.real)
+          end
+
+        end
+        result
+      end
+
+      # Benchmarks file collection processing
+      # @param files [Array<String>] List of files to process
+      # @return [Array] Results from processing files
+      def measure_collection(files)
+        unless Expressir.configuration.benchmark_enabled?
+          # Process each file individually even when benchmarking is disabled
+          results = []
+          files.each do |file|
+            file_results = yield(file)
+            results.concat(Array(file_results))
+          end
+          return results
+        end
+
+        results = []
+        total_time = ::Benchmark.measure do
+          files.each_with_index do |file, i|
+            if Expressir.configuration.benchmark_verbose?
+              puts "#{i + 1}/#{files.length} Processing #{file}"
+            end
+
+            file_results = measure_file(file) do
+              yield(file)
+            end
+
+            results.concat(Array(file_results))
+          end
+        end
+
+        output_collection_result(files.length, total_time.real, results)
+        results
+      end
+
+      # Measures reference resolution
+      # @return The result of the block
+      def measure_references
+        return yield unless Expressir.configuration.benchmark_enabled?
+
+        if Expressir.configuration.benchmark_ips?
+          require "benchmark/ips"
+
+          result = nil
+          ::Benchmark.ips do |x|
+            x.config(time: Expressir.configuration.benchmark_iterations,
+                     warmup: Expressir.configuration.benchmark_warmup)
+
+            x.report("Reference resolution") do
+              result = yield
+            end
+          end
+
+        else
+          result = nil
+          time = ::Benchmark.measure do
+            result = yield
+          end
+
+          output_benchmark_result("Reference resolution", time.real)
+        end
+        result
+      end
+
+      # Benchmark with caching
+      # @param path [String] Path to the file
+      # @param cache_path [String] Path for the cache file
+      # @return [Hash] Results with timing information
+      def measure_with_cache(path, cache_path = nil)
+        return yield(path) unless Expressir.configuration.benchmark_enabled?
+
+        require "tempfile"
+        temp_file = nil
+
+        unless cache_path
+          temp_file = Tempfile.new(["expressir_cache", ".bin"])
+          cache_path = temp_file.path
+        end
+
+        results = {}
+
+        # Measure parsing time
+        parsing_time = ::Benchmark.measure do
+          results[:repository] = yield(path)
+        end
+        results[:parsing_time] = parsing_time.real
+
+        # Measure cache writing time
+        cache_write_time = ::Benchmark.measure do
+          Expressir::Express::Cache.to_file(cache_path, results[:repository])
+        end
+        results[:cache_write_time] = cache_write_time.real
+
+        # Measure cache reading time
+        cache_read_time = ::Benchmark.measure do
+          results[:cached_repository] =
+            Expressir::Express::Cache.from_file(cache_path)
+        end
+        results[:cache_read_time] = cache_read_time.real
+
+        # Output results
+        if Expressir.configuration.benchmark_verbose?
+          puts "Parsing time:      #{results[:parsing_time].round(4)}s"
+          puts "Cache write time:  #{results[:cache_write_time].round(4)}s"
+          puts "Cache read time:   #{results[:cache_read_time].round(4)}s"
+
+          if results[:repository].is_a?(Model::Repository)
+            objects = count_objects(results[:repository])
+            puts "Total objects:     #{objects}"
+            puts "Objects per second (parsing): #{(objects / results[:parsing_time]).round(2)}"
+            puts "Objects per second (reading): #{(objects / results[:cache_read_time]).round(2)}"
+          end
+        end
+
+        # Clean up temp file if we created one
+        if temp_file
+          temp_file.close
+          temp_file.unlink
+        end
+
+        results
+      end
+
+      private
+
+      # Calculate objects per second
+      # @param repository [Object] The repository object
+      # @param time [Float] The time taken in seconds
+      # @return [Float] Objects per second
+      def calculate_objects_per_second(repository, time = 1.0)
+        objects = count_objects(repository)
+        (objects / time).round(2)
+      end
+
+      # Count objects in a repository
+      # @param repository [Object] The repository object
+      # @return [Integer] Number of objects
+      def count_objects(repository)
+        return 0 unless repository.is_a?(Model::Repository)
+
+        count = repository.schemas.size
+
+        repository.schemas.each do |schema|
+          count += schema.entities.size if schema.entities
+          count += schema.types.size if schema.types
+          count += schema.functions.size if schema.functions
+          count += schema.rules.size if schema.rules
+          count += schema.procedures.size if schema.procedures
+          count += schema.constants.size if schema.constants
+
+          # Count attributes in entities
+          schema.entities&.each do |entity|
+            # Count explicit attributes
+            if entity.attributes
+              count += entity.attributes.size
+            end
+
+            # Count inheritance relationships
+            count += 1 if entity.subtype_of
+          end
+        end
+
+        count
+      end
+
+      # Output benchmark result in the appropriate format
+      # @param label [String] Label for the benchmark
+      # @param time [Float] Time in seconds
+      # @param objects_per_second [Float, nil] Objects per second metric (optional)
+      def output_benchmark_result(label, time, objects_per_second = nil)
+        time_rounded = time.round(4)
+
+        case Expressir.configuration.benchmark_format
+        when "json"
+          result = {
+            label: label,
+            time_seconds: time_rounded,
+          }
+          result[:objects_per_second] = objects_per_second if objects_per_second
+          puts JSON.generate(result)
+        when "csv"
+          headers = ["Label", "Time (s)"]
+          headers << "Objects/s" if objects_per_second
+
+          values = [label, time_rounded]
+          values << objects_per_second if objects_per_second
+
+          puts headers.join(",")
+          puts values.join(",")
+        else
+          # Default format
+          message = "#{label}: #{time_rounded}s"
+          message += " (#{objects_per_second} objects/s)" if objects_per_second
+          puts message if Expressir.configuration.benchmark_verbose?
+        end
+      end
+
+      # Output collection benchmark result
+      # @param count [Integer] Number of files processed
+      # @param total_time [Float] Total time in seconds
+      # @param results [Array] Array of results
+      def output_collection_result(count, total_time, results)
+        avg_time = total_time / count
+
+        # Get total object count if possible
+        total_objects = 0
+        schema_count = 0
+
+        # Try to count total objects and schemas
+        results.each do |result|
+          if result.is_a?(Model::Repository)
+            schema_count += result.schemas.size
+            total_objects += count_objects(result)
+          elsif result.is_a?(Array)
+            result.each do |r|
+              if r.is_a?(Model::Declarations::Schema)
+                schema_count += 1
+                total_objects += 1 # Count the schema itself
+              end
+            end
+          end
+        end
+
+        objects_per_second = (total_objects / total_time).round(2)
+
+        case Expressir.configuration.benchmark_format
+        when "json"
+          result = {
+            files_processed: count,
+            schemas_loaded: schema_count,
+            total_objects: total_objects,
+            total_time_seconds: total_time.round(4),
+            average_time_seconds: avg_time.round(4),
+            objects_per_second: objects_per_second,
+          }
+          puts JSON.generate(result)
+        when "csv"
+          headers = ["Files", "Schemas", "Objects", "Total Time (s)",
+                     "Avg Time (s)", "Objects/s"]
+          values = [count, schema_count, total_objects, total_time.round(4),
+                    avg_time.round(4), objects_per_second]
+
+          puts headers.join(",")
+          puts values.join(",")
+        else
+          # Default format
+          if Expressir.configuration.benchmark_verbose?
+            puts "\nProcessed #{count} files in #{total_time.round(4)}s"
+            puts "Loaded #{schema_count} schemas containing #{total_objects} objects"
+            puts "Average time per file: #{avg_time.round(4)}s"
+            puts "Performance: #{objects_per_second} objects/s"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/expressir/changes/item_change.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Changes
+    # Represents a single change to an EXPRESS construct
+    class ItemChange < Lutaml::Model::Serializable
+      attribute :type, :string
+      attribute :name, :string
+      attribute :description, :string, collection: true
+      attribute :interfaced_items, :string
+
+      yaml do
+        map "type", to: :type
+        map "name", to: :name
+        map "description", to: :description
+        map "interfaced_items", to: :interfaced_items
+      end
+    end
+  end
+end

data/lib/expressir/changes/mapping_change.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Changes
+    # Represents a mapping change entry
+    class MappingChange < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :description, :string
+
+      yaml do
+        map "name", to: :name
+        map "description", to: :description
+      end
+    end
+  end
+end

data/lib/expressir/changes/schema_change.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Changes
+    # Represents changes to an EXPRESS schema across multiple versions
+    class SchemaChange < Lutaml::Model::Serializable
+      attribute :schema, :string
+      attribute :versions, VersionChange, collection: true
+
+      yaml do
+        map "schema", to: :schema
+        map "versions", to: :versions
+      end
+
+      class << self
+        # Load a SchemaChange from a YAML file
+        #
+        # @param path [String] Path to the YAML file
+        # @return [SchemaChange] The loaded schema changes
+        def from_file(path)
+          content = File.read(path)
+          # Handle empty or minimal YAML files
+          # Skip leading comments and empty lines
+          lines = content.lines
+          yaml_start_index = lines.find_index do |line|
+            !line.strip.start_with?("#") && !line.strip.empty?
+          end
+
+          if yaml_start_index
+            content = lines[yaml_start_index..].join
+          end
+
+          return new if content.strip == "---" || content.strip.empty?
+
+          from_yaml(content)
+        end
+      end
+
+      # Add or update a change version in this schema
+      #
+      # @param version [String] Version number
+      # @param description [String] Description of changes
+      # @param changes [Hash] Hash with :additions, :modifications, :deletions
+      # @return [VersionChange] The added or updated version
+      def add_or_update_version(version, description, changes)
+        # Initialize versions array if nil
+        self.versions ||= []
+
+        # Find existing version with this version
+        existing_index = versions.find_index do |ed|
+          ed.version == version
+        end
+
+        # Create new version
+        version = VersionChange.new(
+          version: version,
+          description: description,
+          additions: changes[:additions] || [],
+          modifications: changes[:modifications] || [],
+          deletions: changes[:deletions] || [],
+        )
+
+        if existing_index
+          # Replace existing version with same version
+          versions[existing_index] = version
+        else
+          # Add new version
+          versions << version
+        end
+
+        version
+      end
+
+      # Save this SchemaChange to a YAML file
+      #
+      # @param path [String] Path where to save the file
+      # @return [Integer] Number of bytes written
+      def to_file(path)
+        # Add schema hint for editor support
+        content = "# yaml-language-server: $schema=https://www.expresslang.org/schemas/changes/v1/schema_changes.yaml\n#{to_yaml}"
+        File.write(path, content)
+      end
+    end
+  end
+end

data/lib/expressir/changes/version_change.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Changes
+    # Represents a version version of schema changes
+    class VersionChange < Lutaml::Model::Serializable
+      attribute :version, :integer
+      attribute :description, :string
+      attribute :additions, ItemChange, collection: true
+      attribute :modifications, ItemChange, collection: true
+      attribute :deletions, ItemChange, collection: true
+      attribute :mappings, MappingChange, collection: true
+      attribute :changes, MappingChange, collection: true
+
+      yaml do
+        map "version", to: :version
+        map "description", to: :description
+        map "additions", to: :additions
+        map "modifications", to: :modifications
+        map "deletions", to: :deletions
+        map "mappings", to: :mappings
+        map "changes", to: :changes
+      end
+    end
+  end
+end

data/lib/expressir/changes.rb

@@ -0,0 +1,9 @@
+# lib/expressir/changes.rb
+module Expressir
+  module Changes
+    autoload :SchemaChange, "#{__dir__}/changes/schema_change"
+    autoload :VersionChange, "#{__dir__}/changes/version_change"
+    autoload :ItemChange, "#{__dir__}/changes/item_change"
+    autoload :MappingChange, "#{__dir__}/changes/mapping_change"
+  end
+end