expressir 2.1.13 → 2.1.14

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

@@ -3,20 +3,15 @@ module Expressir
     module DataTypes
       # Specified in ISO 10303-11:2004
       # - section 9.5.3.1 Aggregate data type
-      class Aggregate < DataType
+      class Aggregate < ModelElement
         include Identifier
 
-        model_attr_accessor :base_type, "Type"
+        attribute :base_type, ModelElement
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        # @option options [Type] :base_type
-        def initialize(options = {})
-          initialize_identifier(options)
-
-          @base_type = options[:base_type]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "base_type", to: :base_type
         end
 
         # @return [Array<Declaration>]

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

@@ -3,27 +3,21 @@ module Expressir
     module DataTypes
       # Specified in ISO 10303-11:2004
       # - section 8.2.1 Array data type
-      class Array < DataType
-        model_attr_accessor :bound1, "Expression"
-        model_attr_accessor :bound2, "Expression"
-        model_attr_accessor :optional, "::Boolean"
-        model_attr_accessor :unique, "::Boolean"
-        model_attr_accessor :base_type, "DataType"
+      class Array < ModelElement
+        attribute :bound1, ModelElement
+        attribute :bound2, ModelElement
+        attribute :optional, :boolean
+        attribute :unique, :boolean
+        attribute :base_type, ModelElement
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option options [Expression] :bound1
-        # @option options [Expression] :bound2
-        # @option options [::Boolean] :optional
-        # @option options [::Boolean] :unique
-        # @option options [DataType] :base_type
-        def initialize(options = {})
-          @bound1 = options[:bound1]
-          @bound2 = options[:bound2]
-          @optional = options[:optional]
-          @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 "optional", to: :optional
+          map "unique", to: :unique
+          map "base_type", to: :base_type
         end
       end
     end

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

@@ -3,21 +3,17 @@ module Expressir
     module DataTypes
       # Specified in ISO 10303-11:2004
       # - section 8.2.3 Bag data type
-      class Bag < DataType
-        model_attr_accessor :bound1, "Expression"
-        model_attr_accessor :bound2, "Expression"
-        model_attr_accessor :base_type, "DataType"
+      class Bag < ModelElement
+        attribute :bound1, ModelElement
+        attribute :bound2, ModelElement
+        attribute :base_type, ModelElement
+        attribute :_class, :string, default: -> { send(: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

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

@@ -3,18 +3,15 @@ module Expressir
     module DataTypes
       # Specified in ISO 10303-11:2004
       # - section 8.1.7 Binary data type
-      class Binary < DataType
-        model_attr_accessor :width, "Expression"
-        model_attr_accessor :fixed, "::Boolean"
+      class Binary < ModelElement
+        attribute :width, ModelElement
+        attribute :fixed, :boolean
+        attribute :_class, :string, default: -> { send(: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

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

@@ -3,7 +3,12 @@ module Expressir
     module DataTypes
       # Specified in ISO 10303-11:2004
       # - section 8.1.5 Boolean data type
-      class Boolean < DataType
+      class Boolean < ModelElement
+        attribute :_class, :string, default: -> { send(:name) }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+        end
       end
     end
   end

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

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

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

@@ -6,12 +6,10 @@ module Expressir
       class EnumerationItem < ModelElement
         include Identifier
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        def initialize(options = {})
-          initialize_identifier(options)
+        attribute :_class, :string, default: -> { send(:name) }
 
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
         end
 
         # @return [Array<Declaration>]

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

@@ -3,15 +3,13 @@ module Expressir
     module DataTypes
       # Specified in ISO 10303-11:2004
       # - section 9.5.3.2 Generic data type
-      class Generic < DataType
+      class Generic < ModelElement
         include Identifier
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        def initialize(options = {})
-          initialize_identifier(options)
+        attribute :_class, :string, default: -> { send(:name) }
 
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
         end
 
         # @return [Array<Declaration>]

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

@@ -3,15 +3,13 @@ module Expressir
     module DataTypes
       # Specified in ISO 10303-11:2004
       # - section 9.5.3.3 Generic entity data type
-      class GenericEntity < DataType
+      class GenericEntity < ModelElement
         include Identifier
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        def initialize(options = {})
-          initialize_identifier(options)
+        attribute :_class, :string, default: -> { send(:name) }
 
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
         end
       end
 

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

@@ -3,7 +3,12 @@ module Expressir
     module DataTypes
       # Specified in ISO 10303-11:2004
       # - section 8.1.3 Integer data type
-      class Integer < DataType
+      class Integer < ModelElement
+        attribute :_class, :string, default: -> { send(:name) }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+        end
       end
     end
   end

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

@@ -3,24 +3,19 @@ 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: -> { send(: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

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

@@ -3,7 +3,12 @@ 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: -> { send(:name) }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+        end
       end
     end
   end

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

@@ -3,7 +3,12 @@ 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: -> { send(:name) }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+        end
       end
     end
   end

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

@@ -3,15 +3,13 @@ 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: -> { send(: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

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

@@ -3,24 +3,19 @@ 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: -> { send(: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

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

@@ -3,21 +3,17 @@ 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: -> { send(: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

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

@@ -3,18 +3,15 @@ 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: -> { send(: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

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

@@ -3,36 +3,27 @@ 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: -> { send(: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>]

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

@@ -3,23 +3,17 @@ 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: -> { 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/entity.rb

@@ -3,38 +3,27 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 9.2 Entity declaration
-      class Entity < Declaration
+      class Entity < ModelElement
         include Identifier
 
-        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>"
+        attribute :abstract, :boolean
+        attribute :supertype_expression, ModelElement
+        attribute :subtype_of, ModelElement, collection: true
+        attribute :attributes, Attribute, collection: true
+        attribute :unique_rules, UniqueRule, collection: true
+        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 [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)
-
-          @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 "unique_rules", to: :unique_rules
+          map "where_rules", to: :where_rules
+          map "informal_propositions", to: :informal_propositions
         end
 
         # @return [Array<Declaration>]