alf 0.12.2 → 0.13.0

data/spec/unit/alf-core/operator/relational/test_extend.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Operator::Relational
-    describe Extend do
-
-      let(:operator_class){ Extend }
-      it_should_behave_like("An operator class")
-
-      let(:input) {[
-        {:tested => 1,  :other => "b"},
-        {:tested => 30, :other => "a"},
-      ]}
-
-      let(:expected){[
-        {:tested => 1,  :other => "b", :big => false},
-        {:tested => 30, :other => "a", :big => true},
-      ]}
-
-      subject{ operator.to_a }
-
-      context "with Lispy" do 
-        let(:operator){ Lispy.extend(input, :big => lambda{ tested > 10 }) }
-        it{ should == expected }
-      end
-
-    end 
-  end
-end

data/spec/unit/alf-core/operator/relational/test_group.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Operator::Relational
-    describe Group do
-
-      let(:operator_class){ Group }
-      it_should_behave_like("An operator class")
-
-      let(:input) {[
-        {:a => "via_method", :time => 1, :b => "b"},
-        {:a => "via_method", :time => 2, :b => "b"},
-        {:a => "via_reader", :time => 3, :b => "b"},
-      ]}
-
-      let(:expected) {[
-        {:a => "via_method", :as => Alf::Relation[{:time => 1, :b => "b"}, 
-                                                  {:time => 2, :b => "b"}]},
-        {:a => "via_reader", :as => Alf::Relation[{:time => 3, :b => "b"}]},
-      ]}
-
-      subject{ operator.to_a.sort{|k1,k2| k1[:a] <=> k2[:a]} }
-
-      context "--no-allbut" do
-        context "with Lispy" do
-          let(:operator){ Lispy.group(input, [:time, :b], :as) }
-          it { should == expected }
-        end
-      end # --no-allbut
-  
-      context "--allbut" do
-        context "with Lispy" do
-          let(:operator){ Lispy.group(input, [:a], :as, :allbut => true) }
-          it { should == expected }
-        end
-      end # --allbut
-
-    end 
-  end
-end

data/spec/unit/alf-core/operator/relational/test_heading.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Operator::Relational
-    describe Heading do
-
-      let(:operator_class){ Heading }
-      it_should_behave_like("An operator class")
-
-      let(:input) {[
-        {:tested => 1,    :other => "b"},
-        {:tested => 10.0, :other => "a"},
-      ]}
-
-      let(:expected){[
-        {:tested => Numeric, :other => String},
-      ]}
-
-      subject{ operator.to_a }
-
-      context "with Lispy" do 
-        let(:operator){ Lispy.heading(input) }
-        it{ should == expected }
-      end
-
-    end 
-  end
-end

data/spec/unit/alf-core/operator/relational/test_intersect.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Operator::Relational
-    describe Intersect do
-
-      let(:operator_class){ Intersect }
-      it_should_behave_like("An operator class")
-
-      let(:left) {[
-        {:sid => 'S1', :city => 'London'},
-        {:sid => 'S2', :city => 'Paris'},
-        {:sid => 'S3', :city => 'Paris'}
-      ]}
-
-      let(:right) {[
-        {:sid => 'S2', :city => 'Paris'},
-        {:sid => 'S1', :city => 'London'},
-      ]}
-
-      let(:disjoint) {[
-        {:sid => 'S4', :city => 'Oslo'},
-        {:sid => 'S5', :city => 'Bruxelles'},
-      ]}
-
-      let(:operator){ Lispy.intersect(*args) }
-      subject{ operator.to_a }
-
-      context "with same operand twice" do
-        let(:args){ [left, left] }
-        it { should eq(left) }
-      end
-
-      context "on operands sharing tuples" do
-        let(:args){ [left, right] }
-        let(:expected) {[
-          {:sid => 'S1', :city => 'London'},
-          {:sid => 'S2', :city => 'Paris'},
-        ]}
-        it { should eq(expected) }
-      end
-
-      context "on disjoint operands" do
-        let(:args){ [left, disjoint] }
-        it { should be_empty }
-      end
-
-      context "with Lispy" do
-        let(:operator){ Lispy.intersect(left, right) }
-        let(:expected) {[
-          {:sid => 'S1', :city => 'London'},
-          {:sid => 'S2', :city => 'Paris'},
-        ]}
-        it { should == expected }
-      end
-
-    end
-  end
-end

data/spec/unit/alf-core/operator/relational/test_join.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Operator::Relational
-    describe Join do
-
-      let(:suppliers){Relation.coerce [
-        {:sid => 'S1', :city => 'London'},
-        {:sid => 'S2', :city => 'Paris'},
-        {:sid => 'S3', :city => 'Paris'},
-        {:sid => 'S4', :city => 'London'},
-        {:sid => 'S5', :city => 'Athens'},
-      ]}
-
-      context "when applied to sub-relations" do
-        let(:suppliers_by_city){Relation.coerce( 
-          Lispy.group(suppliers, [:sid], :suppliers)
-        )}
-        let(:s2_s3){Relation.coerce([
-          {:sid => 'S3'},
-          {:sid => 'S2'}
-        ])} 
-        let(:right){Relation.coerce([
-          {:suppliers => s2_s3, :hello => "world"}
-        ])}
-        let(:expected){Relation.coerce([
-          {:suppliers => s2_s3, :hello => "world", :city => 'Paris'}
-        ])}
-        subject{Relation.coerce(
-          Lispy.join(suppliers_by_city, right)
-        )}
-        it{ should eq(expected) }
-      end
-
-    end
-  end
-end

data/spec/unit/alf-core/operator/relational/test_minus.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Operator::Relational
-    describe Minus do
-
-      let(:operator_class){ Minus }
-      it_should_behave_like("An operator class")
-
-      let(:left) {[
-        {:sid => 'S1', :city => 'London'},
-        {:sid => 'S2', :city => 'Paris'},
-        {:sid => 'S3', :city => 'Paris'}
-      ]}
-
-      let(:right) {[
-        {:sid => 'S2', :city => 'Paris'},
-        {:sid => 'S1', :city => 'London'},
-      ]}
-
-      let(:disjoint) {[
-        {:sid => 'S4', :city => 'Oslo'},
-        {:sid => 'S5', :city => 'Bruxelles'},
-      ]}
-
-      let(:operator){ Lispy.minus(*args) }
-      subject{ operator.to_a }
-
-      context "when applied on the same operand twice" do
-        let(:args){ [left, left] }
-        it { should be_empty }
-      end
-
-      context "when applied on operands sharing tuples" do
-        let(:args){ [left, right] }
-        let(:expected) {[
-          {:sid => 'S3', :city => 'Paris'}
-        ]}
-        it { should eq(expected) }
-      end
-
-      context "when applied on disjoint operands" do
-        let(:args){ [left, disjoint] }
-        it { should eq(left) }
-      end
-
-      context "when factored with Lispy" do
-        let(:operator){ Lispy.minus(left, right) }
-        let(:expected) {[
-          {:sid => 'S3', :city => 'Paris'}
-        ]}
-        it { should eq(expected) }
-      end
-
-    end
-  end
-end

data/spec/unit/alf-core/operator/relational/test_project.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Operator::Relational
-    describe Project do
-
-      let(:operator_class){ Project }
-      it_should_behave_like("An operator class")
-
-      let(:input) {[
-        {:a => "a", :b => "b"},
-        {:a => "a", :b => "b"},
-      ]}
-
-      subject{ operator.to_a }
-
-      context "--no-allbut" do
-        let(:expected){[{:a => "a"}]}
-
-        context "with Lispy" do
-          let(:operator){ Lispy.project(input, [:a]) }
-          it { should eq(expected) } 
-        end
-      end # --no-allbut
-
-      context "--allbut" do
-        let(:expected){[{:b => "b"}]}
-
-        context "and factored with Lispy#project" do
-          let(:operator){ Lispy.project(input, [:a], :allbut => true) }
-          it { should eq(expected) } 
-        end
-
-        context "and factored with Lispy#allbut" do
-          let(:operator){ Lispy.allbut(input, [:a]) }
-          it { should eq(expected) } 
-        end
-
-      end # --allbut
-
-      context "when all is projected" do
-        let(:expected){[{}]}
-
-        context "with empty attributes" do
-          let(:operator){ Lispy.project(input, []) }
-          it { should eq(expected) } 
-        end
-
-        context "when empty attributes and input" do
-          let(:operator){ Lispy.project([], []) }
-          it { should == [] } 
-        end
-
-        context "--allbut" do
-          let(:operator){ Lispy.project(input, [:a, :b], :allbut => true) }
-          it { should eq(expected) } 
-        end
-
-      end # all attributes projected
-
-    end 
-  end
-end

data/spec/unit/alf-core/operator/relational/test_quota.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Operator::Relational
-    describe Quota do
-
-      let(:operator_class){ Quota }
-      it_should_behave_like("An operator class")
-
-      let(:input) {[
-        {:a => "via_method", :time => 1},
-        {:a => "via_method", :time => 2},
-        {:a => "via_method", :time => 3},
-        {:a => "via_reader", :time => 4},
-        {:a => "via_reader", :time => 2},
-      ]}
-
-      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},
-      ]}
-
-      subject{ operator.to_a }
-
-      context "with Lispy" do
-        let(:aggs){{:time_sum => Aggregator.sum{ time },
-                    :time_max => Aggregator.max{ time }}} 
-        let(:operator){ Lispy.quota(input, [:a], [:time], aggs) }
-        it { should == expected }
-      end
-
-    end
-  end
-end

data/spec/unit/alf-core/operator/relational/test_rank.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Operator::Relational
-    describe Rank do
-
-      let(:operator_class){ Rank }
-      it_should_behave_like("An operator class")
-
-      let(:input) {[
-        {: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 }
-
-      context "with partial ordering" 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){ Lispy.rank(input, [:weight]) }
-        it{ should eq(expected) }
-      end # partial ordering
-
-      describe "with total ordering" do
-        let(:expected) {Alf::Relation[
-          {:pid => 'P1', :weight => 12.0, :newname => 0},
-          {:pid => 'P5', :weight => 12.0, :newname => 1},
-          {:pid => 'P4', :weight => 14.0, :newname => 2},
-          {:pid => 'P2', :weight => 17.0, :newname => 3},
-          {:pid => 'P3', :weight => 17.0, :newname => 4},
-          {:pid => 'P6', :weight => 19.0, :newname => 5}
-        ]}
-        let(:operator){ Lispy.rank(input, [:weight, :pid], :newname) }
-        it{ should eq(expected) }
-      end # total ordering
-
-    end
-  end
-end

data/spec/unit/alf-core/operator/relational/test_rename.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Operator::Relational
-    describe Rename do
-
-      let(:operator_class){ Rename }
-      it_should_behave_like("An operator class")
-
-      let(:input) {[
-        {:a => "a", :b => "b"},
-      ]}
-
-      let(:expected){[
-        {:z => "a", :b => "b"},
-      ]}
-
-      subject{ operator.to_a }
-
-      context "with Lispy" do 
-        let(:operator){ Lispy.rename(input, {:a => :z}) }
-        it{ should == expected }
-      end
-
-    end 
-  end
-end

data/spec/unit/alf-core/operator/relational/test_restrict.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Operator::Relational
-    describe Restrict do
-
-      let(:operator_class){ Restrict }
-      it_should_behave_like("An operator class")
-
-      let(:input) {[
-        {:tested => 1, :other => "b"},
-        {:tested => 30, :other => "a"},
-      ]}
-
-      let(:expected){[
-        {:tested => 1, :other => "b"}
-      ]}
-
-      subject{ operator.to_a }
-
-      context "with no argument" do
-        let(:operator){ Lispy.restrict(input) }
-        it { should eq(input) }
-      end
-
-      context "with a string" do
-        context "with Lispy" do
-          let(:operator){ Lispy.restrict(input, "tested < 10") }
-          it { should eq(expected) }
-        end
-      end
-
-      context "with arguments" do
-        context "with Lispy and Proc" do
-          let(:operator){ Lispy.restrict(input, lambda{ tested < 10 }) }
-          it { should eq(expected) }
-        end
-        context "with Lispy and array" do
-          let(:operator){ Lispy.restrict(input, [:tested, 1]) }
-          it { should eq(expected) }
-        end
-      end
-
-    end 
-  end
-end