activefacts 0.6.0

data/script/txt2html

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+load File.dirname(__FILE__) + "/../Rakefile"
+require 'rubyforge'
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+
+download = "http://rubyforge.org/projects/#{$hoe.rubyforge_name}"
+version  = $hoe.version
+
+def rubyforge_project_id
+  RubyForge.new.configure.autoconfig["group_ids"][$hoe.rubyforge_name]
+end
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.join(File.dirname(__FILE__), '/../website/template.html.erb')
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.html.erb] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text_template = fsrc.read
+  body_text = ERB.new(body_text_template).result(binding)
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)

data/spec/absorption_spec.rb

@@ -0,0 +1,95 @@
+#
+# 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'
+require 'activefacts/persistence'
+
+describe "Absorption" do
+  Prologue = %Q{
+    vocabulary Test;
+    DateTime is defined as DateAndTime();
+    Month is defined as VariableLengthText(3);
+    Season is defined as VariableLengthText(6);
+    PartyID is defined as AutoCounter();
+    ClaimID is defined as AutoCounter();
+  }
+  Claim = %Q{
+    Claim is identified by ClaimID where
+      Claim has exactly one ClaimID,
+      ClaimID is of at most one Claim;
+  }
+  Incident = %Q{
+    Incident is identified by Claim where
+      Claim concerns at most one Incident,
+      Incident is of exactly one Claim;
+  }
+  Party = %Q{
+    Party is identified by PartyID where
+      Party has exactly one PartyID,
+      PartyID is of at most one Party;
+  }
+  Person = %Q{
+    Person is a kind of Party;
+  }
+
+  Tests = [
+    { :should => "inject a value column into the table for an independent ValueType",
+      :cql => %Q{
+        #{Prologue}
+        Month is in exactly one Season;
+      },
+      :tables => { "Month" => [ %w{Month Value}, "Season" ] }
+    },
+
+    { :should => "absorb a one-to-one along the identification path",
+      :cql => %Q{
+        #{Prologue} #{Claim} #{Incident}
+        Incident relates to loss on exactly one DateTime;
+      },
+      :tables => { "Claim" => ["ClaimID", %w{Incident DateTime}]}
+    },
+
+    { :should => "absorb an objectified binary with single-role UC",
+      :cql => %Q{
+        #{Prologue} #{Claim} #{Party} #{Person}
+        Lodgement is where
+          Claim was lodged by at most one Person;
+        Lodgement was made at at most one DateTime;
+        Person has exactly one birth-Date;
+      },
+      :tables => {
+        "Claim" => ["ClaimID", %w{Lodgement DateTime}, %w{Lodgement Person ID}],
+        "Party" => ["PartyID", %w{Person birth Date}]
+      }
+    },
+
+  ]
+
+  setup do
+  end
+
+  Tests.each do |test|
+    should = test[:should]
+    cql = test[:cql]
+    expected_tables = test[:tables]
+    it "should #{should}" do
+      @compiler = ActiveFacts::Input::CQL.new(cql, should)
+      @vocabulary = @compiler.read
+
+      # Ensure that the same tables were generated:
+      tables = @vocabulary.tables
+      tables.map(&:name).sort.should == expected_tables.keys.sort
+
+      # Ensure that the same column descriptions were generated:
+      tables.sort_by(&:name).each do |table|
+        column_descriptions = table.absorbed_roles.all_role_ref.map{|rr| rr.column_name(nil) }.sort
+        column_descriptions.should == expected_tables[table.name].map{|c| Array(c) }.sort
+      end
+    end
+  end
+end

data/spec/api/autocounter.rb

@@ -0,0 +1,82 @@
+#
+# ActiveFacts tests: Value instances in the Runtime API
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+describe "AutoCounter Value Type instances" do
+  setup do
+    Object.send :remove_const, :Mod if Object.const_defined?("Mod")
+    module Mod
+      class ThingId < AutoCounter
+        value_type
+      end
+      class Thing
+        identified_by :thing_id
+        has_one :thing_id
+      end
+      class Ordinal < Int
+        value_type
+      end
+      class ThingFacet
+        identified_by :thing, :ordinal
+        has_one :thing
+        has_one :ordinal
+      end
+    end
+    @constellation = ActiveFacts::API::Constellation.new(Mod)
+    @thing = Mod::Thing.new(:new)
+    @thing_id = Mod::ThingId.new
+  end
+
+  it "should respond to verbalise" do
+    @thing_id.respond_to?(:verbalise).should be_true
+  end
+
+  it "should verbalise correctly" do
+    @thing_id.verbalise.should =~ /ThingId 'new_[0-9]+'/
+  end
+
+  it "should respond to constellation" do
+    @thing_id.respond_to?(:constellation).should be_true
+  end
+
+  it "should respond to its roles" do
+    @thing_id.respond_to?(:all_thing).should be_true
+  end
+
+  it "should allow prevent invalid role assignment" do
+    lambda {
+        @thing.thing_id = "foo"
+      }.should raise_error
+  end
+
+  it "should allow its roles to be assigned" do
+    lambda {
+        @thing.thing_id = @thing_id
+      }.should_not raise_error
+  end
+
+  it "should allow an existing counter to be re-used" do
+    @new_thing = Mod::Thing.new(@thing_id)
+    @new_thing.thing_id.should == @thing_id
+  end
+
+  it "should return the ValueType in response to .class()" do
+    @thing_id.class.vocabulary.should == Mod
+  end
+
+  it "should not allow a counter to be cloned" do
+    lambda {
+      @thing_id.clone
+    }.should raise_error
+  end
+
+  it "should allow an existing counter-identified object to be re-used" do
+    thing = @constellation.Thing(:new)
+    facets = []
+    facets << @constellation.ThingFacet(thing, 0)
+    facets << @constellation.ThingFacet(thing, 1)
+    facets[0].thing.object_id.should == facets[1].thing.object_id
+    facets[0].thing.thing_id.object_id.should == facets[1].thing.thing_id.object_id
+  end
+
+end

data/spec/api/constellation.rb

@@ -0,0 +1,130 @@
+#
+# ActiveFacts tests: Constellation instances in the Runtime API
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+require "ruby-debug"
+
+require 'activefacts/api'
+
+describe "A Constellation instance" do
+  setup do
+    Object.send :remove_const, :Mod if Object.const_defined?("Mod")
+    module Mod
+      @base_types = [
+          Int, Real, AutoCounter, String, Date, DateTime
+        ]
+
+      # Create a value type and a subtype of that value type for each base type:
+      @base_types.each do |base_type|
+        eval %Q{
+          class #{base_type.name}Value < #{base_type.name}
+            value_type
+          end
+
+          class #{base_type.name}SubValue < #{base_type.name}Value
+            # Note no new "value_type" is required here, it comes through inheritance
+          end
+        }
+      end
+
+      class Name < StringValue
+        value_type
+        #has_one :attr, Name
+      end
+
+      class LegalEntity
+        identified_by :name
+        has_one :name
+      end
+
+      class SurrogateId
+        identified_by :auto_counter_value
+        has_one :auto_counter_value
+      end
+
+      class Company < LegalEntity
+        supertypes SurrogateId
+      end
+
+      class Person < LegalEntity
+        identified_by :name, :family_name     # REVISIT: want a way to role_alias :name, :given_name
+        supertypes SurrogateId
+
+        has_one :family_name, :Name
+      end
+    end
+    @constellation = ActiveFacts::API::Constellation.new(Mod)
+  end
+
+  it "should support fetching its vocabulary" do
+    @constellation.vocabulary.should == Mod
+  end
+
+#  it "should support fetching its query" do
+#    pending
+#    @constellation.query.should == Mod
+#  end
+
+  it "should support methods to construct instances of any concept" do
+    name = foo = acme = fred_fly = nil
+    lambda {
+        name = @constellation.Name("foo")
+        foo = @constellation.LegalEntity("foo")
+        acme = @constellation.Company("Acme, Inc")
+        fred_fly = @constellation.Person("fred", "fly")
+      }.should_not raise_error
+    name.class.should == Mod::Name
+    name.constellation.should == @constellation
+    foo.class.should == Mod::LegalEntity
+    foo.constellation.should == @constellation
+    acme.class.should == Mod::Company
+    acme.constellation.should == @constellation
+    fred_fly.class.should == Mod::Person
+    fred_fly.constellation.should == @constellation
+  end
+
+  it "should re-use instances constructed the same way" do
+    name1 = @constellation.Name("foo")
+    foo1 = @constellation.LegalEntity("foo")
+    acme1 = @constellation.Company("Acme, Inc")
+    fred_fly1 = @constellation.Person("fred", "fly")
+
+    name2 = @constellation.Name("foo")
+    foo2 = @constellation.LegalEntity("foo")
+    acme2 = @constellation.Company("Acme, Inc")
+    fred_fly2 = @constellation.Person("fred", "fly")
+
+    name1.object_id.should == name2.object_id
+    foo1.object_id.should == foo2.object_id
+    acme1.object_id.should == acme2.object_id
+    fred_fly1.object_id.should == fred_fly2.object_id
+  end
+
+  it "should index value instances, including by its superclasses" do
+    baz = @constellation.Name("baz")
+    @constellation.Name.keys.sort.should == ["baz"]
+
+    @constellation.StringValue.keys.sort.should == ["baz"]
+  end
+
+  it "should index entity instances, including by its superclass and secondary supertypes" do
+    name = "Acme, Inc"
+    fred = "Fred"
+    fly = "Fly"
+    acme = @constellation.Company name, :auto_counter_value => :new
+    fred_fly = @constellation.Person fred, fly, :auto_counter_value => :new
+
+    # REVISIT: This should be illegal:
+    #fred_fly.auto_counter_value = :new
+
+    @constellation.Person.keys.sort.should == [[fred, fly]]
+    @constellation.Company.keys.sort.should == [[name]]
+
+    @constellation.LegalEntity.keys.sort.should be_include([name])
+    @constellation.LegalEntity.keys.sort.should be_include([fred])
+
+    @constellation.SurrogateId.values.should be_include(acme)
+    @constellation.SurrogateId.values.should be_include(fred_fly)
+  end
+
+end

data/spec/api/entity_type.rb

@@ -0,0 +1,101 @@
+#
+# ActiveFacts tests: Entity classes in the Runtime API
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+describe "Entity Type class definitions" do
+  setup do
+    Object.send :remove_const, :Mod if Object.const_defined?("Mod")
+    module Mod
+      class Name < String
+        value_type
+      end
+      class LegalEntity
+      end
+      class Person < LegalEntity
+        identified_by :name
+        has_one :name, Name
+      end
+    end
+  end
+
+  it "should respond_to verbalise" do
+    Mod::Person.respond_to?(:verbalise).should be_true
+  end
+
+  it "should not pollute the superclass" do
+    Mod::LegalEntity.respond_to?(:verbalise).should_not be_true
+    Class.respond_to?(:verbalise).should_not be_true
+  end
+
+  it "should return a string from verbalise" do
+    v = Mod::Person.verbalise
+    v.should_not be_nil
+    v.should_not =~ /REVISIT/
+  end
+
+  it "should respond_to vocabulary" do
+    Mod::Person.respond_to?(:vocabulary).should be_true
+  end
+
+  it "should return the parent module as the vocabulary" do
+    vocabulary = Mod::Person.vocabulary
+    vocabulary.should == Mod
+  end
+
+  it "should return a vocabulary that knows about this concept" do
+    vocabulary = Mod::Person.vocabulary
+    vocabulary.respond_to?(:concept).should be_true
+    vocabulary.concept.has_key?("Person").should be_true
+  end
+
+  it "should respond to roles()" do
+    Mod::Person.respond_to?(:roles).should be_true
+  end
+
+  it "should contain only the added role definition" do
+    Mod::Person.roles.size.should == 1
+  end
+
+  it "should return the role definition" do
+    # Check the role definition may be accessed by passing an index:
+    Mod::Person.roles(0).should be_nil
+
+    role = Mod::Person.roles(:name)
+    role.should_not be_nil
+
+    role = Mod::Person.roles("name")
+    role.should_not be_nil
+
+    # Check the role definition may be accessed by indexing the returned hash:
+    role = Mod::Person.roles[:name]
+    role.should_not be_nil
+
+    # Check the role definition array by .include?
+    Mod::Person.roles.include?(:name).should be_true
+  end
+
+  it "should fail on a ValueClass" do
+    lambda{
+      class SomeClass < String
+        identified_by
+      end
+    }.should raise_error
+  end
+
+  it "should return the identifying roles" do
+    Mod::Person.identifying_roles.should == [:name]
+  end
+
+  it "should prevent a role name from matching a concept that exists unless that concept is the player" do
+    lambda {
+        module Mod
+          class LegalEntity
+          end
+          class Bad
+            identified_by :name
+            has_one :name, LegalEntity
+          end
+        end
+      }.should raise_error
+  end
+end