bovem 2.4.1 → 3.0.0

data/lib/bovem/shell.rb

@@ -561,12 +561,12 @@ module Bovem
     #
     # @return [Shell] A new instance.
     def self.instance
-      @instance ||= ::Bovem::Shell.new
+      @instance ||= Bovem::Shell.new
     end
 
     # Initializes a new Shell.
     def initialize
-      @console = ::Bovem::Console.instance
+      @console = Bovem::Console.instance
       i18n_setup(:bovem, ::File.absolute_path(::Pathname.new(::File.dirname(__FILE__)).to_s + "/../../locales/"))
     end
   end

data/lib/bovem/version.rb

@@ -11,13 +11,13 @@ module Bovem
   # @see http://semver.org
   module Version
     # The major version.
-    MAJOR = 2
+    MAJOR = 3
 
     # The minor version.
-    MINOR = 4
+    MINOR = 0
 
     # The patch version.
-    PATCH = 1
+    PATCH = 0
 
     # The current version number of Bovem.
     STRING = [MAJOR, MINOR, PATCH].compact.join(".")

data/locales/en.yml

@@ -41,3 +41,36 @@
       mkdir_file: "Path {mark=bright}%1{/mark} is currently a file."
       mkdir_denied: "Cannot create following directory due to permission denied: {mark=bright}%1{/mark}."
       mkdir_error: "Cannot create following directories:"
+    application:
+      default_application_name: "__APPLICATION__"
+      ambigous_command: "Command shortcut \"%1\" is ambiguous across commands %2. Please add some other characters."
+      needless_argument: "Option %1 does not expects an argument."
+      missing_argument: "Option %1 expects an argument."
+      invalid_option: "Invalid option %1."
+      invalid_integer: "Option %1 expects a valid integer as argument."
+      invalid_float: "Option %1 expects a valid floating number as argument."
+      conflicting_options: "Options %1 and %2 have conflicting forms."
+      missing_option: "Required option %1 is missing."
+      invalid_value: "Value of option %1 must be one of these values: %2."
+      invalid_for_regexp: "Value of option %1 must match the regular expression: %2."
+      help_option_short_form: "-h"
+      help_option_long_form: "--help"
+      help_message: "Shows this message."
+      help_arg: "ARG"
+      help_name: "[NAME]"
+      help_application_synopsis: "%s [options] %s[command-options] [arguments] "
+      help_command_synopsis: "%s [options] %s %s[command-options] [arguments] "
+      help_synopsis: "[SYNOPSIS]"
+      help_description: "[DESCRIPTION]"
+      help_no_description: "*NO DESCRIPTION PROVIDED*"
+      help_options: "[OPTIONS]"
+      help_global_options: "[GLOBAL OPTIONS]"
+      help_commands: "[COMMANDS]"
+      help_subcommands: "[SUBCOMMANDS]"
+      help_subcommand_invocation: "[command [sub-command ...]] "
+      help_subsubcommand_invocation: "[sub-command [sub-sub-command ...]] "
+      help_command_description: "Shows a help about a command."
+      existing_command: "The command \"%1\" already exists."
+      existing_option_global: "The global option \"%1\" already exists."
+      existing_option: "The option \"%1\" already exists for the command \"%2\"."
+      missing_app_block: "You have to provide a block to the Bovem::Application constructor!"

data/locales/it.yml

@@ -41,3 +41,36 @@
       mkdir_file: "Il percorso {mark=bright}%1{/mark} è attualmente un file."
       mkdir_denied: "Impossible creare la seguente cartella a causa di permessi negati: {mark=bright}%1{/mark}."
       mkdir_error: "Impossibile creare le seguenti cartelle:"
+    application:
+      default_application_name: "__APPLICAZIONE__"
+      ambigous_command: "La scorciatoia di comando \"%1\" è ambigua tra i seguenti comandi %2. Per favore aggiungi qualche altro carattere."
+      needless_argument: "L'opzione %1 non richiede un argomento."
+      missing_argument: "L'opzione %1 richiede un argomento."
+      invalid_option: "L'opzione %1 non è valida."
+      invalid_integer: "L'opzione %1 richiede un numero intero valido come argomento."
+      invalid_float: "L'opzione %1 richiede un numero decimale valido come argomento."
+      conflicting_options: "Le opzioni %1 e %2 hanno forme in conflitto."
+      missing_option: "L'opzione richiesta %1 è mancante."
+      invalid_value: "Il valore dell'opzione %1 deve essere uno dei seguenti valori: %2."
+      invalid_for_regexp: "Il valore dell'opzione %1 deve soddisfare questa espressione regolare: %2."
+      help_option_short_form: "-h"
+      help_option_long_form: "--help"
+      help_message: "Mostra questo messaggio."
+      help_arg: "ARG"
+      help_name: "[NOME]"
+      help_application_synopsis: "%s [opzioni] %s[opzioni-comando] [argomenti] "
+      help_command_synopsis: "%s [opzioni] %s %s[opzioni-comando] [argomenti] "
+      help_synopsis: "[UTILIZZO]"
+      help_description: "[DESCRIZIONE]"
+      help_no_description: "*NESSUNA DESCRIZIONE FORNITA*"
+      help_options: "[OPZIONI]"
+      help_global_options: "[OPZIONI GLOBALI]"
+      help_commands: "[COMANDI]"
+      help_subcommands: "[SOTTOCOMANDI]"
+      help_subcommand_invocation: "[comando [sotto-comando ...]] "
+      help_subsubcommand_invocation: "[sotto-comando [sotto-sotto-comando ...]] "
+      help_command_description: "Mostra aiuto riguardo un comando."
+      existing_command: "Il comando \"%1\" è già esistente."
+      existing_option_global: "L'opzione globale \"%1\" è già esistente."
+      existing_option: "L'opzione \"%1\" è già esistente per il comando \"%2\"."
+      missing_app_block: "Devi fornire un blocco per il costruttore di Bovem::Application!"

data/spec/bovem/application_spec.rb

@@ -0,0 +1,170 @@
+# encoding: utf-8
+#
+# This file is part of the bovem gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+require "spec_helper"
+
+describe Bovem::Application do
+  let(:application) { Bovem::Application.new(locale: :en) }
+
+  describe "#initialize" do
+    it "should call the parent constructor" do
+      options = {a: :b}
+      block = Proc.new {}
+
+      expect(Bovem::Command).to receive(:new).with(options, &block)
+      Bovem::Application.new(options, &block)
+    end
+
+    it "should set good defaults" do
+      expect(application.shell).to eq(Bovem::Shell.instance)
+      expect(application.console).to eq(application.shell.console)
+      expect(application.skip_commands).to be_false
+      expect(application.show_commands).to be_false
+      expect(application.output_commands).to be_false
+    end
+  end
+
+  describe "#version" do
+    it "should set and return the version" do
+      expect(application.version).to be_nil
+      expect(application.version("another")).to eq("another")
+      expect(application.version(nil)).to eq("another")
+    end
+  end
+
+  describe "#help_option" do
+    it "should add a command and a option" do
+      expect(application).to receive(:command).with(:help, {description: "Shows a help about a command."})
+      expect(application).to receive(:option).with(:help, ["-h", "--help"], {help: "Shows this message."})
+      application.help_option
+    end
+
+    it "should execute associated actions" do
+      expect(application).to receive(:show_help).exactly(2)
+      expect(application).to receive(:command_help)
+
+      application.execute(["help", "command"])
+      application.execute("-h")
+    end
+  end
+
+  describe "#executable_name" do
+    it "should return executable name" do
+      expect(application.executable_name).to eq($0)
+    end
+  end
+
+  describe "#command_help" do
+    it "should show the help for the command" do
+      command = application.command "command"
+      subcommand = command.command "subcommand"
+
+      expect(application).to receive(:show_help)
+      application.command_help(application)
+
+      expect(command).to receive(:show_help)
+      application.argument(command.name)
+      application.command_help(application)
+
+      expect(subcommand).to receive(:show_help)
+      application.argument(subcommand.name)
+      application.command_help(application)
+
+      expect(subcommand).to receive(:show_help)
+      application.argument("foo")
+      application.command_help(application)
+    end
+  end
+
+  describe "#run" do
+    it "should forward to the shell" do
+      expect(application.shell).to receive(:run).with("COMMAND", "MESSAGE", true, "A", false, false, "B")
+      application.run("COMMAND", "MESSAGE", "A", "B")
+
+      application.skip_commands = true
+      application.output_commands = true
+      application.show_commands = true
+      expect(application.shell).to receive(:run).with("COMMAND", "MESSAGE", false, "C", true, true, "D")
+      application.run("COMMAND", "MESSAGE", "C", "D")
+    end
+  end
+
+  describe ".create" do
+    it "should complain about a missing block" do
+      expect { Bovem::Application.create }.to raise_error(Bovem::Errors::Error)
+    end
+
+    it "should print errors" do
+      allow(Bovem::Application).to receive(:create_application).and_raise(ArgumentError.new("ERROR"))
+      expect(Kernel).to receive(:puts).with("ERROR")
+      expect(Kernel).to receive(:exit).with(1)
+      Bovem::Application.create(__args__: []) {}
+    end
+
+    it "should create a default application" do
+      expect(Bovem::Application).to receive(:new).with({name: "__APPLICATION__", parent: nil, application: nil, locale: :en})
+      Bovem::Application.create({locale: :en}) {}
+    end
+
+    it "should create an application with given options and block" do
+      options = {name: "OK"}
+
+      expect(Bovem::Application).to receive(:new).with({name: "OK", parent: nil, application: nil})
+      application = Bovem::Application.create(options) {}
+    end
+
+    it "should execute the block" do
+      allow_any_instance_of(Bovem::Console).to receive(:write)
+      allow(Kernel).to receive(:exit)
+      options = {name: "OK", __args__: []}
+      check = false
+
+      application = Bovem::Application.create(options) { check = true }
+      expect(check).to be_true
+      expect(application.name).to eq("OK")
+    end
+
+    it "should execute the new application" do
+      args = []
+
+      application = Bovem::Application.create do
+        option("require", [], {})
+        option("format", [], {})
+        option("example", [], {})
+
+        action do |command|
+          args = command.arguments.join("-")
+        end
+      end
+
+      expect(args).to eq(ARGV.reject {|a| a =~ /^--/ }.join("-"))
+    end
+
+    it "can override arguments" do
+      args = []
+
+      application = Bovem::Application.create({__args__: ["C", "D"]}) do
+        action do |command|
+          args = command.arguments.join("-")
+        end
+      end
+
+      expect(args).to eq("C-D")
+    end
+
+    it "should not execute the application if requested to" do
+      args = []
+
+      application = Bovem::Application.create(run: false) do
+        action do |command|
+          args = command.arguments.join("-")
+        end
+      end
+
+      expect(args).to eq([])
+    end
+  end
+end

data/spec/bovem/command_spec.rb

@@ -0,0 +1,526 @@
+# encoding: utf-8
+#
+# This file is part of the bovem gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+require "spec_helper"
+
+describe Bovem::Command do
+  let(:application) {
+    Bovem::Application.new(locale: :en) {
+      action {}
+    }
+  }
+
+  let(:command) {
+    c = Bovem::Command.new(locale: :en)
+    c.application = application
+    c
+  }
+
+  describe "#initialize" do
+    it "should forward to #setup_with" do
+      expect(Bovem::Command.new(name: "command").name).to eq("command")
+    end
+
+    it "should call the block" do
+      count = 0
+      Bovem::Command.new(name: "command") { count += 1 }
+      expect(count).to eq(1)
+    end
+  end
+
+  describe "#name" do
+    it "should set and return the name" do
+      expect(command.name).to be_nil
+      expect(command.name("another")).to eq("another")
+      expect(command.name(nil)).to eq("another")
+    end
+  end
+
+  describe "#full_name" do
+    it "should retrieve the full hierarchy of the name" do
+      command.name = "root"
+      expect(command.full_name).to eq("root")
+
+      subcommand = Bovem::Command.new(name: "child")
+      subcommand.parent = command
+      expect(subcommand.full_name).to eq("root:child")
+      expect(subcommand.full_name(nil, " ")).to eq("root child")
+      expect(subcommand.full_name("A", " ")).to eq("root child A")
+    end
+  end
+
+  describe "#description" do
+    it "should set and return the description" do
+      expect(command.description).to be_nil
+      expect(command.description("another")).to eq("another")
+      expect(command.description(nil)).to eq("another")
+    end
+  end
+
+  describe "#banner" do
+    it "should set and return the banner" do
+      expect(command.banner).to be_nil
+      expect(command.banner("another")).to eq("another")
+      expect(command.banner(nil)).to eq("another")
+    end
+
+  end
+
+  describe "#synopsis" do
+    it "should set and return the synopsis" do
+      expect(command.synopsis).to be_nil
+      expect(command.synopsis("another")).to eq("another")
+      expect(command.synopsis(nil)).to eq("another")
+    end
+  end
+
+  describe "#before" do
+    it "should set and return the before hook" do
+      valid = Proc.new{|a| puts "OK" }
+
+      expect(command.before).to be_nil
+      expect(command.before(1)).to be_nil
+      expect(command.before { puts "OK" }).to be_nil
+      expect(command.before {|a, b| puts "OK" }).to be_nil
+      expect(command.before(:method)).to eq(:method)
+      expect(command.action("METHOD")).to eq("METHOD")
+      expect(command.before(&valid)).to eq(valid)
+      expect(command.before("METHOD", &valid)).to eq("METHOD")
+    end
+  end
+
+  describe "#action" do
+    it "should set and return the action" do
+      valid = Proc.new{|a| puts "OK" }
+
+      expect(command.action).to be_nil
+      expect(command.action(1)).to be_nil
+      expect(command.action { puts "OK" }).to be_nil
+      expect(command.action {|a, b| puts "OK" }).to be_nil
+      expect(command.action(:method)).to eq(:method)
+      expect(command.action("METHOD")).to eq("METHOD")
+      expect(command.action(&valid)).to eq(valid)
+      expect(command.action("METHOD", &valid)).to eq("METHOD")
+    end
+  end
+
+  describe "#after" do
+    it "should set and return the after hook" do
+      valid = Proc.new{|a| puts "OK" }
+
+      expect(command.after).to be_nil
+      expect(command.after(1)).to be_nil
+      expect(command.after { puts "OK" }).to be_nil
+      expect(command.after {|a, b| puts "OK" }).to be_nil
+      expect(command.after(:method)).to eq(:method)
+      expect(command.after("METHOD")).to eq("METHOD")
+      expect(command.after(&valid)).to eq(valid)
+      expect(command.after("METHOD", &valid)).to eq("METHOD")
+    end
+  end 
+
+  describe "#has_description?" do
+    it "should check if the command has a description" do
+      expect(Bovem::Command.new.has_description?).to be_false
+      expect(Bovem::Command.new({description: "DESCRIPTION"}).has_description?).to be_true
+    end
+  end
+
+  describe "#has_banner?" do
+    it "should check if the command has a banner" do
+      expect(Bovem::Command.new.has_banner?).to be_false
+      expect(Bovem::Command.new({banner: "BANNER"}).has_banner?).to be_true
+    end
+  end
+
+  describe "#command" do
+    it "should add a subcommand" do
+      command.command("subcommand", {banner: "BANNER"}) do |option|
+        description("DESCRIPTION")
+      end
+
+      subcommand = command.commands["subcommand"]
+
+      expect(subcommand.name).to eq("subcommand")
+      expect(subcommand.parent).to be(command)
+      expect(subcommand.application).to be(application)
+      expect(subcommand.banner).to eq("BANNER")
+      expect(subcommand.description).to eq("DESCRIPTION")
+    end
+
+    it "should check for duplicates" do
+      command.command("subcommand")
+      expect {command.command("subcommand")}.to raise_error(Bovem::Errors::Error)
+    end
+  end
+
+  describe "#option" do
+    it "should add a subcommand" do
+      command.option("option", ["short", "long"], {type: String, help: "HELP"})
+
+      option = command.options["option"]
+
+      expect(option.name).to eq("option")
+      expect(option.short).to eq("s")
+      expect(option.long).to eq("long")
+      expect(option.help).to eq("HELP")
+    end
+
+    it "should check for duplicates" do
+      application.option("option")
+      command.option("option")
+      expect {command.option("option")}.to raise_error(Bovem::Errors::Error)
+      expect {application.option("option")}.to raise_error(Bovem::Errors::Error)
+    end
+  end
+
+  describe "#commands" do
+    it "should return the list of commands" do
+      expect(command.commands).to eq({})
+      command.command("subcommand1")
+      command.command("subcommand2")
+      expect(command.commands.values.collect(&:name).sort).to eq(["subcommand1", "subcommand2"])
+    end
+
+    it "should let access both with Symbol or String" do
+      command.command("subcommand1")
+      expect(command.commands).to be_a(HashWithIndifferentAccess)
+      expect(command.commands[:subcommand1]).to eq(command.commands["subcommand1"])
+    end
+  end
+
+  describe "#clear_commands" do
+    it "should remove commands" do
+      command.command("subcommand")
+      expect(command.commands.length == 1)
+      command.clear_commands
+      expect(command.commands.length == 0)
+    end
+  end
+
+  describe "#has_commands?" do
+    it "should check if the command has subcommands" do
+      expect(command.has_commands?).to be_false
+      command.command("subcommand")
+      expect(command.has_commands?).to be_true
+    end
+  end
+
+  describe "#clear_options" do
+    it "should remove options" do
+      command.option("option")
+      expect(command.options.length == 1)
+      command.clear_options
+      expect(command.options.length == 0)
+    end
+  end
+
+  describe "#options" do
+    it "should return the list of options" do
+      expect(command.options).to eq({})
+      command.option("option1")
+      command.option("option2")
+      expect(command.options.values.collect(&:name).sort).to eq(["option1", "option2"])
+    end
+
+    it "should let access both with Symbol or String" do
+      command.option("option1")
+      expect(command.options).to be_a(HashWithIndifferentAccess)
+      expect(command.options[:option1]).to eq(command.options["option1"])
+    end
+  end
+
+  describe "#has_options?" do
+    it "should check if the command has options" do
+      expect(command.has_options?).to be_false
+      command.option("option")
+      expect(command.has_options?).to be_true
+    end
+  end
+
+  describe "#argument" do
+    it "should add an argument to the command" do
+      expect(command.arguments).to eq([])
+      command.argument("A")
+      expect(command.arguments).to eq(["A"])
+      command.argument("B")
+      expect(command.arguments).to eq(["A", "B"])
+    end
+  end
+
+  describe "#arguments" do
+    it "should return arguments" do
+      expect(command.arguments).to eq([])
+      command.argument("A")
+      expect(command.arguments).to eq(["A"])
+      command.argument("B")
+      expect(command.arguments).to eq(["A", "B"])
+    end
+  end
+
+  describe "#application" do
+    it "should return the application" do
+      expect(command.application).to be(application)
+      expect(application.application).to be(application)
+    end
+  end
+
+  describe "#is_application?" do
+    it "should check if the command is an application" do
+      expect(command.is_application?).to be_false
+      expect(application.is_application?).to be_true
+    end
+  end
+
+  describe "#setup_with" do
+    it "should setup required option by calling proper methods" do
+      expect(command).to receive("name").with("new-command")
+      expect(command).to receive("application=").with(nil)
+      command.setup_with({name: "new-command", application: nil, invalid: false})
+    end
+  end
+
+  describe "#execute" do
+    it "should parse command line" do
+      allow(Kernel).to receive(:exit)
+      allow_any_instance_of(Bovem::Console).to receive(:write)
+
+      args = ["command"]
+      expect(Bovem::Parser).to receive(:parse).with(command, args)
+      command.execute(args)
+    end
+
+    it "should execute hooks and actions in sequence" do
+      check = []
+      child = []
+      args = ["command"]
+
+      command.before do |command|
+        check << "A"
+      end
+
+      command.action do |command|
+        check << "B"
+      end
+
+      command.after do |command|
+        check << "C"
+      end
+
+      command.command("subcommand") do
+        before do |command|
+          check << "D"
+        end
+
+        action do |command|
+          check << "E"
+        end
+
+        after do |command|
+          check << "F"
+        end
+      end
+
+      allow(Bovem::Parser).to receive(:parse).and_return(nil)
+      command.execute(args)
+      expect(check).to eq(["A", "B", "C"])
+    end
+
+    it "should execute the hooks even they are methods" do
+      check = []
+      child = []
+      args = ["command"]
+
+      allow(command).to receive(:application).and_return(Object.new)
+      allow(command.application).to receive(:action_before) { check << "A" }
+      allow(command.application).to receive("action_perform") { check << "B" }
+      allow(command.application).to receive(:action_after) { check << "C" }
+
+      command.before(:action_before)
+      command.action("action_perform")
+      command.after(:action_after)
+
+      allow(Bovem::Parser).to receive(:parse).and_return(nil)
+      command.execute(args)
+      expect(check).to eq(["A", "B", "C"])
+    end
+
+    it "should skip its actions and hooks and pass control to the subcommand" do
+      check = []
+      child = []
+      args = ["command"]
+
+      command.before do |command|
+        check << "A"
+      end
+
+      command.action do |command|
+        check << "B"
+      end
+
+      command.after do |command|
+        check << "C"
+      end
+
+      command.command("subcommand") do
+        before do |command|
+          check << "D"
+        end
+
+        action do |command|
+          check << "E"
+        end
+
+        after do |command|
+          check << "F"
+        end
+      end
+
+      allow(Bovem::Parser).to receive(:parse) do |cmd, args|
+        cmd == command ? {name: "subcommand", args: args} : nil
+      end
+      command.execute(args)
+      expect(check).to eq(["D", "E", "F"])
+    end
+
+    it "should show help if action is not defined and no subcommand is found" do
+      check = []
+      child = []
+      args = ["command"]
+
+      command.command("subcommand") do
+        before do |command|
+          check << "D"
+        end
+
+        action do |command|
+          check << "E"
+        end
+
+        after do |command|
+          check << "F"
+        end
+      end
+
+      allow(Bovem::Parser).to receive(:parse).and_return(nil)
+      expect(command).to receive(:show_help)
+      command.execute(args)
+      expect(check).to eq([])
+    end
+  end
+
+  describe "#get_options" do
+    let(:reference){
+      c = Bovem::Command.new("command") do
+        option("aaa", [], {type: Integer, default: 456})
+        option("bbb", [], {type: String})
+        option("ccc", [], {type: Array, default: ["1", "2"]})
+      end
+
+      c.application = Bovem::Application.new do |a|
+        option("aaa", [], {type: Integer, default: 123})
+        option("ddd", [], {type: Float})
+        action {}
+      end
+
+      c
+    }
+
+    it "should return the full list of options" do
+      Bovem::Parser.parse(reference.application, ["--aaa", "111", "--ddd", "2.0"])
+      Bovem::Parser.parse(reference, ["--bbb", "2.0", "--ccc", "A,B,C"])
+      expect(reference.get_options.symbolize_keys).to eq({application_aaa: 111, application_ddd: 2.0, aaa: 456, bbb: "2.0", ccc: ["A", "B", "C"]})
+    end
+
+    it "should only return provided options if required to" do
+      Bovem::Parser.parse(reference.application, ["--aaa", "111"])
+      Bovem::Parser.parse(reference, ["--ccc", "2.0"])
+      expect(reference.get_options(false).symbolize_keys).to eq({application_aaa: 111, aaa: 456, ccc: ["2.0"]})
+    end
+
+    it "should skip application options if required to" do
+      Bovem::Parser.parse(reference.application, ["--aaa", "111", "--ddd", "2.0"])
+      Bovem::Parser.parse(reference, ["--bbb", "2.0", "--ccc", "A,B,C"])
+      expect(reference.get_options(true, false).symbolize_keys).to eq({aaa: 456, bbb: "2.0", ccc: ["A", "B", "C"]})
+      expect(reference.get_options(true, nil).symbolize_keys).to eq({aaa: 456, bbb: "2.0", ccc: ["A", "B", "C"]})
+    end
+
+    it "should apply the requested prefix for command options" do
+      Bovem::Parser.parse(reference.application, ["--aaa", "111", "--ddd", "2.0"])
+      Bovem::Parser.parse(reference, ["--bbb", "2.0", "--ccc", "A,B,C"])
+      expect(reference.get_options(true, false, "PREFIX").symbolize_keys).to eq({PREFIXaaa: 456, PREFIXbbb: "2.0", PREFIXccc: ["A", "B", "C"]})
+    end
+
+    it "should apply the requested prefix for application options" do
+      Bovem::Parser.parse(reference.application, ["--aaa", "111", "--ddd", "2.0"])
+      Bovem::Parser.parse(reference, ["--bbb", "2.0", "--ccc", "A,B,C"])
+      expect(reference.get_options(true, "APP").symbolize_keys).to eq({APPaaa: 111, APPddd: 2.0, aaa: 456, bbb: "2.0", ccc: ["A", "B", "C"]})
+    end
+
+    it "should only return requested options" do
+      Bovem::Parser.parse(reference.application, ["--aaa", "111", "--ddd", "2.0"])
+      Bovem::Parser.parse(reference, ["--bbb", "2.0", "--ccc", "A,B,C"])
+      expect(reference.get_options(true, "application_", "", :aaa, :bbb).symbolize_keys).to eq({application_aaa: 111, aaa: 456, bbb: "2.0"})
+    end
+
+    it "should apply higher precedence to command options in case of conflicts" do
+      Bovem::Parser.parse(reference.application, ["--aaa", "111", "--ddd", "2.0"])
+      Bovem::Parser.parse(reference, ["--bbb", "2.0", "--ccc", "A,B,C"])
+      expect(reference.get_options(true, "", "").symbolize_keys).to eq({ddd: 2.0, aaa: 456, bbb: "2.0", ccc: ["A", "B", "C"]})
+    end
+  end
+
+  describe "#show_help" do
+    it "should behave differently for application" do
+      allow(Kernel).to receive(:exit).and_return(0)
+
+      expect(application.console).to receive(:write).with("[NAME]")
+      expect(application.console).to receive(:write).at_least(1)
+      application.show_help
+    end
+
+    it "should print a banner" do
+      allow(Kernel).to receive(:exit).and_return(0)
+
+      command.banner = "BANNER"
+      expect(application.console).to receive(:write).with("[DESCRIPTION]")
+      expect(application.console).to receive(:write).at_least(1)
+      command.show_help
+    end
+
+    it "should print options" do
+      allow(Kernel).to receive(:exit).and_return(0)
+
+      application.option("global", [], {type: String})
+      command.option("local")
+
+      expect(application.console).to receive(:write).with("[GLOBAL OPTIONS]")
+      expect(application.console).to receive(:write).with("[OPTIONS]")
+      expect(application.console).to receive(:write).at_least(1)
+      application.show_help
+      command.show_help
+    end
+
+    it "should print subcommands" do
+      allow(Kernel).to receive(:exit).and_return(0)
+
+      command.command("subcommand")
+      expect(application.console).to receive(:write).with("[COMMANDS]")
+      expect(application.console).to receive(:write).with("[SUBCOMMANDS]")
+      expect(application.console).to receive(:write).at_least(1)
+      application.show_help
+      command.show_help
+    end
+
+    it "should exit" do
+      allow(Kernel).to receive(:puts)
+      allow(Bovem::Console.any_instance).to receive(:write)
+
+      expect(Kernel).to receive(:exit).with(0).exactly(1)
+      application.show_help
+    end
+  end
+end