alf 0.9.2 → 0.9.3

data/spec/unit/environment/test_folder.rb

@@ -4,7 +4,12 @@ module Alf
     
     let(:path){ File.expand_path('../examples', __FILE__) }
     let(:env){ Environment::Folder.new(path) }
-      
+    
+    specify ".recognizes?" do
+      Environment::Folder.recognizes?([path]).should be_true
+      Environment::Folder.recognizes?(["not/an/existing/one"]).should be_false
+    end
+        
     describe "dataset" do
       
       subject{ env.dataset(name) }

data/spec/unit/operator/relational/matching/test_hash_based.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+module Alf
+  module Operator::Relational
+    describe Matching::HashBased do
+        
+      let(:suppliers) {Alf::Relation[
+        {:sid => 'S1', :city => 'London'},
+        {:sid => 'S2', :city => 'Paris'},
+        {:sid => 'S3', :city => 'Paris'}
+      ]}
+  
+      let(:statuses) {Alf::Relation[
+        {:sid => 'S1', :status => 20},
+        {:sid => 'S2', :status => 10},
+        {:sid => 'S3', :status => 30}
+      ]}
+  
+      let(:countries) {Alf::Relation[
+        {:city => 'London',    :country => 'England'},
+        {:city => 'Paris',     :country => 'France'},
+        {:city => 'Bruxelles', :country => 'Belgium (until ?)'}
+      ]}
+  
+      let(:operator){ Matching::HashBased.new }
+      subject{ operator.to_rel }
+  
+      describe "when applied on both candidate keys" do
+        before{ operator.datasets = [suppliers, statuses] }
+        it { should eq(suppliers) }
+      end
+      
+      describe "when applied on a typical foreign key" do
+        describe "on one way" do
+          before{ operator.datasets = [suppliers, countries] }
+          it { should eq(suppliers) }
+        end
+        describe "on the other way around" do
+          before{ operator.datasets = [countries, suppliers] }
+          it { should eq(countries.restrict(lambda{ city != 'Bruxelles' })) }
+        end
+      end
+      
+      describe "when no attributes are in common" do
+        before{ operator.datasets = [statuses, countries] }
+        it { should eq(statuses) }
+      end
+      
+      describe "against DEE" do
+        before{ operator.datasets = [suppliers, Relation::DEE] }
+        it { should eq(suppliers) }
+      end
+      
+      describe "against DUM" do
+        before{ operator.datasets = [suppliers, Relation::DUM] }
+        it { should eq(Relation::DUM) }
+      end
+
+    end 
+  end
+end

data/spec/unit/operator/relational/not_matching/test_hash_based.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+module Alf
+  module Operator::Relational
+    describe NotMatching::HashBased do
+        
+      let(:suppliers) {Alf::Relation[
+        {:sid => 'S1', :city => 'London'},
+        {:sid => 'S2', :city => 'Paris'},
+        {:sid => 'S3', :city => 'Paris'}
+      ]}
+  
+      let(:operator){ NotMatching::HashBased.new }
+      subject{ operator.to_rel }
+
+      describe "when applied on itself" do
+        before{ operator.datasets = [suppliers, suppliers] }
+        it { should eq(suppliers.minus(suppliers)) }
+      end
+  
+      describe "when applied against a subset" do
+        before{ operator.datasets = [suppliers, Alf::Relation[{:sid => 'S1'}]] }
+        it { should eq(suppliers.restrict(lambda{ sid != 'S1' })) }
+      end
+      
+      describe "against DEE" do
+        before{ operator.datasets = [suppliers, Relation::DEE] }
+        it { should eq(Relation::DUM) }
+      end
+      
+      describe "against DUM" do
+        before{ operator.datasets = [suppliers, Relation::DUM] }
+        it { should eq(suppliers) }
+      end
+
+    end 
+  end
+end

data/spec/unit/operator/relational/test_rank.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+module Alf
+  module Operator::Relational
+    describe Rank do
+        
+      let(:operator_class){ Rank }
+      it_should_behave_like("An operator class")
+        
+      let(:input) {Alf::Relation[
+        {:pid => 'P1', :weight => 12.0},
+        {:pid => 'P2', :weight => 17.0},
+        {:pid => 'P3', :weight => 17.0},
+        {:pid => 'P4', :weight => 14.0},
+        {:pid => 'P5', :weight => 12.0},
+        {:pid => 'P6', :weight => 19.0}
+      ]}
+  
+      subject{ operator.to_rel }
+
+      describe "when a partial ordering is used" do
+        let(:expected) {Alf::Relation[
+          {:pid => 'P1', :weight => 12.0, :rank => 0},
+          {:pid => 'P5', :weight => 12.0, :rank => 0},
+          {:pid => 'P4', :weight => 14.0, :rank => 2},
+          {:pid => 'P2', :weight => 17.0, :rank => 3},
+          {:pid => 'P3', :weight => 17.0, :rank => 3},
+          {:pid => 'P6', :weight => 19.0, :rank => 5}
+        ]}
+        let(:operator){ Rank.new([:weight]) }
+        before{ operator.pipe(input) }
+        it{ should eq(expected) }
+      end
+    
+      describe "when a total ordering is used" do
+        let(:expected) {Alf::Relation[
+          {:pid => 'P1', :weight => 12.0, :rank => 0},
+          {:pid => 'P5', :weight => 12.0, :rank => 1},
+          {:pid => 'P4', :weight => 14.0, :rank => 2},
+          {:pid => 'P2', :weight => 17.0, :rank => 3},
+          {:pid => 'P3', :weight => 17.0, :rank => 4},
+          {:pid => 'P6', :weight => 19.0, :rank => 5}
+        ]}
+        let(:operator){ Rank.new([:weight, :pid]) }
+        before{ operator.pipe(input) }
+        it{ should eq(expected) }
+      end
+          
+    end
+  end
+end

data/spec/unit/operator/test_relational.rb

@@ -10,9 +10,12 @@ module Alf
         Alf::Operator::Relational::Group,
         Alf::Operator::Relational::Intersect,
         Alf::Operator::Relational::Join,
+        Alf::Operator::Relational::Matching,
         Alf::Operator::Relational::Minus,
+        Alf::Operator::Relational::NotMatching,
         Alf::Operator::Relational::Project,
         Alf::Operator::Relational::Quota,
+        Alf::Operator::Relational::Rank,
         Alf::Operator::Relational::Rename,
         Alf::Operator::Relational::Restrict,
         Alf::Operator::Relational::Summarize,

data/spec/unit/reader/test_alf_file.rb

@@ -2,11 +2,14 @@ require 'spec_helper'
 module Alf
   describe Reader::AlfFile do
     
-    let(:io){ StringIO.new(expr) }
-    def dataset(name)
-      [{:status => 10},{:status => 30}]
+    class TestEnv < Alf::Environment
+      def dataset(name)
+        [{:status => 10},{:status => 30}]
+      end
     end
-    subject{ Reader::AlfFile.new(io, self).to_a }
+    
+    let(:io){ StringIO.new(expr) }
+    subject{ Reader::AlfFile.new(io, TestEnv.new).to_a }
 
     describe "on pure functional expressions" do
       let(:expr){ "(restrict :suppliers, lambda{status > 20})" }

data/spec/unit/reader/test_initialize.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+module Alf
+  describe "Reader#initialize" do
+    
+    subject{ Reader.new(*args) }
+    
+    describe "with full args" do
+      let(:args){[
+        "suppliers", Environment.examples, {:opts => true}
+      ]}
+      specify {
+        subject.input.should eq("suppliers")
+        subject.environment.should be_a(Environment)
+        subject.options.should eq(:opts => true)
+      }
+    end
+    
+    describe "with only options" do
+      let(:args){[
+        {:opts => true}
+      ]}
+      specify {
+        subject.input.should be_nil
+        subject.environment.should be_nil
+        subject.options.should eq(:opts => true)
+      }
+    end
+
+    describe "on a subclass" do
+      class FooReader < Reader
+        DEFAULT_OPTIONS = {:from => :subclass}
+      end
+      subject{ FooReader.new(*args) }
+        
+      describe "without option overriding" do
+        let(:args){[
+          {:opts => true}
+        ]}
+        specify {
+          subject.input.should be_nil
+          subject.environment.should be_nil
+          subject.options.should eq(:opts => true, :from => :subclass)
+        }
+      end
+      
+      describe "with option overriding" do
+        let(:args){[
+          {:opts => true, :from => :overrided}
+        ]}
+        specify {
+          subject.input.should be_nil
+          subject.environment.should be_nil
+          subject.options.should eq(:opts => true, :from => :overrided)
+        }
+      end
+      
+    end
+    
+  end
+end

data/spec/unit/relation/test_relops.rb

@@ -12,6 +12,10 @@ module Alf
       {:sid => 'S5'},
       {:sid => 'S2'}
     )}
+
+    specify "allbut" do
+      rel1.allbut([:sid]).should == rel({})
+    end
     
     specify "extend" do
       rel1.extend(:x => lambda{ sid.downcase }).should == rel(

data/spec/unit/relation/test_to_a.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+module Alf
+  describe "Relation#to_a" do
+    
+    let(:rel){Alf::Relation[
+      {:sid => 'S2'},
+      {:sid => 'S1'},
+      {:sid => 'S3'}
+    ]}
+    
+    specify "without an ordering key" do
+      rel.to_a.sort{|k1,k2| k1[:sid] <=> k2[:sid]}.should eq([
+        {:sid => 'S1'},
+        {:sid => 'S2'},
+        {:sid => 'S3'}
+      ])
+    end
+      
+    specify "with an ordering key" do
+      rel.to_a([:sid]).should eq([
+        {:sid => 'S1'},
+        {:sid => 'S2'},
+        {:sid => 'S3'}
+      ])
+      rel.to_a([[:sid, :desc]]).should eq([
+        {:sid => 'S3'},
+        {:sid => 'S2'},
+        {:sid => 'S1'}
+      ])
+    end
+    
+    specify "ON DUM" do
+      Relation::DUM.to_a.should eq([])
+    end
+    
+    specify "ON DEE" do
+      Relation::DEE.to_a.should eq([{}])
+    end
+    
+  end
+end

data/spec/unit/renderer/test_initialize.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+module Alf
+  describe "Renderer#initialize" do
+    
+    subject{ Renderer.new(*args) }
+    
+    describe "with full args" do
+      let(:args){[
+        [], Environment.examples, {:opts => true}
+      ]}
+      specify {
+        subject.input.should eq([])
+        subject.environment.should be_a(Environment)
+        subject.options.should eq(:opts => true)
+      }
+    end
+    
+    describe "with only options" do
+      let(:args){[
+        {:opts => true}
+      ]}
+      specify {
+        subject.input.should be_nil
+        subject.environment.should be_nil
+        subject.options.should eq(:opts => true)
+      }
+    end
+
+    describe "on a subclass" do
+      class FooRenderer < Renderer
+        DEFAULT_OPTIONS = {:from => :subclass}
+      end
+      subject{ FooRenderer.new(*args) }
+        
+      describe "without option overriding" do
+        let(:args){[
+          {:opts => true}
+        ]}
+        specify {
+          subject.input.should be_nil
+          subject.environment.should be_nil
+          subject.options.should eq(:opts => true, :from => :subclass)
+        }
+      end
+      
+      describe "with option overriding" do
+        let(:args){[
+          {:opts => true, :from => :overrided}
+        ]}
+        specify {
+          subject.input.should be_nil
+          subject.environment.should be_nil
+          subject.options.should eq(:opts => true, :from => :overrided)
+        }
+      end
+      
+    end
+    
+  end
+end

data/spec/unit/test_environment.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+module Alf
+  describe Environment do
+    
+    subject{ Environment }
+    it { should respond_to(:folder) }
+      
+    describe "folder" do
+      subject{ Environment.folder(File.dirname(__FILE__)) }
+      it{ should be_a(Environment::Folder) }
+    end
+    
+    describe "autodetect" do
+      
+      it "should support an Environment instance" do
+        env = Environment.examples
+        Environment.autodetect(env).should eq(env)
+      end
+      
+      it "should recognize an existing folder" do
+        env = Environment.autodetect(File.dirname(__FILE__))
+        env.should be_a(Environment::Folder)
+      end
+      
+      it "should raise an Argument when no match" do
+        lambda{ Environment.autodetect(12) }.should raise_error(ArgumentError)
+      end
+      
+      it "should be aliased as coerce" do
+        env = Environment.examples
+        Environment.coerce(env).should eq(env)
+        Environment.coerce(File.dirname(__FILE__)).should be_a(Environment::Folder)
+      end
+      
+    end
+
+  end
+end

data/spec/unit/test_heading.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+module Alf
+  describe Heading do
+    
+    let(:h0){ Heading.new({}) }
+    let(:h1){ Heading.new(:name => String) }
+    let(:h2){ Heading.new(:name => String, :price => Float) }
+    
+    specify "cardinality" do
+      h0.cardinality.should eq(0)
+      h1.cardinality.should eq(1)
+      h2.cardinality.should eq(2)
+    end
+    
+    specify "to_hash" do
+      h0.to_hash.should eq({})
+      h1.to_hash.should eq(:name => String)
+      h2.to_hash.should eq(:name => String, :price => Float)
+    end
+    
+    describe "EMPTY" do
+      subject{ Heading::EMPTY }
+      it_should_behave_like "A value" 
+    end
+    
+    describe "h0" do
+      subject{ h0 }
+      it { should == Heading::EMPTY }
+      it_should_behave_like "A value" 
+    end
+    
+    describe "h1" do
+      subject{ h1 }
+      it_should_behave_like "A value" 
+    end
+    
+  end 
+end