activefacts 0.8.6 → 0.8.8

data/spec/cql_mysql_spec.rb

@@ -10,15 +10,10 @@ 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",
@@ -27,7 +22,7 @@ describe "CQL Loader with SQL output" do
   # 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 = ActiveFacts::Generate::SQL::MYSQL.new(vocabulary.constellation)
     @dumper.generate(output)
     output.rewind
     output.read
@@ -53,7 +48,8 @@ describe "CQL Loader with SQL output" do
       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
+      next unless File.exists? expected_file
+      # ("expected output file #{expected_file} not found")
 
       expected_text = File.open(expected_file) {|f| f.read }
       broken = cql_mysql_failures[File.basename(actual_file, ".cql")]

data/spec/cql_parse_spec.rb

@@ -9,14 +9,10 @@ require 'activefacts/support'
 require 'activefacts/input/cql'
 require 'activefacts/generate/cql'
 
-include ActiveFacts
-
 describe "CQL Parser" do
   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"] || "*"

data/spec/cql_ruby_spec.rb

@@ -10,8 +10,6 @@ require 'activefacts/support'
 require 'activefacts/input/cql'
 require 'activefacts/generate/ruby'
 
-include ActiveFacts
-
 class String
   def strip_comments()
     c_comment = %r{/\*((?!\*/).)*\*/}m
@@ -23,8 +21,7 @@ describe "CQL Loader with Ruby output" do
   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",
+    # "OrienteeringER" => "Invalid model, it just works differently in CQL"
   }
 
   # Generate and return the Ruby for the given vocabulary

data/spec/cql_sql_spec.rb

@@ -10,35 +10,19 @@ require 'activefacts/support'
 require 'activefacts/input/cql'
 require 'activefacts/generate/sql/server'
 
-include ActiveFacts
-include ActiveFacts::Metamodel
-
 describe "CQL Loader with SQL output" do
   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",
+    "OrienteeringER" => "Invalid model, it just works differently in CQL"
   }
 
   # Generate and return the SQL for the given vocabulary
   def sql(vocabulary)
     output = StringIO.new
-    @dumper = ActiveFacts::Generate::SQL::SERVER.new(vocabulary.constellation, "norma")
+    @dumper = ActiveFacts::Generate::SQL::SERVER.new(vocabulary.constellation)
     @dumper.generate(output)
     output.rewind
     output.read
@@ -73,6 +57,9 @@ describe "CQL Loader with SQL output" do
           sql_text.should_not differ_from(expected_text)
         }
       else
+        # Discard index names:
+        sql_text.gsub!(/(CREATE .* INDEX )([^ ]* )ON /, '\1ON ')
+        expected_text.gsub!(/(CREATE .* INDEX )([^ ]* )ON /, '\1ON ')
         sql_text.should_not differ_from(expected_text)
         File.delete(actual_file)  # It succeeded, we don't need the file.
       end

data/spec/cql_symbol_tables_spec.rb

@@ -3,6 +3,8 @@
 # Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
 #
 
+=begin
+
 require 'activefacts/support'
 require 'activefacts/api/support'
 require 'activefacts/input/cql'
@@ -256,3 +258,4 @@ describe "CQL Symbol table" do
   end
 
 end
+=end

data/spec/cqldump_spec.rb

@@ -8,8 +8,6 @@ require 'activefacts/support'
 require 'activefacts/vocabulary'
 require 'activefacts/generate/cql'
 
-include ActiveFacts
-
 describe "CQL Dumper" do
   def self.hide(*a,&b)
   end

data/spec/helpers/array_matcher.rb

@@ -0,0 +1,35 @@
+require 'pathname'
+
+module ArrayMatcher
+  class BeDifferentArray
+    def initialize(expected)
+      @expected = expected
+    end
+
+    def matches?(actual)
+      @extra = actual - @expected
+      @missing = @expected - actual
+      @extra + @missing != []   # Because the predicate is "be_different_array_from", the sense is inverted
+    end
+
+    def failure_message
+      "expected a difference in the two lists, but got none"
+    end
+
+    def negative_failure_message
+      "expected no difference, but result #{
+        [ (@missing.empty? ? nil : 'lacks '+@missing.sort.inspect),
+          (@extra.empty? ? nil : 'has extra '+@extra.sort.inspect)
+        ].compact * ' and '
+      }"
+    end
+  end
+
+  def be_different_array_from(expected)
+    BeDifferentArray.new(expected)
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.include(ArrayMatcher)
+end

data/spec/helpers/ctrl_c_support.rb

@@ -0,0 +1,52 @@
+# Monkey patch in CTRL-C support for rspec from 
+# http://github.com/dchelimsky/rspec/commit/029f77c5063894cf52af05335b8e1c278411978b
+# until it gets released
+
+module Spec
+  module Example
+    module ExampleMethods
+      def execute(run_options, instance_variables) # :nodoc:
+        run_options.reporter.example_started(@_proxy)
+        set_instance_variables_from_hash(instance_variables)
+ 
+        execution_error = nil
+        Timeout.timeout(run_options.timeout) do
+          begin
+            before_each_example
+            instance_eval(&@_implementation)
+          rescue Interrupt
+            exit 1
+          rescue Exception => e
+            execution_error ||= e
+          end
+          begin
+            after_each_example
+          rescue Interrupt
+            exit 1
+          rescue Exception => e
+            execution_error ||= e
+          end
+        end
+ 
+        run_options.reporter.example_finished(@_proxy.update(description), execution_error)
+        success = execution_error.nil? || ExamplePendingError === execution_error
+      end
+    end
+  end
+end
+
+module Spec
+  module Runner
+    class ExampleGroupRunner
+      def run
+        prepare
+        success = true
+        example_groups.each do |example_group|
+          success = success & example_group.run(@options)
+        end
+        finish
+        success
+      end
+    end
+  end
+end

data/spec/helpers/diff_matcher.rb

@@ -0,0 +1,38 @@
+require 'pathname'
+
+module DiffMatcher
+  class DifferFrom
+    def initialize(expected)
+      case expected
+      when Pathname
+        @matcher = FileMatcher::BeDifferentFile.new(expected)
+      when Array
+        @matcher = ArrayMatcher::BeDifferentArray.new(expected)
+      when String
+        @matcher = FileMatcher::BeDifferentFile.new(expected)
+      else
+        raise "DiffMatcher doesn't know how to match a #{expected.class}"
+      end
+    end
+
+    def matches?(actual)
+      @matcher.matches?(actual)
+    end
+
+    def failure_message
+      @matcher.failure_message
+    end
+
+    def negative_failure_message
+      @matcher.negative_failure_message
+    end
+  end
+
+  def differ_from(expected)
+    DifferFrom.new(expected)
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.include(DiffMatcher)
+end

data/spec/helpers/file_matcher.rb

@@ -1,12 +1,14 @@
 require 'diff/lcs'
 
 module FileMatcher
-  class BeDifferent
+  class BeDifferentFile
     def initialize(expected)
+      expected = File.open(expected).read if expected.is_a?(Pathname)
       @expected = expected.scan(/[^\n]+/)
     end
 
     def matches?(actual)
+      actual = File.open(actual).read if actual.is_a?(Pathname)
       actual_lines = actual.scan(/[^\n]+/)
       differences = Diff::LCS::diff(@expected, actual_lines)
       @diff = differences.map do |chunk|
@@ -29,8 +31,8 @@ module FileMatcher
     end
   end
 
-  def differ_from(expected)
-    BeDifferent.new(expected)
+  def have_different_contents(expected)
+    BeDifferentFile.new(expected)
   end
 end
 

data/spec/helpers/string_matcher.rb

@@ -0,0 +1,39 @@
+require 'diff/lcs'
+
+module StringMatcher
+  class BeDifferentString
+    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 have_different_contents(expected)
+    BeDifferentString.new(expected)
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.include(StringMatcher)
+end

data/spec/helpers/test_parser.rb

@@ -0,0 +1,13 @@
+# The test parser regards any word starting with an upper-case letter as a pre-existing term
+class TestParser < ActiveFacts::CQL::Parser
+  def context
+    @context ||= Context.new(self)
+  end     
+
+  class Context < ActiveFacts::CQL::Parser::Context
+    # Capitalised words that are otherwise undefined are treated as terms:
+    def system_term(t)
+      (first = t[0,1] and first.upcase == first) ? {t=>t} : false
+    end
+  end
+end

data/spec/norma_cql_spec.rb

@@ -10,11 +10,13 @@ require 'activefacts/support'
 require 'activefacts/input/orm'
 require 'activefacts/generate/cql'
 
-include ActiveFacts
-
 describe "Norma Loader" do
+  orm_failures = {
+    "SubtypePI" => "Has an illegal uniqueness join constraint",
+  }
   orm_cql_failures = {
-#    "OddIdentifier" => "Strange identification pattern is incorrectly verbalised to CQL",  # Fixed
+    # "OddIdentifier" => "Strange identification pattern is incorrectly verbalised to CQL",  # Fixed
+    "UnaryIdentification" => "No PI for VisitStatus",
   }
   # Generate and return the CQL for the given vocabulary
   def cql(vocabulary)
@@ -29,9 +31,15 @@ describe "Norma Loader" do
   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')
+    base = File.basename(orm_file, ".orm")
 
     it "should load #{orm_file} and dump CQL matching #{expected_file}" do
-      vocabulary = ActiveFacts::Input::ORM.readfile(orm_file)
+      begin
+        vocabulary = ActiveFacts::Input::ORM.readfile(orm_file)
+      rescue => e
+        raise unless orm_failures.include?(base)
+        pending orm_failures[base]
+      end
 
       cql_text = cql(vocabulary)
       # Save the actual file:
@@ -41,7 +49,7 @@ describe "Norma Loader" do
 
       expected_text = File.open(expected_file) {|f| f.read }
 
-      broken = orm_cql_failures[File.basename(orm_file, ".orm")]
+      broken = orm_cql_failures[base]
       if broken
         pending(broken) {
           cql_text.should_not differ_from(expected_text)

data/spec/norma_ruby_spec.rb

@@ -10,8 +10,6 @@ require 'activefacts/support'
 require 'activefacts/input/orm'
 require 'activefacts/generate/ruby'
 
-include ActiveFacts
-
 class String
   def strip_comments()
     c_comment = %r{/\*((?!\*/).)*\*/}m
@@ -20,6 +18,10 @@ class String
 end
 
 describe "NORMA Loader with Ruby output" do
+  orm_failures = {
+    "SubtypePI" => "Has an illegal uniqueness join constraint",
+  }
+
   # Generate and return the Ruby for the given vocabulary
   def ruby(vocabulary)
     output = StringIO.new
@@ -33,9 +35,15 @@ describe "NORMA Loader with Ruby output" do
   Dir["examples/norma/#{pattern}.orm"].each do |orm_file|
     expected_file = orm_file.sub(%r{examples/norma/(.*).orm\Z}, 'examples/ruby/\1.rb')
     actual_file = orm_file.sub(%r{examples/norma/(.*).orm\Z}, 'spec/actual/\1.rb')
+    base = File.basename(orm_file, ".orm")
 
     it "should load #{orm_file} and dump Ruby matching #{expected_file}" do
-      vocabulary = ActiveFacts::Input::ORM.readfile(orm_file)
+      begin
+        vocabulary = ActiveFacts::Input::ORM.readfile(orm_file)
+      rescue => e
+        raise unless orm_failures.include?(base)
+        pending orm_failures[base]
+      end
 
       # Build and save the actual file:
       ruby_text = ruby(vocabulary)

data/spec/{absorption_ruby_spec.rb → norma_ruby_sql_spec.rb}

@@ -3,6 +3,7 @@
 # Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
 #
 
+require 'spec/spec_helper'
 require 'stringio'
 require 'activefacts/vocabulary'
 require 'activefacts/support'
@@ -10,13 +11,14 @@ require 'activefacts/input/orm'
 require 'activefacts/persistence'
 require 'activefacts/generate/ruby'
 
-include ActiveFacts
-
 describe "Column lists from absorption compared with Ruby's" do
-  ABSORPTION_RUBY_FAILURES = {
-    "Metamodel" => "Overlaps with ActiveFacts Metamodel",
-    "MetamodelNext" => "Overlaps with ActiveFacts Metamodel",
-    "ServiceDirector" => "Lacks standard AutoTimestamp class"
+  orm_failures = {
+    "SubtypePI" => "Has an illegal uniqueness join constraint",
+  }
+  norma_ruby_failures = {
+    "UnaryIdentification" => "No PI for VisitStatus",
+    "BPMN" => "Has duplicate column names",
+    "Diplomacy" => "Has duplicate column names",
   }
 
   # Generate and return the Ruby for the given vocabulary
@@ -32,29 +34,52 @@ describe "Column lists from absorption compared with Ruby's" do
   Dir["examples/norma/#{pattern}.orm"].each do |orm_file|
     expected_file = orm_file.sub(%r{examples/norma/(.*).orm\Z}, 'examples/ruby/\1.rb')
     actual_file = orm_file.sub(%r{examples/norma/(.*).orm\Z}, 'spec/actual/\1.rb')
+    base = File.basename(orm_file, ".orm")
 
     it "should load #{orm_file} and generate relational composition and Ruby with matching column names" do
-      vocabulary = ActiveFacts::Input::ORM.readfile(orm_file)
+      begin
+        vocabulary = ActiveFacts::Input::ORM.readfile(orm_file)
+      rescue => e
+        raise unless orm_failures.include?(base)
+        pending orm_failures[base]
+      end
 
       # Get the list of tables from the relational composition:
       absorption_tables = vocabulary.tables.sort_by(&:name)
-      absorption_table_names = absorption_tables.map{|at| at.name}
+      absorption_table_names = absorption_tables.map{|at| at.name.gsub(/\s/,'')}
 
       # Build the Ruby and eval it:
       ruby_text = ruby(vocabulary)
       File.open(actual_file, "w") { |f| f.write ruby_text }
 
-      broken = ABSORPTION_RUBY_FAILURES[File.basename(orm_file, ".orm")]
-      eval_it = lambda { Object.send :eval, ruby_text }
+      broken = norma_ruby_failures[base]
+      eval_it = lambda {
+        Object.send :eval, ruby_text
+      }
+      exception = nil
       if broken
         pending(broken) {
           lambda {
-            eval_it.call
+            begin
+              eval_it.call
+            rescue => exception
+              if debug :exception
+                puts exception.to_s+": \n\t"+exception.backtrace*"\n\t"
+              end
+              raise
+            end
           }.should_not raise_error
         }
       else
         lambda {
+          begin
             eval_it.call
+          rescue => exception
+            if debug :exception
+              puts exception.to_s+": \n\t"+exception.backtrace*"\n\t"
+            end
+            raise
+          end
         }.should_not raise_error
       end
 
@@ -69,27 +94,7 @@ describe "Column lists from absorption compared with Ruby's" do
       ruby_table_names = ruby_tables.map{|c| c.basename}
 
       # Assert that the list of tables is the same:
-      tables = lambda { ruby_table_names.should == absorption_table_names }
-      if broken
-        pending { tables.call }
-      else
-        tables.call
-      end
-
-      # So we get to see the full differences, figure them here and assert them to be empty:
-      diffs = {}
-      ruby_tables.each{|rt|
-        next unless rt.is_entity_type
-        absorption_table = absorption_tables.select{|at| at.name == rt.basename}[0]
-        absorption_columns = absorption_table.columns.map{|c| c.name("").downcase}.sort
-        ruby_columns = rt.columns.map{|c| c.gsub(/\./,'').downcase}.sort
-        missing = absorption_columns - ruby_columns
-        extra = ruby_columns - absorption_columns
-        unless missing.empty? and extra.empty?
-          diffs[rt.basename] = missing.map{|m| "-"+m} + extra.map{|e| '+'+e}
-        end
-      }
-      diffs.should == {}
+      ruby_table_names.should_not differ_from(absorption_table_names)
 
       # Clean up:
       Object.send :remove_const, vocabulary.name.to_sym