escort 0.1.0 → 0.2.0

data/spec/lib/escort/formatter/command_spec.rb

@@ -0,0 +1,238 @@
+describe Escort::Formatter::Command do
+  let(:command) { Escort::Formatter::Command.new(name, setup, context)}
+  let(:setup) { Escort::SetupAccessor.new(app_configuration) }
+  let(:context) {[]}
+  let(:name) {:command1}
+  let(:command_alias) {:c1}
+  let(:aliases) {[command_alias]}
+  let(:summary) {'command summary'}
+  let(:description) {'command description'}
+
+  let(:app_configuration) do
+    Escort::Setup::Dsl::Global.new do |app|
+      app.command name, :aliases => aliases  do |command|
+        command.summary summary
+        command.description description
+
+        command.action do |options, arguments|
+        end
+      end
+    end
+  end
+
+  context "#description" do
+    subject {command.description}
+
+    context "when no description" do
+      let(:description) {nil}
+      it{subject.should == ''}
+    end
+
+    context "when has description" do
+      let(:description) {'command description'}
+      it{subject.should == description}
+    end
+  end
+
+  context "#summary" do
+    subject {command.summary}
+
+    context "when no summary" do
+      let(:summary) {nil}
+      it{subject.should == ''}
+    end
+
+    context "when has summary" do
+      let(:summary) {'command summary'}
+      it{subject.should == summary}
+    end
+  end
+
+  context "#has_aliases?" do
+    subject {command.has_aliases?}
+
+    context "when no aliases" do
+      let(:aliases) {[]}
+      it {subject.should be_false}
+    end
+
+    context "when has an alias" do
+      let(:aliases) {[command_alias]}
+      it {subject.should be_true}
+    end
+  end
+
+  context "#aliases" do
+    subject {command.aliases}
+
+    context "when no aliases" do
+      let(:aliases) {[]}
+      it {subject.should == []}
+    end
+
+    context "when has an alias" do
+      let(:aliases) {[command_alias]}
+      it {subject.first.should == command_alias}
+    end
+  end
+
+  context "#outline" do
+    subject {command.outline}
+
+    context "when no summary or description" do
+      let(:summary) {nil}
+      let(:description) {nil}
+      it {subject.should == ''}
+    end
+
+    context "when no summary" do
+      let(:summary) {nil}
+      let(:description) {'desc 1'}
+      it {subject.should == 'desc 1'}
+    end
+
+    context "when no description" do
+      let(:summary) {'summary 1'}
+      let(:description) {nil}
+      it {subject.should == 'summary 1'}
+    end
+  end
+
+  context "#aliases" do
+    subject {command.name_with_aliases}
+
+    context "when no aliases" do
+      let(:aliases) {[]}
+      it {subject.should == "command1"}
+    end
+
+    context "when has an alias" do
+      let(:aliases) {[command_alias]}
+      it {subject.should == "command1, #{command_alias}"}
+    end
+  end
+
+  context "#script_name" do
+    subject {command.script_name}
+
+    context "when context is global" do
+      let(:context) {[]}
+      it{subject.split(" ").count.should == 1}
+    end
+
+    context "when context is not global" do
+      let(:context) {[:hello]}
+      it{subject.split(" ").count.should == 2}
+      it{subject.split(" ").include?('hello').should be_true}
+    end
+  end
+
+  context "#child_commands" do
+    subject {command.child_commands}
+
+    context "when no child commands" do
+      let(:app_configuration) do
+        Escort::Setup::Dsl::Global.new do |app|
+          app.action do |options, arguments|
+          end
+        end
+      end
+      it {subject.should be_empty}
+    end
+
+    context "when has child commands" do
+      it {subject.should_not be_empty}
+      it {subject.count.should == 1}
+      it {subject.first.should == :command1}
+    end
+  end
+
+  context "#has_child_commands?" do
+    subject {command.has_child_commands?}
+
+    context "when no child commands" do
+      let(:app_configuration) do
+        Escort::Setup::Dsl::Global.new do |app|
+          app.action do |options, arguments|
+          end
+        end
+      end
+      it {subject.should be_false}
+    end
+
+    context "when has child commands" do
+      it {subject.should be_true}
+    end
+  end
+
+  context "#requires_arguments?" do
+    subject {command.requires_arguments?}
+
+    context "when arguments not required" do
+      it {subject.should be_false}
+    end
+
+    context "when arguments are required" do
+      let(:app_configuration) do
+        Escort::Setup::Dsl::Global.new do |app|
+          app.requires_arguments
+          app.action do |options, arguments|
+          end
+        end
+      end
+      it {subject.should be_true}
+    end
+  end
+
+  context "#usage" do
+    subject {command.usage}
+
+    before do
+      $0 = 'hello'
+    end
+
+    context "when global command with no children" do
+      let(:app_configuration) do
+        Escort::Setup::Dsl::Global.new do |app|
+          app.action do |options, arguments|
+          end
+        end
+      end
+      it {subject.split(" ").first.should == 'hello'}
+      it {subject.split(" ")[1].should == '[options]'}
+      it {subject.split(" ")[2].should == '[arguments]'}
+    end
+
+    context "when global command with children" do
+      it {subject.split(" ").first.should == 'hello'}
+      it {subject.split(" ")[1].should == '[options]'}
+      it {subject.split(" ")[2].should == 'command'}
+      it {subject.split(" ")[3].should == '[command_options]'}
+      it {subject.split(" ")[4].should == '[arguments]'}
+    end
+
+    context "when global command and requires arguments" do
+      let(:app_configuration) do
+        Escort::Setup::Dsl::Global.new do |app|
+          app.requires_arguments
+          app.action do |options, arguments|
+          end
+        end
+      end
+      it {subject.split(" ").last.should == 'arguments'}
+    end
+
+    context "when does not require arguments" do
+      it {subject.split(" ").last.should == '[arguments]'}
+    end
+
+    context "when child command context with no children of its own" do
+      let(:context){[:command1]}
+      it {subject.split(" ").first.should == 'hello'}
+      it {subject.split(" ")[1].should == '[options]'}
+      it {subject.split(" ")[2].should == 'command1'}
+      it {subject.split(" ")[3].should == '[command1_options]'}
+      it {subject.split(" ")[4].should == '[arguments]'}
+    end
+  end
+end

data/spec/lib/escort/formatter/global_command_spec.rb

@@ -0,0 +1,50 @@
+describe Escort::Formatter::GlobalCommand do
+  let(:command) { Escort::Formatter::GlobalCommand.new(setup)}
+  let(:setup) { Escort::SetupAccessor.new(app_configuration) }
+  let(:context) {[]}
+  let(:name) {:command1}
+  let(:command_alias) {:c1}
+  let(:aliases) {[command_alias]}
+  let(:summary) {'app summary'}
+  let(:description) {'app description'}
+
+  let(:app_configuration) do
+    Escort::Setup::Dsl::Global.new do |app|
+      app.summary summary
+      app.description description
+
+      app.command name, :aliases => aliases  do |command|
+        command.action do |options, arguments|
+        end
+      end
+    end
+  end
+
+  context "#description" do
+    subject {command.description}
+
+    context "when no description" do
+      let(:description) {nil}
+      it{subject.should == ''}
+    end
+
+    context "when has description" do
+      let(:description) {'app description'}
+      it{subject.should == description}
+    end
+  end
+
+  context "#summary" do
+    subject {command.summary}
+
+    context "when no summary" do
+      let(:summary) {nil}
+      it{subject.should == ''}
+    end
+
+    context "when has summary" do
+      let(:summary) {'app summary'}
+      it{subject.should == summary}
+    end
+  end
+end

data/spec/lib/escort/formatter/option_spec.rb

@@ -0,0 +1,300 @@
+describe Escort::Formatter::Option do
+  let(:option) {Escort::Formatter::Option.new(name, details, setup, context)}
+  let(:setup) { Escort::SetupAccessor.new(app_configuration) }
+  let(:context) {[]}
+  let(:name) { 'option1' }
+  let(:details) do
+    {:short=>short, :long=>"option1", :type=>type, :default=>default, :desc=>desc, :multi=>false}
+  end
+  let(:short) {:none}
+  let(:type) {:string}
+  let(:default) {'foo'}
+  let(:desc) {'Option 1'}
+  let(:app_configuration) do
+    Escort::Setup::Dsl::Global.new do |app|
+    end
+  end
+
+  describe "#usage" do
+    subject {option.usage}
+
+    context "when option is a flag" do
+      let(:type) {:flag}
+
+      context "and it has a default value of 'true'" do
+        let(:default) {true}
+        it {subject.should == '--option1, --no-option1'}
+      end
+
+      context "and its default value is 'false'" do
+        let(:default) {false}
+        it {subject.should == '--option1'}
+      end
+    end
+
+    context 'when option is not a flag' do
+      let(:type) {:string}
+
+      context "and it has no short specification" do
+        let(:short) {:none}
+        it {subject.should == '--option1 <s>'}
+      end
+
+      context "and it has a short specification" do
+        let(:short) {'o'}
+        it {subject.should == '--option1 -o <s>'}
+      end
+    end
+  end
+
+  describe "#description" do
+    subject {option.description}
+
+    context "when no description" do
+      let(:desc) {nil}
+      context "and has no default value" do
+        let(:default) {nil}
+        it {subject.should == ''}
+      end
+
+      context "and has a default value" do
+        let(:default) {"blah"}
+        it {subject.should == '(default: blah)'}
+      end
+    end
+
+    context "when has description" do
+      context "and description end with dot" do
+        let(:desc) {"Option 1."}
+
+        context "and has no default value" do
+          let(:default) {nil}
+          it {subject.should == 'Option 1.'}
+        end
+
+        context "and has a default value" do
+          let(:default) {"blah"}
+          it {subject.should == 'Option 1. (Default: blah)'}
+        end
+      end
+
+      context "and description does not end with dot" do
+        let(:desc) {"Option 1"}
+
+        context "and has no default value" do
+          let(:default) {nil}
+          it {subject.should == 'Option 1'}
+        end
+
+        context "and has a default value" do
+          let(:default) {"blah"}
+          it {subject.should == 'Option 1 (default: blah)'}
+        end
+      end
+    end
+  end
+
+  describe "#has_conflicts?" do
+    subject {option.has_conflicts?}
+    context "when no conflicts defined" do
+      let(:app_configuration) do
+        Escort::Setup::Dsl::Global.new do |app|
+          app.options do |opts|
+            opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+            opts.opt :option2, "Option2", :short => :none, :long => '--option2', :type => :string
+          end
+
+          app.action do |options, arguments|
+          end
+        end
+      end
+      it {subject.should be_false}
+    end
+
+    context "when conflict is defined" do
+      let(:app_configuration) do
+        Escort::Setup::Dsl::Global.new do |app|
+          app.options do |opts|
+            opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string, :conflicts_with => :option2
+            opts.opt :option2, "Option2", :short => :none, :long => '--option2', :type => :string
+          end
+
+          app.action do |options, arguments|
+          end
+        end
+      end
+      it {subject.should be_true}
+    end
+  end
+
+  describe "#has_dependencies?" do
+    subject {option.has_dependencies?}
+    context "when no dependencies defined" do
+      let(:app_configuration) do
+        Escort::Setup::Dsl::Global.new do |app|
+          app.options do |opts|
+            opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+            opts.opt :option2, "Option2", :short => :none, :long => '--option2', :type => :string
+          end
+
+          app.action do |options, arguments|
+          end
+        end
+      end
+      it {subject.should be_false}
+    end
+
+    context "when dependency is defined" do
+      let(:app_configuration) do
+        Escort::Setup::Dsl::Global.new do |app|
+          app.options do |opts|
+            opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string, :depends_on => :option2
+            opts.opt :option2, "Option2", :short => :none, :long => '--option2', :type => :string
+          end
+
+          app.action do |options, arguments|
+          end
+        end
+      end
+      it {subject.should be_true}
+    end
+  end
+
+  describe "#has_validations?" do
+    subject {option.has_validations?}
+    context "when no validations defined" do
+      let(:app_configuration) do
+        Escort::Setup::Dsl::Global.new do |app|
+          app.options do |opts|
+            opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+            opts.opt :option2, "Option2", :short => :none, :long => '--option2', :type => :string
+          end
+
+          app.action do |options, arguments|
+          end
+        end
+      end
+      it {subject.should be_false}
+    end
+
+    context "when validations is defined" do
+      let(:app_configuration) do
+        Escort::Setup::Dsl::Global.new do |app|
+          app.options do |opts|
+            opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+            opts.opt :option2, "Option2", :short => :none, :long => '--option2', :type => :string
+
+            opts.validate(:option1, "must be 'foo'") {|option| option == 'foo'}
+          end
+
+          app.action do |options, arguments|
+          end
+        end
+      end
+      it {subject.should be_true}
+    end
+  end
+
+  describe "#conflicts" do
+    subject {option.conflicts}
+    context "when no conflicts defined" do
+      let(:app_configuration) do
+        Escort::Setup::Dsl::Global.new do |app|
+          app.options do |opts|
+            opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+            opts.opt :option2, "Option2", :short => :none, :long => '--option2', :type => :string
+          end
+
+          app.action do |options, arguments|
+          end
+        end
+      end
+      it {subject.should == ''}
+    end
+
+    context "when conflict is defined" do
+      let(:app_configuration) do
+        Escort::Setup::Dsl::Global.new do |app|
+          app.options do |opts|
+            opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string, :conflicts_with => [:option2, :option3]
+            opts.opt :option2, "Option2", :short => :none, :long => '--option2', :type => :string
+            opts.opt :option3, "Option3", :short => :none, :long => '--option3', :type => :string
+          end
+
+          app.action do |options, arguments|
+          end
+        end
+      end
+      it {subject.should == 'conflicts with: --option2, --option3'}
+    end
+  end
+
+  describe "#dependencies" do
+    subject {option.dependencies}
+    context "when no dependencies defined" do
+      let(:app_configuration) do
+        Escort::Setup::Dsl::Global.new do |app|
+          app.options do |opts|
+            opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+            opts.opt :option2, "Option2", :short => :none, :long => '--option2', :type => :string
+          end
+
+          app.action do |options, arguments|
+          end
+        end
+      end
+      it {subject.should == ''}
+    end
+
+    context "when dependency is defined" do
+      let(:app_configuration) do
+        Escort::Setup::Dsl::Global.new do |app|
+          app.options do |opts|
+            opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string, :depends_on => :option2
+            opts.opt :option2, "Option2", :short => :none, :long => '--option2', :type => :string
+          end
+
+          app.action do |options, arguments|
+          end
+        end
+      end
+      it {subject.should == 'depends on: --option2'}
+    end
+  end
+
+  describe "#validations" do
+    subject {option.validations}
+    context "when no validations defined" do
+      let(:app_configuration) do
+        Escort::Setup::Dsl::Global.new do |app|
+          app.options do |opts|
+            opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+            opts.opt :option2, "Option2", :short => :none, :long => '--option2', :type => :string
+          end
+
+          app.action do |options, arguments|
+          end
+        end
+      end
+      it {subject.should == ''}
+    end
+
+    context "when validations is defined" do
+      let(:app_configuration) do
+        Escort::Setup::Dsl::Global.new do |app|
+          app.options do |opts|
+            opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+            opts.opt :option2, "Option2", :short => :none, :long => '--option2', :type => :string
+
+            opts.validate(:option1, "must be 'foo'") {|option| option == 'foo'}
+            opts.validate(:option1, "must not be 'bar'") {|option| option != 'bar'}
+          end
+
+          app.action do |options, arguments|
+          end
+        end
+      end
+      it {subject.should == "must be 'foo'\n- must not be 'bar'"}
+    end
+  end
+end

data/spec/lib/escort/formatter/shell_command_executor_spec.rb

@@ -0,0 +1,59 @@
+describe Escort::Formatter::ShellCommandExecutor do
+  let(:executor) {Escort::Formatter::ShellCommandExecutor.new(command)}
+  let(:result) { [] }
+  let(:error_callback) {lambda{ |command, error| result << 'error'; result << error.class }}
+
+  #describe "#execute_in_new_shell" do
+    #subject {executor.execute_in_new_shell(success_callback, error_callback)}
+
+    #let(:success_callback) {lambda{ |command, stdin, stdout, stderr| result << 'success' }}
+
+    #context "when command is invalid" do
+      #let(:command) { 'lx -z' }
+      #it("error callback should be executed") {subject; result.first.should == 'error'}
+      #it("should return nil") {subject.should be_nil}
+    #end
+
+    #context "when command is valid" do
+      #context "but options passed to it are invalid" do
+        #let(:command) { 'ls --foobar' }
+        #it("error callback should be executed") {subject; result.first.should == 'error'}
+        #it("command should produce an exit status error") {subject; result[1].should == Escort::InternalError}
+        #it("should return nil") {subject.should be_nil}
+      #end
+
+      #context "and options passed to it are valid" do
+        #let(:command) { 'ls -al' }
+        #it("success callback should be executed") {subject; result.first.should == 'success'}
+        #it("should not return nil") {subject.should_not be_nil}
+      #end
+    #end
+  #end
+
+  describe "#execute_in_current_shell" do
+    subject {executor.execute_in_current_shell(success_callback, error_callback)}
+
+    let(:success_callback) {lambda{ |command, final_result| result << 'success' }}
+
+    context "when command is invalid" do
+      let(:command) { 'lx -z' }
+      it("error callback should be executed") {subject; result.first.should == 'error'}
+      it("should return nil") {subject.should be_nil}
+    end
+
+    context "when command is valid" do
+      context "but options passed to it are invalid" do
+        let(:command) { 'ls --foobar' }
+        it("error callback should be executed") {subject; result.first.should == 'error'}
+        it("command should produce an exit status error") {subject; result[1].should == Escort::InternalError}
+        it("should return nil") {subject.should be_nil}
+      end
+
+      context "and options passed to it are valid" do
+        let(:command) { 'ls -al' }
+        it("success callback should be executed") {subject; result.first.should == 'success'}
+        it("should not return nil") {subject.should_not be_nil}
+      end
+    end
+  end
+end

data/spec/lib/escort/formatter/string_splitter_spec.rb

@@ -34,5 +34,17 @@ describe Escort::Formatter::StringSplitter do
         it("first segment should be 'd'") { subject[2].should == 'd' }
       end
     end
+
+    context "when segment width is 5" do
+      let(:max_segment_width) { 5 }
+
+      context "and string is 'abc\\n123456'" do
+        let(:string) {"abc\n123456"}
+        it("should produce 3 segments") { subject.size.should == 3 }
+        it("first segment should be 'abc'") { subject[0].should == 'abc' }
+        it("second segment should be '12345'") { subject[1].should == '12345' }
+        it("last segment should be '6'") { subject[2].should == '6' }
+      end
+    end
   end
 end

data/spec/lib/escort/formatter/terminal_spec.rb

@@ -0,0 +1,19 @@
+describe Escort::Formatter::Terminal do
+  let(:terminal) {Escort::Formatter::Terminal}
+
+  describe "#width" do
+    subject {terminal.width}
+
+    context "when width can be found successfully" do
+      let(:current_width) {`/usr/bin/env tput cols`.to_i}
+      it("should be equal to current width") {subject.should == current_width}
+    end
+
+    context "when width could not be found successfully" do
+      before do
+        Escort::Formatter::ShellCommandExecutor.any_instance.stub(:execute_in_current_shell).and_return(nil)
+      end
+      it("should be equal to default width") {subject.should == Escort::Formatter::Terminal::DEFAULT_WIDTH}
+    end
+  end
+end

data/spec/lib/escort/setup_accessor_spec.rb

@@ -1,5 +1,6 @@
 describe Escort::SetupAccessor do
   let(:setup) { Escort::SetupAccessor.new(app_configuration) }
+
   let(:global_app_configuration) do
     Escort::Setup::Dsl::Global.new do |app|
       app.options do |opts|