alf 0.12.2 → 0.13.0

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

@@ -1,19 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe "Tools#varargs" do
-
-    it "should work with exact arguments" do
-      Tools.varargs([1, "hello"], [Integer, String]).should eq([1, "hello"])
-    end
-
-    it "should work when some args are missing" do
-      Tools.varargs(["hello"], [Integer, String]).should eq([nil, "hello"])
-      Tools.varargs([1, 2], [Integer, String, Integer]).should eq([1, nil, 2])
-    end
-
-    it 'should work when no arguments are passed at all' do
-      Tools.varargs([], [Integer, String]).should eq([nil, nil])
-    end
-
-  end
-end

data/spec/unit/alf-core/types/test_attr_list.rb

@@ -1,188 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe AttrList do
-
-    describe "the class itself" do
-      let(:type){ AttrList }
-      def AttrList.exemplars
-        [
-          [],
-          [:a],
-          [:a, :b]
-        ].map{|arg| AttrList.coerce(arg) }
-      end
-      it_should_behave_like 'A valid type implementation'
-    end
-
-    describe "coerce" do
-
-      subject{ AttrList.coerce(arg) }
-
-      describe "when passed a AttrList" do
-        let(:arg){ [:a, :b] } 
-        it{ should eq(AttrList.new(arg)) }
-      end
-
-      describe "when passed an Ordering" do
-        let(:arg){ Ordering.new [[:a, :asc], [:b, :asc]] }
-        it{ should eq(AttrList.new([:a, :b])) }
-      end
-
-      describe "when passed a TupleComputation" do
-        let(:arg){ TupleComputation[:a => 12, :b => "Smith"] }
-        specify{ 
-          subject.should be_a(AttrList) 
-          subject.to_a.to_set.should eq([:a, :b].to_set)
-        }
-      end
-
-      describe "when passed an array" do
-        let(:arg){ [:a, :b] }
-        it{ should eq(AttrList.new([:a, :b])) }
-      end
-
-      describe "when passed an unrecognized argument" do
-        let(:arg){ :not_recognized }
-        specify{
-          lambda{ subject }.should raise_error(ArgumentError)
-        }
-      end
-
-    end # coerce
-
-    describe "[]" do
-
-      it 'should allow an empty list' do
-        AttrList[].should eq(AttrList.new([]))
-      end
-
-      it 'should allow an non-empty list' do
-        AttrList[:name, :city].should eq(AttrList.new([:name, :city]))
-      end
-
-    end # []
-
-    describe "from_argv" do
-
-      subject{ AttrList.from_argv(argv) }
-
-      describe "on an empty array" do
-        let(:argv){ [] }
-        it{ should eq(AttrList.new([])) }
-      end
-
-      describe "on a singleton" do
-        let(:argv){ ["hello"] }
-        it{ should eq(AttrList.new([:hello])) }
-      end
-
-      describe "on multiple strings" do
-        let(:argv){ ["hello", "world"] }
-        it{ should eq(AttrList.new([:hello, :world])) }
-      end
-
-      describe "when passed an unrecognized argument" do
-        let(:argv){ :not_recognized }
-        specify{
-          lambda{ subject }.should raise_error(ArgumentError)
-        }
-      end
-
-    end # from_argv
-
-    describe "to_ordering" do
-
-      describe "without direction" do
-        subject{ AttrList.coerce(attrs).to_ordering }
-        let(:attrs){ [:a, :b] }
-        it{ should eq(Ordering.new [[:a, :asc], [:b, :asc]])}
-      end
-
-      describe "with a direction" do
-        subject{ AttrList.coerce(attrs).to_ordering(direction) }
-        let(:attrs){ [:a, :b] }
-        let(:direction){ :desc }
-        it{ should eq(Ordering.new [[:a, :desc], [:b, :desc]])}
-      end
-
-    end # to_ordering
-
-    describe "split_tuple" do 
-
-      let(:key){ AttrList.new [:a, :b] }
-      let(:tuple){ {:a => 1, :b => 2, :c => 3} }
-
-      describe "when used without allbut" do
-        subject{ key.split_tuple(tuple) }
-        it{ should eq([{:a => 1, :b => 2}, {:c => 3}]) }
-      end
-
-      describe "when used with allbut set to true" do
-        subject{ key.split_tuple(tuple, true) }
-        it{ should eq([{:c => 3}, {:a => 1, :b => 2}]) }
-      end
-
-      describe "when used with allbut set to false" do
-        subject{ key.split_tuple(tuple, false) }
-        it{ should eq([{:a => 1, :b => 2}, {:c => 3}]) }
-      end
-
-      specify "the documentation example" do
-        list = AttrList.new([:name])
-        tuple = {:name => "Jones", :city => "London"}
-        list.split_tuple(tuple).should eq([{:name => "Jones"}, {:city => "London"}])
-        list.split_tuple(tuple, true).should eq([{:city => "London"}, {:name => "Jones"}])
-      end
-
-    end # split
-
-    describe "project_tuple" do 
-
-      let(:key){ AttrList.new [:a, :b] }
-      let(:tuple){ {:a => 1, :b => 2, :c => 3} }
-
-      describe "when used without allbut" do
-        subject{ key.project_tuple(tuple) }
-        it{ should eq({:a => 1, :b => 2}) }
-      end
-
-      describe "when used with allbut set to true" do
-        subject{ key.project_tuple(tuple, true) }
-        it{ should eq({:c => 3}) }
-      end
-
-      describe "when used without allbut set to false" do
-        subject{ key.project_tuple(tuple, false) }
-        it{ should eq({:a => 1, :b => 2}) }
-      end
-
-      specify "the documentation example" do
-        list = AttrList.new([:name])
-        tuple = {:name => "Jones", :city => "London"}
-        list.project_tuple(tuple).should eq({:name => "Jones"})
-        list.project_tuple(tuple, true).should eq({:city => "London"})
-      end
-
-    end # project
-
-    it 'should to_a' do
-      AttrList[:a, :b].to_a.should eq([:a, :b])
-      AttrList[].to_a.should eq([])
-    end
-
-    it "should define a value" do
-      l1 = AttrList.new [:a, :b]
-      l2 = AttrList.new [:a, :b]
-      l3 = AttrList.new [:a]
-
-      l1.should == l2
-      l1.should eq(l2)
-
-      l1.should_not == l3
-      l1.should_not eq(l3)
-
-      {l1 => 1, l2 => 2}.size.should eq(1)
-    end
-
-  end
-end

data/spec/unit/alf-core/types/test_attr_name.rb

@@ -1,78 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe AttrName do
-
-    describe "===" do
-
-      it "should allow normal names" do
-        (AttrName === :city).should be_true
-      end
-
-      it "should allow underscores" do
-        (AttrName === :my_city).should be_true
-      end
-
-      it "should allow numbers" do
-        (AttrName === :city2).should be_true
-      end
-
-      it "should allow question marks and bang" do
-        (AttrName === :big?).should be_true
-        (AttrName === :big!).should be_true
-      end
-
-      it "should not allow strange attribute names" do
-        (AttrName === "$$$".to_sym).should be_false
-      end
-
-    end # ===
-
-    describe "coerce" do
-
-      it 'should work on valid attribute names' do
-        AttrName.coerce("city").should eq(:city)
-        AttrName.coerce(:big?).should eq(:big?)
-      end
-
-      it 'should be aliased as []' do
-        AttrName["city"].should eq(:city)
-      end
-
-      it 'should raise ArgumentError otherwise' do
-        lambda{ AttrName["!123"] }.should raise_error(ArgumentError)
-      end
-
-    end # coerce
-
-    describe "from_argv" do
-
-      subject{ AttrName.from_argv(argv, opts) }
-
-      describe "with a String" do
-        let(:argv){ %w{hello} }
-        let(:opts) {{}}
-        it{ should eq(:hello) }
-      end
-
-      describe "with nothing but a default" do
-        let(:argv){ %w{} }
-        let(:opts){ {:default => :hello} }
-        it{ should eq(:hello) }
-      end
-
-      describe "with nothing and no default" do
-        let(:argv){ %w{} }
-        let(:opts){ {} }
-        specify{ lambda{subject}.should raise_error(ArgumentError) }
-      end
-
-      describe "with more than one string" do
-        let(:argv){ %w{hello world} }
-        let(:opts){ {} }
-        specify{ lambda{subject}.should raise_error(ArgumentError) }
-      end
-
-    end # from_argv
-
-  end
-end

data/spec/unit/alf-core/types/test_boolean.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Boolean do
-
-    describe "from_argv" do
-
-      subject{ Boolean.from_argv(argv, opts) }
-
-      describe "with a String" do
-        let(:argv){ %w{true} }
-        let(:opts) {{}}
-        it{ should eq(true) }
-      end
-
-      describe "with nothing but a default" do
-        let(:argv){ %w{} }
-        let(:opts){ {:default => true} }
-        it{ should eq(true) }
-      end
-
-      describe "with nothing and no default" do
-        let(:argv){ %w{} }
-        let(:opts){ {} }
-        it{ should eq(false) }
-      end
-
-      describe "with an invalid string" do
-        let(:argv){ %w{hello} }
-        let(:opts){ {} }
-        specify{ lambda{subject}.should raise_error(ArgumentError) }
-      end
-
-      describe "with more than one string" do
-        let(:argv){ %w{hello world} }
-        let(:opts){ {} }
-        specify{ lambda{subject}.should raise_error(ArgumentError) }
-      end
-
-    end # from_argv
-
-  end
-end

data/spec/unit/alf-core/types/test_class_methods.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Types do
-    include Types
-
-    describe "common_super_type" do
-
-      it 'should work on same types' do
-        common_super_type(String, String).should eq(String)
-      end
-
-      it 'should work with related types' do
-        common_super_type(Fixnum, Integer).should eq(Integer)
-        common_super_type(Fixnum, Float).should eq(Numeric)
-      end
-
-      it 'should work with un related types' do
-        common_super_type(Fixnum, String).should eq(Object)
-      end
-
-    end
-
-  end # describe Types
-end # module Alf

data/spec/unit/alf-core/types/test_heading.rb

@@ -1,146 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Heading do
-
-    describe "the class itself" do
-      let(:type){ Heading }
-      def Heading.exemplars
-        [
-          {},
-          {:a => String},
-          {:a => String, :b => Date}
-        ].map{|x| Heading.coerce(x)}
-      end
-      it_should_behave_like 'A valid type implementation'
-    end
-
-    let(:h0){ Heading.new({}) }
-    let(:h1){ Heading.new(:name => String) }
-    let(:h2){ Heading.new(:name => String, :price => Float) }
-
-    it 'should be Enumerable' do
-      h2.map{|k,v| [k,v]}.to_set.should eq([[:name, String], [:price, Float]].to_set)
-    end
-
-    describe "coerce" do
-
-      it "should work with a heading" do
-        Heading.coerce(h0).should eq(h0)
-        Heading.coerce(h1).should eq(h1)
-      end
-
-      it "should work with hashes" do
-        Heading.coerce(:name => String).should eq(h1)
-        Heading.coerce("name" => "String").should eq(h1)
-        Heading.coerce({}).should eq(h0)
-      end
-
-      it "should work with arrays" do
-        Heading.coerce([]).should eq(h0)
-        Heading.coerce(["name", "String"]).should eq(h1)
-      end
-
-      specify "should raise ArgumentError on error" do
-        lambda{ Heading.coerce(true) }.should raise_error(ArgumentError)
-      end
-
-    end # coerce
-
-    describe "[]" do
-
-      specify "it should mimic coerce" do
-        Heading[:name => String].should eq(h1)
-        Heading["name" => "String"].should eq(h1)
-        Heading[{}].should eq(h0)
-        Heading[[]].should eq(h0)
-        Heading[["name", "String"]].should eq(h1)
-      end
-
-      specify "should raise ArgumentError on error" do
-        lambda{ Heading[true] }.should raise_error(ArgumentError)
-      end
-
-    end # []
-
-    describe "from_argv" do
-
-      it "should work with an array of strings" do
-        Heading.from_argv(["name", "String"]).should eq(h1)
-      end
-
-    end
-
-    describe "cardinality" do
-
-      it "should return the number of pairs" do
-        h0.cardinality.should eq(0)
-        h1.cardinality.should eq(1)
-        h2.cardinality.should eq(2)
-      end
-
-      it 'should be aliased as count' do
-        [h0, h1, h2].all?{|h| h.cardinality == h.count}.should be_true
-      end
-
-      it 'should be aliased as size' do
-        [h0, h1, h2].all?{|h| h.cardinality == h.size}.should be_true
-      end
-
-    end # cardinality, count, size
-
-    describe "union" do
-
-      let(:h_name){ Heading[:name => String] }
-      let(:h_city){ Heading[:city => String] }
-
-      it "should work on empty headings" do
-        Heading::EMPTY.union(Heading::EMPTY).should eq(Heading::EMPTY)
-      end
-
-      it "should work with disjoint headings" do
-        h_name.union(h_city).should eq(Heading[:name => String, :city => String])
-      end
-
-      it "should be aliased as +" do
-        (h_name + h_city).should eq(Heading[:name => String, :city => String])
-      end
-
-      it "should work compute supertype on non-disjoint headings" do
-        h1 = Heading[:age => Fixnum, :name => String]
-        h2 = Heading[:age => Integer]
-        (h1 + h2).should eq(Heading[:age => Integer, :name => String])
-      end
-
-      it "should be aliased as join" do
-        h1 = Heading[:age => Fixnum, :name => String]
-        h2 = Heading[:age => Integer]
-        h1.join(h2).should eq(Heading[:age => Integer, :name => String])
-      end
-
-    end # union
-
-    it "should implement a to_h method" do
-      h0.to_h.should eq({})
-      h1.to_h.should eq(:name => String)
-      h2.to_h.should eq(:name => String, :price => Float)
-    end
-
-    describe "EMPTY" do
-      subject{ Heading::EMPTY }
-      it{ should be_a(Heading) }
-      it_should_behave_like "A value"
-    end
-
-    describe "h0" do
-      subject{ h0 }
-      it { should == Heading::EMPTY }
-      it_should_behave_like "A value" 
-    end
-
-    describe "h1" do
-      subject{ h1 }
-      it_should_behave_like "A value" 
-    end
-
-  end 
-end