expressir 1.3.0-aarch64-linux-gnu

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

@@ -0,0 +1,53 @@
+module Expressir
+  module Model
+    module Expressions
+      # Specified in ISO 10303-11:2004
+      # - section 12.1 Arithmetic operators
+      # - section 12.2 Relational operators
+      # - section 12.3 Binary operators
+      # - section 12.4 Logical operators
+      # - 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
+
+        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'
+
+        # @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
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,34 @@
+module Expressir
+  module Model
+    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
+
+        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'
+
+        # @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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Expressir
+  module Model
+    module Expressions
+      # Specified in ISO 10303-11:2004
+      # - section 12.6.7 Query expression
+      class QueryExpression < Expression
+        include Identifier
+
+        model_attr_accessor :aggregate_source, 'Reference'
+        model_attr_accessor :expression, 'Expression'
+
+        # @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
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            self,
+            *remark_items
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Expressir
+  module Model
+    module Expressions
+      # 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
+
+        model_attr_accessor :operator, ':MINUS, :NOT, :PLUS'
+        model_attr_accessor :operand, 'Expression'
+
+        # @param [Hash] options
+        # @option options [:MINUS, :NOT, :PLUS] :operator
+        # @option options [Expression] :operand
+        def initialize(options = {})
+          @operator = options[:operator]
+          @operand = options[:operand]
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/identifier.rb

@@ -0,0 +1,34 @@
+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
+
+      # @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]
+      end
+    end
+  end
+end

data/lib/expressir/model/literal.rb

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

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

@@ -0,0 +1,19 @@
+module Expressir
+  module Model
+    module Literals
+      # Specified in ISO 10303-11:2004
+      # - section 7.5.1 Binary literal
+      class Binary < Literal
+        model_attr_accessor :value, '::String'
+
+        # @param [Hash] options
+        # @option options [::String] :value
+        def initialize(options = {})
+          @value = options[:value]
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Expressir
+  module Model
+    module Literals
+      # Specified in ISO 10303-11:2004
+      # - section 7.5.2 Integer literal
+      class Integer < Literal
+        model_attr_accessor :value, '::String'
+
+        # @param [Hash] options
+        # @option options [::String] :value
+        def initialize(options = {})
+          @value = options[:value]
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Expressir
+  module Model
+    module Literals
+      # Specified in ISO 10303-11:2004
+      # - section 7.5.5 Logical literal
+      class Logical < Literal
+        TRUE = :TRUE
+        FALSE = :FALSE
+        UNKNOWN = :UNKNOWN
+
+        model_attr_accessor :value, ':TRUE, :FALSE, :UNKNOWN'
+
+        # @param [Hash] options
+        # @option options [:TRUE, :FALSE, :UNKNOWN] :value
+        def initialize(options = {})
+          @value = options[:value]
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Expressir
+  module Model
+    module Literals
+      # Specified in ISO 10303-11:2004
+      # - section 7.5.3 Real literal
+      class Real < Literal
+        model_attr_accessor :value, '::String'
+
+        # @param [Hash] options
+        # @option options [::String] :value
+        def initialize(options = {})
+          @value = options[:value]
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Expressir
+  module Model
+    module Literals
+      # Specified in ISO 10303-11:2004
+      # - section 7.5.4 String literal
+      class String < Literal
+        model_attr_accessor :value, '::String'
+        model_attr_accessor :encoded, '::Boolean'
+
+        # @param [Hash] options
+        # @option options [::String] :value
+        # @option options [::Boolean] :encoded
+        def initialize(options = {})
+          @value = options[:value]
+          @encoded = options[:encoded]
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/model_element.rb

@@ -0,0 +1,208 @@
+require 'pathname'
+
+module Expressir
+  module Model
+    # Base model element
+    class ModelElement
+      CLASS_KEY = '_class'
+      FILE_KEY = 'file'
+      SOURCE_KEY = 'source'
+
+      private_constant :CLASS_KEY
+      private_constant :FILE_KEY
+      private_constant :SOURCE_KEY
+
+      # @return [ModelElement]
+      attr_accessor :parent
+
+      # @param [Hash] options
+      def initialize(options = {})
+        attach_parent_to_children
+      end
+
+      # @return [String]
+      def path
+        # this creates an implicit scope
+        return if is_a? Statements::Alias or is_a? Statements::Repeat or is_a? Expressions::QueryExpression
+
+        current_node = self
+        path_parts = []
+        loop do
+          if current_node.class.method_defined? :id and !(current_node.is_a? References::SimpleReference)
+            path_parts << current_node.id
+          end
+
+          current_node = current_node.parent
+          break unless current_node
+        end
+
+        return if path_parts.empty?
+
+        path_parts.reverse.join(".")
+      end
+
+      # @param [String] path
+      # @return [ModelElement]
+      def find(path)
+        return self if path.empty?
+
+        path_parts = path.downcase.split(/\./).map do |current_path|
+          _, _, current_path = current_path.rpartition(":") # ignore prefix
+          current_path
+        end
+
+        current_scope = self
+        target_node = nil
+        loop do
+          # find in current scope
+          current_node = current_scope
+          path_parts.each do |current_path|
+            current_node = current_node.children_by_id[current_path]
+            break unless current_node
+          end
+          target_node = current_node
+          break if target_node
+
+          # retry search in parent scope
+          current_scope = current_scope.parent
+          break unless current_scope
+        end
+
+        if target_node.is_a? Model::Declarations::InterfacedItem
+          target_node = target_node.base_item
+        end
+
+        target_node
+      end
+
+      # @return [Array<Declaration>]
+      def children
+        []
+      end
+
+      # @return [Hash<String, Declaration>]
+      def children_by_id
+        @children_by_id ||= children.select{|x| x.id}.map{|x| [x.id.downcase, x]}.to_h
+      end
+
+      # @return [nil]
+      def reset_children_by_id
+        @children_by_id = nil
+        nil
+      end
+      
+      # @param [String] root_path
+      # @param [Express::Formatter] formatter
+      # @param [Boolean] include_empty
+      # @return [Hash]
+      def to_hash(root_path: nil, formatter: nil, include_empty: nil)
+        hash = {}
+        hash[CLASS_KEY] = self.class.name
+
+        self.class.model_attrs.each do |variable|
+          value = self.send(variable)
+          empty = value.nil? || (value.is_a?(Array) && value.count == 0)
+
+          # skip empty values
+          if !empty or include_empty
+            hash[variable.to_s] = if value.is_a? Array
+              value.map do |value|
+                if value.is_a? ModelElement
+                  value.to_hash(root_path: root_path, formatter: formatter, include_empty: include_empty)
+                else
+                  value
+                end
+              end
+            elsif value.is_a? ModelElement
+              value.to_hash(root_path: root_path, formatter: formatter, include_empty: include_empty)
+            else
+              value
+            end
+          end
+        end
+
+        if self.is_a? Declarations::Schema and file
+          hash[FILE_KEY] = root_path ? Pathname.new(file).relative_path_from(root_path).to_s : file
+        end
+
+        if self.class.method_defined? :source and formatter
+          hash[SOURCE_KEY] = formatter.format(self)
+        end
+
+        hash
+      end
+      
+      # @param [Hash] hash
+      # @param [String] root_path
+      # @return [ModelElement]
+      def self.from_hash(hash, root_path: nil)
+        node_class = Object.const_get(hash[CLASS_KEY])
+        node_options = {}
+
+        node_class.model_attrs.each do |variable|
+          value = hash[variable.to_s]
+
+          node_options[variable] = if value.is_a? Array
+            value.map do |value|
+              if value.is_a? Hash
+                self.from_hash(value, root_path: root_path)
+              else
+                value
+              end
+            end
+          elsif value.is_a? Hash
+            self.from_hash(value, root_path: root_path)
+          else
+            value
+          end
+        end
+
+        if node_class == Declarations::Schema and hash[FILE_KEY]
+          node_options[FILE_KEY.to_sym] = root_path ? File.expand_path("#{root_path}/#{hash[FILE_KEY]}") : hash[FILE_KEY]
+        end
+
+        node = node_class.new(node_options)
+
+        node
+      end
+
+      # @return [Array<Symbol>]
+      def self.model_attrs
+        @model_attrs ||= []
+      end
+
+      # Define a new model attribute
+      # @param attr_name [Symbol] attribute name
+      # @param attr_type [Symbol] attribute type
+      # @!macro [attach] model_attr_accessor
+      #   @!attribute $1
+      #     @return [$2]
+      def self.model_attr_accessor(attr_name, attr_type = nil)
+        @model_attrs ||= []
+        @model_attrs << attr_name
+
+        attr_accessor attr_name
+      end
+
+      private
+
+      # @return [nil]
+      def attach_parent_to_children
+        self.class.model_attrs.each do |variable|
+          value = self.send(variable)
+
+          if value.is_a? Array
+            value.each do |value|
+              if value.is_a? ModelElement
+                value.parent = self
+              end
+            end
+          elsif value.is_a? ModelElement
+            value.parent = self
+          end
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/expressir/model/reference.rb

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

data/lib/expressir/model/references/attribute_reference.rb

@@ -0,0 +1,22 @@
+module Expressir
+  module Model
+    module References
+      # Specified in ISO 10303-11:2004
+      # - section 12.7.3 Attribute references
+      class AttributeReference < Reference
+        model_attr_accessor :ref, 'Reference'
+        model_attr_accessor :attribute, 'Reference'
+
+        # @param [Hash] options
+        # @option options [Reference] :ref
+        # @option options [Reference] :attribute
+        def initialize(options = {})
+          @ref = options[:ref]
+          @attribute = options[:attribute]
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/references/group_reference.rb

@@ -0,0 +1,22 @@
+module Expressir
+  module Model
+    module References
+      # Specified in ISO 10303-11:2004
+      # - section 12.7.4 Group references
+      class GroupReference < Reference
+        model_attr_accessor :ref, 'Reference'
+        model_attr_accessor :entity, 'Reference'
+
+        # @param [Hash] options
+        # @option options [Reference] :ref
+        # @option options [Reference] :entity
+        def initialize(options = {})
+          @ref = options[:ref]
+          @entity = options[:entity]
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/references/index_reference.rb

@@ -0,0 +1,27 @@
+module Expressir
+  module Model
+    module References
+      # Specified in ISO 10303-11:2004
+      # - section 12.3.1 Binary indexing
+      # - section 12.5.1 String indexing
+      # - section 12.6.1 Aggregate indexing
+      class IndexReference < Reference
+        model_attr_accessor :ref, 'Reference'
+        model_attr_accessor :index1, 'Expression'
+        model_attr_accessor :index2, 'Expression'
+
+        # @param [Hash] options
+        # @option options [Reference] :ref
+        # @option options [Expression] :index1
+        # @option options [Expression] :index2
+        def initialize(options = {})
+          @ref = options[:ref]
+          @index1 = options[:index1]
+          @index2 = options[:index2]
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/references/simple_reference.rb

@@ -0,0 +1,24 @@
+module Expressir
+  module Model
+    module References
+      # Specified in ISO 10303-11:2004
+      # - section 12.7.1 Simple references
+      class SimpleReference < Reference
+        model_attr_accessor :id, 'String'
+
+        model_attr_accessor :base_path, 'String'
+
+        # @param [Hash] options
+        # @option options [String] :id
+        # @option options [String] :base_path
+        def initialize(options = {})
+          @id = options[:id]
+
+          @base_path = options[:base_path]
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/repository.rb

@@ -0,0 +1,23 @@
+module Expressir
+  module Model
+    # Multi-schema global scope
+    class Repository < ModelElement
+      model_attr_accessor :schemas, 'Array<Declarations::Schema>'
+
+      # @param [Hash] options
+      # @option options [Array<Declarations::Schema>] :schemas
+      def initialize(options = {})
+        @schemas = options[:schemas] || []
+
+        super
+      end
+
+      # @return [Array<Declaration>]
+      def children
+        [
+          *schemas
+        ]
+      end
+    end
+  end
+end