activefacts 0.6.0

data/spec/api/value_type.rb

@@ -0,0 +1,112 @@
+#
+# ActiveFacts tests: Value types in the Runtime API
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+describe "Value Type class definitions" do
+  setup do
+    Object.send :remove_const, :Mod if Object.const_defined?("Mod")
+    module Mod
+      class Name < String
+        value_type
+        has_one :name
+      end
+      class Year < Int
+        value_type
+        has_one :name
+      end
+      class Weight < Real
+        value_type
+        has_one :name
+      end
+    end
+
+    @classes = [Mod::Name, Mod::Year,Mod::Weight]
+    @attrs = [:name, :name, :name]
+
+  end
+
+  it "should respond_to verbalise" do
+    @classes.each { |klass|
+        klass.respond_to?(:verbalise).should be_true
+      }
+  end
+
+  it "should not pollute the value class" do
+    @classes.each { |klass|
+        klass.superclass.respond_to?(:verbalise).should_not be_true
+      }
+  end
+
+  it "should return a string from verbalise" do
+    @classes.each { |klass|
+        v = klass.verbalise
+        v.should_not be_nil
+        v.should_not =~ /REVISIT/
+      }
+  end
+
+  it "should respond_to vocabulary" do
+    @classes.each { |klass|
+        klass.respond_to?(:vocabulary).should be_true
+      }
+  end
+
+  it "should return the parent module as the vocabulary" do
+    @classes.each { |klass|
+        vocabulary = klass.vocabulary
+        vocabulary.should == Mod
+      }
+  end
+
+  it "should return a vocabulary that knows about this concept" do
+    @classes.each { |klass|
+        vocabulary = klass.vocabulary
+        vocabulary.respond_to?(:concept).should be_true
+        vocabulary.concept.has_key?(klass.basename).should be_true
+      }
+  end
+
+  it "should respond to roles()" do
+    @classes.each { |klass|
+        klass.respond_to?(:roles).should be_true
+      }
+  end
+
+  it "should contain only the added role definitions" do
+    Mod::Name.roles.size.should == 4
+    (@classes-[Mod::Name]).each { |klass|
+        klass.roles.size.should == 1
+      }
+  end
+
+  it "should return the role definition" do
+    # Check the role definition may not be accessed by passing an index:
+    Mod::Name.roles(0).should be_nil
+
+    @classes.zip(@attrs).each { |pair|
+        klass, attr = *pair
+        role = klass.roles(attr)
+        role.should_not be_nil
+
+        role = klass.roles(attr.to_s)
+        role.should_not be_nil
+
+        # Check the role definition may be accessed by indexing the returned array:
+        role = klass.roles[attr]
+        role.should_not be_nil
+
+        # Check the role definition array by .include?
+        klass.roles.include?(attr).should be_true
+      }
+  end
+
+  # REVISIT: role value restrictions
+
+  it "should fail on a non-ValueClass" do
+    lambda{
+      class NameNotString
+        value_type
+      end
+    }.should raise_error
+  end
+end

data/spec/api_spec.rb

@@ -0,0 +1,14 @@
+#
+# ActiveFacts tests: Run the API tests
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+base = File.dirname(__FILE__)+"/"
+require 'rubygems'
+require 'activefacts/api'
+
+require base+'api/constellation'
+require base+'api/entity_type'
+require base+'api/instance'
+require base+'api/autocounter'
+require base+'api/value_type'
+require base+'api/roles'

data/spec/cql_cql_spec.rb

@@ -0,0 +1,58 @@
+#
+# ActiveFacts tests: Parse all CQL 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'
+require 'activefacts/input/cql'
+require 'activefacts/generate/cql'
+
+include ActiveFacts
+
+class String
+  def strip_comments()
+    c_comment = %r{/\*((?!\*/).)*\*/}m
+    gsub(c_comment, '').gsub(%r{\n\n+},"\n")
+  end
+end
+
+describe "CQL Loader" do
+  CQL_CQL_FAILURES = %w{
+    Airline
+    CompanyQuery
+    Insurance
+    OrienteeringER
+    ServiceDirector
+  }
+
+  # 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
+
+  #Dir["examples/CQL/Bl*.cql"].each do |cql_file|
+  #Dir["examples/CQL/Meta*.cql"].each do |cql_file|
+  #Dir["examples/CQL/[ACG]*.cql"].each do |cql_file|
+  Dir["examples/CQL/*.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
+      pending if CQL_CQL_FAILURES.include? File.basename(cql_file, ".cql")
+      vocabulary = ActiveFacts::Input::CQL.readfile(cql_file)
+
+      # 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.strip_comments }.scan(/.*?\n/)
+      cql_text.strip_comments.scan(/.*?\n/).should == expected_text
+      File.delete(actual_file)  # It succeeded, we don't need the file.
+    end
+  end
+end

data/spec/cql_parse_spec.rb

@@ -0,0 +1,31 @@
+#
+# 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'
+require 'activefacts/input/cql'
+require 'activefacts/generate/cql'
+
+include ActiveFacts
+
+describe "CQL Parser" do
+  CQLPARSE_FAILURES = %w{
+    Airline
+    CompanyQuery
+    Insurance
+    OrienteeringER
+  }
+
+  #Dir["examples/CQL/Bl*.cql"].each do |cql_file|
+  #Dir["examples/CQL/Meta*.cql"].each do |cql_file|
+  #Dir["examples/CQL/[ACG]*.cql"].each do |cql_file|
+  Dir["examples/CQL/*.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
+    end
+  end
+end

data/spec/cql_ruby_spec.rb

@@ -0,0 +1,60 @@
+#
+# ActiveFacts tests: Parse all CQL files and check the generated Ruby.
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+require 'rubygems'
+require 'stringio'
+require 'activefacts/vocabulary'
+require 'activefacts/support'
+require 'activefacts/input/cql'
+require 'activefacts/generate/ruby'
+
+include ActiveFacts
+
+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_RUBY_FAILURES = %w{
+    Airline
+    CompanyQuery
+    Insurance
+    OrienteeringER
+    Orienteering
+    ServiceDirector
+  }
+
+  # 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
+
+  #Dir["examples/CQL/Bl*.cql"].each do |cql_file|
+  #Dir["examples/CQL/Meta*.cql"].each do |cql_file|
+  #Dir["examples/CQL/[ACG]*.cql"].each do |cql_file|
+  Dir["examples/CQL/*.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')
+
+    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)
+
+      # 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.
+    end
+  end
+end

data/spec/cql_sql_spec.rb

@@ -0,0 +1,54 @@
+#
+# ActiveFacts tests: Parse all CQL files and check the generated SQL.
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+require 'rubygems'
+require 'stringio'
+require 'activefacts/vocabulary'
+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_SQL_FAILURES = %w{
+    Airline
+    CompanyQuery
+    Insurance
+    OrienteeringER
+    ServiceDirector
+    SimplestUnary
+  }
+
+  # 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
+
+  #Dir["examples/CQL/Bl*.cql"].each do |cql_file|
+  #Dir["examples/CQL/Meta*.cql"].each do |cql_file|
+  #Dir["examples/CQL/[ACG]*.cql"].each do |cql_file|
+  Dir["examples/CQL/*.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')
+
+    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)
+
+      # 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.
+    end
+  end
+end

data/spec/cql_symbol_tables_spec.rb

@@ -0,0 +1,259 @@
+#
+# 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'
+
+describe "CQL Symbol table" do
+
+  # A Form here is a form of reference to a concept, being a name and optional adjectives, possibly designated by a role name:
+  # Struct.new("Form", :concept, :name, :leading_adjective, :trailing_adjective, :role_name)
+  # def initialize(constellation, vocabulary)
+  # def bind(words, leading_adjective = nil, trailing_adjective = nil, role_name = nil, allowed_forward = false, leading_speculative = false, trailing_speculative = false)
+
+  setup do
+    include ActiveFacts::Input::CQL
+    @constellation = ActiveFacts::API::Constellation.new(ActiveFacts::Metamodel)
+    @vocabulary = @constellation.Vocabulary("Test")
+    @symbols = ActiveFacts::Input::CQL::SymbolTable.new(@constellation, @vocabulary)
+  end
+
+  Definitions = [
+    [ "predefined value type",
+      ["Date"],
+      ["Date", nil, nil, nil]],
+    [ "predefined value type as word array",
+      [["Date"]],
+      ["Date", nil, nil, nil]],
+    [ "predefined value type with inline leading adjective",
+      [["Birth", "Date"]],
+      ["Date", "Birth", nil, nil]],
+    [ "predefined value types with inline trailing adjective",
+      [["Date", "OfBirth"]],
+      ["Date", nil, "OfBirth", nil]],
+    [ "predefined value type with two inline adjectives",
+      [["Second", "Birth", "Date"]],
+      nil],   # Illegal
+    [ "predefined value type with defined leading adjective",
+      ["Date", "Birth"],
+      ["Date", "Birth", nil, nil]],
+    [ "predefined value types with defined trailing adjective",
+      ["Date", nil, "OfBirth"],
+      ["Date", nil, "OfBirth", nil]],
+    [ "predefined value type with inline and defined leading adjective",
+      [["Second", "Date"], "Birth"],
+      nil],   # Illegal
+    [ "predefined value types with inline and defined trailing adjective",
+      [["Second", "Date"], nil, "OfBirth"],
+      nil],   # Illegal
+
+    [ "predefined type with role name",
+      ["Date", nil, nil, "BirthDate"],
+      ["Date", nil, nil, "BirthDate"]],
+
+    [ "forward-referenced type",
+      ["Unknown", nil, nil, nil, true],
+      ["Unknown", nil, nil, nil]],
+    [ "forward-referenced type with inline adjective",
+      [["Haha", "Unknown"], nil, nil, nil, true],
+      nil],   # Illegal
+
+    [ "entity type",
+      ["Person"],
+      ["Person", nil, nil, nil]],
+    [ "entity type as word array",
+      [["Person"]],
+      ["Person", nil, nil, nil]],
+    [ "entity type with inline leading adjective",
+      [["Birth", "Person"]],
+      ["Person", "Birth", nil, nil]],
+    [ "entity types with inline trailing adjective",
+      [["Person", "OfBirth"]],
+      ["Person", nil, "OfBirth", nil]],
+    [ "entity type with two inline adjectives",
+      [["Second", "Birth", "Person"]],
+      nil],   # Illegal
+    [ "entity type with defined leading adjective",
+      ["Person", "Birth"],
+      ["Person", "Birth", nil, nil]],
+    [ "entity types with defined trailing adjective",
+      ["Person", nil, "OfBirth"],
+      ["Person", nil, "OfBirth", nil]],
+    [ "entity type with inline and defined leading adjective",
+      [["Second", "Person"], "Birth"],
+      nil],   # Illegal
+    [ "entity types with inline and defined trailing adjective",
+      [["Second", "Person"], nil, "OfBirth"],
+      nil],   # Illegal
+
+    [ "entity type with role name",
+      ["Person", nil, nil, "Father"],
+      ["Person", nil, nil, "Father"]],
+  ]
+
+  Definitions.each do |c|
+    description, args, result = *c
+
+    it "should define #{description}" do
+      if result
+        # Predefine an entity type, some cases use it:
+        @constellation.EntityType("Person", @vocabulary.identifying_role_values)
+
+        player, bound = @symbols.bind(*args)
+        player.should_not be_nil
+        player.should == bound.concept
+        [bound.name, bound.leading_adjective, bound.trailing_adjective, bound.role_name].should == result
+      else
+        lambda {player, bound = @symbols.bind(*args)}.should raise_error
+      end
+    end
+  end
+
+  it "should disallow binding to a role name where a leading adjective is provided" do
+    concept, = @symbols.bind("Name", nil, nil, "GivenName", true)
+    lambda{player, bound = @symbols.bind("GivenName", "SomeAdj")}.should raise_error
+  end
+
+  it "should disallow binding to a role name where a trailing adjective is provided" do
+    concept, = @symbols.bind("Name", nil, nil, "GivenName", true)
+    lambda{player, bound = @symbols.bind("GivenName", nil, "SomeAdj")}.should raise_error
+  end
+
+  it "should disallow binding to a role name and defining a new role name" do
+    concept, = @symbols.bind("Name", nil, nil, "GivenName", true)
+    lambda{player, bound = @symbols.bind("GivenName", nil, nil, "SomeName")}.should raise_error
+  end
+
+  Predefined = [
+    [ "Name",   "Given",  nil,      nil,          true  ],
+    [ "Nom",    nil,      "Donné",  nil,          true  ],
+    [ "Name",   nil,      nil,      "GivenName",  true  ],
+    [ "Simple", nil,      nil,                          ],
+  ]
+
+  it "should allow adding a role name to an adjectival form without one" do
+    concept, = @symbols.bind("Name", "Given", nil, nil, true)
+    player, bound = @symbols.bind("Name", nil, nil, "GivenName")
+    player.should == concept
+  end
+
+  it "should create new binding with a role name rather than binding to existing simple player without adjectives" do
+    concept, bare = @symbols.bind("Name", nil, nil, nil, true)
+    player, bound = @symbols.bind("Name", nil, nil, "SomeAdj")
+    bare.should_not == bound
+  end
+
+  it "should disallow adding a role name which is the name of an existing concept" do
+    concept, = @symbols.bind("Name", "Given", nil, nil, true)
+    lambda{player, bound = @symbols.bind("Name", "Given", nil, "Date")}.should raise_error
+  end
+
+  it "should disallow adding a role name to a role player that already has one" do
+    concept, first = @symbols.bind("Name", "Given", nil, "GivenName", true)
+    player, bound = @symbols.bind("Name", "Given", nil, "FirstName")
+    first.should_not == bound
+  end
+
+  it "should bind to an existing player without adjectives" do
+    concept, = @symbols.bind("Name", nil, nil, nil, true)
+    player, bound = @symbols.bind("Name")
+    player.should == concept
+  end
+
+  it "should bind to an existing player using a leading adjective" do
+    concept, = @symbols.bind("Name", nil, nil, nil, true)
+    player, bound = @symbols.bind("Name", "Given")
+    player.should == concept
+  end
+
+  it "should bind to an existing player using a trailing adjective" do
+    concept, = @symbols.bind("Name", nil, nil, nil, true)
+    player, bound = @symbols.bind("Name", nil, "Donné")
+    player.should == concept
+  end
+
+  it "should bind to an existing player only using the defined leading adjective" do
+    concept, = @symbols.bind("Name", "Given", nil, nil, true)
+    player, bound = @symbols.bind("Name", "Given")
+    player.should == concept
+    forms = [bound]
+
+    player, alt = @symbols.bind("Name")
+    forms.should_not be_include(alt)
+    forms << alt
+
+    player, alt = @symbols.bind("Name", nil, "Donné")
+    forms.should_not be_include(alt)
+    forms << alt
+
+    player, alt = @symbols.bind("Name", "Given", "Donné")
+    forms.should_not be_include(alt)
+  end
+
+  it "should bind to an existing player only using a defined trailing adjective" do
+    concept, = @symbols.bind("Name", nil, "Donné", nil, true)
+    player, bound = @symbols.bind("Name", nil, "Donné")
+    player.should == concept
+    forms = [bound]
+
+    player, alt = @symbols.bind("Name")
+    forms.should_not be_include(alt)
+    forms << alt
+
+    player, alt = @symbols.bind("Name", "Given")
+    forms.should_not be_include(alt)
+    forms << alt
+
+    player, alt = @symbols.bind("Name", "Given", "Donné")
+    forms.should_not be_include(alt)
+  end
+
+  it "should bind to an existing player only using defined leading and trailing adjective" do
+    concept, = @symbols.bind("Name", "Given", "Donné", nil, true)
+    player, bound = @symbols.bind("Name", "Given", "Donné")
+    player.should == concept
+    forms = [bound]
+
+    player, alt = @symbols.bind("Name")
+    forms.should_not be_include(alt)
+    forms << alt
+
+    player, alt = @symbols.bind("Name", "Given")
+    forms.should_not be_include(alt)
+    forms << alt
+
+    player, alt = @symbols.bind("Name", nil, "Donné")
+    forms.should_not be_include(alt)
+  end
+
+  it "should bind to an existing player using a speculative leading adjective" do
+    concept, = @symbols.bind("Name", "Given", nil, nil, true)
+    player, bound = @symbols.bind("Name", l = "Given", t = "Donné", nil, nil, true, true)
+    player.should == concept
+    bound.leading_adjective.should == "Given"
+    bound.trailing_adjective.should be_nil
+    l.should be_empty
+    t.should == "Donné"
+  end
+
+  it "should bind to an existing player using a speculative trailing adjective" do
+    concept, = @symbols.bind("Name", nil, "Donné", nil, true)
+    player, bound = @symbols.bind("Name", l = "Given", t = "Donné", nil, nil, true, true)
+    player.should == concept
+    l.should == "Given"
+    t.should be_empty
+  end
+
+  it "should bind to an existing player using a speculative leading and trailing adjective" do
+    concept, = @symbols.bind("Name", "Given", "Donné", nil, true)
+    player, bound = @symbols.bind("Name", l = "Given", t = "Donné", nil, nil, true, true)
+    player.should == concept
+    l.should be_empty
+    t.should be_empty
+  end
+
+end