expressir 0.2.8-x64-mingw32 → 0.2.13-x64-mingw32

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,24 @@
+require "spec_helper"
+require "expressir/express_exp/parser"
+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)
+
+      result = Expressir::ExpressExp::HyperlinkFormatter.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/parser/head_source_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+require "expressir/express_exp/parser"
+
+RSpec.describe Expressir::ExpressExp::Parser do
+  describe ".head_source" do
+    it "contains original head source" do
+      input = File.read(sample_file)
+      repo = Expressir::ExpressExp::Parser.from_file(sample_file)
+
+      repo.schemas[0].tap do |x|
+        start_index = x.source.index("SCHEMA")
+        stop_index = x.source.index(";") + ";".length - 1
+        expected_result = x.source[start_index..stop_index]
+        expect(x.head_source).to eq(expected_result)
+      end
+
+      repo.schemas[1].tap do |x|
+        start_index = x.source.index("SCHEMA")
+        stop_index = x.source.index(";") + ";".length - 1
+        expected_result = x.source[start_index..stop_index]
+        expect(x.head_source).to eq(expected_result)
+      end
+
+      repo.schemas[2].tap do |x|
+        start_index = x.source.index("SCHEMA")
+        stop_index = x.source.index("REFERENCE FROM contract_schema;") + "REFERENCE FROM contract_schema;".length - 1
+        expected_result = x.source[start_index..stop_index]
+        expect(x.head_source).to eq(expected_result)
+      end
+    end
+  end
+
+  def sample_file
+    @sample_file ||= Expressir.root_path.join(
+      "original", "examples", "syntax", "source.exp"
+    )
+  end
+end

data/spec/expressir/express_exp/parser/multiple_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+require "expressir/express_exp/parser"
+
+RSpec.describe Expressir::ExpressExp::Parser do
+  describe ".from_files" 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].id).to eq("syntax_schema")
+      expect(schemas[1].id).to eq("remark_schema")
+      expect(schemas[2].id).to eq("entity_schema")
+      expect(schemas[3].id).to eq("version_entity_schema")
+      expect(schemas[4].id).to eq("version_interface_entity_schema")
+    end
+  end
+
+  def sample_files
+    @sample_files ||= [
+      Expressir.root_path.join(
+        "original", "examples", "syntax", "syntax.exp"
+      ),
+      Expressir.root_path.join(
+        "original", "examples", "syntax", "remark.exp"
+      ),
+      Expressir.root_path.join(
+        "original", "examples", "syntax", "source.exp"
+      )
+    ]
+  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
 
@@ -18,7 +18,7 @@ RSpec.describe Expressir::ExpressExp::Parser do
         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)
@@ -26,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)
@@ -38,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)
@@ -51,8 +77,8 @@ 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|
+
+      schema.entities.first.attributes.find{|x| x.kind == Expressir::Model::Attribute::EXPLICIT}.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Attribute)
         expect(x.kind).to eq(Expressir::Model::Attribute::EXPLICIT)
         expect(x.remarks).to be_instance_of(Array)
@@ -61,8 +87,8 @@ 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|
+
+      schema.entities.first.attributes.find{|x| x.kind == Expressir::Model::Attribute::DERIVED}.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Attribute)
         expect(x.kind).to eq(Expressir::Model::Attribute::DERIVED)
         expect(x.remarks).to be_instance_of(Array)
@@ -71,8 +97,8 @@ 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|
+
+      schema.entities.first.attributes.find{|x| x.kind == Expressir::Model::Attribute::INVERSE}.tap do |x|
         expect(x).to be_instance_of(Expressir::Model::Attribute)
         expect(x.kind).to eq(Expressir::Model::Attribute::INVERSE)
         expect(x.remarks).to be_instance_of(Array)
@@ -81,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)
@@ -90,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)
@@ -107,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)
@@ -115,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)
@@ -124,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)
@@ -137,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)
@@ -152,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)
@@ -161,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)
@@ -183,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)
@@ -191,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)
@@ -200,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)
@@ -213,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)
@@ -228,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)
@@ -237,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)
@@ -259,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)
@@ -267,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)
@@ -280,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)
@@ -295,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)
@@ -304,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)
@@ -326,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