activefacts 0.8.16 → 0.8.18

data/spec/absorption_spec.rb

@@ -3,6 +3,7 @@
 # Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
 #
 
+require 'spec_helper'
 require 'activefacts/support'
 require 'activefacts/api/support'
 require 'activefacts/input/cql'

data/spec/cql/comparison_spec.rb

@@ -43,7 +43,7 @@ describe "When matching a reading with an existing fact type" do
     def value_should_match value, lit, unit = nil
       value.should_not be_nil
       value.literal.should == lit.to_s
-      (!!value.is_a_string).should == lit.is_a?(String)
+      (!!value.is_literal_string).should == lit.is_a?(String)
       if unit
         value.unit.should_not be_nil
         value.unit.name.should == unit
@@ -52,14 +52,14 @@ describe "When matching a reading with an existing fact type" do
       end
     end
 
-    def one_join_with_value v, unit = nil
-      joins.size.should == 1
-      (jss = join_steps).size.should == 2
-      (jns = join_nodes).size.should == 3
+    def one_query_with_value v, unit = nil
+      queries.size.should == 1
+      (jss = steps).size.should == 2
+      (jns = variables).size.should == 3
       integer_node = jns.detect{|jn| jn.object_type.name == 'Integer'}
       integer_node.should_not be_nil
       value_should_match integer_node.value, v, unit
-      # pending should test content of the join steps
+      # pending should test content of the steps
     end
 
     it "should create a comparison fact type" do
@@ -72,7 +72,7 @@ describe "When matching a reading with an existing fact type" do
       comparison_ft = (new_fact_types - [is_old_ft])[0]
       (comparison_ft.all_reading.map{ |r| r.expand }*', ').should == "Boolean = Age >= Integer"
 
-      one_join_with_value 60, 'year'
+      one_query_with_value 60, 'year'
     end
 
     it "should create a comparison fact type twice without duplication"
@@ -83,7 +83,7 @@ describe "When matching a reading with an existing fact type" do
       (readings = new_fact_types[0].all_reading).size.should == 1
       readings.single.text.should == '{0} = {1} >= {2}'
 
-      one_join_with_value 60, 'year'
+      one_query_with_value 60, 'year'
     end
   end
 end

data/spec/cql/contractions_spec.rb

@@ -121,7 +121,7 @@ require 'activefacts/api/support'
 require 'activefacts/cql/compiler'
 require File.dirname(__FILE__) + '/../helpers/compile_helpers'  # Can't see how to include/extend these methods correctly
 
-describe "When compiling a join, " do
+describe "When compiling a query, " do
   before :each do
     extend CompileHelpers
 
@@ -139,33 +139,6 @@ describe "When compiling a join, " do
 
     baseline
 
-=begin
-    def self.baseline
-      @base_facts = @constellation.FactType.values-@constellation.ImplicitFactType.values
-      @base_objects = @constellation.ObjectType.values
-    end
-
-    def self.fact_types
-      @constellation.FactType.values-@base_facts-@constellation.ImplicitFactType.values
-    end
-
-    def self.object_types
-      @constellation.ObjectType.values-@base_objects
-    end
-
-    def self.fact_pcs fact_type
-      fact_type.all_role.map{|r| r.all_role_ref.map{|rr| rr.role_sequence.all_presence_constraint.to_a}}.flatten.uniq
-    end
-
-    def self.derivation fact_type
-      join = (joins = @constellation.Join.values.to_a)[0]
-      # PENDING: When the fact type's roles are projected, use this instead:
-      # joins = fact_type.all_role.map{|r| r.all_join_role.map{|jr| jr.join}}.flatten.uniq
-      joins.size.should == 1
-      joins[0]
-    end
-=end
-
     def self.compile string
       lambda {
         @compiler.compile string
@@ -185,29 +158,29 @@ describe "When compiling a join, " do
       fact_type = fact_types[0]
       (pcs = fact_pcs(fact_type)).size.should == 0
     end
-    it "should produce one join" do
+    it "should produce one query" do
       fact_type = fact_types[0]
-      join = derivation(fact_type)
+      query = derivation(fact_type)
     end
-    it "the join should have 3 nodes" do
+    it "the query should have 3 variables" do
       fact_type = fact_types[0]
-      join = derivation(fact_type)
-      nodes = join.all_join_node.to_a
-      nodes.size.should == 3
+      query = derivation(fact_type)
+      variables = query.all_variable.to_a
+      variables.size.should == 3
     end
-    it "the join should have 2 steps" do
+    it "the query should have 2 steps" do
       fact_type = fact_types[0]
-      join = derivation(fact_type)
-      steps = join.all_join_step.to_a
+      query = derivation(fact_type)
+      steps = query.all_step.to_a
       steps.size.should == 2
     end
 
-    it "and should project the fact type roles from the join" do
-      pending "Join roles are not yet projected" do
-        join = derivation(fact_type)
-        joins = fact_type.all_role.map{|r| r.all_join_role.map{|jr| jr.join}}.flatten.uniq
-        joins.size == 1
-        joins.should == [join]
+    it "and should project the fact type roles from the query" do
+      pending "Plays are not yet projected" do
+        query = derivation(fact_type)
+        queries = fact_type.all_role.map{|r| r.all_play.map{|play| play.query}}.flatten.uniq
+        queries.size == 1
+        queries.should == [query]
       end
     end
   end

data/spec/cql/entity_type_spec.rb

@@ -20,7 +20,7 @@ describe "When compiling an entity type, " do
 
   def self.SingleFact &b
     lambda {|c|
-      real_fact_types = c.FactType.values-c.ImplicitFactType.values
+      real_fact_types = c.FactType.values-c.LinkFactType.values
       real_fact_types.size.should == 1
       @fact_type = real_fact_types[0]
       b.call(@fact_type) if b
@@ -301,6 +301,7 @@ describe "When compiling an entity type, " do
           result = @compiler.compile(MatchingPrefix+test)
           puts @compiler.failure_reason unless result
           result.should_not be_nil
+	  @compiler.vocabulary.finalise
         when Proc
           begin
             test.call(@compiler.vocabulary.constellation)

data/spec/cql/expressions_spec.rb

@@ -1,5 +1,5 @@
 #
-# ActiveFacts CQL Join Expressions
+# ActiveFacts CQL Expressions
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
 
@@ -55,7 +55,7 @@ describe "When compiling expressions" do
       comparison_ft = (new_fact_types - [is_old_ft])[0]
       (comparison_ft.all_reading.map{ |r| r.expand }*', ').should == "Boolean = Age >= product(Integer, sum(Integer, Integer))"
 
-      # one_join_with_value 60, 'year'
+      # one_query_with_value 60, 'year'
     end
   end
 end

data/spec/cql/fact_type_matching_spec.rb

@@ -22,6 +22,7 @@ describe "When matching a reading" do
     }
     @compiler = ActiveFacts::CQL::Compiler.new('Test')
     @compiler.compile(prefix)
+    @compiler.vocabulary.finalise
     @constellation = @compiler.vocabulary.constellation
 
     baseline
@@ -219,8 +220,10 @@ describe "When matching a reading" do
             Girl is going out with ugly-Boy monster,
             Boy is going out with Girl;
           }
+	@compiler.vocabulary.finalise
         (new_fact_types = fact_types).size.should == 1
-        (fact_type = new_fact_types[0]).all_reading.size.should == 2
+        fact_type = new_fact_types[0]
+        fact_type.all_reading.size.should == 2
         (pcs = fact_pcs(fact_type)).size.should == 1
       end
     end

data/spec/cql/parser/bad_literals_spec.rb

@@ -11,76 +11,76 @@ require 'helpers/test_parser'
 
 describe "Parsing Invalid Numbers and Strings" do
   it "should fail to parse an octal number containing non-octal digits" do
-    "a is written as b(08);".
-    should fail_to_parse /Expected (.|\n)* after a is written as b\(0$/
+    "aa is written as b(08);".
+    should fail_to_parse /Expected (.|\n)* at .* after aa is written as b\(0$/
   end
 
   it "should fail to parse a hexadecimal number containing non-hexadecimal digits" do
-    "a is written as b(0xDice);".
-    should fail_to_parse /Expected (.|\n)* after a is written as b\(0$/
+    "aa is written as b(0xDice);".
+    should fail_to_parse /Expected (.|\n)* at .* after aa is written as b\(0$/
   end
 
   it "should fail to parse a negative number with an intervening space" do
-    "a is written as b(- 1);".
-    should fail_to_parse /Expected .* after a is written as b\(/
+    "aa is written as b(- 1);".
+    should fail_to_parse /Expected .* after aa is written as b\(/
   end
 
   it "should fail to parse an explicit positive number with an intervening space" do
-    "a is written as b(+ 1);".
-    should fail_to_parse /Expected .* after a is written as b\(/
+    "aa is written as b(+ 1);".
+    should fail_to_parse /Expected .* after aa is written as b\(/
   end
 
   it "should fail to parse a negative octal number" do
-    "a is written as b(-077);".
-    should fail_to_parse /Expected .* after a is written as b\(/
+    "aa is written as b(-077);".
+    should fail_to_parse /Expected .* after aa is written as b\(/
   end
 
   it "should fail to parse a negative hexadecimal number" do
-    "a is written as b(-0xFace);".
-    should fail_to_parse /Expected .* after a is written as b\(/
+    "aa is written as b(-0xFace);".
+    should fail_to_parse /Expected .* after aa is written as b\(/
   end
 
   it "should fail to parse invalid real numbers (no digits before or nonzero after the point)" do
-    "a is written as b(.0);".
-    should fail_to_parse /Expected .* after a is written as b\(/
+    "aa is written as b(.0);".
+    should fail_to_parse /Expected .* after aa is written as b\(/
   end
 
   it "should fail to parse invalid real numbers (no digits after or nonzero before the point)" do
-    "a is written as b(0.);".
-    should fail_to_parse /Expected .* after a is written as b\(/
+    "aa is written as b(0.);".
+    should fail_to_parse /Expected .* after aa is written as b\(/
   end
 
   it "should fail to parse a number with illegal whitespace before the exponent" do
-    "inch converts to 1 inch; a is written as b() inch ^2 ; ".
-    should fail_to_parse /Expected .* after a is written as b\(\) inch/
+    "inch converts to 1 inch; aa is written as b() inch ^2 ; ".
+    should fail_to_parse /Expected .* after aa is written as b\(\) inch/
   end
 
   it "should fail to parse a number with illegal whitespace around the exponent" do
-    "inch converts to 1 inch; a is written as b() inch^ 2 ; ".
-    should fail_to_parse /Expected .* after a is written as b\(\) inch/
+    "inch converts to 1 inch; aa is written as b() inch^ 2 ; ".
+    should fail_to_parse /Expected .* after aa is written as b\(\) inch/
   end
 
   it "should fail to parse a string with an illegal octal escape" do
-    "a is written as b() restricted to { '\\7a' };".
-    should fail_to_parse /Expected .* a is written as b\(\) restricted to \{ '/
+    "aa is written as b() restricted to { '\\7a' };".
+    should fail_to_parse /Expected .* aa is written as b\(\) restricted to \{ '/
   end
 
   it "should fail to parse a string with a control character" do
-    "a is written as b() restricted to { '\001' };".
-    should fail_to_parse /Expected .* a is written as b\(\) restricted to \{ '/
+    "aa is written as b() restricted to { '\001' };".
+    should fail_to_parse /Expected .* aa is written as b\(\) restricted to \{ '/
   end
 
   it "should fail to parse a string with a control character" do
-    "a is written as b() restricted to { '\n' };".
-    should fail_to_parse /Expected .* a is written as b\(\) restricted to \{ '/
+    "aa is written as b() restricted to { '\n' };".
+    should fail_to_parse /Expected .* aa is written as b\(\) restricted to \{ '/
   end
 
   it "should fail to parse a cross-typed range" do
-    "a is written as b() restricted to { 0..'A' };".
-    should fail_to_parse /Expected .* after a is written as b\(\) restricted to \{ 0\.\./
+    "aa is written as b() restricted to { 0..'A' };".
+    should fail_to_parse /Expected .* after aa is written as b\(\) restricted to \{ 0\.\./
 
-    "a is written as b() restricted to { 'a'..27 };".
-    should fail_to_parse /Expected .* after a is written as b\(\) restricted to \{ 'a'\.\./
+    "aa is written as b() restricted to { 'a'..27 };".
+    should fail_to_parse /Expected .* after aa is written as b\(\) restricted to \{ 'a'\.\./
   end
 
 end

data/spec/cql/parser/entity_types_spec.rb

@@ -37,14 +37,14 @@ describe "Entity Types" do
     [ "a is identified by b, c where d;",                    # Entity type declaration with two-part identifier
       ["EntityType: a [{b}, {c}] where [\"d\"];"]
     ],
-    [ "a is written as b(); e is identified by a where d;",
-      ["ValueType: a is written as b;", "EntityType: e [{a}] where [\"d\"];"]
+    [ "aa is written as b(); e is identified by aa where d;",
+      ["ValueType: aa is written as b;", "EntityType: e [{aa}] where [\"d\"];"]
     ],
-    [ " a is written as b ( ) ; e is identified by a where d ; ",
-      ["ValueType: a is written as b;", "EntityType: e [{a}] where [\"d\"];"]
+    [ " aa is written as b ( ) ; e is identified by aa where d ; ",
+      ["ValueType: aa is written as b;", "EntityType: e [{aa}] where [\"d\"];"]
     ],
-    [ "e is written as b; a is identified by e where maybe d;",
-      ["ValueType: e is written as b;", "EntityType: a [{e}] where [[\"maybe\"] \"d\"];"]
+    [ "e is written as b; aa is identified by e where maybe d;",
+      ["ValueType: e is written as b;", "EntityType: aa [{e}] where [maybe \"d\"];"]
     ],
   ]
 

data/spec/cql/parser/expressions_spec.rb

@@ -64,16 +64,16 @@ describe "ASTs from Derived Fact Types with expressions" do
       Person(1) is ancestor of Person(2): maybe Person(1) is parent of Person(2) [transitive];
     }.should parse_to_ast \
       %q{FactType: [{Person(1)} "is ancestor of" {Person(2)}] where
-        ["maybe", "transitive"] {Person(1)} "is parent of" {Person(2)}}
+	["transitive"] maybe {Person(1)} "is parent of" {Person(2)}}
   end
 
   it "should parse a contracted reading with qualifiers" do
     %q{
       Person(1) provides lineage of Person(2): maybe Person(2) is child of Person(1) [transitive] who is male;
     }.should parse_to_ast \
-      %q{FactType: [{Person(1)} "provides lineage of" {Person(2)}] where
-        ["maybe", "transitive"] {Person(2)} "is child of" {Person(1)} 
-        who {Person(1)} "is male"}
+       %q{FactType: [{Person(1)} "provides lineage of" {Person(2)}] where
+        ["transitive"] maybe {Person(2)} "is child of" {Person(1)}
+	who {Person(1)} "is male"}
   end
 
   it "should parse a contracted readings and comparisons with qualifiers" do
@@ -83,10 +83,10 @@ describe "ASTs from Derived Fact Types with expressions" do
           who maybe is of Age [static]
             definitely >= 21;
     }.should parse_to_ast \
-      %q{FactType: [{Person(1)} "is ancestor of adult" {Person(2)}] where
-        ["maybe", "transitive"] {Person(1)} "is parent of" {Person(2)}
-        who ["maybe", "static"] {Person(2)} "is of" {Age}
-        >= compare>=({Age} 21, [definitely])}
+       %q{FactType: [{Person(1)} "is ancestor of adult" {Person(2)}] where
+	["transitive"] maybe {Person(1)} "is parent of" {Person(2)}
+	who ["static"] maybe {Person(2)} "is of" {Age}
+	>= compare>=({Age} 21)}
   end
 
   it "should parse a comparison expression with a contracted reading" do
@@ -102,10 +102,10 @@ describe "ASTs from Derived Fact Types with expressions" do
     %q{
       Director is old: Person directs company, Person is of Age, maybe 20 <= Age definitely < 60;
     }.should parse_to_ast \
-      %q{FactType: [{Director} "is old"] where {Person} "directs company" ,
-        {Person} "is of" {Age} ,
-        compare<=(20 {Age}, [maybe]) 
-        < compare<({Age} 60, [definitely])}
+       %q{FactType: [{Director} "is old"] where {Person} "directs company" ,
+	{Person} "is of" {Age} ,
+	compare<=(maybe 20 {Age})
+	< compare<({Age} 60)}
   end
 
   it "should parse a comparison expression with right-contracted then left-contracted comparisons"
@@ -122,18 +122,18 @@ describe "ASTs from Derived Fact Types with expressions" do
     %q{
       A is a farce: maybe A has completely- B [transitive, acyclic] < 5, B -c = 2;
     }.should parse_to_ast \
-      %q{FactType: [{A} "is a farce"] where ["acyclic", "maybe", "transitive"] {A} "has" {completely- B}
-        < compare<({completely- B} 5)
-        , compare=({B -c} 2)}
+       %q{FactType: [{A} "is a farce"] where ["acyclic", "transitive"] maybe {A} "has" {completely- B}
+	< compare<({completely- B} 5)
+	, compare=({B -c} 2)}
   end
 
   it "should parse multiple leading and trailing adjectives with contracted comparisons" do
     %q{
       A is a farce: maybe A has completely- green B [transitive, acyclic] < 9, B c -d = 2;
     }.should parse_to_ast \
-      %q{FactType: [{A} "is a farce"] where ["acyclic", "maybe", "transitive"] {A} "has" {completely- green B} 
-      < compare<({completely- green B} 9)
-      , compare=({B c -d} 2)}
+       %q{FactType: [{A} "is a farce"] where ["acyclic", "transitive"] maybe {A} "has" {completely- green B}
+	< compare<({completely- green B} 9)
+	, compare=({B c -d} 2)}
   end
 
   it "should parse a comparison clause containing units" do
@@ -163,11 +163,17 @@ describe "ASTs from Derived Fact Types with expressions" do
 
   it "should parse a fact type containing an expression with subscripts"
 
-  it "should parse a fact type containing objectification joins and contractions" do
+  it "should parse a fact type containing objectification steps and contractions" do
     %q{
       Driving was negligent where
         Driving (where maybe Driver drove in Incident [acyclic] that definitely is of Claim [intransitive]) followed Intoxication [static];
     }.should parse_to_ast \
+       %q{
+	FactType: [{Driving} "was negligent"] where ["static"] {Driving}
+	(where ["acyclic"] maybe {Driver} "drove in" {Incident}
+	  that ["intransitive"] {Incident} "is of" {Claim})
+	"followed" {Intoxication}
+       }
       %q{
         FactType: [{Driving} "was negligent"] where ["static"] {Driving}
         (where ["acyclic", "maybe"] {Driver} "drove in" {Incident}

data/spec/cql/samples_spec.rb

@@ -51,11 +51,11 @@ describe "Sample data" do
       "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
+    [   # The Company instance asserted with a related identifying instance
       "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
+    [   # The same, with an explicit identifying value step
       "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'"]}]
     ],
@@ -107,7 +107,7 @@ describe "Sample data" do
     if v.to_s !~ /[^-+0-9.]/ and (n = eval(v.to_s) rescue nil)
       n
     else
-      "'"+v.to_s.gsub(/'/,'\\\'')+"'"
+      v.to_s
     end
   end
 
@@ -179,6 +179,7 @@ describe "Sample data" do
       lambda do
         begin
           @vocabulary = ActiveFacts::Input::CQL.readstring(@text)
+	  @vocabulary.finalise
         rescue => exception
           if debug :exception
             puts "#{exception.message}"
@@ -220,7 +221,7 @@ describe "Sample data" do
 
   BadSamples.each do |c|
     source, missing = *Array(c)
-    it "should detect missing joins in #{source.inspect}" do
+    it "should detect missing queries in #{source.inspect}" do
       @text = SamplePrefix+source
       lambda do
         begin