expressir 2.2.0 → 2.3.0

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

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

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

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

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

@@ -24,5 +24,3 @@ module Expressir
     end
   end
 end
-
-Builder.register(:derived_attr, Expressir::Express::Builders::DerivedAttrBuilder.new)

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

@@ -17,5 +17,3 @@ module Expressir
     end
   end
 end
-
-Builder.register(:domain_rule, Expressir::Express::Builders::DomainRuleBuilder.new)

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

@@ -1,14 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "helpers"
-
 module Expressir
   module Express
     module Builders
       # Builds entity_decl nodes into Entity objects.
       class EntityDeclBuilder
-        include Helpers
-
         def call(ast_data)
           entity_head = ast_data[:entity_head]
           entity_body = ast_data[:entity_body]
@@ -40,7 +36,7 @@ module Expressir
                 if subtype_constraint[:supertype_expression]
                   supertype_expression = Builder.build({ supertype_expression: subtype_constraint[:supertype_expression] })
                 elsif subtype_constraint[:list_of_entity_ref]
-                  entity_refs = Builder.build_children([subtype_constraint[:list_of_entity_ref][:entity_ref]].flatten.compact)
+                  entity_refs = Builder.build_children(Builder.ensure_array(subtype_constraint[:list_of_entity_ref][:entity_ref]).map { |d| { entity_ref: d } })
                   supertype_expression = entity_refs.first if entity_refs.length == 1
                 end
               end
@@ -51,7 +47,7 @@ module Expressir
               if list_ref.is_a?(Hash)
                 entity_ref_data = list_ref[:entity_ref]
                 if entity_ref_data
-                  subtype_of = Builder.build_children([{ entity_ref: entity_ref_data }].flatten.compact)
+                  subtype_of = Builder.build_children(Builder.ensure_array(entity_ref_data).map { |d| { entity_ref: d } })
                 end
               end
             end
@@ -64,17 +60,17 @@ module Expressir
           if entity_body.is_a?(Hash)
             if entity_body[:explicit_attr]
               explicit_attrs = Builder.build_children(entity_body[:explicit_attr])
-              attributes.concat(explicit_attrs.flatten.compact)
+              attributes.concat(explicit_attrs)
             end
 
             if entity_body[:derive_clause]
               derived = Builder.build({ derive_clause: entity_body[:derive_clause] })
-              attributes.concat([derived].flatten.compact) if derived
+              attributes.concat([derived]) if derived
             end
 
             if entity_body[:inverse_clause]
               inverse = Builder.build({ inverse_clause: entity_body[:inverse_clause] })
-              attributes.concat([inverse].flatten.compact) if inverse
+              attributes.concat([inverse]) if inverse
             end
 
             if entity_body[:unique_clause]
@@ -93,8 +89,8 @@ module Expressir
             supertype_expression: supertype_expression,
             subtype_of: subtype_of,
             attributes: attributes,
-            unique_rules: [unique_rules].flatten.compact,
-            where_rules: [where_rules].flatten.compact,
+            unique_rules: [unique_rules].flatten,
+            where_rules: [where_rules].flatten,
           }
           entity_params[:abstract] = true if abstract
 
@@ -104,5 +100,3 @@ module Expressir
     end
   end
 end
-
-Builder.register(:entity_decl, Expressir::Express::Builders::EntityDeclBuilder.new)

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

@@ -1,14 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "helpers"
-
 module Expressir
   module Express
     module Builders
       # Builds explicit_attr nodes.
       class ExplicitAttrBuilder
-        include Helpers
-
         def call(ast_data)
           list_data = ast_data[:list_of_attribute_decl]
           attr_decl_data = if list_data.is_a?(Hash)
@@ -20,7 +16,7 @@ module Expressir
                            else
                              ast_data[:attribute_decl]
                            end
-          attr_decls = [attr_decl_data].flatten.compact
+          attr_decls = Builder.ensure_array(attr_decl_data)
           optional = !ast_data[:t_optional].nil?
           type = Builder.build_optional(ast_data[:parameter_type])
 
@@ -40,7 +36,10 @@ module Expressir
             attr_params[:optional] = true if optional
             # Preserve source information from the intermediate object
             attr_params[:source] = attr.source if attr.source
-            attr_params[:source_offset] = attr.source_offset if attr.source_offset
+            if attr.source_offset
+              attr_params[:source_offset] =
+                attr.source_offset
+            end
             Expressir::Model::Declarations::Attribute.new(**attr_params)
           end
         end
@@ -48,5 +47,3 @@ module Expressir
     end
   end
 end
-
-Builder.register(:explicit_attr, Expressir::Express::Builders::ExplicitAttrBuilder.new)

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