escort 0.2.1 → 0.3.0

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

@@ -0,0 +1,59 @@
+describe Escort::Formatter::StringGrid do
+  let(:width) {20}
+
+  describe "#to_s" do
+    subject {grid.to_s}
+
+    context "when 2 rows and 3 columns" do
+      context "no strings span multiple rows" do
+        let(:grid) do
+          Escort::Formatter::StringGrid.new(:columns => 3, :width => width) do |g|
+            g.row 'a', 'b', 'c'
+            g.row 1, 2, 3
+          end
+        end
+        it("all rows should equal table width") do
+          subject.split("\n").each do |val|
+            val.length.should == width
+          end
+        end
+        it {subject.should == "a b c               \n1 2 3               "}
+      end
+
+      context "first column string spans 4 rows" do
+        let(:grid) do
+          Escort::Formatter::StringGrid.new(:columns => 3, :width => width) do |g|
+            g.row '123456789abcdefgh', 'b', 'c'
+            g.row 1, 2, 3
+          end
+        end
+        it("should have 5 rows") do
+          subject.split("\n").size.should == 5
+        end
+        it("all rows should equal table width") do
+          subject.split("\n").each do |val|
+            val.length.should == width
+          end
+        end
+        it { subject.should == "12345 b c           \n6789a               \nbcdef               \ngh                  \n1     2 3           " }
+      end
+      context "last column string spans 2 rows" do
+        let(:grid) do
+          Escort::Formatter::StringGrid.new(:columns => 3, :width => width) do |g|
+            g.row 'a', 'b', 'c'
+            g.row 1, 2, "123456789abcdefghijk"
+          end
+        end
+        it("should have 3 rows") do
+          subject.split("\n").size.should == 3
+        end
+        it("all rows should equal table width") do
+          subject.split("\n").each do |val|
+            val.length.should == width
+          end
+        end
+        it { subject.should == "a b c               \n1 2 123456789abcdef \n    ghijk           " }
+      end
+    end
+  end
+end

data/spec/lib/escort/setup/configuration/generator_spec.rb

@@ -0,0 +1,101 @@
+describe Escort::Setup::Configuration::Generator do
+
+  let(:generator) {Escort::Setup::Configuration::Generator.new(setup)}
+  let(:setup) { Escort::SetupAccessor.new(app_configuration) }
+
+
+  describe "#default_data" do
+    subject {generator.default_data}
+
+    context "when basic configuration" do
+      let(:app_configuration) do
+        Escort::Setup::Dsl::Global.new do |app|
+          app.options do |opts|
+            opts.opt :option1, "option1", :short => :none, :long => '--option1', :type => :string
+          end
+
+          app.action do |options, arguments|
+          end
+        end
+      end
+      it("should have a user config") {subject[:user].should_not be_nil}
+      it("user config should be empty") {subject[:user].should be_empty}
+      it("shoud have a global config") {subject[:global].should_not be_nil}
+      it("global config should not be empty") {subject[:global].should_not be_empty}
+      it("should have a global commands config") {subject[:global][:commands].should_not be_nil}
+      it("global commands config should be empty") {subject[:global][:commands].should be_empty}
+      it("should have a global options config") {subject[:global][:options].should_not be_nil}
+      it("global options config should not be empty") {subject[:global][:options].should_not be_empty}
+      it("options config should have a key for configured option") {subject[:global][:options].keys.size.should == 1}
+      it("options config key for configured config should be nil when no default value") {subject[:global][:options][:option1].should be_nil}
+
+      context "and configured option has default value" do
+        let(:app_configuration) do
+          Escort::Setup::Dsl::Global.new do |app|
+            app.options do |opts|
+              opts.opt :option1, "option1", :short => :none, :long => '--option1', :type => :string, :default => "hello"
+            end
+
+            app.action do |options, arguments|
+            end
+          end
+        end
+        it("options config key for configured config should equal to default value") {subject[:global][:options][:option1].should == 'hello'}
+      end
+    end
+
+    context "when suite configuration" do
+      let(:app_configuration) do
+        Escort::Setup::Dsl::Global.new do |app|
+          app.options do |opts|
+            opts.opt :option1, "option1", :short => :none, :long => '--option1', :type => :string
+          end
+
+          app.command :command1, :aliases => [:c1, :com1]  do |command|
+            command.options do |opts|
+              opts.opt :option2, "option2", :short => :none, :long => '--option2', :type => :string, :default => 'blah'
+            end
+          end
+        end
+      end
+
+      it("should have a global commands config") {subject[:global][:commands].should_not be_nil}
+      it("global commands config should be empty") {subject[:global][:commands].should_not be_empty}
+      it("command1 commands config should not be nil") {subject[:global][:commands][:command1][:commands].should_not be_nil}
+      it("command1 commands config should be empty") {subject[:global][:commands][:command1][:commands].should be_empty}
+      it("command1 options config should not be nil") {subject[:global][:commands][:command1][:options].should_not be_nil}
+      it("command1 options config should not be empty") {subject[:global][:commands][:command1][:options].should_not be_empty}
+      it("command1 options option value should be the same as default value") {subject[:global][:commands][:command1][:options][:option2].should == 'blah'}
+    end
+
+    context "when suite with sub commands configuration" do
+      let(:app_configuration) do
+        Escort::Setup::Dsl::Global.new do |app|
+          app.options do |opts|
+            opts.opt :option1, "option1", :short => :none, :long => '--option1', :type => :string
+          end
+
+          app.command :command1, :aliases => [:c1, :com1]  do |command|
+            command.options do |opts|
+              opts.opt :option2, "option2", :short => :none, :long => '--option2', :type => :string, :default => 'blah'
+            end
+
+            command.command :sub_command1 do |command|
+              command.options do |opts|
+                opts.opt :option3, "option3", :short => :none, :long => '--option3', :type => :string, :default => 'yadda'
+              end
+            end
+          end
+        end
+      end
+
+      it("command1 commands config should not be nil") {subject[:global][:commands][:command1][:commands].should_not be_nil}
+      it("command1 commands config should not be empty") {subject[:global][:commands][:command1][:commands].should_not be_empty}
+      it("sub_command1 command config should not be nil") {subject[:global][:commands][:command1][:commands][:sub_command1][:commands].should_not be_nil}
+      it("sub_command1 command config should be empty") {subject[:global][:commands][:command1][:commands][:sub_command1][:commands].should be_empty}
+      it("sub_command1 options config should not be nil") {subject[:global][:commands][:command1][:commands][:sub_command1][:options].should_not be_nil}
+      it("sub_command1 options config should not be empty") {subject[:global][:commands][:command1][:commands][:sub_command1][:options].should_not be_empty}
+      it("sub_command1 options option value should be the same as default value") {subject[:global][:commands][:command1][:commands][:sub_command1][:options][:option3].should == 'yadda'}
+    end
+  end
+end

data/spec/lib/escort/setup/configuration/loader_spec.rb

@@ -0,0 +1,79 @@
+describe Escort::Setup::Configuration::Loader do
+  include FakeFS::SpecHelpers
+
+  let(:loader) {Escort::Setup::Configuration::Loader.new(setup, auto_options)}
+  let(:setup) { Escort::SetupAccessor.new(app_configuration) }
+  let(:auto_options) {Escort::AutoOptions.new({})}
+
+  describe "#default_config_path" do
+    subject {loader.default_config_path}
+
+    context "when setup has config file" do
+      let(:app_configuration) do
+        Escort::Setup::Dsl::Global.new do |app|
+          app.config_file '.test1rc'
+          app.options do |opts|
+            opts.opt :option1, "option1", :short => :none, :long => '--option1', :type => :string
+          end
+        end
+      end
+      it {subject.should == File.join(File.expand_path('~'), '.test1rc')}
+    end
+
+    context "when setup has no config file" do
+      let(:app_configuration) do
+        Escort::Setup::Dsl::Global.new do |app|
+          app.options do |opts|
+            opts.opt :option1, "option1", :short => :none, :long => '--option1', :type => :string
+          end
+        end
+      end
+      it {subject.should be_nil }
+    end
+  end
+
+  describe "#configuration" do
+    subject {loader.configuration}
+
+
+    context "when setup has config file" do
+      context "and config file is autocreatable" do
+        let(:app_configuration) do
+          Escort::Setup::Dsl::Global.new do |app|
+            app.config_file '.test1rc', :autocreate => true
+            app.options do |opts|
+              opts.opt :option1, "option1", :short => :none, :long => '--option1', :type => :string
+            end
+          end
+        end
+        it {subject.should_not be_nil}
+        it {subject.should_not be_empty}
+        it {subject; File.should exist File.join(File.expand_path('~'), '.test1rc') }
+      end
+
+      context "and config file is not autocreatable" do
+        let(:app_configuration) do
+          Escort::Setup::Dsl::Global.new do |app|
+            app.config_file '.test1rc'
+            app.options do |opts|
+              opts.opt :option1, "option1", :short => :none, :long => '--option1', :type => :string
+            end
+          end
+        end
+        it {subject.should_not be_nil}
+        it {subject.should be_empty}
+      end
+    end
+
+    context "when setup has no config file" do
+      let(:app_configuration) do
+        Escort::Setup::Dsl::Global.new do |app|
+          app.options do |opts|
+            opts.opt :option1, "option1", :short => :none, :long => '--option1', :type => :string
+          end
+        end
+      end
+      it {subject.should be_empty}
+    end
+  end
+end

data/spec/lib/escort/setup/configuration/locator/chaining_spec.rb

@@ -0,0 +1,81 @@
+describe Escort::Setup::Configuration::Locator::Chaining do
+  include FakeFS::SpecHelpers
+
+  let(:locator) {Escort::Setup::Configuration::Locator::Chaining.new(filename)}
+  let(:filename) {'.blahrc'}
+  let(:home) {File.expand_path('~')}
+  let(:pwd) {File.expand_path(File.join(home, 'blah', 'yadda', 'foo'))}
+  let(:executing_directory) {File.expand_path(File.dirname($0))}
+
+  let(:descending_locator) {Escort::Setup::Configuration::Locator::DescendingToHome.new(filename)}
+  let(:executing_script_locator) {Escort::Setup::Configuration::Locator::ExecutingScriptDirectory.new(filename)}
+
+  before do
+    FileUtils.mkdir_p(executing_directory)
+    FileUtils.mkdir_p(home)
+    FileUtils.mkdir_p(pwd)
+    Dir.chdir(pwd)
+  end
+
+  describe "#add_locator" do
+    subject {locator.add_locator("blah")}
+    it {subject.should == locator}
+    it {subject.locators.size.should == 1}
+  end
+
+  describe "#locate" do
+    subject {locator.locate}
+
+    context "when no sub-locators specified" do
+      it {subject.should be_nil}
+    end
+
+    context "when executing directory locator specified" do
+      before do
+        locator.add_locator(executing_script_locator)
+      end
+
+      let(:path) {File.join(executing_directory, filename)}
+
+      context "and file should be found by it" do
+        before do
+          File.open(path, 'w') {|f| f.write("hello") }
+        end
+
+        it {subject.should == path}
+      end
+
+      context "and file should not be found by it" do
+        it {subject.should be_nil}
+      end
+    end
+
+    context "when descending and current script locators are specified" do
+      before do
+        locator.
+          add_locator(descending_locator).
+          add_locator(executing_script_locator)
+      end
+
+      context "and file should not be found" do
+        it {subject.should be_nil}
+      end
+
+      context "and file should be found by current script locator" do
+        let(:path) {File.join(executing_directory, filename)}
+        before do
+          File.open(path, 'w') {|f| f.write("hello") }
+        end
+        it {subject.should == path}
+      end
+
+      context "and file should be found by descending locator"do
+        let(:path) {File.join(home, filename)}
+        before do
+          File.open(path, 'w') {|f| f.write("hello") }
+        end
+        it {subject.should == path}
+      end
+    end
+  end
+end

data/spec/lib/escort/setup/configuration/locator/descending_to_home_spec.rb

@@ -0,0 +1,57 @@
+describe Escort::Setup::Configuration::Locator::DescendingToHome do
+  include FakeFS::SpecHelpers
+
+  let(:locator) {Escort::Setup::Configuration::Locator::DescendingToHome.new(filename)}
+  let(:filename) {'.blahrc'}
+  let(:home) {File.expand_path('~')}
+  let(:pwd) {File.expand_path(File.join(home, 'blah', 'yadda', 'foo'))}
+
+  before do
+    FileUtils.mkdir_p(home)
+    FileUtils.mkdir_p(pwd)
+    Dir.chdir(pwd)
+  end
+
+  describe "#locate" do
+    subject {locator.locate}
+
+    context "when file does not exist anywhere in the relevant directories" do
+      it {subject.should be_nil}
+    end
+
+    context "when file exists" do
+      context "in the top directory of search" do
+        let(:file_location) {File.expand_path(File.join(home, 'blah', 'yadda', 'foo'))}
+        let(:path) {File.join(file_location, filename)}
+
+        before do
+          File.open(path, 'w') {|f| f.write("hello") }
+        end
+
+        it {subject.should == path}
+      end
+
+      context "in one of the middle directories of search" do
+        let(:file_location) {File.expand_path(File.join(home, 'blah', 'yadda'))}
+        let(:path) {File.join(file_location, filename)}
+
+        before do
+          File.open(path, 'w') {|f| f.write("hello") }
+        end
+
+        it {subject.should == path}
+      end
+
+      context "in the home directory" do
+        let(:file_location) {File.expand_path(home)}
+        let(:path) {File.join(file_location, filename)}
+
+        before do
+          File.open(path, 'w') {|f| f.write("hello") }
+        end
+
+        it {subject.should == path}
+      end
+    end
+  end
+end

data/spec/lib/escort/setup/configuration/locator/executing_script_directory_spec.rb

@@ -0,0 +1,29 @@
+describe Escort::Setup::Configuration::Locator::ExecutingScriptDirectory do
+  include FakeFS::SpecHelpers
+
+  let(:locator) {Escort::Setup::Configuration::Locator::ExecutingScriptDirectory.new(filename)}
+  let(:filename) {'.blahrc'}
+  let(:directory) {File.expand_path(File.dirname($0))}
+  let(:path) {File.join(directory, filename)}
+
+  describe "#locate" do
+    subject {locator.locate}
+
+    context "when file does not exist in directory" do
+      before do
+        FileUtils.mkdir_p(directory)
+      end
+
+      it {subject.should be_nil}
+    end
+
+    context "when file exists in directory" do
+      before do
+        FileUtils.mkdir_p(directory)
+        File.open(path, 'w') {|f| f.write("hello") }
+      end
+
+      it {subject.should == path}
+    end
+  end
+end

data/spec/lib/escort/setup/configuration/locator/specified_directory_spec.rb

@@ -0,0 +1,33 @@
+describe Escort::Setup::Configuration::Locator::SpecifiedDirectory do
+  include FakeFS::SpecHelpers
+
+  let(:locator) {Escort::Setup::Configuration::Locator::SpecifiedDirectory.new(filename, directory)}
+  let(:filename) {'.blahrc'}
+  let(:directory) {'/usr/alan/yadda'}
+  let(:path) {File.join(directory, filename)}
+
+  describe "#locate" do
+    subject {locator.locate}
+
+    context "when directory does not exist" do
+      it {subject.should be_nil}
+    end
+
+    context "when file does not exist in directory" do
+      before do
+        FileUtils.mkdir_p(directory)
+      end
+
+      it {subject.should be_nil}
+    end
+
+    context "when file exists in directory" do
+      before do
+        FileUtils.mkdir_p(directory)
+        File.open(path, 'w') {|f| f.write("hello") }
+      end
+
+      it {subject.should == path}
+    end
+  end
+end

data/spec/lib/escort/setup/configuration/merge_tool_spec.rb

@@ -0,0 +1,41 @@
+describe Escort::Setup::Configuration::MergeTool do
+  let(:merge_tool) {Escort::Setup::Configuration::MergeTool.new(new_config_hash, old_config_hash)}
+
+  describe "#config_hash" do
+    subject {merge_tool.config_hash}
+
+    context "when there is a new command" do
+      let(:old_config_hash) { {:global => {:commands =>{}, :options => {:option1 => nil}}, :user => {:hello => :world}} }
+      let(:new_config_hash) { {:global => {:commands =>{:command1 => {:commands => {}, :options => {}}}, :options => {}}, :user => {}} }
+
+      it("should be part of the config"){subject[:global][:commands][:command1].should_not be_nil}
+    end
+
+    context "when there is a new option for an old command" do
+      let(:old_config_hash) { {:global => {:commands =>{}, :options => {:option1 => nil}}, :user => {:hello => :world}} }
+      let(:new_config_hash) { {:global => {:commands =>{}, :options => {:option1 => nil, :option2 => nil}}, :user => {}} }
+
+      it("should be part of the config"){subject[:global][:options].keys.should include(:option2) }
+    end
+
+    context "when an old option for a command is no longer there" do
+      let(:old_config_hash) { {:global => {:commands =>{}, :options => {:option1 => nil}}, :user => {:hello => :world}} }
+      let(:new_config_hash) { {:global => {:commands =>{}, :options => {:option2 => nil}}, :user => {}} }
+
+      it("should not be part of the config"){subject[:global][:options].keys.should_not include(:option1) }
+    end
+
+    context "when old config hash has user supplied value for option" do
+      let(:old_config_hash) { {:global => {:commands =>{}, :options => {:option1 => :hello}}, :user => {:hello => :world}} }
+      let(:new_config_hash) { {:global => {:commands =>{}, :options => {:option1 => nil}}, :user => {}} }
+
+      it("should retain the user supplied value for option"){subject[:global][:options][:option1].should == :hello }
+    end
+
+    context "when old user hash has values" do
+      let(:old_config_hash) { {:global => {:commands =>{}, :options => {}}, :user => {:hello => :world}} }
+      let(:new_config_hash) { {:global => {:commands =>{}, :options => {}}, :user => {}} }
+      it("should retain the user config values"){subject[:user][:hello].should == :world}
+    end
+  end
+end