activefacts-cql 1.7.1

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

@@ -0,0 +1,161 @@
+module ActiveFacts
+  module CQL
+    class Compiler < ActiveFacts::CQL::Parser
+
+      # 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 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 References
+        attr_reader :role_name
+        attr_accessor :rebound_to       # Loose binding may set this to another binding
+        attr_reader :variable
+        attr_accessor :instance         # When binding fact instances, the instance goes here
+
+        def initialize player, role_name = nil
+          @player = player
+          @role_name = role_name
+          @refs = []
+        end
+
+        def inspect
+          "#{@player.name}#{@role_name and @role_name.is_a?(Integer) ? " (#{@role_name})" : " (as #{@role_name})"}"
+        end
+
+        def key
+          "#{@player.name}#{@role_name && " (as #{@role_name})"}"
+        end
+
+        def <=>(other)
+          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
+      end
+
+      class CompilationContext
+        attr_accessor :vocabulary
+        attr_accessor :allowed_forward_terms
+        attr_accessor :left_contraction_allowed
+        attr_accessor :left_contractable_clause
+        attr_accessor :left_contraction_conjunction
+        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 = []
+          @bindings = {}
+          @player_by_role_name = {}
+          @left_contraction_allowed = false
+        end
+
+        # Look up this object_type by its name
+        def object_type(name)
+          constellation = @vocabulary.constellation
+          player = constellation.ObjectType[[@vocabulary_identifier, name]]
+
+          # Bind to an existing role which has a role name (that's why we bind those first)
+          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, :concept => :new)
+          end
+
+          player
+        end
+
+        # 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
+          cl = clauses.flatten
+          cl.each { |clause| clause.identify_players_with_role_name(self) }
+          cl.each { |clause| clause.identify_other_players(self) }
+          cl.each { |clause| clause.bind(self) }
+        end
+      end
+
+      class Definition
+        attr_accessor :constellation, :vocabulary, :tree
+        def compile
+          raise "#{self.class} should implement the compile method"
+        end
+
+        def to_s
+          @vocabulary ? "#{vocabulary.to_s}::" : ''
+        end
+
+        def source
+          @tree.text_value
+        end
+      end
+
+      class Vocabulary < Definition
+        def initialize name
+          @name = name
+        end
+
+        def compile
+          if @constellation.Vocabulary.size > 0
+	    @constellation.Topic @name
+	  else
+	    @constellation.Vocabulary @name
+	  end
+        end
+
+        def to_s
+          @name
+        end
+      end
+
+      class Import < Definition
+        def initialize parser, name, alias_hash
+          @parser = parser
+          @name = name
+          @alias_hash = alias_hash
+        end
+
+        def to_s
+          "#{@vocabulary.to_s} imports #{@alias_hash.map{|k,v| "#{k} as #{v}" }*', '};"
+        end
+
+        def compile
+          @parser.compile_import(@name, @alias_hash)
+        end
+      end
+
+      class ObjectType < Definition
+        attr_reader :name
+
+        def initialize name
+          @name = name
+        end
+
+        def to_s
+          "#{super}#{@name}"
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,174 @@
+module ActiveFacts
+  module CQL
+    class Compiler < ActiveFacts::CQL::Parser
+
+      class Unit < Definition
+        def initialize singular, plural, numerator, denominator, offset, base_units, approximately, ephemera_url
+          @singular = singular
+          @plural = plural
+          @numerator, @denominator = numerator, denominator
+          @offset = offset
+          @base_units = base_units  # An array of pairs, each [unit_name, power]
+          @approximately = approximately
+          @ephemera_url = ephemera_url
+        end
+
+        def compile
+          if (@numerator.to_f / @denominator.to_i != 1.0)
+            coefficient = @constellation.Coefficient(
+                @numerator,
+                @denominator.to_i,
+                !@approximately
+                # REVISIT: activefacts-api is complaining at present. The following is better and should work:
+                # :numerator => @numerator,
+                # :denominator => @denominator.to_i,
+                # :is_precise => !@approximately
+              )
+          else
+            coefficient = nil
+          end
+          @offset = nil if @offset.to_f == 0
+
+          trace :units, "Defining new unit #{@singular}#{@plural ? "/"+@plural : ""}" do
+            trace :units, "Coefficient is #{coefficient.numerator}#{coefficient.denominator != 1 ? "/#{coefficient.denominator}" : ""} #{coefficient.is_precise ? "exactly" : "approximately"}" if coefficient
+            trace :units, "Offset is #{@offset}" if @offset
+            raise "Redefinition of unit #{@singular}" if @constellation.Unit.values.detect{|u| u.name == @singular}
+            raise "Redefinition of unit #{@plural}" if @constellation.Unit.values.detect{|u| u.name == @plural}
+            unit = @constellation.Unit(:new,
+                :name => @singular,
+                :plural_name => @plural,
+                :coefficient => coefficient,
+                :offset => @offset,
+                :is_fundamental => @base_units.empty?,
+                :ephemera_url => @ephemera_url,
+                :vocabulary => @vocabulary
+              )
+            @base_units.each do |base_unit, exponent|
+              base = @constellation.Unit.values.detect{|u| u.name == base_unit || u.plural_name == base_unit }
+              trace :units, "Base unit #{base_unit}^#{exponent} #{base ? "" : "(implicitly fundamental)"}"
+              base ||= @constellation.Unit(:new, :name => base_unit, :is_fundamental => true, :vocabulary => @vocabulary)
+              @constellation.Derivation(:derived_unit => unit, :base_unit => base, :exponent => exponent)
+            end
+=begin
+            if @plural
+              plural_unit = @constellation.Unit(:new,
+                  :name => @plural,
+                  :is_fundamental => false,
+                  :vocabulary => @vocabulary
+                )
+              @constellation.Derivation(:derived_unit => plural_unit, :base_unit => unit, :exponent => 1)
+            end
+=end
+            unit
+          end
+        end
+
+        def inspect
+          to_s
+        end
+
+        def to_s
+          super + "Unit(#{
+            @singular
+          }#{
+            @plural ? '/'+@plural : ''
+          }) is #{
+            @numerator
+          }/#{
+            @denominator
+          }+#{
+            @offset
+          } #{
+            @base_units.map{|b,e|
+              b+'^'+e.to_s
+            }*'*'
+          }"
+        end
+      end
+
+      class ValueType < ObjectType
+        def initialize name, base, parameters, unit, value_constraint, pragmas, context_note, auto_assigned_at
+          super name
+          @base_type_name = base
+          @parameters = parameters
+          @unit = unit
+          @value_constraint = value_constraint
+          @pragmas = pragmas
+	  @context_note = context_note
+	  @auto_assigned_at = auto_assigned_at
+        end
+
+        def compile
+          length, scale = *@parameters
+
+          # 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)
+              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.is_independent = true if @pragmas.delete('independent')
+	  @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
+          vt.transaction_phase = @auto_assigned_at
+
+          unless @unit.empty?
+            unit_name, exponent = *@unit[0]
+            unit = @constellation.Name[unit_name].unit ||
+              @constellation.Name[unit_name].plural_named_unit
+            raise "Unit #{unit_name} for value type #{@name} is not defined" unless unit
+            if exponent != 1
+              base_unit = unit
+              unit_name = base_unit.name+"^#{exponent}"
+              unless unit = @constellation.Unit.detect{|k,v| v.name == unit_name } 
+                # Define a derived unit (these are skipped on output)
+                unit = @constellation.Unit(:new,
+                      :vocabulary => @vocabulary,
+                      :name => unit_name,
+                      :is_fundamental => false
+                    )
+                @constellation.Derivation(unit, base_unit).exponent = exponent
+              end
+            end
+            vt.unit = unit
+          end
+
+          if @value_constraint
+            @value_constraint.constellation = @constellation
+            vt.value_constraint = @value_constraint.compile
+          end
+
+	  if @context_note
+	    @context_note.compile(@constellation, vt)
+	  end
+
+          vt
+        end
+
+        def to_s
+          "ValueType: #{super} is written as #{
+              @base_type_name
+            }#{
+              @parameters.size > 0 ? "(#{ @parameters.map{|p|p.to_s}*', ' })" : ''
+            }#{
+              @unit && @unit.length > 0 ? " in #{@unit.inspect}" : ''
+            }#{
+              @value_constraint ? " "+@value_constraint.to_s : ''
+            }#{
+              @pragmas.size > 0 ? ", pragmas [#{@pragmas*','}]" : ''
+            };"
+        end
+      end
+    end
+  end
+end

data/lib/activefacts/cql/parser.rb

@@ -0,0 +1,234 @@
+#
+#       ActiveFacts CQL Parser.
+#       The parser turns CQL strings into abstract syntax trees ready for semantic analysis.
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+require 'rubygems'
+require 'treetop'
+
+# These are Treetop files, which Polyglot will compile on the fly if precompiled ones aren't found:
+
+require 'activefacts/cql/parser/CQLParser'
+
+module ActiveFacts
+  module CQL
+    class Parser < CQLParser
+    end
+  end
+end
+require 'activefacts/cql/parser/nodes'
+
+class Treetop::Runtime::SyntaxNode
+  def node_type
+    terminal? ? :keyword : :composite
+  end
+end
+
+module ActiveFacts
+  module CQL
+    module Terms
+      class SavedContext < Treetop::Runtime::SyntaxNode
+        attr_accessor :context
+      end
+    end
+
+    # Extend the generated parser:
+    class Parser
+      include ActiveFacts
+
+      # The Context manages some key information revealed or needed during parsing
+      # 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
+          @terms = {}
+          @role_names = {}
+          @allowed_forward_terms = []
+        end
+
+        def object_type(name, kind)
+          index_name(@terms, name) && trace(:context, "new #{kind} '#{name}'")
+          true
+        end
+
+        def reset_role_names
+          trace :context, "\tresetting role names #{@role_names.keys.sort*", "}" if @role_names && @role_names.size > 0
+          @role_names = {}
+        end
+
+        def allowed_forward_terms(terms)
+          @allowed_forward_terms = terms
+        end
+
+        def new_leading_adjective_term(adj, term)
+          index_name(@role_names, "#{adj} #{term}", term) && trace(:context, "new compound term '#{adj}- #{term}'")
+          true
+        end
+
+        def new_trailing_adjective_term(adj, term)
+          index_name(@role_names, "#{term} #{adj}", term) && trace(:context, "new compound term '#{term} -#{adj}'")
+          true
+        end
+
+        def role_name(name)
+          index_name(@role_names, name) && trace(:context, "new role '#{name}'")
+          true
+        end
+
+        def term_starts?(s, context_saver)
+          @term = @global_term = nil
+
+          @term_part = s
+          @context_saver = context_saver
+          t = @terms[s] || @role_names[s] || system_term(s)
+          if t
+            # s is a prefix of the keys of t.
+            if t[s]
+              @global_term = @term = @term_part
+              @context_saver.context = {:term => @term, :global_term => @global_term }
+            end
+            trace :context, "Term #{t[s] ? "is" : "starts"} '#{@term_part}'"
+          elsif @allowed_forward_terms.include?(@term_part)
+            @term = @term_part
+            @context_saver.context = {:term => @term, :global_term => @term }
+            trace :context, "Term #{s} is an allowed forward"
+            return true
+          end
+          t
+        end
+
+        def term_continues?(s)
+          @term_part = "#{@term_part} #{s}"
+          t = @terms[@term_part]
+          r = @role_names[@term_part]
+          if t && (!r || !r[@term_part])    # Part of a term and not a complete role name
+            w = "term"
+          else
+            t = r
+            w = "role_name"
+          end
+          if t
+            trace :context, "Multi-word #{w} #{t[@term_part] ? 'ends at' : 'continues to'} #{@term_part.inspect}"
+
+            # Record the name of the full term and the underlying global term:
+            if t[@term_part]
+              @term = @term_part if t[@term_part]
+              @global_term = (t = t[@term_part]) == true ? @term_part : t
+              trace :context, "saving context #{@term}/#{@global_term}"
+              @context_saver.context = {:term => @term, :global_term => @global_term }
+            end
+          end
+          t
+        end
+
+        def term_complete?
+          return true if @allowed_forward_terms.include?(@term)
+          return true if system_term(@term)
+          (t = @terms[@term] and t[@term]) or
+            (t = @role_names[@term] and t[@term])
+        end
+
+        def system_term(s)
+          false
+        end
+
+        def unit? s
+          @parser.unit? s
+        end
+
+      private
+        # Index the name by all prefixes
+        def index_name(index, name, value = true)
+          added = false
+          words = name.split(/\s+/)
+          words.inject("") do |n, w|
+            # Index all prefixes up to the full term
+            n = n.empty? ? w : "#{n} #{w}"
+            index[n] ||= {}
+            added = true unless index[n][name]
+            index[n][name] = value    # Save all possible completions of this prefix
+            n
+          end
+          added
+        end
+      end
+
+      class InputProxy
+        attr_reader :context, :parser
+
+        def initialize(input, context, parser)
+          @input = input
+          @context = context
+          @parser = parser
+        end
+
+        def length
+          @input.length
+        end
+
+        def size
+          length
+        end
+
+        def [](*a)
+          @input[*a]
+        end
+
+        def index(*a)
+          @input.index(*a)
+        end
+
+        def line_of(x)
+          @input.line_of(x)
+        end
+
+        def column_of(x)
+          @input.column_of(x)
+        end
+      end
+
+      def context
+        @context ||= Context.new(self)
+      end
+
+      def unit?(s)
+        # puts "Asking whether #{s.inspect} is a unit"
+        true
+      end
+
+      def parse(input, options = {})
+        input = InputProxy.new(input, context, self) unless input.respond_to?(:context)
+        super(input, options)
+      end
+
+      def parse_all(input, rule_name = nil, &block)
+        self.root = rule_name if rule_name
+
+        @index = 0  # Byte offset to start next parse
+        @block = block
+        self.consume_all_input = false
+        nodes = []
+        begin
+          node = parse(InputProxy.new(input, context, self), :index => @index)
+          unless node 
+            raise failure_reason unless @index == input.size
+            return nil  # No input, or no more input
+          end
+          if @block
+            @block.call(node)
+          else
+            nodes << node
+          end
+        end until self.index == @input_length
+        @block ? true : nodes
+      end
+    end
+
+  end
+
+  Polyglot.register('cql', CQL::Parser)
+end