expressir 0.2.4 → 0.2.9

data/spec/expressir/express_exp/parse_remark_spec.rb

@@ -11,13 +11,14 @@ RSpec.describe Expressir::ExpressExp::Parser do
       schema.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Schema)
         expect(x.remarks).to be_instance_of(Array)
-        expect(x.remarks.count).to eq(4)
+        expect(x.remarks.count).to eq(5)
         expect(x.remarks[0]).to eq("Any character within the EXPRESS character set may occur between the start and end of\nan embedded remark including the newline character; therefore, embedded remarks can span\nseveral physical lines.")
         expect(x.remarks[1]).to eq("The tail remark is written at the end of a physical line.")
-        expect(x.remarks[2]).to eq("universal scope - schema before")
-        expect(x.remarks[3]).to eq("universal scope - schema")
+        expect(x.remarks[2]).to eq("UTF8 test: Příliš žluťoučký kůň úpěl ďábelské ódy.")
+        expect(x.remarks[3]).to eq("universal scope - schema before")
+        expect(x.remarks[4]).to eq("universal scope - schema")
       end
-      
+
       schema.constants.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Constant)
         expect(x.remarks).to be_instance_of(Array)
@@ -25,7 +26,7 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.remarks[0]).to eq("schema scope - constant")
         expect(x.remarks[1]).to eq("universal scope - constant")
       end
-      
+
       schema.types.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Type)
         expect(x.remarks).to be_instance_of(Array)
@@ -37,12 +38,38 @@ RSpec.describe Expressir::ExpressExp::Parser do
         x.type.items.first.tap do |x|
           expect(x).to be_instance_of(Expressir::Model::EnumerationItem)
           expect(x.remarks).to be_instance_of(Array)
-          expect(x.remarks.count).to eq(2)
+          expect(x.remarks.count).to eq(4)
           expect(x.remarks[0]).to eq("schema scope - enumeration item")
-          expect(x.remarks[1]).to eq("universal scope - enumeration item")
+          expect(x.remarks[1]).to eq("schema scope - enumeration item, on the same level as the type")
+          expect(x.remarks[2]).to eq("universal scope - enumeration item")
+          expect(x.remarks[3]).to eq("universal scope - enumeration item, on the same level as the type")
         end
       end
-      
+
+      schema.types.first.where.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Where)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(6)
+        expect(x.remarks[0]).to eq("type scope - type where")
+        expect(x.remarks[1]).to eq("type scope - type where, with prefix")
+        expect(x.remarks[2]).to eq("schema scope - type where")
+        expect(x.remarks[3]).to eq("schema scope - type where, with prefix")
+        expect(x.remarks[4]).to eq("universal scope - type where")
+        expect(x.remarks[5]).to eq("universal scope - type where, with prefix")
+      end
+
+      schema.types.first.informal_propositions.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::InformalProposition)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(6)
+        expect(x.remarks[0]).to eq("type scope - type informal proposition")
+        expect(x.remarks[1]).to eq("type scope - type informal proposition, with prefix")
+        expect(x.remarks[2]).to eq("schema scope - type informal proposition")
+        expect(x.remarks[3]).to eq("schema scope - type informal proposition, with prefix")
+        expect(x.remarks[4]).to eq("universal scope - type informal proposition")
+        expect(x.remarks[5]).to eq("universal scope - type informal proposition, with prefix")
+      end
+
       schema.entities.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Entity)
         expect(x.remarks).to be_instance_of(Array)
@@ -50,7 +77,7 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.remarks[0]).to eq("schema scope - entity")
         expect(x.remarks[1]).to eq("universal scope - entity")
       end
-      
+
       schema.entities.first.explicit_attributes.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Attribute)
         expect(x.kind).to eq(Expressir::Model::Attribute::EXPLICIT)
@@ -60,7 +87,7 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.remarks[1]).to eq("schema scope - entity attribute")
         expect(x.remarks[2]).to eq("universal scope - entity attribute")
       end
-      
+
       schema.entities.first.derived_attributes.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Attribute)
         expect(x.kind).to eq(Expressir::Model::Attribute::DERIVED)
@@ -70,7 +97,7 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.remarks[1]).to eq("schema scope - entity derived attribute")
         expect(x.remarks[2]).to eq("universal scope - entity derived attribute")
       end
-      
+
       schema.entities.first.inverse_attributes.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Attribute)
         expect(x.kind).to eq(Expressir::Model::Attribute::INVERSE)
@@ -80,7 +107,7 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.remarks[1]).to eq("schema scope - entity inverse attribute")
         expect(x.remarks[2]).to eq("universal scope - entity inverse attribute")
       end
-      
+
       schema.entities.first.unique.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Unique)
         expect(x.remarks).to be_instance_of(Array)
@@ -89,16 +116,31 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.remarks[1]).to eq("schema scope - entity unique")
         expect(x.remarks[2]).to eq("universal scope - entity unique")
       end
-      
+
       schema.entities.first.where.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Where)
         expect(x.remarks).to be_instance_of(Array)
-        expect(x.remarks.count).to eq(3)
+        expect(x.remarks.count).to eq(6)
         expect(x.remarks[0]).to eq("entity scope - entity where")
-        expect(x.remarks[1]).to eq("schema scope - entity where")
-        expect(x.remarks[2]).to eq("universal scope - entity where")
+        expect(x.remarks[1]).to eq("entity scope - entity where, with prefix")
+        expect(x.remarks[2]).to eq("schema scope - entity where")
+        expect(x.remarks[3]).to eq("schema scope - entity where, with prefix")
+        expect(x.remarks[4]).to eq("universal scope - entity where")
+        expect(x.remarks[5]).to eq("universal scope - entity where, with prefix")
+      end
+
+      schema.entities.first.informal_propositions.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::InformalProposition)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(6)
+        expect(x.remarks[0]).to eq("entity scope - entity informal proposition")
+        expect(x.remarks[1]).to eq("entity scope - entity informal proposition, with prefix")
+        expect(x.remarks[2]).to eq("schema scope - entity informal proposition")
+        expect(x.remarks[3]).to eq("schema scope - entity informal proposition, with prefix")
+        expect(x.remarks[4]).to eq("universal scope - entity informal proposition")
+        expect(x.remarks[5]).to eq("universal scope - entity informal proposition, with prefix")
       end
-      
+
       schema.subtype_constraints.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::SubtypeConstraint)
         expect(x.remarks).to be_instance_of(Array)
@@ -106,7 +148,7 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.remarks[0]).to eq("schema scope - subtype constraint")
         expect(x.remarks[1]).to eq("universal scope - subtype constraint")
       end
-      
+
       schema.functions.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Function)
         expect(x.remarks).to be_instance_of(Array)
@@ -114,7 +156,7 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.remarks[0]).to eq("schema scope - function")
         expect(x.remarks[1]).to eq("universal scope - function")
       end
-      
+
       schema.functions.first.parameters.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Parameter)
         expect(x.remarks).to be_instance_of(Array)
@@ -123,7 +165,7 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.remarks[1]).to eq("schema scope - function parameter")
         expect(x.remarks[2]).to eq("universal scope - function parameter")
       end
-      
+
       schema.functions.first.types.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Type)
         expect(x.remarks).to be_instance_of(Array)
@@ -136,13 +178,16 @@ RSpec.describe Expressir::ExpressExp::Parser do
         x.type.items.first.tap do |x|
           expect(x).to be_instance_of(Expressir::Model::EnumerationItem)
           expect(x.remarks).to be_instance_of(Array)
-          expect(x.remarks.count).to eq(3)
+          expect(x.remarks.count).to eq(6)
           expect(x.remarks[0]).to eq("function scope - function enumeration item")
-          expect(x.remarks[1]).to eq("schema scope - function enumeration item")
-          expect(x.remarks[2]).to eq("universal scope - function enumeration item")
+          expect(x.remarks[1]).to eq("function scope - function enumeration item, on the same level as the type")
+          expect(x.remarks[2]).to eq("schema scope - function enumeration item")
+          expect(x.remarks[3]).to eq("schema scope - function enumeration item, on the same level as the type")
+          expect(x.remarks[4]).to eq("universal scope - function enumeration item")
+          expect(x.remarks[5]).to eq("universal scope - function enumeration item, on the same level as the type")
         end
       end
-      
+
       schema.functions.first.constants.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Constant)
         expect(x.remarks).to be_instance_of(Array)
@@ -151,7 +196,7 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.remarks[1]).to eq("schema scope - function constant")
         expect(x.remarks[2]).to eq("universal scope - function constant")
       end
-      
+
       schema.functions.first.variables.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Variable)
         expect(x.remarks).to be_instance_of(Array)
@@ -160,21 +205,21 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.remarks[1]).to eq("schema scope - function variable")
         expect(x.remarks[2]).to eq("universal scope - function variable")
       end
-      
+
       schema.functions.first.statements[0].tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Statements::Alias)
         expect(x.remarks).to be_instance_of(Array)
         expect(x.remarks.count).to eq(1)
         expect(x.remarks[0]).to eq("function alias scope - function alias")
       end
-      
+
       schema.functions.first.statements[1].tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Statements::Repeat)
         expect(x.remarks).to be_instance_of(Array)
         expect(x.remarks.count).to eq(1)
         expect(x.remarks[0]).to eq("function repeat scope - function repeat")
       end
-      
+
       schema.functions.first.statements[2].tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Statements::Assignment)
         expect(x.expression).to be_instance_of(Expressir::Model::Expressions::QueryExpression)
@@ -182,7 +227,7 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.expression.remarks.count).to eq(1)
         expect(x.expression.remarks[0]).to eq("function query scope - function query")
       end
-      
+
       schema.procedures.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Procedure)
         expect(x.remarks).to be_instance_of(Array)
@@ -190,7 +235,7 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.remarks[0]).to eq("schema scope - procedure")
         expect(x.remarks[1]).to eq("universal scope - procedure")
       end
-      
+
       schema.procedures.first.parameters.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Parameter)
         expect(x.remarks).to be_instance_of(Array)
@@ -199,7 +244,7 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.remarks[1]).to eq("schema scope - procedure parameter")
         expect(x.remarks[2]).to eq("universal scope - procedure parameter")
       end
-      
+
       schema.procedures.first.types.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Type)
         expect(x.remarks).to be_instance_of(Array)
@@ -212,13 +257,16 @@ RSpec.describe Expressir::ExpressExp::Parser do
         x.type.items.first.tap do |x|
           expect(x).to be_instance_of(Expressir::Model::EnumerationItem)
           expect(x.remarks).to be_instance_of(Array)
-          expect(x.remarks.count).to eq(3)
+          expect(x.remarks.count).to eq(6)
           expect(x.remarks[0]).to eq("procedure scope - procedure enumeration item")
-          expect(x.remarks[1]).to eq("schema scope - procedure enumeration item")
-          expect(x.remarks[2]).to eq("universal scope - procedure enumeration item")
+          expect(x.remarks[1]).to eq("procedure scope - procedure enumeration item, on the same level as the type")
+          expect(x.remarks[2]).to eq("schema scope - procedure enumeration item")
+          expect(x.remarks[3]).to eq("schema scope - procedure enumeration item, on the same level as the type")
+          expect(x.remarks[4]).to eq("universal scope - procedure enumeration item")
+          expect(x.remarks[5]).to eq("universal scope - procedure enumeration item, on the same level as the type")
         end
       end
-      
+
       schema.procedures.first.constants.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Constant)
         expect(x.remarks).to be_instance_of(Array)
@@ -227,7 +275,7 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.remarks[1]).to eq("schema scope - procedure constant")
         expect(x.remarks[2]).to eq("universal scope - procedure constant")
       end
-      
+
       schema.procedures.first.variables.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Variable)
         expect(x.remarks).to be_instance_of(Array)
@@ -236,21 +284,21 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.remarks[1]).to eq("schema scope - procedure variable")
         expect(x.remarks[2]).to eq("universal scope - procedure variable")
       end
-      
+
       schema.procedures.first.statements[0].tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Statements::Alias)
         expect(x.remarks).to be_instance_of(Array)
         expect(x.remarks.count).to eq(1)
         expect(x.remarks[0]).to eq("procedure alias scope - procedure alias")
       end
-      
+
       schema.procedures.first.statements[1].tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Statements::Repeat)
         expect(x.remarks).to be_instance_of(Array)
         expect(x.remarks.count).to eq(1)
         expect(x.remarks[0]).to eq("procedure repeat scope - procedure repeat")
       end
-      
+
       schema.procedures.first.statements[2].tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Statements::Assignment)
         expect(x.expression).to be_instance_of(Expressir::Model::Expressions::QueryExpression)
@@ -258,7 +306,7 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.expression.remarks.count).to eq(1)
         expect(x.expression.remarks[0]).to eq("procedure query scope - procedure query")
       end
-      
+
       schema.rules.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Rule)
         expect(x.remarks).to be_instance_of(Array)
@@ -266,7 +314,7 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.remarks[0]).to eq("schema scope - rule")
         expect(x.remarks[1]).to eq("universal scope - rule")
       end
-      
+
       schema.rules.first.types.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Type)
         expect(x.remarks).to be_instance_of(Array)
@@ -279,13 +327,16 @@ RSpec.describe Expressir::ExpressExp::Parser do
         x.type.items.first.tap do |x|
           expect(x).to be_instance_of(Expressir::Model::EnumerationItem)
           expect(x.remarks).to be_instance_of(Array)
-          expect(x.remarks.count).to eq(3)
+          expect(x.remarks.count).to eq(6)
           expect(x.remarks[0]).to eq("rule scope - rule enumeration item")
-          expect(x.remarks[1]).to eq("schema scope - rule enumeration item")
-          expect(x.remarks[2]).to eq("universal scope - rule enumeration item")
+          expect(x.remarks[1]).to eq("rule scope - rule enumeration item, on the same level as the type")
+          expect(x.remarks[2]).to eq("schema scope - rule enumeration item")
+          expect(x.remarks[3]).to eq("schema scope - rule enumeration item, on the same level as the type")
+          expect(x.remarks[4]).to eq("universal scope - rule enumeration item")
+          expect(x.remarks[5]).to eq("universal scope - rule enumeration item, on the same level as the type")
         end
       end
-      
+
       schema.rules.first.constants.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Constant)
         expect(x.remarks).to be_instance_of(Array)
@@ -294,7 +345,7 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.remarks[1]).to eq("schema scope - rule constant")
         expect(x.remarks[2]).to eq("universal scope - rule constant")
       end
-      
+
       schema.rules.first.variables.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Variable)
         expect(x.remarks).to be_instance_of(Array)
@@ -303,21 +354,21 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.remarks[1]).to eq("schema scope - rule variable")
         expect(x.remarks[2]).to eq("universal scope - rule variable")
       end
-      
+
       schema.rules.first.statements[0].tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Statements::Alias)
         expect(x.remarks).to be_instance_of(Array)
         expect(x.remarks.count).to eq(1)
         expect(x.remarks[0]).to eq("rule alias scope - rule alias")
       end
-      
+
       schema.rules.first.statements[1].tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Statements::Repeat)
         expect(x.remarks).to be_instance_of(Array)
         expect(x.remarks.count).to eq(1)
         expect(x.remarks[0]).to eq("rule repeat scope - rule repeat")
       end
-      
+
       schema.rules.first.statements[2].tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Statements::Assignment)
         expect(x.expression).to be_instance_of(Expressir::Model::Expressions::QueryExpression)
@@ -325,14 +376,29 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.expression.remarks.count).to eq(1)
         expect(x.expression.remarks[0]).to eq("rule query scope - rule query")
       end
-      
+
       schema.rules.first.where.first.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Where)
         expect(x.remarks).to be_instance_of(Array)
-        expect(x.remarks.count).to eq(3)
+        expect(x.remarks.count).to eq(6)
         expect(x.remarks[0]).to eq("rule scope - rule where")
-        expect(x.remarks[1]).to eq("schema scope - rule where")
-        expect(x.remarks[2]).to eq("universal scope - rule where")
+        expect(x.remarks[1]).to eq("rule scope - rule where, with prefix")
+        expect(x.remarks[2]).to eq("schema scope - rule where")
+        expect(x.remarks[3]).to eq("schema scope - rule where, with prefix")
+        expect(x.remarks[4]).to eq("universal scope - rule where")
+        expect(x.remarks[5]).to eq("universal scope - rule where, with prefix")
+      end
+
+      schema.rules.first.informal_propositions.first.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::InformalProposition)
+        expect(x.remarks).to be_instance_of(Array)
+        expect(x.remarks.count).to eq(6)
+        expect(x.remarks[0]).to eq("rule scope - rule informal proposition")
+        expect(x.remarks[1]).to eq("rule scope - rule informal proposition, with prefix")
+        expect(x.remarks[2]).to eq("schema scope - rule informal proposition")
+        expect(x.remarks[3]).to eq("schema scope - rule informal proposition, with prefix")
+        expect(x.remarks[4]).to eq("universal scope - rule informal proposition")
+        expect(x.remarks[5]).to eq("universal scope - rule informal proposition, with prefix")
       end
     end
   end

data/spec/expressir/express_exp/parse_syntax_spec.rb

@@ -42,6 +42,19 @@ RSpec.describe Expressir::ExpressExp::Parser do
       end
 
       use_interfaces[2].tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Interface)
+        expect(x.kind).to eq(Expressir::Model::Interface::USE)
+        expect(x.schema).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+        expect(x.schema.id).to eq("contract_schema")
+        expect(x.items).to be_instance_of(Array)
+        expect(x.items.count).to eq(2)
+        expect(x.items[0]).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+        expect(x.items[0].id).to eq("contract")
+        expect(x.items[1]).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+        expect(x.items[1].id).to eq("contract2")
+      end
+
+      use_interfaces[3].tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Interface)
         expect(x.kind).to eq(Expressir::Model::Interface::USE)
         expect(x.schema).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
@@ -73,6 +86,19 @@ RSpec.describe Expressir::ExpressExp::Parser do
       end
 
       reference_interfaces[2].tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Interface)
+        expect(x.kind).to eq(Expressir::Model::Interface::REFERENCE)
+        expect(x.schema).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+        expect(x.schema.id).to eq("contract_schema")
+        expect(x.items).to be_instance_of(Array)
+        expect(x.items.count).to eq(2)
+        expect(x.items[0]).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+        expect(x.items[0].id).to eq("contract")
+        expect(x.items[1]).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+        expect(x.items[1].id).to eq("contract2")
+      end
+
+      reference_interfaces[3].tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Interface)
         expect(x.kind).to eq(Expressir::Model::Interface::REFERENCE)
         expect(x.schema).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
@@ -1438,6 +1464,20 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.where[0].expression.value).to eq(Expressir::Model::Literals::Logical::TRUE)
       end
 
+      rules.find{|x| x.id == "where_label_rule"}.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Rule)
+        expect(x.applies_to).to be_instance_of(Array)
+        expect(x.applies_to.count).to eq(1)
+        expect(x.applies_to[0]).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+        expect(x.applies_to[0].id).to eq("empty_entity")
+        expect(x.where).to be_instance_of(Array)
+        expect(x.where.count).to eq(1)
+        expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
+        expect(x.where[0].id).to eq("WR1")
+        expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+        expect(x.where[0].expression.value).to eq(Expressir::Model::Literals::Logical::TRUE)
+      end
+
       # simple types
       types.find{|x| x.id == "binary_type"}.type.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Types::Binary)
@@ -2089,6 +2129,11 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.value).to eq("xxx")
       end
 
+      functions.find{|x| x.id == "utf8_simple_string_expression"}.statements[0].expression.tap do |x|
+        expect(x).to be_instance_of(Expressir::Model::Literals::String)
+        expect(x.value).to eq("UTF8 test: Příliš žluťoučký kůň úpěl ďábelské ódy.")
+      end
+
       functions.find{|x| x.id == "encoded_string_expression"}.statements[0].expression.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Literals::String)
         expect(x.value).to eq("000000780000007800000078")
@@ -2982,8 +3027,8 @@ RSpec.describe Expressir::ExpressExp::Parser do
       functions.find{|x| x.id == "query_expression"}.statements[0].expression.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Expressions::QueryExpression)
         expect(x.id).to eq("test")
-        expect(x.source).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
-        expect(x.source.id).to eq("test2")
+        expect(x.aggregate_source).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+        expect(x.aggregate_source.id).to eq("test2")
         expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
         expect(x.expression.value).to eq(Expressir::Model::Literals::Logical::TRUE)
       end