alf 0.9.0

data/spec/operator/relational/union_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+module Alf
+  module Operator::Relational
+    describe Union do
+        
+      let(:operator_class){ Union }
+      it_should_behave_like("An operator class")
+        
+      let(:left) {[
+        {:city => 'London'},
+        {:city => 'Paris'},
+        {:city => 'Paris'}
+      ]}
+  
+      let(:right) {[
+        {:city => 'Oslo'},
+        {:city => 'Paris'}
+      ]}
+  
+      let(:operator){ Union.run([]) }
+      subject{ operator.to_a }
+  
+      describe "when applied on non disjoint sets" do
+        before{ operator.datasets = [left, right] }
+        let(:expected){[
+          {:city => 'London'},
+          {:city => 'Paris'},
+          {:city => 'Oslo'}
+        ]}
+        it { should == expected }
+      end
+  
+    end 
+  end
+end

data/spec/operator/relational/unnest_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+module Alf
+  module Operator::Relational
+    describe Unnest do
+        
+      let(:operator_class){ Unnest }
+      it_should_behave_like("An operator class")
+        
+      let(:input) {[
+        {:nested => {:a => "a", :b => "b"}, :c => "c"}
+      ]}
+  
+      let(:expected) {[
+        {:a => "a", :b => "b", :c => "c"},
+      ]}
+  
+      subject{ operator.to_a }
+  
+      describe "when factored with commandline args" do
+        let(:operator){ Unnest.run(%w{-- nested}) }
+        before{ operator.pipe(input) }
+        it { should == expected }
+      end
+  
+      describe "when factored with Lispy" do
+        let(:operator){ Lispy.unnest(input, :nested) }
+        it { should == expected }
+      end
+  
+    end 
+  end
+end

data/spec/reader/alf_file_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+module Alf
+  describe Reader::AlfFile do
+    
+    let(:io){ StringIO.new "(restrict :suppliers, lambda{status > 20})" }
+    let(:reader){ Reader::AlfFile.new(io, self) } 
+    def dataset(name)
+      [{:status => 10},{:status => 30}]
+    end
+    
+    subject{ reader.to_a }
+    it{ should == [{:status => 30}]}
+      
+  end
+end

data/spec/reader/input.rb

@@ -0,0 +1,2 @@
+{:id => 1}
+{:id => 2}

data/spec/reader/rash_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+module Alf
+  describe Reader::Rash do
+
+    let(:lines){ [{:id => 1},{:id => 2}]                 }
+    let(:str)  { lines.collect{|s| s.inspect}.join("\n") }
+    let(:io)   { StringIO.new(str) }
+
+    describe "when called on a StringIO" do
+      
+      let(:reader){ Reader::Rash.new(io) }
+  
+      it "should be enumerable" do
+        reader.to_a.should == lines
+      end
+
+    end
+    
+    describe "when called on a String" do
+      
+      let(:file){ File.expand_path('../input.rb', __FILE__) }
+      let(:reader){ Reader::Rash.new(file) }
+  
+      it "should be enumerable" do
+        reader.to_a.should == lines
+      end
+
+    end
+    
+  end
+end

data/spec/reader_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+module Alf
+  describe Reader do
+    
+    subject{ Reader }
+    it { should respond_to(:rash) }
+      
+    describe "rash" do
+      subject{ Reader.rash($stdin) }
+      it{ should be_a(Reader::Rash) }
+    end
+    
+    describe "reader" do
+      
+      specify "when associated" do
+        r = Reader.reader('suppliers.rash')
+        r.should  be_a(Reader::Rash)
+      end
+      
+      specify "when not associated" do
+        lambda{ Reader.reader('.noone') }.should raise_error
+      end
+      
+    end
+
+  end
+end

data/spec/renderer/text/cell_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+module Alf
+  class Renderer::Text
+    describe Cell do
+     
+      let(:f){ Cell.new }
+
+      specify "text_rendering" do
+        Cell.new(100).text_rendering.should == "100"
+        Cell.new(:hello).text_rendering.should == ":hello"
+        Cell.new("hello").text_rendering.should == "hello"
+        Cell.new(10.0).text_rendering.should == "10.0000000"
+        Cell.new(10/3.0).text_rendering.should == "3.3333333"
+        Cell.new([]).text_rendering.should == "[]"
+        Cell.new([10/3.0, true]).text_rendering.should == "[3.3333333, true]"
+      end
+
+      specify "min_width" do
+        Cell.new("").min_width.should == 0
+        Cell.new(10/3.0).min_width.should == 9
+        Cell.new("12\n5345").min_width.should == 4
+      end
+
+      specify "rendering_lines" do
+        Cell.new("").rendering_lines.should == []
+        Cell.new(10/3.0).rendering_lines.should == ["3.3333333"]
+        Cell.new([10/3.0,true]).rendering_lines.should == ["[3.3333333, true]"]
+        Cell.new("abc").rendering_lines(5).should == ["abc  "]
+        Cell.new(12).rendering_lines(5).should == ["   12"]
+      end
+
+    end
+  end
+end

data/spec/renderer/text/row_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module Alf
+  class Renderer::Text
+    describe Row do
+     
+      let(:row){ Row.new(values) }
+
+      describe "when single values are used only" do
+
+        let(:values){ [ 10/3.0, true ] }
+        specify "rendering_lines" do
+          row.rendering_lines.should == ["| 3.3333333 | true |"]
+          row.rendering_lines([10,5]).should == ["|  3.3333333 | true  |"]
+        end
+
+      end
+
+      describe "when multiple-line values are used" do
+
+        let(:values){ [ 10/3.0, [1, 2, 3] ] }
+
+        specify "rendering_lines" do
+          row.rendering_lines.should == ["| 3.3333333 | [1, 2, 3] |"]
+        end
+
+      end
+
+    end
+  end
+end

data/spec/renderer/text/table_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+module Alf
+  class Renderer::Text
+    describe Table do
+     
+      let(:columns){ [ :method, :total ] }
+      let(:table){ Table.new(records, columns) }
+
+      describe "on an empty table" do
+
+        let(:records){ [ ] }
+
+        specify "render" do
+          table.render.should == "+---------+--------+\n" +
+                                 "| :method | :total |\n" +
+                                 "+---------+--------+\n" +
+                                 "+---------+--------+\n"
+        end
+
+      end
+
+      describe "when single values are used only" do
+
+        let(:records){ [ [:by_x, 10.0], [:by_y, 2.0] ] }
+
+        specify "render" do
+          table.render.should == "+---------+------------+\n" +
+                                 "| :method | :total     |\n" +
+                                 "+---------+------------+\n" +
+                                 "| :by_x   | 10.0000000 |\n" +
+                                 "| :by_y   |  2.0000000 |\n" +
+                                 "+---------+------------+\n"
+        end
+
+      end
+
+    end
+  end
+end

data/spec/renderer_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+module Alf
+  describe Renderer do
+    
+    subject{ Renderer }
+    it { should respond_to(:rash) }
+    it { should respond_to(:text) }
+
+    describe 'renderer' do
+      subject{ Renderer.renderer(:rash) } 
+      it{ should be_a(Renderer) }
+    end
+      
+    describe 'rash' do
+      subject{ Renderer.rash(input) } 
+      let(:input){ [{:a => 1}] }
+      let(:output){ "" }
+      let(:expected){ "{:a=>1}\n" }
+      specify{ 
+        subject.should be_a(Renderer)
+        subject.execute(output).should == expected
+      }
+    end
+    
+    describe 'text' do
+      subject{ Renderer.text(input) } 
+      let(:input){ [{:a => 1}] }
+      let(:output){ "" }
+      let(:expected){ "+----+\n"\
+                      "| :a |\n"\
+                      "+----+\n"\
+                      "|  1 |\n"\
+                      "+----+\n"
+      }
+      specify{ 
+        subject.should be_a(Renderer)
+        subject.execute(output).should == expected
+      }
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'alf'
+
+Alf::Lispy.extend(Alf::Lispy)
+
+shared_examples_for "An operator class" do
+
+  it "should not have public set_args, _each and _prepare methods" do
+    operator_class.public_method_defined?(:set_args).should be_false
+    operator_class.public_method_defined?(:_each).should be_false
+    operator_class.public_method_defined?(:_prepare).should be_false
+  end
+
+  it "should have a public run method" do
+    operator_class.public_method_defined?(:run).should be_true
+  end
+  
+  it "should have a public pipe method" do
+    operator_class.public_method_defined?(:pipe).should be_true
+  end
+
+  it "should have a public each method" do
+    operator_class.public_method_defined?(:each).should be_true
+  end
+
+end

data/spec/tools/ordering_key_spec.rb

@@ -0,0 +1,81 @@
+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 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/tools/projection_key_spec.rb

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