activefacts 0.8.9 → 0.8.10

data/spec/cql/parser/pragmas_spec.rb

@@ -0,0 +1,89 @@
+#
+# ActiveFacts tests: Test the CQL parser by looking at its parse trees.
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+
+require 'activefacts/cql'
+require 'activefacts/support'
+require 'activefacts/api/support'
+require 'helpers/test_parser'
+
+describe "Entity Types" do
+  IndependentObjectTypes = [
+    # Value types
+    [ "a is written as b [independent];",
+      ['ValueType: a is written as b, pragmas [independent];'],
+    ],
+    [ "a [independent] is written as b;",
+      ['ValueType: a is written as b, pragmas [independent];'],
+    ],
+
+    # Entity types
+    [ "a is identified by its id [independent];",
+      ['EntityType: a identified by its id, pragmas [independent];']
+    ],
+    [ "a [independent] is identified by its id;",
+      ['EntityType: a identified by its id, pragmas [independent];']
+    ],
+    [ "a is independent identified by its id;",
+      ['EntityType: a identified by its id, pragmas [independent];']
+    ],
+    [ "a is identified by b [independent] where a has one b;",
+      ['EntityType: a [{b}] where [{a} "has" {[1..1] b}], pragmas [independent];']
+    ],
+    [ "a is independent identified by b where a has one b;",
+      ['EntityType: a [{b}] where [{a} "has" {[1..1] b}], pragmas [independent];']
+    ],
+
+    # Subtypes
+    [ "Employee [independent] is a kind of Person;",
+      ['EntityType: Employee < Person nil, pragmas [independent];']
+    ],
+    [ "Employee is a kind of Person [independent];",
+      ['EntityType: Employee < Person nil, pragmas [independent];']
+    ],
+    [ "Employee is a kind of independent Person;",
+      ['EntityType: Employee < Person nil, pragmas [independent];']
+    ],
+    [ "Employee is a kind of Person identified by its id [independent];",
+      ["EntityType: Employee < Person identified by its id, pragmas [independent];"]
+    ],
+
+    # Fact Types
+    [ "Director is where c relates to b;",
+      ["FactType: Director [{c} \"relates to\" {b}]"]
+    ],
+    [ "Director [independent] is where c relates to b;",
+      ["FactType: Director [{c} \"relates to\" {b}], pragmas [independent]"]
+    ],
+    [ "Director is independent where c relates to b;",
+      ["FactType: Director [{c} \"relates to\" {b}], pragmas [independent]"]
+    ],
+  ]
+
+  PragmaObjectTypes =
+    IndependentObjectTypes
+
+  before :each do
+    @parser = TestParser.new
+    @parser.parse_all("c is written as b;", :definition)
+  end
+
+  PragmaObjectTypes.each do |c|
+    source, ast = *c
+    it "should parse #{source.inspect}" do
+      result = @parser.parse_all(source, :definition)
+
+      puts @parser.failure_reason unless result
+      result.should_not be_nil
+
+      canonical_form = result.map{|d| d.ast.to_s}
+      if ast
+        canonical_form.should == ast
+      else
+        pending "#{source.inspect} should compile to\n" +
+          "\t#{canonical_form}"
+      end
+    end
+  end
+end

data/spec/cql/parser/value_types_spec.rb

@@ -0,0 +1,42 @@
+#
+# ActiveFacts tests: Test the CQL parser by looking at its parse trees.
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+
+require 'activefacts/cql'
+require 'activefacts/support'
+require 'activefacts/api/support'
+require 'helpers/test_parser'
+
+describe "Value Types" do
+  ValueTypes = [
+    [ "a is written as b(1, 2) inch restricted to { 3 .. 4 } inch ;",
+      ['ValueType: a is written as b(1, 2) in [["inch", 1]] ValueConstraint to ([3..4]) in [["inch", 1]];']
+    ],
+#    [ "a c  is written as b(1, 2) inch restricted to { 3 .. 4 } inch ;",
+#      [["a c", [:value_type, "b", [1, 2], "inch", [[3, 4]]]]]
+#    ],
+  ]
+
+  before :each do
+    @parser = TestParser.new
+  end
+
+  ValueTypes.each do |c|
+    source, ast = *c
+    it "should parse #{source.inspect}" do
+      result = @parser.parse_all(source, :definition)
+
+      puts @parser.failure_reason unless result
+      result.should_not be_nil
+
+      canonical_form = result.map{|d| d.ast.to_s}
+      if ast
+        canonical_form.should == ast
+      else
+        puts "#{source.inspect} should compile to"
+        puts "\t#{canonical_form}"
+      end
+    end
+  end
+end

data/spec/cql/role_matching_spec.rb

@@ -0,0 +1,147 @@
+#
+# ActiveFacts CQL Fact Type matching tests
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+
+require 'rspec/expectations'
+
+require 'activefacts/support'
+require 'activefacts/api/support'
+require 'activefacts/cql/compiler'
+require 'spec/helpers/compile_helpers'
+
+describe "When comparing roles of a reading with an existing reading" do
+  before :each do
+    extend CompileHelpers
+
+    prefix = %q{
+      vocabulary Tests;
+      Boy is written as String;
+      Girl is written as Integer;
+    }
+    @compiler = ActiveFacts::CQL::Compiler.new('Test')
+    @compiler.compile(prefix)
+    @constellation = @compiler.vocabulary.constellation
+
+    baseline
+  end
+
+  describe "producing correct side effects" do
+    before :each do
+      @compiler.compile %q{ Boy is going out with Girl; }
+      @simple_ft = fact_types[0]
+      baseline
+      @compiler.compile %q{ Boy dislikes ugly-Girl; }
+      @ugly_ft = fact_types[0]
+      baseline
+      @compiler.compile %q{ Boy -monster hurts Girl; }
+      @hurts_ft = fact_types[0]
+      baseline
+      #debug_enable("matching"); debug_enable("matching_fails"); debug_enable("parse")
+    end
+    after :each do
+      # debug_disable("matching"); debug_disable("matching_fails"); debug_disable("parse")
+    end
+
+    it "should match exact reading" do
+      parse %q{Boy is going out with Girl;}
+      @asts.size.should == 1
+      side_effects = match_readings_to_existing(@asts[0], @simple_ft.all_reading.single)
+      side_effects[0].should_not be_nil
+      side_effects.to_s.should == 'side-effects are [{Boy} absorbs 0/0 at 0, {Girl} absorbs 0/0 at 5]'
+    end
+
+    it "should match with explicit leading adjective" do
+      parse %q{Boy dislikes ugly-Girl;}
+      @asts.size.should == 1
+      side_effects = match_readings_to_existing(@asts[0], @ugly_ft.all_reading.single)
+      side_effects[0].should_not be_nil
+      side_effects.to_s.should == 'side-effects are [{Boy} absorbs 0/0 at 0, {ugly- Girl} absorbs 0/0 at 2]'
+    end
+
+    it "should match with implicit leading adjective" do
+      parse %q{Boy dislikes ugly Girl;}
+      @asts.size.should == 1
+      side_effects = match_readings_to_existing(@asts[0], @ugly_ft.all_reading.single)
+      side_effects[0].should_not be_nil
+      side_effects.to_s.should == 'side-effects are [{Boy} absorbs 0/0 at 0, {Girl} absorbs 1/0 at 3]'
+    end
+
+    it "should match with local leading adjective" do
+      parse %q{
+        bad-Boy is going out with Girl,
+        Girl likes bad-Boy; // New reading, no match expected, but must use residual adjective
+      }
+      @asts.size.should == 1
+      side_effects = match_readings_to_existing(@asts[0], @simple_ft.all_reading.single)
+      side_effects.size.should == 2
+      side_effects[0].should_not be_nil
+      side_effects[1].should be_nil
+      pending side_effects[0].to_s
+      side_effects[0].to_s.should == '[{bad- Boy} absorbs 0/0 at 0 with residual adjectives, {Girl} absorbs 0/0 at 5] with residual adjectives'
+      #side_effects[1].to_s.should == ''
+    end
+
+    it "should match with explicit and local leading adjective" do
+      parse %q{
+        Boy dislikes nasty- ugly Girl,
+        nasty- Girl likes Boy; // New reading, no match expected, but must use residual adjective
+      }
+      @asts.size.should == 1
+      side_effects = match_readings_to_existing(@asts[0], @ugly_ft.all_reading.single)
+      side_effects.size.should == 2
+      pending "Matched adjectives must be removed and the role rebound before deciding whether residual adjectives have a purpose" do
+        side_effects[0].should_not be_nil
+        puts side_effects[0].to_s
+        #side_effects.to_s.should == ''
+      end
+    end
+
+    # Trailing adjectives
+    it "should match with explicit trailing adjective" do
+      parse %q{Boy-monster hurts Girl;}
+      @asts.size.should == 1
+      side_effects = match_readings_to_existing(@asts[0], @hurts_ft.all_reading.single)
+      pending "Thinks trailing adjectives are always residual"
+      side_effects[0].should_not be_nil
+      side_effects.to_s.should == ''
+    end
+
+    it "should match with implicit trailing adjective" do
+      parse %q{Boy monster hurts Girl;}
+      @asts.size.should == 1
+      side_effects = match_readings_to_existing(@asts[0], @hurts_ft.all_reading.single)
+      side_effects[0].should_not be_nil
+      side_effects.to_s.should == 'side-effects are [{Boy} absorbs 0/1 at 0, {Girl} absorbs 0/0 at 3]'
+    end
+
+    it "should match with local trailing adjective" do
+      parse %q{
+        Boy is going out with Girl-troublemaker,
+        Girl troublemaker likes Boy;
+      }
+      @asts.size.should == 1
+      side_effects = match_readings_to_existing(@asts[0], @simple_ft.all_reading.single)
+      side_effects.size.should == 2
+      side_effects[0].should_not be_nil
+      side_effects.to_s.should == 'side-effects are [{Boy} absorbs 0/0 at 0, {Girl -troublemaker} absorbs 0/0 at 5 with residual adjectives] with residual adjectives'
+    end
+
+    it "should match with explicit and local trailing adjective" do
+      parse %q{
+        Boy monster -foo hurts Girl,
+          Girl likes Boy foo;
+      }
+      @asts.size.should == 1
+      side_effects = match_readings_to_existing(@asts[0], @hurts_ft.all_reading.single)
+      side_effects.size.should == 2
+
+      pending "Matched adjectives must be removed and the role rebound before deciding whether residual adjectives have a purpose" do
+        side_effects[0].should_not be_nil
+        puts side_effects.to_s
+        # side_effects.to_s.should == ''
+      end
+    end
+
+  end
+end

data/spec/cql/samples_spec.rb

@@ -118,29 +118,29 @@ describe "Sample data" do
       # REVISIT: Include the instance_names of all role players
     end
 
-    if i.concept.is_a?(ActiveFacts::Metamodel::ValueType)
-      return "#{i.concept.name} #{i.value}"
+    if i.object_type.is_a?(ActiveFacts::Metamodel::ValueType)
+      return "#{i.object_type.name} #{i.value}"
     end
 
-    if i.concept.fact_type      # An instance of an objectified fact type
-      return "#{i.concept.name} where #{instance_name(i.fact)}"
+    if i.object_type.fact_type      # An instance of an objectified fact type
+      return "#{i.object_type.name} where #{instance_name(i.fact)}"
     end
 
     # It's an entity that's not an objectified fact type
     # REVISIT: If it has a simple identifier, there's no need to fully verbalise the identifying facts
-    pi = i.concept.preferred_identifier
+    pi = i.object_type.preferred_identifier
     identifying_role_refs = pi.role_sequence.all_role_ref.sort_by{|rr| rr.ordinal}
-    return "#{i.concept.name}" +
+    return "#{i.object_type.name}" +
       " is identified by " +
       identifying_role_refs.map do |rr|
         [ (l = rr.leading_adjective) ? l+"-" : nil,
-          rr.role.role_name || rr.role.concept.name,
+          rr.role.role_name || rr.role.object_type.name,
           (t = rr.trailing_adjective) ? l+"-" : nil
         ].compact*""
       end * " and " +
       " where " +
       identifying_role_refs.map do |rr|  # Go through the identifying roles and emit the facts that define them
-        instance_role = i.concept.all_role.detect{|r| r.fact_type == rr.role.fact_type}
+        instance_role = i.object_type.all_role.detect{|r| r.fact_type == rr.role.fact_type}
         identifying_fact = i.all_role_value.detect{|rv| rv.fact.fact_type == rr.role.fact_type}.fact
         #counterpart_role = (rr.role.fact_type.all_role.to_a-[instance_role])[0]
         #identifying_instance = counterpart_role.all_role_value.detect{|rv| rv.fact == identifying_fact}.instance
@@ -223,7 +223,7 @@ describe "Sample data" do
       end.should raise_error
 
       if missing
-        missing.each do |m|
+        Array(missing).each do |m|
           @exception.message.should =~ (m.is_a?(Regexp) ? m : Regexp.new(Regexp.escape(m)))
         end
       else

data/spec/cql_cql_spec.rb

@@ -3,7 +3,7 @@
 # Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
 #
 
-require 'spec/spec_helper'
+require File.dirname(__FILE__) + '/spec_helper'
 require 'stringio'
 require 'activefacts/vocabulary'
 require 'activefacts/support'

data/spec/cql_dm_spec.rb

@@ -0,0 +1,116 @@
+#
+# 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.
+
+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'
+
+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)',
+    'MetamodelNext' => 'Cannot handle models that contain classes like Constraint with external supertypes (ObjectType)',
+    'MultiInheritance' => 'Cannot handle models that contain classes like Australian Employee with external supertypes (Australian)',
+    '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")
+
+    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
+
+      # Build and save the actual file:
+      dm_text = ''
+      lambda do
+        begin
+          dm_text = dm(vocabulary)
+          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