activefacts 1.1.0 → 1.2.0

data/spec/cql/expressions_spec.rb

@@ -42,7 +42,7 @@ describe "When compiling expressions" do
       new_fact_types.size.should == 3
   end
 
-  it "should create derived fact type and project the roles" do
+  it "should create derived fact types and project the roles" do
       compile %q{Person is old where Person is of Age >= 3*(9+11); }
 
       new_fact_types = fact_types
@@ -52,8 +52,13 @@ describe "When compiling expressions" do
       is_old_ft = new_fact_types.detect{|ft| ft.all_reading.detect{|r| r.text =~ /is old/} }
       (is_old_ft.all_reading.map{ |r| r.expand }*', ').should == "Person is old"
 
-      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))"
+      new_readings = new_fact_types.
+	reject{|ft| ft == is_old_ft}.
+	map{|ft| ft.all_reading.map{|r| r.expand}*", "}
+
+      new_readings.should include("Boolean = Age >= PRODUCT_OF<Integer SUM_OF<Integer, Integer>>")
+      new_readings.should include("PRODUCT_OF<Integer SUM_OF<Integer, Integer>> = Integer * SUM_OF<Integer, Integer>")
+      new_readings.should include("SUM_OF<Integer, Integer> = Integer + Integer")
 
       # one_query_with_value 60, 'year'
     end

data/spec/cql/parser/entity_types_spec.rb

@@ -50,7 +50,7 @@ describe "Entity Types" do
 
   EntityTypes_Objectified = [
     [ "Director is where b directs c, c is directed by b;",
-      ["FactType: Director [{b} \"directs\" {c}, {c} \"is directed by\" {b}]"]
+      ["FactType: [{b} \"directs\" {c}, {c} \"is directed by\" {b}]"]
     ],
   ]
 

data/spec/cql/parser/expressions_spec.rb

@@ -15,9 +15,12 @@ describe "ASTs from Derived Fact Types with expressions" do
     %q{
       Director is old: Person directs Company, Person is of Age, Age > 60;
     }.should parse_to_ast \
-      %q{FactType: [{Director} "is old"] where {Person} "directs" {Company} ,
-        {Person} "is of" {Age} ,
-        compare>({Age} 60)}
+      %q{
+	FactType: Query: where {Person} "directs" {Company} ,
+	{Person} "is of" {Age} ,
+	COMPARE>({Age} WITH 60)
+	[{Director} "is old"]
+      }
   end
 
   it "should parse a comparison clause with subscripts" do
@@ -25,11 +28,11 @@ describe "ASTs from Derived Fact Types with expressions" do
       Director is old: Person directs Company, Person has Salary(2), Person is of Age(1), Age(1) > Salary(2);
     }.should parse_to_ast \
       %q{
-        FactType: [{Director} "is old"]
-        where {Person} "directs" {Company} ,
-        {Person} "has" {Salary(2)} ,
-        {Person} "is of" {Age(1)} ,
-        compare>({Age(1)} {Salary(2)})
+	FactType: Query: where {Person} "directs" {Company} ,
+	{Person} "has" {Salary(2)} ,
+	{Person} "is of" {Age(1)} ,
+	COMPARE>({Age(1)} WITH {Salary(2)})
+	[{Director} "is old"]
       }
   end
 
@@ -37,43 +40,44 @@ describe "ASTs from Derived Fact Types with expressions" do
     %q{
       Person is independent: Person has taxable- Income and taxable Income >= 20000 dollars or Person has sugar-Daddy;
     }.should parse_to_ast \
-      %q{FactType: [{Person} "is independent"] where {Person} "has" {taxable- Income} and
-        compare>=({taxable- Income} (20000 in dollars)) or {Person} "has" {sugar- Daddy}}
+      %q{
+	FactType: Query: where {Person} "has" {taxable- Income} and
+	COMPARE>=({taxable- Income} WITH (20000 in dollars)) or
+	{Person} "has" {sugar- Daddy}
+	[{Person} "is independent"]
+      }
   end
 
   it "should parse a reading with a contracted comparison expression" do
     %q{
       Director is old: Person directs company, Person is of Age > 20+2*20;
     }.should parse_to_ast \
-      %q{FactType: [{Director} "is old"] where {Person} "directs company" ,
-        {Person} "is of" {Age}
-        > compare>({Age} sum(20 product(2 20)))}
+      %q{
+	FactType: Query: where {Person} "directs company" ,
+	{Person} "is of" {Age} > COMPARE>({Age} WITH SUM(20 PLUS PRODUCT(2 TIMES 20)))
+	[{Director} "is old"]
+      }
   end
 
   it "should parse a right-contracted comparison clause after a right-contracted clause" do
     %q{
       Director is old: Company is directed by Person who is of Age > 60;
     }.should parse_to_ast \
-      %q{FactType: [{Director} "is old"] where {Company} "is directed by" {Person} who
-        {Person} "is of" {Age} >
-        compare>({Age} 60)}
+      %q{FactType: Query: where {Company} "is directed by" {Person} who {Person} "is of" {Age} > COMPARE>({Age} WITH 60) [{Director} "is old"]}
   end
 
   it "should parse a simple reading with qualifiers" do
     %q{
       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
-	["transitive"] maybe {Person(1)} "is parent of" {Person(2)}}
+      %q{FactType: Query: where ["transitive"] maybe {Person(1)} "is parent of" {Person(2)} [{Person(1)} "is ancestor 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
-        ["transitive"] maybe {Person(2)} "is child of" {Person(1)}
-	who {Person(1)} "is male"}
+       %q{FactType: Query: where ["transitive"] maybe {Person(2)} "is child of" {Person(1)} who {Person(1)} "is male" [{Person(1)} "provides lineage of" {Person(2)}]}
   end
 
   it "should parse a contracted readings and comparisons with qualifiers" do
@@ -83,29 +87,37 @@ 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
-	["transitive"] maybe {Person(1)} "is parent of" {Person(2)}
-	who ["static"] maybe {Person(2)} "is of" {Age}
-	>= compare>=({Age} 21)}
+      %q{
+	FactType: Query: where ["transitive"] maybe {Person(1)} "is parent of" {Person(2)} who
+	["static"] maybe {Person(2)} "is of" {Age} >=
+	COMPARE>=({Age} WITH 21)
+	[{Person(1)} "is ancestor of adult" {Person(2)}]
+      }
   end
 
   it "should parse a comparison expression with a contracted reading" do
     %q{
       Director is old: Person directs company, 3*30 >= Age that is of Person;
     }.should parse_to_ast \
-      %q{FactType: [{Director} "is old"] where {Person} "directs company" ,
-        compare>=(product(3 30) {Age})
-        that {Age} "is of" {Person}}
+      %q{
+	FactType: Query: where {Person} "directs company" ,
+	COMPARE>=(PRODUCT(3 TIMES 30) WITH {Age}) that
+	{Age} "is of" {Person}
+	[{Director} "is old"]
+      }
   end
 
   it "should parse a comparison expression with a contracted comparison" 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" ,
+      %q{
+	FactType: Query: where {Person} "directs company" ,
 	{Person} "is of" {Age} ,
-	compare<=(maybe 20 {Age})
-	< compare<({Age} 60)}
+	COMPARE<=(maybe 20 WITH {Age}) <
+	COMPARE<({Age} WITH 60)
+	[{Director} "is old"]
+      }
   end
 
   it "should parse a comparison expression with right-contracted then left-contracted comparisons"
@@ -122,24 +134,30 @@ 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", "transitive"] maybe {A} "has" {completely- B}
-	< compare<({completely- B} 5)
-	, compare=({B -c} 2)}
+      %q{
+	FactType: Query: where ["acyclic", "transitive"] maybe {A} "has" {completely- B} <
+	COMPARE<({completely- B} WITH 5) ,
+	COMPARE=({B -c} WITH 2)
+	[{A} "is a farce"]
+      }
   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", "transitive"] maybe {A} "has" {completely- green B}
-	< compare<({completely- green B} 9)
-	, compare=({B c -d} 2)}
+      %q{
+	FactType: Query: where ["acyclic", "transitive"] maybe {A} "has" {completely- green B} <
+	COMPARE<({completely- green B} WITH 9) ,
+	COMPARE=({B c -d} WITH 2)
+	[{A} "is a farce"]
+      }
   end
 
   it "should parse a comparison clause containing units" do
     %q{
       254 mm converts to foot/feet;
-      Width is written as Integer mm;
+      Width is written as Integer in mm;
       Window requires toughening where
         Window has Width,
         Window has Height,
@@ -147,9 +165,11 @@ describe "ASTs from Derived Fact Types with expressions" do
     }.should parse_to_ast \
       %q{Unit(foot/feet) is 254/1+0 mm^1},
       %q{ValueType: Width is written as Integer in [["mm", 1]];},
-      %q{FactType: [{Window} "requires toughening"] where {Window} "has" {Width} ,
-        {Window} "has" {Height}
-        , compare>=(product({Width} {Height}) (10 in feet^2))}
+      %q{FactType: Query: where {Window} "has" {Width} ,
+	{Window} "has" {Height} ,
+	COMPARE>=(PRODUCT({Width} TIMES {Height}) WITH (10 in feet^2))
+	[{Window} "requires toughening"]
+      }
   end
 
   it "should parse nested expressions" do
@@ -158,7 +178,7 @@ describe "ASTs from Derived Fact Types with expressions" do
       A > B+3*(4+5)?
     }.should parse_to_ast \
       %q{ValueType: A is written as B;},
-      %q{FactType: [] where compare>({A} sum({B} product(3 sum(4 5))))}
+      %q{FactType: Query: where COMPARE>({A} WITH SUM({B} PLUS PRODUCT(3 TIMES SUM(4 PLUS 5)))) []}
   end
 
   it "should parse a fact type containing an expression with subscripts"
@@ -168,17 +188,11 @@ describe "ASTs from Derived Fact Types with expressions" do
       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}
-          that ["definitely", "intransitive"] {Incident} "is of" {Claim})
-        "followed" {Intoxication}
+	FactType: Query: where ["static"] {Driving} (in which where
+	["acyclic"] maybe {Driver} "drove in" {Incident}
+	  that ["intransitive"] {Incident} "is of" {Claim}) "followed" {Intoxication}
+	[{Driving} "was negligent"]
       }
   end
 

data/spec/cql/parser/fact_types_spec.rb

@@ -23,7 +23,7 @@ describe "Fact Types" do
 #      [%q{FactType: AnnualIncome [{Person} "has" {total- Income} "in" {Year}] where {Person} "has" {total- Income}.sum() , {Income} "was earned in" {current- Time (as Year)}.Year()}]
 #    ],
     [ "A is interesting : b- C has F -g;",
-      ["FactType: [{A} \"is interesting\"] where {b- C} \"has\" {F -g}"]
+      [%q{FactType: Query: where {b- C} "has" {F -g} [{A} "is interesting"]}]
     ],
     [ "A has one pre-- bound B;",
       [%q{FactType: [{A} "has" {[1..1] pre-bound- B}]}]

data/spec/cql/parser/literals_spec.rb

@@ -114,31 +114,31 @@ describe "Valid Numbers, Strings and Ranges" do
     ],
 
     # Value types with units
-    [ "a is written as b inch;",                          # Value type declaration with unit
+    [ "a is written as b in inch;",                          # Value type declaration with unit
       ['ValueType: a is written as b in [["inch", 1]];']
     ],
-    [ "a is written as b() inch ; ",                      # Value type declaration with unit and whitespace
+    [ "a is written as b() in inch ; ",                      # Value type declaration with unit and whitespace
       ['ValueType: a is written as b in [["inch", 1]];']
     ],
-    [ "a is written as b() inch;",                        # Value type declaration with unit
+    [ "a is written as b() in inch;",                        # Value type declaration with unit
       ['ValueType: a is written as b in [["inch", 1]];']
     ],
-    [ "a is written as b inch^2;",                        # Value type declaration with unit and exponent
+    [ "a is written as b in inch^2;",                        # Value type declaration with unit and exponent
       ['ValueType: a is written as b in [["inch", 2]];']
     ],
-    [ "a is written as b() inch^2 ; ",                    # Value type declaration with unit and exponent with maximum whitespace
+    [ "a is written as b() in inch^2 ; ",                    # Value type declaration with unit and exponent with maximum whitespace
       ['ValueType: a is written as b in [["inch", 2]];']
     ],
-    [ "a is written as b second^-1;",                     # Value type declaration with unit and negative exponent
+    [ "a is written as b in second^-1;",                     # Value type declaration with unit and negative exponent
       ['ValueType: a is written as b in [["second", -1]];']
     ],
-    [ "a is written as b inch inch;",                     # Value type declaration with repeated unit
+    [ "a is written as b in inch inch;",                     # Value type declaration with repeated unit
       ['ValueType: a is written as b in [["inch", 1], ["inch", 1]];']
     ],
-    [ "a is written as b inch^2/minute^-1;",              # Value type declaration with unit and divided unit with exponents
+    [ "a is written as b in inch^2/minute^-1;",              # Value type declaration with unit and divided unit with exponents
       ['ValueType: a is written as b in [["inch", 2], ["minute", 1]];']
     ],
-    [ "a is written as b() second^-1/mm^-1 mm^-1;",       # Value type declaration with repeated divided unit
+    [ "a is written as b() in second^-1/mm^-1 mm^-1;",       # Value type declaration with repeated divided unit
       ['ValueType: a is written as b in [["second", -1], ["mm", 1], ["mm", 1]];']
     ],
 
@@ -281,7 +281,7 @@ describe "Valid Numbers, Strings and Ranges" do
     [ "a is written as b() restricted to {1} inches^2/second;",    # constraint with units and exponent
       ['ValueType: a is written as b ValueConstraint to ([1]) in [["inches", 2], ["second", -1]];']
     ],
-    [ "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
+    [ "a is written as b() in second^-1/mm^-1 mm^-1 restricted to {1} inches^2/second;",    # type with unit and constraint with units and exponent
       #['a is written as b ValueConstraint to ([1]) in [["inches", 2], ["second", -1]];']
       ["ValueType: a is written as b in [[\"second\", -1], [\"mm\", 1], [\"mm\", 1]] ValueConstraint to ([1]) in [[\"inches\", 2], [\"second\", -1]];"]
     ],

data/spec/cql/parser/pragmas_spec.rb

@@ -51,13 +51,13 @@ describe "Entity Types" do
 
     # Fact Types
     [ "Director is where c relates to b;",
-      ["FactType: Director [{c} \"relates to\" {b}]"]
+      ["FactType: [{c} \"relates to\" {b}]"]
     ],
     [ "Director [independent] is where c relates to b;",
-      ["FactType: Director [{c} \"relates to\" {b}], pragmas [independent]"]
+      ["FactType: [{c} \"relates to\" {b}], pragmas [independent]"]
     ],
     [ "Director is independent where c relates to b;",
-      ["FactType: Director [{c} \"relates to\" {b}], pragmas [independent]"]
+       ["FactType: [{c} \"relates to\" {b}], pragmas [independent]"]
     ],
   ]
 

data/spec/cql/parser/value_types_spec.rb

@@ -10,7 +10,7 @@ require 'helpers/test_parser'
 
 describe "Value Types" do
   ValueTypes = [
-    [ "a is written as b(1, 2) inch restricted to { 3 .. 4 } inch ;",
+    [ "a is written as b(1, 2) in inch restricted to { 3 .. 4 } inch ;",
       ['ValueType: a is written as b(1, 2) in [["inch", 1]] ValueConstraint to ([3..4]) in [["inch", 1]];']
     ],
 #    [ "a c  is written as b(1, 2) inch restricted to { 3 .. 4 } inch ;",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activefacts
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Clifford Heath
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-06 00:00:00.000000000 Z
+date: 2015-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activefacts-api