alf-shell 0.14.0 → 0.15.0

data/spec/unit/from_argv/test_to_tuple_computation.rb

@@ -1,18 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

data/spec/unit/operator/test_minus.rb

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

data/spec/unit/operator/test_not_matching.rb

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