expressir 2.1.19 → 2.1.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b68644d000b4b7d47a7e132922afa9b4e9f1d3fb19ba6c3b9e2a8db28c5fd33
-  data.tar.gz: 132ecfd9ca85168335536626fea46c3648757ccd973823242b04b0744869376c
+  metadata.gz: 5523a9cdb1e5b8168a0d2d7262cdd8a5e849b066a3eeaaad90a3bcb3a640fe38
+  data.tar.gz: 293acbebeecc50a22ba8bc56aa8413f7e156dac17fa4fa872380aff5a9bf320c
 SHA512:
-  metadata.gz: 895f018faf2bbdd075991d45fa22061459b918f907e568e4481a98dd2e0eb96a312cb98d96e2e7de381c7c85841d05631119f7c26e1773ac634377cdac8e6fe2
-  data.tar.gz: 025421a41b6463548b8ac099fe8b5bc94eb21ee58339f77a6ff028c59ebdb1ac27c5f24ea46050d1fa5b84ee5e80802efcb45b0a549bc733ea833f43c48e0e14
+  metadata.gz: b756fab7be254dc71ab78ce9ffdb220c727cc1ef8599c2e293ee2edb35d8fb7f2ab9e127683e7621d5a0ac2df4379efa5ff1c2aeaa8dd7623b94b18d5e778d7e
+  data.tar.gz: cb767afb4bef0a7555b9519a29b1cefa14ba3c96278d5154e2c2b5af29e813ba0824ffb7efbfd2e601f2e606f0a5800595b8a97b7998a83dd80c4d99448e7546

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2025-06-04 17:31:42 UTC using RuboCop version 1.75.2.
+# on 2025-06-07 05:08:55 UTC using RuboCop version 1.75.2.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -21,11 +21,31 @@ Layout/LineLength:
   Exclude:
     - 'lib/expressir/express/parser.rb'
 
+# Offense count: 1
+# Configuration parameters: IgnoreLiteralBranches, IgnoreConstantBranches, IgnoreDuplicateElseBranch.
+Lint/DuplicateBranch:
+  Exclude:
+    - 'lib/expressir/coverage.rb'
+
+# Offense count: 1
+# This cop supports safe autocorrection (--autocorrect).
+Lint/ScriptPermission:
+  Exclude:
+    - 'update_yaml_fixtures.rb'
+
 # Offense count: 3
 Lint/ShadowingOuterLocalVariable:
   Exclude:
     - 'lib/expressir/express/visitor.rb'
 
+# Offense count: 2
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: AutoCorrect, IgnoreEmptyBlocks, AllowUnusedKeywordArguments.
+Lint/UnusedBlockArgument:
+  Exclude:
+    - 'lib/expressir/express/visitor.rb'
+    - 'spec/support/yaml_matchers.rb'
+
 # Offense count: 2
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: AutoCorrect, AllowUnusedKeywordArguments, IgnoreEmptyMethods, IgnoreNotImplementedMethods, NotImplementedExceptions.
@@ -35,7 +55,7 @@ Lint/UnusedMethodArgument:
     - 'lib/expressir/express/cache.rb'
     - 'lib/expressir/express/parser.rb'
 
-# Offense count: 71
+# Offense count: 76
 # Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes, Max.
 Metrics/AbcSize:
   Exclude:
@@ -54,13 +74,13 @@ Metrics/AbcSize:
     - 'lib/expressir/model/declarations/schema.rb'
     - 'lib/expressir/model/model_element.rb'
 
-# Offense count: 1
+# Offense count: 2
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 # AllowedMethods: refine
 Metrics/BlockLength:
   Max: 143
 
-# Offense count: 51
+# Offense count: 56
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/CyclomaticComplexity:
   Exclude:
@@ -75,12 +95,12 @@ Metrics/CyclomaticComplexity:
     - 'lib/expressir/model/model_element.rb'
     - 'spec/support/model_element_helper.rb'
 
-# Offense count: 94
+# Offense count: 100
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 Metrics/MethodLength:
-  Max: 50
+  Max: 82
 
-# Offense count: 39
+# Offense count: 44
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/PerceivedComplexity:
   Exclude:
@@ -92,6 +112,17 @@ Metrics/PerceivedComplexity:
     - 'lib/expressir/model/declarations/schema.rb'
     - 'lib/expressir/model/model_element.rb'
 
+# Offense count: 1
+# Configuration parameters: NamePrefix, ForbiddenPrefixes, AllowedMethods, MethodDefinitionMacros, UseSorbetSigs.
+# NamePrefix: is_, has_, have_, does_
+# ForbiddenPrefixes: is_, has_, have_, does_
+# AllowedMethods: is_a?
+# MethodDefinitionMacros: define_method, define_singleton_method
+Naming/PredicateName:
+  Exclude:
+    - 'spec/**/*'
+    - 'lib/expressir/coverage.rb'
+
 # Offense count: 5
 Performance/FixedSize:
   Exclude:
@@ -101,3 +132,9 @@ Performance/FixedSize:
 Style/MissingRespondToMissing:
   Exclude:
     - 'lib/expressir/express/visitor.rb'
+
+# Offense count: 2
+# This cop supports unsafe autocorrection (--autocorrect-all).
+Style/SlicingWithRange:
+  Exclude:
+    - 'lib/expressir/express/visitor.rb'

data/README.adoc

@@ -286,25 +286,190 @@ such as TYPE entities whose descriptions are generated by template strings.
 # Exclude TYPE entities from coverage analysis
 expressir coverage --exclude=TYPE schemas/resources/action_schema/action_schema.exp
 
+# Exclude only SELECT type definitions (useful since TYPE descriptions are often template-generated)
+expressir coverage --exclude=TYPE:SELECT schemas/resources/action_schema/action_schema.exp
+
 # Exclude multiple entity types
 expressir coverage --exclude=TYPE,CONSTANT,FUNCTION schemas/resources/action_schema/action_schema.exp
 
+# Exclude parameters and variables (often don't require individual documentation)
+expressir coverage --exclude=PARAMETER,VARIABLE schemas/resources/action_schema/action_schema.exp
+
 # Combine with output format options
-expressir coverage --exclude=TYPE --format=json schemas/resources/action_schema/action_schema.exp
+expressir coverage --exclude=TYPE:SELECT --format=json schemas/resources/action_schema/action_schema.exp
+----
+
+==== Elements checked in documentation coverage
+
+Expressir checks documentation coverage for all EXPRESS elements (ModelElement
+subclasses), including:
+
+Schema-level entities:
+
+`TYPE`:: Type definitions (supports subtype exclusion, see below)
+`ENTITY`:: Entity definitions
+`CONSTANT`:: Constant definitions
+`FUNCTION`:: Function definitions
+`RULE`:: Rule definitions
+`PROCEDURE`:: Procedure definitions
+`SUBTYPE_CONSTRAINT`:: Subtype constraint definitions
+`INTERFACE`:: Interface definitions
+
+Nested entities within other constructs:
+
+`PARAMETER`:: Function and procedure parameters
+`VARIABLE`:: Variables within functions, rules, and procedures
+`ATTRIBUTE`:: Entity attributes
+`DERIVED_ATTRIBUTE`:: Derived attributes in entities
+`INVERSE_ATTRIBUTE`:: Inverse attributes in entities
+`UNIQUE_RULE`:: Unique rules within entities
+`WHERE_RULE`:: Where rules within entities and types
+`ENUMERATION_ITEM`:: Items within enumeration types
+`INTERFACE_ITEM`:: Items within interfaces
+`INTERFACED_ITEM`:: Interfaced items
+`SCHEMA_VERSION`:: Schema version information
+`SCHEMA_VERSION_ITEM`:: Schema version items
+
+==== TYPE subtype exclusion
+
+For TYPE elements, you can exclude specific subtypes using the `TYPE:SUBTYPE`
+syntax:
+
+[source, sh]
+----
+# Exclude only SELECT types
+expressir coverage --exclude=TYPE:SELECT schemas/resources/action_schema/action_schema.exp
+
+# Exclude multiple TYPE subtypes
+expressir coverage --exclude=TYPE:SELECT,TYPE:ENUMERATION schemas/resources/action_schema/action_schema.exp
+----
+
+==== FUNCTION subtype exclusion
+
+For FUNCTION elements, you can exclude inner functions (functions nested within
+other functions, rules, or procedures) using the `FUNCTION:INNER` syntax:
+
+[source, sh]
+----
+# Exclude inner functions from coverage analysis
+expressir coverage --exclude=FUNCTION:INNER schemas/resources/action_schema/action_schema.exp
+
+# Combine with other exclusions
+expressir coverage --exclude=TYPE:SELECT,FUNCTION:INNER schemas/resources/action_schema/action_schema.exp
+----
+
+This is useful when you want to focus documentation coverage on top-level
+functions while excluding nested helper functions that may not require
+individual documentation.
+
+Valid FUNCTION subtypes that can be excluded:
+
+`INNER`:: Inner functions nested within other functions, rules, or procedures
++
+[example]
+====
+----
+FUNCTION outer_function : BOOLEAN;
+  -- This inner function would be excluded with FUNCTION:INNER
+  FUNCTION inner_helper_function : BOOLEAN;
+    RETURN (TRUE);
+  END_FUNCTION;
+
+  RETURN (TRUE);
+END_FUNCTION;
+----
+====
+
+Valid TYPE subtypes that can be excluded:
+
+`AGGREGATE`:: Aggregate type
+`ARRAY`:: Array type
+`BAG`:: Bag type
+`BINARY`:: Binary type
+`BOOLEAN`:: Boolean type
+`ENUMERATION`:: Enumeration type
++
+[example]
+====
+----
+TYPE uuid_relationship_role = ENUMERATION OF
+  (supersedes,
+    merge,
+    split,
+    derive_from,
+    same_as,
+    similar_to);
+END_TYPE;
+----
+====
+
+`GENERIC`:: Generic type
+`GENERIC_ENTITY`:: Generic entity type
++
+[example]
+====
+----
+TYPE uuid_attribute_select = EXTENSIBLE GENERIC_ENTITY SELECT;
+END_TYPE;
+----
+====
+
+`INTEGER`:: Integer type
+`LIST`:: List type
++
+[example]
+====
+----
+TYPE uuid_list_item = LIST [1:?] OF UNIQUE LIST [1:?] OF UNIQUE uuid_attribute_select;
+END_TYPE;
+----
+====
+
+`LOGICAL`:: Logical type
+`NUMBER`:: Number type
+`REAL`:: Real type
+`SELECT`:: Select type
++
+[example]
+====
+----
+TYPE uuid_set_or_list_attribute_select = SELECT
+  (uuid_list_item,
+    uuid_set_item);
+END_TYPE;
+----
+====
+
+`SET`:: Set type
++
+[example]
+====
 ----
+TYPE uuid_set_item = SET [1:?] OF uuid_attribute_select;
+END_TYPE;
+----
+====
+
+`STRING`::
+String type
++
+[example]
+====
+----
+TYPE uuid = STRING (36) FIXED;
+END_TYPE;
+----
+====
 
-Valid entity types that can be excluded:
+This is particularly useful since TYPE entities with certain subtypes (like
+SELECT) often have descriptions generated by template strings and may not
+require individual remark item coverage.
 
-* `TYPE` - Type definitions
-* `ENTITY` - Entity definitions
-* `CONSTANT` - Constant definitions
-* `FUNCTION` - Function definitions
-* `RULE` - Rule definitions
-* `PROCEDURE` - Procedure definitions
-* `SUBTYPE_CONSTRAINT` - Subtype constraint definitions
+NOTE: ISO 10303 excludes documentation coverage for TYPE:SELECT and
+TYPE:ENUMERATION.
 
-If you specify an invalid entity type, the command will display an error message
-with the list of valid types.
+If you specify an invalid entity type or subtype, the command will display an
+error message with the list of valid options.
 
 .Example with JSON output:
 [example]

data/expressir.gemspec

@@ -42,5 +42,4 @@ Gem::Specification.new do |spec|
   spec.add_dependency "ruby-progressbar", "~> 1.11"
   spec.add_dependency "terminal-table", "~> 3.0"
   spec.add_dependency "thor", "~> 1.0"
-  spec.add_dependency "zeitwerk", "~> 2.6"
 end

data/lib/expressir/cli.rb

@@ -55,7 +55,8 @@ module Expressir
 
     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)"
+    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)"
     def coverage(*paths)
       Commands::Coverage.new(options).run(paths)
     end

data/lib/expressir/commands/coverage.rb

@@ -275,33 +275,74 @@ module Expressir
       end
 
       def display_json_output(reports)
-        say JSON.pretty_generate(build_structured_report(reports))
+        output_file = options[:output] || "coverage_report.json"
+        File.write(output_file, JSON.pretty_generate(build_structured_report(reports)))
+        say "JSON coverage report written to: #{output_file}"
       end
 
       def display_yaml_output(reports)
-        say build_structured_report(reports).to_yaml
+        output_file = options[:output] || "coverage_report.yaml"
+        File.write(output_file, build_structured_report(reports).to_yaml)
+        say "YAML coverage report written to: #{output_file}"
       end
 
       # Parse and validate the skip_types option
       # @return [Array<String>] Array of validated entity type names
       def parse_skip_types
-        skip_types_option = options["exclude"]
+        skip_types_option = options["exclude"] || options[:exclude]
         return [] unless skip_types_option
 
-        # Split by comma and clean up whitespace
-        requested_types = skip_types_option.split(",").map(&:strip).map(&:upcase)
+        # Handle both string (comma-separated) and array inputs
+        requested_types = if skip_types_option.is_a?(Array)
+                            skip_types_option.map(&:to_s).map(&:strip).map(&:upcase)
+                          else
+                            skip_types_option.split(",").map(&:strip).map(&:upcase)
+                          end
 
-        # Validate against known entity types
-        valid_types = Expressir::Coverage::ENTITY_TYPE_MAP.keys
-        invalid_types = requested_types - valid_types
-
-        unless invalid_types.empty?
-          exit_with_error "Invalid entity types: #{invalid_types.join(', ')}. " \
-                          "Valid types are: #{valid_types.join(', ')}"
+        # Validate each type (supports both TYPE and TYPE:SUBTYPE formats)
+        requested_types.each do |type|
+          validate_skip_type(type)
         end
 
         requested_types
       end
+
+      # Validate a single skip type (supports TYPE:SUBTYPE and FUNCTION:SUBTYPE syntax)
+      # @param type [String] The type to validate
+      def validate_skip_type(type)
+        if type.include?(":")
+          # Handle TYPE:SUBTYPE and FUNCTION:SUBTYPE format
+          main_type, subtype = type.split(":", 2)
+
+          # Validate main type
+          unless Expressir::Coverage::ENTITY_TYPE_MAP.key?(main_type)
+            exit_with_error "Invalid entity type: #{main_type}. " \
+                            "Valid types are: #{Expressir::Coverage::ENTITY_TYPE_MAP.keys.join(', ')}"
+          end
+
+          # For TYPE, validate subtype
+          if main_type == "TYPE"
+            unless Expressir::Coverage::TYPE_SUBTYPES.include?(subtype)
+              exit_with_error "Invalid TYPE subtype: #{subtype}. " \
+                              "Valid TYPE subtypes are: #{Expressir::Coverage::TYPE_SUBTYPES.join(', ')}"
+            end
+          # For FUNCTION, validate subtype
+          elsif main_type == "FUNCTION"
+            unless subtype == "INNER"
+              exit_with_error "Invalid FUNCTION subtype: #{subtype}. " \
+                              "Valid FUNCTION subtypes are: INNER"
+            end
+          else
+            exit_with_error "Subtype syntax (#{type}) is only supported for TYPE and FUNCTION entities"
+          end
+        else
+          # Handle simple type format
+          unless Expressir::Coverage::ENTITY_TYPE_MAP.key?(type)
+            exit_with_error "Invalid entity type: #{type}. " \
+                            "Valid types are: #{Expressir::Coverage::ENTITY_TYPE_MAP.keys.join(', ')}"
+          end
+        end
+      end
     end
   end
 end

data/lib/expressir/coverage.rb

@@ -12,7 +12,50 @@ module Expressir
       "RULE" => "Expressir::Model::Declarations::Rule",
       "PROCEDURE" => "Expressir::Model::Declarations::Procedure",
       "SUBTYPE_CONSTRAINT" => "Expressir::Model::Declarations::SubtypeConstraint",
+      "PARAMETER" => "Expressir::Model::Declarations::Parameter",
+      "VARIABLE" => "Expressir::Model::Declarations::Variable",
+      "ATTRIBUTE" => "Expressir::Model::Declarations::Attribute",
+      "DERIVED_ATTRIBUTE" => "Expressir::Model::Declarations::DerivedAttribute",
+      "INVERSE_ATTRIBUTE" => "Expressir::Model::Declarations::InverseAttribute",
+      "UNIQUE_RULE" => "Expressir::Model::Declarations::UniqueRule",
+      "WHERE_RULE" => "Expressir::Model::Declarations::WhereRule",
+      "ENUMERATION_ITEM" => "Expressir::Model::DataTypes::EnumerationItem",
+      "INTERFACE" => "Expressir::Model::Declarations::Interface",
+      "INTERFACE_ITEM" => "Expressir::Model::Declarations::InterfaceItem",
+      "INTERFACED_ITEM" => "Expressir::Model::Declarations::InterfacedItem",
+      "SCHEMA_VERSION" => "Expressir::Model::Declarations::SchemaVersion",
+      "SCHEMA_VERSION_ITEM" => "Expressir::Model::Declarations::SchemaVersionItem",
     }.freeze
+
+    # Mapping of class names to EXPRESS entity type names (for proper formatting)
+    CLASS_TO_EXPRESS_TYPE_MAP = {
+      "Type" => "TYPE",
+      "Entity" => "ENTITY",
+      "Constant" => "CONSTANT",
+      "Function" => "FUNCTION",
+      "Rule" => "RULE",
+      "Procedure" => "PROCEDURE",
+      "SubtypeConstraint" => "SUBTYPE_CONSTRAINT",
+      "Parameter" => "PARAMETER",
+      "Variable" => "VARIABLE",
+      "Attribute" => "ATTRIBUTE",
+      "DerivedAttribute" => "DERIVED_ATTRIBUTE",
+      "InverseAttribute" => "INVERSE_ATTRIBUTE",
+      "UniqueRule" => "UNIQUE_RULE",
+      "WhereRule" => "WHERE_RULE",
+      "EnumerationItem" => "ENUMERATION_ITEM",
+      "Interface" => "INTERFACE",
+      "InterfaceItem" => "INTERFACE_ITEM",
+      "InterfacedItem" => "INTERFACED_ITEM",
+      "SchemaVersion" => "SCHEMA_VERSION",
+      "SchemaVersionItem" => "SCHEMA_VERSION_ITEM",
+    }.freeze
+
+    # Available TYPE subtypes based on data types
+    TYPE_SUBTYPES = %w[
+      AGGREGATE ARRAY BAG BINARY BOOLEAN ENUMERATION GENERIC GENERIC_ENTITY
+      INTEGER LIST LOGICAL NUMBER REAL SELECT SET STRING
+    ].freeze
     # Represents a documentation coverage report for EXPRESS schemas
     class Report
       attr_reader :repository, :schema_reports, :total_entities, :documented_entities,
@@ -173,8 +216,8 @@ module Expressir
         # Get class name (e.g., "Type" from "Expressir::Model::Declarations::Type")
         type_name = entity.class.name.split("::").last
 
-        # Convert to EXPRESS convention (e.g., "TYPE")
-        express_type = type_name.upcase
+        # Use proper mapping to EXPRESS convention
+        express_type = CLASS_TO_EXPRESS_TYPE_MAP[type_name] || type_name.upcase
 
         # Return structured format
         {
@@ -209,11 +252,35 @@ module Expressir
       end
     end
 
-    # Find all entities in a schema
-    # @param schema [Expressir::Model::Declarations::Schema] The schema to analyze
+    # Find all entities in a schema or repository
+    # @param schema_or_repo [Expressir::Model::Declarations::Schema, Expressir::Model::Repository] The schema or repository to analyze
     # @param skip_types [Array<String>] Array of entity type names to skip from coverage
     # @return [Array<Expressir::Model::ModelElement>] Array of entities
-    def self.find_entities(schema, skip_types = [])
+    def self.find_entities(schema_or_repo, skip_types = [])
+      entities = []
+
+      # Handle both repository and schema inputs
+      if schema_or_repo.is_a?(Expressir::Model::Repository)
+        # If it's a repository, process all schemas
+        schema_or_repo.schemas.each do |schema|
+          entities.concat(find_entities_in_schema(schema))
+        end
+      else
+        # If it's a schema, process it directly
+        entities.concat(find_entities_in_schema(schema_or_repo))
+      end
+
+      # Filter out any nil elements and ensure all have IDs
+      entities = entities.compact.select { |e| e.respond_to?(:id) && e.id }
+
+      # Filter out skipped entity types
+      apply_exclusions(entities, skip_types)
+    end
+
+    # Find all entities in a single schema
+    # @param schema [Expressir::Model::Declarations::Schema] The schema to analyze
+    # @return [Array<Expressir::Model::ModelElement>] Array of entities
+    def self.find_entities_in_schema(schema)
       entities = []
 
       # Add all schema-level entities
@@ -224,26 +291,203 @@ module Expressir
       entities.concat(schema.rules) if schema.rules
       entities.concat(schema.procedures) if schema.procedures
       entities.concat(schema.subtype_constraints) if schema.subtype_constraints
+      entities.concat(schema.interfaces) if schema.interfaces
+
+      # Add nested entities recursively
+      entities.concat(find_nested_entities(schema))
+
+      entities
+    end
+
+    # Find all nested entities within a container (schema, entity, function, etc.)
+    # @param container [Expressir::Model::ModelElement] The container to search
+    # @return [Array<Expressir::Model::ModelElement>] Array of nested entities
+    def self.find_nested_entities(container)
+      entities = []
+
+      # Handle different container types
+      case container
+      when Expressir::Model::Declarations::Schema
+        # Schema-level nested entities
+        container.types&.each do |type|
+          entities.concat(find_nested_entities(type))
+        end
+        container.entities&.each do |entity|
+          entities.concat(find_nested_entities(entity))
+        end
+        container.functions&.each do |function|
+          entities.concat(find_nested_entities(function))
+        end
+        container.rules&.each do |rule|
+          entities.concat(find_nested_entities(rule))
+        end
+        container.procedures&.each do |procedure|
+          entities.concat(find_nested_entities(procedure))
+        end
+        container.interfaces&.each do |interface|
+          entities.concat(find_nested_entities(interface))
+        end
+
+      when Expressir::Model::Declarations::Type
+        # Type nested entities
+        if container.respond_to?(:enumeration_items) && container.enumeration_items
+          entities.concat(container.enumeration_items)
+        end
+
+      when Expressir::Model::Declarations::Entity
+        # Entity nested entities
+        entities.concat(container.attributes) if container.attributes
+        entities.concat(container.unique_rules) if container.unique_rules
+        entities.concat(container.where_rules) if container.where_rules
+
+      when Expressir::Model::Declarations::Function
+        # Function nested entities
+        entities.concat(container.parameters) if container.parameters
+        entities.concat(container.variables) if container.variables
+        entities.concat(container.constants) if container.constants
+        entities.concat(container.types) if container.types
+        entities.concat(container.entities) if container.entities
+        entities.concat(container.functions) if container.functions
+        entities.concat(container.procedures) if container.procedures
+        entities.concat(container.subtype_constraints) if container.subtype_constraints
+
+        # Recursively find nested entities in nested containers
+        container.types&.each { |type| entities.concat(find_nested_entities(type)) }
+        container.entities&.each { |entity| entities.concat(find_nested_entities(entity)) }
+        container.functions&.each { |function| entities.concat(find_nested_entities(function)) }
+        container.procedures&.each { |procedure| entities.concat(find_nested_entities(procedure)) }
+
+      when Expressir::Model::Declarations::Rule
+        # Rule nested entities
+        entities.concat(container.variables) if container.variables
+        entities.concat(container.constants) if container.constants
+        entities.concat(container.types) if container.types
+        entities.concat(container.entities) if container.entities
+        entities.concat(container.functions) if container.functions
+        entities.concat(container.procedures) if container.procedures
+        entities.concat(container.subtype_constraints) if container.subtype_constraints
+
+        # Recursively find nested entities in nested containers
+        container.types&.each { |type| entities.concat(find_nested_entities(type)) }
+        container.entities&.each { |entity| entities.concat(find_nested_entities(entity)) }
+        container.functions&.each { |function| entities.concat(find_nested_entities(function)) }
+        container.procedures&.each { |procedure| entities.concat(find_nested_entities(procedure)) }
+
+      when Expressir::Model::Declarations::Procedure
+        # Procedure nested entities
+        entities.concat(container.parameters) if container.parameters
+        entities.concat(container.variables) if container.variables
+        entities.concat(container.constants) if container.constants
+        entities.concat(container.types) if container.types
+        entities.concat(container.entities) if container.entities
+        entities.concat(container.functions) if container.functions
+        entities.concat(container.procedures) if container.procedures
+        entities.concat(container.subtype_constraints) if container.subtype_constraints
+
+        # Recursively find nested entities in nested containers
+        container.types&.each { |type| entities.concat(find_nested_entities(type)) }
+        container.entities&.each { |entity| entities.concat(find_nested_entities(entity)) }
+        container.functions&.each { |function| entities.concat(find_nested_entities(function)) }
+        container.procedures&.each { |procedure| entities.concat(find_nested_entities(procedure)) }
+
+      when Expressir::Model::Declarations::Interface
+        # Interface nested entities
+        entities.concat(container.items) if container.items
+      end
+
+      entities
+    end
+
+    # Apply exclusions to filter out entities based on skip_types (supports both simple and TYPE:SUBTYPE syntax)
+    # @param entities [Array<Expressir::Model::ModelElement>] The entities to filter
+    # @param exclusions [Array<String>] Array of entity type names to exclude from coverage
+    # @return [Array<Expressir::Model::ModelElement>] Filtered entities
+    def self.apply_exclusions(entities, exclusions)
+      filter_skipped_entities(entities, exclusions)
+    end
 
-      # Add enumeration items from types (only if TYPE is not being skipped)
-      unless skip_types.include?("TYPE")
-        schema.types&.each do |type|
-          if type.respond_to?(:enumeration_items) && type.enumeration_items
-            entities.concat(type.enumeration_items)
+    # Filter out entities based on skip_types (supports both simple and TYPE:SUBTYPE syntax)
+    # @param entities [Array<Expressir::Model::ModelElement>] The entities to filter
+    # @param skip_types [Array<String>] Array of entity type names to skip from coverage
+    # @return [Array<Expressir::Model::ModelElement>] Filtered entities
+    def self.filter_skipped_entities(entities, skip_types)
+      return entities if skip_types.empty?
+
+      # Parse skip_types into simple types, TYPE subtypes, and FUNCTION subtypes
+      simple_skips = []
+      type_subtype_skips = []
+      function_subtype_skips = []
+
+      skip_types.each do |skip_type|
+        if skip_type.include?(":")
+          # Handle TYPE:SUBTYPE and FUNCTION:SUBTYPE format
+          main_type, subtype = skip_type.split(":", 2)
+          if main_type == "TYPE" && TYPE_SUBTYPES.include?(subtype)
+            type_subtype_skips << subtype
+          elsif main_type == "FUNCTION" && subtype == "INNER"
+            function_subtype_skips << subtype
           end
+        else
+          # Handle simple type format
+          simple_skips << skip_type
         end
       end
 
-      # Filter out any nil elements and ensure all have IDs
-      entities = entities.compact.select { |e| e.respond_to?(:id) && e.id }
+      # Filter entities
+      entities.reject do |entity|
+        entity_class = entity.class.name
+
+        # Check simple type exclusions
+        # Convert entity class to EXPRESS type name for comparison
+        class_name = entity_class.split("::").last
+        express_type = CLASS_TO_EXPRESS_TYPE_MAP[class_name] || class_name.upcase
+
+        if simple_skips.include?(express_type)
+          true
+        # Check TYPE subtype exclusions
+        elsif entity_class == "Expressir::Model::Declarations::Type" && type_subtype_skips.any?
+          entity_subtype = get_type_subtype(entity)
+          type_subtype_skips.include?(entity_subtype)
+        # Check FUNCTION:INNER exclusions
+        elsif entity_class == "Expressir::Model::Declarations::Function" && function_subtype_skips.include?("INNER")
+          is_inner_function?(entity)
+        else
+          false
+        end
+      end
+    end
 
-      # Filter out skipped entity types
-      if skip_types.any?
-        skip_classes = skip_types.map { |type| ENTITY_TYPE_MAP[type] }.compact
-        entities = entities.reject { |entity| skip_classes.include?(entity.class.name) }
+    # Get the subtype of a TYPE entity based on its underlying_type
+    # @param type_entity [Expressir::Model::Declarations::Type] The TYPE entity
+    # @return [String] The subtype name (e.g., "SELECT", "ENUMERATION")
+    def self.get_type_subtype(type_entity)
+      return nil unless type_entity.respond_to?(:underlying_type) && type_entity.underlying_type
+
+      # Get the class name of the underlying type
+      underlying_class = type_entity.underlying_type.class.name
+
+      # Extract the data type name (e.g., "Select" from "Expressir::Model::DataTypes::Select")
+      if underlying_class.start_with?("Expressir::Model::DataTypes::")
+        data_type_name = underlying_class.split("::").last
+        # Convert to uppercase (e.g., "Select" -> "SELECT")
+        data_type_name.upcase
+      else
+        # For other types, try to extract the last part of the class name
+        underlying_class.split("::").last&.upcase
       end
+    end
 
-      entities
+    # Check if a function is an inner function (nested within another function, rule, or procedure)
+    # @param function_entity [Expressir::Model::Declarations::Function] The function entity to check
+    # @return [Boolean] True if the function is nested within another function, rule, or procedure
+    def self.is_inner_function?(function_entity)
+      return false unless function_entity.respond_to?(:parent) && function_entity.parent
+
+      # Check if the parent is a function, rule, or procedure (not a schema)
+      parent = function_entity.parent
+      parent.is_a?(Expressir::Model::Declarations::Function) ||
+        parent.is_a?(Expressir::Model::Declarations::Rule) ||
+        parent.is_a?(Expressir::Model::Declarations::Procedure)
     end
   end
 end

data/lib/expressir/express/formatter.rb

@@ -208,7 +208,8 @@ module Expressir
       private
 
       def format_repository(node)
-        node.schemas&.map { |x| format(x) }&.join("\n\n")
+        result = node.schemas&.map { |x| format(x) }&.join("\n\n")
+        result ? "#{result}\n" : ""
       end
 
       def format_declarations_attribute(node)
@@ -1615,39 +1616,65 @@ module Expressir
       end
 
       def format_remark(node, remark)
+        # Handle embedded remarks
         if remark.include?("\n")
           [
             [
-              "(*",
-              '"',
+              "(*\"",
               node.path || node.id,
-              '"',
+              "\"",
             ].join,
             remark,
             "*)",
           ].join("\n")
         else
+          # Handle tail remarks
           [
-            "--",
-            '"',
+            "--\"",
             node.path || node.id,
-            '"',
-            " ",
+            "\" ",
+            remark,
+          ].join
+        end
+      end
+
+      def format_untagged_remark(remark)
+        # Handle embedded remarks
+        if remark.include?("\n")
+          [
+            "(*",
+            remark,
+            "*)",
+          ].join("\n")
+        else
+          # Handle tail remarks
+          [
+            "-- ",
             remark,
           ].join
         end
       end
 
       def format_remarks(node)
+        remarks = []
+
+        # Add tagged remarks
         if node.class.method_defined?(:remarks) && !@no_remarks &&
             !node.remarks.nil?
-
-          node.remarks.map do |remark|
+          remarks.concat(node.remarks.map do |remark|
             format_remark(node, remark)
-          end
-        else
-          []
+          end)
+        end
+
+        # Add untagged remarks
+        if node.respond_to?(:untagged_remarks) && !@no_remarks &&
+            !node.untagged_remarks.nil?
+          remarks.concat(node.untagged_remarks.map do |remark|
+            format_untagged_remark(remark)
+          end)
         end
+
+        remarks
       end
 
       def format_scope_remarks(node)

data/lib/expressir/express/visitor.rb

@@ -271,32 +271,67 @@ module Expressir
         remark_tokens = remark_tokens.reject { |x| @attached_remark_tokens.include?(x) }
 
         # parse remarks, find remark targets
-        tagged_remark_tokens = remark_tokens.map do |span|
+        tagged_remark_tokens = []
+        untagged_remark_tokens = []
+
+        remark_tokens.each do |span|
           text = @source[span[0]..span[1] - 1]
-          _, remark_tag, remark_text = if text.start_with?("--")
-                                         text.match(/^--"([^"]*)"(.*)$/).to_a
-                                       else
-                                         text.match(/^\(\*"([^"]*)"(.*)\*\)$/m).to_a
-                                       end
-
-          if remark_tag
-            remark_target = find_remark_target(node, remark_tag)
-          end
-          if remark_text
-            remark_text = remark_text.strip.force_encoding("UTF-8")
+          remark_type = if text.start_with?("--")
+                          :tail
+                        else
+                          :embedded
+                        end
+
+          if text.start_with?("--\"") && text.include?("\"")
+            # Tagged tail remark: --"tag" content
+            quote_end = text.index("\"", 3)
+            if quote_end
+              remark_target_path = text[3...quote_end]
+              remark_text = text[(quote_end + 1)..].strip.force_encoding("UTF-8")
+              remark_target = find_remark_target(node, remark_target_path)
+              if remark_target
+                tagged_remark_tokens << [span, remark_target, remark_text]
+              end
+            end
+          elsif text.start_with?("(*\"") && text.include?("\"")
+            # Tagged embedded remark: (*"tag" content *)
+            quote_end = text.index("\"", 3)
+            if quote_end
+              remark_target_path = text[3...quote_end]
+              remark_text = text[(quote_end + 1)...-2].strip.force_encoding("UTF-8")
+              remark_target = find_remark_target(node, remark_target_path)
+              if remark_target
+                tagged_remark_tokens << [span, remark_target, remark_text]
+              end
+            end
+          elsif text.start_with?("--")
+            # Untagged tail remark: -- content
+            untagged_text = text[2..].strip.force_encoding("UTF-8")
+            untagged_remark_tokens << [span, untagged_text, remark_type]
+          else
+            # Untagged embedded remark: (* content *)
+            untagged_text = text[2...-2].strip.force_encoding("UTF-8")
+            untagged_remark_tokens << [span, untagged_text, remark_type]
           end
+        end
 
-          [span, remark_target, remark_text]
-        end.select { |x| x[1] }
-
+        # Attach tagged remarks
         tagged_remark_tokens.each do |span, remark_target, remark_text|
-          # attach remark
           remark_target.remarks ||= []
           remark_target.remarks << remark_text
-
-          # mark remark as attached, so that it is not attached again at higher nesting level
           @attached_remark_tokens << span
         end
+
+        # Attach untagged remarks to the current node if it supports them
+        # All ModelElements support untagged remarks, but we may get Arrays here
+        if node.respond_to?(:untagged_remarks) && !untagged_remark_tokens.empty?
+          node.untagged_remarks ||= []
+          untagged_remark_tokens.each do |span, untagged_text, _remark_type|
+            # Handle both embedded and tail remarks
+            node.untagged_remarks << untagged_text
+            @attached_remark_tokens << span
+          end
+        end
       end
 
       def visit_attribute_ref(ctx)

data/lib/expressir/model/identifier.rb

@@ -5,11 +5,13 @@ module Expressir
         mod.attribute :id, :string
         mod.attribute :remarks, :string, collection: true
         mod.attribute :remark_items, ::Expressir::Model::Declarations::RemarkItem, collection: true
+        mod.attribute :untagged_remarks, :string, collection: true
 
         mod.key_value do
           map "id", to: :id
           map "remarks", to: :remarks
           map "remark_items", to: :remark_items
+          map "untagged_remarks", to: :untagged_remarks
         end
       end
     end

data/lib/expressir/model/model_element.rb

@@ -13,6 +13,7 @@ module Expressir
       attribute :_class, :string, default: -> { send(:name) },
                                   polymorphic_class: true
       attribute :source, :string
+      attribute :untagged_remarks, :string, collection: true
 
       # TODO: Add basic mappings that can be inherited by all subclasses
       key_value do

data/lib/expressir/model.rb

@@ -1,72 +1,95 @@
-require_relative "model/model_element"
-require_relative "model/cache"
-require_relative "model/identifier"
-require_relative "model/repository"
+# This file is kept for backward compatibility and to ensure all model classes are loaded
+# when explicitly requiring 'expressir/model'. The actual autoload definitions are in the main
+# expressir.rb file.
 
-require_relative "model/data_types/aggregate"
-require_relative "model/data_types/array"
-require_relative "model/data_types/bag"
-require_relative "model/data_types/binary"
-require_relative "model/data_types/boolean"
-require_relative "model/data_types/enumeration"
-require_relative "model/data_types/enumeration_item"
-require_relative "model/data_types/generic_entity"
-require_relative "model/data_types/generic"
-require_relative "model/data_types/integer"
-require_relative "model/data_types/list"
-require_relative "model/data_types/logical"
-require_relative "model/data_types/number"
-require_relative "model/data_types/real"
-require_relative "model/data_types/set"
-require_relative "model/data_types/select"
-require_relative "model/data_types/string"
-require_relative "model/declarations/attribute"
-require_relative "model/declarations/constant"
-require_relative "model/declarations/entity"
-require_relative "model/declarations/function"
-require_relative "model/declarations/interface"
-require_relative "model/declarations/interface_item"
-require_relative "model/declarations/interfaced_item"
-require_relative "model/declarations/parameter"
-require_relative "model/declarations/procedure"
-require_relative "model/declarations/remark_item"
-require_relative "model/declarations/rule"
-require_relative "model/declarations/schema"
-require_relative "model/declarations/schema_version"
-require_relative "model/declarations/schema_version_item"
-require_relative "model/declarations/subtype_constraint"
-require_relative "model/declarations/type"
-require_relative "model/declarations/unique_rule"
-require_relative "model/declarations/variable"
-require_relative "model/declarations/where_rule"
-require_relative "model/expressions/aggregate_initializer"
-require_relative "model/expressions/aggregate_initializer_item"
-require_relative "model/expressions/binary_expression"
-require_relative "model/expressions/entity_constructor"
-require_relative "model/expressions/function_call"
-require_relative "model/expressions/interval"
-require_relative "model/expressions/query_expression"
-require_relative "model/expressions/unary_expression"
-require_relative "model/literals/binary"
-require_relative "model/literals/integer"
-require_relative "model/literals/logical"
-require_relative "model/literals/real"
-require_relative "model/literals/string"
-require_relative "model/references/attribute_reference"
-require_relative "model/references/group_reference"
-require_relative "model/references/index_reference"
-require_relative "model/references/simple_reference"
-require_relative "model/statements/alias"
-require_relative "model/statements/assignment"
-require_relative "model/statements/case"
-require_relative "model/statements/case_action"
-require_relative "model/statements/compound"
-require_relative "model/statements/escape"
-require_relative "model/statements/if"
-require_relative "model/statements/null"
-require_relative "model/statements/procedure_call"
-require_relative "model/statements/repeat"
-require_relative "model/statements/return"
-require_relative "model/statements/skip"
-require_relative "model/supertype_expressions/binary_supertype_expression"
-require_relative "model/supertype_expressions/oneof_supertype_expression"
+# Ensure all model classes are loaded by referencing them
+# This triggers the autoload mechanism for each class
+
+# Core model classes
+Expressir::Model::ModelElement
+Expressir::Model::Cache
+Expressir::Model::Identifier
+Expressir::Model::Repository
+
+# Data types
+Expressir::Model::DataTypes::Aggregate
+Expressir::Model::DataTypes::Array
+Expressir::Model::DataTypes::Bag
+Expressir::Model::DataTypes::Binary
+Expressir::Model::DataTypes::Boolean
+Expressir::Model::DataTypes::Enumeration
+Expressir::Model::DataTypes::EnumerationItem
+Expressir::Model::DataTypes::GenericEntity
+Expressir::Model::DataTypes::Generic
+Expressir::Model::DataTypes::Integer
+Expressir::Model::DataTypes::List
+Expressir::Model::DataTypes::Logical
+Expressir::Model::DataTypes::Number
+Expressir::Model::DataTypes::Real
+Expressir::Model::DataTypes::Select
+Expressir::Model::DataTypes::Set
+Expressir::Model::DataTypes::String
+
+# Declarations
+Expressir::Model::Declarations::Attribute
+Expressir::Model::Declarations::Constant
+Expressir::Model::Declarations::DerivedAttribute
+Expressir::Model::Declarations::Entity
+Expressir::Model::Declarations::Function
+Expressir::Model::Declarations::Interface
+Expressir::Model::Declarations::InterfaceItem
+Expressir::Model::Declarations::InterfacedItem
+Expressir::Model::Declarations::InverseAttribute
+Expressir::Model::Declarations::Parameter
+Expressir::Model::Declarations::Procedure
+Expressir::Model::Declarations::RemarkItem
+Expressir::Model::Declarations::Rule
+Expressir::Model::Declarations::Schema
+Expressir::Model::Declarations::SchemaVersion
+Expressir::Model::Declarations::SchemaVersionItem
+Expressir::Model::Declarations::SubtypeConstraint
+Expressir::Model::Declarations::Type
+Expressir::Model::Declarations::UniqueRule
+Expressir::Model::Declarations::Variable
+Expressir::Model::Declarations::WhereRule
+
+# Expressions
+Expressir::Model::Expressions::AggregateInitializer
+Expressir::Model::Expressions::AggregateInitializerItem
+Expressir::Model::Expressions::BinaryExpression
+Expressir::Model::Expressions::EntityConstructor
+Expressir::Model::Expressions::FunctionCall
+Expressir::Model::Expressions::Interval
+Expressir::Model::Expressions::QueryExpression
+Expressir::Model::Expressions::UnaryExpression
+
+# Literals
+Expressir::Model::Literals::Binary
+Expressir::Model::Literals::Integer
+Expressir::Model::Literals::Logical
+Expressir::Model::Literals::Real
+Expressir::Model::Literals::String
+
+# References
+Expressir::Model::References::AttributeReference
+Expressir::Model::References::GroupReference
+Expressir::Model::References::IndexReference
+Expressir::Model::References::SimpleReference
+
+# Statements
+Expressir::Model::Statements::Alias
+Expressir::Model::Statements::Assignment
+Expressir::Model::Statements::Case
+Expressir::Model::Statements::CaseAction
+Expressir::Model::Statements::Compound
+Expressir::Model::Statements::Escape
+Expressir::Model::Statements::If
+Expressir::Model::Statements::Null
+Expressir::Model::Statements::ProcedureCall
+Expressir::Model::Statements::Repeat
+Expressir::Model::Statements::Return
+Expressir::Model::Statements::Skip
+
+# Supertype expressions
+Expressir::Model::SupertypeExpressions::BinarySupertypeExpression
+Expressir::Model::SupertypeExpressions::OneofSupertypeExpression

data/lib/expressir/version.rb

@@ -1,3 +1,3 @@
 module Expressir
-  VERSION = "2.1.19".freeze
+  VERSION = "2.1.21".freeze
 end

data/lib/expressir.rb

@@ -1,4 +1,3 @@
-require "zeitwerk"
 require_relative "expressir/version"
 require_relative "expressir/cli"
 require_relative "expressir/config"
@@ -36,13 +35,129 @@ module Expressir
   def self.root_path
     @root_path ||= Pathname.new(Expressir.root)
   end
-end
 
-loader = Zeitwerk::Loader.for_gem
-loader.setup
+  # Autoload for Express module classes
+  module Express
+    autoload :Cache, "expressir/express/cache"
+    autoload :Error, "expressir/express/error"
+    autoload :Formatter, "expressir/express/formatter"
+    autoload :HyperlinkFormatter, "expressir/express/hyperlink_formatter"
+    autoload :ModelVisitor, "expressir/express/model_visitor"
+    autoload :Parser, "expressir/express/parser"
+    autoload :ResolveReferencesModelVisitor, "expressir/express/resolve_references_model_visitor"
+    autoload :SchemaHeadFormatter, "expressir/express/schema_head_formatter"
+    autoload :Visitor, "expressir/express/visitor"
+  end
+
+  # Autoload for Model module classes
+  module Model
+    autoload :ModelElement, "expressir/model/model_element"
+    autoload :Cache, "expressir/model/cache"
+    autoload :Identifier, "expressir/model/identifier"
+    autoload :Repository, "expressir/model/repository"
+
+    module DataTypes
+      autoload :Aggregate, "expressir/model/data_types/aggregate"
+      autoload :Array, "expressir/model/data_types/array"
+      autoload :Bag, "expressir/model/data_types/bag"
+      autoload :Binary, "expressir/model/data_types/binary"
+      autoload :Boolean, "expressir/model/data_types/boolean"
+      autoload :Enumeration, "expressir/model/data_types/enumeration"
+      autoload :EnumerationItem, "expressir/model/data_types/enumeration_item"
+      autoload :GenericEntity, "expressir/model/data_types/generic_entity"
+      autoload :Generic, "expressir/model/data_types/generic"
+      autoload :Integer, "expressir/model/data_types/integer"
+      autoload :List, "expressir/model/data_types/list"
+      autoload :Logical, "expressir/model/data_types/logical"
+      autoload :Number, "expressir/model/data_types/number"
+      autoload :Real, "expressir/model/data_types/real"
+      autoload :Select, "expressir/model/data_types/select"
+      autoload :Set, "expressir/model/data_types/set"
+      autoload :String, "expressir/model/data_types/string"
+    end
+
+    module Declarations
+      autoload :Attribute, "expressir/model/declarations/attribute"
+      autoload :Constant, "expressir/model/declarations/constant"
+      autoload :DerivedAttribute, "expressir/model/declarations/derived_attribute"
+      autoload :Entity, "expressir/model/declarations/entity"
+      autoload :Function, "expressir/model/declarations/function"
+      autoload :Interface, "expressir/model/declarations/interface"
+      autoload :InterfaceItem, "expressir/model/declarations/interface_item"
+      autoload :InterfacedItem, "expressir/model/declarations/interfaced_item"
+      autoload :InverseAttribute, "expressir/model/declarations/inverse_attribute"
+      autoload :Parameter, "expressir/model/declarations/parameter"
+      autoload :Procedure, "expressir/model/declarations/procedure"
+      autoload :RemarkItem, "expressir/model/declarations/remark_item"
+      autoload :Rule, "expressir/model/declarations/rule"
+      autoload :Schema, "expressir/model/declarations/schema"
+      autoload :SchemaVersion, "expressir/model/declarations/schema_version"
+      autoload :SchemaVersionItem, "expressir/model/declarations/schema_version_item"
+      autoload :SubtypeConstraint, "expressir/model/declarations/subtype_constraint"
+      autoload :Type, "expressir/model/declarations/type"
+      autoload :UniqueRule, "expressir/model/declarations/unique_rule"
+      autoload :Variable, "expressir/model/declarations/variable"
+      autoload :WhereRule, "expressir/model/declarations/where_rule"
+    end
 
-Dir[File.join(__dir__, "expressir", "express", "*.rb")].sort.each do |fea|
-  require fea
+    module Expressions
+      autoload :AggregateInitializer, "expressir/model/expressions/aggregate_initializer"
+      autoload :AggregateInitializerItem, "expressir/model/expressions/aggregate_initializer_item"
+      autoload :BinaryExpression, "expressir/model/expressions/binary_expression"
+      autoload :EntityConstructor, "expressir/model/expressions/entity_constructor"
+      autoload :FunctionCall, "expressir/model/expressions/function_call"
+      autoload :Interval, "expressir/model/expressions/interval"
+      autoload :QueryExpression, "expressir/model/expressions/query_expression"
+      autoload :UnaryExpression, "expressir/model/expressions/unary_expression"
+    end
+
+    module Literals
+      autoload :Binary, "expressir/model/literals/binary"
+      autoload :Integer, "expressir/model/literals/integer"
+      autoload :Logical, "expressir/model/literals/logical"
+      autoload :Real, "expressir/model/literals/real"
+      autoload :String, "expressir/model/literals/string"
+    end
+
+    module References
+      autoload :AttributeReference, "expressir/model/references/attribute_reference"
+      autoload :GroupReference, "expressir/model/references/group_reference"
+      autoload :IndexReference, "expressir/model/references/index_reference"
+      autoload :SimpleReference, "expressir/model/references/simple_reference"
+    end
+
+    module Statements
+      autoload :Alias, "expressir/model/statements/alias"
+      autoload :Assignment, "expressir/model/statements/assignment"
+      autoload :Case, "expressir/model/statements/case"
+      autoload :CaseAction, "expressir/model/statements/case_action"
+      autoload :Compound, "expressir/model/statements/compound"
+      autoload :Escape, "expressir/model/statements/escape"
+      autoload :If, "expressir/model/statements/if"
+      autoload :Null, "expressir/model/statements/null"
+      autoload :ProcedureCall, "expressir/model/statements/procedure_call"
+      autoload :Repeat, "expressir/model/statements/repeat"
+      autoload :Return, "expressir/model/statements/return"
+      autoload :Skip, "expressir/model/statements/skip"
+    end
+
+    module SupertypeExpressions
+      autoload :BinarySupertypeExpression, "expressir/model/supertype_expressions/binary_supertype_expression"
+      autoload :OneofSupertypeExpression, "expressir/model/supertype_expressions/oneof_supertype_expression"
+    end
+  end
+
+  # Autoload for Commands module classes
+  module Commands
+    autoload :Base, "expressir/commands/base"
+    autoload :Benchmark, "expressir/commands/benchmark"
+    autoload :BenchmarkCache, "expressir/commands/benchmark_cache"
+    autoload :Clean, "expressir/commands/clean"
+    autoload :Coverage, "expressir/commands/coverage"
+    autoload :Format, "expressir/commands/format"
+    autoload :Validate, "expressir/commands/validate"
+    autoload :Version, "expressir/commands/version"
+  end
 end
 
 require_relative "expressir/model"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: expressir
 version: !ruby/object:Gem::Version
-  version: 2.1.19
+  version: 2.1.21
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-06-04 00:00:00.000000000 Z
+date: 2025-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -136,20 +136,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: zeitwerk
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.6'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.6'
 description: Expressir ("EXPRESS in Ruby") is a Ruby parser for EXPRESS and a set
   of tools for accessing EXPRESS data models.
 email: