alf 0.9.3 → 0.10.0

data/spec/unit/operator/test_command_methods.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Operator::CommandMethods do
-    
-    let(:cmd){ Object.new.extend(Operator::CommandMethods) }
-    
-    describe "split_command_args" do
-    
-      subject{ cmd.send(:split_command_args, args) }
-
-      describe "when applied to both operands and args" do
-        let(:args)    { %w{op1 op2 -- a b c} }
-        let(:expected){ [ %w{op1 op2}, %w{a b c} ] }
-        it { should == expected }
-      end
-      
-      describe "when applied to one operand only" do
-        let(:args)    { %w{op1} }
-        let(:expected){ [ %w{op1}, %w{} ] }
-        it { should == expected }
-      end
-      
-      describe "when applied to two operands only" do
-        let(:args)    { %w{op1 op2} }
-        let(:expected){ [ %w{op1 op2}, %w{} ] }
-        it { should == expected }
-      end
-      
-      describe "when applied to args only" do
-        let(:args)    { %w{-- a b c} }
-        let(:expected){ [ [$stdin], %w{a b c} ] }
-        it { should == expected }
-      end
-      
-    end
-      
-  end
-end

data/spec/unit/tools/test_ordering_key.rb

@@ -1,94 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Tools
-    describe OrderingKey do
-  
-      describe "coerce" do
-  
-        specify "when passed an doubly array" do
-          key = OrderingKey.coerce [[:a, :asc], [:b, :desc]]
-          key.attributes.should == [:a, :b]
-          key.order_of(:a).should == :asc
-          key.order_of(:b).should == :desc
-        end
-  
-        specify "when passed a single array" do
-          key = OrderingKey.coerce [:a, :b]
-          key.attributes.should == [:a, :b]
-          key.order_of(:a).should == :asc
-          key.order_of(:b).should == :asc
-        end
-  
-        specify "when passed a single array with asc and desc (1)" do
-          key = OrderingKey.coerce [:a, :asc]
-          key.attributes.should == [:a]
-          key.order_of(:a).should == :asc
-        end
-  
-        specify "when passed a single array with asc and desc (1)" do
-          key = OrderingKey.coerce [:a, :asc, :b, :desc]
-          key.attributes.should == [:a, :b]
-          key.order_of(:a).should == :asc
-          key.order_of(:b).should == :desc
-        end
-  
-        specify "when passed an ordering key" do
-          key  = OrderingKey.coerce [:a, :b]
-          key2 = OrderingKey.coerce key
-          key.should == key2
-        end
-  
-        specify "when passed a projection key" do
-          pkey = ProjectionKey.new [:a, :b]
-          key = OrderingKey.coerce pkey
-          key.attributes.should == [:a, :b]
-          key.order_of(:a).should == :asc
-          key.order_of(:b).should == :asc
-        end
-  
-      end # coerce
-  
-      describe "compare" do
-        
-        specify "when passed a single key" do
-          key = OrderingKey.coerce [:a]
-          key.compare({:a => 1}, {:a => 2}).should == -1
-          key.compare({:a => 1}, {:a => 1}).should == 0
-          key.compare({:a => 2}, {:a => 1}).should == 1
-        end 
-        
-        specify "when passed a single key with desc order" do
-          key = OrderingKey.coerce [[:a, :desc]]
-          key.compare({:a => 1}, {:a => 2}).should == 1
-          key.compare({:a => 1}, {:a => 1}).should == 0
-          key.compare({:a => 2}, {:a => 1}).should == -1
-        end 
-  
-        specify "when passed a double key" do
-          key = OrderingKey.coerce [[:a, :asc], [:b, :desc]]
-          key.compare({:a => 1, :b => 1}, {:a => 0, :b => 1}).should == 1
-          key.compare({:a => 1, :b => 1}, {:a => 1, :b => 2}).should == 1
-          key.compare({:a => 1, :b => 1}, {:a => 1, :b => 1}).should == 0
-        end 
-  
-      end
-  
-      describe "+" do
-  
-        specify "when passed another key" do
-          key = OrderingKey.coerce [:a]
-          key2 = key + OrderingKey.coerce([[:b, :desc]])
-          key2.ordering.should == [[:a, :asc], [:b, :desc]]
-        end
-  
-        specify "when passed another array" do
-          key = OrderingKey.coerce [:a]
-          key2 = key + [[:b, :desc]]
-          key2.ordering.should == [[:a, :asc], [:b, :desc]]
-        end
-  
-      end
-  
-    end
-  end
-end

data/spec/unit/tools/test_parse_commandline_args.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe "Tools#parse_commandline_args" do
-    
-    subject{ Tools.parse_commandline_args(args) }
-    
-    describe "on empty string" do
-      let(:args){ "" }
-      it { should eq([]) }
-    end
-
-    describe "on pseudo empty string" do
-      let(:args){ "   " }
-      it { should eq([]) }
-    end
-
-    describe "on a single arg" do
-      let(:args){ "--text" }
-      it { should eq(["--text"]) }
-    end
-
-    describe "on a multiple args" do
-      let(:args){ "--text --size=10" }
-      it { should eq(["--text", "--size=10"]) }
-    end
-
-    describe "on single quoted arg" do
-      let(:args){ "'hello'" }
-      it { should eq(["hello"]) }
-    end
-
-    describe "on single quoted arg with spacing" do
-      let(:args){ "'hello the world'" }
-      it { should eq(["hello the world"]) }
-    end
-    
-    describe "on double quoted arg" do
-      let(:args){ '"hello"' }
-      it { should eq(["hello"]) }
-    end
-
-    describe "on double quoted arg with spacing" do
-      let(:args){ "'hello the world'" }
-      it { should eq(['hello the world']) }
-    end
-  end
-end

data/spec/unit/tools/test_projection_key.rb

@@ -1,83 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Tools
-    describe ProjectionKey do
-  
-      describe "coerce" do
-        
-        specify "when passed an array" do
-          key = ProjectionKey.coerce [:a, :b]
-          key.attributes.should == [:a, :b]
-          key.allbut.should == false
-        end
-  
-        specify "when passed a ProjectionKey" do
-          key = ProjectionKey.coerce [:a, :b]
-          key2 = ProjectionKey.coerce key
-          key2.should == key
-        end
-  
-        specify "when passed an OrderingKey" do
-          okey = OrderingKey.new [[:a, :asc], [:b, :asc]]
-          key = ProjectionKey.coerce(okey)
-          key.attributes.should == [:a, :b]
-          key.allbut.should == false
-        end
-  
-      end
-  
-      describe "to_ordering_key" do
-  
-        specify "when passed an array" do
-          key = ProjectionKey.coerce [:a, :b]
-          okey = key.to_ordering_key
-          okey.attributes.should == [:a, :b]
-          okey.order_of(:a).should == :asc
-          okey.order_of(:b).should == :asc
-        end
-  
-      end
-  
-      describe "split" do 
-  
-        subject{ key.split(tuple) }
-  
-        describe "when used without allbut" do
-          let(:key){ ProjectionKey.new [:a, :b] }
-          let(:tuple){ {:a => 1, :b => 2, :c => 3} }
-          let(:expected){ [{:a => 1, :b => 2}, {:c => 3}] }
-          it{ should == expected }
-        end   
-  
-        describe "when used with allbut" do
-          let(:key){ ProjectionKey.new [:a, :b], true }
-          let(:tuple){ {:a => 1, :b => 2, :c => 3} }
-          let(:expected){ [{:c => 3}, {:a => 1, :b => 2}] }
-          it{ should == expected }
-        end   
-  
-      end
-  
-      describe "project" do 
-  
-        subject{ key.project(tuple) }
-  
-        describe "when used without allbut" do
-          let(:key){ ProjectionKey.new [:a, :b] }
-          let(:tuple){ {:a => 1, :b => 2, :c => 3} }
-          let(:expected){ {:a => 1, :b => 2} }
-          it{ should == expected }
-        end   
-  
-        describe "when used with allbut" do
-          let(:key){ ProjectionKey.new [:a, :b], true }
-          let(:tuple){ {:a => 1, :b => 2, :c => 3} }
-          let(:expected){ {:c => 3} }
-          it{ should == expected }
-        end   
-  
-      end
-  
-    end
-  end
-end