alf-shell 0.13.0

data/spec/unit/from_argv/test_to_size.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+module Alf
+  describe Shell, ".from_argv(argv, Size)" do
+
+    subject{ Shell.from_argv(argv, Size) }
+
+    context 'on an empty array' do
+      let(:argv){ [ ] }
+      it{ should eq(0) }
+    end
+
+    context 'with a single string' do
+      let(:argv){ [ "12" ] }
+      it{ should eq(12) }
+    end
+
+    context 'on a big array' do
+      let(:argv){ ["12", "hello"] }
+      specify{
+        lambda{ subject }.should raise_error(Myrrha::Error)
+      }
+    end
+
+    context 'when not coercable' do
+      let(:argv){ ["hello"] }
+      specify{ 
+        lambda{ subject }.should raise_error(Myrrha::Error)
+      }
+    end
+
+  end
+end

data/spec/unit/from_argv/test_to_summarization.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+module Alf
+  describe Shell, ".from_argv(argv, Summarization)" do
+
+    subject{ Shell.from_argv(argv, Summarization) }
+
+    context "from an Array" do
+      let(:argv){ ["s", "sum{ qty }", "m", "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

data/spec/unit/from_argv/test_to_tuple_computation.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Alf
+  describe Shell, ".from_argv(argv, TupleComputation)" do
+
+    subject{ Shell.from_argv(argv, TupleComputation) }
+
+    describe "from an Array with coercions" do
+      let(:argv){ ["hello", "who", "hello2", "2"] }
+      let(:expected){
+        TupleComputation.new(
+          :hello => Alf::TupleExpression.coerce("who"), 
+          :hello2 => Alf::TupleExpression.coerce("2"))
+      }
+      it{ should eql(expected) }
+    end
+
+  end
+end

data/spec/unit/from_argv/test_to_tuple_expression.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+module Alf
+  describe Shell, ".from_argv(argv, TupleExpression)" do
+
+    let(:scope) {
+      Support::TupleScope.new(:status => 10)
+    }
+
+    subject{ Shell.from_argv(argv, TupleExpression) }
+
+    context "with a String (1)" do
+      let(:argv){ %w{true} }
+      it { should be_a(TupleExpression) }
+      specify{
+        subject.evaluate(scope).should eql(true)
+        subject.source.should eq("true")
+      }
+    end
+
+    context "with a String (2)" do
+      let(:argv){ ["status > 10"] }
+      it { should be_a(TupleExpression) }
+      specify{
+        subject.evaluate(scope).should eql(false)
+        subject.source.should eq("status > 10")
+      }
+    end
+
+    context "with two String" do
+      let(:argv){ %w{hello world} }
+      specify{
+        lambda{ subject }.should raise_error(Myrrha::Error)
+      }
+    end
+
+
+  end
+end

data/spec/unit/main/test_class_methods.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+module Alf
+  module Shell
+    describe Main, "class methods for doc" do
+
+      specify "relational_operators" do
+        Shell::Main.relational_operators.should_not be_empty
+        Shell::Main.relational_operators.each do |cmd|
+          cmd.should_not be_command
+          cmd.should be_operator
+          cmd.should respond_to(:run)
+        end
+      end
+
+      specify "experimental_operators" do
+        Shell::Main.experimental_operators.should_not be_empty
+        Shell::Main.experimental_operators.each do |cmd|
+          cmd.should_not be_command
+          cmd.should be_operator
+          cmd.should respond_to(:run)
+        end
+      end
+
+      specify "non_relational_operators" do
+        Shell::Main.non_relational_operators.should_not be_empty
+        Shell::Main.non_relational_operators.each do |cmd|
+          cmd.should_not be_command
+          cmd.should be_operator
+          cmd.should respond_to(:run)
+        end
+      end
+
+      specify "other_non_relational_commands" do
+        Shell::Main.other_non_relational_commands.should_not be_empty
+        Shell::Main.other_non_relational_commands.each do |cmd|
+          cmd.should be_command
+          cmd.should_not be_operator
+          cmd.should respond_to(:run)
+        end
+      end
+        
+    end # class methods for doc
+  end # module Shell
+end # module Alf

data/spec/unit/operator/test_autonum.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module Alf::Shell::Operator
+  describe Autonum do
+
+    let(:input){ suppliers }
+    subject{ Autonum.run(argv) }
+
+    before do
+      subject.should be_a(Alf::Algebra::Autonum)
+      subject.operands.should eq([input])
+    end
+
+    context "with default attribute name" do
+      let(:argv){ [input] }
+      specify{
+        subject.as.should eq(:autonum)
+      }
+    end
+
+    context "with explicit attribute name" do
+      let(:argv){ [input, "--", "unique"] }
+      specify{
+        subject.as.should eq(:unique)
+      }
+    end
+
+  end
+end

data/spec/unit/operator/test_clip.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+module Alf::Shell::Operator
+  describe Clip do
+
+    let(:input){ suppliers }
+    subject{ Clip.run(argv) }
+
+    before do
+      subject.should be_a(Alf::Algebra::Clip)
+      subject.attributes.should eq(Alf::AttrList[:a, :b])
+      subject.operands.should eq([input])
+    end
+
+    context "--no-allbut" do
+      let(:argv){ [input, "--", "a", "b"] }
+      specify{
+        subject.allbut.should be_false
+      }
+    end
+
+    context "--allbut" do
+      let(:argv){ [input, "--allbut", "--", "a", "b"] }
+      specify{
+        subject.allbut.should be_true
+      }
+    end
+
+  end
+end

data/spec/unit/operator/test_coerce.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Alf::Shell::Operator
+  describe Coerce do
+
+    let(:input){ suppliers }
+    subject{ Coerce.run(argv) }
+
+    before do
+      subject.should be_a(Alf::Algebra::Coerce)
+      subject.operands.should eq([input])
+    end
+
+    context "a typical coercion" do
+      let(:argv){ [input] + %w{-- a Integer b Float} }
+      specify{
+        expected = Alf::Heading[:a => Integer, :b => Float]
+        subject.coercions.should eq(expected)
+      }
+    end
+
+  end
+end

data/spec/unit/operator/test_compact.rb

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

data/spec/unit/operator/test_defaults.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+module Alf::Shell::Operator
+  describe Defaults do
+
+    let(:input){ suppliers }
+    subject{ Defaults.run(argv) }
+
+    before do
+      subject.should be_a(Alf::Algebra::Defaults)
+      subject.defaults.should eq(Alf::TupleComputation[:a => Alf::TupleExpression["1"], :c => Alf::TupleExpression["'blue'"]])
+      subject.operands.should eq([input])
+    end
+
+    context "--no-strict" do
+      let(:argv){ [input] + %w{-- a 1 c 'blue'} }
+      specify{
+        subject.strict.should eq(false)
+      }
+    end
+
+    context "--strict" do
+      let(:argv){ [input] + %w{--strict -- a 1 c 'blue'} }
+      specify{
+        subject.strict.should eq(true)
+      }
+    end
+
+  end
+end

data/spec/unit/operator/test_extend.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+module Alf::Shell::Operator
+  describe Extend do
+
+    let(:input){ suppliers }
+    subject{ Extend.run(argv) }
+
+    before do
+      subject.should be_a(Alf::Algebra::Extend)
+      subject.operands.should eq([input])
+    end
+
+    context "a typical config" do
+      let(:argv){ [input] + %w{-- big} + ["tested > 10"] }
+      specify{
+        subject.ext.should eq(Alf::TupleComputation[:big => Alf::TupleExpression["tested > 10"]])
+      }
+    end
+
+  end
+end

data/spec/unit/operator/test_generator.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+module Alf::Shell::Operator
+  describe Generator do
+
+    subject{ Generator.run(argv) }
+
+    before do
+      subject.should be_a(Alf::Algebra::Generator)
+      subject.operands.should eq([])
+    end
+
+    context "with empty args" do
+      let(:argv){ %w{} }
+      specify{
+        subject.size.should eq(10)
+        subject.as.should eq(:num)
+      }
+    end
+
+    context "with a size" do
+      let(:argv){ %w{-- 2} }
+      specify{
+        subject.size.should eq(2)
+        subject.as.should eq(:num)
+      }
+    end
+
+    context "with a size and a name" do
+      let(:argv){ %w{-- 2 -- generated} }
+      specify{
+        subject.size.should eq(2)
+        subject.as.should eq(:generated)
+      }
+    end
+
+  end
+end

data/spec/unit/operator/test_group.rb

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

data/spec/unit/operator/test_infer_heading.rb

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

data/spec/unit/operator/test_intersect.rb

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

data/spec/unit/operator/test_join.rb

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

data/spec/unit/operator/test_matching.rb

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