alf-core 0.15.0 → 0.16.0

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

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

@@ -1,22 +0,0 @@
-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/scope/test_branch.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Support
-    describe Scope, '__branch' do
-
-      let(:scope) { Scope.new [ HelpersInScope ] }
-
-      subject{ scope.__branch(arg) }
-
-      context 'when branched with a Tuple' do
-        let(:arg){ {:here => "here"} }
-
-        it_behaves_like 'A scope'
-
-        it 'responds to the tuple keys' do
-          subject.respond_to?(:here).should be_true
-          subject.here.should eq("here")
-        end
-
-        it "responds to helper's methods" do
-          subject.respond_to?(:world).should be_true
-          subject.world.should eq('world')
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Support
-    describe Scope, "evaluate" do
-
-      context 'on a scope with helpers' do
-        let(:scope) { Scope.new [ HelpersInScope ] }
-
-        it 'has available helpers in scope' do
-          scope.evaluate{ hello(world) }.should eq("Hello world!")
-        end
-
-        it 'supports a string' do
-          scope.evaluate("hello(world)").should eq("Hello world!")
-        end
-
-        it 'supports traceability on errors' do
-          begin
-            scope.evaluate("no_such_one", "a file", 65)
-            raise "Should not pass here"
-          rescue NameError => ex
-            ex.backtrace.any?{|l| l =~ /a file:65/}.should be_true
-          end
-        end
-      end
-
-      context 'on a scope with a parent' do
-        let(:here) { Module.new{ def here; 'here'; end } }
-        let(:scope){ Scope.new [ here ], Scope.new([ HelpersInScope ]) }
-
-        it 'delegates to the parent' do
-          scope.evaluate{ hello(world) }.should eq("Hello world!")
-        end
-
-        it 'correctly respect the priorities' do
-          scope.evaluate{ hello(here) }.should eq("Hello here!")
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/alf-support/scope/test_initialize.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Support
-    describe Scope, 'initialize' do
-
-      it 'supports no argument' do
-        lambda{ Scope.new }.should_not raise_error
-      end
-
-      it 'supports an array of modules' do
-        lambda{ Scope.new([ Helpers ]) }.should_not raise_error
-      end
-
-      it 'supports a parent scope' do
-        lambda{ Scope.new([ Helpers ], Scope.new) }.should_not raise_error
-      end
-
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Support
-    describe Scope, 'respond_to?' do
-
-      context 'on an empty Scope' do
-        subject{ Scope.new }
-        it_behaves_like "A scope"
-      end
-
-      context 'on a Scope that has helpers' do
-        subject{ Scope.new [ HelpersInScope ] }
-
-        it_behaves_like "A scope"
-
-        it "responds to helpers' methods" do
-          subject.respond_to?(:world).should be_true
-        end
-      end
-
-      context 'on a Scope that has a parent scope' do
-        subject{ Scope.new [ ], Scope.new([ HelpersInScope ]) }
-
-        it_behaves_like "A scope"
-
-        it "responds to parent scope methods" do
-          subject.respond_to?(:world).should be_true
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Support, "class_name" do
-
-    let(:tools){ Object.new.extend(Support) }
-
-    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::Support).should eq(:Support)
-    end
-
-  end
-end

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

@@ -1,24 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe "Support#coerce" do
-
-    it 'coerces integers without trouble' do
-      Support.coerce("12", Integer).should eql(12)
-    end
-
-    it 'coerces Time without trouble' do
-      Support.coerce("2012-05-11 12:00:00.000000+0200", Time).should be_a(Time)
-    end
-
-    it 'coerces DateTime without trouble' do
-      Support.coerce("2012-05-11 12:00:00.000000+0200", DateTime).should be_a(DateTime)
-    end
-
-    it 'should raise a TypeError in case of error' do
-      lambda{ 
-        Support.coerce("abc", Integer)
-      }.should raise_error(TypeError)
-    end
-
-  end
-end

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

@@ -1,63 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Support
-    describe Registry do
-
-      let(:clazz){ Class.new.extend(Registry) }
-      let(:seen) { [] }
-
-      before do
-        clazz.listen{|n,c| seen << [n,c] }
-      end
-
-      describe 'when used with classes' do
-        before do
-          clazz.register(Integer, clazz)
-        end
-
-        it 'installs class-level methods' do
-          clazz.should respond_to(:integer)
-        end
-
-        it 'add the class to the registered elements' do
-          clazz.registered.should eq([Integer])
-          clazz.all.should eq([Integer])
-        end
-
-        it 'calls the listeners' do
-          seen.should eq([[:integer, Integer]])
-        end
-      end
-
-      describe 'when used with an array and arguments' do
-        before do
-          clazz.register([:hello, Integer], clazz)
-        end
-
-        it 'installs class-level methods' do
-          clazz.should respond_to(:hello)
-        end
-
-        it 'maintain the registered elements' do
-          clazz.registered.should eq([[:hello, Integer]])
-        end
-
-        it 'calls the listeners' do
-          seen.should eq([[:hello, Integer]])
-        end
-      end
-
-      describe 'when listen after some components have already been registered' do
-        before do
-          clazz.register(Integer, clazz)
-        end
-        it 'calls the listener with registered components at listening time' do
-          seen = []
-          clazz.listen{|n,c| seen << [n,c] }
-          seen.should eq([[:integer, Integer]])
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Support, "ruby_case" do
-
-    let(:tools){ Object.new.extend(Support) }
-
-    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-support/test_rubycase_name.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Support, "rubycase_name" do
-
-    let(:tools){ Object.new.extend(Support) }
-
-    it "should work on a Symbol" do
-      tools.rubycase_name(:Alf).should == :alf
-    end
-
-    it "should work on a String" do
-      tools.rubycase_name("HelloWorld").should == :hello_world
-    end
-
-    it "should work on a Class" do
-      tools.rubycase_name(String ).should == :string
-    end
-
-    it "should work on a Module" do
-      tools.rubycase_name(Algebra::NonRelational).should == :non_relational
-    end
-
-  end
-end

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

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

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

@@ -1,124 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Support, ".to_lispy" do
-
-    subject{ Support.to_lispy(value) }
-
-    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(:expr){ ->(t){ t.qty*t.price } }
-      let(:value){ Aggregator.coerce(Aggregator.sum(expr)) }
-
-      it { should eq("sum{|t| [code unavailable] }") }
-    end
-
-    describe "on a TupleExpression" do
-      let(:value){ TupleExpression.coerce(arg) }
-
-      describe "When built from a symbol" do
-        let(:arg){ :status }
-        it{ should eq("->(t){ t.status }")}
-      end
-
-    end # TupleExpression
-
-    describe "on a Predicate" do
-      let(:value){ Predicate.coerce(arg) }
-
-      describe "When built from a boolean" do
-        let(:arg){ true }
-        it{ should eq("->(t){ true }")}
-      end
-
-      describe "When built from a Hash" do
-        let(:arg){ {:status => 10} }
-        it{ should eq("->(t){ t.status == 10 }")}
-      end
-
-    end # Predicate
-
-    describe "on a TupleComputation" do
-      let(:value){ TupleComputation.coerce(arg) }
-      let(:expr){ ->(t){ status.upcase } }
-
-      describe "When built from a Hash" do
-        let(:arg){ {"upcased" => expr} }
-        it{ should eq("{upcased: ->(t){ [code unavailable] }}")}
-      end
-
-    end # TupleComputation
-
-    describe "on a Summarization" do
-      let(:value){ Summarization.coerce(arg) }
-      let(:expr){ Aggregator.sum{|t| t.qty*t.price } }
-
-      describe "When built from an Array" do
-        let(:arg){ {"total" => expr} }
-        it{ should eq("{total: sum{|t| [code unavailable] }}") }
-      end
-
-    end # Summarization
-
-    let(:conn){ examples_database }
-
-    describe "on an nullary operator" do
-      let(:value){
-        conn.parse{ generator(10, :id) }
-      }
-      it { should eq("generator(10, :id)") }
-    end
-
-    describe "on a served operand" do
-      let(:value){
-        conn.parse{ suppliers }
-      }
-      it { should eq("suppliers") }
-    end
-
-    describe "on an monadic operator with an option" do
-      let(:value){
-        conn.parse{ project(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){
-        conn.parse{ project(suppliers, [:city]) }
-      }
-      it { should eq("project(suppliers, [:city])") }
-    end
-
-    describe "on an dyadic operator without no args nor any option" do
-      let(:value){
-        conn.parse{ join(suppliers, cities) }
-      }
-      it { should eq("join(suppliers, cities)") }
-    end
-
-  end
-end