alf-shell 0.14.0 → 0.15.0

data/spec/unit/operator/test_project.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Project do
-
-    let(:input){ suppliers }
-    subject{ Project.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Algebra::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/operator/test_quota.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Quota do
-
-    let(:input){ suppliers }
-    subject{ Quota.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Algebra::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/operator/test_rank.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Rank do
-
-    let(:input){ suppliers }
-    subject{ Rank.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Algebra::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/operator/test_rename.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Rename do
-
-    let(:input){ suppliers }
-    subject{ Rename.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Algebra::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/operator/test_restrict.rb

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

data/spec/unit/operator/test_sort.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Sort do
-
-    let(:input){ suppliers }
-    subject{ Sort.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Algebra::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/operator/test_summarize.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Summarize do
-
-    let(:input){ suppliers }
-    subject{ Summarize.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Algebra::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/operator/test_ungroup.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Ungroup do
-
-    let(:input){ suppliers }
-    subject{ Ungroup.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Algebra::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/operator/test_union.rb

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

data/spec/unit/operator/test_unwrap.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Unwrap do
-
-    let(:input){ suppliers }
-    subject{ Unwrap.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Algebra::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/operator/test_wrap.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-module Alf::Shell::Operator
-  describe Wrap do
-
-    let(:input){ suppliers }
-    subject{ Wrap.run(argv) }
-
-    before do
-      subject.should be_a(Alf::Algebra::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