activefacts-cql 1.8.1 → 1.8.2

data/lib/activefacts/cql/compiler/informal.rb

@@ -0,0 +1,48 @@
+module ActiveFacts
+  module CQL
+    class Compiler < ActiveFacts::CQL::Parser
+      class InformalDefinition < Definition
+        def initialize kind, subject, phrases, text
+          @kind = kind
+          @subject = subject
+          @phrases = phrases
+          @text = text
+        end
+
+        def compile
+          @context = CompilationContext.new(@vocabulary)
+          case @kind
+          when :each
+            compile_object_description
+          when :when
+            compile_fact_type_description
+          end
+        end
+
+        def apply_description concept_type
+          concept_type.concept.informal_description =
+            [ concept_type.concept.informal_description,
+              @text
+            ].compact*".\n"
+        end
+
+        def compile_object_description
+          object_type = @context.object_type(@subject)
+          raise "Cannot add informal description of undefined object #{@subject.inspect}" unless object_type
+          apply_description object_type 
+          false
+        end
+
+        def compile_fact_type_description
+          @clause = Compiler::Clause.new(@phrases)  # Make the phrases into a clause
+          @context.bind [@clause]                   # Bind player names in the claise
+          fact_type = @clause.match_existing_fact_type @context
+          apply_description fact_type if fact_type
+          false
+        end
+
+      end
+    end
+  end
+end
+

data/lib/activefacts/cql/compiler/query.rb

@@ -10,11 +10,11 @@ module ActiveFacts
               each do |binding|
                 trace :query, "Creating variable #{query.all_variable.size} for #{binding.inspect}"
                 binding.variable = @constellation.Variable(query, query.all_variable.size, :object_type => binding.player)
-		if literal = binding.refs.detect{|r| r.literal}
-		  if literal.kind_of?(ActiveFacts::CQL::Compiler::Reference)
-		    # REVISIT: Fix this crappy ad-hoc polymorphism hack
-		    literal = literal.literal
-		  end
+                if literal = binding.refs.detect{|r| r.literal}
+                  if literal.kind_of?(ActiveFacts::CQL::Compiler::Reference)
+                    # REVISIT: Fix this crappy ad-hoc polymorphism hack
+                    literal = literal.literal
+                  end
                   unit = @constellation.Unit.detect{|k, v| [v.name, v.plural_name].include? literal.unit} if literal.unit
                   binding.variable.value = [literal.literal.to_s, literal.literal.is_a?(String), unit]
                 end
@@ -34,60 +34,60 @@ module ActiveFacts
         end
 
         def build_step clause, roles_by_binding = {}, parent_variable = nil
-	  return unless clause.refs.size > 0  # Empty clause... really?
+          return unless clause.refs.size > 0  # Empty clause... really?
 
-	  step = @constellation.Step(
-	      :guid => :new,
-	      :fact_type => clause.fact_type,
-	      :alternative_set => nil,
-	      :is_disallowed => clause.certainty == false,
-	      :is_optional => clause.certainty == nil
-	    )
+          step = @constellation.Step(
+              :guid => :new,
+              :fact_type => clause.fact_type,
+              :alternative_set => nil,
+              :is_disallowed => clause.certainty == false,
+              :is_optional => clause.certainty == nil
+            )
 
-	  trace :query, "Creating Plays for #{clause.inspect} with #{clause.refs.size} refs" do
-	    is_input = true
-	    clause.refs.each do |ref|
-	      # These refs are the Compiler::References, which have associated Metamodel::RoleRefs,
-	      # but we need to create Plays for those roles.
-	      # REVISIT: Plays may need to save residual_adjectives
-	      binding = ref.binding
-	      role = (ref && ref.role) || (ref.role_ref && ref.role_ref.role)
+          trace :query, "Creating Plays for #{clause.inspect} with #{clause.refs.size} refs" do
+            is_input = true
+            clause.refs.each do |ref|
+              # These refs are the Compiler::References, which have associated Metamodel::RoleRefs,
+              # but we need to create Plays for those roles.
+              # REVISIT: Plays may need to save residual_adjectives
+              binding = ref.binding
+              role = (ref && ref.role) || (ref.role_ref && ref.role_ref.role)
 
-	      objectification_step = nil
-	      if ref.nested_clauses
-		ref.nested_clauses.each do |nested_clause|
-		  objectification_step = build_step nested_clause, roles_by_binding
-		  if ref.binding.player.is_a?(ActiveFacts::Metamodel::EntityType) and
-		      ref.binding.player.fact_type == nested_clause.fact_type
-		    objectification_step.objectification_variable = binding.variable
-		  end
-		end
-	      end
-	      if clause.is_naked_object_type
-		raise "#{self} lacks a proper objectification" if clause.refs[0].nested_clauses and !objectification_step
-		return objectification_step
-	      end
+              objectification_step = nil
+              if ref.nested_clauses
+                ref.nested_clauses.each do |nested_clause|
+                  objectification_step = build_step nested_clause, roles_by_binding
+                  if ref.binding.player.is_a?(ActiveFacts::Metamodel::EntityType) and
+                      ref.binding.player.fact_type == nested_clause.fact_type
+                    objectification_step.objectification_variable = binding.variable
+                  end
+                end
+              end
+              if clause.is_naked_object_type
+                raise "#{self} lacks a proper objectification" if clause.refs[0].nested_clauses and !objectification_step
+                return objectification_step
+              end
 
-	      if binding.variable.object_type != role.object_type	  # Type mismatch
-		if binding.variable.object_type.common_supertype(role.object_type)
-		  # REVISIT: there's an implicit subtyping step here, create it; then always raise the error here.
-		  # I don't want to do this for now because the verbaliser will always verbalise all steps.
-		  raise "Disallowing implicit subtyping step from #{role.object_type.name} to #{binding.variable.object_type.name} in #{clause.fact_type.default_reading.inspect}"
-		end
-		raise "A #{role.object_type.name} cannot satisfy #{binding.variable.object_type.name} in #{clause.fact_type.default_reading.inspect}"
-	      end
+              if binding.variable.object_type != role.object_type         # Type mismatch
+                if binding.variable.object_type.common_supertype(role.object_type)
+                  # REVISIT: there's an implicit subtyping step here, create it; then always raise the error here.
+                  # I don't want to do this for now because the verbaliser will always verbalise all steps.
+                  raise "Disallowing implicit subtyping step from #{role.object_type.name} to #{binding.variable.object_type.name} in #{clause.fact_type.default_reading.inspect}"
+                end
+                raise "A #{role.object_type.name} cannot satisfy #{binding.variable.object_type.name} in #{clause.fact_type.default_reading.inspect}"
+              end
 
-	      trace :query, "Creating Play for #{ref.inspect}"
-	      play = @constellation.Play(:step => step, :role => role, :variable => binding.variable)
-	      play.is_input = is_input
-	      is_input = false
+              trace :query, "Creating Play for #{ref.inspect}"
+              play = @constellation.Play(:step => step, :role => role, :variable => binding.variable)
+              play.is_input = is_input
+              is_input = false
 
-	      roles_by_binding[binding] = [role, play]
-	    end
-	  end
+              roles_by_binding[binding] = [role, play]
+            end
+          end
 
-	  step
-	end
+          step
+        end
 
         # Return the unique array of all bindings in these clauses, including in objectification steps
         def all_bindings_in_clauses clauses

data/lib/activefacts/cql/compiler/shared.rb

@@ -36,18 +36,18 @@ module ActiveFacts
           key <=> other.key
         end
         
-	def variable= v
-	  @variable = v	  # A place for a breakpoint :)
-	end
-
-	def add_ref ref
-	  @refs << ref
-	  ref
-	end
-
-	def delete_ref ref
-	  @refs.delete ref
-	end
+        def variable= v
+          @variable = v   # A place for a breakpoint :)
+        end
+
+        def add_ref ref
+          @refs << ref
+          ref
+        end
+
+        def delete_ref ref
+          @refs.delete ref
+        end
       end
 
       class CompilationContext
@@ -77,7 +77,7 @@ module ActiveFacts
           player ||= @player_by_role_name[name]
 
           if !player && @allowed_forward_terms.include?(name)
-	    @vocabulary.valid_entity_type_name(name)  # No need for the result here, just no exceptional condition
+            @vocabulary.valid_entity_type_name(name)  # No need for the result here, just no exceptional condition
             player = constellation.EntityType(@vocabulary, name, :concept => :new)
           end
 
@@ -117,10 +117,10 @@ module ActiveFacts
 
         def compile
           if @constellation.Vocabulary.size > 0
-	    @constellation.Topic @name
-	  else
-	    @constellation.Vocabulary @name
-	  end
+            @constellation.Topic @name
+          else
+            @constellation.Vocabulary @name
+          end
         end
 
         def to_s

data/lib/activefacts/cql/compiler/value_type.rb

@@ -94,8 +94,8 @@ module ActiveFacts
           @unit = unit
           @value_constraint = value_constraint
           @pragmas = pragmas
-	  @context_note = context_note
-	  @auto_assigned_at = auto_assigned_at
+          @context_note = context_note
+          @auto_assigned_at = auto_assigned_at
         end
 
         def compile
@@ -104,19 +104,19 @@ module ActiveFacts
           # Create the base type unless it already exists:
           base_type = nil
           if (@base_type_name != @name)
-	    unless base_type = @vocabulary.valid_value_type_name(@base_type_name)
+            unless base_type = @vocabulary.valid_value_type_name(@base_type_name)
               base_type = @constellation.ValueType(@vocabulary, @base_type_name, :concept => :new)
               return base_type if @base_type_name == @name
             end
           end
 
           # Create and initialise the ValueType:
-	  vt = @vocabulary.valid_value_type_name(@name) ||
-	    @constellation.ValueType(@vocabulary, @name, :concept => :new)
+          vt = @vocabulary.valid_value_type_name(@name) ||
+            @constellation.ValueType(@vocabulary, @name, :concept => :new)
           vt.is_independent = true if @pragmas.delete('independent')
-	  @pragmas.each do |p|
-	    @constellation.ConceptAnnotation(:concept => vt.concept, :mapping_annotation => p)
-	  end if @pragmas
+          @pragmas.each do |p|
+            @constellation.ConceptAnnotation(:concept => vt.concept, :mapping_annotation => p)
+          end if @pragmas
           vt.supertype = base_type if base_type
           vt.length = length if length
           vt.scale = scale if scale
@@ -148,9 +148,9 @@ module ActiveFacts
             vt.value_constraint = @value_constraint.compile
           end
 
-	  if @context_note
-	    @context_note.compile(@constellation, vt)
-	  end
+          if @context_note
+            @context_note.compile(@constellation, vt)
+          end
 
           vt
         end

data/lib/activefacts/cql/parser/CQLParser.treetop

@@ -37,16 +37,16 @@ module ActiveFacts
 
       # Each definition has an ast() method that returns an instance of a subclass of Compiler::Definition
       rule definition
-	definition_body s
-	{
-	  def ast
-	    definition_body.ast
-	  end
-
-	  def body
-	    definition_body.text_value
-	  end
-	}
+        definition_body s
+        {
+          def ast
+            definition_body.ast
+          end
+
+          def body
+            definition_body.text_value
+          end
+        }
       end
 
       rule definition_body
@@ -56,30 +56,31 @@ module ActiveFacts
         / constraint
         / unit_definition   # REVISIT: Move this above the prescan?
         / object_type
-	/ query
-	/ s ';' s { def ast; nil; end }
+        / informal_description
+        / query
+        / s ';' s { def ast; nil; end }
       end
 
       rule vocabulary_definition
         s vocabulary S vocabulary_name s ';'
         {
-	  def ast
-	    Compiler::Vocabulary.new(vocabulary_name.value)
-	  end
+          def ast
+            Compiler::Vocabulary.new(vocabulary_name.value)
+          end
         }
       end
 
       rule vocabulary_name
-	id
-	{ def node_type; :vocabulary; end }
+        id
+        { def node_type; :vocabulary; end }
       end
 
       rule import_definition
         s import S vocabulary_name alias_list ';'
         {
-	  def ast
-	    Compiler::Import.new(import.input.parser, vocabulary_name.value, alias_list.value)
-	  end
+          def ast
+            Compiler::Import.new(import.input.parser, vocabulary_name.value, alias_list.value)
+          end
         }
       end
 
@@ -94,8 +95,27 @@ module ActiveFacts
       end
 
       rule alias_term
-	id
-	{ def node_type; :term; end }
+        id
+        { def node_type; :term; end }
+      end
+
+      rule informal_description
+        informally s ',' s
+          subject:(
+            signifier:each S term         # Informal definition of an object type
+            /
+            signifier:when S reading:phrase+ s ','       # or a fact type
+          ) s
+          text:(!(!. / '.' [ \t\r]* "\n") (string / .))*  # Allow . inside a string
+          (!. / '.' [ \t\r]* "\n")          # The description terminates in a fullstop at the end of a line, or EOF
+        {
+          def ast
+            kind = subject.signifier.text_value.to_sym
+            subject_name = (kind == :each ? subject.term.text_value : subject.reading.text_value)
+            phrases = subject.reading.elements.map(&:ast) if kind == :when
+            Compiler::InformalDefinition.new(kind, subject_name, phrases, text.text_value)
+          end
+        }
       end
 
       rule constraint
@@ -106,60 +126,60 @@ module ActiveFacts
         # REVISIT: / value_constraint
       end
 
+      # Adding enforcement to a constraint makes it deontic
       rule enforcement
-	s '(' s otherwise s action s a:agent? s ')' s
-	  {
-	    def ast; Compiler::Enforcement.new(action.text_value, a.empty? ? nil : a.text_value); end
-	  }
-	/
-	''
-	  {
-	    def ast; nil; end
-	  }
-      end
-
-      # An enforcement action, like SMS, email, log, alarm, etc.
-      rule action
-	id
+        s '(' s
+          otherwise s
+          action:id s   # An enforcement action, like SMS, email, log, alarm, etc.
+          a:agent? s
+        ')' s
+          {
+            def ast; Compiler::Enforcement.new(action.text_value, a.empty? ? nil : a.text_value); end
+          }
+        /
+        ''
+          {
+            def ast; nil; end
+          }
       end
 
       # presence constraint:
       rule presence_constraint
-	(each_occurs_in_clauses / either_or)
+        (each_occurs_in_clauses / either_or)
         {
-	  def ast
-	    Compiler::PresenceConstraint.new c, enforcement.ast, clauses_ast, role_list_ast, quantifier_ast
-	  end
-	}
+          def 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
-	(for_each_how_many / either_or_not_both)
+        (for_each_how_many / either_or_not_both)
           {
-	    def ast
-	      Compiler::SetExclusionConstraint.new c, enforcement.ast, clauses_ast, role_list_ast, quantifier_ast
-	    end
-	  }
+            def ast
+              Compiler::SetExclusionConstraint.new c, enforcement.ast, clauses_ast, role_list_ast, quantifier_ast
+            end
+          }
       end
 
       rule subset_constraint
         (a_only_if_b / if_b_then_a)
         {
-	  def ast
-	    Compiler::SubsetConstraint.new c, enforcement.ast, [clauses.ast, r2.ast]
-	  end
-	}
+          def ast
+            Compiler::SubsetConstraint.new c, enforcement.ast, [clauses.ast, r2.ast]
+          end
+        }
       end
 
       rule equality_constraint
-	if_and_only_if
+        if_and_only_if
         {
-	  def ast
-	    all_clauses = [clauses.ast, *tail.elements.map{|e| e.clauses.ast }]
-	    Compiler::SetEqualityConstraint.new c, enforcement.ast, all_clauses
-	  end
-	}
+          def ast
+            all_clauses = [clauses.ast, *tail.elements.map{|e| e.clauses.ast }]
+            Compiler::SetEqualityConstraint.new c, enforcement.ast, all_clauses
+          end
+        }
       end
 
     end