alf-shell 0.14.0 → 0.15.0

data/spec/unit/ext/signature/test_argv2args.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Signature, "#argv2args" do
-      
-      class FakeOp
-        attr_accessor :operands
-      end
-      before{ 
-        signature.install
-      }
-      subject{
-        signature.argv2args(argv)
-      }
- 
-      context "on a signature with arguments only" do
-        let(:signature){ 
-          Signature.new(FakeOp) do |s|
-            s.argument :proj, AttrList
-          end
-        }
-        let(:argv){ %w{operand -- hello world} }
-
-        it 'should return the expected triple' do
-          [["operand"], [AttrList[:hello, :world]], {}]
-        end
-      end # arguments only
-
-      context "with default values for arguments" do
-        let(:signature){ 
-          Signature.new(FakeOp) do |s|
-            s.argument :attrname, AttrName, :autonum
-          end
-        }
-        let(:arguments){ subject[1] }
-
-        context 'and passed' do
-          let(:argv){ %w{operand -- hello} }
-
-          it 'should not use the default value' do
-            arguments.should eq([:hello]) 
-          end
-        end
-
-        context 'and not passed' do
-          let(:argv){ %w{operand} }
-
-          it 'should use the default value' do
-            arguments.should eq([:autonum]) 
-          end
-        end
-      end # default values for arguments
-
-      context "on a signature with options" do
-        let(:signature){
-          Signature.new(FakeOp) do |s|
-            s.argument :key, AttrList, []
-            s.option   :allbut, Boolean, false
-          end
-        }
-        let(:options){ subject[2] }
-
-        context "when no option is provided" do
-          let(:argv){ %w{operand -- hello world} }
-
-          it 'should use the default values for options' do
-            options.should eq({:allbut => false})
-          end
-        end
-
-        context "when option is provided" do
-          let(:argv){ %w{operand --allbut -- hello world} }
-
-          it 'should not use the default values for options' do
-            options.should eq({:allbut => true})
-          end
-        end
-      end # signature with options
-
-    end
-  end
-end

data/spec/unit/ext/signature/test_to_shell.rb

@@ -1,103 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Signature, '#to_shell' do
-
-      subject{ signature.to_shell }
-
-      describe "on a nullary signature" do
-        let(:clazz){ Generator }
-
-        describe "on an empty signature" do
-          let(:signature){ Signature.new(clazz){|s|} }
-          it{ should eq("alf generator") }
-        end
-
-        describe "on an option-only signature" do
-          let(:signature){ 
-            Signature.new(clazz) do |s|
-              s.option :allbut, Boolean
-            end
-          }
-          it{ should eq("alf generator [--allbut]") }
-        end
-
-      end # nullary signature
-
-      describe "on a monadic operator" do
-        let(:clazz){ Coerce }
-
-        describe "on an empty signature" do
-          let(:signature){ Signature.new(clazz){|s|} }
-          it{ should eq("alf coerce [OPERAND]") }
-        end
-
-        describe "on an option-only signature" do
-          let(:signature){ 
-            Signature.new(clazz) do |s|
-              s.option :allbut, Boolean
-            end
-          }
-          it{ should eq("alf coerce [--allbut] [OPERAND]") }
-        end
-
-        describe "on an option-only signature with multiple options" do
-          let(:signature){ 
-            Signature.new(clazz) do |s|
-              s.option :allbut, Boolean
-              s.option :newname, AttrName
-            end
-          }
-          it{ should eq("alf coerce [--allbut] [--newname=NEWNAME] [OPERAND]") }
-        end
-
-        describe "on a signature with one argument only" do
-          let(:signature){ 
-            Signature.new(clazz) do |s|
-              s.argument :proj, AttrList
-            end
-          }
-          it{ should eq("alf coerce [OPERAND] -- PROJ") }
-        end
-
-        describe "on a signature with multiple arguments" do
-          let(:signature){ 
-            Signature.new(clazz) do |s|
-              s.argument :proj, AttrList
-              s.argument :ordering, Ordering
-            end
-          }
-          it{ should eq("alf coerce [OPERAND] -- PROJ -- ORDERING") }
-        end
-
-        describe "on a full signature" do
-          let(:signature){ 
-            Signature.new(clazz) do |s|
-              s.argument :proj, AttrList
-              s.argument :ordering, Ordering
-              s.option :allbut, Boolean
-              s.option :newname, AttrName
-            end
-          }
-          it{ should eq("alf coerce [--allbut] [--newname=NEWNAME] [OPERAND] -- PROJ -- ORDERING") }
-        end
-
-      end
-
-      describe "on a dyadic operator" do
-        let(:clazz){ Join }
-
-        describe "on an option-only signature" do
-          let(:signature){ 
-            Signature.new(clazz) do |s|
-              s.option :allbut, Boolean
-            end
-          }
-          it{ should eq("alf join [--allbut] [LEFT] RIGHT") }
-        end
-
-      end
-
-    end
-  end
-end

data/spec/unit/from_argv/test_to_attr_list.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Shell, ".from_argv(argv, AttrList)" do
-
-    subject{ Shell.from_argv(argv, AttrList) }
-
-    context "on an empty array" do
-      let(:argv){ [] }
-      it{ should eq(AttrList.new([])) }
-    end
-
-    context "on a singleton" do
-      let(:argv){ ["hello"] }
-      it{ should eq(AttrList.new([:hello])) }
-    end
-
-    context "on multiple strings" do
-      let(:argv){ ["hello", "world"] }
-      it{ should eq(AttrList.new([:hello, :world])) }
-    end
-
-    context "when passed an unrecognized argument" do
-      let(:argv){ :not_recognized }
-      specify{
-        lambda{ subject }.should raise_error(Myrrha::Error)
-      }
-    end
-
-  end
-end

data/spec/unit/from_argv/test_to_attr_name.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Shell, ".from_argv(argv, AttrName)" do
-
-    subject{ Shell.from_argv(argv, AttrName) }
-
-    context "with a String" do
-      let(:argv){ %w{hello} }
-      it{ should eq(:hello) }
-    end
-
-    context "with nothing" do
-      let(:argv){ %w{} }
-      specify{
-        lambda{ subject }.should raise_error(Myrrha::Error)
-      }
-    end
-
-    context "with more than one string" do
-      let(:argv){ %w{hello world} }
-      specify{
-        lambda{ subject }.should raise_error(Myrrha::Error)
-      }
-    end
-
-  end
-end

data/spec/unit/from_argv/test_to_boolean.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Shell, ".from_argv(argv, Boolean)" do
-
-    subject{ Shell.from_argv(argv, Boolean) }
-
-    context "with a String" do
-      let(:argv){ %w{true} }
-      it{ should eq(true) }
-    end
-
-    context "with nothing" do
-      let(:argv){ %w{} }
-      it{ should eq(false) }
-    end
-
-    context "with an invalid string" do
-      let(:argv){ %w{hello} }
-      specify{
-        lambda{ subject }.should raise_error(Myrrha::Error)
-      }
-    end
-
-    context "with more than one string" do
-      let(:argv){ %w{hello world} }
-      specify{
-        lambda{ subject }.should raise_error(Myrrha::Error)
-      }
-    end
-
-  end
-end

data/spec/unit/from_argv/test_to_heading.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Shell, ".from_argv(argv, Heading)" do
-
-    subject{ Shell.from_argv(argv, Heading) }
-
-    context "on an empty array" do
-      let(:argv){ [] }
-      it{ should eq(Heading.new({})) }
-    end
-
-    context "on a single pair" do
-      let(:argv){ ["name", "String"] }
-      it{ should eq(Heading.new :name => String) }
-    end
-
-    context "on a double pair" do
-      let(:argv){ ["name", "String", "age", "Fixnum"] }
-      it{ should eq(Heading.new :name => String, :age => Fixnum) }
-    end
-
-    context "on odd number of strings" do
-      let(:argv){ ["hello", "world", "foo"] }
-      specify{
-        lambda{ subject }.should raise_error(Myrrha::Error)
-      }
-    end
-
-    context "when passed an unrecognized argument" do
-      let(:argv){ :not_recognized }
-      specify{
-        lambda{ subject }.should raise_error(Myrrha::Error)
-      }
-    end
-
-  end
-end

data/spec/unit/from_argv/test_to_ordering.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Shell, ".from_argv(argv, Ordering)" do
-
-    subject{ Shell.from_argv(argv, Ordering) }
-
-    context "on an empty array" do
-      let(:argv){ [] }
-      it{ should eq(Ordering.new([])) }
-    end
-
-    context "on a singleton" do
-      let(:argv){ ["hello"] }
-      it{ should eq(Ordering.new([[:hello, :asc]])) }
-    end
-
-    context "on multiple strings without explit directions" do
-      let(:argv){ ["hello", "world"] }
-      it{ should eq(Ordering.new([[:hello, :asc], [:world, :asc]])) }
-    end
-
-    context "on multiple strings with explit directions" do
-      let(:argv){ ["hello", "asc", "world", "desc"] }
-      it{ should eq(Ordering.new([[:hello, :asc], [:world, :desc]])) }
-    end
-
-  end
-end

data/spec/unit/from_argv/test_to_predicate.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Shell, ".from_argv(argv, Predicate)" do
-
-    subject{ Shell.from_argv(argv, Predicate) }
-
-    describe "from a singleton Array" do
-      let(:argv){ ["status == 10"] }
-
-      specify{
-        subject.expr.should be_a(Predicate::Native)
-        subject.to_ruby_literal.should eq("lambda{ status == 10 }")
-      }
-    end
-
-    describe "from an Array with coercion" do
-      let(:argv){ ["status", "10"] }
-
-      specify{
-        subject.expr.should be_a(Predicate::Eq)
-        subject.expr.should eq([:eq, [:var_ref, :status], [:literal, 10]])
-      }
-    end
-
-  end
-end

data/spec/unit/from_argv/test_to_renaming.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Shell, ".from_argv(argv, Renaming)" do
-
-    subject{ Shell.from_argv(argv, Renaming) }
-
-    context "from an empty Array" do
-      let(:argv){ [] }
-      it{ should eq(Renaming.new({})) }
-    end
-
-    context "from an Array of two elements" do
-      let(:argv){ ["old", "new"] }
-      it{ should eq(Renaming.new(:old => :new)) }
-    end
-
-    context "from an Array of four elements" do
-      let(:argv){ ["old", "new", "hello", "world"] }
-      it{ should eq(Renaming.new(:old => :new, :hello => :world)) }
-    end
-
-  end
-end

data/spec/unit/from_argv/test_to_size.rb

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

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