activefacts 1.6.0 → 1.7.1

data/script/txt2html

@@ -1,71 +0,0 @@
-#!/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

@@ -1,95 +0,0 @@
-#
-# ActiveFacts tests: Test the relational absorption by compiling CQL fragments.
-# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
-#
-
-require 'spec_helper'
-require 'activefacts/support'
-require 'activefacts/api/support'
-require 'activefacts/input/cql'
-require 'activefacts/persistence'
-
-describe "Absorption" do
-  AT_Prologue = %Q{
-    vocabulary Test;
-    DateTime is written as DateAndTime();
-    Month is written as VariableLengthText(3);
-    Season is written as VariableLengthText(6);
-    PartyID is written as AutoCounter();
-    ClaimID is written as AutoCounter();
-  }
-  AT_Claim = %Q{
-    Claim is identified by ClaimID where
-      Claim has exactly one ClaimID,
-      ClaimID is of at most one Claim;
-    Claim was reported on one DateTime;
-  }
-  AT_Incident = %Q{
-    Incident is identified by Claim where
-      Claim concerns at most one Incident,
-      Incident is of exactly one Claim;
-  }
-  AT_Party = %Q{
-    Party is identified by PartyID where
-      Party has exactly one PartyID,
-      PartyID is of at most one Party;
-  }
-  AT_Person = %Q{
-    Person is a kind of Party;
-  }
-
-  Tests = [
-    { :should => "inject a value column into the table for an independent ValueType",
-      :cql => %Q{
-        #{AT_Prologue}
-        Month is in exactly one Season;
-      },
-      :tables => { "Month" => [["Month", "Value"], ["Season"]] }
-    },
-
-    { :should => "absorb a one-to-one along the identification path",
-      :cql => %Q{
-        #{AT_Prologue} #{AT_Claim} #{AT_Incident}
-        Incident relates to loss on exactly one DateTime;
-      },
-      :tables => { "Claim" => [%w{Claim ID}, %w{Date Time}, %w{Incident Date Time}]}
-    },
-
-    { :should => "absorb an objectified binary with single-role UC",
-      :cql => %Q{
-        #{AT_Prologue} #{AT_Claim} #{AT_Party} #{AT_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-DateTime;
-      },
-      :tables => {
-        "Claim" => [%w{Claim ID}, %w{Date Time}, %w{Lodgement Date Time}, %w{Lodgement Person ID}],
-        "Party" => [%w{Party ID}, %w{Person Birth Date Time}]
-      }
-    },
-
-  ]
-
-  Tests.each do |test|
-    should = test[:should]
-    cql = test[:cql]
-    expected_tables = test[:tables]
-    it "should #{should}" do
-      @compiler = ActiveFacts::CQL::Compiler.new(should)
-      @vocabulary = @compiler.compile(cql)
-
-      # puts cql
-
-      # Ensure that the same tables were generated:
-      tables = @vocabulary.tables.sort_by(&:name)
-      tables.map(&:name).should == expected_tables.keys.sort
-
-      # Ensure that the same column descriptions were generated:
-      tables.each do |table|
-        column_descriptions = table.columns.map{|col| col.name(nil) }.sort
-        column_descriptions.should == expected_tables[table.name].map{|c| Array(c) }.sort
-      end
-    end
-  end
-end

data/spec/cql/comparison_spec.rb

@@ -1,89 +0,0 @@
-#
-# ActiveFacts CQL Comparison Fact Type 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 File.dirname(__FILE__) + '/../helpers/compile_helpers'
-
-describe "When matching a reading with an existing fact type" do
-  before :each do
-    extend CompileHelpers
-
-    prefix = %q{
-      vocabulary Tests;
-      Name is written as String;
-      year/years converts to 365.25 day;
-      Age is written as Integer year;
-      Person is identified by its Name;
-      Person is of Age;
-
-      // Company is identified by its Name;
-      // Directorship is where Person directs Company;
-    }
-    @compiler = ActiveFacts::CQL::Compiler.new('Test')
-    @compiler.compile(prefix)
-    @constellation = @compiler.vocabulary.constellation
-
-    baseline
-  end
-
-  describe "equality comparisons" do
-    before :each do
-      #debug_enable("binding"); debug_enable("matching"); debug_enable("matching_fails"); debug_enable("parse")
-    end
-    after :each do
-      #debug_disable("binding"); debug_disable("matching"); debug_disable("matching_fails"); debug_disable("parse")
-    end
-
-    def value_should_match value, lit, unit = nil
-      value.should_not be_nil
-      value.literal.should == lit.to_s
-      (!!value.is_literal_string).should == lit.is_a?(String)
-      if unit
-        value.unit.should_not be_nil
-        value.unit.name.should == unit
-      else
-        value.unit.should be_nil
-      end
-    end
-
-    def one_query_with_value v, unit = nil
-      queries.size.should == 1
-      (jss = steps).size.should == 2
-      (jns = variables).size.should == 3
-      integer_node = jns.detect{|jn| jn.object_type.name == 'Integer'}
-      integer_node.should_not be_nil
-      value_should_match integer_node.value, v, unit
-      # pending should test content of the steps
-    end
-
-    it "should create a comparison fact type" do
-      compile %q{Person is old where Person is of Age >= 60 years; }
-      (new_fact_types = fact_types).size.should == 2
-
-      is_old_ft = new_fact_types.detect{|ft| ft.all_reading.detect{|r| r.text =~ /is old/} }
-      (is_old_ft.all_reading.map{ |r| r.expand }*', ').should == "Person is old"
-
-      comparison_ft = (new_fact_types - [is_old_ft])[0]
-      (comparison_ft.all_reading.map{ |r| r.expand }*', ').should == "Boolean = Age >= Integer"
-
-      one_query_with_value 60, 'year'
-    end
-
-    it "should create a comparison fact type twice without duplication"
-
-    it "should parse a query and comparison fact type" do
-      compile %q{Person is of Age >= 60 years? }
-      (new_fact_types = fact_types).size.should == 1
-      (readings = new_fact_types[0].all_reading).size.should == 1
-      readings.single.text.should == '{0} = {1} >= {2}'
-
-      one_query_with_value 60, 'year'
-    end
-  end
-end

data/spec/cql/context_spec.rb

@@ -1,94 +0,0 @@
-#
-# 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/compiler'
-
-describe "Business Context Notes" do
-  # (according_to people ',')? (because / as_opposed_to / so_that / to_avoid) discussion (',' as_agreed_by)? s
-  ContextNotePrefix = %q{
-    vocabulary Test;
-    Person is written as Person;
-    Person is employed;
-    Person is unemployed;
-    Person is a bad credit risk;
-    Person is good credit risk;
-    Bar is written as Bar;
-    Baz is written as Baz;
-  }
-  Notes = [
-    # Constraints:
-    [ 'each Person occurs one time in Person is employed, Person is unemployed (because it can be no other way!);',
-      1, 'because'
-    ],
-    [ 'each Person occurs one time in Person is employed, Person is unemployed (as opposed to blah!);',
-      1, 'as_opposed_to'
-    ],
-    [ 'for each Person at least one of these holds: Person is employed, Person is a bad credit risk (so that blah);',
-      1, 'so_that'
-    ],
-    [ 'Person is good credit risk only if Person is employed (to avoid lending to people who can\'t repay);',
-      1, 'to_avoid'
-    ],
-    [ 'Person is good credit risk if and only if Person is employed (to avoid lending to people who can\'t repay);',
-      1, 'to_avoid'
-    ],
-    [ 'Person is good credit risk if and only if Person is employed (to avoid lending to people who can\'t repay, as agreed by Jim);',
-      1, 'to_avoid', nil, ['Jim']
-    ],
-    # Entity and Fact types
-    # Entity and Fact types
-    [ 'Foo is identified by Bar [independent] where Foo has one(to avoid fuckups) Bar (so that we have an id);',
-      1, 'so_that'
-    ],
-    [ 'Baz has one Bar (so that we have an id), Bar is of one Baz (because we need that);',
-      2
-    ],
-    # 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);',
-      1, 'so_that', 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 10-04-10 by Jim);',
-      1, 'so_that', nil, ['Jim'], '10-04-10'
-    ],
-    # 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);',
-      1, 'so_that', ['jim']
-    ],
-  ]
-
-  before :each do
-    @compiler = ActiveFacts::CQL::Compiler.new('Test')
-  end
-
-  Notes.each do |c|
-    source, count, kind, according_to, agreed_by, agreed_date = *c
-    it "should parse #{source.inspect}" do
-
-      result =
-        begin
-          @compiler.compile(ContextNotePrefix+source)
-        rescue => e
-          puts "#{e}:\n\t#{e.backtrace*"\n\t"}"
-        end
-      puts @compiler.failure_reason unless result
-      result.should_not be_nil
-      constellation = @compiler.vocabulary.constellation
-
-      # constellation.ContextNote.each{|k,cn| puts "#{k.inspect} => #{cn.inspect}" }
-      constellation.ContextNote.size.should == (count || 1)
-      context_note = constellation.ContextNote.values[0]
-      context_note.context_note_kind.should == kind if kind
-      context_note.all_context_according_to.map{|cat| cat.agent.agent_name }.sort.should == according_to if according_to
-      # context_note.discussion.should == discussion if discussion
-      context_note.agreement.should_not be_nil if agreed_by || agreed_date
-      context_note.agreement.all_context_agreed_by.map{|cab| cab.agent.agent_name}.sort.should == agreed_by if agreed_by
-      context_note.agreement.date.should == Date.parse(agreed_date) if agreed_date
-    end
-  end
-end

data/spec/cql/contractions_spec.rb

@@ -1,224 +0,0 @@
-#
-# ActiveFacts CQL Fact Type matching tests - contractions.
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-# Contractions are where a fact type clause is followed by another (with
-# some conjunction except for comparisons) with one player *implicit* in
-# the following clause.
-#
-# Right contraction elides the repetition of the right-most player,
-# and left contraction elides the left-most player.
-#
-# So, using the notation "A rel B" for binaries,
-# "A relA B relA C" for ternaries, and "C prop" for properties,
-# we can write equivalences as follows.
-#
-# Note 1: Terms may be more than one word.
-# Note 2: For any "A rel B", the example also applies to a ternary or
-#       higher, as appropriate.
-
-=begin
-Right contractions with 'and':
-  A rel B and B prop
-    -> A rel B who/that prop
-  E.g. Person pats Cat that is asleep
-
-  A rel B and B rel2 C
-    -> A rel B who/that rel2 C
-  E.g. Person pats Cat that is lying on Mat
-
-  A rel B and B rel2A C rel2A D
-    -> A rel B who/that rel2A C rel2B D
-  E.g. Person pats Cat that ate Food at Time
-
-  A rel B and B > C
-    -> A rel B > C
-  E.g. Person is of Age >= 21
-
-  A > B and B rel C
-    -> A > B rel C
-  E.g. 21 > Age of Person
-
-Right contractions with ',':
-  A rel B, B rel2 C
-    -> A rel B who/that rel2 C
-
-  A rel B, B prop
-    -> A rel B who/that prop
-
-  A rel B, B > C
-    -> A rel B > C
-
-  A > B, B rel C
-    -> A > B rel C
-
-Left contractions with 'and':
-  A rel B and A rel2 C
-    -> A rel B and rel2 C
-  E.g. Boy seduces Girl and is drunk
-  
-  A rel B and A prop
-    -> A rel B and prop
-
-  A rel B and A > C
-    -> A rel B and > C
-
-Left contractions with 'or':
-  A rel B or A rel2 C
-    -> A rel B or rel2 C
-  
-  A rel B or A prop
-    -> A rel B or prop
-
-  A rel B or A > C
-    -> A rel B or > C
-
-  A > B or A rel C
-    -> A > B or rel C
-
-Double contractions (not supported in CQL yet):
-  A rel B and A rel2 B
-    -> A rel B and rel2
-  E.g. Person came to Party and was invited to
-
-Extended contractions (not supported in CQL yet) (note the ambiguity - if allowed, the first takes precedence!):
-  A rel B and B rel2 C and B prop
-    -> A rel B that rel2 C and prop
-  E.g. LazyDogOwner is a Person who owns Dog that barks and Dog is lazy.
-
-  A rel B and B rel2 C and A prop
-    -> A rel B that rel2 C and prop
-  E.g. LazyDogOwner is a Person who owns Dog that barks and Person is lazy.
-
-And/or resolution:
-  A rel B and B rel2 C or A rel3 D
-  A rel B and B rel2 C or B rel3 D  -> Logical, A must rel B but B can carry either rel
-  A rel B and B rel2 C or C rel3 D  -> Illogical form (mandates B rel2 C so 'or' is meaningless)
-
-Ambiguous, disallowed:
-  A > 2 + B > C
-
-Comments from Matt on contraction and verbalisation:
-
-I have two types of list phrases which I classify as 'header' and 'inline'.
-And and or are inline, the other four (negated and/or, positive or negative
-xor) all use header forms. There is also a header form of negation (it is not
-true that...). The header forms (all of the following must be true: etc) can
-introduce vars in the starting context, but not those introduced by previous
-elements in the list.
-
-You'll likely need something similar, though, on nested expressions. You also
-have to decide where your implicit existential placement is if you use the
-same var in multiple branches or under negation. Lots of fun stuff.
-
-=end
-
-
-require 'rspec/expectations'
-
-require 'activefacts/support'
-require 'activefacts/api/support'
-require 'activefacts/cql/compiler'
-require File.dirname(__FILE__) + '/../helpers/compile_helpers'  # Can't see how to include/extend these methods correctly
-
-describe "When compiling a query, " do
-  before :each do
-    extend CompileHelpers
-
-    prefix = %q{
-      vocabulary Tests;
-      Boy is written as String;
-      Girl is written as Integer;
-      Age is written as Integer;
-      Boy is of Age;
-      Boy is going out with Girl, Girl is going out with Boy;
-    }
-    @compiler = ActiveFacts::CQL::Compiler.new('Test')
-    @compiler.compile(prefix)
-    @constellation = @compiler.vocabulary.constellation
-
-    baseline
-
-    def self.compile string
-      lambda {
-        @compiler.compile string
-      }.should_not raise_error
-    end
-  end
-
-  shared_examples_for "single contractions" do
-    it "should produce one fact type" do
-      (new_fact_types = fact_types).size.should == 1
-    end
-    it "the fact type should have one reading" do
-      fact_type = fact_types[0]
-      fact_type.all_reading.size.should == 1
-    end
-    it "the fact type should have no presence constraints" do
-      fact_type = fact_types[0]
-      (pcs = fact_pcs(fact_type)).size.should == 0
-    end
-    it "should produce one query" do
-      fact_type = fact_types[0]
-      query = derivation(fact_type)
-    end
-    it "the query should have 3 variables" do
-      fact_type = fact_types[0]
-      query = derivation(fact_type)
-      variables = query.all_variable.to_a
-      variables.size.should == 3
-    end
-    it "the query should have 2 steps" do
-      fact_type = fact_types[0]
-      query = derivation(fact_type)
-      steps = query.all_step.to_a
-      steps.size.should == 2
-    end
-
-    it "and should project the fact type roles from the query" do
-      skip "Plays are not yet projected" do
-        query = derivation(fact_type)
-        queries = fact_type.all_role.map{|r| r.all_play.map{|play| play.query}}.flatten.uniq
-        queries.size == 1
-        queries.should == [query]
-      end
-    end
-  end
-
-  describe "right contractions having" do
-    describe "a single contraction using 'who'" do
-      before :each do
-        compile %q{Boy is relevant where Girl is going out with Boy who is of Age; }
-      end
-
-      it_should_behave_like "single contractions"
-    end
-
-    describe "a single contraction using 'that'" do
-      before :each do
-        compile %q{Boy is relevant where Girl is going out with Boy that is of Age; }
-      end
-
-      it_should_behave_like "single contractions"
-    end
-  end
-
-  describe "left contractions having" do
-    describe "a single contraction" do
-      before :each do
-        compile %q{Boy is relevant where Boy is of Age and is going out with Girl; }
-      end
-
-      it_should_behave_like "single contractions"
-    end
-  end
-end
-
-=begin
-Examples on the Blog model:
-
-Post is nice where Post was written by Author and belongs to Topic and includes Ordinal paragraph;
-Post is nice where Post was written by Author and belongs to Topic or Post includes Ordinal paragraph or has Post Id;
-Post is nice where Post was written by Author and belongs to Topic or includes Ordinal paragraph;
-Post is nice where Post was written by Author and belongs to Topic or Post includes Ordinal paragraph or has Post Id;
-=end