alf-core 0.13.0

data/spec/integration/ext/test_relation.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+describe "Relation()" do
+
+  it 'returns a Relation' do
+    Relation(:name => "Alf").should be_a(Alf::Relation)
+  end
+
+  it 'helps building a singleton' do
+    Relation(:name => "Alf").cardinality.should eq(1)
+  end
+
+  it 'helps building a list if values' do
+    Relation(:name => ["Alf", "Myrrha"]).cardinality.should eq(2)
+  end
+
+end

data/spec/integration/relation/test_to_array.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+describe Alf::Relation, 'to_array' do
+
+  let(:rel) {
+    examples_database.query do
+      group((project suppliers, [:city, :name]), [:name], :incity)
+    end
+  }
+
+  let(:expected){
+    [
+      Tuple(:city => 'Athens', :incity => [ Tuple(:name => 'Adams') ] ),
+      Tuple(:city => 'London', :incity => [ Tuple(:name => 'Clark'), Tuple(:name => 'Smith') ]),
+      Tuple(:city => 'Paris',  :incity => [ Tuple(:name => 'Blake'), Tuple(:name => 'Jones') ]),
+    ]
+  }
+
+  let(:ordering){ [:city, :name] }
+
+  it 'recursively converts to sorted arrays' do
+    rel.to_array(:sort => ordering).should eq(expected)
+  end
+
+  # it 'is aliased as to_a' do
+  #   rel.to_a(:sort => ordering).should eq(expected)
+  # end
+
+end

data/spec/integration/relvar/test_type_safe.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Alf
+  describe Relvar, 'type_safe' do
+
+    let(:operand){ an_operand.with_heading(status: Integer)     }
+    let(:relvar) { operand.to_relvar.type_safe(status: Integer) }
+
+    context 'when invalid tuples are inserted' do
+      let(:tuples){
+        [ {status: "blah"} ]
+      }
+      subject{ relvar.insert(tuples) }
+
+      it 'raises a TypeCheckError' do
+        lambda{
+          subject
+        }.should raise_error(TypeCheckError)
+      end
+    end
+
+  end
+end

data/spec/integration/test_alf.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+describe Alf::Core do
+  
+  it "has a version number" do
+    Alf::Core.const_defined?(:VERSION).should be_true
+  end
+  
+end

data/spec/integration/test_examples.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+Dir["#{File.expand_path('../../../examples', __FILE__)}/**/*.alf"].each do |file|
+
+  describe "Alf example: #{file}" do
+    let(:example_path){ file }
+    let(:example_dir) { File.dirname(file) }
+    let(:example_db) { Alf.connect(example_dir) }
+
+    it "should run without error" do
+      example_db.query(File.read(example_path), example_path)
+    end
+  end
+
+end

data/spec/optimizer_helper.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+require 'unit/alf-optimizer/shared/a_pass_through_expression_for_restrict'
+require 'unit/alf-optimizer/shared/a_split_able_expression_for_restrict'
+require 'unit/alf-optimizer/shared/an_unoptimizable_expression_for_restrict'
+require 'unit/alf-optimizer/shared/an_optimizable_expression_for_restrict'
+
+module Helpers
+
+  def comp(*args)
+    args.unshift(:eq) if Alf::TupleLike===args.first
+    Alf::Predicate.comp(*args)
+  end
+
+end
+
+RSpec.configure do |c|
+  c.include Alf::Lang::Functional
+end

data/spec/regression/heading/test_heading_with_date.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'date'
+module Alf
+  describe Heading do
+  
+    describe "when attributes on Foo domain" do
+      subject{ Heading[{:date => Date}] }
+      it_should_behave_like "A value"
+    end
+    
+  end
+end

data/spec/regression/relation/test_coerce.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Alf
+  describe Relation, ".coerce bugs" do
+
+    let(:arg){ [Tuple(sid: "S5", suppliers: Relation([]))] }
+
+    context 'on Relation' do
+      subject{ Relation.coerce(arg) }
+
+      it 'works' do
+        subject.should be_a(Relation)
+      end
+    end
+
+    context 'on Relation[...]' do
+      subject{ Relation[sid: String, suppliers: Relation[{}]].coerce(arg) }
+
+      it 'works' do
+        subject.should be_a(Relation)
+      end
+    end
+
+  end
+end

data/spec/regression/relation/test_relation_allbut_all.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+require 'date'
+module Alf
+  describe Relation, "allbut" do
+
+    describe "when all attributes are projected away" do
+      subject{
+        Relation(sid: "P1").allbut([:sid])
+      }
+      it{ should eql(Relation::DEE) }
+    end
+
+  end
+end

data/spec/regression/relation/test_relation_with_date.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'date'
+module Alf
+  describe Relation do
+  
+    describe "when attributes on Date domain" do
+      subject{ Relation(date: Date.today) }
+      it_should_behave_like "A value"
+    end
+    
+  end
+end

data/spec/regression/relation/test_restrict.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+module Alf
+  describe Relation, ".restrict bugs" do
+
+    let(:arg){
+      Relation([
+        { sid: "S1", supplies: Relation(pid: ["P1", "P2"]) },
+        { sid: "S5", supplies: Relation([]) }
+      ])
+    }
+
+    context 'on Relation' do
+      subject{ arg.restrict(sid: 'S5') }
+
+      it 'does not raise a TypeError' do
+        subject.should be_a(Relation)
+      end
+    end
+
+  end
+end

data/spec/regression/restrict/test_restrict_with_keywords.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+module Alf
+  describe "(restrict xxx, :keyword => ...)" do
+
+    it "should support using a keyword on Relation" do
+      rel = Relation(when: "now")
+      rel.restrict(when: "now").should eq(rel)
+    end
+
+    it "should support using a keyword on Lispy" do
+      Alf.examples.query do
+        (restrict (extend suppliers, {:when => lambda{"notnow"}}), {:when => "now"})
+      end.should eq(Relation::DUM)
+    end
+
+  end
+end

data/spec/shared/a_scope.rb

@@ -0,0 +1,21 @@
+shared_examples_for "A scope" do
+
+  it 'responds to its own methods' do
+    subject.respond_to?(:respond_to?).should be_true
+    subject.respond_to?(:evaluate).should be_true
+    subject.respond_to?(:__eval_binding).should be_true
+  end
+
+  it 'responds to needed kernel methods' do
+    subject.respond_to?(:lambda).should be_true
+  end
+
+  it "responds to BasicObject's API" do
+    subject.respond_to?(:instance_eval).should be_true
+  end
+  
+  it 'does not respond to anything' do
+    subject.respond_to?(:anything_else).should be_false
+  end
+
+end

data/spec/shared/a_valid_type_implementation.rb

@@ -0,0 +1,47 @@
+shared_examples_for "A valid type implementation" do
+
+  it 'should have exemplars available' do
+    type.exemplars.should_not be_empty
+    type.exemplars.each do |value|
+      (type === value).should be_true
+    end
+  end
+
+  it 'should define dupable values' do
+    type.exemplars.each do |ex|
+      ex.dup.should eq(ex)
+      ex.dup.object_id.should_not eq(ex.object_id)
+    end
+  end
+
+  it 'should define values that appear same in arrays' do
+    type.exemplars.each do |ex|
+      [ex, ex.dup, ex].uniq.should eq([ex])
+    end
+  end
+
+  it 'should define values with correct hash codes' do
+    type.exemplars.each do |ex|
+      ex.dup.hash.should eq(ex.hash)
+    end
+  end
+
+  it 'should define values that can be used as Hash keys' do
+    type.exemplars.each do |ex|
+      {ex => 1, ex.dup => 2}.size.should eq(1)
+    end
+  end
+
+  it 'should define values respecting the :to_ruby_literal spec' do
+    type.exemplars.each do |ex|
+      Kernel.eval(ex.to_ruby_literal).should eq(ex)
+    end
+  end
+
+  it 'should define values respecting the :inspect spec' do
+    type.exemplars.each do |ex|
+      Kernel.eval(ex.inspect).should eq(ex)
+    end
+  end
+
+end

data/spec/shared/a_value.rb

@@ -0,0 +1,12 @@
+shared_examples_for "A value" do
+  
+  it "should have a inspect/class.parse that lead to equal values" do
+    Kernel.eval(subject.inspect).should eq(subject)
+  end
+  
+  it "should act a valid Hash keys" do
+     dup = Kernel.eval(subject.inspect)
+     {subject => true, dup => false}.size.should == 1
+  end
+  
+end

data/spec/shared/an_operator_class.rb

@@ -0,0 +1,49 @@
+shared_examples_for "An operator class" do
+
+  it "should have a public rubycase_name method" do
+    operator_class.should respond_to(:rubycase_name)
+  end
+
+  it "should have an arity class method" do
+    operator_class.should respond_to(:arity)
+  end
+
+  it "should have a unary? class method" do
+    operator_class.should respond_to(:unary?)
+  end
+
+  it "should have a binary? class method" do
+    operator_class.should respond_to(:binary?)
+  end
+
+  it "should have a nullary? class method" do
+    operator_class.should respond_to(:nullary?)
+  end
+
+  it "should have relational? and non_relational? methods" do
+    operator_class.should respond_to(:relational?)
+    operator_class.should respond_to(:non_relational?)
+  end
+
+  it "arity should be consistent with nullary?, unary?, binary?" do
+    case operator_class.arity
+    when 0
+      operator_class.should be_nullary
+    when 1
+      operator_class.should be_unary
+    when 2
+      operator_class.should be_binary
+    else
+      raise "Unexpected arity #{operator_class.arity} (#{operator_class})"
+    end
+  end
+
+  it "should implement unary? and binary? consistently" do
+    op = operator_class
+    (op.nullary? || op.unary? || op.binary?).should be_true
+    (op.nullary? && op.unary?).should be_false
+    (op.nullary? && op.binary?).should be_false
+    (op.unary? && op.binary?).should be_false
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,68 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'alf-core'
+require "rspec"
+require 'shared/an_operator_class'
+require 'shared/a_valid_type_implementation'
+require 'shared/a_value'
+require 'shared/a_scope'
+
+(Path.dir/"unit").glob("**/shared_examples/*").each do |f|
+  require(f)
+end
+
+module Helpers
+
+  SUPPLIER_NAMES = ["Smith", "Clark", "Jones", "Blake", "Adams"]
+
+  def examples_path
+    @examples_path ||= Path.backfind('examples/operators')
+  end
+
+  def a_lispy
+    Alf::Lang::Lispy.new
+  end
+
+  def supplier_names
+    SUPPLIER_NAMES
+  end
+
+  def supplier_names_relation
+    Relation(:name => supplier_names)
+  end
+
+  def examples_database(&bl)
+    Alf.examples
+  end
+
+  def sap_adapter
+    Alf::Adapter.factor(examples_path)
+  end
+
+  def sap_db
+    Alf::Database.new(sap_adapter)
+  end
+
+  def sap_conn
+    sap_db.connection
+  end
+
+  def suppliers
+    Alf::Algebra.named_operand(:suppliers, examples_database)
+  end
+
+  def an_operand
+    Alf::Algebra::Operand::Fake.new
+  end
+
+end
+
+module HelpersInScope
+  def hello(who); "Hello #{who}!"; end
+  def world; "world"; end
+end
+
+RSpec.configure do |c|
+  c.include Helpers
+  c.extend  Helpers
+  c.filter_run_excluding :ruby19 => (RUBY_VERSION < "1.9")
+end

data/spec/unit/alf-adapter-fs/folder/fixtures/suppliers.rash

@@ -0,0 +1,5 @@
+{:sid => 'S1', :name => 'Smith', :status => 20, :city => 'London'}
+{:sid => 'S2', :name => 'Jones', :status => 10, :city => 'Paris'}
+{:sid => 'S3', :name => 'Blake', :status => 30, :city => 'Paris'}
+{:sid => 'S4', :name => 'Clark', :status => 20, :city => 'London'}
+{:sid => 'S5', :name => 'Adams', :status => 30, :city => 'Athens'}

data/spec/unit/alf-adapter-fs/folder/test_adapter_class.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+module Alf
+  class Adapter
+    describe Folder do
+
+      let(:adapter_class){ Folder }
+
+      let(:recognized_conn_specs) do
+        [ File.dirname(__FILE__), Path.dir ]
+      end
+
+      it_should_behave_like "an adapter class"
+
+      describe "recognizes?" do
+
+        it 'is not be too permissive' do
+          Folder.recognizes?("not/an/existing/one").should be_false
+        end
+      end
+
+    end # describe Folder
+  end # class Adapter
+end # module Alf