alf 0.12.2 → 0.13.0

data/spec/unit/alf-core/text/test_cell.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Text::Renderer
-    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.000"
-        Cell.new(10/3.0).text_rendering.should == "3.333"
-        Cell.new([]).text_rendering.should == "[]"
-        Cell.new([10/3.0, true]).text_rendering.should == "[3.333, true]"
-        Cell.new(10/3.0, {:float_format => "%.6f"}).text_rendering.should == "3.333333"
-      end
-
-      specify "min_width" do
-        Cell.new("").min_width.should == 0
-        Cell.new(10/3.0).min_width.should == 5
-        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.333"]
-        Cell.new([10/3.0,true]).rendering_lines.should == ["[3.333, true]"]
-        Cell.new("abc").rendering_lines(5).should == ["abc  "]
-        Cell.new(12).rendering_lines(5).should == ["   12"]
-      end
-
-    end
-  end
-end

data/spec/unit/alf-core/text/test_row.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Text::Renderer
-    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.333 | true |"]
-          row.rendering_lines([10,5]).should == ["|      3.333 | 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.333 | [1, 2, 3] |"]
-        end
-
-      end
-
-    end
-  end
-end

data/spec/unit/alf-core/text/test_table.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Text::Renderer
-    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.000 |\n" +
-                                 "| :by_y   |  2.000 |\n" +
-                                 "+---------+--------+\n"
-        end
-
-      end
-
-    end
-  end
-end

data/spec/unit/alf-core/tools/test_class_name.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Tools, "class_name" do
-
-    let(:tools){ Object.new.extend(Tools) }
-
-    it "should work on top-level namespaces" do
-      tools.class_name(Alf).should eq(:Alf)
-    end
-
-    it "should work on non top-level namespaces" do
-      tools.class_name(Alf::Tools).should eq(:Tools)
-    end
-
-  end
-end

data/spec/unit/alf-core/tools/test_coalesce.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Tools, "coalesce" do
-    
-    it "should support a varargs variant" do
-      Tools.coalesce(:a, nil, :b, :c).should eql(:a)
-      Tools.coalesce(nil, :a, nil, :b, :c).should eql(:a)
-    end
-    
-    it "should support a block for costly computations" do
-      Tools.coalesce(nil){ :hello }.should eql(:hello)
-    end
-    
-    it "should return nil otherwise" do
-      Tools.coalesce(nil).should be_nil
-    end
-
-  end
-end

data/spec/unit/alf-core/tools/test_coerce.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe "Tools#coerce" do
-
-    it 'should coerce integers without trouble' do
-      Tools.coerce("12", Integer).should eql(12)
-    end
-
-    it 'should raise a Alf::CoercionError in case of error' do
-      lambda{ 
-        Tools.coerce("abc", Integer)
-      }.should raise_error(Alf::CoercionError)
-    end
-
-  end
-end

data/spec/unit/alf-core/tools/test_ruby_case.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Tools, "ruby_case" do
-
-    let(:tools){ Object.new.extend(Tools) }
-
-    it "should work on one word" do
-      tools.ruby_case(:Alf).should == "alf"
-    end
-
-    it "should work on multiple words" do
-      tools.ruby_case(:HelloWorld).should == "hello_world"
-    end
-
-  end
-end

data/spec/unit/alf-core/tools/test_to_lispy.rb

@@ -1,145 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Tools, ".to_lispy" do
-
-    it "should have a valid example" do
-      expr = Alf.lispy.compile{ 
-       (project :suppliers, [:name])
-      }
-      Tools.to_lispy(expr).should eq("(project :suppliers, [:name])")
-    end
-
-    subject{ Tools.to_lispy(value) } 
-
-    describe "on a Proxy" do
-      let(:value){ Iterator::Proxy.new(Environment.examples, :suppliers) }
-      it { should eq(":suppliers") }
-    end
-
-    describe "on an AttrName" do
-      let(:value){ :city }
-      it { should eq(":city") }
-    end
-
-    describe "on an AttrList" do
-      let(:value){ AttrList.new([:name, :city]) }
-      it { should eq("[:name, :city]") }
-    end
-
-    describe "on a Heading" do
-      let(:value){ Heading.new(:name => String) }
-      it { should eq("{:name => String}") }
-    end
-
-    describe "on an Ordering" do
-      let(:value){ Ordering.new([[:name, :asc], [:city, :desc]]) }
-      it { should eq("[[:name, :asc], [:city, :desc]]") }
-    end
-
-    describe "on a Renaming" do
-      let(:value){ Renaming.new(:old => :new) }
-      it { should eq("{:old => :new}") }
-    end
-
-    describe "on an Aggregation" do
-      let(:value){ Aggregator.coerce("sum{ qty*price }") }
-      it { should eq("sum{ qty*price }") }
-    end
-
-    describe "on a TupleExpression" do
-      let(:value){ TupleExpression.coerce(arg) }
-
-      describe "When built from a string" do
-        let(:arg){ "status.upcase" }
-        it{ should eq("->{ status.upcase }")}
-      end
-
-      describe "When built from a symbol" do
-        let(:arg){ :status }
-        it{ should eq("->{ status }")}
-      end
-
-    end # TupleExpression
-
-    describe "on a TuplePredicate" do
-      let(:value){ TuplePredicate.coerce(arg) }
-
-      describe "When built from a TupleExpression" do
-        let(:arg){ TupleExpression.coerce("status > 10") }
-        it{ should eq("->{ status > 10 }")}
-      end
-
-      describe "When built from a boolean" do
-        let(:arg){ true }
-        it{ should eq("->{ true }")}
-      end
-
-      describe "When built from a String" do
-        let(:arg){ "status > 10" }
-        it{ should eq("->{ status > 10 }")}
-      end
-
-      describe "When built from a Hash" do
-        let(:arg){ {:status => 10} }
-        it{ should eq("->{ (self.status == 10) }")}
-      end
-
-      describe "When built with a singleton Array" do
-        let(:arg){ ["status > 10"] }
-        it{ should eq("->{ status > 10 }")}
-      end
-
-      describe "When built with a Hash-Array" do
-        let(:arg){ ["status", "10"] }
-        it{ should eq("->{ (self.status == 10) }")}
-      end
-
-      describe "When built with a Hash-Array without coercion" do
-        let(:arg){ [:status, "10"] }
-        it{ should eq("->{ (self.status == \"10\") }")}
-      end
-
-    end # TuplePredicate
-
-    describe "on a TupleComputation" do
-      let(:value){ TupleComputation.coerce(arg) }
-
-      describe "When built from a Hash" do
-        let(:arg){ {"upcased" => "status.upcase"} }
-        it{ should eq("{:upcased => ->{ status.upcase }}")}
-      end
-
-    end # TupleComputation
-
-    describe "on a Summarization" do
-      let(:value){ Summarization.coerce(arg) }
-
-      describe "When built from an Array" do
-        let(:arg){ {"total" => "sum{ qty*price }"} }
-        it{ should eq("{:total => sum{ qty*price }}") }
-      end
-
-    end # Summarization
-
-    describe "on an nullary operator" do
-      let(:value){ Alf::Operator::NonRelational::Generator.new([], 10, :id) } 
-      it { should eq("(generator 10, :id)") }
-    end
-
-    describe "on an monadic operator with an option" do
-      let(:value){ Alf::Operator::Relational::Project.new([:suppliers], [:city], :allbut => true) } 
-      it { should eq("(project :suppliers, [:city], {:allbut => true})") }
-    end
-
-    describe "on an monadic operator with default values for options" do
-      let(:value){ Alf::Operator::Relational::Project.new([:suppliers], [:city]) } 
-      it { should eq("(project :suppliers, [:city])") }
-    end
-
-    describe "on an dyadic operator without no args nor any option" do
-      let(:value){ Alf::Operator::Relational::Join.new([:suppliers, :cities]) } 
-      it { should eq("(join :suppliers, :cities)") }
-    end
-
-  end
-end

data/spec/unit/alf-core/tools/test_to_relation.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe "Tools#to_relation" do
-
-    let(:expected){
-      Relation.new(Set.new << {:name => "Alf"})
-    }
-
-    def to_rel(x)
-      Relation(x) # Relation(...) -> Alf::Relation(...) -> Tools.to_relation(...)
-    end
-
-    it 'delegates to to_relation if it exists' do
-      x = Struct.new(:to_relation).new("Hello")
-      to_rel(x).should eq("Hello")
-    end
-
-    it 'works on Relation' do
-      to_rel(expected).should eq(expected)
-      to_rel(expected).object_id.should eq(expected.object_id)
-    end
-
-    it 'converts a single Hash as a singleton relation' do
-      tuple = {:name => "Alf"}
-      to_rel(tuple).should eq(expected)
-    end
-
-    it 'converts a list of names values to a Relation' do
-      tuple    = {:name => ["Alf", "Myrrha"]}
-      expected = Relation.new(Set.new << {:name => "Alf"} << {:name => "Myrrha"})
-      to_rel(tuple).should eq(expected)
-    end
-
-    it 'converts an array of tuples' do
-      to_rel(expected.to_a).should eq(expected)
-    end
-
-  end
-end

data/spec/unit/alf-core/tools/test_to_ruby_literal.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe "Tools#to_ruby_literal" do
-
-    it 'should work on Integers' do
-      Tools.to_ruby_literal(12).should eql("12")
-    end
-
-  end
-end

data/spec/unit/alf-core/tools/test_tuple_handle.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Tools
-    describe TupleHandle do
-
-      let(:handle){ TupleHandle.new }
-
-      it "should install methods properly" do
-        handle.set(:hello => "a", :world => "b")
-        handle.should respond_to(:hello)
-        handle.should respond_to(:world)
-      end
-
-      it "should behave correctly" do
-        handle.set(:hello => "a", :world => "b")
-        handle.hello.should == "a"
-        handle.world.should == "b"
-        handle.set(:hello => "c", :world => "d")
-        handle.hello.should == "c"
-        handle.world.should == "d"
-      end
-
-      it "should allow instance evaluating on exprs" do
-        handle.set(:tested => 1)
-        handle.instance_eval{ tested < 1 }.should be_false
-      end
-
-      it "should support an attribute called :path" do
-        handle.set(:path => 1)
-        handle.instance_eval{ path < 1 }.should be_false
-      end
-
-      describe "evaluate" do
-        before{ handle.set(:a => 1, :b => 2) }
-
-        it "should allow a String" do
-          handle.evaluate("a").should == 1
-        end
-
-        it "should allow a Symbol" do
-          handle.evaluate(:a).should == 1
-        end
-
-        it "should allow a Proc" do
-          handle.evaluate(lambda{ a }).should == 1
-        end
-
-      end # evaluate
-
-    end
-  end
-end

data/spec/unit/alf-core/tools/test_tuple_heading.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Tools, "tuple_heading" do
-
-    it 'should work on the empty tuple' do
-      Tools.tuple_heading({}).should eq(Heading::EMPTY)
-    end
-
-    it 'should work on a supplier-like tuple' do
-      expected = Heading[:name => String, :old => FalseClass]
-      Tools.tuple_heading(:name => "Jones", :old => false).should eq(expected)
-    end
-
-  end
-end