expressir 2.3.0 → 2.3.1

data/benchmark/srl_benchmark.rb

@@ -5,21 +5,21 @@
 # Compares Parsanol Ruby vs Native performance on full STEPmod Resource Library
 # Features: Live progress, emojis, colors, per-schema stats
 
-require 'bundler/setup'
-require 'benchmark'
-require 'fileutils'
+require "bundler/setup"
+require "benchmark"
+require "fileutils"
 
 # Force loading of native extension
-require 'parsanol'
-require 'parsanol/native'
+require "parsanol"
+require "parsanol/native"
 
 # Now require expressir
-require 'expressir'
+require "expressir"
 
 # Configuration
-SRL_PATH = '/Users/mulgogi/src/mn/iso-10303/schemas/resources'
-ITERATIONS = (ENV['ITERATIONS'] || 1).to_i
-TIMEOUT_SECONDS = (ENV['TIMEOUT'] || 30).to_i  # Timeout per file
+SRL_PATH = "/Users/mulgogi/src/mn/iso-10303/schemas/resources"
+ITERATIONS = (ENV["ITERATIONS"] || 1).to_i
+TIMEOUT_SECONDS = (ENV["TIMEOUT"] || 30).to_i # Timeout per file
 
 # Check if we're running in an interactive terminal
 INTERACTIVE = $stdout.tty?
@@ -64,7 +64,9 @@ include Colors
 module Terminal
   class << self
     def width
-      IO.console.winsize[1] rescue 80
+      IO.console.winsize[1]
+    rescue StandardError
+      80
     end
 
     def clear_line
@@ -85,7 +87,7 @@ class ProgressBar
     @current = 0
   end
 
-  def render(current, label = '')
+  def render(current, label = "")
     @current = current
     percentage = (@current.to_f / @total * 100).round(1)
     filled = (@width * @current / @total.to_f).round
@@ -97,7 +99,9 @@ class ProgressBar
 end
 
 def find_exp_files
-  Dir.glob("#{SRL_PATH}/*/*.exp").sort.reject { |f| f.include?('quantities_and_units') }
+  Dir.glob("#{SRL_PATH}/*/*.exp").reject do |f|
+    f.include?("quantities_and_units")
+  end
 end
 
 def count_lines(files)
@@ -158,50 +162,56 @@ class ParserBenchmark
     @results = []
   end
 
-  def run(files, total_lines)
+  def run(files, _total_lines)
     puts "#{@color}#{@emoji} #{@name}#{@RESET}"
     puts "#{DIM}┌──────────────────────────────────────────────────────────┐#{RESET}"
 
     progress_bar = ProgressBar.new(files.size, 25)
-    iteration_results = { success: 0, failed: 0, errors: [], time: 0, schema_times: [] }
+    iteration_results = { success: 0, failed: 0, errors: [], time: 0,
+                          schema_times: [] }
     start_time = Time.now
 
     files.each_with_index do |file, idx|
-      schema_name = File.basename(file, '.exp')
+      schema_name = File.basename(file, ".exp")
       file_start = Time.now
       schema_lines = File.read(file).lines.count
 
       begin
-        require 'timeout'
+        require "timeout"
         Timeout.timeout(TIMEOUT_SECONDS) do
           if @use_native
             content = File.read(file)
-            Expressir::Express::Parser.from_exp(content, skip_references: true, use_native: true)
+            Expressir::Express::Parser.from_exp(content, skip_references: true,
+                                                         use_native: true)
           else
             Expressir::Express::Parser.from_file(file, skip_references: true)
           end
         end
         iteration_results[:success] += 1
         status = "#{BRIGHT_GREEN}✓#{RESET}"
-      rescue Timeout::Error => e
+      rescue Timeout::Error
         iteration_results[:failed] += 1
-        iteration_results[:errors] << { file: File.basename(file), error: "Timeout after #{TIMEOUT_SECONDS}s" }
+        iteration_results[:errors] << { file: File.basename(file),
+                                        error: "Timeout after #{TIMEOUT_SECONDS}s" }
         status = "#{BRIGHT_YELLOW}⏱#{RESET}"
-      rescue => e
+      rescue StandardError => e
         iteration_results[:failed] += 1
-        iteration_results[:errors] << { file: File.basename(file), error: e.message[0..60] }
+        iteration_results[:errors] << { file: File.basename(file),
+                                        error: e.message[0..60] }
         status = "#{BRIGHT_RED}✗#{RESET}"
       end
 
       elapsed = Time.now - file_start
-      iteration_results[:schema_times] << { name: schema_name, time: elapsed, lines: schema_lines }
+      iteration_results[:schema_times] << { name: schema_name, time: elapsed,
+                                            lines: schema_lines }
 
       # Live progress update
       if INTERACTIVE
         progress_label = "#{status} #{schema_name[0..20].ljust(21)}"
-        print "#{Terminal.clear_line}  #{progress_bar.render(idx + 1, progress_label)}"
+        print "#{Terminal.clear_line}  #{progress_bar.render(idx + 1,
+                                                             progress_label)}"
         $stdout.flush
-      elsif (idx + 1) % 10 == 0 || idx == 0
+      elsif ((idx + 1) % 10).zero? || idx.zero?
         # Print progress every 10 files when not interactive
         pct = ((idx + 1).to_f / files.size * 100).round(1)
         puts "  #{progress_bar.render(idx + 1, "#{pct}% complete")}"
@@ -230,7 +240,7 @@ class ParserBenchmark
     puts "#{DIM}│#{RESET}   #{BRIGHT_CYAN}⏱️  Time:#{RESET}    #{BRIGHT_WHITE}#{format_time(avg_time).rjust(5)}#{RESET}"
     puts "#{DIM}│#{RESET}   #{BRIGHT_YELLOW}⚡ Speed:#{RESET}   #{BRIGHT_WHITE}#{format_number(lines_per_sec).rjust(5)}#{RESET} lines/sec"
 
-    if result[:failed] > 0 && result[:failed] <= 5
+    if result[:failed].positive? && result[:failed] <= 5
       puts "#{DIM}├──────────────────────────────────────────────────────────┤#{RESET}"
       puts "#{DIM}│#{RESET} #{BRIGHT_RED}⚠️  Errors:#{RESET}"
       result[:errors].first(3).each do |err|
@@ -241,7 +251,8 @@ class ParserBenchmark
     puts "#{DIM}└──────────────────────────────────────────────────────────┘#{RESET}"
     puts
 
-    { avg_time: avg_time, lines_per_sec: lines_per_sec, files_per_sec: files_per_sec }
+    { avg_time: avg_time, lines_per_sec: lines_per_sec,
+      files_per_sec: files_per_sec }
   end
 
   def print_slowest_schemas(result, count = 5)
@@ -290,7 +301,7 @@ def print_comparison(ruby_stats, native_stats, files, total_lines)
     puts "#{DIM}│#{RESET}  #{BRIGHT_YELLOW}⏱️  Time Saved:#{RESET}  #{BRIGHT_GREEN}#{format_time(time_saved)} per run#{RESET}             #{DIM}│#{RESET}"
   else
     puts "#{DIM}│#{RESET}  #{BOLD}#{BRIGHT_BLUE}🏆 WINNER: Ruby Parser#{RESET}                       #{DIM}│#{RESET}"
-    puts "#{DIM}│#{RESET}  #{BRIGHT_YELLOW}⚡ Speedup:#{RESET}     #{BOLD}#{BRIGHT_BLUE}#{(1/speedup).round(1)}x FASTER#{RESET}                  #{DIM}│#{RESET}"
+    puts "#{DIM}│#{RESET}  #{BRIGHT_YELLOW}⚡ Speedup:#{RESET}     #{BOLD}#{BRIGHT_BLUE}#{(1 / speedup).round(1)}x FASTER#{RESET}                  #{DIM}│#{RESET}"
   end
 
   puts "#{DIM}│#{RESET}                                                     #{DIM}│#{RESET}"
@@ -336,15 +347,16 @@ warmup_file = files.first
 
 begin
   Expressir::Express::Parser.from_file(warmup_file, skip_references: true)
-rescue => e
+rescue StandardError => e
   puts "#{BRIGHT_YELLOW}⚠️  Ruby warmup warning: #{e.message[0..40]}#{RESET}"
 end
 
 if Parsanol::Native.available?
   begin
     content = File.read(warmup_file)
-    Expressir::Express::Parser.from_exp(content, skip_references: true, use_native: true)
-  rescue => e
+    Expressir::Express::Parser.from_exp(content, skip_references: true,
+                                                 use_native: true)
+  rescue StandardError => e
     puts "#{BRIGHT_YELLOW}⚠️  Native warmup warning: #{e.message[0..40]}#{RESET}"
   end
 end
@@ -356,7 +368,7 @@ ruby_benchmark = ParserBenchmark.new(
   name: "Ruby Parser",
   emoji: "💎",
   color: BRIGHT_BLUE,
-  use_native: false
+  use_native: false,
 )
 
 ruby_result = ruby_benchmark.run(files, total_lines)
@@ -369,17 +381,18 @@ if Parsanol::Native.available?
     name: "Native Parser (Rust)",
     emoji: "🦀",
     color: BRIGHT_CYAN,
-    use_native: true
+    use_native: true,
   )
 
   native_result = native_benchmark.run(files, total_lines)
-  native_stats = native_benchmark.print_summary(files, total_lines, native_result)
+  native_stats = native_benchmark.print_summary(files, total_lines,
+                                                native_result)
   native_benchmark.print_slowest_schemas(native_result)
 
   # Print comparison
   print_comparison(ruby_stats, native_stats, files, total_lines)
 else
-  puts "#{BRIGHT_YELLOW}⚠️  Native parser not available. Run \`rake compile\` in parsanol-ruby to build.#{RESET}"
+  puts "#{BRIGHT_YELLOW}⚠️  Native parser not available. Run `rake compile` in parsanol-ruby to build.#{RESET}"
   puts
 end
 

data/benchmark/srl_native_benchmark.rb

@@ -4,22 +4,22 @@
 # SRL Benchmark Script for Expressir - Native Parser Only
 # Tests Rust native parser performance on full STEPmod Resource Library
 
-require 'bundler/setup'
-require 'benchmark'
-require 'fileutils'
+require "bundler/setup"
+require "benchmark"
+require "fileutils"
 
 # Force loading of native extension first
-require 'parsanol'
-require 'parsanol/native'
+require "parsanol"
+require "parsanol/native"
 
 # Now require expressir
-require 'expressir'
+require "expressir"
 
 # Configuration
-SRL_PATH = '/Users/mulgogi/src/mn/iso-10303/schemas/resources'
+SRL_PATH = "/Users/mulgogi/src/mn/iso-10303/schemas/resources"
 
 def find_exp_files
-  Dir.glob("#{SRL_PATH}/*/*.exp").sort
+  Dir.glob("#{SRL_PATH}/*/*.exp")
 end
 
 def count_lines(files)
@@ -59,9 +59,10 @@ puts "Warming up..."
 warmup_file = files.first
 begin
   content = File.read(warmup_file)
-  Expressir::Express::Parser.from_exp(content, skip_references: true, use_native: true)
+  Expressir::Express::Parser.from_exp(content, skip_references: true,
+                                               use_native: true)
   puts "Warmup complete."
-rescue => e
+rescue StandardError => e
   puts "Warning: Warmup failed: #{e.message}"
   puts e.backtrace.first(5)
 end
@@ -80,19 +81,22 @@ time = Benchmark.realtime do
     file_start = Time.now
     begin
       content = File.read(file)
-      Expressir::Express::Parser.from_exp(content, skip_references: true, use_native: true)
+      Expressir::Express::Parser.from_exp(content, skip_references: true,
+                                                   use_native: true)
       results[:success] += 1
       file_time = Time.now - file_start
-      file_times << { file: File.basename(file), time: file_time, lines: content.lines.count }
+      file_times << { file: File.basename(file), time: file_time,
+                      lines: content.lines.count }
 
       # Progress every 10 files
-      if (idx + 1) % 10 == 0
+      if ((idx + 1) % 10).zero?
         print "."
         $stdout.flush
       end
-    rescue => e
+    rescue StandardError => e
       results[:failed] += 1
-      results[:errors] << { file: File.basename(file), error: e.message[0..100] }
+      results[:errors] << { file: File.basename(file),
+                            error: e.message[0..100] }
     end
   end
 end
@@ -112,7 +116,7 @@ puts "  Time:    #{results[:total_time].round(2)}s"
 puts "  Speed:   #{lines_per_sec} lines/sec"
 puts "  Speed:   #{files_per_sec} files/sec"
 
-if results[:failed] > 0
+if results[:failed].positive?
   puts
   puts "Errors (first 10):"
   results[:errors].first(10).each do |err|

data/benchmark/srl_ruby_benchmark.rb

@@ -4,18 +4,18 @@
 # SRL Benchmark Script for Expressir - Ruby Parser Only
 # Tests pure Ruby parser performance on full STEPmod Resource Library
 
-require 'bundler/setup'
-require 'benchmark'
-require 'fileutils'
+require "bundler/setup"
+require "benchmark"
+require "fileutils"
 
 # Load expressir WITHOUT native extension
-require 'expressir'
+require "expressir"
 
 # Configuration
-SRL_PATH = '/Users/mulgogi/src/mn/iso-10303/schemas/resources'
+SRL_PATH = "/Users/mulgogi/src/mn/iso-10303/schemas/resources"
 
 def find_exp_files
-  Dir.glob("#{SRL_PATH}/*/*.exp").sort
+  Dir.glob("#{SRL_PATH}/*/*.exp")
 end
 
 def count_lines(files)
@@ -46,7 +46,7 @@ warmup_file = files.first
 begin
   Expressir::Express::Parser.from_file(warmup_file, skip_references: true)
   puts "Warmup complete."
-rescue => e
+rescue StandardError => e
   puts "Warning: Warmup failed: #{e.message}"
 end
 puts
@@ -67,16 +67,18 @@ time = Benchmark.realtime do
       results[:success] += 1
       file_time = Time.now - file_start
       content = File.read(file)
-      file_times << { file: File.basename(file), time: file_time, lines: content.lines.count }
+      file_times << { file: File.basename(file), time: file_time,
+                      lines: content.lines.count }
 
       # Progress every 10 files
-      if (idx + 1) % 10 == 0
+      if ((idx + 1) % 10).zero?
         print "."
         $stdout.flush
       end
-    rescue => e
+    rescue StandardError => e
       results[:failed] += 1
-      results[:errors] << { file: File.basename(file), error: e.message[0..100] }
+      results[:errors] << { file: File.basename(file),
+                            error: e.message[0..100] }
     end
   end
 end
@@ -96,7 +98,7 @@ puts "  Time:    #{results[:total_time].round(2)}s"
 puts "  Speed:   #{lines_per_sec} lines/sec"
 puts "  Speed:   #{files_per_sec} files/sec"
 
-if results[:failed] > 0
+if results[:failed].positive?
   puts
   puts "Errors (first 10):"
   results[:errors].first(10).each do |err|

data/expressir.gemspec

@@ -38,9 +38,9 @@ Gem::Specification.new do |spec|
   spec.add_dependency "liquid"
   spec.add_dependency "lutaml-model", "~> 0.8.0"
   spec.add_dependency "moxml"
-  spec.add_dependency "paint"
-  spec.add_dependency "parsanol", "~> 1.3.7", ">= 1.3.7"
   spec.add_dependency "nokogiri"
+  spec.add_dependency "paint"
+  spec.add_dependency "parsanol", "~> 1.3.9", ">= 1.3.9"
   spec.add_dependency "ruby-progressbar", "~> 1.11"
   spec.add_dependency "rubyzip", "~> 2.3"
   spec.add_dependency "table_tennis"

data/lib/expressir/changes/item_change.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Expressir
   module Changes
     # Represents a single change to an EXPRESS construct

data/lib/expressir/changes/mapping_change.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Expressir
   module Changes
     # Represents a mapping change entry

data/lib/expressir/changes/schema_change.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Expressir
   module Changes
     # Represents changes to an EXPRESS schema across multiple versions

data/lib/expressir/changes/version_change.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Expressir
   module Changes
     # Represents a version version of schema changes

data/lib/expressir/commands/changes_import_eengine.rb

@@ -11,7 +11,7 @@ module Expressir
       # @param version [String] Version identifier
       # @param options [Hash] Additional options
       # @return [Expressir::Changes::SchemaChange]
-      def self.from_xml(xml_content, schema_name, version, **options)
+      def self.from_xml(xml_content, schema_name, version, **)
         require "expressir/changes"
 
         # Parse into CompareReport using Lutaml::Model
@@ -19,7 +19,7 @@ module Expressir
 
         # Convert to SchemaChange
         convert_to_schema_change(compare_report, schema_name, version,
-                                 xml_content: xml_content, **options)
+                                 xml_content: xml_content, **)
       end
 
       # File-based workflow (backward compatible)

data/lib/expressir/commands/validate_ascii.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
 require "paint"
 require "table_tennis"
 

data/lib/expressir/eengine/arm_compare_report.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Expressir
   module Eengine
     # Represents an Eengine ARM comparison XML report

data/lib/expressir/eengine/changes_section.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Expressir
   module Eengine
     # Represents a section of changes (modifications, additions, or deletions)

data/lib/expressir/eengine/mim_compare_report.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Expressir
   module Eengine
     # Represents an Eengine MIM comparison XML report

data/lib/expressir/eengine/modified_object.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Expressir
   module Eengine
     # Represents a modified EXPRESS object in an Eengine comparison report

data/lib/expressir/express/builder.rb

@@ -26,6 +26,21 @@ module Expressir
         # @param source [String, nil] The original source code
         # @param include_source [Boolean, nil] Whether to include source
         # @return [Model::ModelElement] The built model object
+        # Operator tokens that return nil (separators, punctuation)
+        # When these appear as the first key in a multi-key hash, they should be
+        # skipped in favor of the content key. This handles grammar patterns like
+        # `element >> (op_comma >> element).repeat` which produce
+        # {:op_comma => ..., :element => {...}}.
+        OPERATOR_TOKENS = Set.new(%i[
+                                    op_comma op_colon op_decl op_delim op_leftparen op_rightparen
+                                    op_leftbracket op_rightbracket op_left_curly_brace op_right_curly_brace
+                                    op_period op_pipe op_double_backslash op_double_pipe op_double_asterisk
+                                    op_asterisk op_slash op_plus op_minus op_less_equal op_greater_equal
+                                    op_less_greater op_less_than op_greater_than op_equals
+                                    op_colon_less_greater_colon op_colon_equals_colon
+                                    op_query_begin op_query_end op_question_mark
+                                  ]).freeze
+
         def build(ast, source: nil, include_source: nil)
           return nil unless ast
 
@@ -44,25 +59,41 @@ module Expressir
             snake_data = fast_convert_keys(node_data)
 
             builder = @register[handler_key]
-            raise Error::UnknownNodeTypeError, node_type unless builder
-
-            result = builder.call(snake_data)
-
-            # Always store source_offset for remark attachment (if source is available)
-            # Only store source text when include_source is requested
-            if @source && result.is_a?(Model::ModelElement)
-              source_info = extract_source_info(node_data)
-              if source_info
-                # Store offset for remark attachment (always needed)
-                result.source_offset = source_info[:offset]
-                # Store source text only when explicitly requested
-                if @include_source
-                  result.source = source_info[:text]
+            if builder
+              result = builder.call(snake_data)
+
+              # Fast path: single-key hash or non-nil result
+              if !result.nil? || ast.keys.length <= 1
+                attach_source_info(result, node_data)
+                return result
+              end
+
+              # Slow path: operator token returned nil in multi-key hash.
+              # Try other keys for actual content. This handles
+              # {:op_comma => ..., :element => {...}} where the first key
+              # is an operator separator rather than a content key.
+              if OPERATOR_TOKENS.include?(handler_key)
+                ast.each_key do |key|
+                  next if key == node_type
+
+                  h_key = cached_snake_case(key)
+                  h_builder = @register[h_key]
+                  next unless h_builder
+
+                  n_data = ast[key]
+                  s_data = fast_convert_keys(n_data)
+                  result = h_builder.call(s_data)
+
+                  unless result.nil?
+                    attach_source_info(result, n_data)
+                    return result
+                  end
                 end
               end
+            else
+              raise Error::UnknownNodeTypeError, node_type
             end
-
-            result
+            nil
           when Array
             ast.map do |item|
               build(item)
@@ -83,7 +114,9 @@ module Expressir
 
           result = build(ast)
 
-          if source && result
+          # Only attach remarks if include_source is explicitly true
+          # (nil means use default behavior - attach remarks)
+          if source && result && include_source != false
             attacher = RemarkAttacher.new(source)
             attacher.attach(result)
           end
@@ -113,6 +146,7 @@ module Expressir
         def ensure_array(value)
           return [] if value.nil?
           return [] if value.is_a?(Parsanol::Slice)
+
           value.is_a?(Array) ? value : [value]
         end
 
@@ -121,9 +155,8 @@ module Expressir
         def build_children(ast_array)
           return [] if ast_array.nil?
 
-          # Handle Parsanol::Slice (including empty Slices from native parser)
-          # Convert to empty Array to match Ruby parser behavior
-          # Native parser returns empty slices where Ruby parser returns empty arrays
+          # Handle Parsanol::Slice (empty Slices from optional rules)
+          # Convert to empty Array
           if ast_array.is_a?(Parsanol::Slice)
             return []
           end
@@ -138,7 +171,7 @@ module Expressir
           ast_array.each do |item|
             next if item.nil?
 
-            # Empty Slices from native parser should be treated as empty arrays
+            # Empty Slices from optional rules should be treated as empty arrays
             if item.is_a?(Parsanol::Slice)
               next
             end
@@ -328,6 +361,16 @@ module Expressir
           }
         end
 
+        def attach_source_info(result, data)
+          return unless @source && result.is_a?(Model::ModelElement)
+
+          source_info = extract_source_info(data)
+          return unless source_info
+
+          result.source_offset = source_info[:offset]
+          result.source = source_info[:text] if @include_source
+        end
+
         def find_slice(data, depth = 0)
           return nil if depth > 10
 

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

@@ -13,12 +13,14 @@ module Expressir
         end
 
         def build_built_in_function(ast_data)
-          id = extract_text(ast_data[:str])
+          id = extract_text(ast_data[:str]) ||
+            extract_nested_text(ast_data)
           Expressir::Model::References::SimpleReference.new(id: id)
         end
 
         def build_built_in_procedure(ast_data)
-          id = extract_text(ast_data[:str])
+          id = extract_text(ast_data[:str]) ||
+            extract_nested_text(ast_data)
           Expressir::Model::References::SimpleReference.new(id: id)
         end
 

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

@@ -36,7 +36,9 @@ 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(Builder.ensure_array(subtype_constraint[:list_of_entity_ref][:entity_ref]).map { |d| { entity_ref: d } })
+                  entity_refs = Builder.build_children(Builder.ensure_array(subtype_constraint[:list_of_entity_ref][:entity_ref]).map do |d|
+                    { entity_ref: d }
+                  end)
                   supertype_expression = entity_refs.first if entity_refs.length == 1
                 end
               end
@@ -47,7 +49,9 @@ module Expressir
               if list_ref.is_a?(Hash)
                 entity_ref_data = list_ref[:entity_ref]
                 if entity_ref_data
-                  subtype_of = Builder.build_children(Builder.ensure_array(entity_ref_data).map { |d| { entity_ref: d } })
+                  subtype_of = Builder.build_children(Builder.ensure_array(entity_ref_data).map do |d|
+                    { entity_ref: d }
+                  end)
                 end
               end
             end
@@ -65,12 +69,12 @@ module Expressir
 
             if entity_body[:derive_clause]
               derived = Builder.build({ derive_clause: entity_body[:derive_clause] })
-              attributes.concat([derived]) if derived
+              attributes.push(derived) if derived
             end
 
             if entity_body[:inverse_clause]
               inverse = Builder.build({ inverse_clause: entity_body[:inverse_clause] })
-              attributes.concat([inverse]) if inverse
+              attributes.push(inverse) if inverse
             end
 
             if entity_body[:unique_clause]