expressir 2.1.13 → 2.1.14

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

@@ -3,47 +3,33 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 9.5.1 Function
-      class Function < Declaration
+      class Function < ModelElement
         include Identifier
 
-        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>"
+        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: -> { send(:name) }
 
-        # @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)
-
-          @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,7 +37,7 @@ module Expressir
           [
             *parameters,
             *types,
-            *types.flat_map(&:enumeration_items),
+            *types&.flat_map(&:enumeration_items),
             *entities,
             *subtype_constraints,
             *functions,

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

@@ -3,24 +3,20 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 11 Interface specification
-      class Interface < Declaration
-        USE = :USE
-        REFERENCE = :REFERENCE
+      class Interface < ModelElement
+        USE = "USE".freeze
+        REFERENCE = "REFERENCE".freeze
 
-        model_attr_accessor :kind, ":USE, :REFERENCE"
-        model_attr_accessor :schema, "Reference"
-        model_attr_accessor :items, "Array<InterfaceItem>"
+        attribute :kind, :string, values: %w[USE REFERENCE]
+        attribute :schema, ModelElement
+        attribute :items, InterfaceItem, collection: true
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @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] || []
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "kind", to: :kind
+          map "schema", to: :schema
+          map "items", to: :items
         end
       end
     end

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

@@ -4,18 +4,14 @@ 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"
+        attribute :ref, ModelElement
+        attribute :id, :string
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @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]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "ref", to: :ref
+          map "id", to: :id
         end
       end
     end

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

@@ -4,25 +4,18 @@ 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>"
+        attribute :id, :string
+        attribute :remarks, :string, collection: true
+        attribute :remark_items, RemarkItem, collection: true
+        attribute :base_item, ModelElement
+        attribute :_class, :string, default: -> { send(:name) }
 
-        model_attr_accessor :base_item, "ModelElement"
-
-        # @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>]

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

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

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

@@ -3,44 +3,31 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 9.5.2 Procedure
-      class Procedure < Declaration
+      class Procedure < ModelElement
         include Identifier
 
-        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>"
+        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: -> { send(:name) }
 
-        # @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)
-
-          @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,7 +35,7 @@ module Expressir
           [
             *parameters,
             *types,
-            *types.flat_map(&:enumeration_items),
+            *types&.flat_map(&:enumeration_items),
             *entities,
             *subtype_constraints,
             *functions,

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

@@ -2,18 +2,15 @@ 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
+        attribute :id, :string
+        attribute :remarks, :string, collection: true
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option options [String] :id
-        # @option options [Array<String>] :remarks
-        def initialize(options = {})
-          @id = options[:id]
-          @remarks = options[:remarks] || []
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "id", to: :id
+          map "remarks", to: :remarks
         end
       end
     end

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

@@ -3,57 +3,42 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 9.6 Rule
-      class Rule < Declaration
+      class Rule < ModelElement
         include Identifier
 
-        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>"
+        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, RemarkItem, collection: true
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @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)
-
-          @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(&:enumeration_items),
+            *types&.flat_map(&:enumeration_items),
             *entities,
             *subtype_constraints,
             *functions,

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

@@ -3,49 +3,40 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 9.3 Schema
-      class Schema < Declaration
-        model_attr_accessor :file, "String"
-
+      class Schema < ModelElement
         include Identifier
 
-        model_attr_accessor :version, "SchemaVersion"
-        model_attr_accessor :interfaces, "Array<Interface>"
-        model_attr_accessor :constants, "Array<Constant>"
-        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 :rules, "Array<Rule>"
-        model_attr_accessor :procedures, "Array<Procedure>"
-
-        # @param [Hash] options
-        # @option options [String] :file
-        # @option (see Identifier#initialize_identifier)
-        # @option options [SchemaVersion] :version
-        # @option options [Array<Interface>] :interfaces
-        # @option options [Array<Constant>] :constants
-        # @option options [Array<Type>] :types
-        # @option options [Array<Entity>] :entities
-        # @option options [Array<SubtypeConstraint>] :subtype_constraints
-        # @option options [Array<Function>] :functions
-        # @option options [Array<Rule>] :rules
-        # @option options [Array<Procedure>] :procedures
-        def initialize(options = {})
-          @file = options[:file]
-
-          initialize_identifier(options)
+        attribute :file, :string
+        attribute :version, SchemaVersion
+        attribute :interfaces, Interface, collection: true
+        attribute :constants, Constant, collection: true
+        attribute :types, ModelElement, collection: true
+        attribute :entities, Entity, collection: true
+        attribute :subtype_constraints, SubtypeConstraint, collection: true
+        attribute :functions, Function, collection: true
+        attribute :rules, Rule, collection: true
+        attribute :procedures, Procedure, collection: true
+        attribute :_class, :string, default: -> { send(:name) }
+        attribute :selected, :boolean, default: false
+        attribute :formatted, :string
+        attribute :file_basename, :string
+        attribute :full_source, :string
 
-          @version = options[:version]
-          @interfaces = options[:interfaces] || []
-          @constants = options[:constants] || []
-          @types = options[:types] || []
-          @entities = options[:entities] || []
-          @subtype_constraints = options[:subtype_constraints] || []
-          @functions = options[:functions] || []
-          @rules = options[:rules] || []
-          @procedures = options[:procedures] || []
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "id", to: :id
+          map "file", to: :file
+          map "remarks", to: :remarks
+          map "remark_items", to: :remark_items
+          map "version", to: :version
+          map "interfaces", to: :interfaces
+          map "constants", to: :constants
+          map "types", to: :types
+          map "entities", to: :entities
+          map "subtype_constraints", to: :subtype_constraints
+          map "functions", to: :functions
+          map "rules", to: :rules
+          map "procedures", to: :procedures
         end
 
         # @return [Array<Declaration>]
@@ -53,7 +44,7 @@ module Expressir
           [
             *constants,
             *types,
-            *types.flat_map(&:enumeration_items),
+            *types&.flat_map(&:enumeration_items),
             *entities,
             *subtype_constraints,
             *functions,
@@ -71,6 +62,17 @@ module Expressir
           ]
         end
 
+        def full_source
+          Expressir::Express::Formatter.format(self)
+        end
+
+        def source
+          formatter = Class.new(Expressir::Express::Formatter) do
+            include Expressir::Express::SchemaHeadFormatter
+          end
+          formatter.format(self)
+        end
+
         private
 
         # @param [String] id
@@ -91,25 +93,24 @@ module Expressir
 
           interfaces.flat_map do |interface|
             schema = parent.children_by_id[interface.schema.id.safe_downcase]
-            if schema
-              schema_safe_children = schema.safe_children
-              schema_safe_children_by_id = schema_safe_children.select(&:id).map { |x| [x.id.safe_downcase, x] }.to_h
-              if interface.items.length.positive?
-                interface.items.map do |interface_item|
-                  base_item = schema_safe_children_by_id[interface_item.ref.id.safe_downcase]
-                  if base_item
-                    id = interface_item.id || base_item.id
-                    create_interfaced_item(id, base_item)
-                  end
-                end
-              else
-                schema_safe_children.map do |base_item|
-                  id = base_item.id
-                  create_interfaced_item(id, base_item)
-                end
+            next [] unless schema
+
+            safe_children = schema.safe_children
+            children_by_id = safe_children.each_with_object({}) do |child, hash|
+              hash[child.id.safe_downcase] = child if child.id
+            end
+
+            if interface.items.empty?
+              safe_children.map do |base_item|
+                create_interfaced_item(base_item.id, base_item)
+              end
+            else
+              interface.items.filter_map do |item|
+                base_item = children_by_id[item.ref.id.safe_downcase]
+                create_interfaced_item(item.id || base_item.id, base_item) if base_item
               end
             end
-          end.select { |x| x }
+          end.compact
         end
       end
     end

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

@@ -4,17 +4,14 @@ module Expressir
       # Specified in ISO 10303-11:2004
       # - section 9.3 Schema
       class SchemaVersion < ModelElement
-        model_attr_accessor :value, "String"
-        model_attr_accessor :items, "Array<SchemaVersionItem>"
+        attribute :value, :string
+        attribute :items, SchemaVersionItem, collection: true
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option options [String] :value
-        # @option options [Array<SchemaVersionItem>] :items
-        def initialize(options = {})
-          @value = options[:value]
-          @items = options[:items] || []
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "value", to: :value
+          map "items", to: :items
         end
       end
     end

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

@@ -4,17 +4,14 @@ module Expressir
       # Specified in ISO 10303-11:2004
       # - section 9.3 Schema
       class SchemaVersionItem < ModelElement
-        model_attr_accessor :name, "String"
-        model_attr_accessor :value, "String"
+        attribute :name, :string
+        attribute :value, :string
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option options [String] :name
-        # @option options [String] :value
-        def initialize(options = {})
-          @name = options[:name]
-          @value = options[:value]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "name", to: :name
+          map "value", to: :value
         end
       end
     end