alf-shell 0.13.0

data/spec/unit/doc_manager/static.md

@@ -0,0 +1 @@
+Hello

data/spec/unit/doc_manager/test_call.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+module Alf
+  module Shell
+    describe DocManager, ".call" do
+
+      let(:dm){ @dm ||= DocManager.new }
+      let(:cmd){ Alf::Shell::Show }
+      subject{
+        dm.call(cmd, {})
+      }
+
+      describe "on a static file" do
+        before{
+          def dm.find_file(cmd);
+            File.expand_path('../static.md', __FILE__)
+          end
+        }
+        it { should eq("Hello\n") }
+      end
+
+      describe "on a dynamic file" do
+        before{
+          def dm.find_file(cmd);
+            File.expand_path('../dynamic.md', __FILE__)
+          end
+        }
+        it { should eq("show\n") }
+      end
+
+      unless RUBY_VERSION < "1.9"
+        describe "on an example file" do
+          before{
+            def dm.find_file(cmd);
+              File.expand_path('../example.md', __FILE__)
+            end
+          }
+          it { should eq(File.read(File.expand_path('../example_1.txt', __FILE__))) }
+        end
+      end
+
+    end
+  end
+end

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

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

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

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

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

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

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

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

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

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