alf-core 0.13.1 → 0.14.0

data/spec/unit/alf-relvar/virtual/test_to_cog.rb

@@ -3,15 +3,16 @@ module Alf
   module Relvar
     describe Virtual, "to_cog" do
 
-      let(:rv){ Virtual.new(:expr, self) }
+      let(:expr){ Algebra::Operand::Named.new(:aname, self) }
+      let(:rv)  { Virtual.new(expr)                         }
 
       subject{ rv.to_cog }
 
       def cog(expr)
-        [expr]
+        [:seen, expr]
       end
 
-      it{ should eq([:expr]) }
+      it{ should eq([:seen, expr]) }
 
     end
   end

data/spec/unit/alf-relvar/virtual/test_to_lispy.rb

@@ -3,16 +3,13 @@ module Alf
   module Relvar
     describe Virtual, "to_lispy" do
 
-      let(:rv){ Virtual.new(self, :connection) }
-
-      def to_lispy
-        "a lispy expression"
-      end
+      let(:expr){ Algebra::Operand::Named.new(:aname, self) }
+      let(:rv)  { Virtual.new(expr)                         }
 
       subject{ rv.to_lispy }
 
       it 'delegates to the expression' do
-        subject.should eq("a lispy expression")
+        subject.should eq("aname")
       end
 
     end

data/spec/unit/alf-relvar/virtual/test_to_relvar.rb

@@ -3,7 +3,8 @@ module Alf
   module Relvar
     describe Virtual, "to_relvar" do
 
-      let(:rv){ Virtual.new(:expr, :connection) }
+      let(:expr){ Algebra::Operand::Named.new(:aname, self) }
+      let(:rv)  { Virtual.new(expr)                         }
 
       subject{ rv.to_relvar }
 

data/spec/unit/alf-relvar/virtual/test_to_s.rb

@@ -3,12 +3,12 @@ module Alf
   module Relvar
     describe Virtual, "to_s" do
 
-      let(:rv)  { Virtual.new(expr, :connection)              }
-      let(:expr){ Struct.new(:to_s).new("a lispy expression") }
+      let(:expr){ Algebra::Operand::Named.new(:aname, self) }
+      let(:rv)  { Virtual.new(expr)                         }
 
       subject{ rv.to_s }
 
-      it{ should eq("Relvar::Virtual(a lispy expression)") }
+      it{ should eq("Relvar::Virtual(Operand::Named(:aname))") }
 
     end
   end

data/spec/unit/alf-relvar/virtual/test_update.rb

@@ -3,11 +3,10 @@ module Alf
   module Relvar
     describe Virtual, "update" do
 
-      let(:rv)        { Virtual.new(expr, connection)                 }
-      let(:expr)      { Algebra.named_operand(:suppliers, connection) }
-      let(:updating)  { {sname: 'Jones'}                 }
-      let(:predicate) { Predicate.eq(:sid, 1)            }
-      let(:connection){ self                             }
+      let(:rv)        { Virtual.new(expr)                       }
+      let(:expr)      { Algebra.named_operand(:suppliers, self) }
+      let(:updating)  { {sname: 'Jones'}                        }
+      let(:predicate) { Predicate.eq(:sid, 1)                   }
 
       def update(*args)
         @seen = args

data/spec/unit/alf-support/config/test_dup.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+module Alf
+  module Support
+    describe Config, 'dup' do
+
+      let(:conf_subclass){
+        Class.new(Config){
+          option :ready, Boolean, false
+          option :preferences, Array, []
+          option :aproc, Boolean, ->{ !ready? }
+        }
+      }
+
+      let(:config){ conf_subclass.new }
+
+      context 'when not freezed' do
+        subject{ config.dup }
+
+        it 'should return a different instance' do
+          subject.should be_a(conf_subclass)
+          subject.should_not be(config)
+        end
+
+        it 'should dup all options while keeping them equal' do
+          conf_subclass.options.each do |name,_,_|
+            mine, yours = subject[name], config[name]
+            mine.should eq(yours)
+            mine.should_not be(yours) unless Boolean===mine
+          end
+        end
+
+        it 'should keep the semantics of Proc options' do
+          subject.aproc?.should be_true
+          subject.ready = true
+          subject.aproc?.should be_false
+        end
+      end
+
+      context 'when frozen' do
+        subject{ config.freeze.dup }
+
+        it 'should return a non-frezed instance' do
+          subject.should be_a(conf_subclass)
+          subject.should_not be_frozen
+        end
+
+        it 'allow modifying options on the new instance' do
+          lambda{
+            subject.ready = true
+          }.should_not raise_error
+          subject.ready?.should be_true
+          config.ready?.should be_false
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-support/config/test_freeze.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+module Alf
+  module Support
+    describe Config, 'freeze' do
+
+      let(:conf_subclass){
+        Class.new(Config){
+          option :ready, Boolean, false
+          option :preferences, Array, []
+        }
+      }
+
+      let(:config){ conf_subclass.new }
+
+      subject{ config.freeze }
+
+      it 'should return the instance' do
+        subject.should be(config)
+      end
+
+      it 'should freeze the scalar options' do
+        subject
+        lambda{
+          config.ready = true
+        }.should raise_error(/can't modify frozen/)
+      end
+
+      it 'should freeze the non-scalar options' do
+        subject
+        lambda{
+          config.preferences << "foo"
+        }.should raise_error(/can't modify frozen/)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+module Alf
+  module Support
+    describe Config, '[]' do
+
+      let(:conf_subclass){
+        Class.new(Config){
+          option :ready, Boolean, false
+          option :preferences, Array, ["foo"]
+        }
+      }
+
+      let(:config){ conf_subclass.new }
+
+      subject{ config[attr] }
+
+      context 'on a boolean' do
+        let(:attr){ :ready }
+
+        it{ should eq(false) }
+      end
+
+      context 'on a non-boolean' do
+        let(:attr){ :preferences }
+
+        it{ should eq(["foo"]) }
+      end
+
+      context 'after being set' do
+        let(:attr){ :preferences }
+
+        before do
+          config.preferences = ["bar"]
+        end
+
+        it{ should eq(["bar"]) }
+      end
+
+    end
+  end
+end

data/spec/unit/alf-support/config/test_hash_set.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+module Alf
+  module Support
+    describe Config, '[]=' do
+
+      let(:conf_subclass){
+        Class.new(Config){
+          option :ready, Boolean, false
+          option :preferences, Array, ["foo"]
+        }
+      }
+
+      let(:config){ conf_subclass.new }
+
+      subject{ config[attr] = value }
+
+      context 'on a boolean' do
+        let(:attr){ :ready }
+        let(:value){ true }
+
+        it 'should return the value' do
+          subject.should eq(value)
+        end
+
+        it 'should set the value' do
+          subject
+          config.ready?.should eq(true)
+        end
+      end
+
+      context 'on a non boolean' do
+        let(:attr){ :preferences }
+        let(:value){ ["bar"] }
+
+        it 'should return the value' do
+          subject.should eq(value)
+        end
+
+        it 'should set the value' do
+          subject
+          config.preferences.should eq(["bar"])
+        end
+      end
+
+      context 'when used for merging arrays' do
+        let(:attr){ :preferences }
+        let(:value){ ["bar"] }
+
+        subject{
+          config[:preferences] |= value
+        }
+
+        it 'should merge the values' do
+          subject
+          config.preferences.should eq(["foo", "bar"])
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-support/config/test_new.rb

@@ -39,6 +39,16 @@ module Alf
         end
       end
 
+      context 'with a block passed' do
+        subject{
+          conf_subclass.new{|c| c.ready = true }
+        }
+
+        it 'yields the block' do
+          subject.ready?.should be_true
+        end
+      end
+
       context 'when nothing is passed' do
         subject{ conf_subclass.new }
 

data/spec/unit/alf-support/config/test_option.rb

@@ -6,6 +6,9 @@ module Alf
       let(:conf1){
         Class.new(Config){
           option :ready, Boolean, false
+          option :which, String, ->{ "foo" }
+          option :done,  Proc, ->{ "bar" }
+          option :cross, String, ->{ which.capitalize }
         }
       }
 
@@ -22,6 +25,18 @@ module Alf
         conf2.new.should respond_to(:hello)
       end
 
+      it 'supports procs' do
+        conf1.new.which.should eq("foo")
+      end
+
+      it 'executes proc in that context' do
+        conf1.new.cross.should eq("Foo")
+      end
+
+      it 'does not confuse procs' do
+        conf1.new.done.should be_a(Proc)
+      end
+
     end
   end
 end

data/spec/unit/alf-support/config/test_option_setter.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+module Alf
+  module Support
+    describe Config, 'option setter' do
+
+      let(:conf_subclass){
+        Class.new(Config){
+          option :ready, Boolean, false
+          option :which, String, ->{ "foo" }
+          option :done, Proc, ->{ "bar" }
+        }
+      }
+
+      let(:config){ conf_subclass.new }
+
+      context 'on `ready` with a boolean' do
+        subject{ config.ready = true }
+
+        it 'should return the value' do
+          subject.should eq(true)
+        end
+
+        it 'should set the value' do
+          subject
+          config.ready?.should eq(true)
+        end
+      end
+
+      context 'on `ready` with needed coercion' do
+        subject{ config.ready = "true" }
+
+        it 'returns the non-coerced value' do
+          subject.should eq("true")
+        end
+
+        it 'should set the value' do
+          subject
+          config.ready?.should eq(true)
+        end
+      end
+
+      context 'on `which` with a string' do
+        subject{ config.which = "blah" }
+
+        it 'should return the value' do
+          subject.should eq("blah")
+        end
+
+        it 'should set the value' do
+          subject
+          config.which.should eq("blah")
+        end
+      end
+
+      context 'on `which` with a Proc' do
+        let(:proc){ ->{ "blah" } }
+
+        subject{ config.which = proc }
+
+        it 'should return the value' do
+          subject.should be(proc)
+        end
+
+        it 'should call the proc when option is get' do
+          subject
+          config.which.should eq("blah")
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-support/config/test_options.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Alf
+  module Support
+    describe Config, '.options' do
+
+      let(:conf){
+        Class.new(Config){
+          option :ready, Boolean, false
+          option :hello, String, "world"
+        }
+      }
+
+      it 'should contain the options' do
+        conf.options.should eq([
+          [:ready, Boolean, false],
+          [:hello, String, "world"]
+        ])
+      end
+
+    end
+  end
+end

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

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