activefacts 1.6.0 → 1.7.1

data/spec/cql_cql_spec.rb

@@ -1,73 +0,0 @@
-#
-# ActiveFacts tests: Parse all CQL files and check the generated CQL.
-# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
-#
-
-require File.dirname(__FILE__) + '/spec_helper'
-require 'stringio'
-require 'activefacts/vocabulary'
-require 'activefacts/support'
-require 'activefacts/input/cql'
-require 'activefacts/generate/cql'
-
-describe "CQL Loader" do
-  cql_failures = {
-    "Airline" => "Contains queries, unsupported",
-    "CompanyQuery" => "Contains queries, unsupported",
-    #"MetamodelNext" => "Fails due to weak adjective/role matching",
-    #"ServiceDirector" => "Doesn't parse some constraints due to mis-matched adjectives",
-    #"OddIdentifier" => "The odd identifier is built correctly but cannot be found by the current implementation",
-    "units" => "Unit verbalisation into CQL is not implemented"
-  }
-  cql_cql_failures = {
-#    "Insurance" => "Misses a query in a subset constraint",
-#    "OddIdentifier" => "Doesn't support identification of object fact types using mixed external/internal roles",
-  }
-  # Generate and return the CQL for the given vocabulary
-  def cql(vocabulary)
-    output = StringIO.new
-    @dumper = ActiveFacts::Generate::CQL.new(vocabulary.constellation)
-    @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/}, 'spec/actual/')
-
-    it "should load CQL and dump valid CQL for #{cql_file}" do
-      broken = cql_failures[File.basename(actual_file, ".cql")]
-      vocabulary = nil
-      if broken
-        pending(broken) {
-          vocabulary = ActiveFacts::Input::CQL.readfile(cql_file)
-        }
-      else
-        begin
-          vocabulary = ActiveFacts::Input::CQL.readfile(cql_file)
-        rescue => e
-          trace :exception, "#{e.message}\n" +
-            "\t#{e.backtrace*"\n\t"}"
-          raise
-        end
-      end
-      vocabulary.finalise
-
-      # Build and save the actual file:
-      cql_text = cql(vocabulary)
-      File.open(actual_file, "w") { |f| f.write cql_text }
-      expected_text = File.open(cql_file) {|f| f.read }
-
-      broken = cql_cql_failures[File.basename(actual_file, ".cql")]
-      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)  # It succeeded, we don't need the file.
-      end
-    end
-  end
-end

data/spec/cql_dm_spec.rb

@@ -1,136 +0,0 @@
-#
-# ActiveFacts tests: Parse all CQL files and check the generated DataMapper models
-# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
-#
-# From IRC, on how to extract the SQL that DM creates for a set of models:
-#
-# I can tell you that ::DataObjects::Connection#log gets you the SQL
-# after its run (not exactly what you asked for, but a place to start
-# looking).
-# 
-# your choices are intercepting
-# ::DataMapper::Adapters::DataObjectsAdapter#{select,execute} for
-# direct SQL calls, or at a lower level,
-# ::DataObjects::Connection#create_command for all SQL.
-# 
-# one trick I've been using is to selectively intercept the latter
-# and not let it run (no-op it but log/inspect it), which can obviously
-# screw up anything else back up the call stack but at least gives
-# you the opportunity to catch it if you want.
-# 
-# #create_command returns Command, which is subsequently called with
-# #execute_reader(bind_values) or #execute_non_query(bind_values),
-# so if the final query is what you're after, then you'll have to
-# hook those both instead.
-
-if false
-
-require 'spec_helper'
-require 'stringio'
-require 'activefacts/vocabulary'
-require 'activefacts/support'
-require 'activefacts/input/cql'
-require 'activefacts/generate/dm'
-require 'dm-core'
-require 'dm-core/spec/lib/spec_helper'
-
-#def SecureRandom.uuid
-#  @@counter ||= 99999999999
-#  h = "%032X" % @@counter
-#  @@counter -= 1
-#  h.
-#    sub(
-#      @@format_pattern ||= /(........)(....)(....)(....)(............)/,
-#      @@format_string ||= '\1-\2-\3-\4-\5'
-#    )
-#end
-
-describe "CQL Loader with DataMapper output" do
-  cql_failures = {      # These CQL files can't be compiled
-  }
-  mapping_failures = {  # These models can't be mapped to DM
-    'OrienteeringER' => 'Invalid CQL results in unmappable model',
-    'Insurance' => 'Cannot handle models that contain classes like Vehicle Incident with external supertypes (Incident)',
-    'MultiInheritance' => 'Cannot handle models that contain classes like Australian Employee with external supertypes (Australian)',
-    'Metamodel' => 'cannot be used as a property name since it collides with an existing method',
-    'MetamodelNext' => 'Cannot map classes like Constraint with roles inherited from external supertypes (Concept)',
-    'SeparateSubtype' => 'Cannot handle models that contain classes like Vehicle Incident with external supertypes (Incident)',
-    'ServiceDirector' => 'Cannot handle models that contain classes like Client with external supertypes (Company)',
-  }
-  dm_failures = {       # These mapped models don't work in DM
-    'RedundantDependency' => 'Cannot find the child_model Addres for StateOrProvince in address while finalizing StateOrProvince.address',
-    'Supervision' => 'Inflexion failure: Cannot find the parent_model Ceo for Company in ceo while finalizing Company.ceo',
-  }
-
-  # Generate and return the DataMapper models for the given vocabulary
-  def dm(vocabulary)
-    output = StringIO.new
-    @dumper = ActiveFacts::Generate::DM.new(vocabulary.constellation)
-    @dumper.generate(output)
-    output.rewind
-    output.read
-  end
-
-  pattern = ENV["AFTESTS"] || "*"
-  Dir["examples/CQL/#{pattern}.cql"].each do |cql_file|
-    expected_file = cql_file.sub(%r{/CQL/(.*).cql\Z}, '/datamapper/\1.dm.rb')
-    actual_file = cql_file.sub(%r{examples/CQL/(.*).cql\Z}, 'spec/actual/\1.dm.rb')
-    base = File.basename(cql_file, ".cql")
-
-    next unless ENV["AFTESTS"] || File.exists?(expected_file)
-
-    it "should load #{cql_file} and dump DataMapper models matching #{expected_file}" do
-      vocabulary = nil
-      broken = cql_failures[base]
-      if broken
-        pending(broken) {
-          vocabulary = ActiveFacts::Input::CQL.readfile(cql_file)
-        }
-      else
-        vocabulary = ActiveFacts::Input::CQL.readfile(cql_file)
-      end
-      vocabulary.finalise
-
-      # Build and save the actual file:
-      dm_text = ''
-      lambda do
-        begin
-          dm_text = dm(vocabulary)
-	  Dir.mkdir "spec/actual" rescue nil
-          File.open(actual_file, "w") { |f| f.write dm_text }
-        rescue
-          raise unless mapping_failures[base]
-        end
-      end.should_not raise_error
-
-      if m = mapping_failures[base]
-        File.delete(actual_file) rescue nil
-        pending m
-      end
-
-      lambda do
-        begin
-          eval dm_text
-          DataMapper.finalize
-        rescue
-          raise unless dm_failures[base]
-        ensure
-          DataMapper::Spec.cleanup_models
-        end
-      end.should_not raise_error
-      if m = dm_failures[base]
-        File.delete(actual_file) rescue nil
-        pending m
-      end
-
-      pending("expected output file #{expected_file} not found") unless File.exists? expected_file
-
-      # Compare with the expected file:
-      expected_text = File.open(expected_file) {|f| f.read }
-      dm_text.should_not differ_from(expected_text)
-      File.delete(actual_file)  # It succeeded, we don't need the file.
-    end
-  end
-end
-
-end # if false

data/spec/cql_mysql_spec.rb

@@ -1,69 +0,0 @@
-#
-# ActiveFacts tests: Parse all CQL files and check the generated SQL.
-# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
-#
-
-require 'spec_helper'
-require 'stringio'
-require 'activefacts/vocabulary'
-require 'activefacts/support'
-require 'activefacts/input/cql'
-require 'activefacts/generate/sql/mysql'
-
-describe "CQL Loader with SQL output" do
-  cql_failures = {
-    "Airline" => "Contains queries, unsupported",
-    "CompanyQuery" => "Contains queries, unsupported",
-  }
-  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)
-    @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.my.sql')
-
-    next unless ENV["AFTESTS"] || File.exists?(expected_file)
-
-    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
-      vocabulary.finalise
-
-      # Build and save the actual file:
-      sql_text = sql(vocabulary)
-      Dir.mkdir "spec/actual" rescue nil
-      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

@@ -1,34 +0,0 @@
-#
-# ActiveFacts tests: Parse all NORMA files and check the generated CQL.
-# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
-#
-
-require 'stringio'
-require 'activefacts/vocabulary'
-require 'activefacts/support'
-require 'activefacts/input/cql'
-require 'activefacts/generate/cql'
-
-describe "CQL Parser" do
-  cql_failures = {
-    "Airline" => "Contains queries, unsupported",
-    "CompanyQuery" => "Contains queries, unsupported",
-  }
-
-  pattern = ENV["AFTESTS"] || "*"
-  Dir["examples/CQL/#{pattern}.cql"].each do |cql_file|
-    it "should load CQL #{cql_file} without parse errors" 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
-      vocabulary.finalise
-    end
-  end
-end

data/spec/cql_ruby_spec.rb

@@ -1,73 +0,0 @@
-#
-# ActiveFacts tests: Parse all CQL files and check the generated Ruby.
-# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
-#
-
-require 'spec_helper'
-require 'stringio'
-require 'activefacts/vocabulary'
-require 'activefacts/support'
-require 'activefacts/input/cql'
-require 'activefacts/generate/ruby'
-
-class String
-  def strip_comments()
-    c_comment = %r{/\*((?!\*/).)*\*/}m
-    gsub(c_comment, '').gsub(%r{\n\n+},"\n")
-  end
-end
-
-describe "CQL Loader with Ruby output" do
-  cql_failures = {
-    "Airline" => "Contains queries, not supported",
-    "CompanyQuery" => "Contains queries, not supported",
-    # "OrienteeringER" => "Invalid model, it just works differently in CQL"
-  }
-
-  # Generate and return the Ruby for the given vocabulary
-  def ruby(vocabulary)
-    output = StringIO.new
-    @dumper = ActiveFacts::Generate::RUBY.new(vocabulary.constellation)
-    @dumper.generate(output)
-    output.rewind
-    output.read
-  end
-
-  pattern = ENV["AFTESTS"] || "*"
-  Dir["examples/CQL/#{pattern}.cql"].each do |cql_file|
-    expected_file = cql_file.sub(%r{/CQL/(.*).cql\Z}, '/ruby/\1.rb')
-    actual_file = cql_file.sub(%r{examples/CQL/(.*).cql\Z}, 'spec/actual/\1.rb')
-
-    next unless ENV["AFTESTS"] || File.exists?(expected_file)
-
-    it "should load #{cql_file} and dump Ruby matching #{expected_file}" do
-      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
-      vocabulary.finalise
-
-      # Build and save the actual file:
-      ruby_text = ruby(vocabulary)
-      Dir.mkdir "spec/actual" rescue nil
-      File.open(actual_file, "w") { |f| f.write ruby_text }
-
-      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

@@ -1,72 +0,0 @@
-#
-# ActiveFacts tests: Parse all CQL files and check the generated SQL.
-# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
-#
-
-require 'spec_helper'
-require 'stringio'
-require 'activefacts/vocabulary'
-require 'activefacts/support'
-require 'activefacts/input/cql'
-require 'activefacts/generate/sql/server'
-
-describe "CQL Loader with SQL output" do
-  cql_failures = {
-    "Airline" => "Contains unsupported queries",
-    "CompanyQuery" => "Contains unsupported queries",
-  }
-  cql_sql_failures = {
-    "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)
-    @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.sql')
-    expected_file = cql_file.sub(%r{examples/CQL/(.*).cql\Z}, 'examples/SQL/\1.sql')
-
-    next unless ENV["AFTESTS"] || File.exists?(expected_file)
-
-    it "should load #{cql_file} and dump SQL matching #{expected_file}" do
-      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
-      vocabulary.finalise
-
-      # Build and save the actual file:
-      sql_text = sql(vocabulary)
-      Dir.mkdir "spec/actual" rescue nil
-      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_sql_failures[File.basename(cql_file, ".cql")]
-      if broken
-        pending(broken) {
-          sql_text.should_not differ_from(expected_text)
-        }
-      else
-        # Discard index names:
-        sql_text.gsub!(/ INDEX (\[[^\]]*\]|`[^`]*`|[^ ]*) ON /, ' INDEX <Name is hidden> ON ')
-        expected_text.gsub!(/ INDEX (\[[^\]]*\]|`[^`]*`|[^ ]*) ON /, ' INDEX <Name is hidden> ON ')
-        sql_text.should_not differ_from(expected_text)
-        File.delete(actual_file)  # It succeeded, we don't need the file.
-      end
-    end
-  end
-end