activefacts 0.8.16 → 0.8.18

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

@@ -2,20 +2,20 @@ module ActiveFacts
   module CQL
     class Compiler < ActiveFacts::CQL::Parser
 
-      # In a declaration, a Variable has one or more VarRef's.
-      # A Variable is for a single ObjectType, normally related to just one Role,
-      # and the references (VarRefs) to it will normally be the object_type name
+      # In a declaration, a Binding has one or more Reference's.
+      # A Binding is for a single ObjectType, normally related to just one Role,
+      # and the references (References) to it will normally be the object_type name
       # with the same adjectives (modulo loose binding),
       # or a role name or subscript reference.
       #
-      # In some situations a Variable will have some VarRefs with the same adjectives,
-      # and one or more VarRefs with no adjectives - this is called "loose binding".
-      class Variable
+      # In some situations a Binding will have some References with the same adjectives,
+      # and one or more References with no adjectives - this is called "loose binding".
+      class Binding
         attr_reader :player             # The ObjectType (object type)
-        attr_reader :refs               # an array of the VarRefs
+        attr_reader :refs               # an array of the References
         attr_reader :role_name
-        attr_accessor :rebound_to       # Loose binding may set this to another variable
-        attr_accessor :join_node
+        attr_accessor :rebound_to       # Loose binding may set this to another binding
+        attr_accessor :variable
         attr_accessor :instance         # When binding fact instances, the instance goes here
 
         def initialize player, role_name = nil
@@ -43,14 +43,14 @@ module ActiveFacts
         attr_accessor :left_contraction_allowed
         attr_accessor :left_contractable_clause
         attr_accessor :left_contraction_conjunction
-        attr_reader :variables             # The Variables in this declaration
+        attr_reader :bindings             # The Bindings in this declaration
         attr_reader :player_by_role_name
 
         def initialize vocabulary
           @vocabulary = vocabulary
           @vocabulary_identifier = @vocabulary.identifying_role_values
           @allowed_forward_terms = []
-          @variables = {}
+          @bindings = {}
           @player_by_role_name = {}
           @left_contraction_allowed = false
         end
@@ -64,13 +64,14 @@ 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
             player = constellation.EntityType(@vocabulary, name, :guid => :new)
           end
 
           player
         end
 
-        # Pass in an array of clauses or VarRefs for player identification and binding (creating the Variables)
+        # Pass in an array of clauses or References for player identification and binding (creating the Bindings)
         # It's necessary to identify all players that define a role name first,
         # so those names exist in the context for where they're used.
         def bind *clauses

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

@@ -87,29 +87,31 @@ module ActiveFacts
       end
 
       class ValueType < ObjectType
-        def initialize name, base, parameters, unit, value_constraint, pragmas
+        def initialize name, base, parameters, unit, value_constraint, pragmas, context_note
           super name
           @base_type_name = base
           @parameters = parameters
           @unit = unit
           @value_constraint = value_constraint
           @pragmas = pragmas
+	  @context_note = context_note
         end
 
         def compile
           length, scale = *@parameters
 
-          # Create the base type:
+          # Create the base type unless it already exists:
           base_type = nil
           if (@base_type_name != @name)
-            unless base_type = @constellation.ValueType[[@vocabulary.identifying_role_values, @constellation.Name(@base_type_name)]]
+	    unless base_type = @vocabulary.valid_value_type_name(@base_type_name)
               base_type = @constellation.ValueType(@vocabulary, @base_type_name, :guid => :new)
               return base_type if @base_type_name == @name
             end
           end
 
           # Create and initialise the ValueType:
-          vt = @constellation.ValueType(@vocabulary, @name, :guid => :new)
+	  vt = @vocabulary.valid_value_type_name(@name) ||
+	    @constellation.ValueType(@vocabulary, @name, :guid => :new)
           vt.is_independent = true if (@pragmas.include? 'independent')
           vt.supertype = base_type if base_type
           vt.length = length if length
@@ -141,6 +143,10 @@ module ActiveFacts
             vt.value_constraint = @value_constraint.compile
           end
 
+	  if @context_note
+	    @context_note.compile(@constellation, vt)
+	  end
+
           vt
         end
 

data/lib/activefacts/cql/nodes.rb

@@ -13,7 +13,7 @@ module ActiveFacts
             trailing_adjective = t[gt.size+1..-1]
             trailing_adjective.sub!(/ (\S*)\Z/, '-\1') if !tail.elements[-1].dbl.empty?
           end
-          Compiler::VarRef.new(gt, leading_adjective, trailing_adjective, quantifier, function_call, role_name, value_constraint, literal, nested_clauses)
+          Compiler::Reference.new(gt, leading_adjective, trailing_adjective, quantifier, function_call, role_name, value_constraint, literal, nested_clauses)
         end
 
         def value             # Sometimes we just want the full term name

data/lib/activefacts/cql/parser.rb

@@ -48,6 +48,7 @@ module ActiveFacts
       # These methods are semantic predicates; if they return false this parse rule will fail.
       class Context
         attr_reader :term, :global_term
+        attr_reader :terms
 
         def initialize(parser)
           @parser = parser
@@ -150,7 +151,7 @@ module ActiveFacts
         # Index the name by all prefixes
         def index_name(index, name, value = true)
           added = false
-          words = name.scan(/\w+/)
+          words = name.split(/\s+/)
           words.inject("") do |n, w|
             # Index all prefixes up to the full term
             n = n.empty? ? w : "#{n} #{w}"
@@ -220,7 +221,10 @@ module ActiveFacts
         nodes = []
         begin
           node = parse(InputProxy.new(input, context, self), :index => @index)
-          return nil unless node
+          unless node 
+            raise failure_reason unless @index == input.size
+            return nil  # No input, or no more input
+          end
           if @block
             @block.call(node)
           else

data/lib/activefacts/generate/absorption.rb

@@ -4,6 +4,7 @@
 #
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
+require 'activefacts/vocabulary'
 require 'activefacts/persistence'
 
 module ActiveFacts
@@ -18,7 +19,7 @@ module ActiveFacts
     # * paths Show the references paths through which each column was defined
     # * no_identifier Don't show the identified_by columns for an EntityType
 
-    class ABSORPTION
+    class Absorption
       def initialize(vocabulary, *options)  #:nodoc:
         @vocabulary = vocabulary
         @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
@@ -28,6 +29,7 @@ module ActiveFacts
       end
 
       def generate(out = $>)  #:nodoc:
+	@out = out
         no_absorption = 0
         single_absorption_vts = 0
         single_absorption_ets = 0
@@ -45,7 +47,7 @@ module ActiveFacts
         pk = indices.select(&:is_primary)[0]
         indices = indices.clone
         indices.delete pk
-        puts "#{object_type.name}: #{
+        @out.puts "#{object_type.name}: #{
 #            "[#{object_type.indices.size} indices] "
 #          } #{
             object_type.columns.sort_by do |column|
@@ -55,7 +57,7 @@ module ActiveFacts
                 [pk && pk.columns.include?(column) ? "*" : nil] +
                 (0...indices.size).select{|i| indices[i].columns.include?(column)}.map{|i| (i+1).to_i }
               index_nrs.compact!
-              (@paths ? column.references.map{|r| r.to_names}.flatten : column.name(nil)) * "." +
+              (@paths ? column.references.map{|r| r.to_names}.flatten : column.name(nil)) * '.' +
                 (index_nrs.empty? ? "" : "["+index_nrs*""+"]")
             end*", "
           }"
@@ -65,3 +67,4 @@ module ActiveFacts
   end
 end
 
+ActiveFacts::Registry.generator('absorption', ActiveFacts::Generate::Absorption)

data/lib/activefacts/generate/cql.rb

@@ -5,14 +5,15 @@
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
 require 'activefacts/vocabulary'
-require 'activefacts/generate/ordered'
+require 'activefacts/registry'
+require 'activefacts/generate/helpers/ordered'
 
 module ActiveFacts
   module Generate #:nodoc:
     # Generate CQL for an ActiveFacts vocabulary.
     # Invoke as
     #   afgen --cql <file>.cql
-    class CQL < OrderedDumper
+    class CQL < Helpers::OrderedDumper
     private
       def vocabulary_start(vocabulary)
         puts "vocabulary #{vocabulary.name};\n\n"
@@ -26,35 +27,7 @@ module ActiveFacts
       end
 
       def unit_dump unit
-        if !unit.ephemera_url
-          if unit.coefficient
-            # REVISIT: Use a smarter algorithm to switch to exponential form when there'd be lots of zeroes.
-            print unit.coefficient.numerator.to_s('F')
-            if d = unit.coefficient.denominator and d != 1
-              print "/#{d}"
-            end
-            print ' '
-          else
-            print '1 '
-          end
-        end
-
-        print(unit.
-          all_derivation_as_derived_unit.
-          # REVISIT: Sort base units
-          # REVISIT: convert negative powers to division?
-          map do |der|
-            base = der.base_unit
-            "#{base.name}#{der.exponent and der.exponent != 1 ? "^#{der.exponent}" : ''} "
-          end*''
-        )
-        if o = unit.offset and o != 0
-          print "+ #{o.to_s('F')} "
-        end
-        print "converts to #{unit.name}#{unit.plural_name ? '/'+unit.plural_name : ''}"
-        print " approximately" if unit.coefficient and !unit.coefficient.is_precise
-        print " ephemera #{unit.ephemera_url}" if unit.ephemera_url
-        puts ";"
+	puts unit.as_cql
       end
 
       def units_end
@@ -76,7 +49,7 @@ module ActiveFacts
           o.all_role.size == 0 &&
           !o.is_independent &&
           !o.value_constraint &&
-          o.all_context_note.size == 0 &&
+          o.all_context_note_as_relevant_concept.size == 0 &&
           o.all_instance.size == 0
         # No need to dump it if the only thing it does is be a supertype; it'll be created automatically
         # return if o.all_value_type_as_supertype.size == 0
@@ -104,28 +77,26 @@ module ActiveFacts
         #  o.all_role.size != 0
 =end
 
-        parameters =
-          [ o.length != 0 || o.scale != 0 ? o.length : nil,
-            o.scale != 0 ? o.scale : nil
-          ].compact
-        parameters = parameters.length > 0 ? "("+parameters.join(",")+")" : ""
+	puts o.as_cql
+      end
 
-        puts "#{o.name
-          } #{
-            (o.is_independent ? '[independent] ' : '')
-          }is written as #{
-            (o.supertype || o).name
-          }#{
-            parameters
-          }#{
-            o.unit && " "+o.unit.name
-          }#{
-            o.value_constraint && " "+o.value_constraint.describe
-          };"
+      def entity_type_dump(o)
+	@object_types_dumped[o] = true
+	pi = o.preferred_identifier
+
+	supers = o.supertypes
+	if (supers.size > 0)
+	  # Ignore identification by a supertype:
+	  pi = nil if pi && pi.role_sequence.all_role_ref.detect{|rr| rr.role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) }
+	  subtype_dump(o, supers, pi)
+	else
+	  non_subtype_dump(o, pi)
+	end
+	@constraints_used[pi] = true
       end
 
       def append_ring_to_reading(reading, ring)
-        reading << " [#{(ring.ring_type.scan(/[A-Z][a-z]*/)*", ").downcase}]"
+        reading << " [#{(ring.ring_type.scan(/StronglyIntransitive|[A-Z][a-z]*/)*", ").downcase}]"
       end
 
       def mapping_pragma(entity_type, ignore_independence = false)
@@ -245,6 +216,9 @@ module ActiveFacts
         end
         (entity_type.is_independent ? ' independent' : '') +
           " identified by its #{value_residual}#{constraint_text}#{mapping_pragma(entity_type, true)}" +
+	  entity_type.all_context_note_as_relevant_concept.map do |cn|
+	    cn.verbalise
+	  end.join("\n") +
           (fact_readings.size > 0 ? " where\n\t" : "") +
           fact_readings*",\n\t"
       end
@@ -279,6 +253,9 @@ module ActiveFacts
         (entity_type.is_independent ? ' independent' : '') +
           " identified by #{ irn*" and " }" +
           mapping_pragma(entity_type, true) +
+	  entity_type.all_context_note_as_relevant_concept.map do |cn|
+	    cn.verbalise
+	  end.join("\n") +
           " where\n\t"+identifying_fact_text
       end
 
@@ -367,14 +344,14 @@ module ActiveFacts
         verbaliser = ActiveFacts::Metamodel::Verbaliser.new
         verbaliser.alternate_readings fact_type.all_reading
         pr = fact_type.preferred_reading
-        if (pr.role_sequence.all_role_ref.to_a[0].join_role)
+        if (pr.role_sequence.all_role_ref.to_a[0].play)
           verbaliser.prepare_role_sequence pr.role_sequence
         end
         verbaliser.create_subscripts(:rolenames)
 
         print(fact_readings_with_constraints(verbaliser, fact_type)*",\n\t")
-        if (pr.role_sequence.all_role_ref.to_a[0].join_role)
-          print ":\n\t"+verbaliser.verbalise_over_role_sequence(pr.role_sequence)
+        if (pr.role_sequence.all_role_ref.to_a[0].play)
+          print " where\n\t"+verbaliser.verbalise_over_role_sequence(pr.role_sequence)
         end
         puts(';')
       end
@@ -408,13 +385,13 @@ module ActiveFacts
         # having no exact match, but having instead exactly one role of the same player in the readings.
 
         verbaliser = ActiveFacts::Metamodel::Verbaliser.new
-        # For a mandatory constraint (min_frequency == 1, max == nil or 1) any subtyping join is over the proximate role player
-        # For all other presence constraints any subtyping join is over the counterpart player
+        # For a mandatory constraint (min_frequency == 1, max == nil or 1) any subtyping step is over the proximate role player
+        # For all other presence constraints any subtyping step is over the counterpart player
         role_proximity = c.min_frequency == 1 && [nil, 1].include?(c.max_frequency) ? :proximate : :counterpart
         if role_proximity == :proximate
-          verbaliser.role_refs_are_subtype_joined(c.role_sequence)
+          verbaliser.role_refs_have_subtype_steps(c.role_sequence)
         else
-          join_over, joined_roles = ActiveFacts::Metamodel.join_roles_over(c.role_sequence.all_role_ref.map{|rr|rr.role}, role_proximity)
+          join_over, joined_roles = ActiveFacts::Metamodel.plays_over(c.role_sequence.all_role_ref.map{|rr|rr.role}, role_proximity)
           verbaliser.roles_have_same_player(joined_roles) if join_over
         end
 
@@ -433,7 +410,7 @@ module ActiveFacts
           pl = (min&&min>1)||(max&&max>1) ? 's' : ''
           puts \
             "each #{players.size > 1 ? "combination " : ""}#{players*", "} occurs #{c.frequency} time#{pl} in\n\t"+
-            "#{expanded_readings*",\n\t"};"
+            "#{Array(expanded_readings)*",\n\t"};"
         end
       end
 
@@ -445,14 +422,14 @@ module ActiveFacts
 
         # Tell the verbaliser all we know, so it can figure out which players to subscript:
         players = []
-        debug :subscript, "Preparing join across projected roles in set comparison constraint" do
+        debug :subscript, "Preparing query across projected roles in set comparison constraint" do
           transposed_role_refs.each do |role_refs|
-            verbaliser.role_refs_are_subtype_joined role_refs
-            join_over, = ActiveFacts::Metamodel.join_roles_over(role_refs.map{|rr| rr.role})
+            verbaliser.role_refs_have_subtype_steps role_refs
+            join_over, = ActiveFacts::Metamodel.plays_over(role_refs.map{|rr| rr.role})
             players << join_over
           end
         end
-        debug :subscript, "Preparing join between roles in set comparison constraint" do
+        debug :subscript, "Preparing query between roles in set comparison constraint" do
           role_sequences.each do |role_sequence|
             debug :subscript, "role sequence is #{role_sequence.describe}" do
               verbaliser.prepare_role_sequence role_sequence
@@ -461,8 +438,8 @@ module ActiveFacts
         end
         verbaliser.create_subscripts :normal
 
-        if role_sequences.detect{|scr| scr.all_role_ref.detect{|rr| rr.join_role}}
-          # This set constraint has an explicit join. Verbalise it.
+        if role_sequences.detect{|scr| scr.all_role_ref.detect{|rr| rr.play}}
+          # This set constraint has an explicit query. Verbalise it.
 
           readings_list = role_sequences.
             map do |rs|
@@ -480,7 +457,7 @@ module ActiveFacts
           # Internal check: We must have located the players here
           if i = players.index(nil)
             rrs = transposed_role_refs[i]
-            raise "Internal error detecting constrained object types in join involving #{rrs.map{|rr| rr.role.fact_type.default_reading}.uniq*', '}"
+            raise "Internal error detecting constrained object types in query involving #{rrs.map{|rr| rr.role.fact_type.default_reading}.uniq*', '}"
           end
 
           # Loose binding will apply only to the constrained roles, not to all roles. Not handled here.
@@ -499,7 +476,7 @@ module ActiveFacts
           return
         end
 
-        # A constrained role may involve a subtyping join. We substitute the name of the supertype for all occurrences.
+        # A constrained role may involve a subtyping step. We substitute the name of the supertype for all occurrences.
         players = transposed_role_refs.map{|role_refs| common_supertype(role_refs.map{|rr| rr.role.object_type})}
         raise "Constraint must cover matching roles" if players.compact.size < players.size
 
@@ -507,15 +484,15 @@ module ActiveFacts
           map do |scr|
             # verbaliser.verbalise_over_role_sequence(scr.role_sequence)
             # REVISIT: verbalise_over_role_sequence cannot do what we need here, because of the
-            # possibility of subtyping joins in the constrained roles across the different scr's
+            # possibility of subtyping steps in the constrained roles across the different scr's
             # The following code uses "players" and "constrained_roles" to create substitutions.
-            # These should instead be passed to the verbaliser (one join node per index, role_refs for each).
+            # These should instead be passed to the verbaliser (one variable per index, role_refs for each).
             fact_types_processed = {}
             constrained_roles = scr.role_sequence.all_role_ref_in_order.map{|rr| rr.role}
-            join_over, joined_roles = *Metamodel.join_roles_over(constrained_roles)
+            join_over, joined_roles = *Metamodel.plays_over(constrained_roles)
             constrained_roles.map do |constrained_role|
               fact_type = constrained_role.fact_type
-              next nil if fact_types_processed[fact_type] # Don't emit the same fact type twice (in case of objectification join)
+              next nil if fact_types_processed[fact_type] # Don't emit the same fact type twice (in case of objectification step)
               fact_types_processed[fact_type] = true
               reading = fact_type.reading_preferably_starting_with_role(constrained_role)
               expand_constrained(verbaliser, reading, constrained_roles, players)
@@ -540,7 +517,7 @@ module ActiveFacts
         transposed_role_refs = [c.subset_role_sequence, c.superset_role_sequence].map{|rs| rs.all_role_ref_in_order.to_a}.transpose
 
         verbaliser = ActiveFacts::Metamodel::Verbaliser.new
-        transposed_role_refs.each { |role_refs| verbaliser.role_refs_are_subtype_joined role_refs }
+        transposed_role_refs.each { |role_refs| verbaliser.role_refs_have_subtype_steps role_refs }
         verbaliser.prepare_role_sequence c.subset_role_sequence
         verbaliser.prepare_role_sequence c.superset_role_sequence
         verbaliser.create_subscripts :normal
@@ -558,18 +535,18 @@ module ActiveFacts
       end
 
       def constraint_dump(c)
-          case c
-          when ActiveFacts::Metamodel::PresenceConstraint
-            dump_presence_constraint(c)
-          when ActiveFacts::Metamodel::RingConstraint
-            dump_ring_constraint(c)
-          when ActiveFacts::Metamodel::SetComparisonConstraint # includes SetExclusionConstraint, SetEqualityConstraint
-            dump_set_comparison_constraint(c)
-          when ActiveFacts::Metamodel::SubsetConstraint
-            dump_subset_constraint(c)
-          else
-            "#{c.class.basename} #{c.name}: unhandled constraint type"
-          end
+	case c
+	when ActiveFacts::Metamodel::PresenceConstraint
+	  dump_presence_constraint(c)
+	when ActiveFacts::Metamodel::RingConstraint
+	  dump_ring_constraint(c)
+	when ActiveFacts::Metamodel::SetComparisonConstraint # includes SetExclusionConstraint, SetEqualityConstraint
+	  dump_set_comparison_constraint(c)
+	when ActiveFacts::Metamodel::SubsetConstraint
+	  dump_subset_constraint(c)
+	else
+	  "#{c.class.basename} #{c.name}: unhandled constraint type"
+	end
       end
 
       # Find the common supertype of these object_types.
@@ -630,6 +607,7 @@ module ActiveFacts
         end
 
         expanded = verbaliser.expand_reading(reading, frequency_constraints, define_role_names, value_constraints)
+	expanded = "it is not the case that "+expanded if (reading.is_negative)
 
         if (ft_rings = @ring_constraints_by_fact[reading.fact_type]) &&
            (ring = ft_rings.detect{|rc| !@constraints_used[rc]})
@@ -651,9 +629,87 @@ module ActiveFacts
           end
         frequency_constraints = [] unless frequency_constraints.detect{|fc| fc[0] != "some" }
 
-        verbaliser.expand_reading(reading, frequency_constraints)
+	expanded = verbaliser.expand_reading(reading, frequency_constraints)
+	expanded = "it is not the case that "+expanded if (reading.is_negative)
+	expanded
       end
 
     end
   end
+
+  module Metamodel
+    class ValueType
+      def as_cql
+        parameters =
+          [ length != 0 || scale != 0 ? length : nil,
+            scale != 0 ? scale : nil
+          ].compact
+        parameters = parameters.length > 0 ? "("+parameters.join(",")+")" : ""
+
+        "#{name
+          } #{
+            (is_independent ? '[independent] ' : '')
+          }is written as #{
+            (supertype || self).name
+          }#{
+            parameters
+          }#{
+            unit && " "+unit.name
+          }#{
+	    all_context_note_as_relevant_concept.map do |cn|
+	      cn.verbalise
+	    end.join("\n")
+	  }#{
+            value_constraint && " "+value_constraint.describe
+          };"
+      end
+    end
+
+    class Unit
+      def as_cql
+        if !ephemera_url
+          if coefficient
+            # REVISIT: Use a smarter algorithm to switch to exponential form when there'd be lots of zeroes.
+            coefficient.numerator.to_s('F') +
+
+            if d = coefficient.denominator and d != 1
+              "/#{d}"
+	    else
+	      ''
+            end +
+
+            ' '
+          else
+            '1 '
+          end
+	else
+	  ''
+        end +
+
+	all_derivation_as_derived_unit.
+          # REVISIT: Sort base units
+          # REVISIT: convert negative powers to division?
+          map do |der|
+            base = der.base_unit
+            "#{base.name}#{der.exponent and der.exponent != 1 ? "^#{der.exponent}" : ''} "
+          end*'' +
+
+        if o = offset and o != 0
+          "+ #{o.to_s('F')} "
+	else
+	  ''
+        end +
+
+        "converts to #{name}#{plural_name ? '/'+plural_name : ''}" +
+
+	(coefficient && !coefficient.is_precise ?  ' approximately' : '') +
+
+	(ephemera_url ? " ephemera #{ephemera_url}" : '') +
+
+        ';'
+      end
+    end
+  end
 end
+
+ActiveFacts::Registry.generator('cql', ActiveFacts::Generate::CQL)