activefacts 0.7.3 → 0.8.5

data/spec/cql_mysql_spec.rb

@@ -0,0 +1,70 @@
+#
+# ActiveFacts tests: Parse all CQL files and check the generated SQL.
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+
+require 'spec/spec_helper'
+require 'stringio'
+require 'activefacts/vocabulary'
+require 'activefacts/support'
+require 'activefacts/input/cql'
+require 'activefacts/generate/sql/mysql'
+
+include ActiveFacts
+include ActiveFacts::Metamodel
+
+describe "CQL Loader with SQL output" do
+  cql_failures = {
+    "Airline" => "Contains queries, unsupported",
+    "CompanyQuery" => "Contains queries, unsupported",
+    "OrienteeringER" => "Doesn't parse due to difficult fact type match",
+    "ServiceDirector" => "Doesn't parse some constraints due to mis-matched adjectives"
+  }
+  cql_mysql_failures = {
+    "Metamodel" => "An index to enforce uniqueness on the nesting fact type isn't emitted",
+  }
+
+  # Generate and return the SQL for the given vocabulary
+  def sql(vocabulary)
+    output = StringIO.new
+    @dumper = ActiveFacts::Generate::SQL::MYSQL.new(vocabulary.constellation, "norma")
+    @dumper.generate(output)
+    output.rewind
+    output.read
+  end
+
+  pattern = ENV["AFTESTS"] || "*"
+  Dir["examples/CQL/#{pattern}.cql"].each do |cql_file|
+    actual_file = cql_file.sub(%r{examples/CQL/(.*).cql}, 'spec/actual/\1.my.sql')
+    expected_file = cql_file.sub(%r{examples/CQL/(.*).cql\Z}, 'examples/MySQL/\1.sql')
+
+    it "should load #{cql_file} and dump MySQL matching #{expected_file}" do
+      broken = cql_failures[File.basename(cql_file, ".cql")]
+      vocabulary = nil
+      if broken
+        pending(broken) {
+          lambda { vocabulary = ActiveFacts::Input::CQL.readfile(cql_file) }.should_not raise_error
+        }
+      else
+        lambda { vocabulary = ActiveFacts::Input::CQL.readfile(cql_file) }.should_not raise_error
+      end
+
+      # Build and save the actual file:
+      sql_text = sql(vocabulary)
+      File.open(actual_file, "w") { |f| f.write sql_text }
+
+      pending("expected output file #{expected_file} not found") unless File.exists? expected_file
+
+      expected_text = File.open(expected_file) {|f| f.read }
+      broken = cql_mysql_failures[File.basename(actual_file, ".cql")]
+      if broken
+        pending(broken) {
+          sql_text.should_not differ_from(expected_text)
+        }
+      else
+        sql_text.should_not differ_from(expected_text)
+        File.delete(actual_file)  # It succeeded, we don't need the file.
+      end
+    end
+  end
+end

data/spec/cql_parse_spec.rb

@@ -2,7 +2,7 @@
 # ActiveFacts tests: Parse all NORMA files and check the generated CQL.
 # Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
 #
-require 'rubygems'
+
 require 'stringio'
 require 'activefacts/vocabulary'
 require 'activefacts/support'
@@ -12,19 +12,25 @@ require 'activefacts/generate/cql'
 include ActiveFacts
 
 describe "CQL Parser" do
-  CQLPARSE_FAILURES = %w{
-    Airline
-    CompanyQuery
-    Insurance
-    OrienteeringER
-    ServiceDirector
+  cql_failures = {
+    "Airline" => "Contains queries, unsupported",
+    "CompanyQuery" => "Contains queries, unsupported",
+    "OrienteeringER" => "Contains a long fact type that can't be matched properly",
+    "ServiceDirector" => "Contains constraints with mismatched adjectives",
   }
 
   pattern = ENV["AFTESTS"] || "*"
   Dir["examples/CQL/#{pattern}.cql"].each do |cql_file|
     it "should load CQL #{cql_file} without parse errors" do
-      pending if CQLPARSE_FAILURES.include? File.basename(cql_file, ".cql")
-      lambda { vocabulary = ActiveFacts::Input::CQL.readfile(cql_file) }.should_not raise_error
+      broken = cql_failures[File.basename(cql_file, ".cql")]
+
+      if broken
+        pending(broken) {
+          lambda { vocabulary = ActiveFacts::Input::CQL.readfile(cql_file) }.should_not raise_error
+        }
+      else
+        lambda { vocabulary = ActiveFacts::Input::CQL.readfile(cql_file) }.should_not raise_error
+      end
     end
   end
 end

data/spec/cql_ruby_spec.rb

@@ -2,7 +2,8 @@
 # ActiveFacts tests: Parse all CQL files and check the generated Ruby.
 # Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
 #
-require 'rubygems'
+
+require 'spec/spec_helper'
 require 'stringio'
 require 'activefacts/vocabulary'
 require 'activefacts/support'
@@ -19,13 +20,11 @@ class String
 end
 
 describe "CQL Loader with Ruby output" do
-  CQL_RUBY_FAILURES = %w{
-    Airline
-    CompanyQuery
-    Insurance
-    OrienteeringER
-    Orienteering
-    ServiceDirector
+  cql_failures = {
+    "Airline" => "Contains queries, not supported",
+    "CompanyQuery" => "Contains queries, not supported",
+    "OrienteeringER" => "Large fact type reading cannot be matched",
+    "ServiceDirector" => "Constraints contain adjectives that require looser matching",
   }
 
   # Generate and return the Ruby for the given vocabulary
@@ -43,16 +42,31 @@ describe "CQL Loader with Ruby output" do
     actual_file = cql_file.sub(%r{examples/CQL/(.*).cql\Z}, 'spec/actual/\1.rb')
 
     it "should load #{cql_file} and dump Ruby matching #{expected_file}" do
-      pending if CQL_RUBY_FAILURES.include? File.basename(cql_file, ".cql")
-      vocabulary = ActiveFacts::Input::CQL.readfile(cql_file)
+      vocabulary = nil
+      broken = cql_failures[File.basename(cql_file, ".cql")]
+      if broken
+        pending(broken) {
+          vocabulary = ActiveFacts::Input::CQL.readfile(cql_file)
+        }
+      else
+        vocabulary = ActiveFacts::Input::CQL.readfile(cql_file)
+      end
 
       # Build and save the actual file:
       ruby_text = ruby(vocabulary)
       File.open(actual_file, "w") { |f| f.write ruby_text }
 
-      pending unless File.exists? expected_file
-      ruby_text.should == File.open(expected_file) {|f| f.read }
-      File.delete(actual_file)  # It succeeded, we don't need the file.
+      pending("expected output file #{expected_file} not found") unless File.exists? expected_file
+
+      expected_text = File.open(expected_file) {|f| f.read }
+#      if broken
+#        pending(broken) {
+#          ruby_text.should == File.open(expected_file) {|f| f.read }
+#        }
+#      else
+        ruby_text.should_not differ_from(expected_text)
+        File.delete(actual_file)  # It succeeded, we don't need the file.
+#      end
     end
   end
 end

data/spec/cql_sql_spec.rb

@@ -2,7 +2,8 @@
 # ActiveFacts tests: Parse all CQL files and check the generated SQL.
 # Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
 #
-require 'rubygems'
+
+require 'spec/spec_helper'
 require 'stringio'
 require 'activefacts/vocabulary'
 require 'activefacts/support'
@@ -13,16 +14,25 @@ include ActiveFacts
 include ActiveFacts::Metamodel
 
 describe "CQL Loader with SQL output" do
-  CQL_SQL_FAILURES = %w{
-    Airline
-    CompanyDirectorEmployee
-    CompanyQuery
-    Insurance
-    JoinEquality
-    Marriage
-    OrienteeringER
-    ServiceDirector
-    SimplestUnary
+  cql_failures = {
+    "Airline" => "Contains unsupported queries",
+    "CompanyQuery" => "Contains unsupported queries",
+    "OrienteeringER" => "Large fact type reading cannot be matched",
+    "ServiceDirector" => "Constraints contain adjectives that require looser matching",
+  }
+  cql_sql_failures = {
+    "Blog" => "Drops uniqueness constraints",
+    "CompanyDirectorEmployee" => "Names an index automatically from CQL, but explicitly from NORMA",
+    "Insurance" => "CQL doesn't have an option for subtype separation",
+    "Metamodel" =>
+        "Names an index automatically from CQL, but explicitly from NORMA" + " " +
+        "Drops uniqueness constraints",
+    "Orienteering" =>
+        "Names an index automatically from CQL, but explicitly from NORMA" + " " +
+        "Drops uniqueness constraints",
+    "RedundantDependency" => "Drops uniqueness constraints",
+    "SubtypePI" => "Names an index automatically from CQL, but explicitly from NORMA",
+    "Tests.Test5.Load" => "Names an index automatically from CQL, but explicitly from NORMA",
   }
 
   # Generate and return the SQL for the given vocabulary
@@ -40,16 +50,32 @@ describe "CQL Loader with SQL output" do
     expected_file = cql_file.sub(%r{examples/CQL/(.*).cql\Z}, 'examples/SQL/\1.sql')
 
     it "should load #{cql_file} and dump SQL matching #{expected_file}" do
-      pending if CQL_SQL_FAILURES.include? File.basename(cql_file, ".cql")
-      vocabulary = ActiveFacts::Input::CQL.readfile(cql_file)
+      vocabulary = nil
+      broken = cql_failures[File.basename(cql_file, ".cql")]
+      if broken
+        pending(broken) {
+          vocabulary = ActiveFacts::Input::CQL.readfile(cql_file)
+        }
+      else
+        vocabulary = ActiveFacts::Input::CQL.readfile(cql_file)
+      end
 
       # Build and save the actual file:
       sql_text = sql(vocabulary)
       File.open(actual_file, "w") { |f| f.write sql_text }
 
-      pending unless File.exists? expected_file
-      sql_text.should == File.open(expected_file) {|f| f.read }
-      File.delete(actual_file)  # It succeeded, we don't need the file.
+      pending("expected output file #{expected_file} not found") unless File.exists? expected_file
+
+      expected_text = File.open(expected_file) {|f| f.read }
+      broken = cql_sql_failures[File.basename(cql_file, ".cql")]
+      if broken
+        pending(broken) {
+          sql_text.should_not differ_from(expected_text)
+        }
+      else
+        sql_text.should_not differ_from(expected_text)
+        File.delete(actual_file)  # It succeeded, we don't need the file.
+      end
     end
   end
 end

data/spec/cql_symbol_tables_spec.rb

@@ -2,8 +2,7 @@
 # ActiveFacts tests: Test the CQL parser by looking at its parse trees.
 # Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
 #
-require 'rubygems'
-require 'treetop'
+
 require 'activefacts/support'
 require 'activefacts/api/support'
 require 'activefacts/input/cql'
@@ -19,7 +18,7 @@ describe "CQL Symbol table" do
     include ActiveFacts::Input::CQL
     @constellation = ActiveFacts::API::Constellation.new(ActiveFacts::Metamodel)
     @vocabulary = @constellation.Vocabulary("Test")
-    @symbols = ActiveFacts::Input::CQL::SymbolTable.new(@constellation, @vocabulary)
+    @symbols = ActiveFacts::CQL::Compiler::SymbolTable.new(@constellation, @vocabulary)
   end
 
   Definitions = [

data/spec/cqldump_spec.rb

@@ -2,7 +2,7 @@
 # ActiveFacts tests: Test the generated CQL for some simple cases.
 # Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
 #
-require 'rubygems'
+
 require 'stringio'
 require 'activefacts/support'
 require 'activefacts/vocabulary'
@@ -70,8 +70,8 @@ END
   def one_to_many(one, many, reading)
     # Join them with a fact type:
     ft = @constellation.FactType(:new)
-    role0 = @constellation.Role(ft, 0, one)
-    role1 = @constellation.Role(ft, 1, many)
+    role0 = @constellation.Role(ft, 0, :concept => one)
+    role1 = @constellation.Role(ft, 1, :concept => many)
 
     # Make a role sequence:
     rs = @constellation.RoleSequence(:new)
@@ -84,7 +84,7 @@ END
     pc = @constellation.PresenceConstraint(:new, :is_mandatory => false, :is_preferred_identifier => false, :max_frequency => 1, :min_frequency => 0, :role_sequence => pcrs)
 
     # Make a new reading:
-    reading = @constellation.Reading(ft, ft.all_reading.size, :role_sequence => rs, :reading_text => reading)
+    reading = @constellation.Reading(ft, ft.all_reading.size, :role_sequence => rs, :text => reading)
 
     ft
   end
@@ -92,8 +92,8 @@ END
   def one_to_one(first, second, reading)
     # Join them with a fact type:
     ft = @constellation.FactType(:new)
-    role0 = @constellation.Role(ft, 0, first)
-    role1 = @constellation.Role(ft, 1, second)
+    role0 = @constellation.Role(ft, 0, :concept => first)
+    role1 = @constellation.Role(ft, 1, :concept => second)
 
     # Make a role sequence for the reading
     rs = @constellation.RoleSequence(:new)
@@ -101,7 +101,7 @@ END
     rr1 = @constellation.RoleRef(rs, 1, :role => role1)
 
     # Make a new reading:
-    reading = @constellation.Reading(ft, ft.all_reading.size, :role_sequence => rs, :reading_text => reading)
+    reading = @constellation.Reading(ft, ft.all_reading.size, :role_sequence => rs, :text => reading)
 
     # Make a uniqueness constraint for the first role
     first_rs = @constellation.RoleSequence(:new)

data/spec/helpers/file_matcher.rb

@@ -0,0 +1,39 @@
+require 'diff/lcs'
+
+module FileMatcher
+  class BeDifferent
+    def initialize(expected)
+      @expected = expected.scan(/[^\n]+/)
+    end
+
+    def matches?(actual)
+      actual_lines = actual.scan(/[^\n]+/)
+      differences = Diff::LCS::diff(@expected, actual_lines)
+      @diff = differences.map do |chunk|
+          added_at = (add = chunk.detect{|d| d.action == '+'}) && add.position+1
+          removed_at = (remove = chunk.detect{|d| d.action == '-'}) && remove.position+1
+          "Line #{added_at}/#{removed_at}:\n"+
+          chunk.map do |change|
+            "#{change.action} #{change.element}"
+          end*"\n"
+        end*"\n"
+      @diff != ''
+    end
+
+    def failure_message
+      "expected a difference, but got none"
+    end
+
+    def negative_failure_message
+      "expected no difference, but got:\n#{@diff}"
+    end
+  end
+
+  def differ_from(expected)
+    BeDifferent.new(expected)
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.include(FileMatcher)
+end

data/spec/norma_cql_spec.rb

@@ -2,7 +2,8 @@
 # ActiveFacts tests: Parse all NORMA files and check the generated CQL.
 # Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
 #
-require 'rubygems'
+
+require 'spec/spec_helper'
 require 'stringio'
 require 'activefacts/vocabulary'
 require 'activefacts/support'
@@ -12,9 +13,8 @@ require 'activefacts/generate/cql'
 include ActiveFacts
 
 describe "Norma Loader" do
-  ORM_CQL_FAILURES = %w{
-    OddIdentifier
-    ServiceDirector
+  orm_cql_failures = {
+#    "OddIdentifier" => "Strange identification pattern is incorrectly verbalised to CQL",  # Fixed
   }
   # Generate and return the CQL for the given vocabulary
   def cql(vocabulary)
@@ -22,26 +22,34 @@ describe "Norma Loader" do
     @dumper = ActiveFacts::Generate::CQL.new(vocabulary.constellation)
     @dumper.generate(output)
     output.rewind
-    output.readlines
+    output.read
   end
 
   pattern = ENV["AFTESTS"] || "*"
   Dir["examples/norma/#{pattern}.orm"].each do |orm_file|
     expected_file = orm_file.sub(%r{/norma/(.*).orm\Z}, '/CQL/\1.cql')
-
     actual_file = orm_file.sub(%r{examples/norma/(.*).orm\Z}, 'spec/actual/\1.cql')
 
     it "should load #{orm_file} and dump CQL matching #{expected_file}" do
-      pending if ORM_CQL_FAILURES.include? File.basename(orm_file, ".orm")
       vocabulary = ActiveFacts::Input::ORM.readfile(orm_file)
 
-      cql = cql(vocabulary)
+      cql_text = cql(vocabulary)
       # Save the actual file:
-      File.open(actual_file, "w") { |f| f.write cql*"" }
+      File.open(actual_file, "w") { |f| f.write cql_text }
+
+      pending("expected output file #{expected_file} not found") unless File.exists? expected_file
+
+      expected_text = File.open(expected_file) {|f| f.read }
 
-      pending unless File.exists? expected_file
-      cql.should == File.open(expected_file) {|f| f.readlines}
-      File.delete(actual_file)
+      broken = orm_cql_failures[File.basename(orm_file, ".orm")]
+      if broken
+        pending(broken) {
+          cql_text.should_not differ_from(expected_text)
+        }
+      else
+        cql_text.should_not differ_from(expected_text)
+        File.delete(actual_file)
+      end
     end
   end
 end

data/spec/norma_ruby_spec.rb

@@ -2,7 +2,8 @@
 # ActiveFacts tests: Parse all CQL files and check the generated Ruby.
 # Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
 #
-require 'rubygems'
+
+require 'spec/spec_helper'
 require 'stringio'
 require 'activefacts/vocabulary'
 require 'activefacts/support'
@@ -40,8 +41,10 @@ describe "NORMA Loader with Ruby output" do
       ruby_text = ruby(vocabulary)
       File.open(actual_file, "w") { |f| f.write ruby_text }
 
-      pending unless File.exists? expected_file
-      ruby_text.should == File.open(expected_file) {|f| f.read }
+      pending("expected output file #{expected_file} not found") unless File.exists? expected_file
+
+      expected_text = File.open(expected_file) {|f| f.read }
+      ruby_text.should_not differ_from(expected_text)
       File.delete(actual_file)  # It succeeded, we don't need the file.
     end
   end