expressir 0.2.26-arm64-darwin → 1.2.0-arm64-darwin

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

@@ -0,0 +1,23 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 11 Interface specification
+      class InterfaceItem < ModelElement
+        model_attr_accessor :ref, 'Reference'
+        model_attr_accessor :id, 'String'
+
+        # @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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Expressir
+  module Model
+    module Declarations
+      # 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>'
+
+        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
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *remark_items
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.5.3 Parameters
+      class Parameter < Declaration
+        include Identifier
+
+        model_attr_accessor :var, 'Boolean'
+        model_attr_accessor :type, 'DataType'
+
+        # @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
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *remark_items
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.5.2 Procedure
+      class Procedure < Declaration
+        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>'
+
+        # @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
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *parameters,
+            *types,
+            *types.flat_map{|x| x.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 < Declaration
+        model_attr_accessor :id, 'String'
+        model_attr_accessor :remarks, 'Array<String>'
+
+        # @param [Hash] options
+        # @option options [String] :id
+        # @option options [Array<String>] :remarks
+        def initialize(options = {})
+          @id = options[:id]
+          @remarks = options[:remarks] || []
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.6 Rule
+      class Rule < Declaration
+        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>'
+
+        # @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
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *types,
+            *types.flat_map{|x| x.enumeration_items},
+            *entities,
+            *subtype_constraints,
+            *functions,
+            *procedures,
+            *constants,
+            *variables,
+            *where_rules,
+            *informal_propositions,
+            *remark_items
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.3 Schema
+      class Schema < Declaration
+        model_attr_accessor :file, 'String'
+
+        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)
+
+          @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
+        end
+
+        # @return [Array<Declaration>]
+        def safe_children
+          [
+            *constants,
+            *types,
+            *types.flat_map{|x| x.enumeration_items},
+            *entities,
+            *subtype_constraints,
+            *functions,
+            *rules,
+            *procedures,
+            *remark_items
+          ]
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *interfaced_items,
+            *safe_children
+          ]
+        end
+
+        private
+
+        # @param [String] id
+        # @param [ModelElement] base_item
+        # @return [InterfacedItem]
+        def create_interfaced_item(id, base_item)
+          interfaced_item = InterfacedItem.new(
+            id: id
+          )
+          interfaced_item.base_item = base_item # skip overriding parent
+          interfaced_item.parent = self
+          interfaced_item
+        end
+
+        # @return [Array<InterfacedItem>]
+        def interfaced_items
+          return [] unless parent
+
+          interfaces.flat_map do |interface|
+            schema = parent.children_by_id[interface.schema.id.downcase]
+            if schema
+              schema_safe_children = schema.safe_children
+              schema_safe_children_by_id = schema_safe_children.select{|x| x.id}.map{|x| [x.id.downcase, x]}.to_h
+              if interface.items.length > 0
+                interface.items.map do |interface_item|
+                  base_item = schema_safe_children_by_id[interface_item.ref.id.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
+              end
+            end
+          end.select{|x| x}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.3 Schema
+      class SchemaVersion < ModelElement
+        model_attr_accessor :value, 'String'
+        model_attr_accessor :items, 'Array<SchemaVersionItem>'
+
+        # @param [Hash] options
+        # @option options [String] :value
+        # @option options [Array<SchemaVersionItem>] :items
+        def initialize(options = {})
+          @value = options[:value]
+          @items = options[:items] || []
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.3 Schema
+      class SchemaVersionItem < ModelElement
+        model_attr_accessor :name, 'String'
+        model_attr_accessor :value, 'String'
+
+        # @param [Hash] options
+        # @option options [String] :name
+        # @option options [String] :value
+        def initialize(options = {})
+          @name = options[:name]
+          @value = options[:value]
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.7 Subtype constraints
+      class SubtypeConstraint < Declaration
+        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'
+
+        # @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
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *remark_items
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.1 Type declaration
+      class Type < Declaration
+        include Identifier
+
+        model_attr_accessor :underlying_type, 'DataType'
+        model_attr_accessor :where_rules, 'Array<WhereRule>'
+        model_attr_accessor :informal_propositions, 'Array<RemarkItem>'
+
+        # @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
+        end
+
+        # @return [Array<DataTypes::EnumerationItem>]
+        def enumeration_items
+          underlying_type.is_a?(DataTypes::Enumeration) ? underlying_type.items : []
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *enumeration_items,
+            *where_rules,
+            *informal_propositions,
+            *remark_items
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.2.2.1 Uniqueness rule
+      class UniqueRule < Declaration
+        include Identifier
+
+        model_attr_accessor :attributes, 'Reference'
+
+        # @param [Hash] options
+        # @option (see Identifier#initialize_identifier)
+        # @option options [Reference] :attributes
+        def initialize(options = {})
+          initialize_identifier(options)
+
+          @attributes = options[:attributes] || []
+
+          super
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *remark_items
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.5.4 Local variables
+      class Variable < Declaration
+        include Identifier
+
+        model_attr_accessor :type, 'DataType'
+        model_attr_accessor :expression, 'Expression'
+
+        # @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
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *remark_items
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.2.2.2 Domain rules (WHERE clause)
+      class WhereRule < Declaration
+        include Identifier
+
+        model_attr_accessor :expression, 'Expression'
+
+        # @param [Hash] options
+        # @option (see Identifier#initialize_identifier)
+        # @option options [Expression] :expression
+        def initialize(options = {})
+          initialize_identifier(options)
+
+          @expression = options[:expression]
+
+          super
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *remark_items
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/expression.rb

@@ -0,0 +1,9 @@
+module Expressir
+  module Model
+    # Specified in ISO 10303-11:2004
+    # - section 12 Expression
+    # @abstract
+    class Expression < ModelElement
+    end
+  end
+end

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

@@ -1,11 +1,15 @@
 module Expressir
   module Model
     module Expressions
-      class AggregateInitializer < ModelElement
-        model_attr_accessor :items
+      # Specified in ISO 10303-11:2004
+      # - section 12.9 Aggregate initializer
+      class AggregateInitializer < Expression
+        model_attr_accessor :items, 'Array<AggregateInitializerItem>'
 
+        # @param [Hash] options
+        # @option options [Array<AggregateInitializerItem>] :items
         def initialize(options = {})
-          @items = options.fetch(:items, [])
+          @items = options[:items] || []
 
           super
         end

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

@@ -0,0 +1,22 @@
+module Expressir
+  module Model
+    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'
+
+        # @param [Hash] options
+        # @option options [Expression] :expression
+        # @option options [Expression] :repetition
+        def initialize(options = {})
+          @expression = options[:expression]
+          @repetition = options[:repetition]
+
+          super
+        end
+      end
+    end
+  end
+end