expressir 2.2.0 → 2.3.0

data/lib/expressir/express/builders/rule_decl_builder.rb

@@ -1,14 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "helpers"
-
 module Expressir
   module Express
     module Builders
       # Builds rule declaration nodes.
       class RuleDeclBuilder
-        include Helpers
-
         def call(ast_data)
           head = ast_data[:rule_head]
           algorithm_head = ast_data[:algorithm_head]
@@ -23,28 +19,36 @@ module Expressir
             declarations = Builder.build_children(algorithm_head[:declaration])
           end
 
-          types = declarations.select { |x| x.is_a?(Expressir::Model::Declarations::Type) }
-          entities = declarations.select { |x| x.is_a?(Expressir::Model::Declarations::Entity) }
-          subtype_constraints = declarations.select { |x| x.is_a?(Expressir::Model::Declarations::SubtypeConstraint) }
-          functions = declarations.select { |x| x.is_a?(Expressir::Model::Declarations::Function) }
-          procedures = declarations.select { |x| x.is_a?(Expressir::Model::Declarations::Procedure) }
-          constants = build_constant_decl(algorithm_head[:constant_decl]) if algorithm_head.is_a?(Hash) && algorithm_head[:constant_decl]
-          variables = build_local_decl(algorithm_head[:local_decl]) if algorithm_head.is_a?(Hash) && algorithm_head[:local_decl]
+          types = declarations.grep(Expressir::Model::Declarations::Type)
+          entities = declarations.grep(Expressir::Model::Declarations::Entity)
+          subtype_constraints = declarations.grep(Expressir::Model::Declarations::SubtypeConstraint)
+          functions = declarations.grep(Expressir::Model::Declarations::Function)
+          procedures = declarations.grep(Expressir::Model::Declarations::Procedure)
+          constants = if algorithm_head.is_a?(Hash) && algorithm_head[:constant_decl]
+                       build_constant_decl(algorithm_head[:constant_decl])
+                     else
+                       []
+                     end
+          variables = if algorithm_head.is_a?(Hash) && algorithm_head[:local_decl]
+                       build_local_decl(algorithm_head[:local_decl])
+                     else
+                       []
+                     end
           statements = Builder.build_children(stmts)
           where_rules = where_clause ? Builder.build({ where_clause: where_clause }) : []
 
           Expressir::Model::Declarations::Rule.new(
             id: id,
-            applies_to: [applies_to].flatten.compact,
+            applies_to: Builder.ensure_array(applies_to),
             types: types,
             entities: entities,
             subtype_constraints: subtype_constraints,
             functions: functions,
             procedures: procedures,
-            constants: [constants].flatten.compact,
-            variables: [variables].flatten.compact,
+            constants: constants,
+            variables: variables,
             statements: statements.compact,
-            where_rules: [where_rules].flatten.compact,
+            where_rules: [where_rules].flatten,
           )
         end
 
@@ -70,7 +74,7 @@ module Expressir
               refs << Builder.build({ entity_ref: entity_refs[:entity_ref] })
             end
             if entity_refs[:item]
-              [entity_refs[:item]].flatten.each do |item|
+              Builder.ensure_array(entity_refs[:item]).each do |item|
                 if item[:entity_ref]
                   refs << Builder.build({ entity_ref: item[:entity_ref] })
                 end
@@ -85,11 +89,9 @@ module Expressir
         end
 
         def build_local_decl(data)
-          Builder.build_children(data[:local_variable]).flatten.compact
+          Builder.build_children(data[:local_variable])
         end
       end
     end
   end
 end
-
-Builder.register(:rule_decl, Expressir::Express::Builders::RuleDeclBuilder.new)

data/lib/expressir/express/builders/schema_body_decl_builder.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "helpers"
-
 module Expressir
   module Express
     module Builders
@@ -18,5 +16,3 @@ module Expressir
     end
   end
 end
-
-Builder.register(:schema_body_declaration, Expressir::Express::Builders::SchemaBodyDeclBuilder.new)

data/lib/expressir/express/builders/schema_decl_builder.rb

@@ -1,14 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "helpers"
-
 module Expressir
   module Express
     module Builders
       # Builds schema_decl nodes into Schema objects.
       class SchemaDeclBuilder
-        include Helpers
-
         def call(ast_data)
           id = Builder.build_optional(ast_data[:schema_id])
           version = if ast_data[:schema_version_id]
@@ -26,18 +22,18 @@ module Expressir
             declarations = Builder.build_children(body_decls) if body_decls
           end
 
-          types = declarations.select { |x| x.is_a?(Expressir::Model::Declarations::Type) }
-          entities = declarations.select { |x| x.is_a?(Expressir::Model::Declarations::Entity) }
-          subtype_constraints = declarations.select { |x| x.is_a?(Expressir::Model::Declarations::SubtypeConstraint) }
-          functions = declarations.select { |x| x.is_a?(Expressir::Model::Declarations::Function) }
-          rules = declarations.select { |x| x.is_a?(Expressir::Model::Declarations::Rule) }
-          procedures = declarations.select { |x| x.is_a?(Expressir::Model::Declarations::Procedure) }
+          types = declarations.grep(Expressir::Model::Declarations::Type)
+          entities = declarations.grep(Expressir::Model::Declarations::Entity)
+          subtype_constraints = declarations.grep(Expressir::Model::Declarations::SubtypeConstraint)
+          functions = declarations.grep(Expressir::Model::Declarations::Function)
+          rules = declarations.grep(Expressir::Model::Declarations::Rule)
+          procedures = declarations.grep(Expressir::Model::Declarations::Procedure)
 
           Expressir::Model::Declarations::Schema.new(
             id: id,
             version: version,
             interfaces: interfaces.compact,
-            constants: [constants].flatten.compact,
+            constants: [constants].flatten,
             types: types,
             entities: entities,
             subtype_constraints: subtype_constraints,
@@ -58,5 +54,3 @@ module Expressir
     end
   end
 end
-
-Builder.register(:schema_decl, Expressir::Express::Builders::SchemaDeclBuilder.new)

data/lib/expressir/express/builders/schema_version_builder.rb

@@ -1,14 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "helpers"
-
 module Expressir
   module Express
     module Builders
       # Builds schema_version_id nodes into SchemaVersion objects.
       class SchemaVersionBuilder
-        include Helpers
-
         def call(ast_data)
           string_val = Builder.build_optional(ast_data[:string_literal])
           value = string_val.is_a?(Expressir::Model::Literals::String) ? string_val.value : string_val.to_s
@@ -36,5 +32,3 @@ module Expressir
     end
   end
 end
-
-Builder.register(:schema_version_id, Expressir::Express::Builders::SchemaVersionBuilder.new)

data/lib/expressir/express/builders/simple_id_builder.rb

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
-require_relative "helpers"
-
 module Expressir
   module Express
     module Builders
       # Builds simple ID nodes (simple_id, schema_id, entity_id, etc.)
       # These return a string, not a Model object.
       class SimpleIdBuilder
-        include Helpers
+        include ::Expressir::Express::Builders::Helpers
 
         def call(ast_data)
           extract_text(ast_data[:str]) || extract_text(ast_data[:simple_id]&.dig(:str))
@@ -17,10 +15,3 @@ module Expressir
     end
   end
 end
-
-# Register for all ID types
-%i[simple_id schema_id entity_id type_id function_id procedure_id
-   rule_id rule_label_id constant_id parameter_id variable_id
-   enumeration_id subtype_constraint_id type_label_id attribute_id].each do |id_type|
-  Builder.register(id_type, Expressir::Express::Builders::SimpleIdBuilder.new)
-end

data/lib/expressir/express/builders/statement_builder.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
-require_relative "helpers"
-
 module Expressir
   module Express
     module Builders
       # Builds statement nodes (assignment, if, case, repeat, etc.).
       class StatementBuilder
-        include Helpers
+        include ::Expressir::Express::Builders::Helpers
 
         # stmt - choice dispatcher
         def build_stmt(ast_data)
@@ -41,7 +39,7 @@ module Expressir
           expression = Builder.build_optional(ast_data[:expression])
 
           if ast_data[:qualifier]
-            [ast_data[:qualifier]].flatten.compact.each do |qual|
+            Builder.ensure_array(ast_data[:qualifier]).each do |qual|
               qual_result = Builder.build({ qualifier: qual })
               ref = apply_qualifier(ref, qual_result)
             end
@@ -57,7 +55,7 @@ module Expressir
           statements = Builder.build_children(ast_data[:stmt])
 
           if ast_data[:qualifier] && expression
-            [ast_data[:qualifier]].flatten.compact.each do |qual|
+            Builder.ensure_array(ast_data[:qualifier]).each do |qual|
               qual_result = Builder.build({ qualifier: qual })
               expression = apply_qualifier(expression, qual_result)
             end
@@ -202,7 +200,7 @@ module Expressir
 
           Expressir::Model::Statements::ProcedureCall.new(
             procedure: proc_ref,
-            parameters: [params].flatten.compact,
+            parameters: Builder.ensure_array(params),
           )
         end
 
@@ -222,29 +220,3 @@ module Expressir
     end
   end
 end
-
-builder = Expressir::Express::Builders::StatementBuilder.new
-
-Builder.register(:stmt) { |d| builder.build_stmt(d) }
-Builder.register(:assignment_stmt) { |d| builder.build_assignment_stmt(d) }
-Builder.register(:alias_stmt) { |d| builder.build_alias_stmt(d) }
-Builder.register(:if_stmt) { |d| builder.build_if_stmt(d) }
-Builder.register(:case_stmt) { |d| builder.build_case_stmt(d) }
-Builder.register(:selector) { |d| builder.build_selector(d) }
-Builder.register(:case_action) { |d| builder.build_case_action(d) }
-Builder.register(:case_label) { |d| builder.build_case_label(d) }
-Builder.register(:compound_stmt) { |d| builder.build_compound_stmt(d) }
-Builder.register(:repeat_stmt) { |d| builder.build_repeat_stmt(d) }
-Builder.register(:increment_control) { |d| builder.build_increment_control(d) }
-Builder.register(:increment) { |d| builder.build_increment(d) }
-Builder.register(:while_control) { |d| builder.build_while_control(d) }
-Builder.register(:until_control) { |d| builder.build_until_control(d) }
-Builder.register(:return_stmt) { |d| builder.build_return_stmt(d) }
-Builder.register(:escape_stmt) { |d| builder.build_escape_stmt(d) }
-Builder.register(:skip_stmt) { |d| builder.build_skip_stmt(d) }
-Builder.register(:null_stmt) { |d| builder.build_null_stmt(d) }
-Builder.register(:procedure_call_stmt) do |d|
-  builder.build_procedure_call_stmt(d)
-end
-Builder.register(:type_label) { |d| builder.build_type_label(d) }
-Builder.register(:type_label_ref) { |d| builder.build_type_label_ref(d) }

data/lib/expressir/express/builders/subtype_constraint_builder.rb

@@ -1,14 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "helpers"
-
 module Expressir
   module Express
     module Builders
       # Builds subtype constraint and supertype expression nodes.
       class SubtypeConstraintBuilder
-        include Helpers
-
         def build_subtype_constraint_decl(ast_data)
           head = ast_data[:subtype_constraint_head]
           body = ast_data[:subtype_constraint_body]
@@ -25,7 +21,7 @@ module Expressir
           if body.is_a?(Hash)
             abstract = !body[:abstract_supertype].nil?
             if body[:total_over].is_a?(Hash)
-              total_over = Builder.build_children([body[:total_over][:entity_ref]].flatten.compact)
+              total_over = Builder.build_children(Builder.ensure_array(body[:total_over][:entity_ref]))
             end
             # Wrap supertype_expression in its node type so Builder.build dispatches correctly
             supertype_expression = if body[:supertype_expression]
@@ -55,10 +51,10 @@ module Expressir
           # Handle both formats:
           # - With item wrapper: {item: {operator: {...}, supertype_factor: {...}}}
           # - Without item wrapper: {operator: {...}, supertype_factor: {...}}
-          factors = [base_factor] + (ast_data[:rhs] || []).filter_map do |r|
+          factors = [base_factor] + Builder.ensure_array(ast_data[:rhs]).filter_map do |r|
             r[:item]&.dig(:supertype_factor) || r[:supertype_factor]
           end
-          operators = (ast_data[:rhs] || []).map do |r|
+          operators = Builder.ensure_array(ast_data[:rhs]).map do |r|
             (r[:item]&.dig(:operator) || r[:operator])&.values&.first
           end
 
@@ -83,10 +79,10 @@ module Expressir
           # Handle both formats:
           # - With item wrapper: {item: {operator: {...}, supertype_term: {...}}}
           # - Without item wrapper: {operator: {...}, supertype_term: {...}}
-          terms = [base_term] + (ast_data[:rhs] || []).filter_map do |r|
+          terms = [base_term] + Builder.ensure_array(ast_data[:rhs]).filter_map do |r|
             r[:item]&.dig(:supertype_term) || r[:supertype_term]
           end
-          operators = (ast_data[:rhs] || []).map do |r|
+          operators = Builder.ensure_array(ast_data[:rhs]).map do |r|
             (r[:item]&.dig(:operator) || r[:operator])&.values&.first
           end
 
@@ -160,29 +156,9 @@ module Expressir
 
         def build_subtype_declaration(ast_data)
           refs = ast_data[:entity_ref] || ast_data[:list_of_entity_ref]&.dig(:entity_ref)
-          Builder.build_children([refs].flatten.compact)
+          Builder.build_children(Builder.ensure_array(refs))
         end
       end
     end
   end
 end
-
-builder = Expressir::Express::Builders::SubtypeConstraintBuilder.new
-
-Builder.register(:subtype_constraint_decl) do |d|
-  builder.build_subtype_constraint_decl(d)
-end
-Builder.register(:total_over) { |d| builder.build_total_over(d) }
-Builder.register(:supertype_expression) do |d|
-  builder.build_supertype_expression(d)
-end
-Builder.register(:supertype_factor) { |d| builder.build_supertype_factor(d) }
-Builder.register(:supertype_term) { |d| builder.build_supertype_term(d) }
-Builder.register(:one_of) { |d| builder.build_one_of(d) }
-Builder.register(:supertype_rule) { |d| builder.build_supertype_rule(d) }
-Builder.register(:subtype_constraint) do |d|
-  builder.build_subtype_constraint(d)
-end
-Builder.register(:subtype_declaration) do |d|
-  builder.build_subtype_declaration(d)
-end

data/lib/expressir/express/builders/syntax_builder.rb

@@ -1,19 +1,72 @@
 # frozen_string_literal: true
 
-require_relative "helpers"
-
 module Expressir
   module Express
     module Builders
-      # Builds syntax (top-level) nodes into Repository objects.
+      # Builds syntax (top-level) nodes into ExpFile objects.
+      # Each parsed EXPRESS file is represented as an ExpFile containing schemas.
       class SyntaxBuilder
+        # Build ExpFile from AST data
+        # @param ast_data [Hash, Array] The parsed AST with syntax node
+        #   - Ruby parser: Hash with :schema_decl key
+        #   - Native parser: Hash with :syntax wrapper containing :schemaDecl
+        # @return [Model::ExpFile] ExpFile containing the parsed schemas
         def call(ast_data)
-          schemas = Builder.build_children(ast_data[:schema_decl])
-          Expressir::Model::Repository.new(schemas: schemas.compact)
+          # Handle both formats:
+          # - Ruby parser: ast_data is a merged Hash {:schema_decl => [...], :spaces => {...}}
+          # - Native parser: ast_data is {:syntax => {:spaces, :schemaDecl => [...], :trailer}}
+          schema_decl_data = extract_schema_decls(ast_data)
+
+          schemas = Builder.build_children(schema_decl_data)
+          Expressir::Model::ExpFile.new(schemas: schemas.compact)
+        end
+
+        private
+
+        # Extract schema declarations from AST data.
+        # Handles both Ruby (snake_case) and native (camelCase) formats.
+        def extract_schema_decls(ast_data)
+          if ast_data.is_a?(Hash)
+            # Check for :syntax wrapper (native parser format)
+            if ast_data.key?(:syntax)
+              inner = ast_data[:syntax]
+              return inner[:schemaDecl] || inner[:schema_decl] if inner.is_a?(Hash)
+            end
+
+            # Ruby parser format: snake_case
+            return ast_data[:schema_decl] if ast_data.key?(:schema_decl)
+
+            # Native parser format: camelCase at top level (legacy)
+            return ast_data[:schemaDecl] if ast_data.key?(:schemaDecl)
+          elsif ast_data.is_a?(Array)
+            # Legacy native parser format: Array of Hashes
+            merged = {}
+            ast_data.each do |item|
+              if item.is_a?(Hash)
+                item.each do |_key, value|
+                  if value.is_a?(Array)
+                    value.each do |sub|
+                      if sub.is_a?(Hash)
+                        sub.each do |k, v|
+                          snake_key = k.to_s
+                            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                            .downcase
+                            .to_sym
+                          merged[snake_key] ||= []
+                          merged[snake_key] = v if v.is_a?(Array)
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+            return merged[:schema_decl]
+          end
+          nil
         end
       end
     end
   end
 end
-
-Builder.register(:syntax, Expressir::Express::Builders::SyntaxBuilder.new)

data/lib/expressir/express/builders/type_builder.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
-require_relative "helpers"
-
 module Expressir
   module Express
     module Builders
       # Builds data type nodes (enumeration, select, array, bag, list, set, etc.).
       class TypeBuilder
-        include Helpers
+        include ::Expressir::Express::Builders::Helpers
 
         # Simple types
         {
@@ -128,7 +126,7 @@ module Expressir
             if items_data
               items_data = items_data[:enumeration_item] if items_data.is_a?(Hash) && items_data[:enumeration_item]
               items_data = [items_data] unless items_data.is_a?(Array)
-              items = items_data.flatten.compact.filter_map do |item|
+              items = items_data.filter_map do |item|
                 actual_item = item.is_a?(Hash) ? (item[:enumeration_item] || item) : item
                 Builder.build({ enumeration_item: actual_item })
               end
@@ -144,7 +142,7 @@ module Expressir
               if items_data
                 items_data = items_data[:enumeration_item] if items_data.is_a?(Hash) && items_data[:enumeration_item]
                 items_data = [items_data] unless items_data.is_a?(Array)
-                items = items_data.flatten.compact.filter_map do |item|
+                items = items_data.filter_map do |item|
                   actual_item = item.is_a?(Hash) ? (item[:enumeration_item] || item) : item
                   Builder.build({ enumeration_item: actual_item })
                 end
@@ -222,43 +220,3 @@ module Expressir
     end
   end
 end
-
-builder = Expressir::Express::Builders::TypeBuilder.new
-
-# Simple types
-%i[boolean_type integer_type logical_type number_type].each do |type|
-  Builder.register(type) { |d| builder.send(:"build_#{type}", d) }
-end
-Builder.register(:generic_type) { |_d| Expressir::Model::DataTypes::Generic.new }
-Builder.register(:generic_entity_type) { |_d| Expressir::Model::DataTypes::GenericEntity.new }
-Builder.register(:aggregate_type) { |_d| Expressir::Model::DataTypes::Aggregate.new }
-Builder.register(:general_set_type) { |d| builder.build_general_set_type(d) }
-Builder.register(:general_list_type) { |d| builder.build_general_list_type(d) }
-Builder.register(:general_bag_type) { |d| builder.build_general_bag_type(d) }
-Builder.register(:general_array_type) { |d| builder.build_general_array_type(d) }
-
-Builder.register(:string_type) { |d| builder.build_string_type(d) }
-Builder.register(:binary_type) { |d| builder.build_binary_type(d) }
-Builder.register(:real_type) { |d| builder.build_real_type(d) }
-Builder.register(:array_type) { |d| builder.build_array_type(d) }
-Builder.register(:bag_type) { |d| builder.build_bag_type(d) }
-Builder.register(:list_type) { |d| builder.build_list_type(d) }
-Builder.register(:set_type) { |d| builder.build_set_type(d) }
-Builder.register(:enumeration_type) { |d| builder.build_enumeration_type(d) }
-Builder.register(:enumeration_item) { |d| builder.build_enumeration_item(d) }
-Builder.register(:select_type) { |d| builder.build_select_type(d) }
-
-# Type wrappers
-%i[concrete_types simple_types aggregation_types constructed_types
-   generalized_types named_types instantiable_type parameter_type
-   underlying_type general_aggregation_types].each do |type|
-  Builder.register(type) { |d| builder.build_type_wrapper(d) }
-end
-
-# Bound handlers
-Builder.register(:bound1) { |d| Builder.build_optional(d[:numeric_expression]) }
-Builder.register(:bound2) { |d| Builder.build_optional(d[:numeric_expression]) }
-Builder.register(:width_spec) do |d|
-  { width: Builder.build_optional(d[:width]), fixed: !d[:t_fixed].nil? }
-end
-Builder.register(:width) { |d| Builder.build_optional(d[:numeric_expression]) }

data/lib/expressir/express/builders/type_decl_builder.rb

@@ -1,14 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "helpers"
-
 module Expressir
   module Express
     module Builders
       # Builds type_decl nodes.
       class TypeDeclBuilder
-        include Helpers
-
         def call(ast_data)
           id = Builder.build_optional(ast_data[:type_id])
           underlying_type = Builder.build_optional(ast_data[:underlying_type])
@@ -21,12 +17,10 @@ module Expressir
           Expressir::Model::Declarations::Type.new(
             id: id,
             underlying_type: underlying_type,
-            where_rules: [where_rules].flatten.compact,
+            where_rules: [where_rules].flatten,
           )
         end
       end
     end
   end
 end
-
-Builder.register(:type_decl, Expressir::Express::Builders::TypeDeclBuilder.new)

data/lib/expressir/express/builders/unique_clause_builder.rb

@@ -10,7 +10,7 @@ module Expressir
           return [] unless rules_data
 
           rules_data = [rules_data] if rules_data.is_a?(Hash)
-          rules_data.flatten.compact.filter_map do |rule|
+          Builder.ensure_array(rules_data).filter_map do |rule|
             Builder.build({ unique_rule: rule })
           end
         end
@@ -18,5 +18,3 @@ module Expressir
     end
   end
 end
-
-Builder.register(:unique_clause, Expressir::Express::Builders::UniqueClauseBuilder.new)

data/lib/expressir/express/builders/unique_rule_builder.rb

@@ -32,5 +32,3 @@ module Expressir
     end
   end
 end
-
-Builder.register(:unique_rule, Expressir::Express::Builders::UniqueRuleBuilder.new)

data/lib/expressir/express/builders/where_clause_builder.rb

@@ -10,7 +10,7 @@ module Expressir
           return [] unless rules_data
 
           rules_data = [rules_data] if rules_data.is_a?(Hash)
-          rules_data.flatten.compact.filter_map do |rule|
+          Builder.ensure_array(rules_data).filter_map do |rule|
             Builder.build({ domain_rule: rule })
           end
         end
@@ -18,5 +18,3 @@ module Expressir
     end
   end
 end
-
-Builder.register(:where_clause, Expressir::Express::Builders::WhereClauseBuilder.new)

data/lib/expressir/express/builders.rb

@@ -5,39 +5,51 @@
 # Each builder class registers itself with Builder.register.
 
 # Ensure Expressir module and autoloads are set up first
-require_relative "../../expressir"
+module Expressir
+  module Express
+    module Builders
+      autoload :Helpers, "#{__dir__}/builders/helpers"
 
-require_relative "builders/helpers"
-require_relative "builders/token_builder"
-require_relative "builders/simple_id_builder"
-require_relative "builders/syntax_builder"
-require_relative "builders/schema_version_builder"
-require_relative "builders/declaration_builder"
-require_relative "builders/schema_body_decl_builder"
-require_relative "builders/schema_decl_builder"
-require_relative "builders/entity_decl_builder"
-require_relative "builders/explicit_attr_builder"
-require_relative "builders/attribute_decl_builder"
-require_relative "builders/derive_clause_builder"
-require_relative "builders/derived_attr_builder"
-require_relative "builders/inverse_clause_builder"
-require_relative "builders/inverse_attr_builder"
-require_relative "builders/inverse_attr_type_builder"
-require_relative "builders/unique_clause_builder"
-require_relative "builders/unique_rule_builder"
-require_relative "builders/where_clause_builder"
-require_relative "builders/domain_rule_builder"
-require_relative "builders/reference_builder"
-require_relative "builders/literal_builder"
-require_relative "builders/type_decl_builder"
-require_relative "builders/type_builder"
-require_relative "builders/expression_builder"
-require_relative "builders/statement_builder"
-require_relative "builders/function_decl_builder"
-require_relative "builders/procedure_decl_builder"
-require_relative "builders/rule_decl_builder"
-require_relative "builders/subtype_constraint_builder"
-require_relative "builders/interface_builder"
-require_relative "builders/constant_builder"
-require_relative "builders/qualifier_builder"
-require_relative "builders/built_in_builder"
+      autoload :TokenBuilder, "#{__dir__}/builders/token_builder"
+      autoload :SimpleIdBuilder, "#{__dir__}/builders/simple_id_builder"
+      autoload :SyntaxBuilder, "#{__dir__}/builders/syntax_builder"
+      autoload :SchemaVersionBuilder,
+               "#{__dir__}/builders/schema_version_builder"
+      autoload :DeclarationBuilder, "#{__dir__}/builders/declaration_builder"
+      autoload :SchemaBodyDeclBuilder,
+               "#{__dir__}/builders/schema_body_decl_builder"
+      autoload :SchemaDeclBuilder, "#{__dir__}/builders/schema_decl_builder"
+      autoload :EntityDeclBuilder, "#{__dir__}/builders/entity_decl_builder"
+      autoload :ExplicitAttrBuilder, "#{__dir__}/builders/explicit_attr_builder"
+      autoload :AttributeDeclBuilder,
+               "#{__dir__}/builders/attribute_decl_builder"
+      autoload :DeriveClauseBuilder, "#{__dir__}/builders/derive_clause_builder"
+      autoload :DerivedAttrBuilder, "#{__dir__}/builders/derived_attr_builder"
+      autoload :InverseClauseBuilder,
+               "#{__dir__}/builders/inverse_clause_builder"
+      autoload :InverseAttrBuilder, "#{__dir__}/builders/inverse_attr_builder"
+      autoload :InverseAttrTypeBuilder,
+               "#{__dir__}/builders/inverse_attr_type_builder"
+      autoload :UniqueClauseBuilder, "#{__dir__}/builders/unique_clause_builder"
+      autoload :UniqueRuleBuilder, "#{__dir__}/builders/unique_rule_builder"
+      autoload :WhereClauseBuilder, "#{__dir__}/builders/where_clause_builder"
+      autoload :DomainRuleBuilder, "#{__dir__}/builders/domain_rule_builder"
+      autoload :ReferenceBuilder, "#{__dir__}/builders/reference_builder"
+      autoload :LiteralBuilder, "#{__dir__}/builders/literal_builder"
+      autoload :TypeDeclBuilder, "#{__dir__}/builders/type_decl_builder"
+      autoload :TypeBuilder, "#{__dir__}/builders/type_builder"
+      autoload :ExpressionBuilder, "#{__dir__}/builders/expression_builder"
+      autoload :StatementBuilder, "#{__dir__}/builders/statement_builder"
+      autoload :FunctionDeclBuilder, "#{__dir__}/builders/function_decl_builder"
+      autoload :ProcedureDeclBuilder,
+               "#{__dir__}/builders/procedure_decl_builder"
+      autoload :RuleDeclBuilder, "#{__dir__}/builders/rule_decl_builder"
+      autoload :SubtypeConstraintBuilder,
+               "#{__dir__}/builders/subtype_constraint_builder"
+      autoload :InterfaceBuilder, "#{__dir__}/builders/interface_builder"
+      autoload :ConstantBuilder, "#{__dir__}/builders/constant_builder"
+      autoload :QualifierBuilder, "#{__dir__}/builders/qualifier_builder"
+      autoload :BuiltInBuilder, "#{__dir__}/builders/built_in_builder"
+    end
+  end
+end