alf 0.12.2 → 0.13.0

data/spec/unit/alf-core/assumptions/test_scoping.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-describe :clojures_and_scoping do
-
-  class Foo
-    
-    def a_method
-      :inside
-    end
-    
-    def evaluate(lamb)
-      if RUBY_VERSION <= "1.9"
-        self.instance_eval(&lamb)
-      else
-        self.instance_exec(&lamb)
-      end
-    end
-    
-  end
-  
-  specify "when no name clash" do
-    Foo.new.evaluate(lambda{ a_method }).should == :inside 
-  end
-  
-  specify "with name clash" do
-    a_method = :outside
-    Foo.new.evaluate(Proc.new{ a_method }).should == :outside 
-  end
-  
-end

data/spec/unit/alf-core/assumptions/test_set.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-require 'set'
-describe Set do
-  
-  specify "empty sets should be equal" do
-    Set.new([]).should eq(Set.new([]))
-    Set.new([]).should eql(Set.new([]))
-  end
-  
-  describe "on DEE-like sets" do
-    let(:dee){ Set.new([{}]) }
-      
-    specify "DEE sets should be equal" do
-      Set.new([{}]).should eq(dee)
-      Set.new([{}]).should eql(dee)
-    end
-    
-    specify "DEE-like sets should be equal (1)" do
-      arr = [{}]
-      Set.new(arr).should eq(dee)
-      Set.new(arr).should eql(dee)
-    end
-    
-    specify "DEE-like sets should be equal (2)" do
-      arr = [{}]
-      Set.new(arr.to_a).should eq(dee)
-      Set.new(arr.to_a).should eql(dee)
-    end
-    
-    specify "DEE-like sets should be equal (3)" do
-      arr = [{}]
-      arr.to_set.should eq(dee)
-      arr.to_set.should eql(dee)
-    end
-    
-    specify "DEE-like sets should be equal (4)" do
-      arr = [{}]
-      arr.to_set.should eq(dee)
-      arr.to_set.should eql(dee)
-    end
-    
-    specify "DEE-like sets should be equal (5)" do
-      arr = Object.new.extend(Enumerable)
-      def arr.each
-        yield({})
-      end
-      arr.to_set.should eq(dee)
-      arr.to_set.should eql(dee)
-    end
-    
-    specify "DEE-like sets should be equal (5)" do
-      arr = Object.new.extend(Enumerable)
-      def arr.each
-        tuple = {:sid => "1"} 
-        tuple.delete(:sid)
-        yield(tuple)
-      end
-      arr.to_set.should eq(dee)
-      arr.to_set.should eql(dee)
-    end
-
-  end  
-
-end

data/spec/unit/alf-core/environment/examples/suppliers.rash

@@ -1,5 +0,0 @@
-{: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'}

data/spec/unit/alf-core/environment/test_folder.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Environment
-    describe Folder do
-
-      it 'should be registered' do
-        Environment.environments.find{|n,c| c == Folder}.should_not be_nil
-      end
-
-      it 'should lead to an Environment.folder method' do
-        Environment.should respond_to(:folder)
-        Environment.folder(File.dirname(__FILE__)).should be_a(Folder)
-      end
-
-      let(:path){ File.expand_path('../examples', __FILE__) }
-      let(:env){ Folder.new(path) }
-
-      describe "recognizes?" do
-
-        it 'should return true on an existing path' do
-          Folder.recognizes?([File.dirname(__FILE__)]).should be_true
-        end
-
-        it 'should return false on an non existing path' do
-          Folder.recognizes?(["not/an/existing/one"]).should be_false
-        end
-
-      end # recognizes?
-
-      describe "dataset" do
-
-        subject{ env.dataset(name) }
-
-        describe "when called on explicit file" do
-          let(:name){ "suppliers.rash" }
-          it{ should be_a(Reader::Rash) }
-        end
-
-        describe "when called on existing" do
-          let(:name){ "suppliers" }
-          it{ should be_a(Reader::Rash) }
-        end
-
-        describe "when called on unexisting" do
-          let(:name){ "notavalidone" }
-          specify{ lambda{ subject }.should raise_error(Alf::NoSuchDatasetError) }
-        end
-
-      end # dataset
-
-    end
-  end
-end

data/spec/unit/alf-core/operator/non_relational/test_autonum.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Operator::NonRelational
-    describe Autonum do
-
-      let(:operator_class){ Autonum }
-      it_should_behave_like("An operator class")
-
-      let(:input) {[
-        {:a => "a"},
-        {:a => "b"},
-        {:a => "a"},
-      ]}
-
-      subject{ operator.to_a }
-
-      context "with default attribute name" do
-
-        let(:expected){[
-          {:a => "a", :autonum => 0},
-          {:a => "b", :autonum => 1},
-          {:a => "a", :autonum => 2},
-        ]}
-
-        context "with Lispy" do 
-          let(:operator){ Lispy.autonum(input) }
-          it{ should == expected }
-        end
-
-      end # default attribute name
-
-      context "with explicit attribute name" do
-        let(:expected){[
-          {:a => "a", :unique => 0},
-          {:a => "b", :unique => 1},
-          {:a => "a", :unique => 2},
-        ]}
-
-        context "with Lispy" do 
-          let(:operator){ Lispy.autonum(input, :unique) }
-          it{ should == expected }
-        end
-
-      end # explicit attribute name
-
-    end
-  end
-end

data/spec/unit/alf-core/operator/non_relational/test_clip.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Operator::NonRelational
-    describe Clip do
-
-      let(:operator_class){ Clip }
-      it_should_behave_like("An operator class")
-
-      let(:input) {[
-        {:a => "a", :b => "b"},
-      ]}
-
-      subject{ operator.to_a }
-
-      context "--no-allbut" do
-        let(:expected){[{:a => "a"}]}
-
-        context "with Lispy" do
-          let(:operator){ Lispy.clip(input, [:a]) }
-          it { should == expected } 
-        end
-      end # --no-allbut
-
-      context "--allbut" do
-        let(:expected){[{:b => "b"}]}
-
-        context "with Lispy" do
-          let(:operator){ Lispy.clip(input, [:a], :allbut => true) }
-          it { should == expected } 
-        end
-      end # --allbut
-  
-    end 
-  end
-end

data/spec/unit/alf-core/operator/non_relational/test_coerce.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Operator::NonRelational
-    describe Coerce do
-
-      let(:operator_class){ Coerce }
-      it_should_behave_like("An operator class")
-
-      let(:input) {Alf::Relation[
-        {:a => "12", :b => "14.0"},
-      ]}
-
-      subject{ operator.to_rel }
-
-      context "--no-strict" do
-        let(:expected){Alf::Relation[
-          {:a => 12, :b => 14.0}
-        ]}
-
-        context "with Lispy" do
-          let(:operator){ Lispy.coerce(input, :a => Integer, :b => Float) }
-          it { should == expected }
-        end
-
-      end # --no-strict
-
-    end 
-  end
-end

data/spec/unit/alf-core/operator/non_relational/test_compact.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Operator::NonRelational
-    describe Compact do
-
-      let(:operator_class){ Compact }
-      it_should_behave_like("An operator class")
-
-      let(:input) {[
-        {:a => "via_method", :time => 1, :b => "b"},
-        {:a => "via_reader", :time => 3, :b => "b"},
-        {:a => "via_method", :time => 2, :b => "b"},
-        {:a => "via_reader", :time => 3, :b => "b"},
-        {:a => "via_method", :time => 1, :b => "b"},
-      ]}
-
-      let(:expected) {[
-        {:a => "via_method", :time => 1, :b => "b"},
-        {:a => "via_reader", :time => 3, :b => "b"},
-        {:a => "via_method", :time => 2, :b => "b"},
-      ]}
-
-      subject{ operator.to_a }
-
-      context "with Lispy" do
-        let(:operator){ Lispy.compact(input) }
-        it { should == expected }
-      end
-
-    end
-  end
-end

data/spec/unit/alf-core/operator/non_relational/test_defaults.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Operator::NonRelational
-    describe Defaults do
-
-      let(:operator_class){ Defaults }
-      it_should_behave_like("An operator class")
-
-      subject{ operator.to_a }
-
-      context "--no-strict" do
-        let(:input) {[
-          {:a => nil, :b => "b"},
-        ]}
-        let(:expected) {[
-          {:a => 1, :b => "b", :c => "blue"},
-        ]}
-
-        context "with Lispy" do 
-          let(:operator){ Lispy.defaults(input, :a => 1, :c => "blue") }
-          it{ should == expected }
-        end
-
-      end # --no-strict
-
-      describe "--strict" do
-        let(:input) {[
-          {:a => 3,   :b => "b", :c => "blue"},
-          {:a => nil, :b => "b", :c => "blue"},
-        ]}
-        let(:expected) {[
-          {:a => 3, :b => "b"},
-          {:a => 1, :b => "b"},
-        ]}
-
-      end # --strict
-
-      context "with tuple expressions" do
-        let(:input) {[
-          {:a => nil, :b => "b"},
-        ]}
-        let(:expected) {[
-          {:a => "b", :b => "b"},
-        ]}
-        let(:operator){ 
-          Lispy.defaults(input, {:a => TupleExpression.coerce("b")}) 
-        }
-        it{ should == expected }
-      end # tuple expressions
-
-    end
-  end
-end

data/spec/unit/alf-core/operator/non_relational/test_generator.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Operator::NonRelational
-    describe Generator do
-
-      let(:operator_class){ Generator }
-      it_should_behave_like("An operator class")
-
-      subject{ operator.to_rel }
-
-      context "empty args" do
-        let(:expected){Relation[
-          {:num => 1},
-          {:num => 2},
-          {:num => 3},
-          {:num => 4},
-          {:num => 5},
-          {:num => 6},
-          {:num => 7},
-          {:num => 8},
-          {:num => 9},
-          {:num => 10},
-        ]}
-
-        context "with Lispy" do 
-          let(:operator){ Lispy.generator() }
-          it{ should == expected }
-        end
-
-      end # empty args
-
-      context "with a size" do
-        let(:expected){Relation[
-          {:num => 1},
-          {:num => 2},
-        ]}
-
-        context "When factored with Lispy" do 
-          let(:operator){ Lispy.generator(2) }
-          it{ should == expected }
-        end
-
-      end # with a size
-
-      context "when providing a size and a name" do
-        let(:expected){Relation[
-          {:id => 1},
-          {:id => 2},
-        ]}
-
-        context "When factored with Lispy" do 
-          let(:operator){ Lispy.generator(2, :id) }
-          it{ should == expected }
-        end
-
-      end # size and name
-
-    end 
-  end
-end

data/spec/unit/alf-core/operator/non_relational/test_sort.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Operator::NonRelational
-    describe Sort do
-
-      let(:operator_class){ Sort }
-      it_should_behave_like("An operator class")
-
-      let(:input) {[
-        {:first => "a", :second => 20,  :third => true},
-        {:first => "b", :second => 10, :third => false},
-        {:first => "a", :second => 1,  :third => true},
-      ]}
-
-      let(:expected){[
-        {:first => "a", :second => 1,  :third => true},
-        {:first => "a", :second => 20, :third => true},
-        {:first => "b", :second => 10, :third => false},
-      ]}
-
-      subject{ operator.to_a }
-
-      context "with Lispy" do 
-        let(:operator){ Lispy.sort(input, [[:first, :asc], [:second, :asc]]) }
-        it{ should eq(expected) }
-      end
-
-      context "with one arg" do 
-        let(:operator){ Lispy.sort(input, [[:second, :asc]]) }
-        let(:expected){[
-          {:first => "a", :second => 1,  :third => true},
-          {:first => "b", :second => 10, :third => false},
-          {:first => "a", :second => 20, :third => true},
-        ]}
-        it{ should eq(expected) }
-      end
-
-      context "with two args" do 
-        let(:operator){ Lispy.sort(input, [[:second, :asc], [:first, :asc]]) }
-        let(:expected){[
-          {:first => "a", :second => 1,  :third => true},
-          {:first => "b", :second => 10, :third => false},
-          {:first => "a", :second => 20, :third => true},
-        ]}
-        it{ should eq(expected) }
-      end
-
-      context "in descending order" do 
-        let(:operator){ Lispy.sort(input, [[:second, :desc]]) }
-        let(:expected){[
-          {:first => "a", :second => 20, :third => true},
-          {:first => "b", :second => 10, :third => false},
-          {:first => "a", :second => 1,  :third => true},
-        ]}
-        it{ should eq(expected) }
-      end
-
-    end 
-  end
-end