alf 0.12.2 → 0.13.0

data/spec/unit/alf-core/relation/test_inspect.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Relation do
-    
-    let(:rel){Relation.coerce([
-      {:sid => 'S1'},
-      {:sid => 'S2'},
-      {:sid => 'S3'}
-    ])}
-    
-    describe "inspect" do
-      
-      it "should allows the litteral round-trip" do
-        Kernel.eval(rel.inspect).should == rel
-      end
-
-    end # coerce
-      
-  end
-end

data/spec/unit/alf-core/relation/test_relops.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Relation do
-    
-    let(:rel1){Alf::Relation[
-      {:sid => 'S1'},
-      {:sid => 'S2'},
-      {:sid => 'S3'}
-    ]}
-    
-    let(:rel2){Alf::Relation[
-      {:sid => 'S5'},
-      {:sid => 'S2'}
-    ]}
-
-    specify "project" do
-      rel1.project([]).should eq(Alf::Relation[{}])
-      rel1.project([:sid], :allbut => true).should eq(Alf::Relation[{}])
-    end
-    
-    specify "allbut" do
-      rel1.allbut([:sid]).should eq(Alf::Relation[{}])
-    end
-    
-    specify "extend" do
-      rel1.extend(:x => lambda{ sid.downcase }).should == Alf::Relation[
-        {:sid => 'S1', :x => 's1'},
-        {:sid => 'S2', :x => 's2'},
-        {:sid => 'S3', :x => 's3'}
-      ]
-    end
-      
-    specify "union" do
-      (rel1 + rel1).should == rel1
-      (rel1 + rel2).should == Alf::Relation[
-        {:sid => 'S1'},
-        {:sid => 'S3'},
-        {:sid => 'S2'},
-        {:sid => 'S5'}
-      ]
-    end # coerce
-      
-    specify "difference" do
-      (rel1 - rel1).should == Alf::Relation[]
-      (rel1 - rel2).should == Alf::Relation[
-        {:sid => 'S1'},
-        {:sid => 'S3'}
-      ]
-      (rel2 - rel1).should == Alf::Relation[
-        {:sid => 'S5'}
-      ]
-    end # coerce
-    
-  end
-end

data/spec/unit/alf-core/relation/test_to_a.rb

@@ -1,41 +0,0 @@
-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/alf-core/renderer/test_initialize.rb

@@ -1,60 +0,0 @@
-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/alf-core/test_aggregator.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Aggregator do
-
-    let(:input){[
-      {:a => 1, :sign => -1},
-      {:a => 2, :sign => 1 },
-      {:a => 3, :sign => -1},
-      {:a => 1, :sign => -1},
-    ]}
-
-    it "should keep track of registered aggregators" do
-      Aggregator.aggregators.should_not be_empty
-      Aggregator.each do |agg|
-        agg.should be_a(Class)
-      end
-    end
-
-    it "should allow specific tuple computations" do
-      Aggregator.sum{ 1.0 * a * sign }.aggregate(input).should == -3.0
-    end
-
-    describe "coerce" do
-     
-      subject{ Aggregator.coerce(arg) }
-      
-      describe "from an Aggregator" do
-        let(:arg){ Aggregator.sum{a} }
-        it{ should eq(arg) }
-      end
-      
-      describe "from a String" do
-        let(:arg){ "sum{a}" }
-
-        it { 
-          should be_a(Aggregator::Sum) 
-        }
-
-        it 'should have source code' do
-          subject.has_source_code!.should eq("sum{a}")
-        end
-
-        specify{ 
-          subject.aggregate(input).should eql(7) 
-        }
-
-      end
-      
-    end
-
-    it 'should implement optimistic equality based on source code' do
-      ag1 = Aggregator.coerce("sum{ qty }")
-      ag2 = Aggregator.coerce("sum{ qty }")
-      ag1.should eq(ag2)
-    end
-
-  end
-end

data/spec/unit/alf-core/test_environment.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Environment do
-
-    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 # autodetect
-
-  end
-end

data/spec/unit/alf-core/test_operator.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Operator do
-    
-    specify "each" do
-      ops = []
-      Operator.each{|m| ops << m}
-      nonrel = []
-      Operator::NonRelational.each{|m| nonrel << m}
-      rel = []
-      Operator::Relational.each{|m| rel << m}
-      ops.should == nonrel + rel
-    end
-    
-  end
-end

data/spec/unit/alf-core/test_reader.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Reader do
-    
-    subject{ Reader }
-    it { should respond_to(:rash) }
-      
-    describe "rash on a real IO" do
-      subject{ Reader.rash($stdin) }
-      it{ should be_a(Reader::Rash) }
-    end
-    
-    describe "reader" do
-      
-      specify "when associated" do
-        r = Reader.reader('suppliers.rash')
-        r.should  be_a(Reader::Rash)
-      end
-      
-      specify "when not associated" do
-        lambda{ Reader.reader('.noone') }.should raise_error
-      end
-      
-      specify "when an IO" do
-        Reader.reader($stdin).should be_a(Reader::Rash)
-      end
-      
-      specify "when an StringIO" do
-        Reader.reader(StringIO.new).should be_a(Reader::Rash)
-      end
-      
-      specify "with options" do
-        r = Reader.reader('suppliers.rash', {:hello => "world"})
-        r.options.should == {:hello => "world"}
-      end
-      
-    end
-
-  end
-end

data/spec/unit/alf-core/test_relation.rb

@@ -1,75 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Relation do
- 
-    let(:tuples){[
-      {:sid => 'S1', :name => 'Smith', :status => 20, :city => 'London'},
-      {:sid => 'S2', :name => 'Jones', :status => 10, :city => 'Paris'},
-      {:sid => 'S3', :name => 'Blake', :status => 30, :city => 'Paris'}
-    ]}
-    let(:tuples2){ tuples.sort{|t1,t2| t1[:name] <=> t2[:name]} }
-    
-    let(:rel1){ Relation.new(tuples.to_set) }
-    let(:rel2){ Relation.new(tuples2.to_set) }
-    let(:rel3){ Relation.new(tuples[0..1].to_set) }
-  
-    it "should have a cardinality method" do
-      rel1.cardinality.should == 3
-    end
-    
-    it "should have an empty? method" do
-      Alf::Relation[].should be_empty
-      rel1.should_not be_empty
-    end
-      
-    it "should define == correctly" do
-      rel1.should == rel2
-      rel2.should == rel1
-      rel3.should_not == rel1
-    end
-    
-    it "should allow putting them in hashes" do
-      h = {}
-      h[rel1] = 1
-      h[rel2] = 2
-      h[rel3] = 3
-      h.size.should == 2
-      h[rel1].should == 2
-    end
-    
-    it "should be enumerable" do
-      rel1.to_a.sort{|t1,t2| t1[:sid] <=> t2[:sid]}.should == tuples
-    end
-
-    describe "rel1" do
-      subject{ rel1 }
-      it_should_behave_like "A value"  
-    end
-    
-    specify "different empty relations instances should be equal" do
-      Relation.new(Set.new).should eq(Relation.new(Set.new))
-      Relation[{}].should eq(Relation[{}])
-    end
-    
-    describe "DUM" do
-      subject{ Relation::DUM }
-      it_should_behave_like "A value"
-      specify{
-        subject.cardinality.should == 0
-        subject.to_a.should == []
-        subject.should be_empty
-      }
-    end
-    
-    describe "DEE" do
-      subject{ Relation::DEE }
-      it_should_behave_like "A value"  
-      specify{
-        subject.cardinality.should == 1
-        subject.to_a.should == [{}]
-        subject.should_not be_empty
-      }
-    end
-    
-  end
-end

data/spec/unit/alf-core/test_renderer.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Renderer do
-    
-    subject{ Renderer }
-    it { should respond_to(:rash) }
-    it { should respond_to(:text) }
-
-    describe 'renderer' do
-      subject{ Renderer.renderer(:rash) } 
-      it{ should be_a(Renderer) }
-    end
-      
-    describe 'rash' do
-      subject{ Renderer.rash(input) } 
-      let(:input){ [{:a => 1}] }
-      let(:output){ "" }
-      let(:expected){ "{:a => 1}\n" }
-      specify{ 
-        subject.should be_a(Renderer)
-        subject.execute(output).should == expected
-      }
-    end
-
-    describe 'rash --pretty' do
-      subject{ Renderer.rash(input, {:pretty => true}) } 
-      let(:input){ [{:a => 1}] }
-      let(:output){ "" }
-      let(:expected){ "{\n  :a => 1\n}\n" }
-      specify{ 
-        subject.should be_a(Renderer)
-        subject.execute(output).should == expected
-      }
-    end
-    
-    describe 'text' do
-      subject{ Renderer.text(input) } 
-      let(:input){ [{:a => 1}] }
-      let(:output){ "" }
-      let(:expected){ "+----+\n"\
-                      "| :a |\n"\
-                      "+----+\n"\
-                      "|  1 |\n"\
-                      "+----+\n"
-      }
-      specify{ 
-        subject.should be_a(Renderer)
-        subject.execute(output).should == expected
-      }
-    end
-
-  end
-end