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

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

@@ -4,20 +4,18 @@ module Expressir
       # Specified in ISO 10303-11:2004
       # - section 11 Interface specification
       class InterfaceItem < ModelElement
-        model_attr_accessor :ref, 'Reference'
-        model_attr_accessor :id, 'String'
+        include HasId
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        # @option options [Reference] :ref
-        # @option options [String] :id
-        def initialize(options = {})
-          @ref = options[:ref] 
-          @id = options[:id]
+        attribute :ref, ModelElement
+        attribute :id, :string
+        attribute :_class, :string, default: -> { self.class.name }
 
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "ref", to: :ref
+          map "id", to: :id
         end
       end
     end
   end
-end
+end

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

@@ -4,34 +4,30 @@ module Expressir
       # Specified in ISO 10303-11:2004
       # - section 11 Interface specification
       class InterfacedItem < ModelElement
-        model_attr_accessor :id, 'String'
-        model_attr_accessor :remarks, 'Array<String>'
-        model_attr_accessor :remark_items, 'Array<RemarkItem>'
+        include HasId
+        include HasRemarks
 
-        model_attr_accessor :base_item, 'ModelElement'
+        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 }
 
-        # @param [Hash] options
-        # @option options [String] :id
-        # @option options [Array<String>] :remarks
-        # @option options [Array<RemarkItem>] :remark_items
-        # @option options [ModelElement] :base_item
-        def initialize(options = {})
-          @id = options[:id]
-          @remarks = options[:remarks] || []
-          @remark_items = options[:remark_items] || []
-
-          @base_item = options[:base_item]
-
-          super
+        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
+            *remark_items,
           ]
         end
       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

@@ -3,32 +3,26 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 9.5.3 Parameters
-      class Parameter < Declaration
+      class Parameter < ModelElement
         include Identifier
 
-        model_attr_accessor :var, 'Boolean'
-        model_attr_accessor :type, 'DataType'
+        attribute :var, :boolean
+        attribute :type, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        # @option options [Boolean] :var
-        # @option options [DataType] :type
-        def initialize(options = {})
-          initialize_identifier(options)
-
-          @var = options[:var]
-          @type = options[:type]
-
-          super
+        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
+            *remark_items,
           ]
         end
       end
     end
   end
-end
+end

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

@@ -3,44 +3,37 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 9.5.2 Procedure
-      class Procedure < Declaration
+      class Procedure < ModelElement
         include Identifier
+        include ScopeContainer
 
-        model_attr_accessor :parameters, 'Array<Parameter>'
-        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 [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 :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] || []
-          @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 "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>]
@@ -48,17 +41,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/remark_item.rb

@@ -2,20 +2,20 @@ module Expressir
   module Model
     module Declarations
       # Implicit item with remarks
-      class RemarkItem < Declaration
-        model_attr_accessor :id, 'String'
-        model_attr_accessor :remarks, 'Array<String>'
+      class RemarkItem < ModelElement
+        include HasId
+        include HasRemarks
 
-        # @param [Hash] options
-        # @option options [String] :id
-        # @option options [Array<String>] :remarks
-        def initialize(options = {})
-          @id = options[:id]
-          @remarks = options[:remarks] || []
+        attribute :id, :string
+        attribute :remarks, :string, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
 
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "id", to: :id
+          map "remarks", to: :remarks
         end
       end
     end
   end
-end
+end

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

@@ -3,57 +3,52 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 9.6 Rule
-      class Rule < Declaration
+      class Rule < ModelElement
         include Identifier
+        include ScopeContainer
+        include HasInformalPropositions
+        include HasWhereRules
 
-        model_attr_accessor :applies_to, 'Array<Reference>'
-        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>'
-        model_attr_accessor :where_rules, 'Array<WhereRule>'
-        model_attr_accessor :informal_propositions, 'Array<RemarkItem>'
+        collection_attributes :applies_to, :types, :entities,
+                              :subtype_constraints, :functions, :procedures,
+                              :constants, :variables, :statements,
+                              :where_rules, :informal_propositions,
+                              :remark_items
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        # @option options [Array<Reference>] :applies_to
-        # @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
-        # @option options [Array<WhereRule>] :where_rules
-        # @option options [Array<RemarkItem>] :informal_propositions
-        def initialize(options = {})
-          initialize_identifier(options)
+        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 }
 
-          @applies_to = options[:applies_to] || []
-          @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] || []
-          @where_rules = options[:where_rules] || []
-          @informal_propositions = options[:informal_propositions] || []
-
-          super
+        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{|x| x.enumeration_items},
+            *types&.flat_map(&:enumeration_items),
             *entities,
             *subtype_constraints,
             *functions,
@@ -62,10 +57,10 @@ module Expressir
             *variables,
             *where_rules,
             *informal_propositions,
-            *remark_items
+            *remark_items,
           ]
         end
       end
     end
   end
-end
+end