convoy 1.0.0

data/lib/convoy/utils.rb

@@ -0,0 +1,21 @@
+require 'shellwords'
+
+module Convoy
+    class Utils
+        class << self
+            def symbolize_keys(hash)
+                hash.inject({}) do |result, (key, value)|
+                    new_key = (key.kind_of?(String) ? key.to_sym : key)
+                    new_value = (value.kind_of?(Hash) ? symbolize_keys(value) : value)
+                    result[new_key] = new_value
+                    result
+                end
+            end
+
+            def tokenize_option_string(option_string)
+                option_string ||= ''
+                Shellwords.shellwords(option_string)
+            end
+        end
+    end
+end

data/lib/convoy/validator.rb

@@ -0,0 +1,45 @@
+module Convoy
+    class Validator
+        class << self
+            def for(parser)
+                self.new(parser)
+            end
+        end
+
+        attr_reader :parser
+
+        def initialize(parser)
+            @parser = parser
+        end
+
+        def validate(options, validations)
+            validations.each do |option, validations_array|
+                if option_exists?(option)
+                    validate_option(option, options, validations_array)
+                else
+                    raise Convoy::ClientError.new("Unable to create validation for '#{option}' as no such option was defined, maybe you misspelled it")
+                end
+            end
+            options
+        end
+
+        private
+
+        def option_exists?(option)
+            parser.specs.keys.include?(option)
+        end
+
+        def validate_option(option, options, validations_array)
+            validations_array.each do |validation_data|
+                if invalid?(option, options, validation_data)
+                    raise Convoy::UserError.new("#{option} #{validation_data[:desc]}")
+                end
+                #parser.die(option, validation_data[:desc]) if invalid?(option, options, validation_data)
+            end
+        end
+
+        def invalid?(option, options, validation_data)
+            options[option] && !validation_data[:block].call(options[option])
+        end
+    end
+end

data/spec/integration/basic_config_file_spec.rb

@@ -0,0 +1,126 @@
+describe "Convoy basic app with config file defined", :integration => true do
+    include FakeFS::SpecHelpers
+
+    subject { Convoy::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|
+                Convoy::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
+
+    context "when config file specified" do
+        let(:autocreate) { false }
+
+        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
+
+        context "--config global option should exist" do
+            let(:option_string) { "--config=#{path}" }
+            it("should exit with code 0") { expect { subject }.to exit_with_code(0) }
+        end
+
+        context "convoy command should exist" do
+            let(:option_string) { "convoy -h" }
+            it("should exit with code 0") { expect { subject }.to exit_with_code(0) }
+
+            context "--create-config option for convoy command should exist" do
+                let(:option_string) { "convoy --create-config=#{path}" }
+                it("should exit with code 0") { expect { subject }.to exit_with_code(0) }
+            end
+
+            context "--create-default-config option for convoy command should exist" do
+                let(:option_string) { "convoy --create-default-config" }
+                it("should exit with code 0") { expect { subject }.to exit_with_code(0) }
+            end
+
+            context "--update-config option for convoy command should exist" do
+                let(:option_string) { "convoy --update-config=#{path}" }
+                it("should exit with code 0") { expect { subject }.to exit_with_code(0) }
+            end
+
+            context "--update-default-config option for convoy command should exist" do
+                let(:option_string) { "convoy --update-default-config" }
+                it("should exit with code 0") { expect { subject }.to exit_with_code(0) }
+            end
+        end
+    end
+end

data/spec/integration/basic_conflicts_spec.rb

@@ -0,0 +1,47 @@
+describe "Convoy basic app with conflicting options", :integration => true do
+    subject { Convoy::App.create(option_string, &app_configuration) }
+
+    let(:app_configuration) do
+        lambda do |app|
+            app.options do |opts|
+                opts.opt :flag1, "Flag 1", :short => '-f', :long => '--flag1', :type => :boolean
+                opts.opt :flag2, "Flag 2", :short => :none, :long => '--flag2', :type => :boolean
+
+                opts.conflict :flag1, :flag2
+            end
+
+            app.action do |options, arguments|
+                Convoy::IntegrationTestCommand.new(options, arguments).execute(result)
+            end
+        end
+    end
+
+    context "when conflicting options supplied" do
+        let(:option_string) { "--flag1 --flag2" }
+        it("should exit with code 2 or 3") { expect { subject }.to exit_with_code(2, 3) }
+    end
+
+    context "when no conflicting options supplied" do
+        let(:option_string) { "--flag1" }
+        it("should exit with code 0") { expect { subject }.to exit_with_code(0) }
+    end
+
+    context "when non-existant option in conflict list" do
+        let(:app_configuration) do
+            lambda do |app|
+                app.options do |opts|
+                    opts.opt :flag1, "Flag 1", :short => '-f', :long => '--flag1', :type => :boolean
+                    opts.opt :flag2, "Flag 2", :short => :none, :long => '--flag2', :type => :boolean
+
+                    opts.conflict :flag1, :flag2, :flag3
+                end
+
+                app.action do |options, arguments|
+                    Convoy::IntegrationTestCommand.new(options, arguments).execute(result)
+                end
+            end
+        end
+        let(:option_string) { "--flag1" }
+        it("should exit with code 2") { expect { subject }.to exit_with_code(2) }
+    end
+end

data/spec/integration/basic_depends_on_spec.rb

@@ -0,0 +1,275 @@
+describe "Convoy basic app with dependent options", :integration => true do
+    subject { Convoy::App.create(option_string, &app_configuration) }
+
+    context "when dependency specification has no 'on' parameter" do
+        let(:app_configuration) do
+            lambda do |app|
+                app.options do |opts|
+                    opts.opt :flag1, "Flag 1", :short => '-f', :long => '--flag1', :type => :boolean
+                    opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+
+                    opts.dependency :option1
+                end
+
+                app.action do |options, arguments|
+                    Convoy::IntegrationTestCommand.new(options, arguments).execute(result)
+                end
+            end
+        end
+        let(:option_string) { "-f" }
+        it("it should not exit successfully") { expect { subject }.to_not exit_with_code(0) }
+    end
+
+    context "when option dependent on presence of flag" do
+        let(:app_configuration) do
+            lambda do |app|
+                app.options do |opts|
+                    opts.opt :flag1, "Flag 1", :short => '-f', :long => '--flag1', :type => :boolean
+                    opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+
+                    opts.dependency :option1, :on => :flag1
+                end
+
+                app.action do |options, arguments|
+                    Convoy::IntegrationTestCommand.new(options, arguments).execute(result)
+                end
+            end
+        end
+
+        context "and flag is not present" do
+            let(:option_string) { "-o foo" }
+            it("it should not exit successfully") { expect { subject }.to_not exit_with_code(0) }
+        end
+
+        context "and flag is present" do
+            let(:option_string) { "-f -o foo" }
+            it("it should exit successfully") { expect { subject }.to exit_with_code(0) }
+        end
+    end
+
+    context "when flag depends on another flag" do
+        let(:app_configuration) do
+            lambda do |app|
+                app.options do |opts|
+                    opts.opt :flag1, "Flag 1", :short => '-f', :long => '--flag1', :type => :boolean
+                    opts.opt :flag2, "Flag 2", :short => :none, :long => '--flag2', :type => :boolean, :default => true
+                    opts.opt :flag3, "Flag 3", :short => :none, :long => '--flag3', :type => :boolean
+                    opts.opt :flag4, "Flag 4", :short => :none, :long => '--flag4', :type => :boolean
+
+                    opts.dependency :flag3, :on => :flag1
+                    opts.dependency :flag4, :on => :flag2
+                end
+
+                app.action do |options, arguments|
+                    Convoy::IntegrationTestCommand.new(options, arguments).execute(result)
+                end
+            end
+        end
+
+        context "and other flag has a default value of false" do
+            context "and other flag is present" do
+                let(:option_string) { "--flag1 --flag3" }
+                it("it should exit successfully") { expect { subject }.to exit_with_code(0) }
+            end
+
+            context "and other flag is not present" do
+                let(:option_string) { "--flag3" }
+                it("it should not exit successfully") { expect { subject }.to_not exit_with_code(0) }
+            end
+        end
+
+        context "and other flag has a default value of true" do
+            context "and other flag is present" do
+                let(:option_string) { "--flag2 --flag4" }
+                it("it should exit successfully") { expect { subject }.to exit_with_code(0) }
+            end
+
+            context "and other flag is not present" do
+                let(:option_string) { "--flag4" }
+                it("it should exit successfully") { expect { subject }.to exit_with_code(0) }
+            end
+
+            context "and other flag negative option is used" do
+                let(:option_string) { "--no-flag2 --flag4" }
+                it("it should not exit successfully") { expect { subject }.to_not exit_with_code(0) }
+            end
+        end
+    end
+
+    context "when option dependent on presence of multiple other options" do
+        let(:app_configuration) do
+            lambda do |app|
+                app.options do |opts|
+                    opts.opt :flag1, "Flag 1", :short => '-f', :long => '--flag1', :type => :boolean
+                    opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+                    opts.opt :option2, "Option2", :short => :none, :long => '--option2', :type => :string, :multi => true
+
+                    opts.dependency :option2, :on => [:flag1, :option1]
+                end
+
+                app.action do |options, arguments|
+                    Convoy::IntegrationTestCommand.new(options, arguments).execute(result)
+                end
+            end
+        end
+
+        context "and one of the other options is not present" do
+            let(:option_string) { "-f --option2=foo" }
+            it("it should not exit successfully") { expect { subject }.to_not exit_with_code(0) }
+        end
+
+        context "and none of the other options are present" do
+            let(:option_string) { "--option2=foo" }
+            it("it should not exit successfully") { expect { subject }.to_not exit_with_code(0) }
+        end
+
+        context "and all of the other options are present" do
+            let(:option_string) { "-f -o bar --option2=foo" }
+            it("it should exit successfully") { expect { subject }.to exit_with_code(0) }
+        end
+    end
+
+    context "when option dependent on other option value" do
+        let(:app_configuration) do
+            lambda do |app|
+                app.options do |opts|
+                    opts.opt :flag1, "Flag 1", :short => '-f', :long => '--flag1', :type => :boolean
+                    opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+                    opts.opt :option2, "Option2", :short => :none, :long => '--option2', :type => :string, :multi => true
+
+                    opts.dependency :option2, :on => {:option1 => 'bar'}
+                end
+
+                app.action do |options, arguments|
+                    Convoy::IntegrationTestCommand.new(options, arguments).execute(result)
+                end
+            end
+        end
+
+        context "and other option is supplied with this value" do
+            let(:option_string) { "-o bar --option2=foo" }
+            it("it should exit successfully") { expect { subject }.to exit_with_code(0) }
+        end
+
+        context "and other option is supplied with different value" do
+            let(:option_string) { "-o baz --option2=foo" }
+            it("it should not exit successfully") { expect { subject }.to_not exit_with_code(0) }
+        end
+
+        context "and other option is not supplied" do
+            let(:option_string) { "--option2=foo" }
+            it("it should not exit successfully") { expect { subject }.to_not exit_with_code(0) }
+        end
+    end
+
+    context "when option dependent on other option value and presence of yet another option" do
+        let(:app_configuration) do
+            lambda do |app|
+                app.options do |opts|
+                    opts.opt :flag1, "Flag 1", :short => '-f', :long => '--flag1', :type => :boolean
+                    opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+                    opts.opt :option2, "Option2", :short => :none, :long => '--option2', :type => :string, :multi => true
+
+                    opts.dependency :option2, :on => [:flag1, {:option1 => 'bar'}]
+                end
+
+                app.action do |options, arguments|
+                    Convoy::IntegrationTestCommand.new(options, arguments).execute(result)
+                end
+            end
+        end
+
+        context "and yet another option is not present" do
+            let(:option_string) { "-o bar --option2=foo" }
+            it("it should not exit successfully") { expect { subject }.to_not exit_with_code(0) }
+        end
+
+        context "and other option has different value" do
+            let(:option_string) { "-o baz -f --option2=foo" }
+            it("it should not exit successfully") { expect { subject }.to_not exit_with_code(0) }
+        end
+
+        context "and other option has the right value and yet another option is present" do
+            let(:option_string) { "-o bar -f --option2=foo" }
+            it("it should exit successfully") { expect { subject }.to exit_with_code(0) }
+        end
+    end
+
+    context "when option dependent on itself" do
+        let(:app_configuration) do
+            lambda do |app|
+                app.options do |opts|
+                    opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+
+                    opts.dependency :option1, :on => :option1
+                end
+
+                app.action do |options, arguments|
+                    Convoy::IntegrationTestCommand.new(options, arguments).execute(result)
+                end
+            end
+        end
+        let(:option_string) { "-o bar" }
+        it("it should not exit successfully") { expect { subject }.to_not exit_with_code(0) }
+    end
+
+    context "when dependency specified for non-existant option" do
+        let(:app_configuration) do
+            lambda do |app|
+                app.options do |opts|
+                    opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+
+                    opts.dependency :option2, :on => :option1
+                end
+
+                app.action do |options, arguments|
+                    Convoy::IntegrationTestCommand.new(options, arguments).execute(result)
+                end
+            end
+        end
+        let(:option_string) { "-o bar" }
+        it("it should not exit successfully") { expect { subject }.to_not exit_with_code(0) }
+    end
+
+    context "when option dependent on non-existant option" do
+        let(:app_configuration) do
+            lambda do |app|
+                app.options do |opts|
+                    opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string
+
+                    opts.dependency :option1, :on => :option2
+                end
+
+                app.action do |options, arguments|
+                    Convoy::IntegrationTestCommand.new(options, arguments).execute(result)
+                end
+            end
+        end
+        let(:option_string) { "-o bar" }
+        it("it should not exit successfully") { expect { subject }.to_not exit_with_code(0) }
+    end
+
+    context "when dependency is specified inline" do
+        let(:app_configuration) do
+            lambda do |app|
+                app.options do |opts|
+                    opts.opt :flag1, "Flag 1", :short => '-f', :long => '--flag1', :type => :boolean
+                    opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string, :depends_on => :flag1
+                end
+
+                app.action do |options, arguments|
+                    Convoy::IntegrationTestCommand.new(options, arguments).execute(result)
+                end
+            end
+        end
+        context "and dependency is satisfied" do
+            let(:option_string) { "-f -o bar" }
+            it("it should exit successfully") { expect { subject }.to exit_with_code(0) }
+        end
+
+        context "and dependency is not satisfied" do
+            let(:option_string) { "-o bar" }
+            it("it should not exit successfully") { expect { subject }.to_not exit_with_code(0) }
+        end
+    end
+end