alf 0.12.2 → 0.13.0

data/spec/unit/alf-shell/operator/test_heading.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Heading do
-
-    let(:input){ [] }
-    subject{ Heading.run(argv) }
-
-    context "the default config" do
-      let(:argv){ [input] }
-      specify{
-        subject.should be_a(Alf::Operator::Relational::Heading)
-      }
-    end
-
-  end
-end

data/spec/unit/alf-shell/operator/test_intersect.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Intersect do
-
-    let(:left) { [{:left  => true}] }
-    let(:right){ [{:right => true}] }
-    subject{ Intersect.run(argv) }
-
-    context "the default config" do
-      let(:argv){ [left, right] }
-      specify{
-        subject.should be_a(Alf::Operator::Relational::Intersect)
-        subject.operands.should eq([left, right])
-      }
-    end
-
-  end
-end

data/spec/unit/alf-shell/operator/test_join.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Join do
-
-    let(:left) { [{:left  => true}] }
-    let(:right){ [{:right => true}] }
-    subject{ Join.run(argv) }
-
-    context "the default config" do
-      let(:argv){ [left, right] }
-      specify{
-        subject.should be_a(Alf::Operator::Relational::Join)
-        subject.operands.should eq([left, right])
-      }
-    end
-
-  end
-end

data/spec/unit/alf-shell/operator/test_matching.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Matching do
-
-    let(:left) { [{:left  => true}] }
-    let(:right){ [{:right => true}] }
-    subject{ Matching.run(argv) }
-
-    context "the default config" do
-      let(:argv){ [left, right] }
-      specify{
-        subject.should be_a(Alf::Operator::Relational::Matching)
-        subject.operands.should eq([left, right])
-      }
-    end
-
-  end
-end

data/spec/unit/alf-shell/operator/test_minus.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Minus do
-
-    let(:left) { [{:left  => true}] }
-    let(:right){ [{:right => true}] }
-    subject{ Minus.run(argv) }
-
-    context "the default config" do
-      let(:argv){ [left, right] }
-      specify{
-        subject.should be_a(Alf::Operator::Relational::Minus)
-        subject.operands.should eq([left, right])
-      }
-    end
-
-  end
-end

data/spec/unit/alf-shell/operator/test_not_matching.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe NotMatching do
-
-    let(:left) { [{:left  => true}] }
-    let(:right){ [{:right => true}] }
-    subject{ NotMatching.run(argv) }
-
-    context "the default config" do
-      let(:argv){ [left, right] }
-      specify{
-        subject.should be_a(Alf::Operator::Relational::NotMatching)
-        subject.operands.should eq([left, right])
-      }
-    end
-
-  end
-end

data/spec/unit/alf-shell/operator/test_project.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Project do
-
-    let(:input){ [] }
-    subject{ Project.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Operator::Relational::Project)
-      subject.operands.should eq([input])
-    end
-
-    context "--no-allbut" do
-      let(:argv){ [input, "--", "a", "b"] }
-      specify{
-        subject.attributes.should eq(Alf::AttrList[:a, :b])
-        subject.allbut.should eq(false)
-      }
-    end
-
-    context "--allbut" do
-      let(:argv){ [input, "--allbut", "--", "a", "b"] }
-      specify{
-        subject.attributes.should eq(Alf::AttrList[:a, :b])
-        subject.allbut.should eq(true)
-      }
-    end
-
-    context "none projected" do
-      let(:argv){ [input] }
-      specify{
-        subject.attributes.should eq(Alf::AttrList[])
-        subject.allbut.should eq(false)
-      }
-    end
-
-  end
-end

data/spec/unit/alf-shell/operator/test_quota.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Quota do
-
-    let(:input){ [] }
-    subject{ Quota.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Operator::Relational::Quota)
-      subject.operands.should eq([input])
-    end
-
-    context "a typical config" do
-      let(:argv){ [input] + ["--", "a", "--", "time", "--", "time_sum", "sum{ time }"] }
-      specify{
-        subject.by.should eq(Alf::AttrList[:a])
-        subject.order.should eq(Alf::Ordering[[:time, :asc]])
-        subject.summarization.should eq(Alf::Summarization[:time_sum => "sum{ time }"])
-      }
-    end
-
-  end
-end

data/spec/unit/alf-shell/operator/test_rank.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Rank do
-
-    let(:input){ [] }
-    subject{ Rank.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Operator::Relational::Rank)
-      subject.operands.should eq([input])
-    end
-
-    context "without name" do
-      let(:argv){ [input, "--", "time"] }
-      specify{
-        subject.order.should eq(Alf::Ordering[[:time, :asc]])
-        subject.as.should eq(:rank)
-      }
-    end
-
-    context "with explicit name" do
-      let(:argv){ [input, "--","time", "desc", "--", "newname"] }
-      specify{
-        subject.order.should eq(Alf::Ordering[[:time, :desc]])
-        subject.as.should eq(:newname)
-      }
-    end
-
-  end
-end

data/spec/unit/alf-shell/operator/test_rename.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Rename do
-
-    let(:input){ [] }
-    subject{ Rename.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Operator::Relational::Rename)
-      subject.operands.should eq([input])
-    end
-
-    context "a typical config" do
-      let(:argv){ [input, '--', 'a', 'z'] }
-      specify{
-        subject.renaming.should eq(Alf::Renaming[:a => :z])
-      }
-    end
-
-  end
-end

data/spec/unit/alf-shell/operator/test_restrict.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Restrict do
-
-    let(:input){ [] }
-    subject{ Restrict.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Operator::Relational::Restrict)
-      subject.operands.should eq([input])
-    end
-
-    context "without arg" do
-      let(:argv){ [input] }
-      specify{
-        subject.predicate.should eq(Alf::TuplePredicate[true])
-      }
-    end
-
-    context "with a single arg" do
-      let(:argv){ [ input ] + ["--", "status > 10"] }
-      specify{
-        subject.predicate.should eq(Alf::TuplePredicate["status > 10"])
-      }
-    end
-
-    context "with two args" do
-      let(:argv){ [ input ] + ["--", "status", "10"] }
-      specify{
-        subject.predicate.should eq(Alf::TuplePredicate["(self.status == 10)"])
-      }
-    end
-
-  end
-end

data/spec/unit/alf-shell/operator/test_sort.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Sort do
-
-    let(:input){ [] }
-    subject{ Sort.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Operator::NonRelational::Sort)
-      subject.operands.should eq([input])
-    end
-
-    context "with empty args" do
-      let(:argv){ [input] + %w{} }
-      specify{
-        subject.ordering.should eq(Alf::Ordering.new([]))
-      }
-    end
-
-    context "with one arg" do
-      let(:argv){ [input] + %w{-- name} }
-      specify{
-        subject.ordering.should eq(Alf::Ordering[[:name, :asc]])
-      }
-    end
-
-    context "with two args" do
-      let(:argv){ [input] + %w{-- first last} }
-      specify{
-        subject.ordering.should eq(Alf::Ordering[[[:first, :asc], [:last, :asc]]])
-      }
-    end
-
-    context "with explicit ordering" do
-      let(:argv){ [input] + %w{-- first desc} }
-      specify{
-        subject.ordering.should eq(Alf::Ordering[[[:first, :desc]]])
-      }
-    end
-
-    context "with explicit ordering on multiple" do
-      let(:argv){ [input] + %w{-- first desc last asc} }
-      specify{
-        subject.ordering.should eq(Alf::Ordering[[[:first, :desc], [:last, :asc]]])
-      }
-    end
-
-  end
-end

data/spec/unit/alf-shell/operator/test_summarize.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Summarize do
-
-    let(:input){ [] }
-    subject{ Summarize.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Operator::Relational::Summarize)
-      subject.operands.should eq([input])
-      subject.by.should eq(Alf::AttrList[:a])
-      subject.summarization.should eq(Alf::Summarization[:time_sum => "sum{ time }"])
-    end
-
-    context "--no-allbut" do
-      let(:argv){ [input] + ["--", "a", "--", "time_sum", "sum{ time }"] }
-      specify{
-        subject.allbut.should eq(false)
-      }
-    end
-
-    context "--allbut" do
-      let(:argv){ [input] + ["--allbut", "--", "a", "--", "time_sum", "sum{ time }"] }
-      specify{
-        subject.allbut.should eq(true)
-      }
-    end
-
-  end
-end

data/spec/unit/alf-shell/operator/test_ungroup.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Ungroup do
-
-    let(:input){ [] }
-    subject{ Ungroup.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Operator::Relational::Ungroup)
-      subject.operands.should eq([input])
-    end
-
-    context "without name" do
-      let(:argv){ [input] }
-      specify{
-        subject.attribute.should eq(:grouped)
-      }
-    end
-
-    context "with a name" do
-      let(:argv){ [input] + %w{-- attrname} }
-      specify{
-        subject.attribute.should eq(:attrname)
-      }
-    end
-
-  end
-end

data/spec/unit/alf-shell/operator/test_union.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Union do
-
-    let(:left) { [{:left  => true}] }
-    let(:right){ [{:right => true}] }
-    subject{ Union.run(argv) }
-
-    context "the default config" do
-      let(:argv){ [left, right] }
-      specify{
-        subject.should be_a(Alf::Operator::Relational::Union)
-        subject.operands.should eq([left, right])
-      }
-    end
-
-  end
-end

data/spec/unit/alf-shell/operator/test_unwrap.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Unwrap do
-
-    let(:input){ [] }
-    subject{ Unwrap.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Operator::Relational::Unwrap)
-      subject.operands.should eq([input])
-    end
-
-    context "without name" do
-      let(:argv){ [input] }
-      specify{
-        subject.attribute.should eq(:wrapped)
-      }
-    end
-
-    context "with a name" do
-      let(:argv){ [input] + %w{-- attrname} }
-      specify{
-        subject.attribute.should eq(:attrname)
-      }
-    end
-
-  end
-end

data/spec/unit/alf-shell/operator/test_wrap.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Wrap do
-
-    let(:input){ [] }
-    subject{ Wrap.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Operator::Relational::Wrap)
-      subject.operands.should eq([input])
-    end
-
-    context "without name" do
-      let(:argv){ [input, "--", "a", "b"] }
-      specify{
-        subject.attributes.should eq(Alf::AttrList[:a, :b])
-        subject.as.should eq(:wrapped)
-      }
-    end
-
-    context "with a name" do
-      let(:argv){ [input, "--", "a", "b", "--", "attrname"] }
-      specify{
-        subject.attributes.should eq(Alf::AttrList[:a, :b])
-        subject.as.should eq(:attrname)
-      }
-    end
-
-  end
-end