activefacts 1.6.0 → 1.7.1

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

@@ -1,161 +0,0 @@
-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

@@ -1,174 +0,0 @@
-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/nodes.rb

@@ -1,49 +0,0 @@
-module ActiveFacts
-  module CQL
-    class Parser
-      class TermNode < Treetop::Runtime::SyntaxNode
-        def ast quantifier = nil, function_call = nil, role_name = nil, value_constraint = nil, literal = nil, nested_clauses = nil
-          t = x.context[:term]
-          gt = x.context[:global_term]
-          if t.size > gt.size and t[-gt.size..-1] == gt
-            leading_adjective = t[0...-gt.size-1]
-            leading_adjective.sub!(/ /, '-') if !tail.elements[0].dbl.empty?
-          end
-          if t.size > gt.size and t[0...gt.size] == gt
-            trailing_adjective = t[gt.size+1..-1]
-            trailing_adjective.sub!(/ (\S*)\Z/, '-\1') if !tail.elements[-1].dbl.empty?
-          end
-          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
-          x.context[:term]
-        end
-
-        def node_type
-          :term
-        end
-      end
-
-      class TermLANode < TermNode
-        def ast quantifier = nil, function_call = nil, role_name = nil, value_constraint = nil, literal = nil, nested_clauses = nil
-          ast = term.ast(quantifier, function_call, role_name, value_constraint, literal, nested_clauses)
-          ast.leading_adjective = head.text_value
-          ast
-        end
-      end
-
-      class TermDefinitionNameNode < TermNode
-        def value
-          t.elements.inject([
-            id.value
-          ]){|a, e| a << e.id.value}*' '
-        end
-
-        def node_type
-          :term
-        end
-      end
-    end
-  end
-end

data/lib/activefacts/cql/parser.rb

@@ -1,241 +0,0 @@
-#
-#       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/LexicalRules'
-require 'activefacts/cql/Language/English'
-require 'activefacts/cql/Expressions'
-require 'activefacts/cql/Terms'
-require 'activefacts/cql/ObjectTypes'
-require 'activefacts/cql/ValueTypes'
-require 'activefacts/cql/FactTypes'
-require 'activefacts/cql/Context'
-require 'activefacts/cql/CQLParser'
-
-module ActiveFacts
-  module CQL
-    class Parser < CQLParser
-    end
-  end
-end
-require 'activefacts/cql/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