activefacts 0.8.9 → 0.8.10

data/examples/CQL/OneToOnes.cql

@@ -9,9 +9,9 @@ Girl ID is written as Auto Counter;
 /*
  * Entity Types
  */
-Boy is identified by its ID [independent];
+Boy is independent identified by its ID;
 
-Girl is identified by its ID [independent];
+Girl is independent identified by its ID;
 Girl is going out with at most one Boy,
 	Boy is going out with at most one Girl;
 

data/examples/CQL/ServiceDirector.cql

@@ -29,7 +29,7 @@ Recurring Schedule Id is written as Auto Counter;
 Satellite Message Id is written as Unsigned Integer(32);
 Seconds is written as Unsigned Integer(32);
 Serial Number is written as String(20);
-Service Type is written as String(15) [independent];
+Service Type [independent] is written as String(15);
 Subscription Nr is written as Signed Integer(32);
 Switch Id is written as Auto Counter;
 Transaction Nr is written as Unsigned Integer(32);
@@ -84,7 +84,7 @@ Monitor is identified by its Id;
 Monitor monitors one Data Store;
 Monitor is disabled;
 
-Monitoring Application is identified by its Name [independent];
+Monitoring Application is independent identified by its Name;
 Monitor is owned by one Monitoring Application;
 
 Network is identified by its Nr;
@@ -105,13 +105,14 @@ Notification Level is identified by its Nr;
 Notification Level has one Initial- Delay Duration;
 Notification Level has one Repeat-Duration;
 
-Notification Type is identified by its Name [independent];
+Notification Type is independent identified by its Name;
 
 Provider Type is identified by its Id;
 
 Recurring Schedule is identified by its Id;
 Monitor has All- Exclusion Recurring Schedule,
 	All- Exclusion Recurring Schedule applies to at most one Monitor;
+Monitor (as IntegratingMonitor) has Integration- Exclusion Recurring Schedule;  // Avoid ambiguity; this is a new fact type
 Monitor (as IntegratingMonitor) has Integration- Exclusion Recurring Schedule,
 	Integration- Exclusion Recurring Schedule applies to at most one IntegratingMonitor;
 Recurring Schedule has one Duration;
@@ -146,6 +147,7 @@ Switch is one Revision-Version;
 Switch has one monitoring-Port;
 Switch (as Private Interface Switch) is on private-Network,
 	private-Network connects to at most one Private Interface Switch;
+Switch (as Public Interface Switch) is on public-Network;  // Avoid ambiguity; this is a new fact type
 Switch (as Public Interface Switch) is on at least one public-Network,
 	Network connects to at most one Public Interface Switch;
 Switch is backup messages;
@@ -208,11 +210,11 @@ Data Store Service has one Subscription;
  */
 either Company is client or Company is vendor but not both;
 for each Credential exactly one of these holds:
-	Data Store(1) requires Credential,
+	Data Store(2) requires Credential,
 	Data Store Service requires Credential,
 	Vendor requires Credential,
 	Data Store File Host System has Internal-Credential,
-	Data Store(2) has Internal-Credential;
+	Data Store(1) has Internal-Credential;
 for each Network exactly one of these holds:
 	Network is used by Host System,
 	Company has Origin-Network,
@@ -225,6 +227,9 @@ either Host System runs Switch or Data Store has Legacy-Switch but not both;
 for each Network at most one of these holds:
 	Network is ip_single,
 	Network has Ending-IP;
+Data Store Service (where Service is from Data Store) belongs to Client
+	if and only if
+	Client has default Data Store;
 Network has Ending IP
 	if and only if
 	Network is ip_range;

data/examples/CQL/Supervision.cql

@@ -28,12 +28,12 @@ CEO runs Company,
 /*
  * Constraints:
  */
-either Employee reports to Manager(1) or Employee is a Manager(2) that is a CEO that runs Company but not both;
+either Employee reports to Manager(2) or Employee is a Manager(1) that is a CEO that runs Company but not both;
 Employee is a Manager that is a CEO that runs Company
 	if and only if
 	Employee works for Company;
 
 // This constraint cannot be expressed in NORMA until it adds explicit join paths:
-Employee(1) reports to Manager that is a kind of Employee(2) that works for Company
+Employee(2) reports to Manager that is a kind of Employee(1) that works for Company
 	if and only if
-	Employee(1) works for Company;
+	Employee(2) works for Company;

data/examples/CQL/Tests.Test5.Load.cql

@@ -17,7 +17,7 @@ Event Date is identified by ymd where
 	Event Date has one ymd,
 	ymd is of at most one Event Date;
 
-Party is identified by its Id [independent];
+Party is independent identified by its Id;
 
 Party Moniker is where
 	Party is called one Party Name;

data/examples/CQL/Warehousing.cql

@@ -72,12 +72,14 @@ Purchase Order is to one Supplier,
 Transfer Request is identified by its ID;
 Dispatch Item is for at most one Transfer Request;
 Received Item is for at most one Transfer Request;
+Transfer Request is for one Product;
+Transfer Request is for one Quantity;
 
 Warehouse is identified by its ID;
 Purchase Order is to one Warehouse;
 Sales Order is from one Warehouse;
-Transfer Request is at most one from-Warehouse;
-Transfer Request is at most one to-Warehouse;
+Transfer Request is from one Warehouse (as From Warehouse);
+Transfer Request is to one Warehouse (as To Warehouse);
 Warehouse contains at least one Bin;
 
 Customer is a kind of Party;

data/lib/activefacts/cql/CQLParser.treetop

@@ -11,7 +11,7 @@ module ActiveFacts
       include Language        # One of the language modules provides this module
       include Expressions
       include Terms
-      include Concepts
+      include ObjectTypes
       include ValueTypes
       include FactTypes
       include Context
@@ -47,21 +47,27 @@ module ActiveFacts
         / prescan           # Always fails, but its side-effects are needed in the following
         / constraint
         / unit_definition   # REVISIT: Move this above the prescan?
-        / concept
+        / object_type
+	/ query
 	/ s ';' s { def ast; nil; end }
       end
 
       rule vocabulary_definition
-        s vocabulary S id s ';'
+        s vocabulary S vocabulary_name s ';'
         {
 	  def ast
-	    Compiler::Vocabulary.new(id.value)
+	    Compiler::Vocabulary.new(vocabulary_name.value)
 	  end
         }
       end
 
+      rule vocabulary_name
+	id
+	{ def node_type; :vocabulary; end }
+      end
+
       rule import_definition
-        s import S id alias_list ';'
+        s import S vocabulary_name alias_list ';'
         {
 	  def ast
 	    Compiler::Import.new(id.value, alias_list.value)
@@ -71,7 +77,7 @@ module ActiveFacts
 
       # REVISIT: Need a way to define equivalent readings for fact types here (and in the metamodel)
       rule alias_list
-        ( s ',' s alias S aliased_from:id S as S alias_to:id s )*
+        ( s ',' s alias S aliased_from:alias_term S as S alias_to:alias_term s )*
         {
           def value
             elements.inject({}){|h, e| h[e.aliased_from.value] = e.alias_to; h }
@@ -79,6 +85,11 @@ module ActiveFacts
         }
       end
 
+      rule alias_term
+	id
+	{ def node_type; :term; end }
+      end
+
       rule constraint
         subset_constraint /
         equality_constraint /
@@ -101,84 +112,39 @@ module ActiveFacts
 
       # presence constraint:
       rule presence_constraint
-        s 'each' s ('combination' S)? role_list s 'occurs' s quantifier s 'time' 's'? s enforcement 'in' s
-        readings_list s
-        c:context_note? ';'
+	(each_occurs_in_clauses / either_or)
         {
 	  def ast
-	    context_note = c.empty? ? nil : c.ast
-	    Compiler::PresenceConstraint.new context_note, enforcement.ast, readings_list.ast, role_list.ast, quantifier.ast
+	    Compiler::PresenceConstraint.new c, enforcement.ast, clauses_ast, role_list_ast, quantifier_ast
 	  end
 	}
       end
 
       # set (exclusion, mandatory exclusion, complex equality) constraint
       rule set_constraint
-        s 'for' s 'each' s role_list s quantifier s 'of' s 'these' s 'holds' s enforcement ':' s
-          readings_list s
-          c:context_note? ';'
+	(for_each_how_many / either_or_not_both)
           {
 	    def ast
-	      context_note = c.empty? ? nil : c.ast
-	      Compiler::SetExclusionConstraint.new context_note, enforcement.ast, readings_list.ast, role_list.ast, quantifier.ast
+	      Compiler::SetExclusionConstraint.new c, enforcement.ast, clauses_ast, role_list_ast, quantifier_ast
 	    end
 	  }
-        /
-        s either? s r1:readings s or s r2:readings exclusion:(but s not s both s)? c:context_note? enforcement ';'
-          {
-	    def ast
-	      context_note = c.empty? ? nil : c.ast
-
-	      if exclusion.text_value.empty?
-		Compiler::PresenceConstraint.new context_note, enforcement.ast, [r1.ast, r2.ast], nil, Compiler::Quantifier.new(1, nil)
-	      else
-		quantifier = Compiler::Quantifier.new(*(exclusion.text_value.empty? ? [1, nil] : [1, 1]))
-		#quantifier = Compiler::Quantifier.new(1, 1)
-		Compiler::SetExclusionConstraint.new context_note, enforcement.ast, [r1.ast, r2.ast], nil, quantifier
-	      end
-	    end
-          }
       end
 
       rule subset_constraint
-        s readings s only s if s r2:readings s
-        c:context_note? enforcement ';'
+        (a_only_if_b / if_b_then_a)
         {
 	  def ast
-	    context_note = c.empty? ? nil : c.ast
-	    Compiler::SubsetConstraint.new context_note, enforcement.ast, [readings.ast, r2.ast]
+	    Compiler::SubsetConstraint.new c, enforcement.ast, [clauses.ast, r2.ast]
 	  end
 	}
       end
 
       rule equality_constraint
-        s readings s tail:( if s and s only s if s readings s)+
-        c:context_note? enforcement ';'
-        {
-	  def ast
-	    context_note = c.empty? ? nil : c.ast
-	    all_readings = [readings.ast, *tail.elements.map{|e| e.readings.ast }]
-	    Compiler::SetEqualityConstraint.new context_note, enforcement.ast, all_readings
-	  end
-	}
-      end
-
-      rule readings_list
-        readings tail:( ',' s readings )*
-        {
-	  def ast
-	    [readings.ast, *tail.elements.map{|e| e.readings.ast }]
-	  end
-	}
-      end
-
-      rule readings
-        reading s tail:( and s reading s )*
+	if_and_only_if
         {
 	  def ast
-	    readings = reading.ast
-	    tail.elements.map{|e| readings += e.reading.ast }
-	    readings
+	    all_clauses = [clauses.ast, *tail.elements.map{|e| e.clauses.ast }]
+	    Compiler::SetEqualityConstraint.new c, enforcement.ast, all_clauses
 	  end
 	}
       end

data/lib/activefacts/cql/Context.treetop

@@ -29,14 +29,24 @@ module ActiveFacts
       end
 
       rule context_type
-        because         { def value; 'because'; end } /
+        because s       { def value; 'because'; end } /
         as_opposed_to   { def value; 'as_opposed_to'; end } /
         so_that         { def value; 'so_that'; end } /
         to_avoid        { def value; 'to_avoid'; end }
       end
 
+      # An enforcement action, like SMS, email, log, alarm, etc.
+      rule action
+	id
+      end
+
       rule discussion
-        '(' discussion ')' / (!( [()] / ',' as_agreed_by) .)*
+        (
+	  '(' discussion ')' / (!( [()] / ',' as_agreed_by) .)*
+	)
+	{
+	  def node_type; :linking; end
+	}
       end
     end
   end

data/lib/activefacts/cql/Expressions.treetop

@@ -7,22 +7,6 @@
 module ActiveFacts
   module CQL
     grammar Expressions
-      rule comparison
-        e1:expression s
-	comparator s e2:expression
-        {
-	  def ast
-	    Compiler::Comparison.new comparator.text_value, e1.ast, e2.ast
-	  end
-        }
-      end
-
-      rule comparator
-        '<=' / '<' / '=' / '>=' / '>'
-        # REVISIT: These words occur in readings, find alternates:
-        # / matches / includes
-      end
-
       rule expression
         sum
       end
@@ -31,7 +15,11 @@ module ActiveFacts
         t0:product s tail:( op:add_op s t1:product s )*
         {
 	  def ast
-	    Compiler::Sum.new(t0.ast, *tail.elements.map{|e| e.op.text_value == '-' ? Compiler::Negate.new(e.t1.ast) : e.t1.ast})
+	    if tail.elements.empty?
+	      t0.ast
+	    else
+	      Compiler::Sum.new(t0.ast, *tail.elements.map{|e| e.op.text_value == '-' ? Compiler::Negate.new(e.t1.ast) : e.t1.ast})
+	    end
 	  end
         }
       end
@@ -44,7 +32,11 @@ module ActiveFacts
         f0:factor s tail:( op:mul_op s f1:factor s )*
         {
 	  def ast
-	    Compiler::Product.new(f0.ast, *tail.elements.map{|e| e.op.text_value != '*' ? Compiler::DivideBy.new(e.op.text_value, e.f1.ast) : e.t1.ast})
+	    if tail.elements.empty?
+	      f0.ast
+	    else
+	      Compiler::Product.new(f0.ast, *tail.elements.map{|e| e.op.text_value != '*' ? Compiler::Reciprocal.new(e.op.text_value, e.f1.ast) : e.f1.ast})
+	    end
 	  end
         }
       end
@@ -61,19 +53,11 @@ module ActiveFacts
       end
 
       rule derived_variable
-        variable:term s p:function_call*
+        variable:term s role_id:(role_name / subscript )?
         {
-	  def ast
-	    Compiler::FunctionCallChain.new(term.ast, *p.elements.each{|f| f.ast})
-	  end
-        }
-      end
-
-      rule function_call
-        '.' s func:id s param_list:( '(' s params:( p0:expression s tail:( ',' s p1:expression s )* )? ')' s )?
-        {
-	  def ast
-	    Compiler::FunctionCall.new(func.value, *param_list.elements.map{|param| param.ast })
+	  def ast quantifier = nil, value_constraint = nil, literal = nil, nested_clauses = nil
+	    role_name = role_id.empty? ? nil : role_id.value
+	    variable.ast(quantifier, nil, role_name, value_constraint, literal, nested_clauses)
 	  end
         }
       end

data/lib/activefacts/cql/FactTypes.treetop

@@ -7,100 +7,93 @@
 module ActiveFacts
   module CQL
     grammar FactTypes
+      rule query
+	s joined_clauses r:returning_clause? '?'
+	{
+	  def ast
+	    Compiler::FactType.new nil, [], joined_clauses.ast, (r.empty? ? nil : r)
+	  end
+	}
+      end
+
       rule named_fact_type
         s term_definition_name
-        s is s mapping_pragmas where    # REVISIT: Need a place to put mapping pragmas like [independent]
+        mapping_pragmas is_where
         anonymous_fact_type
         {
 	  def ast
 	    ft = anonymous_fact_type.ast
 	    ft.name = term_definition_name.value
+	    pragmas = mapping_pragmas.value
+	    pragmas << 'independent' if is_where.independent
+	    ft.pragmas = pragmas
 	    ft
 	  end
         }
       end
 
       rule anonymous_fact_type
-        fact_clause
-          ftail:( (',' / and ) s fact_clause s )*
-          ctail:( (':' / where) s c:conditions s)?
+        joined_clauses
+          ctail:( (':' / where) s a:joined_clauses s)?
           returning_clause?
         s ';'
         {
 	  def ast
-            readings = fact_clause.ast
-            ftail.elements.each{|e| readings += e.fact_clause.ast }
-            conditions = !ctail.empty? ? ctail.c.ast : []
+            clauses_ast = joined_clauses.ast
+            conditions = !ctail.empty? ? ctail.a.ast : []
 	    returning = respond_to?(:returning_clause) ? returning_clause.ast : nil
-	    if (conditions.empty? && readings.detect{|r| r.includes_literals})
+	    value_derivation = clauses_ast.detect{|r| r.is_equality_comparison}
+	    if !value_derivation and
+		conditions.empty? and
+		clauses_ast.detect{|r| r.includes_literals}
 	      raise "Fact instances may not contain conditions" unless conditions.empty? && !returning
-	      Compiler::Fact.new readings
-	    elsif (readings.size == 1 &&
-	      readings[0].phrases.size == 1 &&
-	      (popname = readings[0].phrases[0]) &&
-	      !popname.is_a?(Compiler::RoleRef) &&
+	      Compiler::Fact.new clauses_ast
+	    elsif (clauses_ast.size == 1 &&
+	      clauses_ast[0].phrases.size == 1 &&
+	      (popname = clauses_ast[0].phrases[0]) &&
+	      !popname.is_a?(Compiler::VarRef) &&
 	      conditions.detect{|r| r.includes_literals}
 	    )
 	      Compiler::Fact.new conditions, popname
 	    else
-	      Compiler::FactType.new nil, readings, conditions, returning
+	      Compiler::FactType.new nil, clauses_ast, conditions, returning
 	    end
 	  end
         }
       end
 
-      rule fact_clauses
-        fact_clause
-          ftail:( (',' / and ) s fact_clause s )*
+      rule joined_clauses
+        qualified_clauses
+          ftail:( conjunction:(',' / and / or ) s qualified_clauses s )*
 	{
 	  def ast
-            readings = fact_clause.ast
-            ftail.elements.each{|e| readings += e.fact_clause.ast }
-	    readings
+            clauses_ast = qualified_clauses.ast
+            ftail.elements.each{|e|
+	      conjunction = e.conjunction.text_value
+	      # conjunction = 'and' if conjunction == ','   # ',' means AND, but disallows left-contractions
+	      clauses_ast += e.qualified_clauses.ast(conjunction)
+	    }
+	    clauses_ast
 	  end
 	}
       end
 
       rule returning_clause
-        returning return (',' return)*
+        returning s return (s ',' s return)*
       end
 
       rule return
-        by order 'REVISIT: return'
+	ordering_prefix? phrase+
       end
 
-      rule conditions
-        head:condition s tail:( (',' s / and S) next:condition s )*
+      rule qualified_clauses
+        s q:qualifier? s contracted_clauses s p:post_qualifiers? s c:context_note?
         {
-	  def ast
-	    conditions = head.ast
-	    tail.elements.each{|i| conditions += i.next.ast}
-	    conditions
-	  end
-        }
-      end
-
-      rule condition
-        head:clause s # tail:(or S alternate:clause s )*
-        {
-	  def ast
-	    head.ast
-            # Compiler::Alternates.new(head.ast, *tail.elements.map{|i| i.alternate.ast})
-	    # REVISIT: alternate conditions are not yet implemented
-	  end
-        }
-      end
-
-      rule clause
-        # REVISIT: No context for comparisons, yet
-        comparison / fact_clause
-      end
-
-      rule fact_clause
-        s q:qualifier? s reading s p:post_qualifiers? s c:context_note?
-        {
-	  def ast
-	    r = reading.ast	# An array of readings
+	  def ast(conjunction = nil)
+	    r = contracted_clauses.ast	# An array of clause asts
+	    r[0].conjunction = conjunction
+	    # pre-qualifiers apply to the first clause, post_qualifiers and context_note to the last
+	    # REVISIT: This may be incorrect where the last is a nested clause
 	    r[0].qualifiers << q.text_value unless q.empty?
 	    r[-1].qualifiers += p.list unless p.empty?
 	    r[-1].context_note = c.ast unless c.empty?
@@ -127,104 +120,173 @@ module ActiveFacts
 	intransitive / transitive / acyclic / symmetric / asymmetric / antisymmetric / reflexive / irreflexive
       end
 
-      rule reading
+      rule clauses_list
+        clauses tail:( ',' s clauses )*
+        {
+	  def ast
+	    [clauses.ast, *tail.elements.map{|e| e.clauses.ast }]
+	  end
+	}
+      end
+
+      rule clauses
+        contracted_clauses s tail:( and s contracted_clauses s )*
+        {
+	  def ast
+	    clauses = contracted_clauses.ast
+	    tail.elements.map{|e| clauses += e.contracted_clauses.ast }
+	    clauses
+	  end
+	}
+      end
+
+      rule contracted_clauses
+	comparison
+	/
         (
-	  contracted_reading
+	  contraction	  # A contraction will terminate this repetition by eating to the end
 	  /
-	  role    # A role reference containing a term, perhaps with attached paraphernalia
-	  /       # A hyphenated non-term. Important: no embedded spaces
-	  id tail:('-' !term id)+ s
-	    {
-	      def ast
-		[id.value, *tail.elements.map{|e| e.id.value}]*"-"
-	      end
-	    }
-	  /       # A normal non-term
-	  !non_role_word id s
-	    {
-	      def ast
-		id.value
-	      end
-	    }
+	  phrase
 	)+
         {
 	  def ast
 	    asts = elements.map{ |r| r.ast }
-	    contraction = []
+	    contracted_clauses = []
 	    qualifiers = []
-	    if asts[-1].is_a?(Array)	    # A contracted_reading (Array of [role, qualifiers, *readings])
-	      contraction = asts.pop	    # Pull off the contraction
-	      contracted_role = contraction.shift
-	      qualifiers = contraction.shift
-	      asts.push(contracted_role)  # And replace it by the role removed from the contraction
+	    if asts[-1].is_a?(Array)	    # A contraction (Array of [role, qualifiers, *clauses])
+	      contracted_clauses = asts.pop	    # Pull off the contracted_clauses
+	      contracted_role = contracted_clauses.shift
+	      qualifiers = contracted_clauses.shift
+	      asts.push(contracted_role)  # And replace it by the role removed from the contracted_clauses
 	    end
-	    reading = Compiler::Reading.new(asts)
-	    reading.qualifiers += qualifiers
-	    [reading] + contraction
+	    clause_ast = Compiler::Clause.new(asts, qualifiers)
+	    [clause_ast] + contracted_clauses
 	  end
         }
       end
 
-      # REVISIT: and later, similarly for contracted conditions (including comparisons)
-      rule contracted_reading
-	role p:post_qualifiers? that s q:qualifier? s reading s
+      rule contraction
+	reading_contraction /
+	condition_contraction
+      end
+
+      rule reading_contraction
+	role p:post_qualifiers? conjunction:(that/who) s q:qualifier? s contracted_clauses s
 	{
 	  def ast
-	    # reading.ast will return an array of Readings, but the first reading is special. We must:
-	    # * prepend a new role
+	    # contracted_clauses.ast will return an array of Clauses, but the first clause is special. We must:
+	    # * prepend a new role (we get the Role to build *two* ast nodes)
 	    # * attach the qualifiers
-	    readings = reading.ast
-	    readings[0].phrases.unshift(role.ast)
-	    readings[0].qualifiers << q.text_value unless q.empty?  # Add maybe/definitely
+	    clauses_ast = contracted_clauses.ast
+	    clauses_ast[0].conjunction = conjunction.text_value
+	    clauses_ast[0].phrases.unshift(role.ast)
+	    clauses_ast[0].qualifiers << q.text_value unless q.empty?  # Add maybe/definitely
 
-	    # A contracted_reading returns an array containing:
+	    # A contraction returns an array containing:
 	    # * a role AST
 	    # * a qualifiers array
-	    # * an array of Readings
-	    [role.ast, p.empty? ? [] : p.list] + readings
+	    # * an array of Clauses
+	    [role.ast, p.empty? ? [] : p.list] + clauses_ast
+	  end
+	}
+      end
+
+      rule condition_contraction
+	role p:post_qualifiers? q:qualifier? s comparator s e2:expression
+	  !phrase	  # The contracted_clauses must not continue here!
+	{
+	  def ast
+	    c = Compiler::Comparison.new(comparator.text_value, role.ast, e2.ast, q.empty? ? [] : [q.text_value])
+	    c.conjunction = comparator.text_value
+	    [ role.ast, p.empty? ? [] : p.list, c ]
+	  end
+	}
+      end
+
+      rule comparison
+	e1:expression s q:qualifier? s comparator s contraction p:post_qualifiers?
+	{
+	  def ast
+	    role, qualifiers, *clauses_ast = *contraction.ast
+	    clauses_ast[0].qualifiers += p.list unless p.empty?	# apply post_qualifiers to the contracted clause
+	    # clauses_ast[0].conjunction = 'and' # AND is implicit for a contraction
+	    c = Compiler::Comparison.new(comparator.text_value, e1.ast, role)
+	    c.qualifiers << q.text_value unless q.empty?
+	    [c] + clauses_ast
 	  end
 	}
+        /
+	q:qualifier? e1:expression s comparator s e2:expression # comparisons have no post-qualifiers: p:post_qualifiers?
+        {
+	  def ast
+	    [Compiler::Comparison.new(comparator.text_value, e1.ast, e2.ast, q.empty? ? [] : [q.text_value])]
+	  end
+        }
+      end
+
+      rule comparator
+        '<=' / '<>' / '<' / '=' / '>=' / '>' / '!='
+      end
+
+      rule phrase
+	role    # A role reference containing a term, perhaps with attached paraphernalia
+	/       # A hyphenated non-term. Important: no embedded spaces
+	id tail:('-' !term id)+ s
+	  {
+	    def ast
+	      [id.value, *tail.elements.map{|e| e.id.value}]*"-"
+	    end
+	    def node_type; :linking; end
+	  }
+	/       # A normal non-term
+	!non_phrase id s
+	  {
+	    def ast
+	      id.value
+	    end
+	    def node_type; :linking; end
+	  }
       end
 
       # This is the rule that causes most back-tracking. I think you can see why.
-      # When we have an expression, we will come down here perhaps multiple times,
-      # but find no way out as soon as we hit the trailing non_role.
       rule role
         q:(quantifier enforcement)?
-        player:term
-        func:function_call? s
-        role_id:(role_name / subscript )?
+        player:derived_variable
         lr:(
 	  literal u:unit?
 	  /
 	  value_constraint enforcement
 	)?
 	oj:objectification_join?
-        !non_role     # If we integrate fact_clauses with comparisons, this can go.
         {
 	  def ast
 	    if !q.empty? && q.quantifier.value
 	      quantifier = Compiler::Quantifier.new(q.quantifier.value[0], q.quantifier.value[1], q.enforcement.ast)
 	    end
-	    role_name = role_id.empty? ? nil : role_id.value
-	    function_call = nil
 	    if !lr.empty?
 	      if lr.respond_to?(:literal)
 		literal = lr.literal.value
 		raise "Literals with units are not yet processed" unless lr.u.empty?
 	      end
-	      value_constraint = Compiler::ValueConstraint.new(lr.value_constraint.ranges, lr.enforcement.ast) if lr.respond_to?(:value_constraint)
-	      raise "It is not permitted to provide both a literal value and a value restriction" if value_constraint and literal
+	      value_constraint = Compiler::ValueConstraint.new(lr.value_constraint.ranges, lr.value_constraint.units, lr.enforcement.ast) if lr.respond_to?(:value_constraint)
+	      raise "It is not permitted to provide both a literal value and a value constraint" if value_constraint and literal
 	    end
 
-	    objectification_join = oj.empty? ? nil : oj.ast
-	    player.ast(quantifier, function_call, role_name, value_constraint, literal, objectification_join)
+	    nested_clauses =
+	      if oj.empty?
+		nil
+	      else
+		ast = oj.ast
+		ast[0].conjunction = 'where'
+		ast
+	      end
+	    player.ast(quantifier, value_constraint, literal, nested_clauses)
 	  end
         }
       end
 
       rule objectification_join
-        '(' s where s facts:fact_clauses s ')' s
+        '(' s where s facts:joined_clauses s ')' s
 	{
 	  def ast
 	    facts.ast
@@ -242,13 +304,6 @@ module ActiveFacts
         { def value; i.text_value.to_i; end }
       end
 
-      rule non_role
-        # Any of these is illegal in or following a reading (they indicate a comparison is coming). Later, this will change:
-        comparator
-        / add_op
-        / mul_op
-      end
-
     end
   end
 end