alf 0.10.1 → 0.11.0

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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,26 @@
+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/{logs → alf-logs}/test_reader.rb

@@ -3,56 +3,55 @@ module Alf
   shared_examples_for "A valid Logs::Reader instance" do
 
     specify{ reader.should be_a(::Alf::Logs::Reader) }
-    
+
     it "should yield a pseudo-relation" do
       reader.all?{|tuple| tuple.is_a?(Hash)}.should be_true
     end
-    
+
   end
   describe Logs::Reader do
-    
+
     let(:input){ _("apache_combined.log", __FILE__) }
-    
+
     describe "when called on a reader directly" do
       let(:reader){
         ::Alf::Logs::Reader.new(input)
       }
       it_should_behave_like "A valid Logs::Reader instance"
     end
-    
+
     describe "when called through registered one" do
       let(:reader){
         ::Alf::Reader.reader(input)
       }
       it_should_behave_like "A valid Logs::Reader instance"
     end
-    
+
     describe "when called through factory method" do
       let(:reader){
         ::Alf::Reader.logs(input)
       }
       it_should_behave_like "A valid Logs::Reader instance"
     end
-    
+
     describe "the auto-detect feature" do
-      let(:reader){ ::Alf::Logs::Reader.new(nil,nil,:file_format => nil) }
+      let(:reader){ ::Alf::Logs::Reader.new(file,nil,:file_format => nil) }
       let(:relation){ reader.to_rel }
-      
-      describe "on postgresql.log" do
+
+      context "on postgresql.log" do
         pending("postgresql log format seems broken") {
-          before{ reader.pipe(_("postgresql.log", __FILE__)) }
+          let(:file){ _("postgresql.log", __FILE__) }
           it_should_behave_like "A valid Logs::Reader instance"
           specify{ relation.should_not be_empty }
         }
       end
-      
-      describe "on apache_combined.log" do
-        before{ reader.pipe(_("apache_combined.log", __FILE__)) }
+
+      context "on apache_combined.log" do
+        let(:file){ _("apache_combined.log", __FILE__) }
         it_should_behave_like "A valid Logs::Reader instance"
         specify{ relation.should_not be_empty }
       end
-        
-    end
+    end # auto-detect
 
   end
 end

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

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require 'fileutils'
+require "sequel"
+module Alf
+  describe Sequel::Environment do
+    
+    let(:rel) {Alf::Relation[
+      {:sid => 'S1', :name => 'Smith', :status => 20, :city => 'London'},
+      {:sid => 'S2', :name => 'Jones', :status => 10, :city => 'Paris'},
+      {:sid => 'S3', :name => 'Blake', :status => 30, :city => 'Paris'},
+      {:sid => 'S4', :name => 'Clark', :status => 20, :city => 'London'},
+      {:sid => 'S5', :name => 'Adams', :status => 30, :city => 'Athens'}
+    ]}
+
+    let(:file){ _("alf.db", __FILE__) }
+
+    before(:all){
+      unless File.exists?(file) 
+        FileUtils.rm_rf file
+        db = ::Sequel.connect(uri)
+        db.create_table(:suppliers){
+          primary_key :sid
+          String  :sid
+          String  :name
+          Integer :status
+          String  :city
+        }
+        rel.each{|tuple| db[:suppliers].insert(tuple)}
+      end
+    }
+
+    describe "recognizes?" do
+
+      it "should recognize sqlite files" do
+        Sequel::Environment.recognizes?([file]).should be_true
+      end
+
+      it "should recognize database uris" do
+        Sequel::Environment.recognizes?(["postgres://localhost/database"]).should be_true
+        Sequel::Environment.recognizes?(["sqlite://#{file}"]).should be_true
+      end
+
+      it "should not be too permissive" do
+        Sequel::Environment.recognizes?(["nosuchone.db"]).should be_false
+        Sequel::Environment.recognizes?([nil]).should be_false
+      end
+
+    end # recognizes?
+
+    it "should let Environment autodetect sqlite files" do
+      Environment.autodetect(file).should be_a(Sequel::Environment)
+    end
+
+    describe "dataset" do
+
+      let(:env) { Sequel::Environment.new(file) }
+
+      it "should serve iterators" do
+        env.dataset(:suppliers).should be_a(Alf::Iterator)
+      end
+
+      it "should be the correct relation" do
+        env.dataset(:suppliers).to_rel.should eq(rel)
+      end
+
+    end # dataset
+
+  end
+end

data/spec/unit/{command → alf-shell}/doc_manager/test_call.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 module Alf
-  module Command
+  module Shell
     describe DocManager, ".call" do
 
       let(:dm){ @dm ||= DocManager.new }
-      let(:cmd){ Alf::Command::Show }
+      let(:cmd){ Alf::Shell::Show }
       subject{ 
         dm.call(cmd, opts) 
       }
@@ -43,7 +43,6 @@ module Alf
 
       end
 
-
     end
   end
 end

data/spec/unit/alf-shell/main/test_class_methods.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+module Alf
+  module Shell
+    describe Main::ClassMethods do
+
+      specify "relational_operators" do
+        Shell::Main.relational_operators.should_not be_empty
+        Shell::Main.relational_operators.each do |cmd|
+          cmd.should_not be_command
+          cmd.should be_operator
+          cmd.should respond_to(:run)
+        end
+      end
+
+      specify "experimental_operators" do
+        Shell::Main.experimental_operators.should_not be_empty
+        Shell::Main.experimental_operators.each do |cmd|
+          cmd.should_not be_command
+          cmd.should be_operator
+          cmd.should respond_to(:run)
+        end
+      end
+
+      specify "non_relational_operators" do
+        Shell::Main.non_relational_operators.should_not be_empty
+        Shell::Main.non_relational_operators.each do |cmd|
+          cmd.should_not be_command
+          cmd.should be_operator
+          cmd.should respond_to(:run)
+        end
+      end
+
+      specify "other_non_relational_commands" do
+        Shell::Main.other_non_relational_commands.should_not be_empty
+        Shell::Main.other_non_relational_commands.each do |cmd|
+          cmd.should be_command
+          cmd.should_not be_operator
+          cmd.should respond_to(:run)
+        end
+      end
+        
+    end # Main::ClassMethods
+  end # module Shell
+end # module Alf

data/spec/unit/alf-shell/operator/test_autonum.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module Alf::Shell::Operator
+  describe Autonum do
+
+    let(:input){ [] }
+    subject{ Autonum.run(argv) }
+
+    before do
+      subject.should be_a(Alf::Operator::NonRelational::Autonum)
+      subject.operands.should eq([input])
+    end
+
+    context "with default attribute name" do
+      let(:argv){ [input] }
+      specify{
+        subject.as.should eq(:autonum)
+      }
+    end
+
+    context "with explicit attribute name" do
+      let(:argv){ [input, "--", "unique"] }
+      specify{
+        subject.as.should eq(:unique)
+      }
+    end
+
+  end
+end

data/spec/unit/alf-shell/operator/test_clip.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+module Alf::Shell::Operator
+  describe Clip do
+
+    let(:input){ [] }
+    subject{ Clip.run(argv) }
+
+    before do
+      subject.should be_a(Alf::Operator::NonRelational::Clip)
+      subject.attributes.should eq(Alf::AttrList[:a, :b])
+      subject.operands.should eq([input])
+    end
+
+    context "--no-allbut" do
+      let(:argv){ [input, "--", "a", "b"] }
+      specify{
+        subject.allbut.should be_false
+      }
+    end
+
+    context "--allbut" do
+      let(:argv){ [input, "--allbut", "--", "a", "b"] }
+      specify{
+        subject.allbut.should be_true
+      }
+    end
+
+  end
+end

data/spec/unit/alf-shell/operator/test_coerce.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+module Alf::Shell::Operator
+  describe Coerce do
+
+    let(:input){ [] }
+    subject{ Coerce.run(argv) }
+
+    before do
+      subject.should be_a(Alf::Operator::NonRelational::Coerce)
+      subject.operands.should eq([input])
+    end
+
+    context "a typical coercion" do
+      let(:argv){ [input] + %w{-- a Integer b Float} }
+      specify{
+        subject.heading.should eq(Alf::Heading[:a => Integer, :b => Float])
+      }
+    end
+
+  end
+end

data/spec/unit/alf-shell/operator/test_compact.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+module Alf::Shell::Operator
+  describe Compact do
+
+    let(:input){ [] }
+    subject{ Compact.run(argv) }
+
+    context "the default config" do
+      let(:argv){ [input] }
+      specify{
+        subject.should be_a(Alf::Operator::NonRelational::Compact)
+      }
+    end
+
+  end
+end