expressir 0.2.0 → 0.2.1

data/lib/expressir/express_exp/parser.rb

@@ -14,11 +14,16 @@ module Expressir
         lexer = Generated::ExpressLexer.new(char_stream)
         token_stream = Antlr4::Runtime::CommonTokenStream.new(lexer)
         parser = Generated::ExpressParser.new(token_stream)
-        
+
+        # don't attempt to recover from any parsing error
+        parser.instance_variable_set(:@_err_handler, Antlr4::Runtime::BailErrorStrategy.new)
+
         parse_tree = parser.syntax()
 
-        visitor = Visitor.new()
-        visitor.visit(parse_tree)
+        visitor = Visitor.new(token_stream)
+        repo = visitor.visit(parse_tree)
+
+        repo
       end
     end
   end

data/lib/expressir/express_exp/visitor.rb

@@ -1,89 +1,5 @@
 require 'expressir/express_exp/generated/ExpressBaseVisitor'
-require 'expressir/model/constant'
-require 'expressir/model/derived'
-require 'expressir/model/entity'
-require 'expressir/model/explicit'
-require 'expressir/model/function'
-require 'expressir/model/inverse'
-require 'expressir/model/local'
-require 'expressir/model/parameter'
-require 'expressir/model/procedure'
-require 'expressir/model/ref'
-require 'expressir/model/reference'
-require 'expressir/model/renamed_ref'
-require 'expressir/model/repository'
-require 'expressir/model/rule'
-require 'expressir/model/schema'
-require 'expressir/model/subtype_constraint'
-require 'expressir/model/type'
-require 'expressir/model/unique'
-require 'expressir/model/use'
-require 'expressir/model/where'
-require 'expressir/model/expressions/aggregate_element'
-require 'expressir/model/expressions/attribute_qualifier'
-require 'expressir/model/expressions/entity_constructor'
-require 'expressir/model/expressions/expression'
-require 'expressir/model/expressions/function_call'
-require 'expressir/model/expressions/group_qualifier'
-require 'expressir/model/expressions/index_qualifier'
-require 'expressir/model/expressions/interval'
-require 'expressir/model/expressions/qualified_ref'
-require 'expressir/model/expressions/query'
-require 'expressir/model/expressions/unknown'
-require 'expressir/model/operators/addition'
-require 'expressir/model/operators/and'
-require 'expressir/model/operators/andor'
-require 'expressir/model/operators/combine'
-require 'expressir/model/operators/equal'
-require 'expressir/model/operators/exponentiation'
-require 'expressir/model/operators/greater_than'
-require 'expressir/model/operators/greater_than_or_equal'
-require 'expressir/model/operators/in'
-require 'expressir/model/operators/instance_equal'
-require 'expressir/model/operators/instance_not_equal'
-require 'expressir/model/operators/integer_division'
-require 'expressir/model/operators/less_than'
-require 'expressir/model/operators/less_than_or_equal'
-require 'expressir/model/operators/like'
-require 'expressir/model/operators/modulo'
-require 'expressir/model/operators/multiplication'
-require 'expressir/model/operators/not'
-require 'expressir/model/operators/not_equal'
-require 'expressir/model/operators/oneof'
-require 'expressir/model/operators/or'
-require 'expressir/model/operators/real_division'
-require 'expressir/model/operators/subtraction'
-require 'expressir/model/operators/unary_plus'
-require 'expressir/model/operators/unary_minus'
-require 'expressir/model/operators/xor'
-require 'expressir/model/statements/alias'
-require 'expressir/model/statements/assignment'
-require 'expressir/model/statements/case'
-require 'expressir/model/statements/case_action'
-require 'expressir/model/statements/compound'
-require 'expressir/model/statements/escape'
-require 'expressir/model/statements/if'
-require 'expressir/model/statements/null'
-require 'expressir/model/statements/procedure_call'
-require 'expressir/model/statements/repeat'
-require 'expressir/model/statements/return'
-require 'expressir/model/statements/skip'
-require 'expressir/model/types/aggregate'
-require 'expressir/model/types/array'
-require 'expressir/model/types/bag'
-require 'expressir/model/types/binary'
-require 'expressir/model/types/boolean'
-require 'expressir/model/types/enumeration'
-require 'expressir/model/types/generic_entity'
-require 'expressir/model/types/generic'
-require 'expressir/model/types/integer'
-require 'expressir/model/types/list'
-require 'expressir/model/types/logical'
-require 'expressir/model/types/number'
-require 'expressir/model/types/real'
-require 'expressir/model/types/set'
-require 'expressir/model/types/select'
-require 'expressir/model/types/string'
+require 'expressir/model'
 
 # issues:
 #
@@ -107,6 +23,77 @@ require 'expressir/model/types/string'
 module Expressir
   module ExpressExp
     class Visitor < Generated::ExpressBaseVisitor
+      REMARK_CHANNEL = 2
+
+      def initialize(tokens)
+        @tokens = tokens
+        @attached_remarks = Set.new
+      end
+
+      def visit(ctx)
+        result = super(ctx)
+        attach_remarks(ctx, result)
+        result
+      end
+
+      def attach_remarks(ctx, item)
+        # get remark tokens
+        start_index, stop_index = if ctx.instance_of? Generated::ExpressParser::SyntaxContext
+          [0, @tokens.size - 1]
+        else
+          [ctx.start.token_index, ctx.stop.token_index]
+        end
+        # puts [start_index, stop_index, ctx.class].inspect
+
+        remark_tokens = @tokens.filter_for_channel(start_index, stop_index, REMARK_CHANNEL)
+        if remark_tokens
+          remark_tokens.each do |remark_token|
+            remark_text = remark_token.text
+
+            # check if it is tagged remark
+            match = if remark_text.start_with?('--')
+              remark_text[2..-1].match(/^"([^"]*)"(.*)$/)
+            elsif remark_text.start_with?('(*') and remark_text.end_with?('*)')
+              remark_text[2..-3].match(/^"([^"]*)"(.*)$/m)
+            end
+            if !match
+              next
+            end
+
+            # don't attach already attached tagged remark
+            if @attached_remarks.include? remark_token
+              next
+            end
+
+            # attach tagged remark
+            remark_tag = match[1]
+            remark_content = match[2].strip
+
+            current_item = item
+            remark_tag.split('.').each do |id|
+              if current_item
+                if current_item.class.method_defined? :scope_items
+                  current_item = current_item.scope_items.find{|x| x.id == id}
+                else
+                  current_item = nil
+                  break
+                end
+              else
+                break
+              end
+            end
+
+            if current_item
+              current_item.remarks ||= []
+              current_item.remarks << remark_content
+
+              # mark remark as attached, so that it is not attached again at higher nesting level
+              @attached_remarks << remark_token
+            end
+          end
+        end
+      end
+
       def visitAttributeRef(ctx)
         id = visit(ctx.attributeId())
 
@@ -250,7 +237,11 @@ module Expressir
       end
 
       def visitAggregateInitializer(ctx)
-        ctx.element().map{|ctx| visit(ctx)}
+        items = ctx.element().map{|ctx| visit(ctx)}
+
+        Model::Expressions::AggregateInitializer.new({
+          items: items
+        })
       end
 
       def visitAggregateSource(ctx)
@@ -347,13 +338,7 @@ module Expressir
       end
 
       def visitAttributeDecl(ctx)
-        if ctx.attributeId()
-          visit(ctx.attributeId())
-        elsif ctx.redeclaredAttribute()
-          visit(ctx.redeclaredAttribute())
-        else
-          raise 'Invalid state'
-        end
+        raise 'Invalid state'
       end
 
       def visitAttributeId(ctx)
@@ -439,12 +424,12 @@ module Expressir
       end
 
       def visitCaseAction(ctx)
-        labels = ctx.caseLabel().map{|ctx| visit(ctx.expression())}
+        expressions = ctx.caseLabel().map{|ctx| visit(ctx.expression())}
         statement = visit(ctx.stmt())
 
-        labels.map do |label|
+        expressions.map do |expression|
           Model::Statements::CaseAction.new({
-            label: label,
+            expression: expression,
             statement: statement
           })
         end
@@ -545,12 +530,20 @@ module Expressir
       end
 
       def visitDerivedAttr(ctx)
-        id = visit(ctx.attributeDecl())
+        id = if ctx.attributeDecl().attributeId()
+          visit(ctx.attributeDecl().attributeId())
+        elsif ctx.attributeDecl().redeclaredAttribute() && ctx.attributeDecl().redeclaredAttribute().attributeId()
+          visit(ctx.attributeDecl().redeclaredAttribute().attributeId())
+        end
+        supertype_attribute = if ctx.attributeDecl().redeclaredAttribute() && ctx.attributeDecl().redeclaredAttribute().qualifiedAttribute()
+          visit(ctx.attributeDecl().redeclaredAttribute().qualifiedAttribute())
+        end
         type = visit(ctx.parameterType())
         expression = visit(ctx.expression())
 
         Model::Derived.new({
           id: id,
+          supertype_attribute: supertype_attribute,
           type: type,
           expression: expression
         })
@@ -684,21 +677,21 @@ module Expressir
 
       def visitEnumerationType(ctx)
         extensible = !!ctx.EXTENSIBLE()
-        list = if ctx.enumerationItems()
-          ctx.enumerationItems().enumerationId().map{|ctx| visit(ctx)}
+        items = if ctx.enumerationItems()
+          ctx.enumerationItems().enumerationId().map{|ctx| handleEnumerationItem(ctx)}
         end
         extension_type = if ctx.enumerationExtension()
           visit(ctx.enumerationExtension().typeRef())
         end
-        extension_list = if ctx.enumerationExtension() && ctx.enumerationExtension().enumerationItems()
-          ctx.enumerationExtension().enumerationItems().enumerationId().map{|ctx| visit(ctx)}
+        extension_items = if ctx.enumerationExtension() && ctx.enumerationExtension().enumerationItems()
+          ctx.enumerationExtension().enumerationItems().enumerationId().map{|ctx| handleEnumerationItem(ctx)}
         end
 
         Model::Types::Enumeration.new({
           extensible: extensible,
-          list: list,
+          items: items,
           extension_type: extension_type,
-          extension_list: extension_list
+          extension_items: extension_items
         })
       end
 
@@ -707,13 +700,22 @@ module Expressir
       end
 
       def visitExplicitAttr(ctx)
-        ids = ctx.attributeDecl().map{|ctx| visit(ctx)}
+        decls = ctx.attributeDecl()
         optional = !!ctx.OPTIONAL()
         type = visit(ctx.parameterType())
 
-        ids.map do |id|
+        decls.map do |decl|
+          id = if decl.attributeId()
+            visit(decl.attributeId())
+          elsif decl.redeclaredAttribute() && decl.redeclaredAttribute().attributeId()
+            visit(decl.redeclaredAttribute().attributeId())
+          end
+          supertype_attribute = if decl.redeclaredAttribute() && decl.redeclaredAttribute().qualifiedAttribute()
+            visit(decl.redeclaredAttribute().qualifiedAttribute())
+          end
           Model::Explicit.new({
             id: id,
+            supertype_attribute: supertype_attribute,
             optional: optional,
             type: type
           })
@@ -948,7 +950,7 @@ module Expressir
       end
 
       def visitIfStmt(ctx)
-        condition = visit(ctx.logicalExpression().expression())
+        expression = visit(ctx.logicalExpression().expression())
         else_index = if ctx.ELSE()
           ctx.children.find_index{|x| x == ctx.ELSE()}
         end
@@ -965,7 +967,7 @@ module Expressir
         end
 
         Model::Statements::If.new({
-          condition: condition,
+          expression: expression,
           statements: statements,
           else_statements: else_statements
         })
@@ -1066,7 +1068,14 @@ module Expressir
       end
 
       def visitInverseAttr(ctx)
-        id = visit(ctx.attributeDecl())
+        id = if ctx.attributeDecl().attributeId()
+          visit(ctx.attributeDecl().attributeId())
+        elsif ctx.attributeDecl().redeclaredAttribute() && ctx.attributeDecl().redeclaredAttribute().attributeId()
+          visit(ctx.attributeDecl().redeclaredAttribute().attributeId())
+        end
+        supertype_attribute = if ctx.attributeDecl().redeclaredAttribute() && ctx.attributeDecl().redeclaredAttribute().qualifiedAttribute()
+          visit(ctx.attributeDecl().redeclaredAttribute().qualifiedAttribute())
+        end
         type = if ctx.SET()
           bound1, bound2 = if ctx.boundSpec()
             [
@@ -1116,6 +1125,7 @@ module Expressir
 
         Model::Inverse.new({
           id: id,
+          supertype_attribute: supertype_attribute,
           type: type,
           attribute: attribute
         })
@@ -1184,15 +1194,19 @@ module Expressir
       end
 
       def visitLogicalLiteral(ctx)
-        if ctx.TRUE()
+        value = if ctx.TRUE()
           true
         elsif ctx.FALSE()
           false
         elsif ctx.UNKNOWN()
-          Model::Expressions::Unknown.new()
+          nil
         else
           raise 'Invalid state'
         end
+
+        Model::Literals::Logical.new({
+          value: value
+        })
       end
 
       def visitLogicalType(ctx)
@@ -1436,17 +1450,7 @@ module Expressir
       end
 
       def visitRedeclaredAttribute(ctx)
-        if ctx.attributeId()
-          ref = visit(ctx.qualifiedAttribute())
-          id = visit(ctx.attributeId())
-
-          Model::RenamedRef.new({
-            ref: ref,
-            id: id
-          })
-        else
-          visit(ctx.qualifiedAttribute())
-        end
+        raise 'Invalid state'
       end
 
       def visitReferencedAttribute(ctx)
@@ -1524,7 +1528,7 @@ module Expressir
       end
 
       def visitRepeatStmt(ctx)
-        variable = if ctx.repeatControl().incrementControl()
+        id = if ctx.repeatControl().incrementControl()
           visit(ctx.repeatControl().incrementControl().variableId())
         end
         bound1, bound2 = if ctx.repeatControl().incrementControl()
@@ -1545,7 +1549,7 @@ module Expressir
         statements = ctx.stmt().map{|ctx| visit(ctx)}
 
         Model::Statements::Repeat.new({
-          variable: variable,
+          id: id,
           bound1: bound1,
           bound2: bound2,
           increment: increment,
@@ -1682,22 +1686,22 @@ module Expressir
       def visitSelectType(ctx)
         extensible = !!ctx.EXTENSIBLE()
         generic_entity = !!ctx.GENERIC_ENTITY()
-        list = if ctx.selectList()
+        items = if ctx.selectList()
           ctx.selectList().namedTypes().map{|ctx| visit(ctx)}
         end
         extension_type = if ctx.selectExtension()
           visit(ctx.selectExtension().typeRef())
         end
-        extension_list = if ctx.selectExtension() && ctx.selectExtension().selectList()
+        extension_items = if ctx.selectExtension() && ctx.selectExtension().selectList()
           ctx.selectExtension().selectList().namedTypes().map{|ctx| visit(ctx)}
         end
 
         Model::Types::Select.new({
           extensible: extensible,
           generic_entity: generic_entity,
-          list: list,
+          items: items,
           extension_type: extension_type,
-          extension_list: extension_list
+          extension_items: extension_items
         })
       end
 
@@ -2053,6 +2057,16 @@ module Expressir
         raise 'Invalid state'
       end
 
+      private
+
+      def handleEnumerationItem(ctx)
+        id = handleSimpleId(ctx.SimpleId())
+
+        Model::EnumerationItem.new({
+          id: id
+        })
+      end
+
       def handleBinaryExpression(operands, operators)
         if operands.length != operators.length + 1
           raise 'Invalid state'
@@ -2072,16 +2086,27 @@ module Expressir
       end
 
       def handleBinaryLiteral(ctx)
-        bin = ctx.text[1..(ctx.text.length - 1)]
-        [bin].pack('B*')
+        value = ctx.text[1..(ctx.text.length - 1)]
+
+        Model::Literals::Binary.new({
+          value: value
+        })
       end
 
       def handleIntegerLiteral(ctx)
-        ctx.text.to_i
+        value = ctx.text
+
+        Model::Literals::Integer.new({
+          value: value
+        })
       end
 
       def handleRealLiteral(ctx)
-        ctx.text.to_f
+        value = ctx.text
+
+        Model::Literals::Real.new({
+          value: value
+        })
       end
 
       def handleSimpleId(ctx)
@@ -2089,14 +2114,20 @@ module Expressir
       end
 
       def handleSimpleStringLiteral(ctx)
-        ctx.text[1..(ctx.text.length - 2)]
+        value = ctx.text[1..(ctx.text.length - 2)]
+
+        Model::Literals::String.new({
+          value: value
+        })
       end
 
       def handleEncodedStringLiteral(ctx)
-        hex = ctx.text[1..(ctx.text.length - 2)]
-        str = [hex].pack('H*')
-        str.force_encoding('UCS-4BE')
-        str.encode('ASCII-8BIT')
+        value = ctx.text[1..(ctx.text.length - 2)]
+
+        Model::Literals::String.new({
+          value: value,
+          encoded: true
+        })
       end
     end
   end