activefacts 1.6.0 → 1.7.1

data/lib/activefacts/cql/Rakefile

@@ -1,14 +0,0 @@
-#
-#       ActiveFacts CQL Parser.
-#       A Rakefile to run Treetop when the ActiveFacts gem is installed.
-#       This isn't mandatory but makes it much faster to start the parser.
-#       Delete the generated files during parser development.
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-task :default do
-  pattern = File.dirname(__FILE__) + '**/*.treetop'
-  files = Dir[pattern]
-  # Hopefully this quoting will work where there are spaces in filenames, and even maybe on Windows?
-  exec "tt '#{files*"' '"}'"
-end

data/lib/activefacts/cql/Terms.treetop

@@ -1,183 +0,0 @@
-#
-#       ActiveFacts CQL Parser.
-#       Parse rules relating to Term names
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-module ActiveFacts
-  module CQL
-    grammar Terms
-      rule term_definition_name
-        id s t:(!non_term_def id s)*
-	  <Parser::TermDefinitionNameNode>
-      end
-
-      rule non_term_def
-        mapping_pragmas entity_prefix
-        / mapping_pragmas written_as			      # Value type
-        / mapping_pragmas is_where			      # Objectified type
-        / non_phrase
-	/ identified_by					      # as in: "a kind of X identified by..."
-	/ in_units
-	/ auto_assignment
-	/ value_constraint
-      end
-
-      rule entity_prefix
-        is s (independent s )? identified_by
-	/
-	subtype_prefix (independent s )? term_definition_name
-	  &{|e| input.context.object_type(e[2].value, "subtype") }
-      end
-
-      rule prescan
-        s each?
-	s (
-          term_definition_name mapping_pragmas entity_prefix
-		&{|e| input.context.object_type(e[0].value, "entity type") }
-          /
-          t1:term_definition_name mapping_pragmas written_as any? s t2:term_definition_name
-                &{|e|
-		  new_term = e[0].value
-		  input.context.object_type(new_term, "value type")
-		  base_term = e[5].value
-		  input.context.object_type(base_term, "value type")
-		}
-          /
-          term_definition_name s mapping_pragmas is_where
-                &{|e| input.context.object_type(e[0].value, "objectified_fact_type") }
-        )?
-        prescan_rest
-        &{|s|
-	  # Wipe any terminal failures that were added:
-          @terminal_failures = []
-          @max_terminal_failure_index = start_index
-
-          # puts "========== prescan is complete on #{(s.map{|e|e.text_value}*" ").inspect} =========="
-          false
-        }
-      end
-
-      # Do a first-pass mainly lexical analysis, looking for role name definitions and adjectives,
-      # for use in detecting terms later.
-      rule prescan_rest
-        &{|s| input.context.reset_role_names }
-        (
-          context_note                      # Context notes have different lexical conventions
-          / '(' as S term_definition_name s ')' s    # Prepare for a Role Name
-            &{|s| input.context.role_name(s[3].value) }
-	  / new_derived_value		    # Prepare for a derived term
-          / new_adjective_term		    # Prepare for an existing term with new Adjectives
-	# The remaining rules exist to correctly eat up anything that doesn't match the above:
-          / global_term                     # If we see A B - C D, don't recognise B as a new adjective for C D.
-	  / prescan_aggregate
-          / id
-	  # / literal # REVISIT: Literals might contain "(as Foo)" and mess things up
-          / range                           # Covers all numbers and strings
-          / comparator                      # handle two-character operators
-          / S                               # White space and comments, must precede / and *
-          / [-+{}\[\].,:^/%*()]             # All other punctuation and operators
-        )* [?;] s
-      end
-
-      # Not sure this is even needed, but it doesn't seem to hurt:
-      rule prescan_aggregate
-	aggregate_type:id s agg_of s global_term agg_in s &'('
-      end
-
-      rule new_derived_value
-        !global_term id derived_value_continuation? s '='
-	  &{|s|
-	    name = [s[1].text_value] + (s[2].empty? ? [] : s[2].value)
-	    input.context.object_type(name*' ', "derived value type")
-	  }
-	/
-	'=' s !global_term id derived_value_continuation? s (that/who)
-	  &{|s|
-	    name = [s[3].text_value] + (s[4].empty? ? [] : s[4].value)
-	    input.context.object_type(name*' ', "derived value type")
-	  }
-      end
-
-      # Derived values are new terms introduced by an = sign before an expression
-      # This rule handles trailing words of a multi-word derived value
-      rule derived_value_continuation
-        s '-' tail:(s !global_term !(that/who) id)*
-	{
-	  def value
-	    tail.elements.map{|e| e.id.text_value}
-	  end
-	}
-      end
-
-      # Used during the pre-scan, match a term with new adjective(s)
-      rule new_adjective_term
-        !global_term adj:id '-' '-'? lead_intervening s global_term	  # Definitely a new leading adjective for this term
-          &{|s| adj = [s[1].text_value, s[4].value].compact*" "; input.context.new_leading_adjective_term(adj, s[6].text_value) }
-        /
-        global_term s trail_intervening '-' '-'? !global_term adj:id	  # Definitely a new trailing adjective for this term
-          &{|s| adj = [s[2].value, s[6].text_value].compact*" "; input.context.new_trailing_adjective_term(adj, s[0].text_value) }
-      end
-
-      rule lead_intervening	# Words intervening between a new adjective and the term
-	(S !global_term id)*
-	{
-	  def value
-	    elements.size == 0 ? nil : elements.map{|e| e.id.text_value}*" "
-	  end
-	}
-      end
-
-      rule trail_intervening	# Words intervening between a new adjective and the term
-	(!global_term id S)*
-	{
-	  def value
-	    elements.size == 0 ? nil : elements.map{|e| e.id.text_value}*" "
-	  end
-	}
-      end
-
-      # This is the rule to use after the prescan; it only succeeds on a complete term or role reference
-      rule term
-        s head:id x		  &{|s| w = s[1].text_value; input.context.term_starts?(w, s[2]) }
-        tail:(
-	  s '-'? dbl:'-'? s w:id  &{|s| w = s[4].text_value; input.context.term_continues?(w) }
-	)*			  &{|s| input.context.term_complete? }
-	  <Parser::TermNode>
-	/
-	s head:id '-' '-'? s term	&{|s| s[5].ast.leading_adjective == nil }
-	  <Parser::TermLANode>
-      end
-
-      rule x
-	'' <SavedContext>
-      end
-
-      rule global_term
-        # This rule shouldn't be used outside the prescan, it will memoize the wrong things.
-        head:id x    &{|s| input.context.term_starts?(s[0].text_value, s[1]) }
-        tail:(s w:id &{|s| input.context.term_continues?(s[1].text_value) } )*
-        { def value
-            tail.elements.inject(head.value) { |t, e| "#{t} #{e.w.value}" }
-          end
-        }
-      end
-
-      rule non_phrase
-        # These words are illegal in (but maybe ok following) a clause where a phrase is expected:
-        and
-        / but
-        / if
-        / role_list_constraint_followers
-        / only_if
-        / or
-        / quantifier
-        / returning
-        / then
-        / value_constraint
-        / where
-      end
-
-    end
-  end
-end

data/lib/activefacts/cql/ValueTypes.treetop

@@ -1,202 +0,0 @@
-#
-#       ActiveFacts CQL Parser.
-#       Parse rules relating to ValueType definitions.
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-module ActiveFacts
-  module CQL
-    grammar ValueTypes
-      rule value_type
-	s each?
-        s term_definition_name
-	m1:mapping_pragmas
-	# REVISIT: ORM2 would allow (subtype_prefix term)?
-        written_as
-	any? s
-        base:(term/implicit_value_type_name) s
-        value_type_parameters
-        u:in_units?
-	a:auto_assignment?
-	c:context_note?
-        r:(value_constraint enforcement)?
-        m2:mapping_pragmas
-	c2:context_note?
-        s ';' s
-        {
-	  def ast
-	    name = term_definition_name.value
-	    params = value_type_parameters.values
-	    value_constraint = nil
-	    unless r.empty? 
-	      value_constraint = Compiler::ValueConstraint.new(r.value_constraint.ast, r.enforcement.ast)
-	    end
-	    units = u.empty? ? [] : u.units.value
-	    auto_assigned_at = a.empty? ? nil : a.auto_assigned_at
-	    pragmas = m1.value+m2.value
-	    context_note = !c.empty? ? c.ast : (!c2.empty? ? c2.ast : nil)
-	    Compiler::ValueType.new name, base.value, params, units, value_constraint, pragmas, context_note, auto_assigned_at
-	  end
-        }
-      end
-
-      rule in_units
-	in S units
-      end
-
-      rule implicit_value_type_name
-	id
-	{
-	  def node_type; :term; end
-	}
-      end
-
-      rule value_type_parameters
-        '(' s tpl:type_parameter_list? ')' s
-          { def values; tpl.empty? ? [] : tpl.values; end }
-        / s
-          { def values; []; end }
-      end
-
-      rule type_parameter_list
-        head:number s tail:( ',' s number s )*
-        {
-          def values
-            [head.value, *tail.elements.map{|i| i.number.value}]
-          end
-        }
-      end
-
-      rule unit_definition
-        u:(
-          s coeff:unit_coefficient? base:units? s o:unit_offset?
-	  conversion
-          singular:unit_name s plural:('/' s p:unit_name s)?
-        /
-          s singular:unit_name s plural:('/' s p:unit_name s)?
-	  conversion
-          coeff:unit_coefficient? base:units? s o:unit_offset?
-        )
-        q:(approximately '' / ephemera s url )? s
-        ';'
-        {
-	  def ast
-            singular = u.singular.text_value
-            plural = u.plural.text_value.empty? ? nil : u.plural.p.text_value 
-	    if u.coeff.empty?
-	      raise "Unit definition requires either a coefficient or an ephemera URL" unless q.respond_to?(:ephemera)
-	      numerator,denominator = 1, 1
-	    else
-	      numerator, denominator = *u.coeff.ast
-	    end
-            offset = u.o.text_value.empty? ? 0 : u.o.value
-	    bases = u.base.empty? ? [] : u.base.value
-	    approximately = q.respond_to?(:approximately) || u.conversion.approximate?
-	    ephemera = q.respond_to?(:ephemera) ? q.url.text_value : nil
-	    Compiler::Unit.new singular, plural, numerator, denominator, offset, bases, approximately, ephemera
-	  end
-        }
-      end
-
-      rule unit_name
-	id
-	{
-	  def node_type; :unit; end
-	}
-      end
-
-
-      rule unit_coefficient
-        numerator:number denominator:(s '/' s number)? s
-        {
-	  def ast
-            [ numerator.text_value,
-              (denominator.text_value.empty? ? "1" : denominator.number.text_value)
-	    ]
-	  end
-        }
-      end
-
-      rule unit_offset
-        sign:[-+] s number s
-        { def value
-            sign.text_value == '-' ? "-"+number.text_value : number.text_value
-          end
-        }
-      end
-
-      # In a unit definition, we may use undefined base units; this is the only way to get fundamental units
-      rule units
-        !non_unit maybe_unit s tail:(!non_unit maybe_unit s)* div:('/' s maybe_unit s tail:(!non_unit maybe_unit s)*)?
-        { def value
-	    tail.elements.inject([maybe_unit.value]) { |a, e| a << e.maybe_unit.value } +
-	      (div.text_value.empty? ? [] : div.tail.elements.inject([div.maybe_unit.inverse]) { |a, e| a << e.maybe_unit.inverse })
-          end
-        }
-      end
-
-      rule non_unit
-        restricted_to / conversion / approximately / ephemera / auto_assignment
-      end
-
-      rule unit
-	maybe_unit &{|s| input.context.unit?(s[0].unit_name.text_value) }
-      end
-
-      rule maybe_unit
-        unit_name pow:('^' '-'? [0-9])?
-        { def value
-            [unit_name.text_value, pow.text_value.empty? ? 1 : Integer(pow.text_value[1..-1])]
-          end
-          def inverse
-            a = value
-            a[1] = -a[1]
-            a
-          end
-        }
-      end
-
-      rule value_constraint
-	restricted_to restricted_values c:context_note?
-        {
-	  def ast
-	    v = restricted_values.values
-	    c[:context_note] = c.ast unless c.empty?
-	    v
-	  end
-        }
-	# REVISIT: "where the possible value/s of that <Term> is/are value (, ...)"
-      end
-
-      rule restricted_values
-	range_list s u:units?
-	{
-	  def values
-	    { :ranges => range_list.ranges,
-	      :units => u.empty? ? nil : u.value
-	    }
-	  end
-	}
-	/
-	regular_expression
-	{
-	  def values
-	    { :regular_expression => contents }
-	  end
-	}
-      end
-
-      rule range_list
-        '{' s
-          head:range s tail:( ',' s range )*
-        '}' s
-        {
-          def ranges
-            [head.value, *tail.elements.map{|e| e.range.value }]
-          end
-        }
-      end
-
-    end
-  end
-end

data/lib/activefacts/cql/compiler.rb

@@ -1,156 +0,0 @@
-#       Compile a CQL string into an ActiveFacts vocabulary.
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-require 'activefacts/vocabulary'
-require 'activefacts/cql/parser'
-require 'activefacts/cql/compiler/shared'
-require 'activefacts/cql/compiler/value_type'
-require 'activefacts/cql/compiler/entity_type'
-require 'activefacts/cql/compiler/clause'
-require 'activefacts/cql/compiler/fact_type'
-require 'activefacts/cql/compiler/expression'
-require 'activefacts/cql/compiler/fact'
-require 'activefacts/cql/compiler/constraint'
-require 'activefacts/cql/compiler/query'
-
-module ActiveFacts
-  module CQL
-    class Compiler < ActiveFacts::CQL::Parser
-      LANGUAGES = {
-        'en' => 'English',
-        'fr' => 'French',
-        'cn' => 'Mandarin'
-      }
-      attr_reader :vocabulary
-
-      def initialize *a
-        @filename = a.shift || "stdio"
-        super *a
-        @constellation = ActiveFacts::API::Constellation.new(ActiveFacts::Metamodel)
-        @language = nil
-        trace :file, "Parsing '#{@filename}'"
-      end
-
-      def compile_file filename
-        old_filename = @filename
-        @filename = filename
-        File.open(filename) do |f|
-          compile(f.read)
-        end
-        @filename = old_filename
-        @vocabulary
-      end
-
-      # Load the appropriate natural language module
-      def detect_language
-        @filename =~ /.*\.(..)\.cql$/i
-        language_code = $1
-        @language = LANGUAGES[language_code] || 'English'
-      end
-
-      def include_language
-        detect_language unless @langage
-        require 'activefacts/cql/Language/'+@language
-        language_module = ActiveFacts::CQL.const_get(@language)
-        extend language_module
-      end
-
-      # Mark any new Concepts as belonging to this topic
-      def topic_flood
-	@constellation.Concept.each do |key, concept|
-	  next if concept.topic
-	  trace :topic, "Colouring #{concept.describe} with #{@topic.topic_name}"
-	  concept.topic = @topic
-	end
-      end
-
-      def compile input
-        include_language
-
-        @string = input
-
-        # The syntax tree created from each parsed CQL statement gets passed to the block.
-        # parse_all returns an array of the block's non-nil return values.
-        ok = parse_all(@string, :definition) do |node|
-          trace :parse, "Parsed '#{node.text_value.gsub(/\s+/,' ').strip}'" do
-	    trace :lex, (proc { node.inspect })
-            begin
-              ast = node.ast
-              next unless ast
-              trace :ast, ast.inspect
-              ast.tree = node
-              ast.constellation = @constellation
-              ast.vocabulary = @vocabulary
-              value = compile_definition ast
-              trace :definition, "Compiled to #{value.is_a?(Array) ? value.map{|v| v.verbalise}*', ' : value.verbalise}" if value
-	      if value.is_a?(ActiveFacts::Metamodel::Topic)
-		topic_flood if @topic
-		@topic = value
-	      elsif ast.is_a?(Compiler::Vocabulary)
-		topic_flood if @topic
-		@vocabulary = value
-		@topic = @constellation.Topic(@vocabulary.name)
-	      end
-            rescue => e
-              # Augment the exception message, but preserve the backtrace
-              start_line = @string.line_of(node.interval.first)
-              end_line = @string.line_of(node.interval.last-1)
-              lines = start_line != end_line ? "s #{start_line}-#{end_line}" : " #{start_line.to_s}"
-              ne = StandardError.new("at line#{lines} #{e.message.strip}")
-              ne.set_backtrace(e.backtrace)
-              raise ne
-            end
-          end
-	  topic_flood if @topic
-        end
-        raise failure_reason unless ok
-        vocabulary
-      end
-
-      def compile_import file, aliases
-        saved_index = @index
-        saved_block = @block
-        saved_string = @string
-        saved_input_length = @input_length
-        saved_topic = @topic
-        old_filename = @filename
-        @filename = File.dirname(old_filename)+'/'+file+'.cql'
-
-        # REVISIT: Save and use another @vocabulary for this file?
-        File.open(@filename) do |f|
-	  topic_flood if @topic
-	  @topic = @constellation.Topic(File.basename(@filename, '.cql'))
-	  trace :import, "Importing #{@filename} as #{@topic.topic_name}" do
-	    ok = parse_all(f.read, nil, &@block)
-	  end
-	  @topic = saved_topic
-        end
-
-      rescue => e
-        ne = StandardError.new("In #{@filename} #{e.message.strip}")
-        ne.set_backtrace(e.backtrace)
-        raise ne
-      ensure
-        @block = saved_block
-        @index = saved_index
-        @input_length = saved_input_length
-        @string = saved_string
-        @filename = old_filename
-        nil
-      end
-
-      def compile_definition ast
-        ast.compile
-      end
-
-      def unit? s
-        name = @constellation.Name[s]
-        units = (!name ? [] : Array(name.unit) + Array(name.plural_named_unit)).uniq
-        trace :units, "Looking for unit #{s}, got #{units.map{|u|u.name}.inspect}"
-        units.size > 0
-      end
-
-    end
-  end
-end