activefacts 0.8.6 → 0.8.8

data/Manifest.txt

@@ -15,16 +15,33 @@ examples/CQL/Address.cql
 examples/CQL/Blog.cql
 examples/CQL/CompanyDirectorEmployee.cql
 examples/CQL/Death.cql
+examples/CQL/Diplomacy.cql
 examples/CQL/Genealogy.cql
+examples/CQL/Insurance.cql
+examples/CQL/JoinEquality.cql
 examples/CQL/Marriage.cql
 examples/CQL/Metamodel.cql
+examples/CQL/MetamodelNext.cql
+examples/CQL/Monogamy.cql
+examples/CQL/MonthInSeason.cql
+examples/CQL/Moon.cql
 examples/CQL/MultiInheritance.cql
+examples/CQL/NonRoleId.cql
+examples/CQL/OddIdentifier.cql
 examples/CQL/OilSupply.cql
+examples/CQL/OneToOnes.cql
 examples/CQL/Orienteering.cql
+examples/CQL/OrienteeringER.cql
 examples/CQL/PersonPlaysGame.cql
+examples/CQL/RedundantDependency.cql
 examples/CQL/SchoolActivities.cql
+examples/CQL/SeparateSubtype.cql
+examples/CQL/ServiceDirector.cql
 examples/CQL/SimplestUnary.cql
 examples/CQL/SubtypePI.cql
+examples/CQL/Supervision.cql
+examples/CQL/Tests.Test5.Load.cql
+examples/CQL/WaiterTips.cql
 examples/CQL/Warehousing.cql
 examples/CQL/WindowInRoomInBldg.cql
 examples/CQL/unit.cql
@@ -59,10 +76,16 @@ lib/activefacts/cql/Rakefile
 lib/activefacts/cql/Terms.treetop
 lib/activefacts/cql/ValueTypes.treetop
 lib/activefacts/cql/compiler.rb
+lib/activefacts/cql/compiler/constraint.rb
+lib/activefacts/cql/compiler/entity_type.rb
+lib/activefacts/cql/compiler/fact.rb
+lib/activefacts/cql/compiler/fact_type.rb
+lib/activefacts/cql/compiler/reading.rb
+lib/activefacts/cql/compiler/shared.rb
+lib/activefacts/cql/compiler/value_type.rb
 lib/activefacts/cql/parser.rb
 lib/activefacts/generate/absorption.rb
 lib/activefacts/generate/cql.rb
-lib/activefacts/generate/cql/html.rb
 lib/activefacts/generate/null.rb
 lib/activefacts/generate/oo.rb
 lib/activefacts/generate/ordered.rb
@@ -84,8 +107,8 @@ lib/activefacts/version.rb
 lib/activefacts/vocabulary.rb
 lib/activefacts/vocabulary/extensions.rb
 lib/activefacts/vocabulary/metamodel.rb
+lib/activefacts/vocabulary/verbaliser.rb
 script/txt2html
-spec/absorption_ruby_spec.rb
 spec/absorption_spec.rb
 spec/api/autocounter.rb
 spec/api/constellation.rb
@@ -95,6 +118,8 @@ spec/api/roles.rb
 spec/api/value_type.rb
 spec/api_spec.rb
 spec/cql/context_spec.rb
+spec/cql/deontic_spec.rb
+spec/cql/matching_spec.rb
 spec/cql/samples_spec.rb
 spec/cql/unit_spec.rb
 spec/cql_cql_spec.rb
@@ -104,9 +129,15 @@ spec/cql_ruby_spec.rb
 spec/cql_sql_spec.rb
 spec/cql_symbol_tables_spec.rb
 spec/cqldump_spec.rb
+spec/helpers/array_matcher.rb
+spec/helpers/ctrl_c_support.rb
+spec/helpers/diff_matcher.rb
 spec/helpers/file_matcher.rb
+spec/helpers/string_matcher.rb
+spec/helpers/test_parser.rb
 spec/norma_cql_spec.rb
 spec/norma_ruby_spec.rb
+spec/norma_ruby_sql_spec.rb
 spec/norma_sql_spec.rb
 spec/norma_tables_spec.rb
 spec/spec.opts

data/README.rdoc

@@ -2,58 +2,52 @@
 
 * http://dataconstellation.com/ActiveFacts/
 
-== DESCRIPTION:
+== DESCRIPTION
 
-ActiveFacts is a semantic modeling toolkit, comprising an implementation
-of the Constellation Query Language, the Constellation API, and code
-generators that receive CQL or ORM (Object Role Modeling files, from
-NORMA) to emit CQL, Ruby and SQL.
+ActiveFacts provides a semantic modeling language, the Constellation
+Query Language (CQL).  CQL combines natural language verbalisation and
+formal logic, producing a formal language that reads like plain
+English. ActiveFacts converts semantic models from CQL to relational
+and object models in SQL, Ruby and other languages.
 
-Semantic modeling is a refinement of fact-based modeling techniques
-that draw on natural language verbalisation and formal logic. Fact
-based modeling is essentially the same as relational modeling in the
-sixth normal form. The tools provided here automatically condense
-that to third normal form for efficient storage. They also generate
-object models as a Ruby module which has an effective mapping to
-both the original semantic model and to the generated SQL.
-
-The result is a formal language that reads like plain English, and
-allows creation of relational and object models that are guaranteed
-equivalent, and much more stable in the face of schema evolution than
-SQL is.
+The generated models are guaranteed congruent, which eliminates the
+object-relational impedance mismatch.  Semantic models are much more
+stable under evolving requirements than either relational or
+object-oriented models, because they directly express the underlying
+elementary facts, so are not susceptible to ramifying change in the
+way those attribute-oriented approaches are.
 
-== FEATURES/PROBLEMS:
+Semantic modeling is a refinement of fact-based modeling techniques
+such as ORM2, NIAM and others. ActiveFacts can convert ORM2 files from
+NORMA to CQL. Fact-based modeling is closely related to relational
+modeling in the sixth normal form, but doesn't suffer from 6NF
+inefficiency.  The relational models it derives are highly efficient.
 
- * Queries are parsed, but not yet generated to SQL. DDL is complete.
+== SYNOPSIS:
 
- * The Constellation API lacks SQL persistence (but is already useful;
-   the CQL compiler uses the generated Ruby code extensively)
+  afgen --sql/server myfile.cql
+  afgen --ruby myfile.cql
+  afgen --cql myfile.orm
 
- * Re-invoking a fact type to add new readings doesn't work
+== INSTALL:
 
- * Some types of external constraints (when adjectives mis-match)
-   don't yet pass the CQL parser's semantic analysis.
+* sudo gem install activefacts
 
- * Validation of semantic models (and many other areas) is incomplete
+== UNIMPLEMENTED FEATURES
 
- * There's no interactive CQL interpreter yet; the cql command merely
-   shows the parse tree.
+ * Queries are parsed, but not yet generated to SQL.
 
-== SYNOPSIS:
+ * The Constellation API lacks SQL persistence (but is already useful;
+   the CQL compiler uses the generated Ruby code extensively)
 
-  afgen --sql/server myfile.cql
-  afgen --ruby myfile.cql
-  afgen --cql myfile.orm
+ * Validation of semantic models is incomplete
 
 == REQUIREMENTS:
 
 * Treetop parser generator
-* Optional: NORMA, see <http://www.ormfoundation.org/files/>
-  (needs Visual Studio pro edition), if you want to use ORM
 
-== INSTALL:
-
-* sudo gem install activefacts
+* NORMA (see <http://www.ormfoundation.org/files/>), if you want to
+  use ORM (needs Visual Studio Pro edition)
 
 == LICENSE:
 

data/Rakefile

@@ -1,6 +1,12 @@
 %w[rubygems hoe rake rake/clean fileutils newgem rubigen spec spec/rake/spectask].each { |f| require f }
 
-require 'hanna/rdoctask'
+# Use mislav-hanna to the API format documentation, if it's installed:
+begin
+  require 'hanna/rdoctask'
+  HANNA = true
+rescue
+  HANNA = false
+end
 
 require File.dirname(__FILE__) + '/lib/activefacts'
 
@@ -10,23 +16,11 @@ $hoe = Hoe.spec('activefacts') do |p|
   p.version = ActiveFacts::VERSION
   p.summary = "A semantic modeling and query language (CQL) and application runtime (the Constellation API)"
   p.description = %q{
-ActiveFacts is a semantic modeling toolkit, comprising an implementation
-of the Constellation Query Language, the Constellation API, and code
-generators that receive CQL or ORM (Object Role Modeling files, from
-NORMA) to emit CQL, Ruby and SQL.
-
-Semantic modeling is a refinement of fact-based modeling techniques
-that draw on natural language verbalisation and formal logic. Fact
-based modeling is essentially the same as relational modeling in the
-sixth normal form. The tools provided here automatically condense
-that to third normal form for efficient storage. They also generate
-object models as a Ruby module which has an effective mapping to
-both the original semantic model and to the generated SQL.
-
-The result is a formal language that reads like plain English, and
-allows creation of relational and object models that are guaranteed
-equivalent, and much more stable in the face of schema evolution than
-SQL is.
+ActiveFacts provides a semantic modeling language, the Constellation
+Query Language (CQL).  CQL combines natural language verbalisation and
+formal logic, producing a formal language that reads like plain
+English. ActiveFacts converts semantic models from CQL to relational
+and object models in SQL, Ruby and other languages.
 }
   p.url = "http://dataconstellation.com/ActiveFacts/"
   p.developer('Clifford Heath', 'cjh@dataconstellation.org')
@@ -35,6 +29,7 @@ SQL is.
   p.rubyforge_name       = "cjheath@rubyforge.org"
   p.extra_deps         = [
     ['treetop','>= 1.4.1'],
+    ['rake','>= 0.8.7'],
   ]
   p.extra_dev_deps = [
     ['newgem', ">= #{::Newgem::VERSION}"]
@@ -42,8 +37,9 @@ SQL is.
   p.spec_extras[:extensions] = 'lib/activefacts/cql/Rakefile'
   # Magic Hoe hook to prevent the generation of diagrams:
   ENV['NODOT'] = 'yes'
-  p.spec_extras[:rdoc_options] = %w{
-      -S -T hanna
+  p.spec_extras[:rdoc_options] = ['-S'] +
+    (HANNA ? %w{ -S -T hanna} : []) +
+    %w{
       -A has_one -A one_to_one -A maybe
       -x lib/activefacts/cql/.*.rb
       -x lib/activefacts/vocabulary/.*.rb

data/bin/afgen

@@ -1,34 +1,37 @@
 #! /usr/bin/env ruby
 #
-#	ActiveFacts: Read a Vocabulary (from a NORMA, CQL or other file) and run a generator
+#       ActiveFacts: Read a Vocabulary (from a NORMA, CQL or other file) and run a generator
 #
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
 $:.unshift File.dirname(File.expand_path(__FILE__))+"/../lib"
 
 require 'rubygems'
-require 'activefacts'
-require 'activefacts/vocabulary'
 
-if ENV['DEBUG']
+# Load the ruby debugger before everything else, if requested
+if d = ENV['DEBUG'] and d.split(/,/).include?('debug')
   begin
     require 'ruby-debug'
-    Debugger.start(:post_mortem => true)	# Stop when an exception is thrown, but before it's rescued
+    Debugger.start(:post_mortem => true)        # Stop when an exception is thrown, but before it's rescued
   rescue LoadError
     # Ok, no debugger, tough luck.
   end
 end
-true # Ok, got the stack set up, continue to the fault
+
+require 'activefacts'
+require 'activefacts/vocabulary'
 
 arg = ARGV.shift
 
 # Load the required generator, or the default "text" generator:
 generator = "text"
+generator_options = []
 if arg =~ /^--([^=]*)(?:=(.*))?/
   generator = $1
   generator_options = ($2||"").split(/,/)
   arg = ARGV.shift
 end
+
 output_handler = "activefacts/generate/#{generator.downcase}"
 require output_handler
 output_class = generator.upcase.gsub(%r{[/\\]+},'::')
@@ -36,20 +39,23 @@ output_klass = eval("ActiveFacts::Generate::#{output_class}")
 raise "Expected #{output_handler} to define #{output_class}" unless output_klass
 
 # Load the file type input method
+arg, *options = *arg.split(/=/)
 extension = arg.sub(/\A.*\./,'').downcase
 input_handler = "activefacts/input/#{extension}"
 require input_handler
+
 input_class = extension.upcase
 input_klass = ActiveFacts::Input.const_get(input_class.to_sym)
 raise "Expected #{input_handler} to define #{input_class}" unless input_klass
 
 # Read the input file:
 begin
-  vocabulary = input_klass.readfile(arg)
+  vocabulary = input_klass.readfile(arg, *options)
+
+  # Generate the output:
+  output_klass.new(vocabulary, *generator_options).generate if vocabulary
 rescue => e
   puts "#{e.message}"
-  puts "#{e}:\n\t#{e.backtrace*"\n\t"}" if debug
+  # puts "\t#{e.backtrace*"\n\t"}"
+  puts "\t#{e.backtrace*"\n\t"}" if debug :exception
 end
-
-# Generate the output:
-output_klass.new(vocabulary, *generator_options).generate if vocabulary

data/bin/cql

@@ -1,62 +1,339 @@
 #! /usr/bin/env ruby
 #
-#	ActiveFacts: Interactive CQL command-line. Incomplete; only parses CQL and shows the parse trees
+#       ActiveFacts: Interactive CQL command-line. Incomplete; only parses CQL and shows the parse trees
 #
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
-
-require 'activefacts'
-require 'activefacts/cql/parser'
 require 'readline'
 
-if ENV['DEBUG']
+# Load the ruby debugger before everything else, if requested
+if d = ENV['DEBUG'] and d.split(/,/).include?('debug')
   begin
     require 'ruby-debug'
-    debugger if debug :exception
+    Debugger.start(:post_mortem => true)        # Stop when an exception is thrown, but before it's rescued
   rescue LoadError
     # Ok, no debugger, tough luck.
   end
 end
-true # Ok, got the stack set up, continue to the fault
 
-puts "This is a stub for the CQL interactive commandline. At the moment it only parses CQL and shows the parse trees."
+require 'activefacts'
+require 'activefacts/cql/compiler'
 
-parser = ActiveFacts::CQL::Parser.new
-parser.root = :definition
-statement = nil
-while line = Readline::readline(statement ? "CQL+ " : "CQL? ", [])
-  statement = statement ? statement + "\n"+line : line
-  if line =~ %r{\A/}
+class InteractiveCQL < ActiveFacts::CQL::Compiler
+  def initialize *a
+    @show_tree = false  # Show the raw Treetop parse tree
+    super *a
+    self.root = :definition
+  end
+
+  def metacommand(line)
     # meta-commands start with /
-    case (words = line.split).shift
+    words = line.split
+    case cmd = words.shift
+    when "/tree"
+      @show_tree = !@show_tree
+      puts "Will #{@show_tree ? "" : "not "}show the parse tree"
     when "/root"
-      parser.root = words[0] && words[0].to_sym || :definition
-      puts "ok"
+      self.root = words[0] && words[0].to_sym || :definition
+      puts "Looking for a #{self.root}"
+    when "/list"
+      concepts_by_vocabulary = {}
+      @constellation.Concept.keys.
+	each do |v,t|
+	  (concepts_by_vocabulary[v[0]] ||= []) << t
+	end
+      concepts_by_vocabulary.keys.sort.each do |v|
+	puts "#{v}:\n\t" + concepts_by_vocabulary[v].sort*"\n\t"
+      end
+    when "/about"
+      concept = @constellation.Concept[[@vocabulary.identifying_role_values, words[0]]]
+      unless concept
+	puts "Concept #{words[0]} is unknown in #{@vocabulary.name}"
+	return
+      end
+      if concept.is_a?(ActiveFacts::Metamodel::ValueType)
+	puts "\t#{concept.name} is written as #{concept.supertype.name};" if concept.supertype
+	concept.all_value_type_as_supertype.each do |st|
+	  puts "#{st.name} is written as #{concept.name};"
+	end
+      end
+      concept.all_role.map{|role| role.fact_type}.uniq.each do |fact_type|
+	puts "\t#{fact_type.default_reading}"
+      end
+    when "/load"
+      begin
+	vocabularies = @constellation.Vocabulary.keys
+	@results = []
+	compile_file words*' '
+	new_vocabularies = @constellation.Vocabulary.keys-vocabularies
+	puts "Loaded new vocabularies: #{new_vocabularies*', '}" unless new_vocabularies.empty?
+      rescue Errno::ENOENT => e
+	$stderr.puts e.message
+      end
     else
-      puts "Unknown metacommand #{line}, did you mean /root <rule>?"
-    end
-    statement = nil
-  elsif parser.root != :definition or
-      line.gsub(/(['"])([^\1\\]|\\.)*\1/,'') =~ /;/
-    # After stripping string literals the line contains a ';', it's the last line of the command:
-    begin
-      result = parser.parse(statement)
-      if result
-        begin
-          p result.value
-        rescue => e
-          puts e.to_s+":"
-	  puts e.backtrace*"\n\t" if ENV["DEBUG"] =~ /exception/
-          p result  # In case the root is changed and there's no value()
-        end
-        #p parser.definition(result)
+      if cmd == "/help" or cmd == "/"
+	help words
       else
-        p parser.failure_reason
+	puts "Unknown metacommand #{line}?"
+	help
       end
+    end
+  end
+
+  def process(statement)
+    begin
+      @results = []
+      compile(statement)
+      puts(@results.map{|r| "\t"+r.inspect}*"\n")
     rescue => e
       puts e
-      puts "\t"+e.backtrace*"\n\t"
+      puts "\t"+e.backtrace*"\n\t" if ENV["DEBUG"] =~ /exception/
     end
+  end
+
+  def compile_definition ast
+    # Accumulate the results:
+    p ast if @show_tree
+    @results += Array(result = super)
+    result
+  end
+
+  def help words = []
+    if words.empty?
+      puts %Q{
+Meta-commands are:
+  /about term\t\tDisplay the fact types in which term plays a part
+  /help\t\t\tThis help message
+  /help topic\t\thelp on a specific topic
+  /help topics\t\tList the available help topics
+  /list\t\t\tList all object type names (terms)
+  /load file.cql\tLoad a CQL file
+  /root rule\t\tParse just a fragment of a CQL statement, matching syntax rule only
+  /tree\t\t\tDisplay the abstract syntax tree from each statement parsed
+}
+    else
+      words.each do |word|
+	case word
+	when /topics/
+	  puts %Q{
+constraint\tHow to enter external constraints
+entity\t\tHow to define a new entity type
+fact\t\tHow to define a new fact type
+instance\tHow to assert instance data (facts)
+query\tHow to formulate queries (and derived fact types)
+term\t\tHow to name object types
+value\t\tHow to define a new value type
+vocabulary\tHow to specify the target vocabulary
+}
+	when /constraint/
+	  puts %Q{
+External Constraints are of various types, and use fact readings with
+role players that may occur in more than one reading. Adjectives, role
+names and subscripts may be used to disambiguate multiple occurrences
+of the same term.
+
+	// A subset constraint:
+	Person is an Employee
+		only if Person has Tax File Number;
+
+	// Mandatory constraint:
+	each Person occurs at least one time in
+		Person has mobile Phone Nr,
+		Person has mailing Address;
+	// Alternate syntax:
+	either Person has mobile Phone Nr or Phone has mailing Address;
+
+	// Uniqueness constraint:
+	each combination Series, Number occurs at most one time in
+		Event is in Series,
+		Event has Number;
+
+	// Disjunctive mandatory constraint:
+	each Person occurs one time in
+		Person is employeed by Company,
+		Person receives Unemployment Benefits;
+		Person is unsupported,
+	// Alternate syntax
+	either Employee reports to Manager or Employee runs Company but not both;
+
+	// Equality constraint with joins:
+	Ticket is for Seat that is at Venue
+		if and only if
+		Ticket is for Event that is held at Venue;
+}
+	when /entity/
+	  puts %q{
+Entity Type with simple identification (a one-to-one with a value type):
+
+	Employee is identified by its Nr; // Asserts the value type 'Employee Nr'
+
+The Value Type 'Employee Nr' is created if necessary, and the supertype 'Nr'
+also.  You may add alternate readings (to "...has..." and "...is for...")
+in a where clause.
+
+Entity Type with a compound identifier:
+
+	Person is identified by given Name and family Name where
+		Person is called given-Name,
+		Person has family-Name;
+
+An Entity Type may be a subtype of one or more other Entity Types.
+If no identification is declared for a subtype, it uses the identification
+of its first supertype:
+
+Vehicle Policy is a kind of Insurance Policy;
+}
+	when /fact/
+	  puts %Q{
+A Fact Type consists of one or more readings, where every reading has
+the same role players interspersed amongst unrestricted (almost!) text.
+Each role player is a Term (/help term) which denotes a Value Type or
+Entity Type (including an objectified Fact Type). Terms are always
+singular (except where a singular group is indicated).
+
+The last role player in each reading may be preceded by a quantifier
+(one, at most one, at least one, etc). Note that "one" or "at least one"
+make the relevant fact instance mandatory:
+
+	Person directs Company,
+		Company is directed by at least 2 Person;
+
+Any role player may be preceeded or followed by an adjective, using
+an adjacent hyphen to indicate the adjective. The hyphen is required
+only for one occurrence of the adjective, and other occurrences will
+be recognised.  Other hyphenated words are allowed in readings, as
+long as neither word is an existing term.
+
+	// Using the Entity Type 'Person' and Value Type 'Name':
+	Person has one family Name, family-Name is of Person;
+
+	// Using the Entity Type 'Personne' and Value Type 'Nom':
+	Personne à Nom-donné;
+
+Multiple adjectives may be used, as long as the hyphen has adjacent space:
+
+	Person driving semi-trailer avoided stray- farm Animal;
+
+Any role player may define a Role Name, which is used to refer to
+this player in other readings of this fact type:
+
+	Person (as Director) directs Company,
+		Company is directed by Director;
+
+Any role player may be followed by a role value restriction (/help constraint):
+
+	Person was born on one birth-Date restricted to {'1900/01/01'..};
+
+A Fact Type which has no embedded uniqueness constraint must be
+objectified (named) by prefixing it with an "is where" clause.
+An objectified fact type is an Entity Type, so maye be used as a
+player in subsequent Fact Types:
+
+	Directorship is where
+		Person directs Company;
+	Directorship began on at most one appointment-Date;
+
+Finally, an objectified Fact Type may be a subtype, and may also have
+separate identification like an Entity Type (/help entity):
+
+	Vehicle Claim is a kind of Insurance Claim identified by Incident ID where
+		Incident ID is of one Vehicle Claim,
+		Vehicle Claim has one Incident ID,
+		Insured Person claimed against Policy on Date;
+}
+	when /instance/
+	  puts %Q{
+An instance (or a collection of instances) is a reading or term (or
+joined collection of readings) with values following the Value Types.
+Simply-identified entities may be contracted by providing the value directly.
+Adjectives, role names and subscripts may be used to differentiate multiple
+occurrences of the same object types.
+
+	Company Name 'Microsoft';   // An instance of Company Name (a Value Type)
+	Company 'Sun';		    // An instance of Company identified by the Company Name 'Sun'
+	Company 'Sun' was founded on Date '1982-02-24';	// A simple binary fact over two objects
+	family Name 'Smith' is of Person, Person has given Name 'Daniel'; // Two facts joined
+	family Name 'Smith' is of Person who has given Name 'Daniel'; // The same, contracted
+	// A collection of facts involving several kinds of join:
+	Directorship (where Person directs Company 'Sun') began in Year '1982',
+		family Name 'Joy' is of Person that has given Name 'Bill',
+		Person was born on Date '1954-11-8;
+}
+	when /query/
+	  puts %Q{
+Queries are not yet implemented
+}
+	when /term/
+	  puts %Q{
+A Term is used to identify a Value Type or Entity Type (collectively, Object
+Types). A Term may be any word or sequence of words, each word being one
+or more alphanumeric characters (or underscore) but not starting with a
+digit. Terms are preferably capitalised; this makes it easier to construct
+unambiguous fact type readings.
+
+Many keywords are disallowed as Terms, but not all.
+}
+	when /value/
+	  puts %Q{
+A Value Type is a kind of Object Type which has an accepted written form.
+For example, a Name or a Date can be written, but a Person cannot. A Year
+is not a Value Type, but a Year Number is.
+
+Every written value must uniquely identify one instance of that Value Type.
+A value may have more than one written form. For example, the number 10000
+may also be written 10E4. A written value may identify a single instance of
+more than one value type however; the string '9/11' may identify a fraction,
+or an event.
+
+Value Types are asserted by the phrase "is written as":
+
+	Birth Date is written as Date;
+	Employee Nr is written as Integer;
+
+If the supertype (the value type after "is written as") is unknown, it is
+also asserted as a Value Type.
+
+A Value Type may have implicit length and scale properties, and in future,
+may also have custom properties. Property values are defined in parentheses
+after the supertype:
+
+	Money Amount is written as Decimal(14, 2);
+	Company Name is written as String(60);
+
+After any parameter list, a Value Type may be associated with a Unit, and be
+subject to a Value Restriction (using "restricted to { <values or ranges> }").
+Either the low end or the high end of a range may be omitted for an open range.
+
+	Drill Size is written as Real in mm restricted to { 0.3, 0.5..15.0};
+}
+	when /vocabulary/
+	  %q{
+Every CQL definition or instance exists in some vocabulary, so you must
+specify a vocabulary name before any other definitions:
+
+	vocabulary Employment;
+	... definitions...
+}
+	else
+	  puts "topic #{word} is unknown"
+	end
+      end
+    end
+  end
+end
+
+compiler = InteractiveCQL.new
+statement = nil
+puts "Enter / for help on special commands"
+while line = Readline::readline(statement ? "CQL+ " : "CQL? ", [])
+  statement = statement ? statement + "\n"+line : line
+  if line =~ %r{\A/}
+    compiler.metacommand(line)
+    statement = nil
+  elsif compiler.root != :definition or
+      line.gsub(/(['"])([^\1\\]|\\.)*\1/,'') =~ /[;?]/
+    # After stripping string literals the line contains a ';' or /?', we've found the last line of the command:
+    compiler.process(statement)
     statement = nil
   end
 end