alf-core 0.15.0 → 0.16.0

data/spec/unit/alf-types/renaming/test_complete.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Renaming, "complete" do
-
-    let(:renaming){ Renaming[:old => :new, :foo => :bar] }
-
-    subject{ renaming.complete(AttrList[:old, :blah]) }
-
-    let(:expected){ Renaming[:old => :new, :foo => :bar, :blah => :blah] }
-
-    it{ should eq(expected) }
-
-  end
-end

data/spec/unit/alf-types/renaming/test_invert.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Renaming, "invert" do
-
-    let(:renaming){ Renaming[:old => :new, :foo => :bar] }
-
-    let(:expected){ Renaming[:new => :old, :bar => :foo] }
-
-    subject{ renaming.invert }
-
-    it{ should eq(expected) }
-
-  end
-end

data/spec/unit/alf-types/renaming/test_rename_attr_list.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Renaming, "rename_attr_list" do
-
-    let(:renaming){ Renaming[:old => :new, :foo => :bar] }
-
-    let(:expected){ AttrList[:bar, :new, :name] }
-
-    subject{ renaming.rename_attr_list(attr_list) }
-
-    context 'on an attribute list' do
-      let(:attr_list){ AttrList[:foo, :old, :name] }
-
-      it{ should eq(expected) }
-    end
-
-    context 'on an Array of names' do
-      let(:attr_list){ [:foo, :old, :name] }
-
-      it{ should eq(expected) }
-    end
-
-  end
-end

data/spec/unit/alf-types/renaming/test_rename_tuple.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Renaming, "rename_tuple" do
-
-    let(:r){ Renaming.coerce(["old", "new"]) } 
-
-    it 'should rename correctly' do
-      tuple    = {:old => :a, :other => :b}
-      expected = {:new => :a, :other => :b}
-      r.rename_tuple(tuple).should eq(expected)
-    end
-
-  end # Renaming
-end # Alf

data/spec/unit/alf-types/renaming/test_to_attr_list.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Renaming, "to_attr_list" do
-
-    let(:renaming){ Renaming[:old => :new, :foo => :bar] }
-
-    subject{ renaming.to_attr_list }
-
-    let(:expected){ AttrList[:old, :foo] }
-
-    it{ should eq(expected) }
-
-  end
-end

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

@@ -1,38 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Selection, ".coerce" do
-
-    subject{ Selection.coerce(arg) }
-
-    before do
-      subject.should be_a(Selection)
-    end
-
-    let(:expected){
-      Selection.new([ Selector.new(:name), Selector.new(:city) ])
-    }
-
-    context 'on an array of strings' do
-      let(:arg){ ["name", "city"] }
-
-      it { should eq(expected) }
-    end
-
-    context 'on an array of strings with composite selections' do
-      let(:arg){ ["name", "city.name"] }
-
-      let(:expected){
-        Selection.new([ Selector.new(:name), Selector.new([:city, :name]) ])
-      }
-
-      it { should eq(expected) }
-    end
-
-    context 'on an array of symbols' do
-      let(:arg){ [:name, :city] }
-
-      it { should eq(expected) }
-    end
-
-  end
-end

data/spec/unit/alf-types/selection/test_select.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Selection, "select" do
-
-    subject{ selection.select(tuple) }
-
-    let(:tuple){ {name: "foo", city: {name: "bar"}} }
-
-    context 'on a selection of name' do
-      let(:selection){ Selection.coerce(["name"]) }
-
-      it{ should eq(["foo"]) }
-    end
-
-    context 'on a selection of city' do
-      let(:selection){ Selection.coerce(["city"]) }
-
-      it{ should eq([{name: "bar"}]) }
-    end
-
-    context 'on a selection of city.name' do
-      let(:selection){ Selection.coerce(["city.name"]) }
-
-      it{ should eq(["bar"]) }
-    end
-
-    context 'on a selection of name and city.name' do
-      let(:selection){ Selection.coerce(["name", "city.name"]) }
-
-      it{ should eq(["foo","bar"]) }
-    end
-
-  end
-end

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

@@ -1,36 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Selector, ".coerce" do
-
-    subject{ Selector.coerce(arg) }
-
-    before do
-      subject.should be_a(Selector)
-    end
-
-    context 'on a Symbol' do
-      let(:arg){ :name }
-
-      it { should eq(Selector.new(:name)) }
-    end
-
-    context 'on a single string' do
-      let(:arg){ "name" }
-
-      it { should eq(Selector.new(:name)) }
-    end
-
-    context 'on a composite string' do
-      let(:arg){ "a.name" }
-
-      it { should eq(Selector.new([:a, :name])) }
-    end
-
-    context 'on an array of strings' do
-      let(:arg){ ["a", "name"] }
-
-      it { should eq(Selector.new([:a, :name])) }
-    end
-
-  end
-end

data/spec/unit/alf-types/selector/test_composite_q.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Selector, "composite?" do
-
-    subject{ selector.composite? }
-
-    context 'on a single' do
-      let(:selector){ Selector.coerce(:name) }
-
-      it { should be_false }
-    end
-
-    context 'on a composite' do
-      let(:selector){ Selector.coerce([:a, :name]) }
-
-      it { should be_true }
-    end
-
-  end
-end

data/spec/unit/alf-types/selector/test_dive.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Selector, "dive" do
-
-    subject{ selector.dive(:a) }
-
-    context 'on a single, not the same' do
-      let(:selector){ Selector.coerce(:name) }
-
-      it { should be_nil }
-    end
-
-    context 'on a single, same' do
-      let(:selector){ Selector.coerce(:a) }
-
-      it { should be_nil }
-    end
-
-    context 'on a composite, starting with' do
-      let(:selector){ Selector.coerce([:a, :b, :c]) }
-
-      it { should eq(Selector.coerce([:b, :c])) }
-    end
-
-    context 'on a composite, not starting with' do
-      let(:selector){ Selector.coerce([:b, :a]) }
-
-      it { should be_nil }
-    end
-
-  end
-end

data/spec/unit/alf-types/selector/test_select.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Selector, "select" do
-
-    subject{ selector.select(tuple) }
-
-    let(:tuple){ {name: "foo", city: {name: "bar"}} }
-
-    context 'on name' do
-      let(:selector){ Selector.coerce("name") }
-
-      it{ should eq("foo") }
-    end
-
-    context 'on city' do
-      let(:selector){ Selector.coerce("city") }
-
-      it{ should eq(name: "bar") }
-    end
-
-    context 'on unexisting' do
-      let(:selector){ Selector.coerce("unexisting") }
-
-      it{ should be_nil }
-    end
-
-    context 'on unexisting composite' do
-      let(:selector){ Selector.coerce("city.unexisting") }
-
-      it{ should be_nil }
-    end
-
-    context 'on unexisting composite II' do
-      let(:selector){ Selector.coerce("cities.unexisting") }
-
-      it{ should be_nil }
-    end
-
-  end
-end

data/spec/unit/alf-types/selector/test_simple_q.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Selector, "simple?" do
-
-    subject{ selector.simple? }
-
-    context 'on a single' do
-      let(:selector){ Selector.coerce(:name) }
-
-      it { should be_true }
-    end
-
-    context 'on a composite' do
-      let(:selector){ Selector.coerce([:a, :name]) }
-
-      it { should be_false }
-    end
-
-  end
-end

data/spec/unit/alf-types/selector/test_to_a.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Selector, "to_a" do
-
-    subject{ selector.to_a }
-
-    context 'on a single' do
-      let(:selector){ Selector.coerce(:name) }
-
-      it { should eq([:name]) }
-    end
-
-    context 'on a composite' do
-      let(:selector){ Selector.coerce([:a, :name]) }
-
-      it { should eq([:a, :name]) }
-    end
-
-  end
-end

data/spec/unit/alf-types/selector/test_to_lispy.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Selector, "to_lispy" do
-
-    subject{ selector.to_lispy }
-
-    context 'on a single' do
-      let(:selector){ Selector.coerce(:name) }
-
-      it { should eq(':name') }
-    end
-
-    context 'on a composite' do
-      let(:selector){ Selector.coerce([:a, :name]) }
-
-      it { should eq('[:a, :name]') }
-    end
-
-  end
-end

data/spec/unit/alf-types/selector/test_to_ruby_literal.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Selector, "to_ruby_literal" do
-
-    subject{ selector.to_ruby_literal }
-
-    context 'on a single' do
-      let(:selector){ Selector.coerce(:name) }
-
-      it { should eq('Alf::Selector[:name]') }
-    end
-
-    context 'on a composite' do
-      let(:selector){ Selector.coerce([:a, :name]) }
-
-      it { should eq('Alf::Selector[[:a, :name]]') }
-    end
-
-  end
-end

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

@@ -1,23 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Types
-    describe Size, "coerce" do
-
-      it 'should coerce strings correctly' do
-        Size.coerce("0").should eq(0)
-        Size.coerce("10").should eq(10)
-      end
-
-      it 'should raise TypeError on negative integers' do
-        lambda{ Size.coerce("-1") }.should raise_error(TypeError)
-      end
-
-      it 'should raise on non integers' do
-        lambda{
-          Size.coerce("hello")
-        }.should raise_error(TypeError)
-      end
-
-    end
-  end
-end

data/spec/unit/alf-types/size/test_triple_equal.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Types
-    describe Size, "===" do
-
-      it 'should recognize 0' do
-        (Size === 0).should be_true
-      end
-
-      it 'should recognize any positive integer' do
-        (Size === 10).should be_true
-      end
-
-      it 'should not recognize negative integers' do
-        (Size === -1).should be_false
-      end
-
-      it 'should not recognize non integers' do
-        (Size === 10.0).should be_false
-        (Size === "12").should be_false
-      end
-
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Summarization, "coerce" do
-
-    subject{ Summarization.coerce(arg) }
-
-    describe "from a Summarization" do
-      let(:arg){ Summarization.new(:s => Aggregator.sum{ qty }) }
-      it{ should eq(arg) }
-    end
-
-    describe "from a Hash" do
-      let(:arg){ { :s => Aggregator.sum{ qty }, :m => Aggregator.max{ size } } }
-      it{ should be_a(Summarization) }
-      specify{ 
-        subject.to_hash.keys.to_set.should eq([:s, :m].to_set)
-        subject.to_hash.values.all?{|v| v.should be_a(Aggregator) }
-      }
-    end
-
-    describe "from an Array" do
-      let(:arg){ ["s", Aggregator.sum{ qty }, "m", Aggregator.max{ size }] }
-      it{ should be_a(Summarization) }
-      specify{ 
-        subject.to_hash.keys.to_set.should eq([:s, :m].to_set)
-        subject.to_hash.values.all?{|v| v.should be_a(Aggregator) }
-      }
-    end
-
-  end
-end