alf-core 0.15.0 → 0.16.0

data/spec/unit/alf-database/options/test_parser.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Database
-    describe Options, "parser" do
-
-      subject{ opts.parser }
-
-      let(:opts){ Options.new }
-
-      context 'by default' do
-
-        it { should be(Lang::Parser::Lispy) }
-      end
-
-      context 'when explicitely set' do
-        before{ opts.parser = Lang::Parser::Safer }
-
-        it{ should be(Lang::Parser::Safer) }
-      end
-
-    end
-  end
-end

data/spec/unit/alf-database/options/test_schema_cache.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Database
-    describe Options, "schema_cache?" do
-
-      subject{ opts.schema_cache? }
-
-      let(:opts){ Options.new }
-
-      context 'by default' do
-
-        it { should eq(true) }
-      end
-
-      context 'when explicitely set' do
-        before{ opts.schema_cache = false }
-
-        it{ should eq(false) }
-      end
-
-      context 'when explicitely set but coercion needed' do
-        before{ opts.schema_cache = "false" }
-
-        it{ should eq(false) }
-      end
-
-    end
-  end
-end

data/spec/unit/alf-database/options/test_viewpoint.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Database
-    describe Options, "viewpoint" do
-
-      subject{ opts.viewpoint }
-
-      let(:opts){ Options.new }
-
-      context 'by default' do
-
-        it { should be(Viewpoint::NATIVE) }
-      end
-
-      context 'when explicitely set' do
-        let(:mod){ Module.new{ include Alf::Viewpoint } }
-
-        before{ opts.viewpoint = mod }
-
-        it{ should be(mod) }
-      end
-
-    end
-  end
-end

data/spec/unit/alf-database/shared_examples/a_facade_on_database_options.rb

@@ -1,5 +0,0 @@
-shared_examples_for "a facade on database options" do
-
-  it{ should respond_to(:schema_cache?)     }
-
-end

data/spec/unit/alf-engine/cog/test_to_ascii_tree.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Cog, "to_cog" do
-
-      let(:cog){ Clip.new([], AttrList[:name], true) }
-
-      subject{ cog.to_ascii_tree }
-
-      it { should eq("Clip ..., [:name], {:allbut => true}\n+-- []\n") }
-
-    end
-  end
-end

data/spec/unit/alf-engine/cog/test_to_cog.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Cog, "to_cog" do
-
-      let(:cog){ Object.new.extend(Cog) }
-
-      subject{ cog.to_cog }
-
-      it { should be(cog) }
-
-    end
-  end
-end

data/spec/unit/alf-engine/compact/test_set.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Compact::Set do
-
-      it 'should work on an empty operand' do
-        Compact::Set.new([]).to_a.should eq([])
-      end
-
-      it 'should work when no duplicate is present' do
-        rel = [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        Compact::Set.new(rel).to_set.should eq(rel.to_set)
-      end
-
-      it 'should work when duplicates are present' do
-        rel = [
-          {:name => "Jones"},
-          {:name => "Smith"},
-          {:name => "Jones"},
-        ]
-        exp = [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        Compact::Set.new(rel).to_set.should eq(exp.to_set)
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/compact/test_uniq.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Compact::Uniq do
-
-      it 'should work on an empty operand' do
-        Compact::Uniq.new([]).to_a.should eq([])
-      end
-
-      it 'should work when no duplicate is present' do
-        rel = [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        Compact::Uniq.new(rel).to_a.should eq(rel)
-      end
-
-      it 'should work when duplicates are present' do
-        rel = [
-          {:name => "Jones"},
-          {:name => "Smith"},
-          {:name => "Jones"},
-        ]
-        exp = [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        Compact::Uniq.new(rel).to_a.should eq(exp)
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/group/test_hash.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Group::Hash do
-
-      let(:operand){[
-        {name: "Smith", city: "London"},
-        {name: "Jones", city: "Paris"},
-        {name: "Blake", city: "London"},
-      ]}
-
-      let(:expected){[
-        { city: "London", suppliers: Relation(name: ["Smith", "Blake"]) },
-        { city: "Paris",  suppliers: Relation(name: ["Jones"])          },
-      ].to_set}
-
-      it 'should group specified attributes' do
-        op = Group::Hash.new(operand, AttrList[:name], :suppliers, false)
-        op.to_set.should eq(expected)
-      end
-
-      it 'should allow specifying allbut grouping' do
-        op = Group::Hash.new(operand, AttrList[:city], :suppliers, true)
-        op.to_set.should eq(expected)
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/hierarchize/test_renamer.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Hierarchize, "renaming" do
-
-      let(:hierarchize){
-        Hierarchize.new([], AttrList[:id, :subid], AttrList[:parent, :subparent], :children)
-      }
-
-      subject{
-        hierarchize.send(:renamer)
-      }
-
-      it{ should eq(Renaming[parent: :id, subparent: :subid]) }
-
-    end
-  end
-end

data/spec/unit/alf-engine/infer_heading/test_heading.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe InferHeading, 'heading' do
-
-      let(:ih){ InferHeading.new([]) }
-
-      subject{ ih.send(:heading, tuple) }
-
-      context 'on a single tuple' do
-        let(:tuple){ {id: 1, name: "Jones"} }
-
-        it{ should eq(Heading.new(id: Fixnum, name: String)) }
-      end
-
-      context 'on a tuple with tuple-valued attribute' do
-        let(:tuple){ {id: 1, hobby: Tuple(name: "Programming")} }
-
-        it{ should eq(Heading.new(id: Fixnum, hobby: Tuple[name: String])) }
-      end
-
-      context 'on a tuple with relation-valued attribute' do
-        let(:tuple){ {id: 1, hobby: Relation(name: "Programming")} }
-
-        it{ should eq(Heading.new(id: Fixnum, hobby: Relation[name: String])) }
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/join/test_hash.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Join::Hash do
-
-      let(:suppliers) {[
-        {:sid => 'S1', :city => 'London'},
-        {:sid => 'S2', :city => 'Paris'},
-        {:sid => 'S3', :city => 'Paris'}
-      ]}
-
-      let(:statuses) {[
-        {:sid => 'S1', :status => 20},
-        {:sid => 'S2', :status => 10},
-        {:sid => 'S3', :status => 30}
-      ]}
-
-      let(:countries) {[
-        {:city => 'London',    :country => 'England'},
-        {:city => 'Paris',     :country => 'France'},
-        {:city => 'Bruxelles', :country => 'Belgium'}
-      ]}
-
-      context "when applied on candidate keys on both sides" do
-        subject{ Join::Hash.new(suppliers, statuses).to_a }
-        let(:expected){[
-          {:sid => 'S1', :city => 'London', :status => 20},
-          {:sid => 'S2', :city => 'Paris', :status => 10},
-          {:sid => 'S3', :city => 'Paris', :status => 30}
-        ]}
-        it { should == expected }
-      end
-
-      context "when applied on a typical foreign key" do
-        subject{ Join::Hash.new(suppliers, countries).to_a }
-        let(:expected){[
-          {:sid => 'S1', :city => 'London', :country => 'England'},
-          {:sid => 'S2', :city => 'Paris',  :country => 'France'},
-          {:sid => 'S3', :city => 'Paris',  :country => 'France'}
-        ]}
-        it { should == expected }
-      end
-
-      context "when applied with no attributes in common" do
-        subject{ Join::Hash.new(statuses, countries).to_a }
-        let(:expected){
-          statuses.collect{|s| countries.collect{|c| c.merge(s)}}.flatten
-        }
-        it { should == expected }
-      end
-
-    end
-  end # module Engine
-end # module Alf    
-

data/spec/unit/alf-engine/materialize/test_array.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Materialize::Array do
-
-      let(:operand){[
-        {:name => "Smith",  :city => "London"},
-        {:name => "Jones",  :city => "Paris"},
-        {:name => "Blake",  :city => "Athens"},
-      ]}
-
-      it 'should act as a normal cog' do
-        op = Materialize::Array.new(operand)
-        op.to_a.should eq(operand)
-      end
-
-      it 'should allow specifying an ordering' do
-        op = Materialize::Array.new(operand, Ordering[[:name, :desc]])
-        op.to_a.should eq([
-          {:name => "Smith",  :city => "London"},
-          {:name => "Jones",  :city => "Paris"},
-          {:name => "Blake",  :city => "Athens"},
-        ])
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/materialize/test_hash.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Materialize::Hash do
-
-      let(:operand){[
-        {:name => "Smith", :city => "London"},
-        {:name => "Jones", :city => "Paris"},
-        {:name => "Smith", :city => "Athens"},
-      ]}
-
-      it 'should act as a normal cog' do
-        op = Materialize::Hash.new(operand, AttrList[:name])
-        op.to_set.should eq(operand.to_set)
-      end
-
-      it 'should allow allbut hashing' do
-        op = Materialize::Hash.new(operand, AttrList[:city], true)
-        op.to_set.should eq(operand.to_set)
-      end
-
-      it 'should allow lazy projection attributes' do
-        op = Materialize::Hash.new(operand, lambda{|tuple| 
-          tuple.should eq({:name => "Smith", :city => "London"})
-          AttrList[:name]
-         })
-        op.to_set.should eq(operand.to_set)
-      end
-
-      it 'should have a each_pair method' do
-        op = Materialize::Hash.new(operand, AttrList[:name])
-        seen = []
-        op.each_pair do |k,v|
-          seen << [k,v]
-        end
-        seen.to_set.should eq([
-          [{:name => "Smith"}, operand.select{|t| t[:name] == "Smith"}],
-          [{:name => "Jones"}, operand.select{|t| t[:name] == "Jones"}]
-        ].to_set)
-      end
-
-      describe "the indexed access" do
-
-        it 'should return the expected tuples' do
-          op = Materialize::Hash.new(operand, AttrList[:name])
-          op[{:name => "Jones"}].to_a.should eq([
-            {:name => "Jones", :city => "Paris"},
-          ])
-          op[{:name => "Smith"}].to_a.should eq([
-            {:name => "Smith", :city => "London"},
-            {:name => "Smith", :city => "Athens"},
-          ])
-          op[{:name => "NoSuchOne"}].to_a.should eq([])
-        end
-
-        it 'should allow late projection' do
-          op = Materialize::Hash.new(operand, AttrList[:name])
-          op[{:name => "Smith", :city => "London"}, true].to_a.should eq([
-            {:name => "Smith", :city => "London"},
-            {:name => "Smith", :city => "Athens"},
-          ])
-        end
-
-        it 'late projection should work with allbut indexing' do
-          op = Materialize::Hash.new(operand, AttrList[:city], true)
-          op[{:name => "Smith", :city => "London"}, true].to_a.should eq([
-            {:name => "Smith", :city => "London"},
-            {:name => "Smith", :city => "Athens"},
-          ])
-        end
-
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/quota/test_cesure.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Quota::Cesure do
-
-      let(:input) {[
-        {:a => "via_method", :time => 1},
-        {:a => "via_method", :time => 2},
-        {:a => "via_method", :time => 3},
-        {:a => "via_reader", :time => 2},
-        {:a => "via_reader", :time => 4},
-      ]}
-
-      let(:expected) {[
-        {:a => "via_method", :time => 1, :time_sum => 1, :time_max => 1},
-        {:a => "via_method", :time => 2, :time_sum => 3, :time_max => 2},
-        {:a => "via_method", :time => 3, :time_sum => 6, :time_max => 3},
-        {:a => "via_reader", :time => 2, :time_sum => 2, :time_max => 2},
-        {:a => "via_reader", :time => 4, :time_sum => 6, :time_max => 4},
-      ]}
-
-      it 'should compute as expected' do
-        sums = Summarization[
-          :time_sum => Aggregator.sum{ time },
-          :time_max => Aggregator.max{ time }
-        ]
-        by = AttrList[:a]
-        op = Engine::Quota::Cesure.new(Leaf.new(input), by, sums)
-        op.to_a.should eq(expected)
-      end
-
-    end
-  end
-end