expressir 0.2.11-x86-linux → 0.2.16-x86-linux

data/original/examples/syntax/syntax_formatted.exp

@@ -61,21 +61,25 @@ ENTITY attribute_multiple_shorthand_entity;
   test : BOOLEAN;
   test2 : BOOLEAN;
 END_ENTITY;
-ENTITY attribute_redeclared_entity;
+ENTITY attribute_redeclared_entity
+  SUBTYPE OF (attribute_entity);
   SELF\attribute_entity.test : BOOLEAN;
 END_ENTITY;
-ENTITY attribute_redeclared_renamed_entity;
+ENTITY attribute_redeclared_renamed_entity
+  SUBTYPE OF (attribute_entity);
   SELF\attribute_entity.test RENAMED test2 : BOOLEAN;
 END_ENTITY;
 ENTITY derived_attribute_entity;
   DERIVE
     test : BOOLEAN := TRUE;
 END_ENTITY;
-ENTITY derived_attribute_redeclared_entity;
+ENTITY derived_attribute_redeclared_entity
+  SUBTYPE OF (attribute_entity);
   DERIVE
     SELF\attribute_entity.test : BOOLEAN := TRUE;
 END_ENTITY;
-ENTITY derived_attribute_redeclared_renamed_entity;
+ENTITY derived_attribute_redeclared_renamed_entity
+  SUBTYPE OF (attribute_entity);
   DERIVE
     SELF\attribute_entity.test RENAMED test2 : BOOLEAN := TRUE;
 END_ENTITY;
@@ -103,11 +107,13 @@ ENTITY inverse_attribute_bag_bound_entity;
   INVERSE
     test : BAG [1:9] OF attribute_entity FOR test;
 END_ENTITY;
-ENTITY inverse_attribute_redeclared_entity;
+ENTITY inverse_attribute_redeclared_entity
+  SUBTYPE OF (attribute_entity);
   INVERSE
     SELF\attribute_entity.test : attribute_entity FOR test;
 END_ENTITY;
-ENTITY inverse_attribute_redeclared_renamed_entity;
+ENTITY inverse_attribute_redeclared_renamed_entity
+  SUBTYPE OF (attribute_entity);
   INVERSE
     SELF\attribute_entity.test RENAMED test2 : attribute_entity FOR test;
 END_ENTITY;
@@ -121,11 +127,13 @@ ENTITY unique_label_entity;
   UNIQUE
     UR1 : test;
 END_ENTITY;
-ENTITY unique_qualified_entity;
+ENTITY unique_redeclared_entity
+  SUBTYPE OF (attribute_entity);
   UNIQUE
     SELF\attribute_entity.test;
 END_ENTITY;
-ENTITY unique_label_qualified_entity;
+ENTITY unique_label_redeclared_entity
+  SUBTYPE OF (attribute_entity);
   UNIQUE
     UR1 : SELF\attribute_entity.test;
 END_ENTITY;
@@ -331,13 +339,8 @@ PROCEDURE statements;
       ;
     END_ALIAS;
   END_PROCEDURE;
-  PROCEDURE alias_attribute_reference_statement;
-    ALIAS test FOR test.test;
-      ;
-    END_ALIAS;
-  END_PROCEDURE;
   PROCEDURE alias_group_reference_statement;
-    ALIAS test FOR test\test;
+    ALIAS test FOR test\test2;
       ;
     END_ALIAS;
   END_PROCEDURE;
@@ -351,14 +354,16 @@ PROCEDURE statements;
       ;
     END_ALIAS;
   END_PROCEDURE;
+  PROCEDURE alias_attribute_reference_statement;
+    ALIAS test FOR test.test2;
+      ;
+    END_ALIAS;
+  END_PROCEDURE;
   PROCEDURE assignment_simple_reference_statement;
     test := TRUE;
   END_PROCEDURE;
-  PROCEDURE assignment_attribute_reference_statement;
-    test.test := TRUE;
-  END_PROCEDURE;
   PROCEDURE assignment_group_reference_statement;
-    test\test := TRUE;
+    test\test2 := TRUE;
   END_PROCEDURE;
   PROCEDURE assignment_index_reference_statement;
     test[1] := TRUE;
@@ -366,6 +371,9 @@ PROCEDURE statements;
   PROCEDURE assignment_index2_reference_statement;
     test[1:9] := TRUE;
   END_PROCEDURE;
+  PROCEDURE assignment_attribute_reference_statement;
+    test.test2 := TRUE;
+  END_PROCEDURE;
   PROCEDURE case_statement;
     CASE test OF
     TRUE :
@@ -651,7 +659,7 @@ PROCEDURE expressions;
     and_or_expression : BOOLEAN := TRUE AND FALSE OR TRUE;
     parenthesis_or_and_expression : BOOLEAN := (TRUE OR FALSE) AND TRUE;
     and_parenthesis_or_expression : BOOLEAN := TRUE AND (FALSE OR TRUE);
-    combine_expression : BOOLEAN := test || test;
+    combine_expression : BOOLEAN := test || test2;
     in_expression : BOOLEAN := TRUE IN [TRUE];
     like_expression : BOOLEAN := 'xxx' LIKE 'xxx';
     aggregate_initializer_expression : BOOLEAN := [4];
@@ -659,11 +667,11 @@ PROCEDURE expressions;
     complex_aggregate_initializer_expression : BOOLEAN := [4 + 2];
     complex_repeated_aggregate_initializer_expression : BOOLEAN := [4 + 2:4 + 2];
     call_expression : BOOLEAN := parameter_function(TRUE);
-    simple_reference_expression : BOOLEAN := simple_string_expression;
-    attribute_reference_expression : BOOLEAN := simple_string_expression.test;
-    group_reference_expression : BOOLEAN := simple_string_expression\test;
-    index_reference_expression : BOOLEAN := simple_string_expression[1];
-    index2_reference_expression : BOOLEAN := simple_string_expression[1:9];
+    simple_reference_expression : BOOLEAN := test;
+    group_reference_expression : BOOLEAN := test\test2;
+    index_reference_expression : BOOLEAN := test[1];
+    index2_reference_expression : BOOLEAN := test[1:9];
+    attribute_reference_expression : BOOLEAN := test.test2;
     lt_lt_interval_expression : BOOLEAN := {1 < 5 < 9};
     lte_lt_interval_expression : BOOLEAN := {1 <= 5 < 9};
     lt_lte_interval_expression : BOOLEAN := {1 < 5 <= 9};

data/spec/expressir/express_exp/{format_remark_spec.rb → formatter/remark_spec.rb}

@@ -4,8 +4,8 @@ require "expressir/express_exp/formatter"
 
 RSpec.describe Expressir::ExpressExp::Formatter do
   describe ".format" do
-    it "formats a file" do
-      repo = Expressir::ExpressExp::Parser.from_exp(input_file)
+    it "formats remark" do
+      repo = Expressir::ExpressExp::Parser.from_file(input_file)
 
       result = Expressir::ExpressExp::Formatter.format(repo)
       expected_result = File.read(output_file)

data/spec/expressir/express_exp/{format_syntax_spec.rb → formatter/syntax_spec.rb}

@@ -4,8 +4,8 @@ require "expressir/express_exp/formatter"
 
 RSpec.describe Expressir::ExpressExp::Formatter do
   describe ".format" do
-    it "formats a file" do
-      repo = Expressir::ExpressExp::Parser.from_exp(input_file)
+    it "formats syntax" do
+      repo = Expressir::ExpressExp::Parser.from_file(input_file)
 
       result = Expressir::ExpressExp::Formatter.format(repo)
       expected_result = File.read(output_file)

data/spec/expressir/express_exp/hyperlink_formatter_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+require "expressir/express_exp/parser"
+require "expressir/express_exp/formatter"
+require "expressir/express_exp/hyperlink_formatter"
+
+RSpec.describe Expressir::ExpressExp::HyperlinkFormatter do
+  describe ".format" do
+    it "formats hyperlink" do
+      repo = Expressir::ExpressExp::Parser.from_file(input_file)
+
+      class CustomFormatter < Expressir::ExpressExp::Formatter
+        include Expressir::ExpressExp::HyperlinkFormatter
+      end
+      result = CustomFormatter.format(repo)
+      expected_result = File.read(output_file)
+
+      expect(result).to eq(expected_result)
+    end
+  end
+
+  def input_file
+    @input_file ||= Expressir.root_path.join("original", "examples", "syntax", "hyperlink.exp")
+  end
+
+  def output_file
+    @output_file ||= Expressir.root_path.join("original", "examples", "syntax", "hyperlink_formatted.exp")
+  end
+end

data/spec/expressir/express_exp/{parse_multiple_spec.rb → parser/multiple_spec.rb}

@@ -3,15 +3,20 @@ require "expressir/express_exp/parser"
 
 RSpec.describe Expressir::ExpressExp::Parser do
   describe ".from_files" do
-    it "build an instance from multiple files file" do
+    it "parses multiple files" do
       repo = Expressir::ExpressExp::Parser.from_files(sample_files)
 
       schemas = repo.schemas
       expect(schemas.count).to eq(5)
+      expect(schemas[0].file).to eq(sample_files[0])
       expect(schemas[0].id).to eq("syntax_schema")
+      expect(schemas[1].file).to eq(sample_files[1])
       expect(schemas[1].id).to eq("remark_schema")
+      expect(schemas[2].file).to eq(sample_files[2])
       expect(schemas[2].id).to eq("entity_schema")
+      expect(schemas[3].file).to eq(sample_files[2])
       expect(schemas[3].id).to eq("version_entity_schema")
+      expect(schemas[4].file).to eq(sample_files[2])
       expect(schemas[4].id).to eq("version_interface_entity_schema")
     end
   end

data/spec/expressir/express_exp/{parse_remark_spec.rb → parser/remark_spec.rb}

@@ -3,8 +3,8 @@ require "expressir/express_exp/parser"
 
 RSpec.describe Expressir::ExpressExp::Parser do
   describe ".from_file" do
-    it "build an instance from a file" do
-      repo = Expressir::ExpressExp::Parser.from_exp(sample_file)
+    it "parses remark" do
+      repo = Expressir::ExpressExp::Parser.from_file(sample_file)
 
       schema = repo.schemas.first
 

data/spec/expressir/express_exp/{source_spec.rb → parser/source_spec.rb}

@@ -5,7 +5,7 @@ RSpec.describe Expressir::ExpressExp::Parser do
   describe ".source" do
     it "contains original source" do
       input = File.read(sample_file)
-      repo = Expressir::ExpressExp::Parser.from_exp(sample_file)
+      repo = Expressir::ExpressExp::Parser.from_file(sample_file)
 
       schema = repo.schemas.first
       start_index = input.index("SCHEMA")

data/spec/expressir/express_exp/{parse_syntax_spec.rb → parser/syntax_spec.rb}

@@ -3,8 +3,8 @@ require "expressir/express_exp/parser"
 
 RSpec.describe Expressir::ExpressExp::Parser do
   describe ".from_file" do
-    it "build an instance from a file" do
-      repo = Expressir::ExpressExp::Parser.from_exp(sample_file)
+    it "parses syntax" do
+      repo = Expressir::ExpressExp::Parser.from_file(sample_file)
 
       schemas = repo.schemas
 
@@ -36,8 +36,9 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.schema.id).to eq("contract_schema")
         expect(x.items).to be_instance_of(Array)
         expect(x.items.count).to eq(1)
-        expect(x.items[0]).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
-        expect(x.items[0].id).to eq("contract")
+        expect(x.items[0]).to be_instance_of(Expressir::Model::InterfaceItem)
+        expect(x.items[0].ref).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+        expect(x.items[0].ref.id).to eq("contract")
       end
 
       interfaces[2].tap do |x|
@@ -47,10 +48,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
         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")
+        expect(x.items[0]).to be_instance_of(Expressir::Model::InterfaceItem)
+        expect(x.items[0].ref).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+        expect(x.items[0].ref.id).to eq("contract")
+        expect(x.items[1]).to be_instance_of(Expressir::Model::InterfaceItem)
+        expect(x.items[1].ref).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+        expect(x.items[1].ref.id).to eq("contract2")
       end
 
       interfaces[3].tap do |x|
@@ -60,10 +63,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.schema.id).to eq("contract_schema")
         expect(x.items).to be_instance_of(Array)
         expect(x.items.count).to eq(1)
-        expect(x.items[0]).to be_instance_of(Expressir::Model::RenamedRef)
+        expect(x.items[0]).to be_instance_of(Expressir::Model::InterfaceItem)
+        expect(x.items[0].id).to eq("contract2")
         expect(x.items[0].ref).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
         expect(x.items[0].ref.id).to eq("contract")
-        expect(x.items[0].id).to eq("contract2")
       end
 
       interfaces[4].tap do |x|
@@ -80,8 +83,9 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.schema.id).to eq("contract_schema")
         expect(x.items).to be_instance_of(Array)
         expect(x.items.count).to eq(1)
-        expect(x.items[0]).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
-        expect(x.items[0].id).to eq("contract")
+        expect(x.items[0]).to be_instance_of(Expressir::Model::InterfaceItem)
+        expect(x.items[0].ref).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+        expect(x.items[0].ref.id).to eq("contract")
       end
 
       interfaces[6].tap do |x|
@@ -91,10 +95,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
         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")
+        expect(x.items[0]).to be_instance_of(Expressir::Model::InterfaceItem)
+        expect(x.items[0].ref).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+        expect(x.items[0].ref.id).to eq("contract")
+        expect(x.items[1]).to be_instance_of(Expressir::Model::InterfaceItem)
+        expect(x.items[1].ref).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+        expect(x.items[1].ref.id).to eq("contract2")
       end
 
       interfaces[7].tap do |x|
@@ -104,10 +110,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.schema.id).to eq("contract_schema")
         expect(x.items).to be_instance_of(Array)
         expect(x.items.count).to eq(1)
-        expect(x.items[0]).to be_instance_of(Expressir::Model::RenamedRef)
+        expect(x.items[0]).to be_instance_of(Expressir::Model::InterfaceItem)
+        expect(x.items[0].id).to eq("contract2")
         expect(x.items[0].ref).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
         expect(x.items[0].ref.id).to eq("contract")
-        expect(x.items[0].id).to eq("contract2")
       end
 
       # constants
@@ -242,6 +248,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       entities.find{|x| x.id == "attribute_redeclared_entity"}.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Entity)
+        expect(x.subtype_of).to be_instance_of(Array)
+        expect(x.subtype_of.count).to eq(1)
+        expect(x.subtype_of[0]).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+        expect(x.subtype_of[0].id).to eq("attribute_entity")
         expect(x.attributes).to be_instance_of(Array)
         expect(x.attributes.count).to eq(1)
         expect(x.attributes[0]).to be_instance_of(Expressir::Model::Attribute)
@@ -259,6 +269,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       entities.find{|x| x.id == "attribute_redeclared_renamed_entity"}.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Entity)
+        expect(x.subtype_of).to be_instance_of(Array)
+        expect(x.subtype_of.count).to eq(1)
+        expect(x.subtype_of[0]).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+        expect(x.subtype_of[0].id).to eq("attribute_entity")
         expect(x.attributes).to be_instance_of(Array)
         expect(x.attributes.count).to eq(1)
         expect(x.attributes[0]).to be_instance_of(Expressir::Model::Attribute)
@@ -289,6 +303,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       entities.find{|x| x.id == "derived_attribute_redeclared_entity"}.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Entity)
+        expect(x.subtype_of).to be_instance_of(Array)
+        expect(x.subtype_of.count).to eq(1)
+        expect(x.subtype_of[0]).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+        expect(x.subtype_of[0].id).to eq("attribute_entity")
         expect(x.attributes).to be_instance_of(Array)
         expect(x.attributes.count).to eq(1)
         expect(x.attributes[0]).to be_instance_of(Expressir::Model::Attribute)
@@ -308,6 +326,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       entities.find{|x| x.id == "derived_attribute_redeclared_renamed_entity"}.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Entity)
+        expect(x.subtype_of).to be_instance_of(Array)
+        expect(x.subtype_of.count).to eq(1)
+        expect(x.subtype_of[0]).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+        expect(x.subtype_of[0].id).to eq("attribute_entity")
         expect(x.attributes).to be_instance_of(Array)
         expect(x.attributes.count).to eq(1)
         expect(x.attributes[0]).to be_instance_of(Expressir::Model::Attribute)
@@ -421,6 +443,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       entities.find{|x| x.id == "inverse_attribute_redeclared_entity"}.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Entity)
+        expect(x.subtype_of).to be_instance_of(Array)
+        expect(x.subtype_of.count).to eq(1)
+        expect(x.subtype_of[0]).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+        expect(x.subtype_of[0].id).to eq("attribute_entity")
         expect(x.attributes).to be_instance_of(Array)
         expect(x.attributes.count).to eq(1)
         expect(x.attributes[0]).to be_instance_of(Expressir::Model::Attribute)
@@ -441,6 +467,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
 
       entities.find{|x| x.id == "inverse_attribute_redeclared_renamed_entity"}.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Entity)
+        expect(x.subtype_of).to be_instance_of(Array)
+        expect(x.subtype_of.count).to eq(1)
+        expect(x.subtype_of[0]).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+        expect(x.subtype_of[0].id).to eq("attribute_entity")
         expect(x.attributes).to be_instance_of(Array)
         expect(x.attributes.count).to eq(1)
         expect(x.attributes[0]).to be_instance_of(Expressir::Model::Attribute)
@@ -495,8 +525,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.unique[0].attributes[0].id).to eq("test")
       end
 
-      entities.find{|x| x.id == "unique_qualified_entity"}.tap do |x|
+      entities.find{|x| x.id == "unique_redeclared_entity"}.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Entity)
+        expect(x.subtype_of).to be_instance_of(Array)
+        expect(x.subtype_of.count).to eq(1)
+        expect(x.subtype_of[0]).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+        expect(x.subtype_of[0].id).to eq("attribute_entity")
         expect(x.unique).to be_instance_of(Array)
         expect(x.unique.count).to eq(1)
         expect(x.unique[0]).to be_instance_of(Expressir::Model::Unique)
@@ -524,8 +558,12 @@ RSpec.describe Expressir::ExpressExp::Parser do
         expect(x.unique[0].attributes[0].id).to eq("test")
       end
 
-      entities.find{|x| x.id == "unique_label_qualified_entity"}.tap do |x|
+      entities.find{|x| x.id == "unique_label_redeclared_entity"}.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Entity)
+        expect(x.subtype_of).to be_instance_of(Array)
+        expect(x.subtype_of.count).to eq(1)
+        expect(x.subtype_of[0]).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+        expect(x.subtype_of[0].id).to eq("attribute_entity")
         expect(x.unique).to be_instance_of(Array)
         expect(x.unique.count).to eq(1)
         expect(x.unique[0]).to be_instance_of(Expressir::Model::Unique)
@@ -1489,19 +1527,6 @@ RSpec.describe Expressir::ExpressExp::Parser do
           expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
         end
 
-        x.procedures.find{|x| x.id == "alias_attribute_reference_statement"}.statements[0].tap do |x|
-          expect(x).to be_instance_of(Expressir::Model::Statements::Alias)
-          expect(x.id).to eq("test")
-          expect(x.expression).to be_instance_of(Expressir::Model::Expressions::AttributeReference)
-          expect(x.expression.ref).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
-          expect(x.expression.ref.id).to eq("test")
-          expect(x.expression.attribute).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
-          expect(x.expression.attribute.id).to eq("test")
-          expect(x.statements).to be_instance_of(Array)
-          expect(x.statements.count).to eq(1)
-          expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
-        end
-
         x.procedures.find{|x| x.id == "alias_group_reference_statement"}.statements[0].tap do |x|
           expect(x).to be_instance_of(Expressir::Model::Statements::Alias)
           expect(x.id).to eq("test")
@@ -1509,7 +1534,7 @@ RSpec.describe Expressir::ExpressExp::Parser do
           expect(x.expression.ref).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
           expect(x.expression.ref.id).to eq("test")
           expect(x.expression.entity).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
-          expect(x.expression.entity.id).to eq("test")
+          expect(x.expression.entity.id).to eq("test2")
           expect(x.statements).to be_instance_of(Array)
           expect(x.statements.count).to eq(1)
           expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
@@ -1543,6 +1568,19 @@ RSpec.describe Expressir::ExpressExp::Parser do
           expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
         end
 
+        x.procedures.find{|x| x.id == "alias_attribute_reference_statement"}.statements[0].tap do |x|
+          expect(x).to be_instance_of(Expressir::Model::Statements::Alias)
+          expect(x.id).to eq("test")
+          expect(x.expression).to be_instance_of(Expressir::Model::Expressions::AttributeReference)
+          expect(x.expression.ref).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+          expect(x.expression.ref.id).to eq("test")
+          expect(x.expression.attribute).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+          expect(x.expression.attribute.id).to eq("test2")
+          expect(x.statements).to be_instance_of(Array)
+          expect(x.statements.count).to eq(1)
+          expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
+        end
+
         x.procedures.find{|x| x.id == "assignment_simple_reference_statement"}.statements[0].tap do |x|
           expect(x).to be_instance_of(Expressir::Model::Statements::Assignment)
           expect(x.ref).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
@@ -1551,24 +1589,13 @@ RSpec.describe Expressir::ExpressExp::Parser do
           expect(x.expression.value).to eq(Expressir::Model::Literals::Logical::TRUE)
         end
 
-        x.procedures.find{|x| x.id == "assignment_attribute_reference_statement"}.statements[0].tap do |x|
-          expect(x).to be_instance_of(Expressir::Model::Statements::Assignment)
-          expect(x.ref).to be_instance_of(Expressir::Model::Expressions::AttributeReference)
-          expect(x.ref.ref).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
-          expect(x.ref.ref.id).to eq("test")
-          expect(x.ref.attribute).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
-          expect(x.ref.attribute.id).to eq("test")
-          expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
-          expect(x.expression.value).to eq(Expressir::Model::Literals::Logical::TRUE)
-        end
-
         x.procedures.find{|x| x.id == "assignment_group_reference_statement"}.statements[0].tap do |x|
           expect(x).to be_instance_of(Expressir::Model::Statements::Assignment)
           expect(x.ref).to be_instance_of(Expressir::Model::Expressions::GroupReference)
           expect(x.ref.ref).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
           expect(x.ref.ref.id).to eq("test")
           expect(x.ref.entity).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
-          expect(x.ref.entity.id).to eq("test")
+          expect(x.ref.entity.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
@@ -1597,6 +1624,17 @@ RSpec.describe Expressir::ExpressExp::Parser do
           expect(x.expression.value).to eq(Expressir::Model::Literals::Logical::TRUE)
         end
 
+        x.procedures.find{|x| x.id == "assignment_attribute_reference_statement"}.statements[0].tap do |x|
+          expect(x).to be_instance_of(Expressir::Model::Statements::Assignment)
+          expect(x.ref).to be_instance_of(Expressir::Model::Expressions::AttributeReference)
+          expect(x.ref.ref).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+          expect(x.ref.ref.id).to eq("test")
+          expect(x.ref.attribute).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+          expect(x.ref.attribute.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
+
         x.procedures.find{|x| x.id == "case_statement"}.statements[0].tap do |x|
           expect(x).to be_instance_of(Expressir::Model::Statements::Case)
           expect(x.expression).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
@@ -2911,29 +2949,21 @@ RSpec.describe Expressir::ExpressExp::Parser do
         # reference expressions
         x.variables.find{|x| x.id == "simple_reference_expression"}.expression.tap do |x|
           expect(x).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
-          expect(x.id).to eq("simple_string_expression")
-        end
-
-        x.variables.find{|x| x.id == "attribute_reference_expression"}.expression.tap do |x|
-          expect(x).to be_instance_of(Expressir::Model::Expressions::AttributeReference)
-          expect(x.ref).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
-          expect(x.ref.id).to eq("simple_string_expression")
-          expect(x.attribute).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
-          expect(x.attribute.id).to eq("test")
+          expect(x.id).to eq("test")
         end
 
         x.variables.find{|x| x.id == "group_reference_expression"}.expression.tap do |x|
           expect(x).to be_instance_of(Expressir::Model::Expressions::GroupReference)
           expect(x.ref).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
-          expect(x.ref.id).to eq("simple_string_expression")
+          expect(x.ref.id).to eq("test")
           expect(x.entity).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
-          expect(x.entity.id).to eq("test")
+          expect(x.entity.id).to eq("test2")
         end
 
         x.variables.find{|x| x.id == "index_reference_expression"}.expression.tap do |x|
           expect(x).to be_instance_of(Expressir::Model::Expressions::IndexReference)
           expect(x.ref).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
-          expect(x.ref.id).to eq("simple_string_expression")
+          expect(x.ref.id).to eq("test")
           expect(x.index1).to be_instance_of(Expressir::Model::Literals::Integer)
           expect(x.index1.value).to eq("1")
         end
@@ -2941,13 +2971,21 @@ RSpec.describe Expressir::ExpressExp::Parser do
         x.variables.find{|x| x.id == "index2_reference_expression"}.expression.tap do |x|
           expect(x).to be_instance_of(Expressir::Model::Expressions::IndexReference)
           expect(x.ref).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
-          expect(x.ref.id).to eq("simple_string_expression")
+          expect(x.ref.id).to eq("test")
           expect(x.index1).to be_instance_of(Expressir::Model::Literals::Integer)
           expect(x.index1.value).to eq("1")
           expect(x.index2).to be_instance_of(Expressir::Model::Literals::Integer)
           expect(x.index2.value).to eq("9")
         end
 
+        x.variables.find{|x| x.id == "attribute_reference_expression"}.expression.tap do |x|
+          expect(x).to be_instance_of(Expressir::Model::Expressions::AttributeReference)
+          expect(x.ref).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+          expect(x.ref.id).to eq("test")
+          expect(x.attribute).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
+          expect(x.attribute.id).to eq("test2")
+        end
+
         # interval expressions
         x.variables.find{|x| x.id == "lt_lt_interval_expression"}.expression.tap do |x|
           expect(x).to be_instance_of(Expressir::Model::Expressions::Interval)
@@ -3003,7 +3041,7 @@ RSpec.describe Expressir::ExpressExp::Parser do
           expect(x.operand1).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
           expect(x.operand1.id).to eq("test")
           expect(x.operand2).to be_instance_of(Expressir::Model::Expressions::SimpleReference)
-          expect(x.operand2.id).to eq("test")
+          expect(x.operand2.id).to eq("test2")
         end
 
         x.variables.find{|x| x.id == "in_expression"}.expression.tap do |x|