expressir 0.2.24 → 1.1.0

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

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

@@ -1,10 +1,17 @@
 module Expressir
   module Model
     module Expressions
-      class BinaryExpression < ModelElement
+      # 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
-        ANDOR = :ANDOR
         COMBINE = :COMBINE
         EQUAL = :EQUAL
         EXPONENTIATION = :EXPONENTIATION
@@ -25,10 +32,14 @@ module Expressir
         SUBTRACTION = :SUBTRACTION
         XOR = :XOR
 
-        model_attr_accessor :operator
-        model_attr_accessor :operand1
-        model_attr_accessor :operand2
+        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]

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

@@ -1,13 +1,18 @@
 module Expressir
   module Model
     module Expressions
-      class EntityConstructor < ModelElement
-        model_attr_accessor :entity
-        model_attr_accessor :parameters
+      # 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.fetch(:parameters, [])
+          @parameters = options[:parameters] || []
 
           super
         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

@@ -1,13 +1,24 @@
 module Expressir
   module Model
     module Expressions
-      class Interval < ModelElement
-        model_attr_accessor :low
-        model_attr_accessor :operator1
-        model_attr_accessor :item
-        model_attr_accessor :operator2
-        model_attr_accessor :high
+      # 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]

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

@@ -1,17 +1,20 @@
 module Expressir
   module Model
     module Expressions
-      class QueryExpression < ModelElement
+      # Specified in ISO 10303-11:2004
+      # - section 12.6.7 Query expression
+      class QueryExpression < Expression
         include Identifier
 
-        model_attr_accessor :aggregate_source
-        model_attr_accessor :expression
+        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 = {})
-          @id = options[:id]
-          @remarks = options.fetch(:remarks, [])
-          @remark_items = options.fetch(:remark_items, [])
-          @source = options[:source]
+          initialize_identifier(options)
 
           @aggregate_source = options[:aggregate_source]
           @expression = options[:expression]
@@ -19,6 +22,7 @@ module Expressir
           super
         end
 
+        # @return [Array<Declaration>]
         def children
           [
             self,

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

@@ -1,14 +1,20 @@
 module Expressir
   module Model
     module Expressions
-      class UnaryExpression < ModelElement
+      # 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
-        model_attr_accessor :operand
+        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]

data/lib/expressir/model/identifier.rb

@@ -1,11 +1,33 @@
 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
-        mod.model_attr_accessor :remarks
-        mod.model_attr_accessor :remark_items
-        mod.model_attr_accessor :source
+        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

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

@@ -1,9 +1,13 @@
 module Expressir
   module Model
     module Literals
-      class Binary < ModelElement
-        model_attr_accessor :value
+      # 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]
 

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

@@ -1,9 +1,13 @@
 module Expressir
   module Model
     module Literals
-      class Integer < ModelElement
-        model_attr_accessor :value
+      # 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]
 

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

@@ -1,13 +1,17 @@
 module Expressir
   module Model
     module Literals
-      class Logical < ModelElement
+      # 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
+        model_attr_accessor :value, ':TRUE, :FALSE, :UNKNOWN'
 
+        # @param [Hash] options
+        # @option options [:TRUE, :FALSE, :UNKNOWN] :value
         def initialize(options = {})
           @value = options[:value]
 

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

@@ -1,9 +1,13 @@
 module Expressir
   module Model
     module Literals
-      class Real < ModelElement
-        model_attr_accessor :value
+      # 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]
 

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

@@ -1,10 +1,15 @@
 module Expressir
   module Model
     module Literals
-      class String < ModelElement
-        model_attr_accessor :value
-        model_attr_accessor :encoded
+      # 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]

data/lib/expressir/model/model_element.rb

@@ -2,24 +2,33 @@ 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
-        return id if is_a? Statements::Alias or is_a? Statements::Repeat or is_a? Expressions::QueryExpression
+        # 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
+          if current_node.class.method_defined? :id and !(current_node.is_a? References::SimpleReference)
             path_parts << current_node.id
           end
 
@@ -27,25 +36,13 @@ module Expressir
           break unless current_node
         end
 
-        path_parts.reverse.join(".")
-      end
+        return if path_parts.empty?
 
-      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
+        path_parts.reverse.join(".")
       end
 
+      # @param [String] path
+      # @return [ModelElement]
       def find(path)
         return self if path.empty?
 
@@ -71,26 +68,34 @@ module Expressir
           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
-
-      def to_hash(options = {})
-        root_path = options[:root_path]
-        formatter = options[:formatter]
-        include_empty = options[:include_empty] || !options[:skip_empty] # TODO: remove skip_empty
-
+      
+      # @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
 
@@ -103,20 +108,20 @@ module Expressir
             hash[variable.to_s] = if value.is_a? Array
               value.map do |value|
                 if value.is_a? ModelElement
-                  value.to_hash(options)
+                  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(options)
+              value.to_hash(root_path: root_path, formatter: formatter, include_empty: include_empty)
             else
               value
             end
           end
         end
 
-        if self.is_a? Schema and file
+        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
 
@@ -126,10 +131,11 @@ module Expressir
 
         hash
       end
-
-      def self.from_hash(hash, options = {})
-        root_path = options[:root_path]
-
+      
+      # @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 = {}
 
@@ -139,19 +145,19 @@ module Expressir
           node_options[variable] = if value.is_a? Array
             value.map do |value|
               if value.is_a? Hash
-                self.from_hash(value, options)
+                self.from_hash(value, root_path: root_path)
               else
                 value
               end
             end
           elsif value.is_a? Hash
-            self.from_hash(value, options)
+            self.from_hash(value, root_path: root_path)
           else
             value
           end
         end
 
-        if node_class == Schema and hash[FILE_KEY]
+        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
 
@@ -160,15 +166,42 @@ module Expressir
         node
       end
 
+      # @return [Array<Symbol>]
       def self.model_attrs
         @model_attrs ||= []
       end
 
-      def self.model_attr_accessor(*vars)
+      # 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.concat(vars)
+        @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)
 
-        attr_accessor *vars
+          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