alf-core 0.15.0 → 0.16.0

data/spec/unit/alf-optimizer/test_autonum.rb

@@ -1,12 +0,0 @@
-require 'optimizer_helper'
-module Alf
-  describe "autonum" do
-
-    subject{ autonum(an_operand, :auto) }
-
-    let(:split_attributes){ AttrList[subject.as] }
-
-    it_should_behave_like "a split-able expression for restrict"
-
-  end
-end

data/spec/unit/alf-optimizer/test_clip.rb

@@ -1,10 +0,0 @@
-require 'optimizer_helper'
-module Alf
-  describe "clip" do
-
-    subject{ clip(an_operand, [:x, :y]) }
-
-    it_behaves_like "a pass-through expression for restrict"
-
-  end
-end

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

@@ -1,12 +0,0 @@
-require 'optimizer_helper'
-module Alf
-  describe "coerce" do
-
-    subject{ coerce(an_operand, :y => Integer) }
-
-    let(:split_attributes){ subject.coercions.to_attr_list }
-
-    it_should_behave_like "a split-able expression for restrict"
-
-  end
-end

data/spec/unit/alf-optimizer/test_compact.rb

@@ -1,10 +0,0 @@
-require 'optimizer_helper'
-module Alf
-  describe "compact" do
-
-    subject{ compact(an_operand) }
-
-    it_behaves_like "a pass-through expression for restrict"
-
-  end
-end

data/spec/unit/alf-optimizer/test_defaults.rb

@@ -1,12 +0,0 @@
-require 'optimizer_helper'
-module Alf
-  describe "defaults" do
-
-    subject{ defaults(an_operand, :y => 12) }
-
-    let(:split_attributes){ subject.defaults.to_attr_list }
-
-    it_should_behave_like "a split-able expression for restrict"
-
-  end
-end

data/spec/unit/alf-optimizer/test_extend.rb

@@ -1,12 +0,0 @@
-require 'optimizer_helper'
-module Alf
-  describe "extend" do
-
-    subject{ extend(an_operand, :y => "x.upcase") }
-
-    let(:split_attributes){ subject.ext.to_attr_list }
-
-    it_should_behave_like "a split-able expression for restrict"
-
-  end
-end

data/spec/unit/alf-optimizer/test_generator.rb

@@ -1,9 +0,0 @@
-require 'optimizer_helper'
-module Alf
-  describe "generator" do
-
-    subject{ generator(10, :auto) }
-
-    it_should_behave_like "an unoptimizable expression for restrict"
-  end
-end

data/spec/unit/alf-optimizer/test_group.rb

@@ -1,12 +0,0 @@
-require 'optimizer_helper'
-module Alf
-  describe "group" do
-
-    subject{ group(an_operand, [:x, :y], :z) }
-
-    let(:split_attributes){ AttrList[subject.as] }
-
-    it_should_behave_like "a split-able expression for restrict"
-
-  end
-end

data/spec/unit/alf-optimizer/test_intersect.rb

@@ -1,10 +0,0 @@
-require 'optimizer_helper'
-module Alf
-  describe "intersect" do
-
-    subject{ intersect(an_operand, an_operand) }
-
-    it_behaves_like "a pass-through expression for restrict"
-
-  end
-end

data/spec/unit/alf-optimizer/test_minus.rb

@@ -1,10 +0,0 @@
-require 'optimizer_helper'
-module Alf
-  describe "minus" do
-
-    subject{ minus(an_operand, an_operand) }
-
-    it_behaves_like "a pass-through expression for restrict"
-
-  end
-end

data/spec/unit/alf-optimizer/test_project.rb

@@ -1,10 +0,0 @@
-require 'optimizer_helper'
-module Alf
-  describe "project" do
-
-    subject{ project(an_operand, [:x, :y]) }
-
-    it_behaves_like "a pass-through expression for restrict"
-
-  end
-end

data/spec/unit/alf-optimizer/test_quota.rb

@@ -1,16 +0,0 @@
-require 'optimizer_helper'
-module Alf
-  describe "quota" do
-
-    let(:summarization){
-      Summarization.coerce(:total => Aggregator.sum{ qty })
-    }
-
-    subject{ quota(an_operand, [:id], [[:x, :asc]], summarization) }
-
-    let(:split_attributes){ subject.summarization.to_attr_list }
-
-    it_should_behave_like "a split-able expression for restrict"
-
-  end
-end

data/spec/unit/alf-optimizer/test_rank.rb

@@ -1,12 +0,0 @@
-require 'optimizer_helper'
-module Alf
-  describe "rank" do
-
-    subject{ rank(an_operand, [[:x, :asc]], :rank) }
-
-    let(:split_attributes){ AttrList[subject.as] }
-
-    it_should_behave_like "a split-able expression for restrict"
-
-  end
-end

data/spec/unit/alf-optimizer/test_rename.rb

@@ -1,26 +0,0 @@
-require 'optimizer_helper'
-module Alf
-  describe "rename" do
-
-    subject{ rename(an_operand, renaming) }
-
-    context 'on a fully known predicate' do
-      let(:predicate){ Predicate.eq(:y, 2) & Predicate.eq(:foo => 3) }
-      let(:renaming) { {:x => :y} }
-
-      let(:replaced_predicate){
-        Predicate.eq(:x, 2) & Predicate.eq(:foo => 3)
-      }
-
-      it_behaves_like "a pass-through expression for restrict"
-    end
-
-    context 'on a native predicate' do
-      let(:predicate){ Predicate.native(->(t){ t.x == 2 }) }
-      let(:renaming) { {:x => :y} }
-
-      it_behaves_like "an unoptimizable expression for restrict"
-    end
-
-  end
-end

data/spec/unit/alf-optimizer/test_sort.rb

@@ -1,10 +0,0 @@
-require 'optimizer_helper'
-module Alf
-  describe "sort" do
-
-    subject{ sort(an_operand, [[:x, :asc]]) }
-
-    it_behaves_like "a pass-through expression for restrict"
-
-  end
-end

data/spec/unit/alf-optimizer/test_summarize.rb

@@ -1,15 +0,0 @@
-require 'optimizer_helper'
-module Alf
-  describe "summarize" do
-
-    let(:summarization){
-      Summarization.coerce(:total => Aggregator.sum{ qty })
-    }
-    subject{ summarize(an_operand, [:id], summarization) }
-
-    let(:split_attributes){ subject.summarization.to_attr_list }
-
-    it_should_behave_like "a split-able expression for restrict"
-
-  end
-end

data/spec/unit/alf-optimizer/test_union.rb

@@ -1,10 +0,0 @@
-require 'optimizer_helper'
-module Alf
-  describe "union" do
-
-    subject{ union(an_operand, an_operand) }
-
-    it_behaves_like "a pass-through expression for restrict"
-
-  end
-end

data/spec/unit/alf-optimizer/test_wrap.rb

@@ -1,12 +0,0 @@
-require 'optimizer_helper'
-module Alf
-  describe "wrap" do
-
-    subject{ wrap(an_operand, [:x, :y], :z) }
-
-    let(:split_attributes){ AttrList[subject.as] }
-
-    it_should_behave_like "a split-able expression for restrict"
-
-  end
-end

data/spec/unit/alf-predicate/expr/test_to_proc.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Predicate
-    describe Expr, "to_proc" do
-
-      let(:expr){ Factory.lte(:x, 2) }
-
-      subject{ expr.to_proc }
-
-      it{ should be_a(Proc) }
-
-      it 'has arity 1' do
-        subject.arity.should eq(1)
-      end
-
-    end
-  end
-end

data/spec/unit/alf-predicate/expr/test_to_ruby_code.rb

@@ -1,154 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Predicate
-    describe Expr, "to_ruby_code" do
-
-      let(:f){ Factory }
-
-      subject{ expr.to_ruby_code }
-
-      after do
-        unless expr.is_a?(Native)
-          lambda{
-            eval(subject)
-          }.should_not raise_error
-        end
-      end
-
-      context 'tautology' do
-        let(:expr){ f.tautology }
-
-        it{ should eq("->(t){ true }") }
-      end
-
-      context 'contradiction' do
-        let(:expr){ f.contradiction }
-
-        it{ should eq("->(t){ false }") }
-      end
-
-      describe "identifier" do
-        let(:expr){ f.identifier(:name) }
-
-        it{ should eq("->(t){ t.name }") }
-      end
-
-      describe "and" do
-        let(:expr){ f.and(f.contradiction, f.contradiction) }
-
-        it{ should eq("->(t){ false && false }") }
-      end
-
-      describe "or" do
-        let(:expr){ f.or(f.contradiction, f.contradiction) }
-
-        it{ should eq("->(t){ false || false }") }
-      end
-
-      describe "not" do
-        let(:expr){ f.not(f.contradiction) }
-
-        it{ should eq("->(t){ !false }") }
-      end
-
-      describe "comp" do
-        let(:expr){ f.comp(:lt, {:x => 2}) }
-
-        it{ should eq("->(t){ t.x < 2 }") }
-      end
-
-      describe "eq" do
-        let(:expr){ f.eq(:x, 2) }
-
-        it{ should eq("->(t){ t.x == 2 }") }
-      end
-
-      describe "eq (parentheses required)" do
-        let(:expr){ f.eq(f.eq(:y, 2), true) }
-
-        it{ should eq("->(t){ (t.y == 2) == true }") }
-      end
-
-      describe "comp (multiple)" do
-        let(:expr){ f.comp(:eq, :x => 2, :y => 3) }
-
-        it{ should eq("->(t){ (t.x == 2) && (t.y == 3) }") }
-      end
-
-      describe "in" do
-        let(:expr){ f.in(:x, [2, 3]) }
-
-        it{ should eq("->(t){ [2, 3].include?(t.x) }") }
-      end
-
-      describe "neq" do
-        let(:expr){ f.neq(:x, 2) }
-
-        it{ should eq("->(t){ t.x != 2 }") }
-      end
-
-      describe "gt" do
-        let(:expr){ f.gt(:x, 2) }
-
-        it{ should eq("->(t){ t.x > 2 }") }
-      end
-
-      describe "gte" do
-        let(:expr){ f.gte(:x, 2) }
-
-        it{ should eq("->(t){ t.x >= 2 }") }
-      end
-
-      describe "lt" do
-        let(:expr){ f.lt(:x, 2) }
-
-        it{ should eq("->(t){ t.x < 2 }") }
-      end
-
-      describe "lte" do
-        let(:expr){ f.lte(:x, 2) }
-
-        it{ should eq("->(t){ t.x <= 2 }") }
-      end
-
-      describe "literal" do
-        let(:expr){ f.literal(12) }
-
-        it{ should eq("->(t){ 12 }") }
-      end
-
-      describe "native" do
-        let(:expr){ f.native(lambda{}) }
-
-        specify{
-          lambda{ subject }.should raise_error(NotSupportedError)
-        }
-      end
-
-      describe "conjunction of two eqs" do
-        let(:expr){
-          f.and(f.eq(:x, 2), f.eq(:y, 3))
-        }
-
-        it{ should eq("->(t){ (t.x == 2) && (t.y == 3) }") }
-      end
-
-      describe "conjunction of two comps" do
-        let(:expr){
-          f.and(f.comp(:eq, :x => 2), f.comp(:eq, :y => 3))
-        }
-
-        it{ should eq("->(t){ (t.x == 2) && (t.y == 3) }") }
-      end
-
-      describe "or and and" do
-        let(:expr){
-          f.and(f.eq(:x, 2), f.or(true, false))
-        }
-
-        it{ should eq("->(t){ (t.x == 2) && (true || false) }") }
-      end
-
-    end
-  end
-end

data/spec/unit/alf-predicate/factory/shared/a_comparison_factory_method.rb

@@ -1,35 +0,0 @@
-require_relative 'a_predicate_ast_node'
-shared_examples_for "a comparison factory method" do
-  include Alf::Predicate::Factory
-
-  context 'with two operands' do
-    subject{ self.send(method, true, true) }
-
-    it_should_behave_like "a predicate AST node"
-    it{ should be_a(node_class) }
-    it{ should eql([method, tautology, tautology]) }
-  end
-
-  context 'with a Hash operand (singleton)' do
-    subject{ self.send(method, :x => :y) }
-    let(:expected){
-      [method, [:identifier, :x], [:identifier, :y]]
-    }
-
-    it_should_behave_like "a predicate AST node"
-    it{ should eql(expected) }
-  end
-
-  context 'with a Hash operand' do
-    subject{ self.send(method, :x => :y, :v => 2) }
-    let(:expected){
-      [:and,
-        [method, [:identifier, :x], [:identifier, :y]],
-        [method, [:identifier, :v], [:literal, 2]]]
-    }
-
-    it_should_behave_like "a predicate AST node"
-    it{ should eql(expected) }
-  end
-
-end