expressir 2.4.29-arm-linux

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

@@ -0,0 +1,38 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.2.1 Attributes
+      class Attribute < ModelElement
+        include Identifier
+
+        EXPLICIT = "EXPLICIT".freeze
+        DERIVED = "DERIVED".freeze
+        INVERSE = "INVERSE".freeze
+
+        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 }
+
+        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,
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.4 Constant
+      class Constant < ModelElement
+        include Identifier
+
+        attribute :type, ModelElement
+        attribute :expression, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
+
+        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,
+          ]
+        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

@@ -0,0 +1,62 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.2 Entity declaration
+      class Entity < ModelElement
+        include Identifier
+        include ScopeContainer
+        include HasInformalPropositions
+        include HasWhereRules
+
+        collection_attributes :attributes, :derived_attributes,
+                              :inverse_attributes, :unique_rules,
+                              :where_rules, :informal_propositions,
+                              :remark_items
+
+        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 }
+
+        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,
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.5.1 Function
+      class Function < ModelElement
+        include Identifier
+        include ScopeContainer
+
+        collection_attributes :parameters, :types, :entities,
+                              :subtype_constraints, :functions, :procedures,
+                              :constants, :variables, :statements,
+                              :remark_items
+
+        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 }
+
+        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>]
+        def children
+          [
+            *parameters,
+            *types,
+            *types&.flat_map(&:enumeration_items),
+            *entities,
+            *subtype_constraints,
+            *functions,
+            *procedures,
+            *constants,
+            *variables,
+            *remark_items,
+          ]
+        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

@@ -0,0 +1,37 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 11 Interface specification
+      class Interface < ModelElement
+        # A remark may trail the clause: `REFERENCE FROM x; -- why`.
+        include TakesInlineRemark
+
+        USE = "USE".freeze
+        REFERENCE = "REFERENCE".freeze
+
+        attribute :kind, :string, values: %w[USE REFERENCE]
+        attribute :schema, ModelElement
+        attribute :items, InterfaceItem, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
+
+        # 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

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

@@ -0,0 +1,21 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 11 Interface specification
+      class InterfaceItem < ModelElement
+        include HasId
+
+        attribute :ref, ModelElement
+        attribute :id, :string
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "ref", to: :ref
+          map "id", to: :id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 11 Interface specification
+      class InterfacedItem < ModelElement
+        include HasId
+        include HasRemarks
+
+        attribute :id, :string
+        attribute :remarks, :string, collection: true
+        attribute :remark_items, RemarkItem, collection: true
+        attribute :base_item, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "id", to: :id
+          map "remarks", to: :remarks
+          map "remark_items", to: :remark_items
+          map "base_item", to: :base_item
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *remark_items,
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.2.1 Attributes
+      class InverseAttribute < Attribute
+        include Identifier
+
+        INVERSE = "INVERSE".freeze
+
+        attribute :kind, :string, default: -> { INVERSE }
+        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/parameter.rb

@@ -0,0 +1,28 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.5.3 Parameters
+      class Parameter < ModelElement
+        include Identifier
+
+        attribute :var, :boolean
+        attribute :type, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "var", to: :var
+          map "type", to: :type
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *remark_items,
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.5.2 Procedure
+      class Procedure < ModelElement
+        include Identifier
+        include ScopeContainer
+
+        collection_attributes :parameters, :types, :entities,
+                              :subtype_constraints, :functions, :procedures,
+                              :constants, :variables, :statements,
+                              :remark_items
+
+        attribute :parameters, Parameter, collection: true
+        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 }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "parameters", to: :parameters
+          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>]
+        def children
+          [
+            *parameters,
+            *types,
+            *types&.flat_map(&:enumeration_items),
+            *entities,
+            *subtype_constraints,
+            *functions,
+            *procedures,
+            *constants,
+            *variables,
+            *remark_items,
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Expressir
+  module Model
+    module Declarations
+      # Implicit item with remarks
+      class RemarkItem < ModelElement
+        include HasId
+        include HasRemarks
+
+        attribute :id, :string
+        attribute :remarks, :string, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "id", to: :id
+          map "remarks", to: :remarks
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.6 Rule
+      class Rule < ModelElement
+        include Identifier
+        include ScopeContainer
+        include HasInformalPropositions
+        include HasWhereRules
+
+        collection_attributes :applies_to, :types, :entities,
+                              :subtype_constraints, :functions, :procedures,
+                              :constants, :variables, :statements,
+                              :where_rules, :informal_propositions,
+                              :remark_items
+
+        attribute :applies_to, ModelElement, collection: true
+        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 :where_rules, WhereRule, collection: true
+        attribute :informal_propositions, InformalPropositionRule,
+                  collection: true
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "applies_to", to: :applies_to
+          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
+          map "where_rules", to: :where_rules
+          map "informal_propositions", to: :informal_propositions
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *types,
+            *types&.flat_map(&:enumeration_items),
+            *entities,
+            *subtype_constraints,
+            *functions,
+            *procedures,
+            *constants,
+            *variables,
+            *where_rules,
+            *informal_propositions,
+            *remark_items,
+          ]
+        end
+      end
+    end
+  end
+end