expressir 2.1.30 → 2.2.0

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds derived_attr nodes.
+      class DerivedAttrBuilder
+        def call(ast_data)
+          attr_decl_data = ast_data[:attribute_decl]
+          attr = if attr_decl_data.is_a?(Hash)
+                   Builder.build({ attribute_decl: attr_decl_data })
+                 end
+          type = Builder.build_optional(ast_data[:parameter_type])
+          expression = Builder.build_optional(ast_data[:expression])
+
+          Expressir::Model::Declarations::DerivedAttribute.new(
+            id: attr&.id,
+            supertype_attribute: attr&.supertype_attribute,
+            type: type,
+            expression: expression,
+          )
+        end
+      end
+    end
+  end
+end
+
+Builder.register(:derived_attr, Expressir::Express::Builders::DerivedAttrBuilder.new)

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds domain_rule nodes.
+      class DomainRuleBuilder
+        def call(ast_data)
+          inner_data = ast_data[:domain_rule] || ast_data
+
+          id = Builder.build_optional(inner_data[:rule_label_id])
+          expression = Builder.build_optional(inner_data[:expression])
+          Expressir::Model::Declarations::WhereRule.new(id: id,
+                                                        expression: expression)
+        end
+      end
+    end
+  end
+end
+
+Builder.register(:domain_rule, Expressir::Express::Builders::DomainRuleBuilder.new)

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

@@ -0,0 +1,108 @@
+# 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]
+
+          return nil unless entity_head
+
+          id = Builder.build_optional(entity_head[:entity_id])
+          subsuper = entity_head[:subsuper]
+
+          abstract = false
+          supertype_expression = nil
+          subtype_of = []
+
+          if subsuper.is_a?(Hash)
+            supertype_constraint = subsuper[:supertype_constraint]
+            subtype_declaration = subsuper[:subtype_declaration]
+
+            if supertype_constraint.is_a?(Hash)
+              abstract_entity = supertype_constraint[:abstract_entity_declaration]
+              abstract_supertype = supertype_constraint[:abstract_supertype_declaration]
+              supertype_rule = supertype_constraint[:supertype_rule]
+
+              abstract = !abstract_entity.nil? || !abstract_supertype.nil?
+
+              if supertype_rule.is_a?(Hash)
+                supertype_expression = Builder.build({ supertype_rule: supertype_rule })
+              elsif abstract_supertype.is_a?(Hash) && abstract_supertype[:subtype_constraint]
+                subtype_constraint = abstract_supertype[:subtype_constraint]
+                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)
+                  supertype_expression = entity_refs.first if entity_refs.length == 1
+                end
+              end
+            end
+
+            if subtype_declaration.is_a?(Hash)
+              list_ref = subtype_declaration[:list_of_entity_ref]
+              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)
+                end
+              end
+            end
+          end
+
+          attributes = []
+          unique_rules = []
+          where_rules = []
+
+          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)
+            end
+
+            if entity_body[:derive_clause]
+              derived = Builder.build({ derive_clause: entity_body[:derive_clause] })
+              attributes.concat([derived].flatten.compact) if derived
+            end
+
+            if entity_body[:inverse_clause]
+              inverse = Builder.build({ inverse_clause: entity_body[:inverse_clause] })
+              attributes.concat([inverse].flatten.compact) if inverse
+            end
+
+            if entity_body[:unique_clause]
+              unique_rules = Builder.build({ unique_clause: entity_body[:unique_clause] })
+            end
+            unique_rules ||= []
+
+            if entity_body[:where_clause]
+              where_rules = Builder.build({ where_clause: entity_body[:where_clause] })
+            end
+            where_rules ||= []
+          end
+
+          entity_params = {
+            id: id,
+            supertype_expression: supertype_expression,
+            subtype_of: subtype_of,
+            attributes: attributes,
+            unique_rules: [unique_rules].flatten.compact,
+            where_rules: [where_rules].flatten.compact,
+          }
+          entity_params[:abstract] = true if abstract
+
+          Expressir::Model::Declarations::Entity.new(**entity_params)
+        end
+      end
+    end
+  end
+end
+
+Builder.register(:entity_decl, Expressir::Express::Builders::EntityDeclBuilder.new)

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

@@ -0,0 +1,52 @@
+# 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)
+                             list_data[:attribute_decl]
+                           elsif list_data.is_a?(Array)
+                             list_data.filter_map do |item|
+                               item[:attribute_decl] if item.is_a?(Hash)
+                             end
+                           else
+                             ast_data[:attribute_decl]
+                           end
+          attr_decls = [attr_decl_data].flatten.compact
+          optional = !ast_data[:t_optional].nil?
+          type = Builder.build_optional(ast_data[:parameter_type])
+
+          attrs = attr_decls.map do |attr_data|
+            Builder.build({ attribute_decl: attr_data })
+          end
+
+          attrs.map do |attr|
+            next attr unless attr.is_a?(Expressir::Model::Declarations::Attribute)
+
+            attr_params = {
+              id: attr.id,
+              kind: Expressir::Model::Declarations::Attribute::EXPLICIT,
+              supertype_attribute: attr.supertype_attribute,
+              type: type,
+            }
+            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
+            Expressir::Model::Declarations::Attribute.new(**attr_params)
+          end
+        end
+      end
+    end
+  end
+end
+
+Builder.register(:explicit_attr, Expressir::Express::Builders::ExplicitAttrBuilder.new)

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

@@ -0,0 +1,453 @@
+# 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
+
+        # Expression
+        def build_expression(ast_data)
+          left = if ast_data[:simple_expression]
+                   Builder.build_simple_expression(ast_data[:simple_expression])
+                 elsif ast_data[:logical_expression]
+                   Builder.build_simple_expression(ast_data[:logical_expression][:simple_expression])
+                 end
+
+          if ast_data[:rel_op_extended] && ast_data[:rhs]
+            op = build_rel_op_extended(ast_data[:rel_op_extended])
+            right = Builder.build(ast_data[:rhs])
+            Expressir::Model::Expressions::BinaryExpression.new(
+              operator: op,
+              operand1: left,
+              operand2: right,
+            )
+          else
+            left
+          end
+        end
+
+        def build_logical_expression(ast_data)
+          Builder.build_simple_expression(ast_data[:simple_expression])
+        end
+
+        def build_numeric_expression(ast_data)
+          Builder.build_simple_expression(ast_data[:simple_expression])
+        end
+
+        # Simple expression (addition/subtraction chain)
+        def build_simple_expression(ast_data)
+          return nil unless ast_data[:term]
+
+          term = Builder.build_term(ast_data[:term])
+          rhs = ast_data[:rhs] || []
+
+          return term if rhs.empty?
+
+          operands = [term]
+          operators = []
+
+          rhs.each do |r|
+            item = r[:item] || r
+            op_data = item[:operator]
+            operators << extract_operator(op_data[:add_like_op]) if op_data
+            if item[:term]
+              operands << Builder.build_term(item[:term])
+            end
+          end
+
+          build_binary_expression(operands, operators)
+        end
+
+        # Term (multiplication/division chain)
+        def build_term(ast_data)
+          return nil unless ast_data[:factor]
+
+          factor = Builder.build_factor(ast_data[:factor])
+          rhs = ast_data[:rhs] || []
+
+          return factor if rhs.empty?
+
+          operands = [factor]
+          operators = []
+
+          rhs.each do |r|
+            item = r[:item] || r
+            op_data = item[:multiplication_like_op] || item[:mul_like_op]
+            operators << extract_operator(op_data) if op_data
+            operands << Builder.build_factor(item[:factor]) if item[:factor]
+          end
+
+          build_binary_expression(operands, operators)
+        end
+
+        def build_factor(ast_data)
+          return nil unless ast_data[:simple_factor]
+
+          Builder.build_simple_factor(ast_data[:simple_factor])
+        end
+
+        def build_simple_factor(ast_data)
+          return nil unless ast_data
+
+          if ast_data[:primary]
+            Builder.build_primary(ast_data[:primary])
+          elsif ast_data[:simple_factor_expression]
+            Builder.build_node(:simple_factor_expression,
+                               ast_data[:simple_factor_expression])
+          elsif ast_data[:simple_factor_unary_expression]
+            Builder.build_node(:simple_factor_unary_expression,
+                               ast_data[:simple_factor_unary_expression])
+          elsif ast_data[:constant_factor]
+            Builder.build_node(:constant_factor, ast_data[:constant_factor])
+          elsif ast_data[:expression]
+            Builder.build_expression(ast_data[:expression])
+          elsif ast_data[:aggregate_initializer]
+            Builder.build_node(:aggregate_initializer,
+                               ast_data[:aggregate_initializer])
+          elsif ast_data[:query_expression]
+            Builder.build_node(:query_expression, ast_data[:query_expression])
+          elsif ast_data[:entity_constructor]
+            Builder.build_node(:entity_constructor,
+                               ast_data[:entity_constructor])
+          elsif ast_data[:interval]
+            Builder.build_node(:interval, ast_data[:interval])
+          elsif ast_data[:string_literal]
+            Builder.build_node(:string_literal, ast_data[:string_literal])
+          elsif ast_data[:enumeration_reference]
+            Builder.build_node(:enumeration_reference,
+                               ast_data[:enumeration_reference])
+          end
+        end
+
+        def build_simple_factor_expression(ast_data)
+          if ast_data[:primary]
+            Builder.build_primary(ast_data[:primary])
+          elsif ast_data[:expression]
+            Builder.build_expression(ast_data[:expression])
+          end
+        end
+
+        def build_simple_factor_unary_expression(ast_data)
+          op = extract_unary_op(ast_data[:unary_op])
+          operand = if ast_data[:simple_factor]
+                      Builder.build_simple_factor(ast_data[:simple_factor])
+                    elsif ast_data[:simple_factor_expression]
+                      Builder.build_node(:simple_factor_expression,
+                                         ast_data[:simple_factor_expression])
+                    elsif ast_data[:primary]
+                      Builder.build_primary(ast_data[:primary])
+                    end
+
+          if op
+            Expressir::Model::Expressions::UnaryExpression.new(
+              operator: op,
+              operand: operand,
+            )
+          else
+            operand
+          end
+        end
+
+        def build_constant_factor(ast_data)
+          if ast_data[:built_in_constant]
+            Builder.build_node(:built_in_constant, ast_data[:built_in_constant])
+          elsif ast_data[:constant_ref]
+            Builder.build_node(:constant_ref, ast_data[:constant_ref])
+          end
+        end
+
+        def build_primary(ast_data)
+          if ast_data[:literal]
+            Builder.build_node(:literal, ast_data[:literal])
+          elsif ast_data[:qualifiable_factor]
+            build_qualifiable_factor(ast_data[:qualifiable_factor],
+                                     ast_data[:qualifier])
+          elsif ast_data[:population]
+            build_population(ast_data[:population], ast_data[:qualifier])
+          elsif ast_data[:expression]
+            Builder.build_expression(ast_data[:expression])
+          end
+        end
+
+        def build_qualifiable_factor(ast_data, qualifiers = nil)
+          ref = nil
+          if ast_data[:constant_factor]
+            ref = Builder.build_node(:constant_factor,
+                                     ast_data[:constant_factor])
+          elsif ast_data[:function_call]
+            ref = Builder.build_node(:function_call, ast_data[:function_call])
+          else
+            %i[constant_ref function_ref general_ref parameter_ref type_label_ref
+               variable_ref attribute_ref entity_ref type_ref enumeration_ref].each do |key|
+              if ast_data[key]
+                ref = Builder.build_node(key, ast_data[key])
+                break
+              end
+            end
+          end
+
+          return ref unless qualifiers
+
+          [qualifiers].flatten.compact.each do |qual|
+            qual_result = Builder.build_node(:qualifier, qual)
+            ref = apply_qualifier(ref, qual_result)
+          end
+          ref
+        end
+
+        def build_population(ast_data, qualifiers = nil)
+          ref = Builder.build_node(:entity_ref, ast_data[:entity_ref])
+          return ref unless qualifiers
+
+          [qualifiers].flatten.compact.each do |qual|
+            qual_result = Builder.build_node(:qualifier, qual)
+            ref = apply_qualifier(ref, qual_result)
+          end
+          ref
+        end
+
+        def build_qualifier(ast_data)
+          if ast_data[:attribute_qualifier]
+            Builder.build_node(:attribute_qualifier,
+                               ast_data[:attribute_qualifier])
+          elsif ast_data[:group_qualifier]
+            Builder.build_node(:group_qualifier, ast_data[:group_qualifier])
+          elsif ast_data[:index_qualifier]
+            Builder.build_node(:index_qualifier, ast_data[:index_qualifier])
+          end
+        end
+
+        def build_rel_op_extended(ast_data)
+          extract_rel_op(ast_data[:rel_op] || ast_data)
+        end
+
+        def build_binary_expression(operands, operators)
+          return operands.first if operands.length == 1
+          return nil if operands.empty? || operators.empty?
+
+          result = Expressir::Model::Expressions::BinaryExpression.new(
+            operator: operators.first,
+            operand1: operands.first,
+            operand2: operands[1],
+          )
+
+          (2...operands.length).each do |i|
+            result = Expressir::Model::Expressions::BinaryExpression.new(
+              operator: operators[i - 1],
+              operand1: result,
+              operand2: operands[i],
+            )
+          end
+          result
+        end
+
+        # Function call
+        def build_function_call(ast_data)
+          func_ref = if ast_data[:built_in_function]
+                       Builder.build_node(:built_in_function,
+                                          ast_data[:built_in_function])
+                     elsif ast_data[:function_ref]
+                       Builder.build_node(:function_ref,
+                                          ast_data[:function_ref])
+                     end
+
+          params = if ast_data[:actual_parameter_list]
+                     Builder.build_node(:actual_parameter_list,
+                                        ast_data[:actual_parameter_list])
+                   else
+                     []
+                   end
+
+          if params.empty?
+            func_ref
+          else
+            Expressir::Model::Expressions::FunctionCall.new(
+              function: func_ref,
+              parameters: [params].flatten.compact,
+            )
+          end
+        end
+
+        def build_actual_parameter_list(ast_data)
+          list_data = ast_data[:list_of_parameter] || ast_data[:parameter]
+
+          case list_data
+          when Hash
+            Builder.build_children(list_data[:parameter])
+          when Array
+            list_data.flat_map do |item|
+              if item.is_a?(Hash) && item[:parameter]
+                Builder.build_children(item[:parameter])
+              else
+                []
+              end
+            end
+          else
+            []
+          end
+        end
+
+        def build_parameter(ast_data)
+          Builder.build_optional(ast_data[:expression])
+        end
+
+        # Entity constructor
+        def build_entity_constructor(ast_data)
+          entity_ref = Builder.build_optional(ast_data[:entity_ref])
+          params = if ast_data[:actual_parameter_list]
+                     Builder.build_node(:actual_parameter_list,
+                                        ast_data[:actual_parameter_list])
+                   else
+                     []
+                   end
+
+          Expressir::Model::Expressions::FunctionCall.new(
+            function: entity_ref,
+            parameters: [params].flatten.compact,
+          )
+        end
+
+        # Query expression
+        def build_query_expression(ast_data)
+          var_id = Builder.build_optional(ast_data[:variable_id])
+          aggregate_source = Builder.build_optional(ast_data[:aggregate_source])
+          logical_expr = Builder.build_optional(ast_data[:logical_expression])
+
+          Expressir::Model::Expressions::QueryExpression.new(
+            id: var_id,
+            aggregate_source: aggregate_source,
+            expression: logical_expr,
+          )
+        end
+
+        def build_aggregate_source(ast_data)
+          Builder.build_optional(ast_data[:simple_expression])
+        end
+
+        # Aggregate initializer
+        def build_aggregate_initializer(ast_data)
+          list_data = ast_data[:list_of_element] || ast_data
+          elements = if list_data.is_a?(Array)
+                       list_data
+                     else
+                       list_data[:element]
+                     end
+
+          items = elements ? Builder.build_children(elements) : []
+          Expressir::Model::Expressions::AggregateInitializer.new(items: items.compact)
+        end
+
+        def build_element(ast_data)
+          expression = Builder.build_optional(ast_data[:expression])
+          repetition = Builder.build_optional(ast_data[:repetition])
+
+          if repetition
+            Expressir::Model::Expressions::AggregateInitializerItem.new(
+              expression: expression,
+              repetition: repetition,
+            )
+          else
+            expression
+          end
+        end
+
+        def build_repetition(ast_data)
+          Builder.build_optional(ast_data[:numeric_expression])
+        end
+
+        # Interval
+        def build_interval(ast_data)
+          low = Builder.build_optional(ast_data[:interval_low])
+          item = Builder.build_optional(ast_data[:interval_item])
+          high = Builder.build_optional(ast_data[:interval_high])
+
+          op1 = extract_interval_op(ast_data[:interval_op])
+          op2_data = ast_data[:interval_op2]
+          op2 = if op2_data.is_a?(Hash) && op2_data[:interval_op]
+                  extract_interval_op(op2_data[:interval_op])
+                else
+                  extract_interval_op(op2_data)
+                end
+
+          Expressir::Model::Expressions::Interval.new(
+            low: low,
+            operator1: op1,
+            item: item,
+            operator2: op2,
+            high: high,
+          )
+        end
+
+        def build_interval_low(ast_data)
+          Builder.build_optional(ast_data[:simple_expression])
+        end
+
+        def build_interval_high(ast_data)
+          Builder.build_optional(ast_data[:simple_expression])
+        end
+
+        def build_interval_item(ast_data)
+          Builder.build_optional(ast_data[:simple_expression])
+        end
+      end
+    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) }