expressir 2.3.5 → 2.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 055f0b5a07f8fdbd0f078d9010e4dc4d119058a0301016bf93254d86e96c38af
-  data.tar.gz: 5f340ae55403cb3115536299cacce02fb102661035b875e251975eb8334e06a8
+  metadata.gz: 6af1982d1df8fc35cf696c67614f670e45386121feb42b962290a8b40acbc7f6
+  data.tar.gz: c03425e140c7b68391efef97105a3c86124d4269a8bb564515b0e83596a62932
 SHA512:
-  metadata.gz: 0e6f194e91f9db5c9fdf5d1f25777a054e040dd015e66a7ba253503d80bdd73f04f872041cb3f7e6b415c0e9ff80660619c7ea7f1751de6ed0469bd73e7b2310
-  data.tar.gz: b49300bb99f04eea589b524affa6a96f4ba2dc37773c583042e047b2682b1e9eab64dbe2e9ce0dfbc37f47ddffb3d83c0240a03b72090654e8ed56d88db8c024
+  metadata.gz: a330cbcd461ed7099e473a4a3d8c689f238096afce4c581b35a198bc487ddf5bd7a8bb777af698b1553efc1950eb878aa03874cc0b6904cb451b95a128962998
+  data.tar.gz: 1c995702e07eb2756811f35cbde5dfad4f1d32452c77a45404d551a1bfce1e374789219c72be5383eb5f804cf4489aee05cb2e29def2245ddd2d40cf591fa4c3

data/lib/expressir/express/builder.rb

@@ -354,7 +354,7 @@ module Expressir
         end
 
         def attach_source_info(result, data)
-          return unless @source && result.is_a?(Model::ModelElement)
+          return unless @source && result.is_a?(Expressir::Model::ModelElement)
 
           source_info = extract_source_info(data)
           return unless source_info

data/lib/expressir/express/builder_registry.rb

@@ -181,18 +181,18 @@ module Expressir
       Builder.register(:interval_high) { |d| expression.build_interval_high(d) }
       Builder.register(:interval_item) { |d| expression.build_interval_item(d) }
       Builder.register(:interval_op) do |d|
-        expression.send(:extract_interval_op, d)
+        expression.extract_interval_op(d)
       end
 
       # Operators
       Builder.register(:add_like_op) do |d|
-        expression.send(:extract_operator, d)
+        expression.extract_operator(d)
       end
       Builder.register(:mul_like_op) do |d|
-        expression.send(:extract_operator, d)
+        expression.extract_operator(d)
       end
-      Builder.register(:unary_op) { |d| expression.send(:extract_unary_op, d) }
-      Builder.register(:rel_op) { |d| expression.send(:extract_rel_op, d) }
+      Builder.register(:unary_op) { |d| expression.extract_unary_op(d) }
+      Builder.register(:rel_op) { |d| expression.extract_rel_op(d) }
 
       # ========================================================================
       # Interface Builder (closures)
@@ -319,45 +319,20 @@ module Expressir
         subtype_constraint.build_total_over(d)
       end
 
-      Builder.register(:subtype_constraint_decl) do |d|
-        subtype_constraint.build_subtype_constraint_decl(d)
-      end
-      Builder.register(:total_over) do |d|
-        subtype_constraint.build_total_over(d)
-      end
-      Builder.register(:supertype_expression) do |d|
-        subtype_constraint.build_supertype_expression(d)
-      end
-      Builder.register(:supertype_factor) do |d|
-        subtype_constraint.build_supertype_factor(d)
-      end
-      Builder.register(:supertype_term) do |d|
-        subtype_constraint.build_supertype_term(d)
-      end
-      Builder.register(:one_of) { |d| subtype_constraint.build_one_of(d) }
-      Builder.register(:supertype_rule) do |d|
-        subtype_constraint.build_supertype_rule(d)
-      end
-      Builder.register(:subtype_constraint) do |d|
-        subtype_constraint.build_subtype_constraint(d)
-      end
-      Builder.register(:subtype_declaration) do |d|
-        subtype_constraint.build_subtype_declaration(d)
-      end
-
       # ========================================================================
       # Type Builder (closures)
       # ========================================================================
 
       # Simple types
-      %i[boolean_type integer_type logical_type number_type].each do |type|
-        Builder.register(type) { |d| type_builder.send(:"build_#{type}", d) }
-      end
+      Builder.register(:boolean_type) { |d| type_builder.build_boolean_type(d) }
+      Builder.register(:integer_type) { |d| type_builder.build_integer_type(d) }
+      Builder.register(:logical_type) { |d| type_builder.build_logical_type(d) }
+      Builder.register(:number_type) { |d| type_builder.build_number_type(d) }
 
       # Type constructors
       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(:aggregate_type) { |d| type_builder.build_aggregate_type(d) }
       Builder.register(:general_set_type) do |d|
         type_builder.build_general_set_type(d)
       end

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

@@ -36,7 +36,10 @@ module Expressir
           ids = if ids_data.is_a?(Hash)
                   [Builder.build({ variable_id: ids_data })]
                 elsif ids_data.is_a?(Array)
-                  ids_data.map { |id| Builder.build({ variable_id: id }) }
+                  ids_data.filter_map do |elem|
+                    actual_id = elem[:variable_id] || elem
+                    Builder.build({ variable_id: actual_id })
+                  end
                 else
                   []
                 end
@@ -64,7 +67,10 @@ module Expressir
           ids = if ids_data.is_a?(Hash)
                   [Builder.build({ parameter_id: ids_data })]
                 elsif ids_data.is_a?(Array)
-                  ids_data.map { |id| Builder.build({ parameter_id: id }) }
+                  ids_data.filter_map do |elem|
+                    actual_id = elem[:parameter_id] || elem
+                    Builder.build({ parameter_id: actual_id })
+                  end
                 else
                   []
                 end

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

@@ -62,7 +62,8 @@ module Expressir
 
           parameters = []
           Builder.ensure_array(params_data).each do |param|
-            result = Builder.build({ procedure_head_parameter: param })
+            actual_param = param[:procedure_head_parameter] || param
+            result = Builder.build({ procedure_head_parameter: actual_param })
             parameters.concat(Builder.ensure_array(result)) if result
           end
           parameters

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

@@ -85,12 +85,14 @@ module Expressir
         def build_case_stmt(ast_data)
           selector = Builder.build_optional(ast_data[:selector])
           actions = Builder.build_children(ast_data[:case_action])
-          otherwise = Builder.build_children(ast_data[:otherwise]&.dig(:stmt))
+          otherwise_stmt = if ast_data[:t_otherwise] && ast_data[:stmt].is_a?(Hash)
+                             Builder.build({ stmt: ast_data[:stmt] })
+                           end
 
           Expressir::Model::Statements::Case.new(
             expression: selector,
             actions: actions.compact,
-            otherwise: otherwise.compact,
+            otherwise_statement: otherwise_stmt,
           )
         end
 
@@ -101,12 +103,23 @@ module Expressir
         end
 
         def build_case_action(ast_data)
-          labels = Builder.build_children(ast_data[:case_label])
-          statements = Builder.build_children(ast_data[:stmt])
+          label_data = ast_data[:list_of_case_label]
+          labels = if label_data.is_a?(Hash)
+                     Builder.build_children(label_data[:case_label])
+                   elsif label_data.is_a?(Array)
+                     label_data.flat_map do |item|
+                       Builder.build_children(item.is_a?(Hash) ? item[:case_label] : item)
+                     end
+                   else
+                     []
+                   end
+          stmt = if ast_data[:stmt].is_a?(Hash)
+                   Builder.build({ stmt: ast_data[:stmt] })
+                 end
 
           Expressir::Model::Statements::CaseAction.new(
             labels: labels.compact,
-            statements: statements.compact,
+            statement: stmt,
           )
         end
 

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

@@ -7,18 +7,20 @@ module Expressir
       class TypeBuilder
         include ::Expressir::Express::Builders::Helpers
 
-        # Simple types
-        {
-          boolean_type: Expressir::Model::DataTypes::Boolean,
-          integer_type: Expressir::Model::DataTypes::Integer,
-          logical_type: Expressir::Model::DataTypes::Logical,
-          number_type: Expressir::Model::DataTypes::Number,
-          generic_type: Expressir::Model::DataTypes::Generic,
-          generic_entity_type: Expressir::Model::DataTypes::GenericEntity,
-        }.each do |type_name, klass|
-          define_method(:"build_#{type_name}") do |_ast_data|
-            klass.new
-          end
+        def build_boolean_type(_ast_data)
+          Expressir::Model::DataTypes::Boolean.new
+        end
+
+        def build_integer_type(_ast_data)
+          Expressir::Model::DataTypes::Integer.new
+        end
+
+        def build_logical_type(_ast_data)
+          Expressir::Model::DataTypes::Logical.new
+        end
+
+        def build_number_type(_ast_data)
+          Expressir::Model::DataTypes::Number.new
         end
 
         # String type
@@ -49,6 +51,12 @@ module Expressir
           end
         end
 
+        # Aggregate type (AGGREGATE OF type)
+        def build_aggregate_type(ast_data)
+          base_type = Builder.build_optional(ast_data[:parameter_type])
+          Expressir::Model::DataTypes::Aggregate.new(base_type: base_type)
+        end
+
         # Aggregation types
         def build_array_type(ast_data)
           build_aggregation_type(ast_data, Expressir::Model::DataTypes::Array)

data/lib/expressir/express/formatters/data_types_formatter.rb

@@ -4,8 +4,18 @@ module Expressir
       module DataTypesFormatter
         private
 
-        def format_data_types_aggregate(_node)
-          "AGGREGATE"
+        def format_data_types_aggregate(node)
+          [
+            "AGGREGATE",
+            *if node.base_type
+               [
+                 " ",
+                 "OF",
+                 " ",
+                 format(node.base_type),
+               ]
+             end,
+          ].join
         end
 
         def format_data_types_array(node)
@@ -257,7 +267,7 @@ module Expressir
                     ].join
                   end,
                ].join
-             else
+             elsif node.items&.length&.positive?
                indent_char = self.class.const_get(:INDENT_CHAR)
                item_indent = indent_char * "(".length
                [

data/lib/expressir/express/formatters/expressions_formatter.rb

@@ -24,9 +24,9 @@ module Expressir
         def format_expressions_binary_expression(node)
           operator_precedence = self.class.const_get(:OPERATOR_PRECEDENCE)
           op1_bin_exp = node.operand1.is_a?(Model::Expressions::BinaryExpression) &&
-            (operator_precedence[node.operand1.operator] > operator_precedence[node.operator])
+            (operator_precedence[node.operand1.operator] >= operator_precedence[node.operator])
           op2_bin_exp = node.operand2.is_a?(Model::Expressions::BinaryExpression) &&
-            (operator_precedence[node.operand2.operator] > operator_precedence[node.operator])
+            (operator_precedence[node.operand2.operator] >= operator_precedence[node.operator])
 
           [
             *if op1_bin_exp
@@ -138,6 +138,9 @@ module Expressir
         end
 
         def format_expressions_unary_expression(node)
+          needs_parens = node.operand.is_a?(Model::Expressions::BinaryExpression) ||
+            node.operand.is_a?(Model::Expressions::Interval)
+
           [
             case node.operator
             when Model::Expressions::UnaryExpression::MINUS then "-"
@@ -147,11 +150,11 @@ module Expressir
             if node.operator == Model::Expressions::UnaryExpression::NOT
               " "
             end,
-            *if node.operand.is_a? Model::Expressions::BinaryExpression
+            *if needs_parens
                "("
              end,
             format(node.operand),
-            *if node.operand.is_a? Model::Expressions::BinaryExpression
+            *if needs_parens
                ")"
              end,
           ].join

data/lib/expressir/express/formatters/literals_formatter.rb

@@ -5,10 +5,7 @@ module Expressir
         private
 
         def format_literals_binary(node)
-          [
-            "%",
-            node.value,
-          ].join
+          node.value
         end
 
         def format_literals_integer(node)

data/lib/expressir/express/remark_attacher.rb

@@ -525,7 +525,7 @@ module Expressir
       def find_target_in_where_clause(scope, tag, remark_line)
         return nil unless supports_where_rules?(scope)
 
-        where_rules = scope.where_rules
+        where_rules = safe_get_collection(scope, :where_rules)
         return nil unless where_rules&.any?
 
         # Search source text for WHERE clause containing this remark

data/lib/expressir/model/declarations/function.rb

@@ -6,7 +6,6 @@ module Expressir
       class Function < ModelElement
         include Identifier
         include ScopeContainer
-        include HasWhereRules
 
         attribute :parameters, Parameter, collection: true
         attribute :return_type, ModelElement

data/lib/expressir/model/declarations/procedure.rb

@@ -6,7 +6,6 @@ module Expressir
       class Procedure < ModelElement
         include Identifier
         include ScopeContainer
-        include HasWhereRules
 
         attribute :parameters, Parameter, collection: true
         attribute :types, ModelElement, collection: true

data/lib/expressir/version.rb

@@ -1,3 +1,3 @@
 module Expressir
-  VERSION = "2.3.5".freeze
+  VERSION = "2.3.6".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: expressir
 version: !ruby/object:Gem::Version
-  version: 2.3.5
+  version: 2.3.6
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-12 00:00:00.000000000 Z
+date: 2026-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64