activefacts 0.7.3 → 0.8.5

data/lib/activefacts/cql/parser.rb

@@ -11,80 +11,147 @@ require 'treetop'
 require 'activefacts/cql/LexicalRules'
 require 'activefacts/cql/Language/English'
 require 'activefacts/cql/Expressions'
+require 'activefacts/cql/Terms'
 require 'activefacts/cql/Concepts'
-require 'activefacts/cql/DataTypes'
+require 'activefacts/cql/ValueTypes'
 require 'activefacts/cql/FactTypes'
+require 'activefacts/cql/Context'
 require 'activefacts/cql/CQLParser'
 
 module ActiveFacts
-  # Extend the generated parser:
-  class CQLParser
-    include ActiveFacts
-
-    # Repeatedly parse rule_name until all input is consumed,
-    # returning an array of syntax trees for each definition.
-    def parse_all(input, rule_name = nil, &block)
-      self.root = rule_name if rule_name
-
-      @index = 0  # Byte offset to start next parse
-      self.consume_all_input = false
-      results = []
-      begin
-        node = parse(input, :index => @index)
-        return nil unless node
-        node = block.call(node) if block
-        results << node if node
-      end until self.index == @input_length
-      results
-    end
+  module CQL
+    # Extend the generated parser:
+    class Parser < CQLParser
+      include ActiveFacts
+
+      class BlackHole
+        def method_missing(m, *p, &b)
+          self    # Make all calls vanish
+        end
+      end
+
+      class InputProxy < Object
+        attr_reader :context
+
+        def initialize(input, context)
+          @input = input
+          @context = context
+        end
+
+        def length
+          @input.length
+        end
+
+        def size
+          length
+        end
+
+        def [](*a)
+          @input[*a]
+        end
+
+        def index(*a)
+          @input.index(*a)
+        end
+      end
+
+      def context
+        @context ||= BlackHole.new
+      end
 
-    def definition(node)
-      name, ast = *node.value
-      kind, *value = *ast
-
-      begin
-        debug "CQL: Processing definition #{[kind, name].compact*" "}" do
-          case kind
-          when :vocabulary
-            [kind, name]
-          when :data_type
-            data_type(name, value)
-          when :entity_type
-            supertypes = value.shift
-            entity_type(name, supertypes, value)
-          when :fact_type
-            f = fact_type(name, value)
-          when :constraint
-            ast
+      def parse(input, options = {})
+        input = InputProxy.new(input, context) unless input.respond_to?(:context)
+        super(input, options)
+      end
+
+      # Repeatedly parse rule_name until all input is consumed,
+      # returning an array of syntax trees for each definition.
+      def parse_all(input, rule_name = nil, &block)
+        self.root = rule_name if rule_name
+
+        @index = 0  # Byte offset to start next parse
+        self.consume_all_input = false
+        results = []
+        begin
+          node = parse(InputProxy.new(input, context), :index => @index)
+          return nil unless node
+          node = block.call(node) if block
+          results << node if node
+        end until self.index == @input_length
+        results
+      end
+
+      def definition(node)
+        name, ast = *node.value
+        kind, *value = *ast
+
+        begin
+          debug "CQL: Processing definition #{[kind, name].compact*" "}" do
+            case kind
+            when :vocabulary
+              [kind, name]
+            when :value_type
+              value_type_ast(name, value)
+            when :entity_type
+              supertypes = value.shift
+              entity_type_ast(name, supertypes, value)
+            when :fact_type
+              f = fact_type_ast(name, value)
+            when :unit
+              ast
+            when :constraint
+              ast
+            else
+              raise "CQL: internal error, unknown definition kind"
+            end
           end
         end
+      rescue => e
+        raise "in #{kind.to_s.camelcase(true)} definition, #{e.message}:\n\t#{node.text_value}" +
+          (ENV['DEBUG'] =~ /\bexception\b/ ? "\nfrom\t"+e.backtrace*"\n\t" : "")
       end
-    rescue => e
-      raise "in #{kind.to_s.camelcase(true)} definition, #{e.message}:\n\t#{node.text_value}"
-    end
 
-    def data_type(name, value)
-      # REVISIT: Massage/check data type here?
-      [:data_type, name, *value]
-    end
+      def value_type_ast(name, value)
+        # REVISIT: Massage/check value type here?
+        [:value_type, name, *value]
+      end
 
-    def entity_type(name, supertypes, value)
-      #print "entity_type parameters for #{name}: "; p value
-      identification, clauses = *value
-      clauses ||= []
+      def entity_type_ast(name, supertypes, value)
+        #print "entity_type parameters for #{name}: "; p value
+        identification, mapping_pragmas, clauses = *value
+        clauses ||= []
 
-      # raise "Entity type clauses must all be fact types" if clauses.detect{|c| c[0] != :fact_clause }
+        # raise "Entity type clauses must all be fact types" if clauses.detect{|c| c[0] != :fact_clause }
 
-      [:entity_type, name, supertypes, identification, clauses]
-    end
+        [:entity_type, name, supertypes, identification, mapping_pragmas, clauses]
+      end
+
+      def fact_type_ast(name, value)
+        clauses, conditions = value
+
+        if conditions.empty? && includes_literals(clauses)
+          [:fact, nil, clauses]
+        elsif clauses.size == 1 &&
+            (popname = clauses[0][2]).size == 1 &&
+            popname[0].keys == [:word] &&
+            includes_literals(conditions)
+          [:fact, popname[0][:word], conditions]
+        else
+          [:fact_type, name, clauses, conditions]
+        end
+      end
 
-    def fact_type(name, value)
-      defined_readings, *clauses = value
+      def includes_literals(clauses)
+        clauses.detect do |clause|
+          raise "alternate clauses are not yet supported" if clause[0] == :"||"
+          fc, qualifiers, phrases, context_note = *clause
+          phrases.detect{|w| w[:literal]}
+        end
+      end
 
-      [:fact_type, name, defined_readings, clauses]
     end
 
   end
 
-  Polyglot.register('cql', CQLParser)
+  Polyglot.register('cql', CQL::Parser)
 end

data/lib/activefacts/generate/absorption.rb

@@ -34,7 +34,7 @@ module ActiveFacts
         multi_absorption_vts = 0
         multi_absorption_ets = 0
         @vocabulary.tables
-        @vocabulary.all_feature.sort_by{|c| c.name}.each do |o|
+        @vocabulary.all_concept.sort_by{|c| c.name}.each do |o|
           next if !o.is_table
           show(o)
         end

data/lib/activefacts/generate/cql.rb

@@ -31,33 +31,22 @@ module ActiveFacts
 
       def value_type_dump(o)
         return unless o.supertype    # An imported type
+
+        # REVISIT: A ValueType that is only used as a reference mode need not be emitted here. We haven't detected this situation yet however...
+
         if o.name == o.supertype.name
-            # In ActiveFacts, parameterising a ValueType will create a new datatype
-            # throw Can't handle parameterized value type of same name as its datatype" if ...
+            # In ActiveFacts, parameterising a ValueType will create a new ValueType
+            # throw Can't handle parameterized value type of same name as its ValueType" if ...
         end
 
         parameters =
           [ o.length != 0 || o.scale != 0 ? o.length : nil,
             o.scale != 0 ? o.scale : nil
           ].compact
-        parameters = parameters.length > 0 ? "("+parameters.join(",")+")" : "()"
-
-                  #" restricted to {#{(allowed_values.map{|r| r.inspect}*", ").gsub('"',"'")}}")
+        parameters = parameters.length > 0 ? "("+parameters.join(",")+")" : ""
 
         puts "#{o.name} is written as #{o.supertype.name}#{ parameters }#{
-            o.value_restriction ? " restricted to {#{
-              o.value_restriction.all_allowed_range.sort_by{|ar|
-                    ((min = ar.value_range.minimum_bound) && min.value) ||
-                      ((max = ar.value_range.maximum_bound) && max.value)
-                  }.map{|ar|
-                  # REVISIT: Need to display as string or numeric according to type here...
-                  min = ar.value_range.minimum_bound
-                  max = ar.value_range.maximum_bound
-
-                  (min ? min.value : "") +
-                    (min.value != (max&&max.value) ? (".." + (max ? max.value : "")) : "")
-                }*", "
-            }}" : ""
+            o.value_restriction && " "+o.value_restriction.describe
           };"
       end
 
@@ -65,6 +54,18 @@ module ActiveFacts
         reading << " [#{(ring.ring_type.scan(/[A-Z][a-z]*/)*", ").downcase}]"
       end
 
+      def mapping_pragma(entity_type)
+        ti = entity_type.all_type_inheritance_as_subtype
+        assimilation = ti.map{|t| t.assimilation }.compact[0]
+        return "" unless entity_type.is_independent || assimilation
+        " [" +
+          [
+            entity_type.is_independent ? "independent" : nil,
+            assimilation || nil
+          ].compact*", " +
+        "]"
+      end
+
       def identified_by_roles_and_facts(entity_type, identifying_roles, identifying_facts, preferred_readings)
         identifying_role_names = identifying_roles.map{|role|
             preferred_role_ref = preferred_readings[role.fact_type].role_sequence.all_role_ref.detect{|reading_rr|
@@ -94,13 +95,16 @@ module ActiveFacts
         # Just beware that readings having the same players will be considered to be of the same fact type, even if they're not.
 
         # Detect standard reference-mode scenarios
-        ft = identifying_facts[0]
+        external_identifying_facts = identifying_facts - [entity_type.fact_type]
+        ft = external_identifying_facts[0]
         fact_constraints = nil
-        ftr = ft.all_role.sort_by{|role| role.ordinal}
-        if identifying_facts.size == 1 and
+        ftr = ft && ft.all_role.sort_by{|role| role.ordinal}
+        if external_identifying_facts.size == 1 and
           entity_role = ftr[n = (ftr[0].concept == entity_type ? 0 : 1)] and
           value_role = ftr[1-n] and
-          value_name = value_role.concept.name and
+          value_player = value_role.concept and
+          value_player.is_a?(ActiveFacts::Metamodel::ValueType) and
+          value_name = value_player.name and
           residual = value_name.gsub(%r{#{entity_role.concept.name}},'') and
           residual != '' and
           residual != value_name
@@ -111,13 +115,13 @@ module ActiveFacts
           # Detect standard reference-mode readings:
           forward_reading = reverse_reading = nil
           ft.all_reading.each do |reading|
-            if reading.reading_text =~ /^\{(\d)\} has \{\d\}$/
+            if reading.text =~ /^\{(\d)\} has \{\d\}$/
               if reading.role_sequence.all_role_ref.detect{|rr| rr.ordinal == $1.to_i}.role == entity_role
                 forward_reading = reading
               else
                 reverse_reading = reading
               end
-            elsif reading.reading_text =~ /^\{(\d)\} is of \{\d\}$/
+            elsif reading.text =~ /^\{(\d)\} is of \{\d\}$/
               if reading.role_sequence.all_role_ref.detect{|rr| rr.ordinal == $1.to_i}.role == value_role
                 reverse_reading = reading
               else
@@ -141,6 +145,7 @@ module ActiveFacts
                 @constraints_used[pc] = true
               end
             end
+            fact_constraints += Array(@presence_constraints_by_fact[entity_type.fact_type])
 
             @fact_types_dumped[ft] = true
 
@@ -148,10 +153,19 @@ module ActiveFacts
             other_readings = ft.all_reading - [forward_reading] - [reverse_reading]
             debug :mode, "--- other_readings.size now = #{other_readings.size}" if other_readings.size > 0
 
-            fact_text = other_readings.map do |reading|
-              expanded_reading(reading, fact_constraints, true)
-            end*",\n\t"
-            return " identified by its #{residual}" +
+            fact_text = (
+              other_readings.map do |reading|
+                expanded_reading(reading, fact_constraints, true)
+              end +
+              (entity_type.fact_type ?
+                fact_readings_with_constraints(entity_type.fact_type, fact_constraints) : []
+              )
+            )*",\n\t"
+
+            restriction = value_role.role_value_restriction || value_player.value_restriction
+            # REVISIT: If both restrictions apply and differ, we can't use a reference mode
+            restriction_text = restriction ? " "+restriction.describe : ""
+            return " identified by its #{residual}#{restriction_text}#{mapping_pragma(entity_type)}" +
               (fact_text != "" ? " where\n\t" + fact_text : "")
           end
         end
@@ -163,6 +177,7 @@ module ActiveFacts
             }.flatten*",\n\t"
 
         " identified by #{ identifying_role_names*" and " }" +
+          mapping_pragma(entity_type) +
           " where\n\t"+@identifying_fact_text
       end
 
@@ -183,7 +198,10 @@ module ActiveFacts
         print "#{o.name} is a kind of #{ o.supertypes.map(&:name)*", " }"
         if pi
           print identified_by(o, pi)
+        else
+          print mapping_pragma(o)
         end
+
         # If there's a preferred_identifier for this subtype, identifying readings were emitted
         print((pi ? "," : " where") + "\n\t" + fact_readings(o.fact_type)) if o.fact_type
         puts ";\n"
@@ -191,7 +209,7 @@ module ActiveFacts
 
       def non_subtype_dump(o, pi)
         print "#{o.name} is" + identified_by(o, pi)
-        print(" where\n\t"+ fact_readings(o.fact_type)) if o.fact_type
+#        print(" where\n\t"+ fact_readings(o.fact_type)) if o.fact_type
         puts ";\n"
       end
 
@@ -209,6 +227,7 @@ module ActiveFacts
           pi = fact_type.entity_type.preferred_identifier
           if pi && primary_supertype && primary_supertype.preferred_identifier != pi
             print identified_by(o, pi)
+            # REVISIT: This *has* to be wrong. When you fix it, remember mapping_pragmas!
             print ";\n"
           end
         end
@@ -244,55 +263,25 @@ module ActiveFacts
       end
 
       def dump_presence_constraint(c)
-        roles = c.role_sequence.all_role_ref.map{|rr| rr.role }
-
-        # REVISIT: If only one role is covered and it's mandatory >=1 constraint, use SOME/THAT form:
-        # each Bug SOME Tester logged THAT Bug;
-        players = c.role_sequence.all_role_ref.map{|rr| rr.role.concept.name}.uniq
-
-        fact_types = c.role_sequence.all_role_ref.map{|rr| rr.role.fact_type}.uniq
-        puts \
-          "each #{players.size > 1 ? "combination " : ""}#{players*", "} occurs #{c.frequency} time in\n\t"+
-          "#{fact_types.map{|ft| ft.default_reading([], nil)}*",\n\t"}" +
-            ";"
-
-=begin
-          # More than one fact type involved, an external constraint.
-            fact_type = rr.role.fact_type
-          # or all facts are binary and the counterparts of the roles are.
-          puts "// REVISIT: " +
-          if (player = roleplayer_subclass(roles))
-            "#{player.name} must play #{c.frequency} of "
-          else
-            counterparts = roles.map{|r|
-                r.fact_type.all_role[r.fact_type.all_role[0] != r ? 0 : -1]
-              }
-            player = roleplayer_subclass(counterparts)
-            "#{c.frequency} #{player ? player.name : "UNKNOWN" } exists for each "
-          end +
-          "#{
-              c.role_sequence.all_role_ref.map{|rr|
-                "'#{rr.role.fact_type.default_reading([], nil)}'"
-              }*", "
-            }"
-=end
-
-=begin
-        puts \
-          "FOR each #{players*", "}" +
-          (c.role_sequence.all_role_ref.size > 1 ? " "+c.frequency+" of these holds" : "") + "\n\t"+
-          "#{c.role_sequence.all_role_ref.map{|rr|
-            role = rr.role
-            fact_type = role.fact_type
-            some_that = Array.new(fact_type.all_role.size, "some")
-            c.role_sequence.all_role_ref.each{|rr2|
-              next if rr2.role.fact_type != fact_type
-              some_that[fact_type.all_role.index(role)] = "that"
-            }
-            rr.role.fact_type.default_reading(some_that, nil)
-          }*",\n\t"}" +
-          ";"
-=end
+        if c.min_frequency == 1 && c.max_frequency == nil and c.role_sequence.all_role_ref.size == 2
+          # REVISIT: Implement the "either... or" syntax for a simple external mandatory constraint
+          puts \
+            "either #{
+              c.role_sequence.all_role_ref.map { |rr|
+                rr.role.fact_type.default_reading([], nil)
+              }*" or "
+            };"
+        else
+          # REVISIT: If only one role is covered and it's mandatory >=1 constraint, use SOME/THAT form:
+          # for each Bug SOME Tester logged THAT Bug;
+          roles = c.role_sequence.all_role_ref.map{|rr| rr.role }
+          players = c.role_sequence.all_role_ref.map{|rr| rr.role.concept.name}.uniq
+          fact_types = c.role_sequence.all_role_ref.map{|rr| rr.role.fact_type}.uniq
+          puts \
+            "each #{players.size > 1 ? "combination " : ""}#{players*", "} occurs #{c.frequency} time in\n\t"+
+            "#{fact_types.map{|ft| ft.default_reading([], nil)}*",\n\t"}" +
+              ";"
+        end
       end
 
       # Find the common supertype of these concepts.
@@ -331,11 +320,13 @@ module ActiveFacts
         # puts "#{c.class.basename} has #{role_seq_count} scr's: #{scrs.map{|scr| "("+scr.role_sequence.all_role_ref.map{|rr| rr.role.concept.name}*", "+")"}*", "}"
 
         players_differ = []   # Record which players are also played by subclasses
-        players = (0...player_count).map do |pi|
-          # Find the common supertype of the players of the pi'th role in each sequence
-          concepts = scrs.map{|r| r.role_sequence.all_role_ref.sort_by{|rr| rr.ordinal}[pi].role.concept }
-          player, players_differ[pi] = common_supertype(concepts)
-          raise "Role sequences of #{c.class.basename} must have concepts matching #{concepts.map(&:name)*","} in position #{pi}" unless player
+        players = (0...player_count).map do |pindex|
+          # Find the common supertype of the players of the pindex'th role in each sequence
+          concepts = scrs.map do |r|
+            r.role_sequence.all_role_ref.sort_by{|rr| rr.ordinal}[pindex].role.concept
+          end
+          player, players_differ[pindex] = common_supertype(concepts)
+          raise "Role sequences of #{c.class.basename} must have concepts matching #{concepts.map(&:name)*","} in position #{pindex}" unless player
           player
         end
         #puts "#{c.class.basename} has players #{players.map{|p| p.name}*", "}"
@@ -349,22 +340,42 @@ module ActiveFacts
           return
         end
 
-        mode = c.is_mandatory ? "exactly one" : "at most one"
-        puts "for each #{players.map{|p| p.name}*", "} #{mode} of these holds:\n\t" +
-          (scrs.map do |scr|
-            constrained_roles = scr.role_sequence.all_role_ref.map{|rr| rr.role }
-            fact_types = constrained_roles.map{|r| r.fact_type }.uniq
-
-            fact_types.map do |fact_type|
-              # REVISIT: future: Use "THAT" and "SOME" only when:
-              # - the role player occurs twice in the reading, or
-              # - is a subclass of the constrained concept, or
-              reading = fact_type.preferred_reading
-              expand_constrained(reading, constrained_roles, players, players_differ)
-            end * " and "
-
-          end*",\n\t"
-          )+';'
+        if scrs.size == 2 && c.is_mandatory
+          puts "either " +
+            ( scrs.map do |scr|
+                constrained_roles = scr.role_sequence.all_role_ref.map{|rr| rr.role }
+                fact_types = constrained_roles.map{|r| r.fact_type }.uniq
+
+                fact_types.map do |fact_type|
+                  # Choose a reading that starts with the input role (constrained role if none)
+                  reading = fact_type.all_reading.sort_by{|r| r.ordinal}.detect do |r|
+                      first_reading_role = r.role_sequence.all_role_ref.detect{|rr| rr.ordinal == 0}.role
+                      constrained_roles.include?(first_reading_role)
+                    end
+                  reading ||= fact_type.preferred_reading
+                  expand_constrained(reading, constrained_roles, players, players_differ)
+                end * " and "
+              end*" or "
+            ) +
+            " but not both;"
+        else
+          mode = c.is_mandatory ? "exactly one" : "at most one"
+          puts "for each #{players.map{|p| p.name}*", "} #{mode} of these holds:\n\t" +
+            (scrs.map do |scr|
+              constrained_roles = scr.role_sequence.all_role_ref.map{|rr| rr.role }
+              fact_types = constrained_roles.map{|r| r.fact_type }.uniq
+
+              fact_types.map do |fact_type|
+                # REVISIT: future: Use "THAT" and "SOME" only when:
+                # - the role player occurs twice in the reading, or
+                # - is a subclass of the constrained concept, or
+                reading = fact_type.preferred_reading
+                expand_constrained(reading, constrained_roles, players, players_differ)
+              end * " and "
+
+            end*",\n\t"
+            )+';'
+        end
       end
 
       # Expand this reading using (in)definite articles where needed
@@ -386,7 +397,7 @@ module ActiveFacts
           }
         frequency_constraints = [] unless frequency_constraints.detect{|fc| fc[0] != "some" }
 
-        #$stderr.puts "fact_type roles (#{fact_type.all_role.map{|r| r.concept.name}*","}) default_reading '#{fact_type.preferred_reading.reading_text}' roles (#{fact_type.preferred_reading.role_sequence.all_role_ref.map{|rr| rr.role.concept.name}*","}) #{frequency_constraints.inspect}"
+        #$stderr.puts "fact_type roles (#{fact_type.all_role.map{|r| r.concept.name}*","}) default_reading '#{fact_type.preferred_reading.text}' roles (#{fact_type.preferred_reading.role_sequence.all_role_ref.map{|rr| rr.role.concept.name}*","}) #{frequency_constraints.inspect}"
 
         # REVISIT: Make sure that we refer to the constrained players by their common supertype