expressir 2.1.13 → 2.1.14

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

@@ -3,29 +3,21 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 9.7 Subtype constraints
-      class SubtypeConstraint < Declaration
+      class SubtypeConstraint < ModelElement
         include Identifier
 
-        model_attr_accessor :applies_to, "Reference"
-        model_attr_accessor :abstract, "Boolean"
-        model_attr_accessor :total_over, "Array<Reference>"
-        model_attr_accessor :supertype_expression, "SupertypeExpression"
+        attribute :applies_to, ModelElement
+        attribute :abstract, :boolean
+        attribute :total_over, ModelElement, collection: true
+        attribute :supertype_expression, ModelElement
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        # @option options [Reference] :applies_to
-        # @option options [Boolean] :abstract
-        # @option options [Array<Reference>] :total_over
-        # @option options [SupertypeExpression] :supertype_expression
-        def initialize(options = {})
-          initialize_identifier(options)
-
-          @applies_to = options[:applies_to]
-          @abstract = options[:abstract]
-          @total_over = options[:total_over] || []
-          @supertype_expression = options[:supertype_expression]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "applies_to", to: :applies_to
+          map "abstract", to: :abstract
+          map "total_over", to: :total_over
+          map "supertype_expression", to: :supertype_expression
         end
 
         # @return [Array<Declaration>]

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

@@ -3,26 +3,19 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 9.1 Type declaration
-      class Type < Declaration
+      class Type < ModelElement
         include Identifier
 
-        model_attr_accessor :underlying_type, "DataType"
-        model_attr_accessor :where_rules, "Array<WhereRule>"
-        model_attr_accessor :informal_propositions, "Array<RemarkItem>"
+        attribute :underlying_type, ModelElement
+        attribute :where_rules, WhereRule, collection: true
+        attribute :informal_propositions, RemarkItem, collection: true
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        # @option options [DataType] :underlying_type
-        # @option options [Array<WhereRule>] :where_rules
-        # @option options [Array<RemarkItem>] :informal_propositions
-        def initialize(options = {})
-          initialize_identifier(options)
-
-          @underlying_type = options[:underlying_type]
-          @where_rules = options[:where_rules] || []
-          @informal_propositions = options[:informal_propositions] || []
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "underlying_type", to: :underlying_type
+          map "where_rules", to: :where_rules
+          map "informal_propositions", to: :informal_propositions
         end
 
         # @return [Array<DataTypes::EnumerationItem>]

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

@@ -3,20 +3,15 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 9.2.2.1 Uniqueness rule
-      class UniqueRule < Declaration
+      class UniqueRule < ModelElement
         include Identifier
 
-        model_attr_accessor :attributes, "Reference"
+        attribute :attributes, ModelElement, collection: true
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        # @option options [Reference] :attributes
-        def initialize(options = {})
-          initialize_identifier(options)
-
-          @attributes = options[:attributes] || []
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "attributes", to: :attributes
         end
 
         # @return [Array<Declaration>]

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

@@ -3,23 +3,17 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 9.5.4 Local variables
-      class Variable < Declaration
+      class Variable < ModelElement
         include Identifier
 
-        model_attr_accessor :type, "DataType"
-        model_attr_accessor :expression, "Expression"
+        attribute :type, ModelElement
+        attribute :expression, ModelElement
+        attribute :_class, :string, default: -> { send(: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>]

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

@@ -3,20 +3,15 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 9.2.2.2 Domain rules (WHERE clause)
-      class WhereRule < Declaration
+      class WhereRule < ModelElement
         include Identifier
 
-        model_attr_accessor :expression, "Expression"
+        attribute :expression, ModelElement
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        # @option options [Expression] :expression
-        def initialize(options = {})
-          initialize_identifier(options)
-
-          @expression = options[:expression]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "expression", to: :expression
         end
 
         # @return [Array<Declaration>]

data/lib/expressir/model/expressions/aggregate_initializer.rb

@@ -3,15 +3,13 @@ module Expressir
     module Expressions
       # Specified in ISO 10303-11:2004
       # - section 12.9 Aggregate initializer
-      class AggregateInitializer < Expression
-        model_attr_accessor :items, "Array<AggregateInitializerItem>"
+      class AggregateInitializer < ModelElement
+        attribute :items, ModelElement, collection: true
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option options [Array<AggregateInitializerItem>] :items
-        def initialize(options = {})
-          @items = options[:items] || []
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "items", to: :items
         end
       end
     end

data/lib/expressir/model/expressions/aggregate_initializer_item.rb

@@ -3,18 +3,15 @@ module Expressir
     module Expressions
       # Specified in ISO 10303-11:2004
       # - section 12.9 Aggregate initializer
-      class AggregateInitializerItem < Expression
-        model_attr_accessor :expression, "Expression"
-        model_attr_accessor :repetition, "Expression"
+      class AggregateInitializerItem < ModelElement
+        attribute :expression, ModelElement
+        attribute :repetition, ModelElement
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option options [Expression] :expression
-        # @option options [Expression] :repetition
-        def initialize(options = {})
-          @expression = options[:expression]
-          @repetition = options[:repetition]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "expression", to: :expression
+          map "repetition", to: :repetition
         end
       end
     end

data/lib/expressir/model/expressions/binary_expression.rb

@@ -9,50 +9,48 @@ module Expressir
       # - section 12.5 String operators
       # - section 12.6 Aggregate operators
       # - section 12.10 Complex entity instance construction operator
-      class BinaryExpression < Expression
-        ADDITION = :ADDITION
-        AND = :AND
-        COMBINE = :COMBINE
-        EQUAL = :EQUAL
-        EXPONENTIATION = :EXPONENTIATION
-        GREATER_THAN = :GREATER_THAN
-        GREATER_THAN_OR_EQUAL = :GREATER_THAN_OR_EQUAL
-        IN = :IN
-        INSTANCE_EQUAL = :INSTANCE_EQUAL
-        INSTANCE_NOT_EQUAL = :INSTANCE_NOT_EQUAL
-        INTEGER_DIVISION = :INTEGER_DIVISION
-        LESS_THAN = :LESS_THAN
-        LESS_THAN_OR_EQUAL = :LESS_THAN_OR_EQUAL
-        LIKE = :LIKE
-        MODULO = :MODULO
-        MULTIPLICATION = :MULTIPLICATION
-        NOT_EQUAL = :NOT_EQUAL
-        OR = :OR
-        REAL_DIVISION = :REAL_DIVISION
-        SUBTRACTION = :SUBTRACTION
-        XOR = :XOR
+      class BinaryExpression < ModelElement
+        ADDITION = "ADDITION".freeze
+        AND = "AND".freeze
+        COMBINE = "COMBINE".freeze
+        EQUAL = "EQUAL".freeze
+        EXPONENTIATION = "EXPONENTIATION".freeze
+        GREATER_THAN = "GREATER_THAN".freeze
+        GREATER_THAN_OR_EQUAL = "GREATER_THAN_OR_EQUAL".freeze
+        IN = "IN".freeze
+        INSTANCE_EQUAL = "INSTANCE_EQUAL".freeze
+        INSTANCE_NOT_EQUAL = "INSTANCE_NOT_EQUAL".freeze
+        INTEGER_DIVISION = "INTEGER_DIVISION".freeze
+        LESS_THAN = "LESS_THAN".freeze
+        LESS_THAN_OR_EQUAL = "LESS_THAN_OR_EQUAL".freeze
+        LIKE = "LIKE".freeze
+        MODULO = "MODULO".freeze
+        MULTIPLICATION = "MULTIPLICATION".freeze
+        NOT_EQUAL = "NOT_EQUAL".freeze
+        OR = "OR".freeze
+        REAL_DIVISION = "REAL_DIVISION".freeze
+        SUBTRACTION = "SUBTRACTION".freeze
+        XOR = "XOR".freeze
 
-        model_attr_accessor :operator,
-                            ":ADDITION, :AND, :COMBINE, :EQUAL, :EXPONENTIATION, :GREATER_THAN, \
-                             :GREATER_THAN_OR_EQUAL, :IN, :INSTANCE_EQUAL, :INSTANCE_NOT_EQUAL, \
-                             :INTEGER_DIVISION, :LESS_THAN, :LESS_THAN_OR_EQUAL, :LIKE, :MODULO,\
-                             :MULTIPLICATION, :NOT_EQUAL, :OR, :REAL_DIVISION, :SUBTRACTION, :XOR"
-        model_attr_accessor :operand1, "Expression"
-        model_attr_accessor :operand2, "Expression"
+        attribute :operator, :string,
+                  values: %w[
+                    ADDITION AND COMBINE EQUAL EXPONENTIATION
+                    GREATER_THAN
+                    GREATER_THAN_OR_EQUAL IN INSTANCE_EQUAL
+                    INSTANCE_NOT_EQUAL
+                    INTEGER_DIVISION LESS_THAN LESS_THAN_OR_EQUAL LIKE
+                    MODULO MULTIPLICATION NOT_EQUAL OR REAL_DIVISION
+                    SUBTRACTION XOR
+                  ]
+        attribute :operand1, ModelElement
+        attribute :operand2, ModelElement
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option options [:ADDITION, :AND, :COMBINE, :EQUAL, :EXPONENTIATION, :GREATER_THAN,
-        #                  :GREATER_THAN_OR_EQUAL, :IN, :INSTANCE_EQUAL, :INSTANCE_NOT_EQUAL,
-        #                  :INTEGER_DIVISION, :LESS_THAN, :LESS_THAN_OR_EQUAL, :LIKE, :MODULO,
-        #                  :MULTIPLICATION, :NOT_EQUAL, :OR, :REAL_DIVISION, :SUBTRACTION, :XOR] :operator
-        # @option options [Expression] :operand1
-        # @option options [Expression] :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

data/lib/expressir/model/expressions/entity_constructor.rb

@@ -3,18 +3,15 @@ module Expressir
     module Expressions
       # Specified in ISO 10303-11:2004
       # - section 9.2.6 Implicit declarations
-      class EntityConstructor < Expression
-        model_attr_accessor :entity, "Reference"
-        model_attr_accessor :parameters, "Array<Expression>"
+      class EntityConstructor < ModelElement
+        attribute :entity, ModelElement
+        attribute :parameters, ModelElement, collection: true
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option options [Reference] :entity
-        # @option options [Array<Expression>] :parameters
-        def initialize(options = {})
-          @entity = options[:entity]
-          @parameters = options[:parameters] || []
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "entity", to: :entity
+          map "parameters", to: :parameters
         end
       end
     end

data/lib/expressir/model/expressions/function_call.rb

@@ -3,18 +3,15 @@ module Expressir
     module Expressions
       # Specified in ISO 10303-11:2004
       # - section 12.8 Function call
-      class FunctionCall < Expression
-        model_attr_accessor :function, "Reference"
-        model_attr_accessor :parameters, "Array<Expression>"
+      class FunctionCall < ModelElement
+        attribute :function, ModelElement
+        attribute :parameters, ModelElement, collection: true
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option options [Reference] :function
-        # @option options [Array<Expression>] :parameters
-        def initialize(options = {})
-          @function = options[:function]
-          @parameters = options[:parameters]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "function", to: :function
+          map "parameters", to: :parameters
         end
       end
     end

data/lib/expressir/model/expressions/interval.rb

@@ -3,30 +3,24 @@ module Expressir
     module Expressions
       # Specified in ISO 10303-11:2004
       # - section 12.2.4 Interval expressions
-      class Interval < Expression
-        LESS_THAN = :LESS_THAN
-        LESS_THAN_OR_EQUAL = :LESS_THAN_OR_EQUAL
+      class Interval < ModelElement
+        LESS_THAN = "LESS_THAN".freeze
+        LESS_THAN_OR_EQUAL = "LESS_THAN_OR_EQUAL".freeze
 
-        model_attr_accessor :low, "Expression"
-        model_attr_accessor :operator1, ":LESS_THAN, :LESS_THAN_OR_EQUAL"
-        model_attr_accessor :item, "Reference"
-        model_attr_accessor :operator2, ":LESS_THAN, :LESS_THAN_OR_EQUAL"
-        model_attr_accessor :high, "Expression"
+        attribute :low, ModelElement
+        attribute :operator1, :string, values: %w[LESS_THAN LESS_THAN_OR_EQUAL]
+        attribute :item, ModelElement
+        attribute :operator2, :string, values: %w[LESS_THAN LESS_THAN_OR_EQUAL]
+        attribute :high, ModelElement
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option options [Expression] :low
-        # @option options [:LESS_THAN, :LESS_THAN_OR_EQUAL] :operator1
-        # @option options [Reference] :item
-        # @option options [:LESS_THAN, :LESS_THAN_OR_EQUAL] :operator2
-        # @option options [Expression] :high
-        def initialize(options = {})
-          @low = options[:low]
-          @operator1 = options[:operator1]
-          @item = options[:item]
-          @operator2 = options[:operator2]
-          @high = options[:high]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "low", to: :low
+          map "operator1", to: :operator1
+          map "item", to: :item
+          map "operator2", to: :operator2
+          map "high", to: :high
         end
       end
     end

data/lib/expressir/model/expressions/query_expression.rb

@@ -3,23 +3,17 @@ module Expressir
     module Expressions
       # Specified in ISO 10303-11:2004
       # - section 12.6.7 Query expression
-      class QueryExpression < Expression
+      class QueryExpression < ModelElement
         include Identifier
 
-        model_attr_accessor :aggregate_source, "Reference"
-        model_attr_accessor :expression, "Expression"
+        attribute :aggregate_source, ModelElement
+        attribute :expression, ModelElement
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        # @option options [Reference] :aggregace_source
-        # @option options [Expression] :expression
-        def initialize(options = {})
-          initialize_identifier(options)
-
-          @aggregate_source = options[:aggregate_source]
-          @expression = options[:expression]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "aggregate_source", to: :aggregate_source
+          map "expression", to: :expression
         end
 
         # @return [Array<Declaration>]

data/lib/expressir/model/expressions/unary_expression.rb

@@ -4,22 +4,19 @@ module Expressir
       # Specified in ISO 10303-11:2004
       # - section 12.1 Arithmetic operators
       # - section 12.4.1 NOT operator
-      class UnaryExpression < Expression
-        MINUS = :MINUS
-        NOT = :NOT
-        PLUS = :PLUS
+      class UnaryExpression < ModelElement
+        MINUS = "MINUS".freeze
+        NOT = "NOT".freeze
+        PLUS = "PLUS".freeze
 
-        model_attr_accessor :operator, ":MINUS, :NOT, :PLUS"
-        model_attr_accessor :operand, "Expression"
+        attribute :operator, :string, values: %w[MINUS NOT PLUS]
+        attribute :operand, ModelElement
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option options [:MINUS, :NOT, :PLUS] :operator
-        # @option options [Expression] :operand
-        def initialize(options = {})
-          @operator = options[:operator]
-          @operand = options[:operand]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "operator", to: :operator
+          map "operand", to: :operand
         end
       end
     end

data/lib/expressir/model/identifier.rb

@@ -1,33 +1,16 @@
 module Expressir
   module Model
     module Identifier
-      # @!attribute id
-      #   @return [::String]
-      # @!attribute remarks
-      #   @return [::Array<::String>]
-      # @!attribute remark_items
-      #   @return [::Array<RemarkItem>]
-      # @!attribute source
-      #   @return [::String]
-      # @!visibility private
       def self.included(mod)
-        mod.model_attr_accessor :id, "::String"
-        mod.model_attr_accessor :remarks, "::Array<::String>"
-        mod.model_attr_accessor :remark_items, "::Array<RemarkItem>"
-        mod.model_attr_accessor :source, "::String"
-      end
+        mod.attribute :id, :string
+        mod.attribute :remarks, :string, collection: true
+        mod.attribute :remark_items, ::Expressir::Model::Declarations::RemarkItem, collection: true
 
-      # @param [Hash] options
-      # @option options [::String] :id
-      # @option options [::Array<::String>] :remarks
-      # @option options [::Array<RemarkItem>] :remark_items
-      # @option options [::String] :source
-      # @!visibility private
-      def initialize_identifier(options = {})
-        @id = options[:id]
-        @remarks = options[:remarks] || []
-        @remark_items = options[:remark_items] || []
-        @source = options[:source]
+        mod.key_value do
+          map "id", to: :id
+          map "remarks", to: :remarks
+          map "remark_items", to: :remark_items
+        end
       end
     end
   end

data/lib/expressir/model/literals/binary.rb

@@ -3,15 +3,13 @@ module Expressir
     module Literals
       # Specified in ISO 10303-11:2004
       # - section 7.5.1 Binary literal
-      class Binary < Literal
-        model_attr_accessor :value, "::String"
+      class Binary < ModelElement
+        attribute :value, :string
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option options [::String] :value
-        def initialize(options = {})
-          @value = options[:value]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "value", to: :value
         end
       end
     end

data/lib/expressir/model/literals/integer.rb

@@ -3,15 +3,13 @@ module Expressir
     module Literals
       # Specified in ISO 10303-11:2004
       # - section 7.5.2 Integer literal
-      class Integer < Literal
-        model_attr_accessor :value, "::String"
+      class Integer < ModelElement
+        attribute :value, :string
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option options [::String] :value
-        def initialize(options = {})
-          @value = options[:value]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "value", to: :value
         end
       end
     end

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

@@ -3,19 +3,17 @@ module Expressir
     module Literals
       # Specified in ISO 10303-11:2004
       # - section 7.5.5 Logical literal
-      class Logical < Literal
-        TRUE = :TRUE
-        FALSE = :FALSE
-        UNKNOWN = :UNKNOWN
+      class Logical < ModelElement
+        TRUE = "TRUE".freeze
+        FALSE = "FALSE".freeze
+        UNKNOWN = "UNKNOWN".freeze
 
-        model_attr_accessor :value, ":TRUE, :FALSE, :UNKNOWN"
+        attribute :value, :string, values: %w[TRUE FALSE UNKNOWN]
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option options [:TRUE, :FALSE, :UNKNOWN] :value
-        def initialize(options = {})
-          @value = options[:value]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "value", to: :value
         end
       end
     end

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

@@ -3,15 +3,13 @@ module Expressir
     module Literals
       # Specified in ISO 10303-11:2004
       # - section 7.5.3 Real literal
-      class Real < Literal
-        model_attr_accessor :value, "::String"
+      class Real < ModelElement
+        attribute :value, :string
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option options [::String] :value
-        def initialize(options = {})
-          @value = options[:value]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "value", to: :value
         end
       end
     end