activefacts 0.7.3 → 0.8.5

data/spec/absorption_ruby_spec.rb

@@ -0,0 +1,99 @@
+#
+# ActiveFacts tests: Compare column lists created by aborption and by generated Ruby.
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+
+require 'stringio'
+require 'activefacts/vocabulary'
+require 'activefacts/support'
+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",
+    "MetamodelTerms" => "Overlaps with ActiveFacts Metamodel",
+    "ServiceDirector" => "Lacks standard AutoTimestamp class"
+  }
+
+  # Generate and return the Ruby for the given vocabulary
+  def ruby(vocabulary)
+    output = StringIO.new
+    @dumper = ActiveFacts::Generate::RUBY.new(vocabulary.constellation, "sql")
+    @dumper.generate(output)
+    output.rewind
+    output.read
+  end
+
+  pattern = ENV["AFTESTS"] || "*"
+  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')
+
+    it "should load #{orm_file} and generate relational composition and Ruby with matching column names" do
+      vocabulary = ActiveFacts::Input::ORM.readfile(orm_file)
+
+      # 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}
+
+      # 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 }
+      if broken
+        pending(broken) {
+          lambda {
+            eval_it.call
+          }.should_not raise_error
+        }
+      else
+        lambda {
+            eval_it.call
+        }.should_not raise_error
+      end
+
+      # Get a list of table classes in the new module, sorted by name
+      mod = eval(vocabulary.name)
+      ruby_tables = mod.constants.map{|n|
+          c = mod.const_get(n)
+          c.class == Class && c.is_table ? c : nil
+        }.compact.sort_by{|c|
+          c.basename
+        }
+      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 == {}
+
+      # Clean up:
+      Object.send :remove_const, vocabulary.name.to_sym
+      File.delete(actual_file)  # It succeeded, we don't need the file.
+    end
+  end
+end

data/spec/absorption_spec.rb

@@ -2,8 +2,7 @@
 # ActiveFacts tests: Test the relational absorption by compiling CQL fragments.
 # Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
 #
-require 'rubygems'
-require 'treetop'
+
 require 'activefacts/support'
 require 'activefacts/api/support'
 require 'activefacts/input/cql'
@@ -75,8 +74,8 @@ describe "Absorption" do
     cql = test[:cql]
     expected_tables = test[:tables]
     it "should #{should}" do
-      @compiler = ActiveFacts::Input::CQL.new(cql, should)
-      @vocabulary = @compiler.read
+      @compiler = ActiveFacts::CQL::Compiler.new(cql, should)
+      @vocabulary = @compiler.vocabulary
 
       # puts cql
 

data/spec/api/constellation.rb

@@ -50,7 +50,7 @@ describe "A Constellation instance" do
         identified_by :name, :family_name     # REVISIT: want a way to role_alias :name, :given_name
         supertypes SurrogateId
 
-        has_one :family_name, :Name
+        has_one :family_name, :class => Name
       end
     end
     @constellation = ActiveFacts::API::Constellation.new(Mod)

data/spec/api/entity_type.rb

@@ -2,6 +2,8 @@
 # ActiveFacts tests: Entity classes in the Runtime API
 # Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
 #
+require 'activefacts/api'
+
 describe "Entity Type class definitions" do
   before :each do
     Object.send :remove_const, :Mod if Object.const_defined?("Mod")
@@ -13,7 +15,7 @@ describe "Entity Type class definitions" do
       end
       class Person < LegalEntity
         identified_by :name
-        has_one :name, Name
+        has_one :name, :class => Name
       end
     end
   end

data/spec/api/instance.rb

@@ -2,6 +2,8 @@
 # ActiveFacts tests: Value instances in the Runtime API
 # Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
 #
+require 'activefacts/api'
+
 describe "An instance of every type of Concept" do
   before :each do
     Object.send :remove_const, :Mod if Object.const_defined?("Mod")
@@ -45,7 +47,7 @@ describe "An instance of every type of Concept" do
               @role_names.map do |role_name|
                 %Q{
             has_one :#{role_name}
-            one_to_one :one_#{role_name}, #{role_name.to_s.camelcase(true)}}
+            one_to_one :one_#{role_name}, :class => #{role_name.to_s.camelcase(true)}}
               end*""
             }
           end
@@ -55,7 +57,7 @@ describe "An instance of every type of Concept" do
               @role_names.map do |role_name|
                 %Q{
             has_one :#{role_name}
-            one_to_one :one_#{role_name}, #{role_name.to_s.camelcase(true)}}
+            one_to_one :one_#{role_name}, :class => #{role_name.to_s.camelcase(true)}}
               end*""
             }
           end

data/spec/api/roles.rb

@@ -2,6 +2,8 @@
 # ActiveFacts tests: Roles of concept classes in the Runtime API
 # Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
 #
+require 'activefacts/api'
+
 describe "Roles" do
   before :each do
     Object.send :remove_const, :Mod if Object.const_defined?("Mod")
@@ -15,16 +17,16 @@ describe "Roles" do
       end
       class Contract
         identified_by :first, :second
-        has_one :first, LegalEntity
-        has_one :second, LegalEntity
+        has_one :first, :class => LegalEntity
+        has_one :second, :class => LegalEntity
       end
       class Person < LegalEntity
         # identified_by         # No identifier needed, inherit from superclass
         # New identifier:
         identified_by :family, :given
-        has_one :family, Name
-        has_one :given, Name
-        has_one :related_to, LegalEntity
+        has_one :family, :class => Name
+        has_one :given, :class => Name
+        has_one :related_to, :class => LegalEntity
       end
     end
     # print "concept: "; p Mod.concept
@@ -79,7 +81,7 @@ describe "Roles" do
     module Mod
       class FamilyName < Name
         value_type
-        one_to_one :patriarch, Person
+        one_to_one :patriarch, :class => Person
       end
     end
     r = Mod::FamilyName.roles(:patriarch)

data/spec/api_spec.rb

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

data/spec/cql/context_spec.rb

@@ -0,0 +1,71 @@
+#
+# ActiveFacts CQL Business Context Note tests
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+
+require 'activefacts/support'
+require 'activefacts/api/support'
+require 'activefacts/cql/parser'
+
+describe "Business Context Notes" do
+  # (according_to people ',')? (because / as_opposed_to / so_that / to_avoid) discussion (',' as_agreed_by)? s
+  Prefix = %q{
+    Person is written as Person;
+  }
+  Notes = [
+    # Constraints:
+    [ 'each Person occurs one time in Person is employed, Person is unemployed (because it can be no other way!);',
+      [["Person", [:value_type, "Person", [], [], [], []]], [nil, [:constraint, :presence, [["Person"]], [1, 1], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"unemployed"}]]], [nil, "because", "it can be no other way!", []]]]]
+    ],
+    [ 'each Person occurs one time in Person is employed, Person is unemployed (as opposed to blah!);',
+      [["Person", [:value_type, "Person", [], [], [], []]], [nil, [:constraint, :presence, [["Person"]], [1, 1], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"unemployed"}]]], [nil, "as_opposed_to", " blah!", []]]]]
+    ],
+    [ 'for each Person at least one of these holds: Person is employed, Person is a bad credit risk (so that blah);',
+      [["Person", [:value_type, "Person", [], [], [], []]], [nil, [:constraint, :set, [["Person"]], [1, nil], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"a"}, {:word=>"bad"}, {:word=>"credit"}, {:word=>"risk"}]]], [nil, "so_that", " blah", []]]]]
+    ],
+    [ 'Person is good credit risk only if Person is employed (to avoid lending to people who can\'t repay);',
+      [["Person", [:value_type, "Person", [], [], [], []]], [nil, [:constraint, :subset, [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"good"}, {:word=>"credit"}, {:word=>"risk"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]]], [nil, "to_avoid", " lending to people who can't repay", []]]]]
+    ],
+    [ 'Person is good credit risk if and only if Person is employed (to avoid lending to people who can\'t repay);',
+      [["Person", [:value_type, "Person", [], [], [], []]], [nil, [:constraint, :equality, [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"good"}, {:word=>"credit"}, {:word=>"risk"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]]], [nil, "to_avoid", " lending to people who can't repay", []]]]]
+    ],
+    # Entity and Fact types
+    [ 'Foo is identified by Bar [independent] where Foo has one Bar (so that we have an id);',
+      [["Person", [:value_type, "Person", [], [], [], []]], ["Foo", [:entity_type, [], {:roles=>[["Bar"]]}, ["independent"], [[:fact_clause, [], [{:word=>"Foo"}, {:word=>"has"}, {:word=>"Bar", :quantifier=>[1, 1]}], [nil, "so_that", " we have an id", []]]]]]]
+    ],
+    [ 'Foo has one Bar (so that we have an id), Bar is of one Foo (because we need that);',
+      [["Person", [:value_type, "Person", [], [], [], []]], [nil, [:fact_type, [[:fact_clause, [], [{:word=>"Foo"}, {:word=>"has"}, {:word=>"Bar", :quantifier=>[1, 1]}], [nil, "so_that", " we have an id", []]], [:fact_clause, [], [{:word=>"Bar"}, {:word=>"is"}, {:word=>"of"}, {:word=>"Foo", :quantifier=>[1, 1]}], [nil, "because", "we need that", []]]], []]]]
+    ],
+    # REVISIT: No context notes on quantifiers yet
+    # As agreed by:
+    [ 'for each Person at least one of these holds: Person is employed, Person is a bad credit risk (so that blah, as agreed by Jim);',
+      [["Person", [:value_type, "Person", [], [], [], []]], [nil, [:constraint, :set, [["Person"]], [1, nil], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"a"}, {:word=>"bad"}, {:word=>"credit"}, {:word=>"risk"}]]], [nil, "so_that", " blah", [nil, ["Jim"]]]]]] 
+    ],
+    # REVISIT: Populate an "as agreed by" with a date
+    [ 'for each Person at least one of these holds: Person is employed, Person is a bad credit risk (so that blah, as agreed on 29 March by Jim);',
+      [["Person", [:value_type, "Person", [], [], [], []]], [nil, [:constraint, :set, [["Person"]], [1, nil], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"a"}, {:word=>"bad"}, {:word=>"credit"}, {:word=>"risk"}]]], [nil, "so_that", " blah", ["29 March", ["Jim"]]]]]]
+    ],
+    # According to:
+    [ 'for each Person at least one of these holds: Person is employed, Person is a bad credit risk (according to jim, so that blah);',
+      [["Person", [:value_type, "Person", [], [], [], []]], [nil, [:constraint, :set, [["Person"]], [1, nil], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"a"}, {:word=>"bad"}, {:word=>"credit"}, {:word=>"risk"}]]], [["jim"], "so_that", " blah", []]]]]
+    ],
+  ]
+
+  before :each do
+    @parser = ActiveFacts::CQL::Parser.new
+  end
+
+  Notes.each do |c|
+    source, ast = *c
+    it "should parse #{source.inspect}" do
+      #debugger
+      result = @parser.parse_all(Prefix+source, :definition)
+
+      puts @parser.failure_reason unless result
+      result.should_not be_nil
+      result.map{|d| d.value}.should == ast if ast
+      # Uncomment this to see what should replace "nil" in the cases above:
+      #puts result.map{|d| d.value}.inspect unless ast
+    end
+  end
+end

data/spec/cql/samples_spec.rb

@@ -0,0 +1,154 @@
+#
+# ActiveFacts tests: Test the CQL parser by looking at its parse trees.
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+
+require 'activefacts/support'
+require 'activefacts/api/support'
+require 'activefacts/input/cql'
+
+describe "Sample data" do
+  SamplePrefix = %q{
+  vocabulary V;
+
+  CompanyName is written as String;
+  Company is identified by its Name;
+  Person is identified by its Name where Person is called PersonName;
+  Directorship is where
+      Company is directed by Person;
+  }
+
+  Samples = [
+    [   # A simple ValueType instance
+      "CompanyName 'Microsoft';",
+      [{:facts=>[], :instances=>["CompanyName 'Microsoft'"]}]
+    ],
+    [   # Re-assert the same instance
+      "CompanyName 'Microsoft'; CompanyName 'Microsoft';",
+      [{:facts=>[], :instances=>["CompanyName 'Microsoft'"]}]
+    ],
+    [   # The same instance, but in a named population
+      "example: CompanyName 'Microsoft';",
+      [{:facts=>[], :instances=>["CompanyName 'Microsoft'"]}]
+    ],
+    [   # A simply-identified EntityType instance
+      "Company 'Microsoft';",
+      [{:facts=>["Company has CompanyName 'Microsoft'"], :instances=>["Company is identified by CompanyName where Company has CompanyName 'Microsoft'", "CompanyName 'Microsoft'"]}]
+    ],
+    [   # Re-assert the same instance
+      "Company 'Microsoft'; Company 'Microsoft';",
+      [{:facts=>["Company has CompanyName 'Microsoft'"], :instances=>["Company is identified by CompanyName where Company has CompanyName 'Microsoft'", "CompanyName 'Microsoft'"]}]
+    ],
+    [   # The same instance in a named population
+      "example: Company 'Microsoft';",
+      [{:facts=>["Company has CompanyName 'Microsoft'"], :instances=>["Company is identified by CompanyName where Company has CompanyName 'Microsoft'", "CompanyName 'Microsoft'"]}]
+    ],
+    [   # The Company instance asserted with an explicit identifying fact
+      "Company has CompanyName 'Microsoft';",
+      [{:facts=>["Company has CompanyName 'Microsoft'"], :instances=>["Company is identified by CompanyName where Company has CompanyName 'Microsoft'", "CompanyName 'Microsoft'"]}]
+    ],
+    [   # The Company instance asserted with an joined identifying instance
+      "Company has CompanyName, CompanyName 'Microsoft';",
+      [{:facts=>["Company has CompanyName 'Microsoft'"], :instances=>["Company is identified by CompanyName where Company has CompanyName 'Microsoft'", "CompanyName 'Microsoft'"]}]
+    ],
+    [   # The same, with an explicit identifying instance join
+      "CompanyName 'Microsoft', Company has CompanyName;",
+      [{:facts=>["Company has CompanyName 'Microsoft'"], :instances=>["Company is identified by CompanyName where Company has CompanyName 'Microsoft'", "CompanyName 'Microsoft'"]}]
+    ],
+    [   # A simple fact instance with two simply-identified entities
+      "Company 'Microsoft' is directed by Person 'Gates';",
+      [{:facts=>["Company has CompanyName 'Microsoft'", "Company is directed by Person", "Person is called PersonName 'Gates'"], :instances=>["Company is identified by CompanyName where Company has CompanyName 'Microsoft'", "CompanyName 'Microsoft'", "Directorship where Company is directed by Person", "Person is identified by PersonName where Person is called PersonName 'Gates'", "PersonName 'Gates'"]}]
+    ],
+    [   # Same with an explicit joined fact
+      "Company 'Microsoft' is directed by Person, Person is called PersonName 'Gates';",
+      [{:facts=>["Company has CompanyName 'Microsoft'", "Company is directed by Person", "Person is called PersonName 'Gates'"], :instances=>["Company is identified by CompanyName where Company has CompanyName 'Microsoft'", "CompanyName 'Microsoft'", "Directorship where Company is directed by Person", "Person is identified by PersonName where Person is called PersonName 'Gates'", "PersonName 'Gates'"]}]
+    ],
+    [   # Same with explicitly joined facts and instances
+      "Company is directed by Person, Person is called PersonName, PersonName 'Gates', Company has CompanyName, CompanyName 'Microsoft';",
+      [{:facts=>["Company has CompanyName 'Microsoft'", "Company is directed by Person", "Person is called PersonName 'Gates'"], :instances=>["Company is identified by CompanyName where Company has CompanyName 'Microsoft'", "CompanyName 'Microsoft'", "Directorship where Company is directed by Person", "Person is identified by PersonName where Person is called PersonName 'Gates'", "PersonName 'Gates'"]}]
+    ],
+    [   # Same in a named population
+      "example: Company is directed by Person, Person is called PersonName, PersonName 'Gates', Company has CompanyName, CompanyName 'Microsoft';",
+      [{:facts=>["Company has CompanyName 'Microsoft'", "Company is directed by Person", "Person is called PersonName 'Gates'"], :instances=>["Company is identified by CompanyName where Company has CompanyName 'Microsoft'", "CompanyName 'Microsoft'", "Directorship where Company is directed by Person", "Person is identified by PersonName where Person is called PersonName 'Gates'", "PersonName 'Gates'"]}]
+    ],
+  ]
+
+  # REVISIT: This code does a better job than verbalise. Consider incorporating it?
+  def instance_name(i)
+    if i.is_a?(ActiveFacts::Metamodel::Fact)
+      fact = i
+      reading = fact.fact_type.preferred_reading
+      reading_roles = reading.role_sequence.all_role_ref.sort_by{|rr| rr.ordinal}.map{|rr| rr.role }
+      role_values_in_reading_order = fact.all_role_value.sort_by{|rv| reading_roles.index(rv.role) }
+      instance_verbalisations = role_values_in_reading_order.map do |rv|
+        next nil unless v = rv.instance.value
+        v.to_s
+      end
+      return reading.expand([], false, instance_verbalisations)
+      # REVISIT: Include the instance_names of all role players
+    end
+
+    if i.concept.is_a?(ActiveFacts::Metamodel::ValueType)
+      return "#{i.concept.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)}"
+    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
+    identifying_role_refs = pi.role_sequence.all_role_ref.sort_by{|rr| rr.ordinal}
+    return "#{i.concept.name}" +
+      " is identified by " +
+      identifying_role_refs.map do |rr|
+        [ (l = rr.leading_adjective) ? l+"-" : nil,
+          rr.role_name || rr.role.concept.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}
+        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
+        instance_name(identifying_fact)
+      end*", "
+  end
+
+  def instance_data(populations)
+    populations = @vocabulary.constellation.Population
+    populations.keys.sort.map do |popname|
+      popvalue = populations[popname]
+      {
+        :instances => popvalue.all_instance.map { |i| instance_name(i) }.sort,
+        :facts => popvalue.all_fact.map { |fact| instance_name(fact) }.sort
+      }
+    end
+  end
+
+  Samples.each do |c|
+    source, expected = *Array(c)
+    it "should handle #{source.inspect}" do
+      @text = SamplePrefix+source
+      @vocabulary = ActiveFacts::Input::CQL.readstring(@text)
+      result = instance_data(@vocabulary)
+
+      if expected
+        result[0].should == expected[0]
+      else
+        pending "#{source}:\n\t#{result.inspect}"
+      end
+    end
+
+    it "should de-duplicate #{source.inspect}" do
+      # Make sure you don't get anything duplicated
+      @text = SamplePrefix+source+source
+      @vocabulary = ActiveFacts::Input::CQL.readstring(@text)
+      result = instance_data(@vocabulary)
+      result[0].should == expected[0]
+    end
+  end
+end