alf 0.12.2 → 0.13.0

data/spec/unit/alf-engine/test_clip.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Clip do
-
-      it 'should work on an empty operand' do
-        Clip.new([], AttrList[:name], true).to_a.should eq([])
-        Clip.new([], AttrList[:name], false).to_a.should eq([])
-      end
-
-      let(:operand){[
-          {:name => "Jones", :city => "London"},
-          {:name => "Smith", :city => "Paris"}
-      ]}
-
-      it 'should work on a non empty operand' do
-        exp = [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        Clip.new(operand, AttrList[:name], false).to_a.should eq(exp)
-      end
-
-      it 'should allow allbut clipping' do
-        exp = [
-          {:city => "London"},
-          {:city => "Paris"}
-        ]
-        Clip.new(operand, AttrList[:name], true).to_a.should eq(exp)
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/test_coerce.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Coerce do
-
-      it 'should work on an empty operand' do
-        Coerce.new([], Heading[:price => Float]).to_a.should eq([])
-      end
-
-      let(:operand){[
-          {:name => "Jones", :price => "12.0"},
-          {:name => "Smith", :price => "-10.0"}
-      ]}
-
-      it 'should work on a non empty operand' do
-        exp = [
-          {:name => "Jones", :price => 12.0},
-          {:name => "Smith", :price => -10.0}
-        ]
-        heading = Heading[:name => String, :price => Float]
-        Coerce.new(operand, heading).to_a.should eq(exp)
-      end
-
-      it 'should not project on the heading' do
-        exp = [
-          {:name => "Jones", :price => 12.0},
-          {:name => "Smith", :price => -10.0}
-        ]
-        heading = Heading[:price => Float]
-        Coerce.new(operand, heading).to_a.should eq(exp)
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/test_compact.rb

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

data/spec/unit/alf-engine/test_concat.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Concat do
-
-      it 'should work on no operand at all' do
-        Concat.new([]).to_a.should eq([])
-      end
-
-      it 'should work with only one operand' do
-        rel = [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        Concat.new([rel]).to_a.should eq(rel)
-      end
-
-      it 'should work with multiple operands' do
-        rel = [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        rel2 = [
-          {:name => "Jones"},
-          {:name => "Clark"}
-        ]
-        exp = [
-          {:name => "Jones"},
-          {:name => "Smith"},
-          {:name => "Jones"},
-          {:name => "Clark"}
-        ]
-        Concat.new([rel, rel2]).to_a.should eq(exp)
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/test_defaults.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Defaults do
-
-      it 'should work on an empty operand' do
-        Defaults.new([], TupleComputation[:id => 1]).to_a.should eq([])
-      end
-
-      it 'should replace nil by the default value' do
-        rel = [
-          {:name => "Jones"},
-          {:name => nil}
-        ]
-        exp = [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        Defaults.new(rel, TupleComputation[:name => "Smith"]).to_a.should eq(exp)
-      end
-
-      it 'should add missing attributes and allow computations' do
-        rel = [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        exp = [
-          {:name => "Jones", :up => "JONES"},
-          {:name => "Smith", :up => "SMITH"}
-        ]
-        defs = TupleComputation[:up => lambda{ name.upcase }]
-        Defaults.new(rel, defs).to_a.should eq(exp)
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/test_filter.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Filter do
-
-      it 'should work on an empty operand' do
-        Filter.new([], TuplePredicate[true]).to_a.should eq([])
-      end
-
-      it 'should filter according to the predicate' do
-        rel = [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        exp = [
-          {:name => "Jones"},
-        ]
-        Filter.new(rel, TuplePredicate["name =~ /^J/"]).to_a.should eq(exp)
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/test_generator.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Generator do
-
-      it 'should generate tuples from 0' do
-        exp = [
-          {:id => 0},
-          {:id => 1}
-        ]
-        Generator.new(:id, 0, 1, 2).to_a.should eq(exp)
-      end
-
-      it 'should allow specifying an offset, step and count' do
-        exp = [
-          {:id => 10},
-          {:id => 15},
-          {:id => 20}
-        ]
-        Generator.new(:id, 10, 5, 3).to_a.should eq(exp)
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/test_rename.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Rename do
-
-      it 'should work on an empty operand' do
-        Rename.new([], Renaming[{}]).to_a.should eq([])
-      end
-
-      it 'should work on a non empty operand' do
-        rel = [
-          {:name => "Jones", :city => "London"},
-          {:name => "Smith", :city => "Paris"}
-        ]
-        exp = [
-          {:last_name => "Jones", :city => "London"},
-          {:last_name => "Smith", :city => "Paris"}
-        ]
-        Rename.new(rel, Renaming[:name => :last_name]).to_a.should eq(exp)
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/test_set_attr.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe SetAttr do
-
-      it 'should work on an empty operand' do
-        SetAttr.new([], TupleComputation[{}]).to_a.should eq([])
-      end
-
-      it 'should allow implementing UPDATE' do
-        rel = [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        exp = [
-          {:name => "JONES"},
-          {:name => "SMITH"}
-        ]
-        comp = TupleComputation[:name => lambda{ name.upcase }]
-        SetAttr.new(rel, comp).to_a.should eq(exp)
-      end
-
-      it 'should allow implementing EXTEND' do
-        rel = [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        exp = [
-          {:name => "Jones", :up => "JONES"},
-          {:name => "Smith", :up => "SMITH"}
-        ]
-        comp = TupleComputation[:up => lambda{ name.upcase }]
-        SetAttr.new(rel, comp).to_a.should eq(exp)
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/test_sort.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Sort do
-
-      it 'should work on an empty operand' do
-        Sort.new([], Ordering[[]]).to_a.should eq([])
-      end
-
-      it 'should work with ascending' do
-        rel = [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        Sort.new(rel, Ordering[[:name, :asc]]).to_a.should eq(rel)
-      end
-
-      it 'should work with descending' do
-        rel = [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        exp = [
-          {:name => "Smith"},
-          {:name => "Jones"}
-        ]
-        Sort.new(rel, Ordering[[:name, :desc]]).to_a.should eq(exp)
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/test_ungroup.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Ungroup do
-
-      let(:input){[
-        {:city => "London", :suppliers => [
-                              {:name => "Smith"},
-                              {:name => "Blake"}
-                            ]},
-        {:city => "Paris", :suppliers => [
-                              {:name => "Jones"}
-                            ]},
-      ]}
-
-      let(:expected){[
-        {:name => "Smith", :city => "London"},
-        {:name => "Blake", :city => "London"},
-        {:name => "Jones", :city => "Paris"},
-      ]}
-
-      it 'should ungroup specified attribute' do
-        Ungroup.new(input, :suppliers).to_a.should eq(expected)
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/test_unwrap.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Unwrap do
-
-      let(:input) {[
-        {:wrapped => {:a => "a", :b => "b"}, :c => "c"}
-      ]}
-
-      let(:expected) {[
-        {:a => "a", :b => "b", :c => "c"},
-      ]}
-
-      it "should unwrap as expected" do
-        Unwrap.new(input, :wrapped).to_a.should eq(expected)
-      end
-
-    end
-  end
-end

data/spec/unit/alf-engine/test_wrap.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Wrap do
-
-      let(:input) {[
-        {:a => "a", :b => "b", :c => "c"},
-      ]}
-
-      let(:expected) {[
-        {:wrapped => {:a => "a", :b => "b"}, :c => "c"}
-      ]}
-
-      it "should wrap as expected" do
-        wrap = Wrap.new(input, AttrList[:a, :b], :wrapped, false)
-        wrap.to_a.should eq(expected)
-      end
-
-      it "should support allbut wrapping" do
-        wrap = Wrap.new(input, AttrList[:c], :wrapped, true)
-        wrap.to_a.should eq(expected)
-      end
-
-    end
-  end
-end

data/spec/unit/alf-logs/apache_combined.log

@@ -1,5 +0,0 @@
-125.76.230.10 - - [02/Sep/2009:03:33:46 +0200] "GET /cart/install.txt HTTP/1.1" 404 214 "-" "Toata dragostea mea pentru diavola"
-125.76.230.10 - - [02/Sep/2009:03:33:47 +0200] "GET /store/install.txt HTTP/1.1" 404 215 "-" "Toata dragostea mea pentru diavola"
-10.0.1.1 - - [02/Sep/2009:05:08:33 +0200] "GET / HTTP/1.1" 200 30 "-" "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_8; en-us) AppleWebKit/531.9 (KHTML, like Gecko) Version/4.0.3 Safari/531.9"
-10.0.1.1 - - [02/Sep/2009:06:41:51 +0200] "GET / HTTP/1.1" 200 30 "-" "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_8; en-us) AppleWebKit/531.9 (KHTML, like Gecko) Version/4.0.3 Safari/531.9"
-69.41.0.45 - - [02/Sep/2009:12:02:40 +0200] "GET //phpMyAdmin/ HTTP/1.1" 404 209 "-" "Mozilla/4.0 (compatible; MSIE 6.0; Windows 98)"

data/spec/unit/alf-logs/postgresql.log

@@ -1,29 +0,0 @@
-2010-10-10 13:50:24 GMT [38626]: [1-1] LOG:  00000: database system was shut down at 2010-10-10 13:49:33 GMT
-2010-10-10 13:50:24 GMT [38626]: [2-1] LOCATION:  StartupXLOG, xlog.c:4816
-2010-10-10 13:50:24 GMT [38624]: [1-1] LOG:  00000: database system is ready to accept connections
-2010-10-10 13:50:24 GMT [38624]: [2-1] LOCATION:  reaper, postmaster.c:2156
-2010-10-10 13:50:24 GMT [38629]: [1-1] LOG:  00000: autovacuum launcher started
-2010-10-10 13:50:24 GMT [38629]: [2-1] LOCATION:  AutoVacLauncherMain, autovacuum.c:520
-2010-10-10 13:52:04 GMT [38747]: [1-1] LOG:  00000: connection received: host=127.0.0.1 port=60020
-2010-10-10 13:52:04 GMT [38747]: [2-1] LOCATION:  BackendInitialize, postmaster.c:3027
-2010-10-10 13:52:04 GMT [38747]: [3-1] LOG:  00000: connection authorized: user=root database=demonstration
-2010-10-10 13:52:04 GMT [38747]: [4-1] LOCATION:  BackendInitialize, postmaster.c:3097
-2010-10-10 13:52:04 GMT [38747]: [5-1] LOG:  00000: duration: 0.329 ms  statement: SHOW clients
-2010-10-10 13:52:05 GMT [38747]: [21-1] LOG:  00000: duration: 0.973 ms  statement:           SELECT tablename
-	            FROM pg_tables
-	           WHERE schemaname IN (E'"$user"',E'public')
-2010-10-10 13:52:07 GMT [38747]: [33-1] LOG:  00000: duration: 0.710 ms  statement: SELECT * FROM "delayed_jobs" 
-2010-10-10 13:52:08 GMT [38747]: [33-1] LOG:  00000: duration: 0.710 ms  statement: SELECT * FROM "delayed_jobs" 
-2010-10-10 15:00:02 GMT [38747]: [1667-1] LOG:  00000: duration: 0.024 ms  statement: BEGIN
-2010-10-10 15:00:02 GMT [38747]: [1668-1] LOCATION:  exec_simple_query, postgres.c:1081
-2010-10-10 15:00:02 GMT [38747]: [1669-1] LOG:  00000: duration: 0.195 ms  statement: INSERT INTO "delayed_jobs" ("failed_at", "locked_by", "created_at", "handler", "updated_at", "priority", "run_at", "attempts", "locked_at", "last_error") VALUES(NULL, NULL, '2010-10-10 15:00:02.159884', E'--- !ruby/object:RuntheChooChootrain {}
-	
-	', '2010-10-10 15:00:02.159884', 0, '2010-10-10 16:00:00.000000', 0, NULL, NULL) RETURNING "id"
-2010-10-10 15:00:02 GMT [38747]: [1670-1] LOCATION:  exec_simple_query, postgres.c:1081
-2010-10-10 15:00:02 GMT [38747]: [1671-1] LOG:  00000: duration: 0.065 ms  statement: COMMIT
-2010-10-10 15:00:02 GMT [38747]: [1672-1] LOCATION:  exec_simple_query, postgres.c:1081
-2010-10-10 15:00:02 GMT [38747]: [1673-1] LOG:  00000: duration: 0.020 ms  statement: BEGIN
-2010-10-10 15:00:02 GMT [38747]: [1674-1] LOCATION:  exec_simple_query, postgres.c:1081
-2010-10-10 15:00:02 GMT [38747]: [1675-1] LOG:  00000: duration: 0.157 ms  statement: DELETE FROM "delayed_jobs" WHERE "id" = 123456
-2010-10-10 15:00:02 GMT [38747]: [1676-1] LOCATION:  exec_simple_query, postgres.c:1081
-2010-10-10 15:00:02 GMT [38747]: [1677-1] LOG:  00000: duration: 0.050 ms  statement: COMMIT