activefacts 0.8.6 → 0.8.8

data/spec/cql/samples_spec.rb

@@ -7,69 +7,93 @@ require 'activefacts/support'
 require 'activefacts/api/support'
 require 'activefacts/input/cql'
 
+require 'set'
+
 describe "Sample data" do
   SamplePrefix = %q{
   vocabulary V;
 
-  CompanyName is written as String;
+  Company Name is written as String;
   Company is identified by its Name;
-  Person is identified by its Name where Person is called PersonName;
+  Person is identified by its Name where Person is called Person Name;
   Directorship is where
       Company is directed by Person;
   }
 
-  Samples = [
+  GoodSamples = [
     [   # A simple ValueType instance
-      "CompanyName 'Microsoft';",
-      [{:facts=>[], :instances=>["CompanyName 'Microsoft'"]}]
+      "Company Name 'Microsoft';",
+      [{:facts=>Set[], :instances=>Set["Company Name 'Microsoft'"]}]
     ],
     [   # Re-assert the same instance
-      "CompanyName 'Microsoft'; CompanyName 'Microsoft';",
-      [{:facts=>[], :instances=>["CompanyName 'Microsoft'"]}]
+      "Company Name 'Microsoft'; Company Name 'Microsoft';",
+      [{:facts=>Set[], :instances=>Set["Company Name 'Microsoft'"]}]
     ],
     [   # The same instance, but in a named population
-      "example: CompanyName 'Microsoft';",
-      [{:facts=>[], :instances=>["CompanyName 'Microsoft'"]}]
+      "example: Company Name 'Microsoft';",
+      [{:facts=>Set[], :instances=>Set["Company Name 'Microsoft'"]}]
     ],
     [   # A simply-identified EntityType instance
       "Company 'Microsoft';",
-      [{:facts=>["Company has CompanyName 'Microsoft'"], :instances=>["Company is identified by CompanyName where Company has CompanyName 'Microsoft'", "CompanyName 'Microsoft'"]}]
+      [{:facts=>Set["Company has Company Name 'Microsoft'"], :instances=>Set["Company is identified by Company Name where Company has Company Name 'Microsoft'", "Company Name 'Microsoft'"]}]
     ],
     [   # Re-assert the same instance
       "Company 'Microsoft'; Company 'Microsoft';",
-      [{:facts=>["Company has CompanyName 'Microsoft'"], :instances=>["Company is identified by CompanyName where Company has CompanyName 'Microsoft'", "CompanyName 'Microsoft'"]}]
+      [{:facts=>Set["Company has Company Name 'Microsoft'"], :instances=>Set["Company is identified by Company Name where Company has Company Name 'Microsoft'", "Company Name 'Microsoft'"]}]
     ],
     [   # The same instance in a named population
       "example: Company 'Microsoft';",
-      [{:facts=>["Company has CompanyName 'Microsoft'"], :instances=>["Company is identified by CompanyName where Company has CompanyName 'Microsoft'", "CompanyName 'Microsoft'"]}]
+      [{:facts=>Set["Company has Company Name 'Microsoft'"], :instances=>Set["Company is identified by Company Name where Company has Company Name 'Microsoft'", "Company Name 'Microsoft'"]}]
     ],
     [   # The Company instance asserted with an explicit identifying fact
-      "Company has CompanyName 'Microsoft';",
-      [{:facts=>["Company has CompanyName 'Microsoft'"], :instances=>["Company is identified by CompanyName where Company has CompanyName 'Microsoft'", "CompanyName 'Microsoft'"]}]
+      "Company has Company Name 'Microsoft';",
+      [{:facts=>Set["Company has Company Name 'Microsoft'"], :instances=>Set["Company is identified by Company Name where Company has Company Name 'Microsoft'", "Company Name 'Microsoft'"]}]
     ],
     [   # The Company instance asserted with an joined identifying instance
-      "Company has CompanyName, CompanyName 'Microsoft';",
-      [{:facts=>["Company has CompanyName 'Microsoft'"], :instances=>["Company is identified by CompanyName where Company has CompanyName 'Microsoft'", "CompanyName 'Microsoft'"]}]
+      "Company has Company Name, Company Name 'Microsoft';",
+      [{:facts=>Set["Company has Company Name 'Microsoft'"], :instances=>Set["Company is identified by Company Name where Company has Company Name 'Microsoft'", "Company Name 'Microsoft'"]}]
     ],
     [   # The same, with an explicit identifying instance join
-      "CompanyName 'Microsoft', Company has CompanyName;",
-      [{:facts=>["Company has CompanyName 'Microsoft'"], :instances=>["Company is identified by CompanyName where Company has CompanyName 'Microsoft'", "CompanyName 'Microsoft'"]}]
+      "Company Name 'Microsoft', Company has Company Name;",
+      [{:facts=>Set["Company has Company Name 'Microsoft'"], :instances=>Set["Company is identified by Company Name where Company has Company Name 'Microsoft'", "Company Name 'Microsoft'"]}]
     ],
     [   # A simple fact instance with two simply-identified entities
       "Company 'Microsoft' is directed by Person 'Gates';",
-      [{:facts=>["Company has CompanyName 'Microsoft'", "Company is directed by Person", "Person is called PersonName 'Gates'"], :instances=>["Company is identified by CompanyName where Company has CompanyName 'Microsoft'", "CompanyName 'Microsoft'", "Directorship where Company is directed by Person", "Person is identified by PersonName where Person is called PersonName 'Gates'", "PersonName 'Gates'"]}]
+      [{:facts=>Set["Company has Company Name 'Microsoft'", "Company is directed by Person", "Person is called Person Name 'Gates'"], :instances=>Set["Company is identified by Company Name where Company has Company Name 'Microsoft'", "Company Name 'Microsoft'", "Directorship where Company is directed by Person", "Person is identified by Person Name where Person is called Person Name 'Gates'", "Person Name 'Gates'"]}]
     ],
     [   # Same with an explicit joined fact
-      "Company 'Microsoft' is directed by Person, Person is called PersonName 'Gates';",
-      [{:facts=>["Company has CompanyName 'Microsoft'", "Company is directed by Person", "Person is called PersonName 'Gates'"], :instances=>["Company is identified by CompanyName where Company has CompanyName 'Microsoft'", "CompanyName 'Microsoft'", "Directorship where Company is directed by Person", "Person is identified by PersonName where Person is called PersonName 'Gates'", "PersonName 'Gates'"]}]
+      "Company 'Microsoft' is directed by Person, Person is called Person Name 'Gates';",
+      [{:facts=>Set["Company has Company Name 'Microsoft'", "Company is directed by Person", "Person is called Person Name 'Gates'"], :instances=>Set["Company is identified by Company Name where Company has Company Name 'Microsoft'", "Company Name 'Microsoft'", "Directorship where Company is directed by Person", "Person is identified by Person Name where Person is called Person Name 'Gates'", "Person Name 'Gates'"]}]
     ],
     [   # Same with explicitly joined facts and instances
-      "Company is directed by Person, Person is called PersonName, PersonName 'Gates', Company has CompanyName, CompanyName 'Microsoft';",
-      [{:facts=>["Company has CompanyName 'Microsoft'", "Company is directed by Person", "Person is called PersonName 'Gates'"], :instances=>["Company is identified by CompanyName where Company has CompanyName 'Microsoft'", "CompanyName 'Microsoft'", "Directorship where Company is directed by Person", "Person is identified by PersonName where Person is called PersonName 'Gates'", "PersonName 'Gates'"]}]
+      "Company is directed by Person, Person is called Person Name, Person Name 'Gates', Company has Company Name, Company Name 'Microsoft';",
+      [{:facts=>Set["Company has Company Name 'Microsoft'", "Company is directed by Person", "Person is called Person Name 'Gates'"], :instances=>Set["Company is identified by Company Name where Company has Company Name 'Microsoft'", "Company Name 'Microsoft'", "Directorship where Company is directed by Person", "Person is identified by Person Name where Person is called Person Name 'Gates'", "Person Name 'Gates'"]}]
     ],
     [   # Same in a named population
-      "example: Company is directed by Person, Person is called PersonName, PersonName 'Gates', Company has CompanyName, CompanyName 'Microsoft';",
-      [{:facts=>["Company has CompanyName 'Microsoft'", "Company is directed by Person", "Person is called PersonName 'Gates'"], :instances=>["Company is identified by CompanyName where Company has CompanyName 'Microsoft'", "CompanyName 'Microsoft'", "Directorship where Company is directed by Person", "Person is identified by PersonName where Person is called PersonName 'Gates'", "PersonName 'Gates'"]}]
+      "example: Company is directed by Person, Person is called Person Name, Person Name 'Gates', Company has Company Name, Company Name 'Microsoft';",
+      [{:facts=>Set["Company has Company Name 'Microsoft'", "Company is directed by Person", "Person is called Person Name 'Gates'"], :instances=>Set["Company is identified by Company Name where Company has Company Name 'Microsoft'", "Company Name 'Microsoft'", "Directorship where Company is directed by Person", "Person is identified by Person Name where Person is called Person Name 'Gates'", "Person Name 'Gates'"]}]
+    ],
+
+    # Objectification examples
+    [   # Same in a named population
+      "Directorship (where Company 'Microsoft' is directed by Person 'Gates');",
+      :pending # [{:facts=>Set["Company has Company Name 'Microsoft'", "Company is directed by Person", "Person is called Person Name 'Gates'"], :instances=>Set["Company is identified by Company Name where Company has Company Name 'Microsoft'", "Company Name 'Microsoft'", "Directorship where Company is directed by Person", "Person is identified by Person Name where Person is called Person Name 'Gates'", "Person Name 'Gates'"]}]
+    ],
+  ]
+
+  BadSamples =
+  [
+    [
+      "Company Name",
+      "Company Name",
+    ],
+    [
+      "foo: Company Name",
+      "Company Name",
+    ],
+    [ # Omit the company name:
+      "example: Company is directed by Person, Person is called Person Name, Person Name 'Gates', Company has Company Name;",
+      [ "Company (lacking Company Name)", "Company Name (needs a value)" ]
     ],
   ]
 
@@ -104,7 +128,7 @@ describe "Sample data" do
       " is identified by " +
       identifying_role_refs.map do |rr|
         [ (l = rr.leading_adjective) ? l+"-" : nil,
-          rr.role_name || rr.role.concept.name,
+          rr.role.role_name || rr.role.concept.name,
           (t = rr.trailing_adjective) ? l+"-" : nil
         ].compact*""
       end * " and " +
@@ -123,17 +147,23 @@ describe "Sample data" do
     populations.keys.sort.map do |popname|
       popvalue = populations[popname]
       {
-        :instances => popvalue.all_instance.map { |i| instance_name(i) }.sort,
-        :facts => popvalue.all_fact.map { |fact| instance_name(fact) }.sort
+        :instances => Set[*popvalue.all_instance.map { |i| instance_name(i) }],
+        :facts => Set[*popvalue.all_fact.map { |fact| instance_name(fact) }]
       }
     end
   end
 
-  Samples.each do |c|
+  # [].
+  GoodSamples.
+  each do |c|
     source, expected = *Array(c)
+
     it "should handle #{source.inspect}" do
       @text = SamplePrefix+source
-      @vocabulary = ActiveFacts::Input::CQL.readstring(@text)
+      pending if expected == :pending
+      lambda do
+        @vocabulary = ActiveFacts::Input::CQL.readstring(@text)
+      end.should_not raise_error
       result = instance_data(@vocabulary)
 
       if expected
@@ -146,9 +176,36 @@ describe "Sample data" do
     it "should de-duplicate #{source.inspect}" do
       # Make sure you don't get anything duplicated
       @text = SamplePrefix+source+source
-      @vocabulary = ActiveFacts::Input::CQL.readstring(@text)
+      pending if expected == :pending
+      lambda do
+        @vocabulary = ActiveFacts::Input::CQL.readstring(@text)
+      end.should_not raise_error
       result = instance_data(@vocabulary)
       result[0].should == expected[0]
     end
+
   end
+
+  BadSamples.each do |c|
+    source, missing = *Array(c)
+    it "should detect missing joins in #{source.inspect}" do
+      @text = SamplePrefix+source
+      lambda do
+        begin
+          @vocabulary = ActiveFacts::Input::CQL.readstring(@text)
+        rescue => @exception
+          raise
+        end
+      end.should raise_error
+
+      if missing
+        missing.each do |m|
+          @exception.message.should =~ (m.is_a?(Regexp) ? m : Regexp.new(Regexp.escape(m)))
+        end
+      else
+        pending "raised #{@exception}"
+      end
+    end
+  end
+
 end

data/spec/cql/unit_spec.rb

@@ -3,13 +3,19 @@
 # Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
 #
 
+=begin
+REVISIT: These tests are important, but the intermediate layer they test no longer exists. Find another solution!
+
+require 'spec/helpers/test_parser'
 require 'activefacts/support'
 require 'activefacts/api/support'
 require 'activefacts/cql/parser'
+require File.dirname(__FILE__) + '/../helpers/test_parser'
 
 describe "Valid Numbers, Strings and Ranges" do
   ValidNumbersEtc = [
     "a is written as b;",                               # Value type declaration, no params, minimal whitespace
+    "a is written as B;",                               # Value type declaration, no params, minimal whitespace
     "a is written as b();",                             # Value type declaration, minimal whitespace
     "a is written as b ;",                              # Value type declaration, no params, trailing whitespace
     "a is written as b ( ) ; ",                         # Value type declaration, maximal whitespace
@@ -58,7 +64,7 @@ describe "Valid Numbers, Strings and Ranges" do
     "a is written as b inch^2/minute^-1;",              # Value type declaration with unit and divided unit with exponents
     "a is written as b() second^-1/mm^-1 mm^-1;",       # Value type declaration with repeated divided unit
 
-    # Integer value restrictions
+    # Integer value constraints
     "a is written as b()restricted to{1};",             # Integer, minimal whitespace
     "a is written as b() restricted to { 1 } ;",        # Integer, maximal whitespace
     "a is written as b() restricted to {1..2};",        # Integer range, minimal whitespace
@@ -76,7 +82,7 @@ describe "Valid Numbers, Strings and Ranges" do
     "a is written as b() restricted to { 1e-4 } ;",     # Integer with negative exponent
     "a is written as b() restricted to { -1e-4 } ;",    # Negative integer with negative exponent
 
-    # Real value restrictions
+    # Real value constraints
     "a is written as b() restricted to {1.0};",         # Real, minimal whitespace
     "a is written as b() restricted to { 1.0 } ;",      # Real, maximal whitespace
     "a is written as b() restricted to { 1.0e4 } ;",    # Real with exponent
@@ -91,7 +97,7 @@ describe "Valid Numbers, Strings and Ranges" do
     "a is written as b() restricted to { 1.1.. };",     # Real range with open end
     "a is written as b() restricted to { 1.1.., 2 };",  # Real range with open end and following integer
 
-    # Strings and string value restrictions
+    # Strings and string value constraints
     "a is written as b() restricted to {''};",          # String, empty, minimal whitespace
     "a is written as b() restricted to {'A'};",         # String, minimal whitespace
     "a is written as b() restricted to { 'A' };",       # String, maximal whitespace
@@ -107,13 +113,13 @@ describe "Valid Numbers, Strings and Ranges" do
     "a is written as b() restricted to { ..'F' };",     # String range, open start
     "a is written as b() restricted to { 'A'.. };",     # String range, open end
 
-    # Value restrictions with units
-    "a is written as b() restricted to {1} inches^2/second;",    # restriction with units and exponent
-    "a is written as b() second^-1/mm^-1 mm^-1 restricted to {1} inches^2/second;",    # type with unit and restriction with units and exponent
+    # Value constraints with units
+    "a is written as b() restricted to {1} inches^2/second;",    # constraint with units and exponent
+    "a is written as b() second^-1/mm^-1 mm^-1 restricted to {1} inches^2/second;",    # type with unit and constraint with units and exponent
   ]
 
   before :each do
-    @parser = ActiveFacts::CQL::Parser.new
+    @parser = TestParser.new
   end
 
   ValidNumbersEtc.each do |c|
@@ -150,7 +156,7 @@ describe "Invalid Numbers and Strings" do
   ]
 
   before :each do
-    @parser = ActiveFacts::CQL::Parser.new
+    @parser = TestParser.new
   end
 
   InvalidValueTypes.each do |c|
@@ -175,7 +181,7 @@ describe "Value Types" do
   ]
 
   before :each do
-    @parser = ActiveFacts::CQL::Parser.new
+    @parser = TestParser.new
   end
 
   ValueTypes.each do |c|
@@ -195,49 +201,49 @@ end
 describe "Entity Types" do
   EntityTypes_RefMode = [
     [ "a is identified by its id;",                     # Entity type declaration with reference mode
-      [["a", [:entity_type, [], {:enforcement=>nil, :mode=>"id", :parameters=>[], :restriction=>nil}, [], nil]]] 
+      [["a", [:entity_type, [], {:enforcement=>nil, :mode=>"id", :parameters=>[], :value_constraint=>nil}, [], nil]]] 
     ],
     [ "a is identified by its number(12);",                     # Entity type declaration with reference mode
-      [["a", [:entity_type, [], {:enforcement=>nil, :mode=>"number", :parameters=>[12], :restriction=>nil}, [], nil]]]
+      [["a", [:entity_type, [], {:enforcement=>nil, :mode=>"number", :parameters=>[12], :value_constraint=>nil}, [], nil]]]
     ],
     [ "a is identified by its id:c;",                   # Entity type declaration with reference mode and fact type(s)
-      [["a", [:entity_type, [], {:enforcement=>nil, :mode=>"id", :parameters=>[], :restriction=>nil}, [], [[:fact_clause, [], [{:word=>"c"}], nil]]]]]
+      [["a", [:entity_type, [], {:enforcement=>nil, :mode=>"id", :parameters=>[], :value_constraint=>nil}, [], [[:fact_clause, [], ["c"], nil]]]]]
     ],
     [ "a is identified by its id where c;",             # Entity type declaration with reference mode and where
-      [["a", [:entity_type, [], {:enforcement=>nil, :mode=>"id", :parameters=>[], :restriction=>nil}, [], [[:fact_clause, [], [{:word=>"c"}], nil]]]]]
+      [["a", [:entity_type, [], {:enforcement=>nil, :mode=>"id", :parameters=>[], :value_constraint=>nil}, [], [[:fact_clause, [], ["c"], nil]]]]]
     ],
   ]
 
   EntityTypes_Simple = [
     [ "a is identified by b: c;",                       # Entity type declaration
-      [["a", [:entity_type, [], {:roles=>[["b"]]}, [], [[:fact_clause, [], [{:word=>"c"}], nil]]]]]
+      [["a", [:entity_type, [], {:roles=>[["b"]]}, [], [[:fact_clause, [], ["c"], nil]]]]]
     ],
     [ "a is identified by b where c;",                  # Entity type declaration with where
-      [["a", [:entity_type, [], {:roles=>[["b"]]}, [], [[:fact_clause, [], [{:word=>"c"}], nil]]]]]
+      [["a", [:entity_type, [], {:roles=>[["b"]]}, [], [[:fact_clause, [], ["c"], nil]]]]]
     ],
     [ "a is identified by b and c: d;",                 # Entity type declaration with two-part identifier
-      [["a", [:entity_type, [], {:roles=>[["b"], ["c"]]}, [], [[:fact_clause, [], [{:word=>"d"}], nil]]]]]
+      [["a", [:entity_type, [], {:roles=>[["b"], ["c"]]}, [], [[:fact_clause, [], ["d"], nil]]]]]
     ],
     [ "a is identified by b, c: d;",                    # Entity type declaration with two-part identifier
-      [["a", [:entity_type, [], {:roles=>[["b"], ["c"]]}, [], [[:fact_clause, [], [{:word=>"d"}], nil]]]]]
+      [["a", [:entity_type, [], {:roles=>[["b"], ["c"]]}, [], [[:fact_clause, [], ["d"], nil]]]]]
     ],
     [ "a is written as b(); c is identified by a:d;",
-      [["a", [:value_type, "b", [], [], [], [], nil]], ["c", [:entity_type, [], {:roles=>[["a"]]}, [], [[:fact_clause, [], [{:word=>"d"}], nil]]]]]
+      [["a", [:value_type, "b", [], [], [], [], nil]], ["c", [:entity_type, [], {:roles=>[["a"]]}, [], [[:fact_clause, [], ["d"], nil]]]]]
     ],
     [ " a is written as b ( ) ; c is identified by a : d ; ",
-      [["a", [:value_type, "b", [], [], [], [], nil]], ["c", [:entity_type, [], {:roles=>[["a"]]}, [], [[:fact_clause, [], [{:word=>"d"}], nil]]]]]
+      [["a", [:value_type, "b", [], [], [], [], nil]], ["c", [:entity_type, [], {:roles=>[["a"]]}, [], [[:fact_clause, [], ["d"], nil]]]]]
     ],
     [ "a is identified by c:maybe d;",
-      [["a", [:entity_type, [], {:roles=>[["c"]]}, [], [[:fact_clause, ["maybe"], [{:word=>"d"}], nil]]]]]
+      [["a", [:entity_type, [], {:roles=>[["c"]]}, [], [[:fact_clause, ["maybe"], ["d"], nil]]]]]
     ],
   ]
 
   EntityTypes_Objectified = [
     [ "Director is where Person directs Company, Company is directed by Person;",
-      [["Director", [:fact_type, [[:fact_clause, [], [{:word=>"Person"}, {:word=>"directs"}, {:word=>"Company"}], nil], [:fact_clause, [], [{:word=>"Company"}, {:word=>"is"}, {:word=>"directed"}, {:word=>"by"}, {:word=>"Person"}], nil]], []]]]
+      [["Director", [:fact_type, [[:fact_clause, [], [{:word=>"Person", :term=>"Person"}, "directs", {:word=>"Company", :term=>"Company"}], nil], [:fact_clause, [], [{:word=>"Company", :term=>"Company"}, "is", "directed", "by", {:word=>"Person", :term=>"Person"}], nil]], []]]]
     ],
     [ "Director: Person directs company;",
-      [[nil, [:fact_type, [[:fact_clause, [], [{:word=>"Director"}], nil]], [[:fact_clause, [], [{:word=>"Person"}, {:word=>"directs"}, {:word=>"company"}], nil]]]]]
+      [[nil, [:fact_type, [[:fact_clause, [], [{:word=>"Director", :term=>"Director"}], nil]], [[:fact_clause, [], [{:word=>"Person", :term=>"Person"}, "directs", "company"], nil]]]]]
     ],
   ]
 
@@ -269,7 +275,7 @@ describe "Entity Types" do
     EntityTypes_Subtypes
 
   before :each do
-    @parser = ActiveFacts::CQL::Parser.new
+    @parser = TestParser.new
   end
 
   EntityTypes.each do |c|
@@ -291,31 +297,43 @@ end
 
 describe "Fact Types" do
   FactTypes = [
-    [ "Director is old: Person directs company, Person is of age, age > 60;",
-      [nil, [:fact_type, [[:fact_clause, [], [{:word=>"Director"}, {:word=>"is"}, {:word=>"old"}], nil]], [[:fact_clause, [], [{:word=>"Person"}, {:word=>"directs"}, {:word=>"company"}], nil], [:fact_clause, [], [{:word=>"Person"}, {:word=>"is"}, {:word=>"of"}, {:word=>"age"}], nil], [">", [:variable, "age"], 60]]]]
+    [ "Foo has at most one Bar, Bar is of one Foo restricted to {1..10};",
+      [nil, [:fact_type, [[:fact_clause, [], [{:word=>"Foo", :term=>"Foo"}, "has", {:quantifier_restriction=>[], :word=>"Bar", :term=>"Bar", :quantifier=>[nil, 1]}], nil], [:fact_clause, [], [{:word=>"Bar", :term=>"Bar"}, "is", "of", {:value_constraint=>[[1, 10]], :quantifier_restriction=>[], :word=>"Foo", :term=>"Foo", :quantifier=>[1, 1], :value_constraint_enforcement=>[]}], nil]], []]]
+    ],
+    [ "Bar(1) is related to Bar(2), primary-Bar(1) has secondary-Bar(2);",
+      [nil, [:fact_type, [[:fact_clause, [], [{:word=>"Bar", :term=>"Bar", :role_name=>1}, "is", "related", "to", {:word=>"Bar", :term=>"Bar", :role_name=>2}], nil], [:fact_clause, [], [{:leading_adjective=>"primary", :word=>"primary Bar", :term=>"Bar", :role_name=>1}, "has", {:leading_adjective=>"secondary", :word=>"secondary Bar", :term=>"Bar", :role_name=>2}], nil]], []]]
+    ],
+    [ "Director is old: Person directs company, Person is of Age, Age > 60;",
+      [nil, [:fact_type, [[:fact_clause, [], [{:word=>"Director", :term=>"Director"}, "is", "old"], nil]], [[:fact_clause, [], [{:word=>"Person", :term=>"Person"}, "directs", "company"], nil], [:fact_clause, [], [{:word=>"Person", :term=>"Person"}, "is", "of", {:word=>"Age", :term=>"Age"}], nil], [">", [:variable, "Age"], 60]]]]
     ],
-    [ "a: maybe a has completely- green b -totally [transitive, acyclic], b -c = 2;",
-      [nil, [:fact_type, [[:fact_clause, [], [{:word=>"a"}], nil]], [[:fact_clause, ["maybe", "transitive", "acyclic"], [{:word=>"a"}, {:word=>"has"}, {:leading_adjective=>"completely", :word=>"green"}, {:trailing_adjective=>"totally", :word=>"b"}], nil], ["=", [:+, [:variable, "b"], [:-, [:variable, "c"]]], 2]]]]
+    [ "A is a farce: maybe A has completely- B [transitive, acyclic], B -c = 2;",
+      [nil, [:fact_type, [[:fact_clause, [], [{:word=>"A", :term=>"A"}, "is", "a", "farce"], nil]], [[:fact_clause, ["maybe", "transitive", "acyclic"], [{:word=>"A", :term=>"A"}, "has", {:leading_adjective=>"completely", :word=>"completely B", :term=>"B"}], nil], ["=", [:variable, "B c"], 2]]]]
+    ],
+    [ "A is a farce: maybe A has completely- green B [transitive, acyclic], B -c = 2;",
+      [nil, [:fact_type, [[:fact_clause, [], [{:word=>"A", :term=>"A"}, "is", "a", "farce"], nil]], [[:fact_clause, ["maybe", "transitive", "acyclic"], [{:word=>"A", :term=>"A"}, "has", {:leading_adjective=>"completely green", :word=>"completely green B", :term=>"B"}], nil], ["=", [:variable, "B c"], 2]]]]
+    ],
+    [ "A is a farce: maybe A has B green -totally [transitive, acyclic], B -c = 2;",
+      [nil, [:fact_type, [[:fact_clause, [], [{:word=>"A", :term=>"A"}, "is", "a", "farce"], nil]], [[:fact_clause, ["maybe", "transitive", "acyclic"], [{:word=>"A", :term=>"A"}, "has", {:trailing_adjective=>"green totally", :word=>"B green totally", :term=>"B"}], nil], ["=", [:variable, "B c"], 2]]]]
     ],
     [ "Person is independent: Person has taxable- Income, taxable Income >= 20000 dollars;",
-      [nil, [:fact_type, [[:fact_clause, [], [{:word=>"Person"}, {:word=>"is"}, {:word=>"independent"}], nil]], [[:fact_clause, [], [{:word=>"Person"}, {:word=>"has"}, {:leading_adjective=>"taxable", :word=>"Income"}], nil], [">=", [:variable, "taxable", "Income"], [20000, "dollars"]]]]]
+      [nil, [:fact_type, [[:fact_clause, [], [{:word=>"Person", :term=>"Person"}, "is", "independent"], nil]], [[:fact_clause, [], [{:word=>"Person", :term=>"Person"}, "has", {:leading_adjective=>"taxable", :word=>"taxable Income", :term=>"Income"}], nil], [">=", [:variable, "taxable Income"], [20000, "dollars"]]]]]
     ],
-    [ "Window requires toughening: Window has width-mm, Window has height-mm, width mm * height mm >= 10 foot^2;",
-      [nil, [:fact_type, [[:fact_clause, [], [{:word=>"Window"}, {:word=>"requires"}, {:word=>"toughening"}], nil]], [[:fact_clause, [], [{:word=>"Window"}, {:word=>"has"}, {:leading_adjective=>"width", :word=>"mm"}], nil], [:fact_clause, [], [{:word=>"Window"}, {:word=>"has"}, {:leading_adjective=>"height", :word=>"mm"}], nil], [">=", [:*, [:variable, "width", "mm"], [:variable, "height", "mm"]], [10, "foot^2"]]]]]
+    [ "Window requires toughening: Window has Width -mm, Window has Height -mm, Width mm * Height mm >= 10 foot^2;",
+      [nil, [:fact_type, [[:fact_clause, [], [{:word=>"Window", :term=>"Window"}, "requires", "toughening"], nil]], [[:fact_clause, [], [{:word=>"Window", :term=>"Window"}, "has", {:trailing_adjective=>"mm", :word=>"Width mm", :term=>"Width"}], nil], [:fact_clause, [], [{:word=>"Window", :term=>"Window"}, "has", {:trailing_adjective=>"mm", :word=>"Height mm", :term=>"Height"}], nil], [">=", [:*, [:variable, "Width mm"], [:variable, "Height mm"]], [10, "foot^2"]]]]]
     ],
     # REVISIT: Test all quantifiers
     # REVISIT: Test all post-qualifiers
     # REVISIT: Test functions
-    [ "AnnualIncome is where Person has total- Income in Year: Person has total- Income.sum(), Income was earned in current- time.Year() (as Year);",
-      ["AnnualIncome", [:fact_type, [[:fact_clause, [], [{:word=>"Person"}, {:word=>"has"}, {:leading_adjective=>"total", :word=>"Income"}, {:word=>"in"}, {:word=>"Year"}], nil]], [[:fact_clause, [], [{:word=>"Person"}, {:word=>"has"}, {:leading_adjective=>"total", :function=>[:"(", "sum"], :word=>"Income"}], nil], [:fact_clause, [], [{:word=>"Income"}, {:word=>"was"}, {:word=>"earned"}, {:word=>"in"}, {:role_name=>"Year", :leading_adjective=>"current", :function=>[:"(", "Year"], :word=>"time"}], nil]]]]
+    [ "AnnualIncome is where Person has total- Income in Year: Person has total- Income.sum(), Income was earned in current- Time.Year() (as Year);",
+      ["AnnualIncome", [:fact_type, [[:fact_clause, [], [{:word=>"Person", :term=>"Person"}, "has", {:leading_adjective=>"total", :word=>"total Income", :term=>"Income"}, "in", {:word=>"Year", :term=>"Year"}], nil]], [[:fact_clause, [], [{:word=>"Person", :term=>"Person"}, "has", {:leading_adjective=>"total", :function=>[:"(", "sum"], :word=>"total Income", :term=>"Income"}], nil], [:fact_clause, [], [{:word=>"Income", :term=>"Income"}, "was", "earned", "in", {:leading_adjective=>"current", :function=>[:"(", "Year"], :role_name=>"Year", :word=>"current Time", :term=>"Time"}], nil]]]]
     ],
-    [ "a is interesting : b- c -d has e- f -g;",
-      [nil, [:fact_type, [[:fact_clause, [], [{:word=>"a"}, {:word=>"is"}, {:word=>"interesting"}], nil]], [[:fact_clause, [], [{:leading_adjective=>"b", :trailing_adjective=>"d", :word=>"c"}, {:word=>"has"}, {:leading_adjective=>"e", :trailing_adjective=>"g", :word=>"f"}], nil]]]]
+    [ "A is interesting : b- C has F -g;",
+      [nil, [:fact_type, [[:fact_clause, [], [{:word=>"A", :term=>"A"}, "is", "interesting"], nil]], [[:fact_clause, [], [{:leading_adjective=>"b", :word=>"b C", :term=>"C"}, "has", {:trailing_adjective=>"g", :word=>"F g", :term=>"F"}], nil]]]]
     ]
   ]
 
   before :each do
-    @parser = ActiveFacts::CQL::Parser.new
+    @parser = TestParser.new
   end
 
   FactTypes.each do |c|
@@ -338,15 +356,17 @@ describe "Fact Types" do
       puts result.map{|d| d.value}.inspect unless ast
     end
   end
+end
 
+describe "Constraint" do
   Constraints = [
     [ "each combination FamilyName, GivenName occurs at most one time in Competitor has FamilyName, Competitor has GivenName;",
-      [nil, [:constraint, :presence, [["FamilyName"], ["GivenName"]], [nil, 1], [[[{:word=>"Competitor"}, {:word=>"has"}, {:word=>"FamilyName"}]], [[{:word=>"Competitor"}, {:word=>"has"}, {:word=>"GivenName"}]]], nil, []]]
+      [nil, [:constraint, :presence, [["FamilyName"], ["GivenName"]], [nil, 1], [[[{:word=>"Competitor", :term=>"Competitor"}, "has", {:word=>"FamilyName", :term=>"FamilyName"}]], [[{:word=>"Competitor", :term=>"Competitor"}, "has", {:word=>"GivenName", :term=>"GivenName"}]]], nil, []]]
     ],
   ]
 
   before :each do
-    @parser = ActiveFacts::CQL::Parser.new
+    @parser = TestParser.new
   end
 
   Constraints.each do |c|
@@ -371,3 +391,4 @@ describe "Fact Types" do
     end
   end
 end
+=end

data/spec/cql_cql_spec.rb

@@ -10,18 +10,17 @@ require 'activefacts/support'
 require 'activefacts/input/cql'
 require 'activefacts/generate/cql'
 
-include ActiveFacts
-
 describe "CQL Loader" do
   cql_failures = {
     "Airline" => "Contains queries, unsupported",
     "CompanyQuery" => "Contains queries, unsupported",
-    "MetamodelNext" => "Fails due to weak adjective/role matching",
-    "OrienteeringER" => "Doesn't parse due to difficult fact type match",
-    "ServiceDirector" => "Doesn't parse some constraints due to mis-matched adjectives"
+    #"MetamodelNext" => "Fails due to weak adjective/role matching",
+    #"ServiceDirector" => "Doesn't parse some constraints due to mis-matched adjectives",
+    #"OddIdentifier" => "The odd identifier is built correctly but cannot be found by the current implementation",
+    "units" => "Unit verbalisation into CQL is not implemented"
   }
   cql_cql_failures = {
-    "Insurance" => "Misses a subtype join in a constraint verbalisation",
+#    "Insurance" => "Misses a join in a subset constraint",
 #    "OddIdentifier" => "Doesn't support identification of object fact types using mixed external/internal roles",
   }
   # Generate and return the CQL for the given vocabulary
@@ -45,7 +44,13 @@ describe "CQL Loader" do
           vocabulary = ActiveFacts::Input::CQL.readfile(cql_file)
         }
       else
-        vocabulary = ActiveFacts::Input::CQL.readfile(cql_file)
+        begin
+          vocabulary = ActiveFacts::Input::CQL.readfile(cql_file)
+        rescue => e
+          debug :exception, "#{e.message}\n" +
+            "\t#{e.backtrace*"\n\t"}"
+          raise
+        end
       end
 
       # Build and save the actual file: