alf-core 0.15.0 → 0.16.0

data/spec/unit/alf-support/test_to_ruby_literal.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe "Support#to_ruby_literal" do
-
-    it 'works on Symbols' do
-      Support.to_ruby_literal(:name).should eql(":name")
-    end
-
-    it 'works on Integers' do
-      Support.to_ruby_literal(12).should eql("12")
-    end
-
-    it 'works on DateTime' do
-      dt = DateTime.parse('2012-05-11T12:00:00+00:00')
-      rl = Support.to_ruby_literal(dt)
-      ::Kernel.eval(rl).should eq(dt)
-    end
-
-    it 'works on Time' do
-      t = Time.parse('2012-05-11T12:00:00+00:00')
-      rl = Support.to_ruby_literal(t)
-      ::Kernel.eval(rl).should eq(t)
-    end
-
-  end
-end

data/spec/unit/alf-support/test_to_tuple.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe "Support#to_tuple" do
-
-    let(:expected){
-      Tuple(name: "Alf")
-    }
-
-    def to_tuple(x, &bl)
-      Tuple(x, &bl) # Tuple(...) -> Alf::Tuple(...) -> Support.to_tuple(...)
-    end
-
-    it 'returns a tuple already' do
-      to_tuple(name: "Alf").should eq(expected)
-    end
-
-    it 'symbolizes keys' do
-      to_tuple('name' => "Alf").should eq(expected)
-    end
-
-    it 'supports a block that is delegated to remap' do
-      to_tuple('name' => "alf", 'version' => "foo"){|k,v|
-        k.should be_a(Symbol)
-        v.upcase
-      }.should eq(Tuple(name: "ALF", version: "FOO"))
-    end
-
-  end
-end

data/spec/unit/alf-support/test_tuple_scope.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Support
-    describe TupleScope do
-
-      let(:scope){ TupleScope.new }
-
-      it "should install methods properly" do
-        scope.__set_tuple(:hello => "a", :world => "b")
-        scope.respond_to?(:hello).should be_true
-        scope.respond_to?(:world).should be_true
-      end
-
-      it "should behave correctly" do
-        scope.__set_tuple(:hello => "a", :world => "b")
-        scope.hello.should == "a"
-        scope.world.should == "b"
-        scope.__set_tuple(:hello => "c", :world => "d")
-        scope.hello.should == "c"
-        scope.world.should == "d"
-      end
-
-      it "should allow instance evaluating on exprs" do
-        scope.__set_tuple(:tested => 1)
-        scope.evaluate{ tested < 1 }.should be_false
-      end
-
-      it "should support an attribute called :path" do
-        scope.__set_tuple(:path => 1)
-        scope.evaluate{ path < 1 }.should be_false
-      end
-
-      it "should support calling Tuple and Relation" do
-        scope.__set_tuple(:path => 1)
-        scope.evaluate{ Tuple(sid: path) }.should eq(Tuple(sid: 1))
-        scope.evaluate{ Relation(sid: path) }.should eq(Relation(sid: 1))
-      end
-
-      it "should support being converted to Relation" do
-        scope.__set_tuple(:path => 1)
-        Relation(scope).should eq(Relation(path: 1))
-      end
-
-    end
-  end
-end

data/spec/unit/alf-support/test_unsymbolize_keys.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Support, 'unsymbolize_keys' do
-    include Support
-
-    subject{ unsymbolize_keys(arg) }
-
-    context 'with an empty Hash' do
-      let(:arg){ Hash.new }
-      it { should eq({}) }
-    end
-
-    context 'with a Hash with String keys' do
-      let(:arg){ {"name" => "Jones", "id" => 2} }
-      it { should eq(arg) }
-    end
-
-    context 'with a Hash with all symbols already' do
-      let(:arg){ {:name => "Jones", :id => 2} }
-      it { should eq({"name" => "Jones", "id" => 2}) }
-    end
-    
-  end
-end

data/spec/unit/alf-support/tuple_scope/test_evaluate.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Support
-    describe TupleScope, "evaluate" do
-
-      context 'with a simple TupleScope' do
-        let(:scope){ TupleScope.new(:a => 1, :b => 2) }
-
-        it "should allow a block" do
-          scope.evaluate{ a }.should == 1
-        end
-
-        it 'should resolve DUM and DEE correctly' do
-          scope.evaluate{ DUM }.should be_a(Relation)
-        end
-      end
-
-      context 'when scopes are added at construction' do
-        let(:scope){ TupleScope.new({:who => "world"}, [ HelpersInScope ]) }
-
-        it 'has available helpers in scope' do
-          scope.evaluate{ hello(who) }.should eq("Hello world!")
-        end
-      end
-
-      context 'when scope has a parent' do
-        let(:parent){ Scope.new [ HelpersInScope ] }
-        let(:scope){ TupleScope.new({:here => "here"}, [  ], parent) }
-
-        it 'has parent helpers in scope' do
-          scope.evaluate{ hello(here) }.should eq("Hello here!")
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/alf-support/tuple_scope/test_hash_get.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Support
-    describe TupleScope, "[]" do
-
-      context 'with a simple TupleScope' do
-        let(:scope){ TupleScope.new(:a => 1, :b => 2) }
-
-        it "delegates to the tuple" do
-          scope[:a].should == 1
-        end
-
-        it "return nil on unexisting" do
-          scope[:c].should be_nil
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/alf-support/tuple_scope/test_respond_to.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Support
-    describe TupleScope, 'respond_to?' do
-
-      context 'on an empty TupleScope' do
-        let(:scope){ TupleScope.new }
-
-        it_behaves_like "A scope"
-
-        it 'responds to [], to_s and inspect' do
-          scope.respond_to?(:[]).should be_true
-          scope.respond_to?(:to_s).should be_true
-          scope.respond_to?(:inspect).should be_true
-        end
-      end
-
-      context 'on a TupleScope that decorates a tuple' do
-        let(:scope){ TupleScope.new(:hello => "world") }
-
-        it_behaves_like "A scope"
-
-        it 'responds to tuple keys' do
-          scope.respond_to?(:hello).should be_true
-        end
-      end
-
-      context 'on a TupleScope that has helpers' do
-        let(:scope){ TupleScope.new(nil, [ HelpersInScope ]) }
-
-        it_behaves_like "A scope"
-
-        it "responds to helpers' methods" do
-          scope.respond_to?(:hello).should be_true
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/alf-support/tuple_scope/test_to_s.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Support
-    describe TupleScope, "to_s and inspect" do
-
-      let(:tuple){ {:a => 1, :b => 2} }
-
-      context 'with a simple TupleScope' do
-        let(:scope){ TupleScope.new(tuple) }
-
-        it "delegates to_s to the tuple" do
-          scope.to_s.should eq(tuple.to_s)
-        end
-
-        it "delegates to the tuple" do
-          scope.inspect.should eq(tuple.inspect)
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/alf-types/attr_list/test_allbut.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe AttrList, "project" do
-
-    let(:list){ AttrList.new [:id, :name, :status] }
-
-    subject{ list.allbut(subset) }
-
-    context 'on a proper subset' do
-      let(:subset){ [:id, :name] }
-
-      it{ should eq(AttrList[:status]) }
-    end
-
-    context 'on an empty subset' do
-      let(:subset){ [] }
-
-      it { should eq(AttrList[:id, :name, :status]) }
-    end
-
-    context 'on the same set' do
-      let(:subset){ list }
-
-      it{ should eq(AttrList[]) }
-    end
-
-  end
-end

data/spec/unit/alf-types/attr_list/test_ampersand.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe AttrList, "&" do
-
-    let(:list){ AttrList.new [:id, :name] }
-
-    context 'disjoint lists' do
-      subject{ list & [:status] }
-
-      it{ should eq(AttrList[]) }
-    end
-
-    context 'non disjoint lists' do
-      subject{ list & [:id, :status] }
-
-      it{ should eq(AttrList[:id]) }
-    end
-
-  end
-end

data/spec/unit/alf-types/attr_list/test_coerce.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe AttrList, "coerce" do
-
-    subject{ AttrList.coerce(arg) }
-
-    let(:expected){ AttrList.new [:a, :b] }
-
-    describe "with an AttrList" do
-      let(:arg){ AttrList.new [:a, :b] }
-
-      it{ should be(arg) }
-    end
-
-    describe "with a list of Symbols" do
-      let(:arg){ [:a, :b] }
-
-      it{ should eq(expected) }
-    end
-
-    describe "with a Hash" do
-      let(:arg){ {a: 12, b: "Smith"} }
-
-      it{ should eq(expected) }
-    end
-
-    describe "with a Hash to be symbolized" do
-      let(:arg){ {'a' => 12, 'b' => "Smith"} }
-
-      it{ should eq(expected) }
-    end
-
-    describe "with an Ordering" do
-      let(:arg){ Ordering.new [[:a, :asc], [:b, :asc]] }
-
-      it{ should eq(expected) }
-    end
-
-    describe "with a TupleComputation" do
-      let(:arg){ TupleComputation[a: 12, b: "Smith"] }
-
-      it{ should eq(expected) }
-    end
-
-    describe "when passed an unrecognized argument" do
-      let(:arg){ false }
-      specify{
-        lambda{ subject }.should raise_error(TypeError)
-      }
-    end
-
-    describe 'the [] alias' do
-
-      it 'allows an empty list' do
-        AttrList[].should eq(AttrList::EMPTY)
-      end
-
-      it 'allows a singleton literal list' do
-        AttrList[:name].should eq(AttrList.new([:name]))
-      end
-
-      it 'allows a non-empty literal list' do
-        AttrList[:name, :city].should eq(AttrList.new([:name, :city]))
-      end
-    end
-
-  end
-end

data/spec/unit/alf-types/attr_list/test_difference.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe AttrList, "-" do
-
-    let(:list){ AttrList.new [:id, :name] }
-
-    context 'disjoint lists' do
-      subject{ list - [:status] }
-
-      it{ should eq(list) }
-    end
-
-    context 'non disjoint lists' do
-      subject{ list - [:id, :status] }
-
-      it{ should eq(AttrList[:name]) }
-    end
-
-  end
-end

data/spec/unit/alf-types/attr_list/test_hash_and_eql.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe AttrList, "hash and ==" do
-
-    subject{ left == right }
-
-    after do
-      left.hash.should eq(right.hash) if subject
-    end
-
-    context "when the same empty lists" do
-      let(:left){ AttrList[] }
-      let(:right){ AttrList[] }
-
-      it{ should be_true }
-    end
-
-    context "when the same lists in same order" do
-      let(:left){ AttrList[:a, :b] }
-      let(:right){ AttrList[:a, :b] }
-
-      it{ should be_true }
-    end
-
-    context "when the same lists in different order" do
-      let(:left){ AttrList[:a, :b] }
-      let(:right){ AttrList[:b, :a] }
-
-      it{ should be_true }
-    end
-
-    context "when not the same lists" do
-      let(:left){ AttrList[:a, :b] }
-      let(:right){ AttrList[:b, :c] }
-
-      it{ should be_false }
-    end
-
-    context "when disjoint" do
-      let(:left){ AttrList[:a, :b] }
-      let(:right){ AttrList[:c, :d] }
-
-      it{ should be_false }
-    end
-
-  end
-end

data/spec/unit/alf-types/attr_list/test_include.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe AttrList, 'include?' do
-
-    let(:list){ AttrList[:id, :name] }
-
-    subject{ list.include?(attribute) }
-
-    context 'when included' do
-      let(:attribute){ :id }
-
-      it{ should be_true }
-    end
-
-    context 'when not included' do
-      let(:attribute){ :notthatone }
-
-      it{ should be_false }
-    end
-
-  end
-end