activefacts 0.8.6 → 0.8.8

data/spec/absorption_spec.rb

@@ -59,11 +59,11 @@ describe "Absorption" do
         Lodgement is where
           Claim was lodged by at most one Person;
         Lodgement was made at at most one DateTime;
-        Person has exactly one birth-Date;
+        Person has exactly one birth-DateTime;
       },
       :tables => {
         "Claim" => [%w{Claim ID}, %w{Lodgement Date Time}, %w{Lodgement Person ID}],
-        "Party" => [%w{Party ID}, %w{Person Birth Date}]
+        "Party" => [%w{Party ID}, %w{Person Birth Date Time}]
       }
     },
 
@@ -74,8 +74,8 @@ describe "Absorption" do
     cql = test[:cql]
     expected_tables = test[:tables]
     it "should #{should}" do
-      @compiler = ActiveFacts::CQL::Compiler.new(cql, should)
-      @vocabulary = @compiler.vocabulary
+      @compiler = ActiveFacts::CQL::Compiler.new(should)
+      @vocabulary = @compiler.compile(cql)
 
       # puts cql
 

data/spec/api/value_type.rb

@@ -100,7 +100,7 @@ describe "Value Type class definitions" do
       }
   end
 
-  # REVISIT: role value restrictions
+  # REVISIT: role value constraints
 
   it "should fail on a non-ValueClass" do
     lambda{

data/spec/cql/context_spec.rb

@@ -5,67 +5,90 @@
 
 require 'activefacts/support'
 require 'activefacts/api/support'
-require 'activefacts/cql/parser'
+require 'activefacts/cql/compiler'
 
 describe "Business Context Notes" do
   # (according_to people ',')? (because / as_opposed_to / so_that / to_avoid) discussion (',' as_agreed_by)? s
-  Prefix = %q{
+  ContextNotePrefix = %q{
+    vocabulary Test;
     Person is written as Person;
+    Person is employed;
+    Person is unemployed;
+    Person is a bad credit risk;
+    Person is good credit risk;
+    Bar is written as Bar;
+    Baz is written as Baz;
   }
   Notes = [
     # Constraints:
     [ 'each Person occurs one time in Person is employed, Person is unemployed (because it can be no other way!);',
-      [["Person", [:value_type, "Person", [], [], [], [], nil]], [nil, [:constraint, :presence, [["Person"]], [1, 1], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"unemployed"}]]], [nil, "because", "it can be no other way!", []], []]]]
+      1, 'because'
     ],
     [ 'each Person occurs one time in Person is employed, Person is unemployed (as opposed to blah!);',
-      [["Person", [:value_type, "Person", [], [], [], [], nil]], [nil, [:constraint, :presence, [["Person"]], [1, 1], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"unemployed"}]]], [nil, "as_opposed_to", " blah!", []], []]]]
+      1, 'as_opposed_to'
     ],
     [ 'for each Person at least one of these holds: Person is employed, Person is a bad credit risk (so that blah);',
-      [["Person", [:value_type, "Person", [], [], [], [], nil]], [nil, [:constraint, :set, [["Person"]], [1, nil], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"a"}, {:word=>"bad"}, {:word=>"credit"}, {:word=>"risk"}]]], [nil, "so_that", " blah", []], []]]]
+      1, 'so_that'
     ],
     [ 'Person is good credit risk only if Person is employed (to avoid lending to people who can\'t repay);',
-      [["Person", [:value_type, "Person", [], [], [], [], nil]], [nil, [:constraint, :subset, [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"good"}, {:word=>"credit"}, {:word=>"risk"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]]], [nil, "to_avoid", " lending to people who can't repay", []], []]]]
+      1, 'to_avoid'
     ],
     [ 'Person is good credit risk if and only if Person is employed (to avoid lending to people who can\'t repay);',
-      [["Person", [:value_type, "Person", [], [], [], [], nil]], [nil, [:constraint, :equality, [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"good"}, {:word=>"credit"}, {:word=>"risk"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]]], [nil, "to_avoid", " lending to people who can't repay", []], []]]]
+      1, 'to_avoid'
     ],
+    [ 'Person is good credit risk if and only if Person is employed (to avoid lending to people who can\'t repay, as agreed by Jim);',
+      1, 'to_avoid', nil, ['Jim']
+    ],
+    # Entity and Fact types
     # Entity and Fact types
     [ 'Foo is identified by Bar [independent] where Foo has one Bar (so that we have an id);',
-      [["Person", [:value_type, "Person", [], [], [], [], nil]], ["Foo", [:entity_type, [], {:roles=>[["Bar"]]}, ["independent"], [[:fact_clause, [], [{:word=>"Foo"}, {:word=>"has"}, {:quantifier=>[1, 1], :quantifier_restriction=>[], :word=>"Bar"}], [nil, "so_that", " we have an id", []]]]]]]
+      1, 'so_that'
     ],
-    [ 'Foo has one Bar (so that we have an id), Bar is of one Foo (because we need that);',
-      [["Person", [:value_type, "Person", [], [], [], [], nil]], [nil, [:fact_type, [[:fact_clause, [], [{:word=>"Foo"}, {:word=>"has"}, {:quantifier=>[1, 1], :quantifier_restriction=>[], :word=>"Bar"}], [nil, "so_that", " we have an id", []]], [:fact_clause, [], [{:word=>"Bar"}, {:word=>"is"}, {:word=>"of"}, {:quantifier=>[1, 1], :quantifier_restriction=>[], :word=>"Foo"}], [nil, "because", "we need that", []]]], []]]]
+    [ 'Baz has one Bar (so that we have an id), Bar is of one Baz (because we need that);',
+      2
     ],
     # REVISIT: No context notes on quantifiers yet
     # As agreed by:
     [ 'for each Person at least one of these holds: Person is employed, Person is a bad credit risk (so that blah, as agreed by Jim);',
-      [["Person", [:value_type, "Person", [], [], [], [], nil]], [nil, [:constraint, :set, [["Person"]], [1, nil], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"a"}, {:word=>"bad"}, {:word=>"credit"}, {:word=>"risk"}]]], [nil, "so_that", " blah", [nil, ["Jim"]]], []]]] 
+      1, 'so_that', nil, ['Jim']
     ],
     # REVISIT: Populate an "as agreed by" with a date
-    [ 'for each Person at least one of these holds: Person is employed, Person is a bad credit risk (so that blah, as agreed on 29 March by Jim);',
-      [["Person", [:value_type, "Person", [], [], [], [], nil]], [nil, [:constraint, :set, [["Person"]], [1, nil], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"a"}, {:word=>"bad"}, {:word=>"credit"}, {:word=>"risk"}]]], [nil, "so_that", " blah", ["29 March", ["Jim"]]], []]]]
+    [ 'for each Person at least one of these holds: Person is employed, Person is a bad credit risk (so that blah, as agreed on 10-04-10 by Jim);',
+      1, 'so_that', nil, ['Jim'], '10-04-10'
     ],
     # According to:
     [ 'for each Person at least one of these holds: Person is employed, Person is a bad credit risk (according to jim, so that blah);',
-      [["Person", [:value_type, "Person", [], [], [], [], nil]], [nil, [:constraint, :set, [["Person"]], [1, nil], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"a"}, {:word=>"bad"}, {:word=>"credit"}, {:word=>"risk"}]]], [["jim"], "so_that", " blah", []], []]]]
+      1, 'so_that', ['jim']
     ],
   ]
 
   before :each do
-    @parser = ActiveFacts::CQL::Parser.new
+    @compiler = ActiveFacts::CQL::Compiler.new('Test')
   end
 
   Notes.each do |c|
-    source, ast = *c
+    source, count, kind, according_to, agreed_by, agreed_date = *c
     it "should parse #{source.inspect}" do
-      #debugger
-      result = @parser.parse_all(Prefix+source, :definition)
 
-      puts @parser.failure_reason unless result
+      result =
+        begin
+          @compiler.compile(ContextNotePrefix+source)
+        rescue => e
+          puts "#{e}:\n\t#{e.backtrace*"\n\t"}"
+        end
+      puts @compiler.failure_reason unless result
       result.should_not be_nil
-      result.map{|d| d.value}.should == ast if ast
-      # Uncomment this to see what should replace "nil" in the cases above:
-      #puts result.map{|d| d.value}.inspect unless ast
+      constellation = @compiler.vocabulary.constellation
+
+      # constellation.ContextNote.each{|k,cn| puts "#{k.inspect} => #{cn.inspect}" }
+      constellation.ContextNote.size.should == (count || 1)
+      context_note = constellation.ContextNote.values[0]
+      context_note.context_note_kind.should == kind if kind
+      context_note.all_context_according_to.map{|cat| cat.agent.agent_name }.sort.should == according_to if according_to
+      # context_note.discussion.should == discussion if discussion
+      context_note.agreement.should_not be_nil if agreed_by || agreed_date
+      context_note.agreement.all_context_agreed_by.map{|cab| cab.agent.agent_name}.sort.should == agreed_by if agreed_by
+      context_note.agreement.date.should == Date.parse(agreed_date) if agreed_date
     end
   end
 end

data/spec/cql/deontic_spec.rb

@@ -0,0 +1,88 @@
+#
+# ActiveFacts CQL Deontic Constraints tests
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+
+require 'activefacts/support'
+require 'activefacts/api/support'
+require 'activefacts/cql/compiler'
+
+describe "Deontic Constraints" do
+  DeonticPrefix = %q{
+    vocabulary Test;
+    Person is written as Person;
+    Person is employed;
+    Person is unemployed;
+    Person has borrowed cash;
+    Person is a bad credit risk;
+    Nr is written as Nr;
+    Person is good credit risk;
+    Bar is written as Bar;
+    Baz is written as Baz;
+  }
+  Cases = [
+    # Constraints:
+    [ 'each Person occurs one time (otherwise alert fraud dept) in Person is employed, Person is unemployed;',
+      'alert', 'fraud dept'
+    ],
+    [ 'for each Person at most one of these holds ( otherwise email auditors ) : Person has borrowed cash, Person is a bad credit risk;',
+      'email', 'auditors'
+    ],
+    [ 'either Person has borrowed cash or Person is a bad credit risk ( otherwise email auditors );',
+      'email', 'auditors'
+    ],
+    [ 'either Person has borrowed cash or Person is a bad credit risk but not both ( otherwise email auditors );',
+      'email', 'auditors'
+    ],
+    [ 'Person is good credit risk only if Person is employed (otherwise consider foreclosure);',
+      'consider', 'foreclosure'
+    ],
+    [ 'Person is good credit risk if and only if Person is employed (otherwise log event);',
+      'log', 'event'
+    ],
+    [ 'Foo is written as Nr restricted to {1..10} (otherwise log);',
+      'log', ''
+    ],
+    [ 'Foo is identified by its Nr restricted to {1..10} (otherwise log);',
+      'log', ''
+    ],
+    [ 'Baz has at most one (otherwise notify security) Bar, Bar is of one Baz restricted to {1..10};',
+      'notify', 'security'
+    ],
+    [ 'Baz has at most one Bar, Bar is of one Baz restricted to {1..10} (otherwise log exception);',
+      'log', 'exception'
+    ],
+  ]
+
+  before :each do
+    @compiler = ActiveFacts::CQL::Compiler.new('Test')
+  end
+
+  Cases.each do |c|
+    source, action, agent = *c
+    it "should parse #{source.inspect}" do
+      result = @compiler.compile(DeonticPrefix+source)
+      puts @compiler.failure_reason unless result
+      result.should_not be_nil
+      constellation = @compiler.vocabulary.constellation
+
+      enforcements = 
+        constellation.Constraint.values.map do |c|
+          c.enforcement
+        end.compact
+      enforcements.size.should == 1
+      enforcements[0].enforcement_code.should == action if action 
+      if agent
+        if agent != ''
+          enforcements[0].agent.agent_name.should == agent
+        else
+          enforcements[0].agent.should be_nil
+        end
+      end
+
+      #result.map{|d| d.value}.should == ast if ast
+      # Uncomment this to see what should replace "nil" in the cases above:
+      #puts result.map{|d| d.value}.inspect unless ast
+    end
+  end
+end

data/spec/cql/matching_spec.rb

@@ -0,0 +1,517 @@
+#
+# ActiveFacts CQL Fact Type matching tests
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+
+require 'activefacts/support'
+require 'activefacts/api/support'
+require 'activefacts/cql/compiler'
+# require File.dirname(__FILE__) + '/../helpers/compiler_helper'  # Can't see how to include/extend these methods correctly
+
+describe "Fact Type Role Matching" do
+  MatchingPrefix = %q{
+    vocabulary Tests;
+    Boy is written as String;
+    Girl is written as String;
+  }
+  BaseConcepts = 3  # String, Boy, Girl
+
+  def self.SingleFact &b
+    lambda {|c|
+      real_fact_types = c.FactType.values-c.ImplicitFactType.values
+      real_fact_types.size.should == 1
+      @fact_type = real_fact_types[0]
+      b.call(@fact_type) if b
+      @fact_type
+    }
+  end
+
+  def self.FactHavingPlayers(*a, &b)
+    lambda {|c|
+      @fact_type = c.FactType.detect do |key, ft|
+        ft.all_role.map{|r| r.concept.name}.sort == a.sort
+      end
+      b.call(@fact_type) if b
+      @fact_type
+    }
+  end
+
+  def self.PresenceConstraints fact_type, &b
+    @presence_constraints =
+      fact_type.all_role.map{|r|
+        r.all_role_ref.map{|rr|
+          rr.role_sequence.all_presence_constraint.to_a
+        }
+      }.flatten.uniq
+    b.call(@presence_constraints) if b
+    @presence_constraints
+  end
+
+  def self.Readings fact_type, &b
+    @readings = fact_type.all_reading.sort_by{|r| r.ordinal}
+    b.call(@readings) if b
+    @readings
+  end
+
+  def self.ReadingCount n
+    lambda {|c|
+      unless @fact_type.all_reading.size == n
+        puts "SPEC FAILED, wrong number of readings (should be #{n}):\n\t#{
+          @fact_type.all_reading.map{ |r| r.expand}*"\n\t"
+        }"
+      end
+      @fact_type.all_reading.size.should == n
+    }
+  end
+
+  def self.PresenceConstraintCount n
+    lambda{ |c|
+      @fact_type.all_role.map{|r|
+        r.all_role_ref.map{|rr|
+          rr.role_sequence.all_presence_constraint.to_a
+        }
+      }.flatten.uniq.size.should == n
+    }
+  end
+
+  def self.ConceptCount n
+    lambda {|c|
+      @constellation = c
+      c.Concept.values.size.should == n
+    }
+  end
+
+  def self.Concept name, &b
+    lambda {|c|
+      @concept = c.Concept[[["Tests"], name]]
+      @concept.should_not == nil
+      b.call(@concept) if b
+      @concept
+    }
+  end
+
+  def self.WrittenAs name
+    lambda {|c|
+      @base_type = c.Concept[[["Tests"], name]]
+      @base_type.class.should == ActiveFacts::Metamodel::ValueType
+      @concept.class.should == ActiveFacts::Metamodel::ValueType
+      @concept.supertype.should == @base_type
+    }
+  end
+
+  def self.PreferredIdentifier num_roles
+    lambda {|c|
+      @preferred_identifier = @concept.preferred_identifier
+      @preferred_identifier.should_not == nil
+      @preferred_identifier.role_sequence.all_role_ref.size.should == num_roles
+      #@preferred_identifier.min_frequency.should == 1
+      @preferred_identifier.max_frequency.should == 1
+      @preferred_identifier.is_preferred_identifier.should == true
+    }
+  end
+
+  def self.PreferredIdentifierRolePlayedBy name, num = 0
+    lambda {|c|
+      @preferred_identifier.role_sequence.all_role_ref.sort_by{|rr| rr.ordinal}[num].role.concept.name.should == name
+    }
+  end
+
+  class BlackHole
+    def method_missing(m,*a,&b)
+      self
+    end
+  end
+  class PendingSilencer
+    def STDOUT; BlackHole.new; end
+    def puts; BlackHole.new; end
+    def p; BlackHole.new; end
+  end
+
+  def self.pending(msg = "TODO", &b)
+    lambda {|*c|
+      raised = nil
+      begin
+        example = b.call
+        eval(lambda { example.call(*c) }, BlackHole.new)
+      rescue => raised
+      end
+      raise Spec::Example::PendingExampleFixedError.new(msg) unless raised
+      raise Spec::Example::ExamplePendingError.new(msg)
+    }
+  end
+
+  def self.ReadingContainsHyphenatedWord reading_num
+    lambda {|c|
+      hyphenated_reading =
+        c.FactType.values[0].all_reading.select {|reading|
+          reading.ordinal == reading_num
+        }[0]
+      hyphenated_reading.should_not == nil
+      (hyphenated_reading.text =~ /[a-z]-[a-z]/).should_not == nil
+    }
+  end
+
+  SimpleBinaryFactTypeTests = [
+    [ # Simple create
+      %q{Girl is going out with at most one Boy; },
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 1
+        PresenceConstraints(fact_type) do |pcs|
+          pcs.size.should == 1
+        end
+      end
+    ],
+    [ # Create with explicit adjective
+      %q{Girl is going out with at most one ugly-Boy;},
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 1
+        PresenceConstraints(fact_type).size.should == 1
+      end
+    ],
+    [ # Simple match
+      %q{Girl is going out with at most one Boy; },
+      %q{
+        Girl is going out with Boy,
+          Boy is going out with Girl;
+      },
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 2
+        PresenceConstraints(fact_type).size.should == 1
+      end
+    ],
+    [ # Simple match with repetition
+      %q{Girl is going out with at most one Boy; },
+      %q{
+        Girl is going out with Boy,
+          Girl is going out with Boy,
+          Boy is going out with Girl,
+          Boy is going out with Girl;
+      },
+      SingleFact() do |fact_type|
+        PresenceConstraints(fact_type).size.should == 1
+        pending("duplicate new clauses are not eliminated") do
+          Readings(fact_type).size.should == 2
+        end.call      # Must call the pending block
+      end,
+#      pending("duplicate new clauses are not eliminated") do
+#        @readings.size.should == 2
+#      end
+    ],
+    [ # Simple match with a new presence Constraint
+      %q{Girl is going out with at most one Boy; },
+      %q{
+        Girl is going out with Boy,
+          Boy is going out with at most one Girl;
+      },
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 2
+        PresenceConstraints(fact_type).size.should == 2
+      end
+    ],
+    [ # RoleName matching
+      %q{Girl is going out with at most one Boy;},
+      %q{
+        Boy is going out with Girlfriend,
+          Girl (as Girlfriend) is going out with at most one Boy;
+      },
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 3
+        PresenceConstraints(fact_type).size.should == 1
+      end
+    ],
+    [ # Match with explicit adjective
+      %q{Girl is going out with at most one ugly-Boy;},
+      %q{Girl is going out with at most one ugly-Boy,
+        ugly-Boy is best friend of Girl;
+      },
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 2
+        PresenceConstraints(fact_type).size.should == 1
+      end
+    ],
+    [ # Match with implicit adjective
+      %q{Girl is going out with at most one ugly-Boy;},
+      %q{Girl is going out with ugly Boy,
+        Boy is going out with Girl;
+      },
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 2
+        PresenceConstraints(fact_type).size.should == 1
+      end
+    ],
+    [ # Match with explicit trailing adjective
+      %q{Girl is going out with at most one Boy-monster;},
+      %q{Girl is going out with Boy-monster,
+        Boy is going out with Girl;
+      },
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 2
+        PresenceConstraints(fact_type).size.should == 1
+      end
+    ],
+    [ # Match with implicit trailing adjective
+      %q{Girl is going out with at most one Boy-monster;},
+      %q{Girl is going out with Boy monster,
+        Boy is going out with Girl;
+      },
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 2
+        PresenceConstraints(fact_type).size.should == 1
+      end
+    ],
+    [ # Match with two explicit adjectives
+      %q{Girl is going out with at most one ugly- bad Boy;},
+      %q{Girl is going out with ugly- bad Boy,
+        ugly- bad Boy is going out with Girl;
+      },
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 2
+        PresenceConstraints(fact_type).size.should == 1
+      end
+    ],
+    [ # Match with two implicit adjective
+      %q{Girl is going out with at most one ugly- bad Boy;},
+      %q{Girl is going out with ugly bad Boy,
+        Boy is going out with Girl;
+      },
+      SingleFact(),
+        ReadingCount(2),
+        PresenceConstraintCount(1)
+    ],
+    [ # Match with two explicit trailing adjective
+      %q{Girl is going out with at most one Boy real -monster;},
+      %q{Girl is going out with Boy real -monster,
+        Boy is going out with Girl;
+      },
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 2
+        PresenceConstraints(fact_type).size.should == 1
+      end
+    ],
+    [ # Match with two implicit trailing adjectives
+      %q{Girl is going out with at most one Boy real -monster;},
+      %q{Girl is going out with Boy real monster,
+        Boy is going out with Girl;
+      },
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 2
+        PresenceConstraints(fact_type).size.should == 1
+      end
+    ],
+    [ # Match with hyphenated word
+      %q{Girl is going out with at most one Boy; },
+      %q{
+        Girl is going out with Boy,
+          Boy is out driving a semi-trailer with Girl;
+      },
+      SingleFact() do |fact_type|
+        (readings = Readings(fact_type)).size.should == 2
+        ## REVISIT: Refactor test
+        #ReadingContainsHyphenatedWord(readings[1])
+        ReadingContainsHyphenatedWord(1)
+        PresenceConstraintCount(1)
+      end
+    ],
+    [ # Match with implicit leading ignoring explicit trailing adjective
+      %q{Girl is going out with at most one ugly-Boy;},
+      %q{Girl is going out with ugly Boy-monster,
+        Boy is going out with Girl;
+      },
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 3
+        PresenceConstraints(fact_type).size.should == 1
+      end
+    ],
+    [ # Match with implicit leading ignoring implicit trailing adjective
+      %q{Girl is going out with at most one ugly-Boy;},
+      %q{Girl is going out with ugly Boy monster,
+        Boy-monster is going out with Girl;
+      },
+      SingleFact(),
+        ReadingCount(3),
+        PresenceConstraintCount(1)
+    ],
+    [ # Match with implicit trailing ignoring explicit leading adjective
+      %q{Girl is going out with at most one Boy-monster;},
+      %q{Girl is going out with ugly-Boy monster,
+        Boy is going out with Girl;
+      },
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 3
+        PresenceConstraints(fact_type).size.should == 1
+      end
+    ],
+    [ # Match with implicit trailing ignoring implicit leading adjective
+      %q{Girl is going out with at most one Boy-monster;},
+      %q{Girl is going out with ugly Boy monster,
+        ugly-Boy is going out with Girl;
+      },
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 3
+        PresenceConstraints(fact_type).size.should == 1
+      end
+    ],
+  ]
+
+  EntityIdentificationTests = [
+    [
+      # REVISIT: At present, this doesn't add the minimum frequency constraint that a preferred identifier requires.
+      %q{Thong is written as String;},
+      %q{Thing is identified by Thong where Thing has one Thong;},
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 1
+        PresenceConstraints(fact_type).size.should == 2
+      end,
+      Concept('Thong') do |concept|
+        concept.class.should == ActiveFacts::Metamodel::ValueType
+        # REVISIT: Figure out how WrittenAs can access the constellation.
+        WrittenAs('String')
+      end,
+      ConceptCount(2+BaseConcepts),
+      Concept('Thing'),
+        PreferredIdentifier(1),
+          PreferredIdentifierRolePlayedBy('Thong'),
+    ],
+
+    [ # Auto-create Id and Thing Id:
+      %q{Thing is identified by its Id;},
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 2
+        PresenceConstraints(fact_type).size.should == 2
+      end,
+      ConceptCount(3+BaseConcepts),
+      Concept('Thing'),
+        PreferredIdentifier(1),
+          PreferredIdentifierRolePlayedBy('Thing Id'),
+    ],
+
+    [ # Auto-create Thing Id:
+      %q{Id is written as String;},
+      %q{Thing is identified by its Id;},
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 2
+        PresenceConstraints(fact_type).size.should == 2
+      end,
+      ConceptCount(3+BaseConcepts),
+      Concept('Thing'),
+        PreferredIdentifier(1),
+          PreferredIdentifierRolePlayedBy('Thing Id'),
+    ],
+
+    [ # Auto-create nothing (identifying value type exists already)
+      %q{Thing Id is written as String;},
+      %q{Thing is identified by its Id;},
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 2
+        PresenceConstraints(fact_type).size.should == 2
+      end,
+      ConceptCount(2+BaseConcepts),
+      Concept('Thing'),
+        PreferredIdentifier(1),
+          PreferredIdentifierRolePlayedBy('Thing Id'),
+    ],
+
+    [ # Auto-create nothing (identifying entity type exists already so don't create a VT)
+      %q{Id is written as Id;},
+      %q{Thing Id is identified by Id where Thing Id has one Id, Id is of one Thing Id;},
+      %q{Thing is identified by its Id;},
+      FactHavingPlayers("Thing", "Thing Id") do |fact_type|
+        Readings(fact_type).size.should == 2
+        PresenceConstraints(fact_type).size.should == 2
+      end,
+      ConceptCount(3+BaseConcepts),
+      Concept('Thing'),
+        PreferredIdentifier(1),
+          PreferredIdentifierRolePlayedBy('Thing Id'),
+    ],
+
+    [
+      %q{Thong is written as String;},
+      %q{Thing is identified by Thong where Thing has one Thong, Thong is of one Thing;},
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 2
+        PresenceConstraints(fact_type).size.should == 2
+      end,
+      ConceptCount(2+BaseConcepts),
+      Concept('Thing'),
+        PreferredIdentifier(1),
+          PreferredIdentifierRolePlayedBy('Thong'),
+    ],
+
+    [   # Objectified fact type with internal identification
+      %q{Relationship is where Boy relates to Girl;},
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 1
+        PresenceConstraints(fact_type).size.should == 1
+      end,
+      ConceptCount(1+BaseConcepts),
+      Concept('Relationship'),
+        PreferredIdentifier(2),
+#          PreferredIdentifierRolePlayedBy('Thong'),
+    ],
+
+    [   # Objectified fact type with external identification
+      %q{Relationship is identified by its Id where Boy relates to Girl;},
+      ConceptCount(3+BaseConcepts),
+      Concept('Relationship'),
+        PreferredIdentifier(1),   # 1 role in PI
+          PreferredIdentifierRolePlayedBy('Relationship Id'),
+      FactHavingPlayers('Relationship', 'Relationship Id') do |fact_type|
+        Readings(fact_type).size.should == 2
+        PresenceConstraints(fact_type).size.should == 2
+        fact_type.all_reading.detect{|r| r.text == '{0} has {1}'}.should_not == nil
+        fact_type.all_reading.detect{|r| r.text == '{0} is of {1}'}.should_not == nil
+      end,
+      FactHavingPlayers('Boy', 'Girl') do |fact_type|
+        fact_type.entity_type.should == @concept
+      end,
+    ],
+
+    [   # Objectified fact type with external identification and explicit reading
+      %q{Relationship is identified by its Id where Boy relates to Girl, Relationship is known by Relationship Id;},
+      ConceptCount(3+BaseConcepts),
+      Concept('Relationship'),
+        PreferredIdentifier(1),
+          PreferredIdentifierRolePlayedBy('Relationship Id'),
+      FactHavingPlayers('Relationship', 'Relationship Id') do |fact_type|
+        Readings(fact_type).size.should == 2
+        PresenceConstraints(fact_type).size.should == 2
+        fact_type.all_reading.detect{|r| r.text == '{0} is known by {1}'}.should_not == nil
+        fact_type.all_reading.detect{|r| r.text == '{0} is of {1}'}.should_not == nil
+      end,
+      FactHavingPlayers('Boy', 'Girl') do |fact_type|
+        fact_type.entity_type.should == @concept
+      end,
+    ],
+
+  ]
+  AllTests =
+#    SimpleBinaryFactTypeTests +
+    EntityIdentificationTests
+
+  before :each do
+    @compiler = ActiveFacts::CQL::Compiler.new('Test')
+  end
+
+  AllTests.each do |tests|
+    it "should process '#{(tests.select{|t| t.is_a?(String)}*' ').gsub(/\s+/m,' ')}' correctly" do
+      tests.each do |test|
+        case test
+        when String
+          result = @compiler.compile(MatchingPrefix+test)
+          puts @compiler.failure_reason unless result
+          result.should_not be_nil
+        when Proc
+          begin
+            test.call(@compiler.vocabulary.constellation)
+          rescue Spec::Example::ExamplePendingError
+            raise
+          rescue => e
+            puts "Failed on\n\t"+tests.select{|t| t.is_a?(String)}*" "
+            raise
+          end
+        end
+      end
+    end
+  end
+end