expressir 2.2.1 → 2.3.0

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

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
-require_relative "helpers"
-
 module Expressir
   module Express
     module Builders
       # Builds expression nodes (binary, unary, query, interval, etc.).
       class ExpressionBuilder
-        include Helpers
+        include ::Expressir::Express::Builders::Helpers
 
         # Expression
         def build_expression(ast_data)
@@ -43,14 +41,24 @@ module Expressir
           return nil unless ast_data[:term]
 
           term = Builder.build_term(ast_data[:term])
-          rhs = ast_data[:rhs] || []
+          rhs = ast_data[:rhs]
+
+          return term if rhs.nil? || (rhs.respond_to?(:empty?) && rhs.empty?)
 
-          return term if rhs.empty?
+          # Handle both formats:
+          # - Ruby parser: rhs is Array of {:item => {...}} hashes
+          # - Native parser: rhs might be a Hash (merged) or Array
+          rhs_array = rhs.is_a?(Array) ? rhs : [rhs]
 
           operands = [term]
           operators = []
 
-          rhs.each do |r|
+          rhs_array.each do |r|
+            # Handle Hash.each yielding [key, value] arrays
+            r = r.last if r.is_a?(Array) && r.length == 2
+
+            next unless r.is_a?(Hash)
+
             item = r[:item] || r
             op_data = item[:operator]
             operators << extract_operator(op_data[:add_like_op]) if op_data
@@ -67,14 +75,24 @@ module Expressir
           return nil unless ast_data[:factor]
 
           factor = Builder.build_factor(ast_data[:factor])
-          rhs = ast_data[:rhs] || []
+          rhs = ast_data[:rhs]
+
+          return factor if rhs.nil? || (rhs.respond_to?(:empty?) && rhs.empty?)
 
-          return factor if rhs.empty?
+          # Handle both formats:
+          # - Ruby parser: rhs is Array of {:item => {...}} hashes
+          # - Native parser: rhs might be a Hash (merged) or Array
+          rhs_array = rhs.is_a?(Array) ? rhs : [rhs]
 
           operands = [factor]
           operators = []
 
-          rhs.each do |r|
+          rhs_array.each do |r|
+            # Handle Hash.each yielding [key, value] arrays
+            r = r.last if r.is_a?(Array) && r.length == 2
+
+            next unless r.is_a?(Hash)
+
             item = r[:item] || r
             op_data = item[:multiplication_like_op] || item[:mul_like_op]
             operators << extract_operator(op_data) if op_data
@@ -192,7 +210,7 @@ module Expressir
 
           return ref unless qualifiers
 
-          [qualifiers].flatten.compact.each do |qual|
+          Builder.ensure_array(qualifiers).each do |qual|
             qual_result = Builder.build_node(:qualifier, qual)
             ref = apply_qualifier(ref, qual_result)
           end
@@ -203,7 +221,7 @@ module Expressir
           ref = Builder.build_node(:entity_ref, ast_data[:entity_ref])
           return ref unless qualifiers
 
-          [qualifiers].flatten.compact.each do |qual|
+          Builder.ensure_array(qualifiers).each do |qual|
             qual_result = Builder.build_node(:qualifier, qual)
             ref = apply_qualifier(ref, qual_result)
           end
@@ -267,7 +285,7 @@ module Expressir
           else
             Expressir::Model::Expressions::FunctionCall.new(
               function: func_ref,
-              parameters: [params].flatten.compact,
+              parameters: params,
             )
           end
         end
@@ -307,7 +325,7 @@ module Expressir
 
           Expressir::Model::Expressions::FunctionCall.new(
             function: entity_ref,
-            parameters: [params].flatten.compact,
+            parameters: params,
           )
         end
 
@@ -397,57 +415,3 @@ module Expressir
     end
   end
 end
-
-builder = Expressir::Express::Builders::ExpressionBuilder.new
-
-Builder.register(:expression) { |d| builder.build_expression(d) }
-Builder.register(:logical_expression) do |d|
-  builder.build_logical_expression(d)
-end
-Builder.register(:numeric_expression) do |d|
-  builder.build_numeric_expression(d)
-end
-Builder.register(:simple_expression) { |d| builder.build_simple_expression(d) }
-Builder.register(:term) { |d| builder.build_term(d) }
-Builder.register(:factor) { |d| builder.build_factor(d) }
-Builder.register(:simple_factor) { |d| builder.build_simple_factor(d) }
-Builder.register(:simple_factor_expression) do |d|
-  builder.build_simple_factor_expression(d)
-end
-Builder.register(:simple_factor_unary_expression) do |d|
-  builder.build_simple_factor_unary_expression(d)
-end
-Builder.register(:constant_factor) { |d| builder.build_constant_factor(d) }
-Builder.register(:primary) { |d| builder.build_primary(d) }
-Builder.register(:qualifiable_factor) do |d|
-  builder.build_qualifiable_factor(d, nil)
-end
-Builder.register(:population) { |d| builder.build_population(d, nil) }
-Builder.register(:qualifier) { |d| builder.build_qualifier(d) }
-Builder.register(:rel_op_extended) { |d| builder.build_rel_op_extended(d) }
-Builder.register(:function_call) { |d| builder.build_function_call(d) }
-Builder.register(:actual_parameter_list) do |d|
-  builder.build_actual_parameter_list(d)
-end
-Builder.register(:parameter) { |d| builder.build_parameter(d) }
-Builder.register(:entity_constructor) do |d|
-  builder.build_entity_constructor(d)
-end
-Builder.register(:query_expression) { |d| builder.build_query_expression(d) }
-Builder.register(:aggregate_source) { |d| builder.build_aggregate_source(d) }
-Builder.register(:aggregate_initializer) do |d|
-  builder.build_aggregate_initializer(d)
-end
-Builder.register(:element) { |d| builder.build_element(d) }
-Builder.register(:repetition) { |d| builder.build_repetition(d) }
-Builder.register(:interval) { |d| builder.build_interval(d) }
-Builder.register(:interval_low) { |d| builder.build_interval_low(d) }
-Builder.register(:interval_high) { |d| builder.build_interval_high(d) }
-Builder.register(:interval_item) { |d| builder.build_interval_item(d) }
-Builder.register(:interval_op) { |d| builder.send(:extract_interval_op, d) }
-
-# Operators
-Builder.register(:add_like_op) { |d| builder.send(:extract_operator, d) }
-Builder.register(:mul_like_op) { |d| builder.send(:extract_operator, d) }
-Builder.register(:unary_op) { |d| builder.send(:extract_unary_op, d) }
-Builder.register(:rel_op) { |d| builder.send(:extract_rel_op, d) }

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

@@ -1,14 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "helpers"
-
 module Expressir
   module Express
     module Builders
       # Builds function declaration nodes.
       class FunctionDeclBuilder
-        include Helpers
-
         def call(ast_data)
           head = ast_data[:function_head]
           algorithm_head = ast_data[:algorithm_head]
@@ -23,13 +19,21 @@ 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)
 
           Expressir::Model::Declarations::Function.new(
@@ -41,8 +45,8 @@ module Expressir
             subtype_constraints: subtype_constraints,
             functions: functions,
             procedures: procedures,
-            constants: [constants].flatten.compact,
-            variables: [variables].flatten.compact,
+            constants: constants,
+            variables: variables,
             statements: statements.compact,
           )
         end
@@ -62,9 +66,9 @@ module Expressir
           end
 
           parameters = []
-          params_data.flatten.compact.each do |param|
+          Builder.ensure_array(params_data).each do |param|
             result = Builder.build({ formal_parameter: param })
-            parameters.concat([result].flatten.compact) if result
+            parameters.concat(Builder.ensure_array(result)) if result
           end
           parameters
         end
@@ -74,11 +78,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(:function_decl, Expressir::Express::Builders::FunctionDeclBuilder.new)

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

@@ -1,14 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "helpers"
-
 module Expressir
   module Express
     module Builders
       # Builds interface specification nodes (use/reference clauses).
       class InterfaceBuilder
-        include Helpers
-
         def build_interface_specification(ast_data)
           ast_data = ast_data[:interface_specification] if ast_data[:interface_specification]
           if ast_data[:reference_clause]
@@ -153,19 +149,3 @@ module Expressir
     end
   end
 end
-
-builder = Expressir::Express::Builders::InterfaceBuilder.new
-
-Builder.register(:interface_specification) do |d|
-  builder.build_interface_specification(d)
-end
-Builder.register(:use_clause) { |d| builder.build_use_clause(d) }
-Builder.register(:reference_clause) { |d| builder.build_reference_clause(d) }
-Builder.register(:named_type_or_rename) do |d|
-  builder.build_named_type_or_rename(d)
-end
-Builder.register(:resource_or_rename) do |d|
-  builder.build_resource_or_rename(d)
-end
-Builder.register(:resource_ref) { |d| builder.build_resource_ref(d) }
-Builder.register(:rename_id) { |d| builder.build_rename_id(d) }

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

@@ -41,5 +41,3 @@ module Expressir
     end
   end
 end
-
-Builder.register(:inverse_attr, Expressir::Express::Builders::InverseAttrBuilder.new)

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

@@ -1,14 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "helpers"
-
 module Expressir
   module Express
     module Builders
       # Builds inverse_attr_type nodes.
       class InverseAttrTypeBuilder
-        include Helpers
-
         def call(ast_data)
           bound_spec = ast_data[:bound_spec] || {}
           bound1 = Builder.build_optional(bound_spec[:bound1])
@@ -32,5 +28,3 @@ module Expressir
     end
   end
 end
-
-Builder.register(:inverse_attr_type, Expressir::Express::Builders::InverseAttrTypeBuilder.new)

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

@@ -12,5 +12,3 @@ module Expressir
     end
   end
 end
-
-Builder.register(:inverse_clause, Expressir::Express::Builders::InverseClauseBuilder.new)

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

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
-require_relative "helpers"
-
 module Expressir
   module Express
     module Builders
       # Builds literal nodes (integer, real, binary, logical, string).
       class LiteralBuilder
-        include Helpers
+        include ::Expressir::Express::Builders::Helpers
 
         # Integer literal
         def build_integer(ast_data)
@@ -93,15 +91,3 @@ module Expressir
     end
   end
 end
-
-builder = Expressir::Express::Builders::LiteralBuilder.new
-Builder.register(:integer_literal) { |d| builder.build_integer(d) }
-Builder.register(:real_literal) { |d| builder.build_real(d) }
-Builder.register(:binary_literal) { |d| builder.build_binary(d) }
-Builder.register(:logical_literal) { |d| builder.build_logical(d) }
-Builder.register(:string_literal) { |d| builder.build_string(d) }
-Builder.register(:simple_string_literal) { |d| builder.build_simple_string(d) }
-Builder.register(:encoded_string_literal) do |d|
-  builder.build_encoded_string(d)
-end
-Builder.register(:literal, builder)

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

@@ -1,14 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "helpers"
-
 module Expressir
   module Express
     module Builders
       # Builds procedure declaration nodes.
       class ProcedureDeclBuilder
-        include Helpers
-
         def call(ast_data)
           head = ast_data[:procedure_head]
           algorithm_head = ast_data[:algorithm_head]
@@ -22,13 +18,21 @@ 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)
 
           Expressir::Model::Declarations::Procedure.new(
@@ -39,8 +43,8 @@ module Expressir
             subtype_constraints: subtype_constraints,
             functions: functions,
             procedures: procedures,
-            constants: [constants].flatten.compact,
-            variables: [variables].flatten.compact,
+            constants: constants,
+            variables: variables,
             statements: statements.compact,
           )
         end
@@ -57,10 +61,9 @@ module Expressir
           end
 
           parameters = []
-          params_data = [params_data].flatten.compact
-          params_data.each do |param|
+          Builder.ensure_array(params_data).each do |param|
             result = Builder.build({ procedure_head_parameter: param })
-            parameters.concat([result].flatten.compact) if result
+            parameters.concat(Builder.ensure_array(result)) if result
           end
           parameters
         end
@@ -70,11 +73,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(:procedure_decl, Expressir::Express::Builders::ProcedureDeclBuilder.new)

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

@@ -1,14 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "helpers"
-
 module Expressir
   module Express
     module Builders
       # Builds qualifier nodes (attribute, group, index qualifiers).
       class QualifierBuilder
-        include Helpers
-
         def build_redeclared_attribute(ast_data)
           qualified_attr = ast_data[:qualified_attribute]
           if qualified_attr.is_a?(Hash)
@@ -103,26 +99,3 @@ module Expressir
     end
   end
 end
-
-builder = Expressir::Express::Builders::QualifierBuilder.new
-
-Builder.register(:redeclared_attribute) do |d|
-  builder.build_redeclared_attribute(d)
-end
-Builder.register(:referenced_attribute) do |d|
-  builder.build_referenced_attribute(d)
-end
-Builder.register(:qualified_attribute) do |d|
-  builder.build_qualified_attribute(d)
-end
-Builder.register(:group_qualifier) { |d| builder.build_group_qualifier(d) }
-Builder.register(:attribute_qualifier) do |d|
-  builder.build_attribute_qualifier(d)
-end
-Builder.register(:index_qualifier) { |d| builder.build_index_qualifier(d) }
-Builder.register(:index1) { |d| builder.build_index1(d) }
-Builder.register(:index2) { |d| builder.build_index2(d) }
-Builder.register(:index) { |d| builder.build_index(d) }
-Builder.register(:enumeration_reference) do |d|
-  builder.build_enumeration_reference(d)
-end

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

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
-require_relative "helpers"
-
 module Expressir
   module Express
     module Builders
       # Builds reference nodes (attribute_ref, entity_ref, etc.).
       # Returns SimpleReference for all reference types.
       class ReferenceBuilder
-        include Helpers
+        include ::Expressir::Express::Builders::Helpers
 
         def call(ast_data)
           id = extract_id_ref(ast_data)
@@ -18,10 +16,3 @@ module Expressir
     end
   end
 end
-
-# Register for all reference types
-%i[attribute_ref constant_ref entity_ref enumeration_ref function_ref
-   parameter_ref procedure_ref rule_ref rule_label_ref schema_ref
-   subtype_constraint_ref type_label_ref type_ref variable_ref].each do |ref_type|
-  Builder.register(ref_type, Expressir::Express::Builders::ReferenceBuilder.new)
-end

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)