expressir 1.2.10-aarch64-linux → 2.4.29-aarch64-linux

data/lib/expressir/model/statements/case_action.rb

@@ -4,19 +4,17 @@ module Expressir
       # Specified in ISO 10303-11:2004
       # - section 13.4 Case statement
       class CaseAction < ModelElement
-        model_attr_accessor :labels, 'Array<Expression>'
-        model_attr_accessor :statement, 'Statement'
+        child_attributes :expression
+        attribute :labels, ModelElement, collection: true
+        attribute :statement, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
 
-        # @param [Hash] options
-        # @option options [Array<Expression>] :labels
-        # @option options [Statement] :statement
-        def initialize(options = {})
-          @labels = options[:labels] || []
-          @statement = options[:statement]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "labels", to: :labels
+          map "statement", to: :statement
         end
       end
     end
   end
-end
+end

data/lib/expressir/model/statements/compound.rb

@@ -3,17 +3,19 @@ module Expressir
     module Statements
       # Specified in ISO 10303-11:2004
       # - section 13.5 Compound statement
-      class Compound < Statement
-        model_attr_accessor :statements, 'Array<Statement>'
+      class Compound < ModelElement
+        include Statement
 
-        # @param [Hash] options
-        # @option options [Array<Statement>] :statements
-        def initialize(options = {})
-          @statements = options[:statements] || []
+        collection_attributes :statements
+        attribute :statements, ModelElement, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
 
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "untagged_remarks", to: :untagged_remarks
+          map "statements", to: :statements
         end
       end
     end
   end
-end
+end

data/lib/expressir/model/statements/escape.rb

@@ -3,8 +3,16 @@ module Expressir
     module Statements
       # Specified in ISO 10303-11:2004
       # - section 13.6 Escape statement
-      class Escape < Statement
+      class Escape < ModelElement
+        include Statement
+
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "untagged_remarks", to: :untagged_remarks
+        end
       end
     end
   end
-end
+end

data/lib/expressir/model/statements/if.rb

@@ -3,23 +3,24 @@ module Expressir
     module Statements
       # Specified in ISO 10303-11:2004
       # - section 13.7 If ... Then ... Else statement
-      class If < Statement
-        model_attr_accessor :expression, 'Expression'
-        model_attr_accessor :statements, 'Array<Statement>'
-        model_attr_accessor :else_statements, 'Array<Statement>'
+      class If < ModelElement
+        include Statement
 
-        # @param [Hash] options
-        # @option options [Expression] :expression
-        # @option options [Array<Statement>] :statements
-        # @option options [Array<Statement>] :else_statements
-        def initialize(options = {})
-          @expression = options[:expression]
-          @statements = options[:statements] || []
-          @else_statements = options[:else_statements] || []
+        collection_attributes :statements, :else_statements
+        child_attributes :expression
+        attribute :expression, ModelElement
+        attribute :statements, ModelElement, collection: true
+        attribute :else_statements, ModelElement, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
 
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "untagged_remarks", to: :untagged_remarks
+          map "expression", to: :expression
+          map "statements", to: :statements
+          map "else_statements", to: :else_statements
         end
       end
     end
   end
-end
+end

data/lib/expressir/model/statements/null.rb

@@ -3,8 +3,16 @@ module Expressir
     module Statements
       # Specified in ISO 10303-11:2004
       # - section 13.1 Null (statement)
-      class Null < Statement
+      class Null < ModelElement
+        include Statement
+
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "untagged_remarks", to: :untagged_remarks
+        end
       end
     end
   end
-end
+end

data/lib/expressir/model/statements/procedure_call.rb

@@ -3,20 +3,20 @@ module Expressir
     module Statements
       # Specified in ISO 10303-11:2004
       # - section 13.8 Procedure call statement
-      class ProcedureCall < Statement
-        model_attr_accessor :procedure, 'Reference'
-        model_attr_accessor :parameters, 'Array<Expression>'
+      class ProcedureCall < ModelElement
+        include Statement
 
-        # @param [Hash] options
-        # @option options [Reference] :procedure
-        # @option options [Array<Expression>] :parameters
-        def initialize(options = {})
-          @procedure = options[:procedure]
-          @parameters = options[:parameters] || []
+        attribute :procedure, ModelElement
+        attribute :parameters, ModelElement, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
 
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "untagged_remarks", to: :untagged_remarks
+          map "procedure", to: :procedure
+          map "parameters", to: :parameters
         end
       end
     end
   end
-end
+end

data/lib/expressir/model/statements/repeat.rb

@@ -3,45 +3,38 @@ module Expressir
     module Statements
       # Specified in ISO 10303-11:2004
       # - section 13.9 Repeat statement
-      class Repeat < Statement
+      class Repeat < ModelElement
+        include Statement
         include Identifier
 
-        model_attr_accessor :bound1, 'Expression'
-        model_attr_accessor :bound2, 'Expression'
-        model_attr_accessor :increment, 'Expression'
-        model_attr_accessor :while_expression, 'Expression'
-        model_attr_accessor :until_expression, 'Expression'
-        model_attr_accessor :statements, 'Array<Statement>'
+        collection_attributes :statements
+        child_attributes :while_expression, :until_expression
+        attribute :bound1, ModelElement
+        attribute :bound2, ModelElement
+        attribute :increment, ModelElement
+        attribute :while_expression, ModelElement
+        attribute :until_expression, ModelElement
+        attribute :statements, ModelElement, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        # @option options [Expression] :bound1
-        # @option options [Expression] :bound2
-        # @option options [Expression] :increment
-        # @option options [Expression] :while_expression
-        # @option options [Expression] :until_expression
-        # @option options [Array<Statement>] :statements
-        def initialize(options = {})
-          initialize_identifier(options)
-
-          @bound1 = options[:bound1]
-          @bound2 = options[:bound2]
-          @increment = options[:increment]
-          @while_expression = options[:while_expression]
-          @until_expression = options[:until_expression]
-          @statements = options[:statements] || []
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "bound1", to: :bound1
+          map "bound2", to: :bound2
+          map "increment", to: :increment
+          map "while_expression", to: :while_expression
+          map "until_expression", to: :until_expression
+          map "statements", to: :statements
         end
 
         # @return [Array<Declaration>]
         def children
           [
             self,
-            *remark_items
+            *remark_items,
           ]
         end
       end
     end
   end
-end
+end

data/lib/expressir/model/statements/return.rb

@@ -3,17 +3,18 @@ module Expressir
     module Statements
       # Specified in ISO 10303-11:2004
       # - section 13.10 Return statement
-      class Return < Statement
-        model_attr_accessor :expression, 'Expression'
+      class Return < ModelElement
+        include Statement
 
-        # @param [Hash] options
-        # @option options [Expression] :expression
-        def initialize(options = {})
-          @expression = options[:expression]
+        attribute :expression, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
 
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "untagged_remarks", to: :untagged_remarks
+          map "expression", to: :expression
         end
       end
     end
   end
-end
+end

data/lib/expressir/model/statements/skip.rb

@@ -3,8 +3,16 @@ module Expressir
     module Statements
       # Specified in ISO 10303-11:2004
       # - section 13.11 Skip statement
-      class Skip < Statement
+      class Skip < ModelElement
+        include Statement
+
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "untagged_remarks", to: :untagged_remarks
+        end
       end
     end
   end
-end
+end

data/lib/expressir/model/statements.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Model
+    module Statements
+      autoload :Alias, "#{__dir__}/statements/alias"
+      autoload :Assignment, "#{__dir__}/statements/assignment"
+      autoload :Case, "#{__dir__}/statements/case"
+      autoload :CaseAction, "#{__dir__}/statements/case_action"
+      autoload :Compound, "#{__dir__}/statements/compound"
+      autoload :Escape, "#{__dir__}/statements/escape"
+      autoload :If, "#{__dir__}/statements/if"
+      autoload :Null, "#{__dir__}/statements/null"
+      autoload :ProcedureCall, "#{__dir__}/statements/procedure_call"
+      autoload :Repeat, "#{__dir__}/statements/repeat"
+      autoload :Return, "#{__dir__}/statements/return"
+      autoload :Skip, "#{__dir__}/statements/skip"
+    end
+  end
+end

data/lib/expressir/model/supertype_expressions/binary_supertype_expression.rb

@@ -4,26 +4,22 @@ module Expressir
       # Specified in ISO 10303-11:2004
       # - section 9.2.5.3 ANDOR
       # - section 9.2.5.4 AND
-      class BinarySupertypeExpression < SupertypeExpression
-        AND = :AND
-        ANDOR = :ANDOR
+      class BinarySupertypeExpression < ModelElement
+        AND = "AND".freeze
+        ANDOR = "ANDOR".freeze
 
-        model_attr_accessor :operator, ':AND, :ANDOR'
-        model_attr_accessor :operand1, 'SupertypeExpression'
-        model_attr_accessor :operand2, 'SupertypeExpression'
+        attribute :operator, :string, values: %w[AND ANDOR]
+        attribute :operand1, ModelElement
+        attribute :operand2, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
 
-        # @param [Hash] options
-        # @option options [:AND, :ANDOR] :operator
-        # @option options [SupertypeExpression] :operand1
-        # @option options [SupertypeExpression] :operand2
-        def initialize(options = {})
-          @operator = options[:operator]
-          @operand1 = options[:operand1]
-          @operand2 = options[:operand2]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "operator", to: :operator
+          map "operand1", to: :operand1
+          map "operand2", to: :operand2
         end
       end
     end
   end
-end
+end

data/lib/expressir/model/supertype_expressions/oneof_supertype_expression.rb

@@ -3,17 +3,15 @@ module Expressir
     module SupertypeExpressions
       # Specified in ISO 10303-11:2004
       # - section 9.2.5.2 ONEOF
-      class OneofSupertypeExpression < SupertypeExpression
-        model_attr_accessor :operands, 'Array<SupertypeExpression>'
+      class OneofSupertypeExpression < ModelElement
+        attribute :operands, ModelElement, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
 
-        # @param [Hash] options
-        # @option options [Array<SupertypeExpression>] :operands
-        def initialize(options = {})
-          @operands = options[:operands]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "operands", to: :operands
         end
       end
     end
   end
-end
+end

data/lib/expressir/model/supertype_expressions.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Model
+    module SupertypeExpressions
+      autoload :BinarySupertypeExpression,
+               "#{__dir__}/supertype_expressions/binary_supertype_expression"
+      autoload :OneofSupertypeExpression,
+               "#{__dir__}/supertype_expressions/oneof_supertype_expression"
+    end
+  end
+end

data/lib/expressir/model.rb

@@ -1,79 +1,39 @@
-require "expressir/model/model_element"
+# lib/expressir/model.rb
 
-require "expressir/model/cache"
-require "expressir/model/data_type"
-require "expressir/model/declaration"
-require "expressir/model/expression"
-require "expressir/model/identifier"
-require "expressir/model/literal"
-require "expressir/model/reference"
-require "expressir/model/repository"
-require "expressir/model/statement"
-require "expressir/model/supertype_expression"
-require "expressir/model/data_types/aggregate"
-require "expressir/model/data_types/array"
-require "expressir/model/data_types/bag"
-require "expressir/model/data_types/binary"
-require "expressir/model/data_types/boolean"
-require "expressir/model/data_types/enumeration"
-require "expressir/model/data_types/enumeration_item"
-require "expressir/model/data_types/generic_entity"
-require "expressir/model/data_types/generic"
-require "expressir/model/data_types/integer"
-require "expressir/model/data_types/list"
-require "expressir/model/data_types/logical"
-require "expressir/model/data_types/number"
-require "expressir/model/data_types/real"
-require "expressir/model/data_types/set"
-require "expressir/model/data_types/select"
-require "expressir/model/data_types/string"
-require "expressir/model/declarations/attribute"
-require "expressir/model/declarations/constant"
-require "expressir/model/declarations/entity"
-require "expressir/model/declarations/function"
-require "expressir/model/declarations/interface"
-require "expressir/model/declarations/interface_item"
-require "expressir/model/declarations/interfaced_item"
-require "expressir/model/declarations/parameter"
-require "expressir/model/declarations/procedure"
-require "expressir/model/declarations/remark_item"
-require "expressir/model/declarations/rule"
-require "expressir/model/declarations/schema"
-require "expressir/model/declarations/schema_version"
-require "expressir/model/declarations/schema_version_item"
-require "expressir/model/declarations/subtype_constraint"
-require "expressir/model/declarations/type"
-require "expressir/model/declarations/unique_rule"
-require "expressir/model/declarations/variable"
-require "expressir/model/declarations/where_rule"
-require "expressir/model/expressions/aggregate_initializer"
-require "expressir/model/expressions/aggregate_initializer_item"
-require "expressir/model/expressions/binary_expression"
-require "expressir/model/expressions/entity_constructor"
-require "expressir/model/expressions/function_call"
-require "expressir/model/expressions/interval"
-require "expressir/model/expressions/query_expression"
-require "expressir/model/expressions/unary_expression"
-require "expressir/model/literals/binary"
-require "expressir/model/literals/integer"
-require "expressir/model/literals/logical"
-require "expressir/model/literals/real"
-require "expressir/model/literals/string"
-require "expressir/model/references/attribute_reference"
-require "expressir/model/references/group_reference"
-require "expressir/model/references/index_reference"
-require "expressir/model/references/simple_reference"
-require "expressir/model/statements/alias"
-require "expressir/model/statements/assignment"
-require "expressir/model/statements/case"
-require "expressir/model/statements/case_action"
-require "expressir/model/statements/compound"
-require "expressir/model/statements/escape"
-require "expressir/model/statements/if"
-require "expressir/model/statements/null"
-require "expressir/model/statements/procedure_call"
-require "expressir/model/statements/repeat"
-require "expressir/model/statements/return"
-require "expressir/model/statements/skip"
-require "expressir/model/supertype_expressions/binary_supertype_expression"
-require "expressir/model/supertype_expressions/oneof_supertype_expression"
+module Expressir
+  module Model
+    # Marker modules — autoload the same concerns.rb file from each name.
+    # The first reference triggers the load; the file defines all eight markers.
+    autoload :HasId, "#{__dir__}/model/concerns"
+    autoload :HasRemarkItems, "#{__dir__}/model/concerns"
+    autoload :HasRemarks, "#{__dir__}/model/concerns"
+    autoload :ScopeContainer, "#{__dir__}/model/concerns"
+    autoload :HasInformalPropositions, "#{__dir__}/model/concerns"
+    autoload :HasWhereRules, "#{__dir__}/model/concerns"
+    autoload :TakesInlineRemark, "#{__dir__}/model/concerns"
+    autoload :Statement, "#{__dir__}/model/concerns"
+
+    autoload :ModelElement, "#{__dir__}/model/model_element"
+    autoload :Cache, "#{__dir__}/model/cache"
+    autoload :ExpFile, "#{__dir__}/model/exp_file"
+    autoload :Identifier, "#{__dir__}/model/identifier"
+    autoload :Repository, "#{__dir__}/model/repository"
+    autoload :RepositoryValidator, "#{__dir__}/model/repository_validator"
+    autoload :DependencyResolver, "#{__dir__}/model/dependency_resolver"
+    autoload :RemarkFormat, "#{__dir__}/model/remark_format"
+    autoload :RemarkPlacement, "#{__dir__}/model/remark_placement"
+    autoload :RemarkInfo, "#{__dir__}/model/remark_info"
+    autoload :InterfaceValidator, "#{__dir__}/model/interface_validator"
+    autoload :SearchEngine, "#{__dir__}/model/search_engine"
+
+    # Submodules - autoload their namespace files
+    autoload :Indexes, "#{__dir__}/model/indexes"
+    autoload :DataTypes, "#{__dir__}/model/data_types"
+    autoload :Declarations, "#{__dir__}/model/declarations"
+    autoload :Expressions, "#{__dir__}/model/expressions"
+    autoload :Literals, "#{__dir__}/model/literals"
+    autoload :References, "#{__dir__}/model/references"
+    autoload :Statements, "#{__dir__}/model/statements"
+    autoload :SupertypeExpressions, "#{__dir__}/model/supertype_expressions"
+  end
+end