alf 0.12.2 → 0.13.0

data/spec/unit/alf-core/types/test_tuple_expression.rb

@@ -1,122 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe TupleExpression do
-
-    describe "the class itself" do
-      let(:type){ TupleExpression }
-      def TupleExpression.exemplars
-        [
-          "10",
-          "status > 10",
-        ].map{|x| TupleExpression.coerce(x)}
-      end
-      it_should_behave_like 'A valid type implementation'
-    end
-
-    it "should include a valid example" do
-      expr = TupleExpression["status * 10"]
-      expr.call(:status => 20).should eq(200)
-    end
-
-    let(:handle) {
-      Tools::TupleHandle.new.set(:status => 10)
-    }
-
-    describe "coerce" do
-
-      subject{ TupleExpression.coerce(arg) }
-
-      describe "with nil" do
-        let(:arg){ nil }
-        specify{ lambda{ subject }.should raise_error(ArgumentError) }
-      end
-
-      describe "with a String" do
-        let(:arg){ "true" }
-        it { should be_a(TupleExpression) }
-        specify{ 
-          subject.evaluate(handle).should eql(true) 
-          subject.source.should eq("true")
-        }
-      end
-
-      describe "with a Symbol" do
-        let(:arg){ :status }
-        it { should be_a(TupleExpression) }
-        specify{ 
-          subject.evaluate(handle).should eql(10) 
-          subject.source.should eq(:status)
-        }
-      end
-
-      describe "with a Proc" do
-        let(:arg){ lambda{ :hello } }
-        it { should be_a(TupleExpression) }
-        specify{ 
-          subject.evaluate(handle).should eql(:hello) 
-          subject.source.should be_nil
-        }
-      end
-
-    end # coerce
-
-    describe "from_argv" do
-
-      subject{ TupleExpression.from_argv(argv) }
-
-      describe "with a String (1)" do
-        let(:argv){ %w{true} }
-        it { should be_a(TupleExpression) }
-        specify{ 
-          subject.evaluate(handle).should eql(true) 
-          subject.source.should eq("true")
-        }
-      end
-
-      describe "with a String (2)" do
-        let(:argv){ ["status > 10"] }
-        it { should be_a(TupleExpression) }
-        specify{ 
-          subject.evaluate(handle).should eql(false) 
-          subject.source.should eq("status > 10")
-        }
-      end
-
-      describe "with two String" do
-        let(:argv){ %w{hello world} }
-        specify{ lambda{subject}.should raise_error(ArgumentError) }
-      end
-
-    end # from_argv
-
-    describe 'call' do
-      let(:expr){ TupleExpression["status > 10"] }
-
-      it 'should build its handle correctly' do
-        expr.call(:status => 20).should be_true
-        expr.call(:status => 5).should be_false
-      end
-
-      it 'should be aliased ad []' do
-        expr[:status => 20].should be_true
-        expr[:status => 5].should be_false
-      end
-
-    end # call
-
-    describe 'to_ruby_literal' do
-
-      it 'should work when code is known' do
-        expr = TupleExpression["status > 10"]
-        expr.to_ruby_literal.should eq('Alf::TupleExpression["status > 10"]')
-      end
-
-      it 'should raise a NotImplementedError if no source code' do
-        expr = TupleExpression[lambda{status > 10}]
-        lambda{ expr.to_ruby_literal }.should raise_error(NotImplementedError)
-      end
-
-    end # to_ruby_literal
-
-  end # TupleExpression
-end # Alf

data/spec/unit/alf-core/types/test_tuple_predicate.rb

@@ -1,108 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe TuplePredicate do
-
-    describe "the class itself" do
-      let(:type){ TuplePredicate }
-      def TuplePredicate.exemplars
-        [
-          "status > 10",
-          {:status => 10}
-        ].map{|x| TuplePredicate.coerce(x)}
-      end
-      it_should_behave_like 'A valid type implementation'
-    end
-
-    let(:handle){ Tools::TupleHandle.new.set(:status => 10) }
-
-    describe "coerce" do
-
-      let(:pred){ TuplePredicate.coerce(arg) }
-      before{ pred.should be_a(TuplePredicate) }
-      subject{ pred.evaluate(handle) }
-
-      describe "from TuplePredicate" do
-        let(:arg){ TuplePredicate.new(lambda{ status == 10 }) }
-        it{ should eql(true) }
-      end
-
-      describe "from true" do
-        let(:arg){ true }
-        it{ should eql(true) }
-      end
-
-      describe "from false" do
-        let(:arg){ false }
-        it{ should eql(false) }
-      end
-
-      describe "from Proc" do
-        let(:arg){ lambda{ status == 10 } }
-        it{ should eql(true) }
-      end
-
-      describe "from String" do
-        let(:arg){ "status == 10" }
-        it{ should eql(true) }
-      end
-
-      describe "from Symbol" do
-        let(:arg){ :status }
-        it{ should eql(10) }
-      end
-
-      describe "from Hash without coercion" do
-        let(:arg){ {:status => 10} }
-        it{ should eql(true) }
-      end
-
-      describe "from Hash with coercion" do
-        let(:arg){ {"status" => "10"} }
-        it{ should eql(true) }
-      end
-
-      describe "from a singleton Array" do
-        let(:arg){ ["status == 10"] }
-        it{ should eql(true) }
-      end
-
-      describe "from an Array with coercion" do
-        let(:arg){ ["status", "10"] }
-        it{ should eql(true) }
-      end
-
-    end # coerce
-
-    describe "from_argv" do
-
-      subject{ TuplePredicate.from_argv(argv).evaluate(handle) }
-      
-      describe "from a singleton Array" do
-        let(:argv){ ["status == 10"] }
-        it{ should eql(true) }
-      end
-
-      describe "from an Array with coercion" do
-        let(:argv){ ["status", "10"] }
-        it{ should eql(true) }
-      end
-
-    end # from_argv
-
-    describe 'to_ruby_literal' do
-
-      it 'should work when code is known' do
-        expr = TuplePredicate["status > 10"]
-        expr.should be_a(TuplePredicate)
-        expr.to_ruby_literal.should eq('Alf::TuplePredicate["status > 10"]')
-      end
-
-      it 'should raise a NotImplementedError if no source code' do
-        expr = TuplePredicate[lambda{status > 10}]
-        lambda{ expr.to_ruby_literal }.should raise_error(NotImplementedError)
-      end
-
-    end # to_ruby_literal
-
-  end # TuplePredicate
-end # Alf

data/spec/unit/alf-csv/input.csv

@@ -1,3 +0,0 @@
-size
-10
-20

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

@@ -1,66 +0,0 @@
-require 'spec_helper'
-module Alf
-  module CSV
-    describe Reader do
-    
-      describe "without options" do
-        let(:input){ 
-          StringIO.new << "size\n10\n20\n"
-        }
-        let(:expected){
-          [{:size => "10"}, {:size => "20"}]
-        }
-        subject{ reader.to_a }
-          
-        describe "when called on a reader directly" do
-          let(:reader){
-            ::Alf::CSV::Reader.new(input)
-          }
-          it{ should eq(expected) }
-        end
-        
-        describe "when called through registered one" do
-          let(:reader){
-            ::Alf::Reader.reader(_('input.csv', __FILE__))
-          }
-          it{ should eq(expected) }
-        end
-        
-        describe "when called through factory method" do
-          let(:reader){
-            ::Alf::Reader.csv(input)
-          }
-          it{ should eq(expected) }
-        end
-      end
-      
-      describe "with options" do
-        let(:input){ 
-          StringIO.new << "size;name\n10;blambeau\n20;mmathieu\n"
-        }
-        let(:options){
-          {:col_sep => ";"}
-        }
-        let(:expected){
-          [{:size => "10", :name => 'blambeau'}, {:size => "20", :name => 'mmathieu'}]
-        }
-        subject{ reader.to_a }
-          
-        describe "when called on a reader directly" do
-          let(:reader){
-            ::Alf::CSV::Reader.new(input, options)
-          }
-          it{ should eq(expected) }
-        end
-        
-        describe "when called through factory method" do
-          let(:reader){
-            ::Alf::Reader.csv(input, options)
-          }
-          it{ should eq(expected) }
-        end
-      end
-      
-    end
-  end
-end

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

@@ -1,73 +0,0 @@
-require 'spec_helper'
-module Alf
-  module CSV
-    describe Renderer do
-    
-      describe "without options" do
-        let(:input){ 
-          [{:size => 10}, {:size => 20}]
-        }
-        let(:expected){
-          "size\n10\n20\n"
-        }
-        subject{ renderer.execute(StringIO.new).string }
-          
-        describe "when called on a renderer directly" do
-          let(:renderer){
-            ::Alf::CSV::Renderer.new(input)
-          }
-          it{ should eq(expected) }
-        end
-        
-        describe "when called through registererd one" do
-          let(:renderer){
-            ::Alf::Renderer.renderer(:csv, input)
-          }
-          it{ should eq(expected) }
-        end
-        
-        describe "when called through factory method" do
-          let(:renderer){
-            ::Alf::Renderer.csv(input)
-          }
-          it{ should eq(expected) }
-        end
-      end
-      
-      describe "with options", :hash_ordering => true do
-        let(:input){ 
-          [{:size => 10, :name => "blambeau"}, {:size => 20, :name => "mmathieu"}]
-        }
-        let(:expected){
-          "size;name\n10;blambeau\n20;mmathieu\n"
-        }
-        let(:options){
-          {:col_sep => ";"}
-        }
-        subject{ renderer.execute(StringIO.new).string }
-          
-        describe "when called on a renderer directly" do
-          let(:renderer){
-            ::Alf::CSV::Renderer.new(input, options)
-          }
-          it{ should eq(expected) }
-        end
-        
-        describe "when called through registererd one" do
-          let(:renderer){
-            ::Alf::Renderer.renderer(:csv, input, options)
-          }
-          it{ should eq(expected) }
-        end
-        
-        describe "when called through factory method" do
-          let(:renderer){
-            ::Alf::Renderer.csv(input, options)
-          }
-          it{ should eq(expected) }
-        end
-      end
-      
-    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,34 +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"},
-                              {:name => "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