expressir 2.3.4 → 2.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e990830fa008a30ebb6b937e503030069e175b329ff44f3eebe212adaa5066b
-  data.tar.gz: 6f84bc382c6e49c6402298a5e1f6557343ad6864e7dfa5364bc52e4467fc6cf3
+  metadata.gz: 6af1982d1df8fc35cf696c67614f670e45386121feb42b962290a8b40acbc7f6
+  data.tar.gz: c03425e140c7b68391efef97105a3c86124d4269a8bb564515b0e83596a62932
 SHA512:
-  metadata.gz: ae27b6f9b65e7622db436d3658867ce76587884b215b0a6f74954740c0110ae957b8ed35c887a7ebeda0c91ea7db4b30bb23836da21730e5cba296a7b2bfc9dd
-  data.tar.gz: 362a01b5e21d36d050ec1049f626a44bb0e62cd2ced0cd74c5581faee4f9903313fe5aaefff20df5c2c814979df4bc806ef621b23cbdb9af71831128485cbc33
+  metadata.gz: a330cbcd461ed7099e473a4a3d8c689f238096afce4c581b35a198bc487ddf5bd7a8bb777af698b1553efc1950eb878aa03874cc0b6904cb451b95a128962998
+  data.tar.gz: 1c995702e07eb2756811f35cbde5dfad4f1d32452c77a45404d551a1bfce1e374789219c72be5383eb5f804cf4489aee05cb2e29def2245ddd2d40cf591fa4c3

data/.gitignore

@@ -24,3 +24,19 @@
 _site/
 
 Gemfile.lock
+
+# Claude Code
+.claude/
+
+# Development / transient files
+*.ler
+*.pax
+TODO.*.md
+debug_*.rb
+measure_mem.rb
+tmp_*.rb
+mise.toml
+Gemfile.local
+Gemfile.local.lock
+Gemfile.original
+benchmark/

data/.rubocop_todo.yml

@@ -1,20 +1,12 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2026-05-11 08:18:39 UTC using RuboCop version 1.86.0.
+# on 2026-05-12 14:41:49 UTC using RuboCop version 1.86.0.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 
-# Offense count: 4
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: EnforcedStyle, IndentationWidth.
-# SupportedStyles: with_first_argument, with_fixed_indentation
-Layout/ArgumentAlignment:
-  Exclude:
-    - 'lib/expressir/express/remark_attacher.rb'
-
-# Offense count: 1082
+# Offense count: 1084
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: Max, AllowHeredoc, AllowURI, AllowQualifiedName, URISchemes, AllowRBSInlineAnnotation, AllowCopDirectives, AllowedPatterns, SplitStrings.
 # URISchemes: http, https
@@ -80,7 +72,7 @@ Metrics/BlockNesting:
 Metrics/CyclomaticComplexity:
   Enabled: false
 
-# Offense count: 287
+# Offense count: 289
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 Metrics/MethodLength:
   Max: 167

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

@@ -12,7 +12,9 @@ module Expressir
         def build_constant_body(ast_data)
           id = Builder.build_optional(ast_data[:constant_id])
           type = Builder.build_optional(ast_data[:instantiable_type])
-          expression = Builder.build_optional(ast_data[:expression])
+          expression = if ast_data[:expression]
+                         Builder.build({ expression: ast_data[:expression] })
+                       end
 
           Expressir::Model::Declarations::Constant.new(id: id, type: type,
                                                        expression: expression)
@@ -34,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
@@ -62,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/derived_attr_builder.rb

@@ -11,7 +11,9 @@ module Expressir
                    Builder.build({ attribute_decl: attr_decl_data })
                  end
           type = Builder.build_optional(ast_data[:parameter_type])
-          expression = Builder.build_optional(ast_data[:expression])
+          expression = if ast_data[:expression]
+                         Builder.build({ expression: ast_data[:expression] })
+                       end
 
           Expressir::Model::Declarations::DerivedAttribute.new(
             id: attr&.id,

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

@@ -9,7 +9,9 @@ module Expressir
           inner_data = ast_data[:domain_rule] || ast_data
 
           id = Builder.build_optional(inner_data[:rule_label_id])
-          expression = Builder.build_optional(inner_data[:expression])
+          expression = if inner_data[:expression]
+                         Builder.build({ expression: inner_data[:expression] })
+                       end
           Expressir::Model::Declarations::WhereRule.new(id: id,
                                                         expression: expression)
         end

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

@@ -223,13 +223,14 @@ module Expressir
         end
 
         def build_qualifier(ast_data)
-          if ast_data[:attribute_qualifier]
+          data = ast_data[:qualifier] || ast_data
+          if 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])
+                               data[:attribute_qualifier])
+          elsif data[:group_qualifier]
+            Builder.build_node(:group_qualifier, data[:group_qualifier])
+          elsif data[:index_qualifier]
+            Builder.build_node(:index_qualifier, data[:index_qualifier])
           end
         end
 
@@ -304,7 +305,9 @@ module Expressir
         end
 
         def build_parameter(ast_data)
-          Builder.build_optional(ast_data[:expression])
+          if ast_data[:expression]
+            Builder.build({ expression: ast_data[:expression] })
+          end
         end
 
         # Entity constructor
@@ -354,7 +357,9 @@ module Expressir
         end
 
         def build_element(ast_data)
-          expression = Builder.build_optional(ast_data[:expression])
+          expression = if ast_data[:expression]
+                         Builder.build({ expression: ast_data[:expression] })
+                       end
           repetition = Builder.build_optional(ast_data[:repetition])
 
           if repetition

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

@@ -138,6 +138,12 @@ module Expressir
           when Expressir::Model::References::IndexReference
             Expressir::Model::References::IndexReference.new(ref: ref,
                                                              index1: qualifier.index1, index2: qualifier.index2)
+          when Expressir::Model::References::SimpleReference
+            Expressir::Model::References::AttributeReference.new(ref: ref,
+                                                                 attribute: qualifier)
+          when Hash
+            Expressir::Model::References::IndexReference.new(ref: ref,
+                                                             index1: qualifier[:index1], index2: qualifier[:index2])
           else
             ref
           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

@@ -36,7 +36,9 @@ module Expressir
 
         def build_assignment_stmt(ast_data)
           ref = Builder.build_optional(ast_data[:general_ref])
-          expression = Builder.build_optional(ast_data[:expression])
+          expression = if ast_data[:expression]
+                         Builder.build({ expression: ast_data[:expression] })
+                       end
 
           if ast_data[:qualifier]
             Builder.ensure_array(ast_data[:qualifier]).each do |qual|
@@ -83,31 +85,48 @@ 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
 
         def build_selector(ast_data)
-          Builder.build_optional(ast_data[:expression])
+          if ast_data[:expression]
+            Builder.build({ expression: ast_data[:expression] })
+          end
         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
 
         def build_case_label(ast_data)
-          Builder.build_optional(ast_data[:expression])
+          if ast_data[:expression]
+            Builder.build({ expression: ast_data[:expression] })
+          end
         end
 
         def build_compound_stmt(ast_data)
@@ -170,7 +189,9 @@ module Expressir
         end
 
         def build_return_stmt(ast_data)
-          expression = Builder.build_optional(ast_data[:expression])
+          expression = if ast_data[:expression]
+                         Builder.build({ expression: ast_data[:expression] })
+                       end
           Expressir::Model::Statements::Return.new(expression: expression)
         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.4".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.4
+  version: 2.3.6
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-11 00:00:00.000000000 Z
+date: 2026-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64