expressir 1.2.11-aarch64-linux → 2.4.29-aarch64-linux

data/lib/expressir/model/data_types/list.rb

@@ -3,26 +3,21 @@ module Expressir
     module DataTypes
       # Specified in ISO 10303-11:2004
       # - section 8.2.2 List data type
-      class List < DataType
-        model_attr_accessor :bound1, 'Expression'
-        model_attr_accessor :bound2, 'Expression'
-        model_attr_accessor :unique, '::Boolean'
-        model_attr_accessor :base_type, 'DataType'
+      class List < ModelElement
+        attribute :bound1, ModelElement
+        attribute :bound2, ModelElement
+        attribute :unique, :boolean
+        attribute :base_type, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
 
-        # @param [Hash] options
-        # @option options [Expression] :bound1
-        # @option options [Expression] :bound2
-        # @option options [::Boolean] :unique
-        # @option options [DataType] :base_type
-        def initialize(options = {})
-          @bound1 = options[:bound1]
-          @bound2 = options[:bound2]
-          @unique = options[:unique]
-          @base_type = options[:base_type]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "bound1", to: :bound1
+          map "bound2", to: :bound2
+          map "unique", to: :unique
+          map "base_type", to: :base_type
         end
       end
     end
   end
-end
+end

data/lib/expressir/model/data_types/logical.rb

@@ -3,8 +3,13 @@ module Expressir
     module DataTypes
       # Specified in ISO 10303-11:2004
       # - section 8.1.4 Logical data type
-      class Logical < DataType
+      class Logical < ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+        end
       end
     end
   end
-end
+end

data/lib/expressir/model/data_types/number.rb

@@ -3,8 +3,13 @@ module Expressir
     module DataTypes
       # Specified in ISO 10303-11:2004
       # - section 8.1.1 Number data type
-      class Number < DataType
+      class Number < ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+        end
       end
     end
   end
-end
+end

data/lib/expressir/model/data_types/real.rb

@@ -3,17 +3,15 @@ module Expressir
     module DataTypes
       # Specified in ISO 10303-11:2004
       # - section 8.1.2 Real data type
-      class Real < DataType
-        model_attr_accessor :precision, 'Expression'
+      class Real < ModelElement
+        attribute :precision, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
 
-        # @param [Hash] options
-        # @option options [Expression] :precision
-        def initialize(options = {})
-          @precision = options[:precision]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "precision", to: :precision
         end
       end
     end
   end
-end
+end

data/lib/expressir/model/data_types/select.rb

@@ -3,26 +3,21 @@ module Expressir
     module DataTypes
       # Specified in ISO 10303-11:2004
       # - section 8.4.2 Select data type
-      class Select < DataType
-        model_attr_accessor :extensible, '::Boolean'
-        model_attr_accessor :generic_entity, '::Boolean'
-        model_attr_accessor :based_on, 'Reference'
-        model_attr_accessor :items, '::Array<Reference>'
+      class Select < ModelElement
+        attribute :extensible, :boolean
+        attribute :generic_entity, :boolean
+        attribute :based_on, ModelElement
+        attribute :items, ModelElement, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
 
-        # @param [Hash] options
-        # @option options [::Boolean] :extensible
-        # @option options [::Boolean] :generic_entity
-        # @option options [Reference] :based_on
-        # @option options [::Array<Reference>] :items
-        def initialize(options = {})
-          @extensible = options[:extensible]
-          @generic_entity = options[:generic_entity]
-          @based_on = options[:based_on]
-          @items = options[:items] || []
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "extensible", to: :extensible
+          map "generic_entity", to: :generic_entity
+          map "based_on", to: :based_on
+          map "items", to: :items
         end
       end
     end
   end
-end
+end

data/lib/expressir/model/data_types/set.rb

@@ -3,23 +3,19 @@ module Expressir
     module DataTypes
       # Specified in ISO 10303-11:2004
       # - section 8.2.4 Set data type
-      class Set < DataType
-        model_attr_accessor :bound1, 'Expression'
-        model_attr_accessor :bound2, 'Expression'
-        model_attr_accessor :base_type, 'DataType'
+      class Set < ModelElement
+        attribute :bound1, ModelElement
+        attribute :bound2, ModelElement
+        attribute :base_type, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
 
-        # @param [Hash] options
-        # @option options [Expression] :bound1
-        # @option options [Expression] :bound2
-        # @option options [DataType] :base_type
-        def initialize(options = {})
-          @bound1 = options[:bound1]
-          @bound2 = options[:bound2]
-          @base_type = options[:base_type]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "bound1", to: :bound1
+          map "bound2", to: :bound2
+          map "base_type", to: :base_type
         end
       end
     end
   end
-end
+end

data/lib/expressir/model/data_types/string.rb

@@ -3,20 +3,17 @@ module Expressir
     module DataTypes
       # Specified in ISO 10303-11:2004
       # - section 8.1.6 String data type
-      class String < DataType
-        model_attr_accessor :width, 'Expression'
-        model_attr_accessor :fixed, '::Boolean'
+      class String < ModelElement
+        attribute :width, ModelElement
+        attribute :fixed, :boolean
+        attribute :_class, :string, default: -> { self.class.name }
 
-        # @param [Hash] options
-        # @option options [Expression] :width
-        # @option options [::Boolean] :fixed
-        def initialize(options = {})
-          @width = options[:width]
-          @fixed = options[:fixed]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "width", to: :width
+          map "fixed", to: :fixed
         end
       end
     end
   end
-end
+end

data/lib/expressir/model/data_types.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Model
+    module DataTypes
+      autoload :Aggregate, "#{__dir__}/data_types/aggregate"
+      autoload :Array, "#{__dir__}/data_types/array"
+      autoload :Bag, "#{__dir__}/data_types/bag"
+      autoload :Binary, "#{__dir__}/data_types/binary"
+      autoload :Boolean, "#{__dir__}/data_types/boolean"
+      autoload :Enumeration, "#{__dir__}/data_types/enumeration"
+      autoload :EnumerationItem, "#{__dir__}/data_types/enumeration_item"
+      autoload :GenericEntity, "#{__dir__}/data_types/generic_entity"
+      autoload :Generic, "#{__dir__}/data_types/generic"
+      autoload :Integer, "#{__dir__}/data_types/integer"
+      autoload :List, "#{__dir__}/data_types/list"
+      autoload :Logical, "#{__dir__}/data_types/logical"
+      autoload :Number, "#{__dir__}/data_types/number"
+      autoload :Real, "#{__dir__}/data_types/real"
+      autoload :Select, "#{__dir__}/data_types/select"
+      autoload :Set, "#{__dir__}/data_types/set"
+      autoload :String, "#{__dir__}/data_types/string"
+    end
+  end
+end

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

@@ -3,45 +3,36 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 9.2.1 Attributes
-      class Attribute < Declaration
+      class Attribute < ModelElement
         include Identifier
 
-        EXPLICIT = :EXPLICIT
-        DERIVED = :DERIVED
-        INVERSE = :INVERSE
+        EXPLICIT = "EXPLICIT".freeze
+        DERIVED = "DERIVED".freeze
+        INVERSE = "INVERSE".freeze
 
-        model_attr_accessor :kind, ':EXPLICIT, :DERIVED, :INVERSE'
-        model_attr_accessor :supertype_attribute, 'Reference'
-        model_attr_accessor :optional, 'Boolean'
-        model_attr_accessor :type, 'DataType'
-        model_attr_accessor :expression, 'Expression'
+        attribute :kind, :string, values: %w[EXPLICIT DERIVED INVERSE]
+        attribute :supertype_attribute, ModelElement
+        attribute :optional, :boolean
+        attribute :type, ModelElement
+        attribute :expression, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        # @option options [:EXPLICIT, :DERIVED, :INVERSE] :kind
-        # @option options [Reference] :supertype_attribute
-        # @option options [Boolean] :optional
-        # @option options [DataType] :type
-        # @option options [Expression] :operand
-        def initialize(options = {})
-          initialize_identifier(options)
-
-          @kind = options[:kind]
-          @supertype_attribute = options[:supertype_attribute]
-          @optional = options[:optional]
-          @type = options[:type]
-          @expression = options[:expression]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "kind", to: :kind
+          map "supertype_attribute", to: :supertype_attribute
+          map "optional", to: :optional
+          map "type", to: :type
+          map "expression", to: :expression
         end
 
         # @return [Array<Declaration>]
         def children
           [
-            *remark_items
+            *remark_items,
           ]
         end
       end
     end
   end
-end
+end

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

@@ -3,32 +3,26 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 9.4 Constant
-      class Constant < Declaration
+      class Constant < ModelElement
         include Identifier
 
-        model_attr_accessor :type, 'DataType'
-        model_attr_accessor :expression, 'Expression'
+        attribute :type, ModelElement
+        attribute :expression, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        # @option options [DataType] :type
-        # @option options [Expression] :expression
-        def initialize(options = {})
-          initialize_identifier(options)
-
-          @type = options[:type]
-          @expression = options[:expression]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "type", to: :type
+          map "expression", to: :expression
         end
 
         # @return [Array<Declaration>]
         def children
           [
-            *remark_items
+            *remark_items,
           ]
         end
       end
     end
   end
-end
+end

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

@@ -0,0 +1,25 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.2.1 Attributes
+      class DerivedAttribute < Attribute
+        include Identifier
+
+        DERIVED = "DERIVED".freeze
+
+        attribute :kind, :string, default: -> { DERIVED }
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "kind", to: :kind, render_default: true
+          map "supertype_attribute", to: :supertype_attribute
+          map "optional", to: :optional
+          map "type", to: :type
+          map "expression", to: :expression
+        end
+      end
+    end
+  end
+end

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

@@ -3,51 +3,60 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 9.2 Entity declaration
-      class Entity < Declaration
+      class Entity < ModelElement
         include Identifier
+        include ScopeContainer
+        include HasInformalPropositions
+        include HasWhereRules
 
-        model_attr_accessor :abstract, 'Boolean'
-        model_attr_accessor :supertype_expression, 'SupertypeExpression'
-        model_attr_accessor :subtype_of, 'Array<Reference>'
-        model_attr_accessor :attributes, 'Array<Attribute>'
-        model_attr_accessor :unique_rules, 'Array<UniqueRule>'
-        model_attr_accessor :where_rules, 'Array<WhereRule>'
-        model_attr_accessor :informal_propositions, 'Array<RemarkItem>'
+        collection_attributes :attributes, :derived_attributes,
+                              :inverse_attributes, :unique_rules,
+                              :where_rules, :informal_propositions,
+                              :remark_items
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        # @option options [Boolean] :abstract
-        # @option options [SupertypeExpression] :supertype_expression
-        # @option options [Array<Reference>] :subtype_of
-        # @option options [Array<Attribute>] :attributes
-        # @option options [Array<UniqueRule>] :unique_rules
-        # @option options [Array<WhereRule>] :where_rules
-        # @option options [Array<RemarkItem>] :informal_propositions
-        def initialize(options = {})
-          initialize_identifier(options)
+        attribute :abstract, :boolean
+        attribute :supertype_expression, ModelElement
+        attribute :subtype_of, ModelElement, collection: true
+        # Heterogeneous by design: Attribute, DerivedAttribute, and
+        # InverseAttribute all live here (the builders concatenate the
+        # three clauses in declaration order). The ModelElement base
+        # keeps from_hash polymorphic via the _class marker, exactly
+        # like the Ruby-built model.
+        attribute :attributes, ModelElement, collection: true
+        attribute :derived_attributes, DerivedAttribute, collection: true
+        attribute :inverse_attributes, InverseAttribute, collection: true
+        attribute :unique_rules, UniqueRule, collection: true
+        attribute :where_rules, WhereRule, collection: true
+        attribute :informal_propositions, InformalPropositionRule,
+                  collection: true
+        attribute :_class, :string, default: -> { self.class.name }
 
-          @abstract = options[:abstract]
-          @supertype_expression = options[:supertype_expression]
-          @subtype_of = options[:subtype_of] || []
-          @attributes = options[:attributes] || []
-          @unique_rules = options[:unique_rules] || []
-          @where_rules = options[:where_rules] || []
-          @informal_propositions = options[:informal_propositions] || []
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "abstract", to: :abstract
+          map "supertype_expression", to: :supertype_expression
+          map "subtype_of", to: :subtype_of
+          map "attributes", to: :attributes
+          map "derived_attributes", to: :derived_attributes
+          map "inverse_attributes", to: :inverse_attributes
+          map "unique_rules", to: :unique_rules
+          map "where_rules", to: :where_rules
+          map "informal_propositions", to: :informal_propositions
         end
 
         # @return [Array<Declaration>]
         def children
           [
             *attributes,
+            *derived_attributes,
+            *inverse_attributes,
             *unique_rules,
             *where_rules,
             *informal_propositions,
-            *remark_items
+            *remark_items,
           ]
         end
       end
     end
   end
-end
+end

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

@@ -3,47 +3,39 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 9.5.1 Function
-      class Function < Declaration
+      class Function < ModelElement
         include Identifier
+        include ScopeContainer
 
-        model_attr_accessor :parameters, 'Array<Parameter>'
-        model_attr_accessor :return_type, 'DataType'
-        model_attr_accessor :types, 'Array<Type>'
-        model_attr_accessor :entities, 'Array<Entity>'
-        model_attr_accessor :subtype_constraints, 'Array<SubtypeConstraint>'
-        model_attr_accessor :functions, 'Array<Function>'
-        model_attr_accessor :procedures, 'Array<Procedure>'
-        model_attr_accessor :constants, 'Array<Constant>'
-        model_attr_accessor :variables, 'Array<Variable>'
-        model_attr_accessor :statements, 'Array<Statement>'
+        collection_attributes :parameters, :types, :entities,
+                              :subtype_constraints, :functions, :procedures,
+                              :constants, :variables, :statements,
+                              :remark_items
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        # @option options [Array<Parameter>] :parameters
-        # @option options [DataType] :return_type
-        # @option options [Array<Type>] :types
-        # @option options [Array<Entity>] :entities
-        # @option options [Array<SubtypeConstraint>] :subtype_constraints
-        # @option options [Array<Function>] :functions
-        # @option options [Array<Procedure>] :procedures
-        # @option options [Array<Constant>] :constants
-        # @option options [Array<Variable>] :variables
-        # @option options [Array<Statement>] :statements
-        def initialize(options = {})
-          initialize_identifier(options)
+        attribute :parameters, Parameter, collection: true
+        attribute :return_type, ModelElement
+        attribute :types, ModelElement, collection: true
+        attribute :entities, Entity, collection: true
+        attribute :subtype_constraints, SubtypeConstraint, collection: true
+        attribute :functions, Function, collection: true
+        attribute :procedures, Procedure, collection: true
+        attribute :constants, Constant, collection: true
+        attribute :variables, Variable, collection: true
+        attribute :statements, ModelElement, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
 
-          @parameters = options[:parameters] || []
-          @return_type = options[:return_type]
-          @types = options[:types] || []
-          @entities = options[:entities] || []
-          @subtype_constraints = options[:subtype_constraints] || []
-          @functions = options[:functions] || []
-          @procedures = options[:procedures] || []
-          @constants = options[:constants] || []
-          @variables = options[:variables] || []
-          @statements = options[:statements] || []
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "parameters", to: :parameters
+          map "return_type", to: :return_type
+          map "types", to: :types
+          map "entities", to: :entities
+          map "subtype_constraints", to: :subtype_constraints
+          map "functions", to: :functions
+          map "procedures", to: :procedures
+          map "constants", to: :constants
+          map "variables", to: :variables
+          map "statements", to: :statements
         end
 
         # @return [Array<Declaration>]
@@ -51,17 +43,17 @@ module Expressir
           [
             *parameters,
             *types,
-            *types.flat_map{|x| x.enumeration_items},
+            *types&.flat_map(&:enumeration_items),
             *entities,
             *subtype_constraints,
             *functions,
             *procedures,
             *constants,
             *variables,
-            *remark_items
+            *remark_items,
           ]
         end
       end
     end
   end
-end
+end

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

@@ -0,0 +1,25 @@
+module Expressir
+  module Model
+    module Declarations
+      # Informal proposition rules are used to specify constraints that cannot be formally expressed
+      class InformalPropositionRule < ModelElement
+        include Identifier
+        include HasInformalPropositions
+
+        attribute :expression, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "expression", to: :expression
+        end
+
+        def children
+          [
+            *remark_items,
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -3,26 +3,35 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 11 Interface specification
-      class Interface < Declaration
-        USE = :USE
-        REFERENCE = :REFERENCE
+      class Interface < ModelElement
+        # A remark may trail the clause: `REFERENCE FROM x; -- why`.
+        include TakesInlineRemark
 
-        model_attr_accessor :kind, ':USE, :REFERENCE'
-        model_attr_accessor :schema, 'Reference'
-        model_attr_accessor :items, 'Array<InterfaceItem>'
+        USE = "USE".freeze
+        REFERENCE = "REFERENCE".freeze
 
-        # @param [Hash] options
-        # @option options [:USE, :REFERENCE] :kind
-        # @option options [Reference] :schema
-        # @option options [Array<InterfaceItem>] :items
-        def initialize(options = {})
-          @kind = options[:kind]
-          @schema = options[:schema]
-          @items = options[:items] || []
+        attribute :kind, :string, values: %w[USE REFERENCE]
+        attribute :schema, ModelElement
+        attribute :items, InterfaceItem, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
 
-          super
+        # Registers :items with the tree-walker registry: the position index
+        # needs the item list to size the clause's span, so an opener-line
+        # remark gets the OPENER_REGION and renders back on the clause's
+        # first line instead of after the closing semicolon.
+        collection_attributes :items
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "kind", to: :kind
+          map "schema", to: :schema
+          map "items", to: :items
+          # Without this the clause's remark survives a format but not a
+          # cache round trip: it would be dropped on serialization and never
+          # come back.
+          map "untagged_remarks", to: :untagged_remarks
         end
       end
     end
   end
-end
+end