escort 0.2.1 → 0.3.0

data/lib/escort/version.rb

@@ -1,3 +1,3 @@
 module Escort
-  VERSION = '0.2.1'
+  VERSION = '0.3.0'
 end

data/spec/integration/basic_config_file_spec.rb

@@ -0,0 +1,82 @@
+describe "Escort basic app with config file defined", :integration => true do
+  include FakeFS::SpecHelpers
+
+  subject { Escort::App.create(option_string, &app_configuration) }
+
+  let(:path) {File.join(File.expand_path('~'), '.test_apprc')}
+  let(:app_configuration) do
+    lambda do |app|
+      app.config_file ".test_apprc", :autocreate => autocreate
+
+      app.options do |opts|
+        opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string, :default => "option 1"
+      end
+
+      app.action do |options, arguments|
+        Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+      end
+    end
+  end
+
+  context "when config file is autocreatable" do
+    context "and config file does not yet exist" do
+      before do
+        begin
+          subject
+        rescue SystemExit => e
+        end
+      end
+      let(:autocreate) {true}
+      let(:option_string) { "" }
+      it("should exit with code 0") { expect{ subject }.to exit_with_code(0) }
+      it("should have created a config file in default location") { File.should exist path  }
+    end
+
+    context "and config file already exists" do
+      before do
+        FileUtils.mkdir_p(File.dirname path)
+        File.open(path, 'w') {|f| f.write(JSON.pretty_generate({:global => {:commands => {}, :options => {:option1 => 'hello'}}, :user => {}})) }
+
+        begin
+          subject
+        rescue SystemExit => e
+        end
+      end
+      let(:autocreate) {true}
+      let(:option_string) { "" }
+      it("should exit with code 0") { expect{ subject }.to exit_with_code(0) }
+      it("should have picked up the existing config file") { result[:command_options][:option1].should == 'hello' }
+    end
+  end
+
+  context "when config file is not autocreatable" do
+    context "and config file already exists" do
+      let(:autocreate) {false}
+      let(:option_string) { "" }
+      before do
+        FileUtils.mkdir_p(File.dirname path)
+        File.open(path, 'w') {|f| f.write(JSON.pretty_generate({:global => {:commands => {}, :options => {:option1 => 'hello'}}, :user => {}})) }
+
+        begin
+          subject
+        rescue SystemExit => e
+        end
+      end
+      it("should exit with code 0") { expect{ subject }.to exit_with_code(0) }
+      it("should have picked up the existing config file") { result[:command_options][:option1].should == 'hello' }
+    end
+
+    context "and config file does not yet exist" do
+      let(:autocreate) {false}
+      let(:option_string) { "" }
+      before do
+        begin
+          subject
+        rescue SystemExit => e
+        end
+      end
+      it("should exit with code 0") { expect{ subject }.to exit_with_code(0) }
+      it("should not have created a config file in default location") { File.should_not exist path  }
+    end
+  end
+end

data/spec/integration/suite_simple_spec.rb

@@ -0,0 +1,45 @@
+describe "Escort suite app with one level of commands", :integration => true do
+  subject { Escort::App.create(option_string, &app_configuration) }
+
+  let(:app_configuration) do
+    lambda do |app|
+      app.options do |opts|
+        opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string, :default => "option 1"
+      end
+
+      app.command :command1, :aliases => [:c1]  do |command|
+        command.options do |opts|
+          opts.opt :option2, "Option2", :short => :none, :long => '--option2', :type => :string
+        end
+
+        command.action do |options, arguments|
+          Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+        end
+      end
+
+      app.action do |options, arguments|
+        Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+      end
+    end
+  end
+
+  context "when calling command with option and global option" do
+    let(:option_string) { "-o hello command1 --option2 world" }
+
+    before do
+      begin
+        subject
+      rescue SystemExit => e
+      end
+    end
+    it("should exit with code 0") { expect{ subject }.to exit_with_code(0) }
+    it("should have the right command name") { result[:command_name].should == :command1 }
+    it("should have have global option set") { result[:options][:global][:options][:option1].should == 'hello' }
+    it("should have have command option set") { result[:command_options][:option2].should == 'world' }
+  end
+
+  context "when using command alias" do
+    let(:option_string) { "-o hello c1 --option2 world" }
+    it("should exit with code 0") { expect{ subject }.to exit_with_code(0) }
+  end
+end

data/spec/integration/suite_sub_command_spec.rb

@@ -0,0 +1,51 @@
+describe "Escort suite app with sub commands", :integration => true do
+  subject { Escort::App.create(option_string, &app_configuration) }
+
+  let(:app_configuration) do
+    lambda do |app|
+      app.options do |opts|
+        opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string, :default => "option 1"
+      end
+
+      app.command :command1, :aliases => [:c1]  do |command|
+        command.options do |opts|
+          opts.opt :option2, "Option2", :short => :none, :long => '--option2', :type => :string
+        end
+
+        command.command :sub_command1 do |command|
+          command.options do |opts|
+            opts.opt :option3, "Option3", :short => :none, :long => '--option3', :type => :string
+          end
+
+          command.action do |options, arguments|
+            Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+          end
+        end
+
+        command.action do |options, arguments|
+          Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+        end
+      end
+
+      app.action do |options, arguments|
+        Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+      end
+    end
+  end
+
+  context "when calling sub command with option and command option and global option" do
+    let(:option_string) { "-o hello command1 --option2=world sub_command1 --option3=foo" }
+
+    before do
+      begin
+        subject
+      rescue SystemExit => e
+      end
+    end
+    it("should exit with code 0") { expect{ subject }.to exit_with_code(0) }
+    it("should have the right command name") { result[:command_name].should == :sub_command1 }
+    it("should have have sub command option set") { result[:command_options][:option3].should == 'foo' }
+    it("should have have global option set") { result[:options][:global][:options][:option1].should == 'hello' }
+    it("should have have command option set") { result[:options][:global][:commands][:command1][:options][:option2].should == 'world' }
+  end
+end

data/spec/lib/escort/action_command/base_spec.rb

@@ -0,0 +1,200 @@
+describe Escort::SetupAccessor do
+  let(:command) { Escort::TestCommand.new(options, arguments, config) }
+  let(:options) { {} }
+  let(:arguments) { [] }
+  let(:config) { {} }
+
+  describe "#command_context" do
+    subject {command.send(:command_context)}
+
+    context "when command context already set" do
+      before do
+        command.instance_variable_set(:"@command_context", [:hello])
+      end
+
+      it {subject.should == [:hello]}
+    end
+
+    context "when command context not yet set" do
+      context "and options hash is empty" do
+        it {subject.should == []}
+      end
+
+      context "and options hash is of valid structure" do
+        context "and command is global" do
+          let(:options) { {:global => {:commands => {}}} }
+          it {subject.should == []}
+        end
+
+        context "and command is child of global" do
+          let(:options) { {:global => {:commands => {:command1 => {:commands => {}}}}} }
+          it {subject.should == [:command1]}
+
+          context "and no commands hash for sub command in options" do
+            let(:options) { {:global => {:commands => {:command1 => {}}}} }
+            it {subject.should == [:command1]}
+          end
+        end
+
+        context "and command is grandchild of global" do
+          let(:options) { {:global => {:commands => {:command1 => {:commands => {:sub_command1 => {:commands => {}}}}}}} }
+          it {subject.should == [:command1, :sub_command1]}
+        end
+
+        context "and command is great grandchild of global" do
+          let(:options) { {:global => {:commands => {:command1 => {:commands => {:sub_command1 => {:commands => {:sub_sub_command1 => {:commands => {}}}}}}}}} }
+          it {subject.should == [:command1, :sub_command1, :sub_sub_command1]}
+        end
+      end
+    end
+  end
+
+  describe "#command_name" do
+    subject {command.send(:command_name)}
+
+    context "when context is global" do
+      let(:options) { {:global => {:commands => {}}} }
+      it {subject.should == :global}
+    end
+
+    context "when context is of size 1" do
+      let(:options) { {:global => {:commands => {:command1 => {:commands => {}}}}} }
+      it {subject.should == :command1}
+    end
+
+    context "when context is of size 2" do
+      let(:options) { {:global => {:commands => {:command1 => {:commands => {:sub_command1 => {:commands => {}}}}}}} }
+      it {subject.should == :sub_command1}
+    end
+  end
+
+  describe "#command_options" do
+    subject {command.send(:command_options)}
+
+    context "when context is global" do
+      let(:options) { {:global => {:commands => {}, :options => {:hello => :world}}} }
+      it {subject.should == {:hello => :world}}
+    end
+
+    context "when context is of size 1" do
+      let(:options) { {:global => {:commands => {:command1 => {:commands => {}, :options => {:hello => :world}}}}} }
+      it {subject.should == {:hello => :world}}
+    end
+
+    context "when context is of size 2" do
+      let(:options) { {:global => {:commands => {:command1 => {:commands => {:sub_command1 => {:commands => {}, :options => {:hello => :world}}}}}}} }
+      it {subject.should == {:hello => :world}}
+    end
+  end
+
+  describe "#global_options" do
+    subject {command.send(:global_options)}
+
+    context "when context is global" do
+      let(:options) { {:global => {:commands => {}, :options => {:hello => :world}}} }
+      it {subject.should == {:hello => :world}}
+    end
+
+    context "when context is of size 1" do
+      let(:options) { {:global => {:commands => {:command1 => {:commands => {}}}, :options => {:hello => :world}}} }
+      it {subject.should == {:hello => :world}}
+    end
+  end
+
+  describe "#parent_options" do
+    subject {command.send(:parent_options)}
+
+    context "when context is global" do
+      let(:options) { {:global => {:commands => {}, :options => {:hello => :world}}} }
+      it {subject.should == {}}
+    end
+
+    context "when context is of size 1" do
+      let(:options) { {:global => {:commands => {:command1 => {:commands => {}}}, :options => {:hello => :world}}} }
+      it {subject.should == {:hello => :world}}
+    end
+
+    context "when context is of size 2" do
+      let(:options) { {:global => {:commands => {:command1 => {:commands => {:sub_command1 => {:commands => {}}}, :options => {:hello => :world}}}}} }
+      it {subject.should == {:hello => :world}}
+    end
+  end
+
+  describe "#grandparent_options" do
+    subject {command.send(:grandparent_options)}
+
+    context "when context is global" do
+      let(:options) { {:global => {:commands => {}, :options => {:hello => :world}}} }
+      it {subject.should == {}}
+    end
+
+    context "when context is of size 1" do
+      let(:options) { {:global => {:commands => {:command1 => {:commands => {}}}, :options => {:hello => :world}}} }
+      it {subject.should == {}}
+    end
+
+    context "when context is of size 2" do
+      let(:options) { {:global => {:commands => {:command1 => {:commands => {:sub_command1 => {:commands => {}}}}}, :options => {:hello => :world}}} }
+      it {subject.should == {:hello => :world}}
+    end
+  end
+
+  describe "#ancestor_options" do
+    subject {command.send(:ancestor_options, generation_number)}
+
+    context "when context is global" do
+      let(:options) { {:global => {:commands => {}, :options => {:hello => :world}}} }
+
+      context "and generation number is 0" do
+        let(:generation_number) {0}
+        it {subject.should == {:hello => :world}}
+      end
+
+      context "and generation number is 1" do
+        let(:generation_number) {1}
+        it {subject.should == {}}
+      end
+
+      context "and generation number is 2" do
+        let(:generation_number) {2}
+        it {subject.should == {}}
+      end
+
+      context "and generation number is 3" do
+        let(:generation_number) {3}
+        it {subject.should == {}}
+      end
+    end
+
+    context "when context is of size 1" do
+      let(:options) { {:global => {:commands => {:command1 => {:commands => {}, :options => {:foo => :bar}}}, :options => {:hello => :world}}} }
+
+      context "and generation number is 0" do
+        let(:generation_number) {0}
+        it {subject.should == {:foo => :bar}}
+      end
+
+      context "and generation number is 1" do
+        let(:generation_number) {1}
+        it {subject.should == {:hello => :world}}
+      end
+
+      context "and generation number is 2" do
+        let(:generation_number) {2}
+        it {subject.should == {}}
+      end
+
+      context "and generation number is 3" do
+        let(:generation_number) {3}
+        it {subject.should == {}}
+      end
+    end
+  end
+end
+
+module Escort
+  class TestCommand < ::Escort::ActionCommand::Base
+    def execute
+    end
+  end
+end

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

@@ -276,7 +276,7 @@ describe Escort::Formatter::Option do
           end
         end
       end
-      it {subject.should == ''}
+      it {subject.should == []}
     end
 
     context "when validations is defined" do
@@ -294,7 +294,7 @@ describe Escort::Formatter::Option do
           end
         end
       end
-      it {subject.should == "must be 'foo'\n- must not be 'bar'"}
+      it {subject.should == ["must be 'foo'", "must not be 'bar'"]}
     end
   end
 end

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

@@ -0,0 +1,214 @@
+describe Escort::Formatter::StreamOutputFormatter do
+  let(:formatter) {Escort::Formatter::StreamOutputFormatter.new(stream, :max_output_width => output_width)}
+  let(:stream) { StringIO.new }
+  let(:output_width) { 10 }
+  let(:output) {stream.readlines}
+
+  describe "#print" do
+    subject {formatter.print(string)}
+
+    before { subject; stream.rewind }
+
+    context "when string is less than output_width" do
+      let(:string) {'12345'}
+      it("stream should have one line") {output.first.should == string}
+    end
+
+    context "when string is greater than output width" do
+      let(:string) {'123456789abcd'}
+      it("stream should have two lines") {output.should == ["123456789a\n", "bcd"]}
+    end
+
+    context "when string is has newlines in it" do
+      context "and both lines less than output width" do
+        let(:string) {"1234567\n89abcd"}
+        it("stream should have two lines") {output.should == ["1234567\n", "89abcd"]}
+      end
+
+      context "and first line greater than output width" do
+        let(:string) {"123456789abcd\nefg"}
+        it("stream should have three lines") {output.should == ["123456789a\n", "bcd\n", "efg"]}
+      end
+    end
+  end
+
+  describe "#puts" do
+    subject {formatter.puts(string, options)}
+    let(:string) {'hello'}
+    let(:options) { {:newlines => newlines} }
+    let(:newlines) {1}
+
+    before { subject; stream.rewind }
+
+    context "when newlines" do
+      context "is zero" do
+        let(:newlines) {0}
+        let(:string) {"123456789abcd\nefg"}
+        it("stream should have three lines") {output.should == ["123456789a\n", "bcd\n", "efg"]}
+      end
+
+      context "not specified" do
+        subject {formatter.puts(string)}
+        let(:string) {"123"}
+        it("stream should have one newline") {output.should == ["123\n"]}
+      end
+
+      context "is two" do
+        let(:string) {"123"}
+        let(:newlines) {2}
+        it("stream should have two newlines") {output.should == ["123\n", "\n"]}
+      end
+    end
+  end
+
+  describe "#newline" do
+    subject {formatter.newline(newline_count)}
+    let(:newline_count) {1}
+
+    before { subject; stream.rewind }
+
+    context "when newline count not specified" do
+      subject {formatter.newline}
+      it("stream should have one newline") {output.should == ["\n"]}
+    end
+
+    context "when newline count is 2" do
+      let(:newline_count) {2}
+      it("stream should have two newlines") {output.should == ["\n", "\n"]}
+    end
+  end
+
+  describe "#indent" do
+    subject {formatter.indent(indent_width, &indented_block)}
+
+    let(:indented_block) do
+      lambda {|f| f.print string}
+    end
+
+    before { subject; stream.rewind }
+
+    context "when indent is 0" do
+      let(:indent_width) {0}
+
+      context "and we print a string less than output_width" do
+        let(:string) {'12345'}
+        it("stream should have one line") {output.should == ['12345']}
+      end
+
+      context "and we print a string greater than output width" do
+        let(:string) {'123456789abcd'}
+        it("stream should have two lines") {output.should == ["123456789a\n", "bcd"]}
+      end
+
+      context "and we print a string that has newlines in it" do
+        context "and both lines are less than output width" do
+          let(:string) {"1234567\n89abcd"}
+          it("stream should have two lines") {output.should == ["1234567\n", "89abcd"]}
+        end
+
+        context "and first line is greater than output width" do
+          let(:string) {"123456789abcd\nefg"}
+          it("stream should have three lines") {output.should == ["123456789a\n", "bcd\n", "efg"]}
+        end
+      end
+    end
+
+    context "when indent is 1" do
+      let(:indent_width) {1}
+
+      context "and we print a string less than output_width" do
+        let(:string) {'12345'}
+        it("stream should have one line") {output.should == [' 12345']}
+      end
+
+      context "and we print a string greater than output width" do
+        let(:string) {'123456789abcd'}
+        it("stream should have two lines") {output.should == [" 123456789\n", " abcd"]}
+      end
+
+      context "and we print a string that has newlines in it" do
+        context "and both lines are less than output width" do
+          let(:string) {"1234567\n89abcd"}
+          it("stream should have two lines") {output.should == [" 1234567\n", " 89abcd"]}
+        end
+
+        context "and first line is greater than output width" do
+          let(:string) {"123456789abcd\nefg"}
+          it("stream should have three lines") {output.should == [" 123456789\n", " abcd\n", " efg"]}
+        end
+      end
+    end
+
+    context "when indent is 3" do
+      let(:indent_width) {3}
+
+      context "and we print a string less than output_width" do
+        let(:string) {'12345'}
+        it("stream should have one line") {output.should == ['   12345']}
+      end
+
+      context "and we print a string greater than output width" do
+        let(:string) {'123456789abcd'}
+        it("stream should have two lines") {output.should == ["   1234567\n", "   89abcd"]}
+      end
+
+      context "and we print a string that has newlines in it" do
+        context "and both lines are less than output width" do
+          let(:string) {"1234567\n89abcd"}
+          it("stream should have two lines") {output.should == ["   1234567\n", "   89abcd"]}
+        end
+
+        context "and first line is greater than output width" do
+          let(:string) {"123456789abcd\nefg"}
+          it("stream should have three lines") {output.should == ["   1234567\n", "   89abcd\n", "   efg"]}
+        end
+      end
+    end
+  end
+
+  context "output combinations" do
+    subject do
+      Escort::Formatter::StreamOutputFormatter.new(stream, :max_output_width => output_width) do |f|
+        f.print "the quick"
+        f.newline
+        f.print "brown fox"
+        f.print "jumped over the"
+        f.print "lazy dog"
+        f.newline
+        f.puts 'rainbow suspenders'
+        f.indent(3) do |f|
+          f.puts "blah blah blah blah"
+          f.newline(2)
+          f.indent(2) do |f|
+            f.puts "indent me good"
+            f.print "foo"
+            f.print "foo"
+            f.print "foo"
+            f.newline
+            f.puts "exit", :newlines => 4
+          end
+        end
+      end
+    end
+    let(:stream) { StringIO.new }
+    let(:output_width) { 10 }
+
+    let(:output) {stream.readlines}
+
+    before { subject; stream.rewind }
+
+    context "lines should not be greater than output width" do
+      it do
+        output.each do |line|
+          line.strip.length.should be <= output_width
+        end
+      end
+    end
+
+    context "stream should contain" do
+      it do
+        output.should == ["the quick\n", "brown foxj\n", "umped over\n", " thelazy d\n", "og\n", "rainbow su\n", "spenders\n", "   blah bl\n", "   ah blah\n", "    blah\n", "\n", "\n", "     inden\n", "     t me \n", "     good\n", "     foofo\n", "     ofoo\n", "     exit\n", "\n", "\n", "\n"]
+      end
+    end
+  end
+end