bovem 2.4.1 → 3.0.0

data/spec/bovem/configuration_spec.rb

@@ -7,7 +7,7 @@
 require "spec_helper"
 
 describe Bovem::Configuration do
-  class BaseConfiguration < ::Bovem::Configuration
+  class BaseConfiguration < Bovem::Configuration
     property :property
   end
 
@@ -24,15 +24,15 @@ describe Bovem::Configuration do
     end
 
     it "reject a missing or unreadable file" do
-      expect { BaseConfiguration.new("/non-existing")}.to raise_error(::Bovem::Errors::InvalidConfiguration)
+      expect { BaseConfiguration.new("/non-existing")}.to raise_error(Bovem::Errors::InvalidConfiguration)
     end
 
     it "reject an invalid configuration" do
       ::File.open("#{test_prefix}-1", "w") {|f| f.write("config.property = ") }
       ::File.open("#{test_prefix}-2", "w") {|f| f.write("config.non_property = 1234") }
 
-      expect { BaseConfiguration.new("#{test_prefix}-1")}.to raise_error(::Bovem::Errors::InvalidConfiguration)
-      expect { BaseConfiguration.new("#{test_prefix}-2")}.to raise_error(::Bovem::Errors::InvalidConfiguration)
+      expect { BaseConfiguration.new("#{test_prefix}-1")}.to raise_error(Bovem::Errors::InvalidConfiguration)
+      expect { BaseConfiguration.new("#{test_prefix}-2")}.to raise_error(Bovem::Errors::InvalidConfiguration)
 
       File.unlink("#{test_prefix}-1")
       File.unlink("#{test_prefix}-2")

data/spec/bovem/console_spec.rb

@@ -8,7 +8,7 @@ require "spec_helper"
 
 describe Bovem::Console do
   let(:console) {
-    c = ::Bovem::Console.new
+    c = Bovem::Console.new
     c.i18n = :en
     c
   }
@@ -20,46 +20,46 @@ describe Bovem::Console do
 
   describe ".instance" do
     it "should always return the same instance" do
-      instance = ::Bovem::Console.instance
-      expect(::Bovem::Console.instance).to be(instance)
+      instance = Bovem::Console.instance
+      expect(Bovem::Console.instance).to be(instance)
     end
   end
 
   describe ".parse_style" do
     it "should correctly parse styles" do
-      expect(::Bovem::Console.parse_style("red")).to eq("\e[31m")
-      expect(::Bovem::Console.parse_style("bg_green")).to eq("\e[42m")
-      expect(::Bovem::Console.parse_style("bright")).to eq("\e[1m")
-      expect(::Bovem::Console.parse_style("FOO")).to eq("")
-      expect(::Bovem::Console.parse_style(nil)).to eq("")
-      expect(::Bovem::Console.parse_style(["A"])).to eq("")
-      expect(::Bovem::Console.parse_style("-")).to eq("")
+      expect(Bovem::Console.parse_style("red")).to eq("\e[31m")
+      expect(Bovem::Console.parse_style("bg_green")).to eq("\e[42m")
+      expect(Bovem::Console.parse_style("bright")).to eq("\e[1m")
+      expect(Bovem::Console.parse_style("FOO")).to eq("")
+      expect(Bovem::Console.parse_style(nil)).to eq("")
+      expect(Bovem::Console.parse_style(["A"])).to eq("")
+      expect(Bovem::Console.parse_style("-")).to eq("")
     end
   end
 
   describe ".replace_markers" do
     it "should correct replace markers" do
-      expect(::Bovem::Console.replace_markers("{mark=red}RED{/mark}")).to eq("\e[31mRED\e[0m")
-      expect(::Bovem::Console.replace_markers("{mark=red}RED {mark=green}GREEN{/mark}{/mark}")).to eq("\e[31mRED \e[32mGREEN\e[31m\e[0m")
-      expect(::Bovem::Console.replace_markers("{mark=red}RED {mark=bright-green}GREEN {mark=blue}BLUE{mark=NONE}RED{/mark}{/mark}{/mark}{/mark}")).to eq("\e[31mRED \e[1m\e[32mGREEN \e[34mBLUERED\e[1m\e[32m\e[31m\e[0m")
-      expect(::Bovem::Console.replace_markers("{mark=bg_red}RED{mark=reset}NORMAL{/mark}{/mark}")).to eq("\e[41mRED\e[0mNORMAL\e[41m\e[0m")
-      expect(::Bovem::Console.replace_markers("{mark=NONE}RED{/mark}")).to eq("RED")
+      expect(Bovem::Console.replace_markers("{mark=red}RED{/mark}")).to eq("\e[31mRED\e[0m")
+      expect(Bovem::Console.replace_markers("{mark=red}RED {mark=green}GREEN{/mark}{/mark}")).to eq("\e[31mRED \e[32mGREEN\e[31m\e[0m")
+      expect(Bovem::Console.replace_markers("{mark=red}RED {mark=bright-green}GREEN {mark=blue}BLUE{mark=NONE}RED{/mark}{/mark}{/mark}{/mark}")).to eq("\e[31mRED \e[1m\e[32mGREEN \e[34mBLUERED\e[1m\e[32m\e[31m\e[0m")
+      expect(Bovem::Console.replace_markers("{mark=bg_red}RED{mark=reset}NORMAL{/mark}{/mark}")).to eq("\e[41mRED\e[0mNORMAL\e[41m\e[0m")
+      expect(Bovem::Console.replace_markers("{mark=NONE}RED{/mark}")).to eq("RED")
     end
 
     it "should clean up markers if requested" do
-      expect(::Bovem::Console.replace_markers("{mark=red}RED{/mark}", true)).to eq("RED")
+      expect(Bovem::Console.replace_markers("{mark=red}RED{/mark}", true)).to eq("RED")
     end
   end
 
   describe ".execute_command" do
     it "should execute a command" do
-      expect(::Bovem::Console.execute("echo OK")).to eq("OK\n")
+      expect(Bovem::Console.execute("echo OK")).to eq("OK\n")
     end
   end
 
   describe ".min_banner_length" do
     it "should return a number" do
-      expect(::Bovem::Console.min_banner_length).to be_a(Fixnum)
+      expect(Bovem::Console.min_banner_length).to be_a(Fixnum)
     end
   end
 
@@ -172,7 +172,7 @@ describe Bovem::Console do
 
   describe "#replace_markers" do
     it "should just forwards to .replace_markers" do
-      expect(::Bovem::Console).to receive(:replace_markers).with("A", "B")
+      expect(Bovem::Console).to receive(:replace_markers).with("A", "B")
       console.replace_markers("A", "B")
     end
   end
@@ -208,7 +208,7 @@ describe Bovem::Console do
 
   describe "#write_banner_aligned" do
     it "should call #min_banner_length and #format" do
-      expect(::Bovem::Console).to receive(:min_banner_length).and_return(1)
+      expect(Bovem::Console).to receive(:min_banner_length).and_return(1)
       expect(console).to receive(:format).with("    A", "B", "C", "D", "E")
       console.write_banner_aligned("A", "B", "C", "D", "E")
     end
@@ -415,8 +415,8 @@ describe Bovem::Console do
     end
 
     it "should execute the given block" do
-      expect(::Bovem::Console).to receive(:foo)
-      console.task { ::Bovem::Console.foo }
+      expect(Bovem::Console).to receive(:foo)
+      console.task { Bovem::Console.foo }
     end
 
     it "should write the correct status" do

data/spec/bovem/errors_spec.rb

@@ -0,0 +1,18 @@
+# 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::Errors::Error do
+  describe "#initialize" do
+    it "copies attributes" do
+      error = Bovem::Errors::Error.new("A", "B", "C")
+      expect(error.target).to eq("A")
+      expect(error.reason).to eq("B")
+      expect(error.message).to eq("C")
+    end
+  end
+end

data/spec/bovem/logger_spec.rb

@@ -7,37 +7,41 @@
 require "spec_helper"
 
 describe Bovem::Logger do
+  before(:each) do
+    allow(::Time).to receive(:now).and_return(Time.at(10))
+  end
+
   describe ".create" do
     it "should create a new default logger" do
-      logger = ::Bovem::Logger.create
-      expect(logger.device).to eq(::Bovem::Logger.default_file)
+      logger = Bovem::Logger.create
+      expect(logger.device).to eq(Bovem::Logger.default_file)
       expect(logger.level).to eq(::Logger::INFO)
-      expect(logger.formatter).to eq(::Bovem::Logger.default_formatter)
+      expect(logger.formatter).to eq(Bovem::Logger.default_formatter)
     end
 
     it "should create a logger with a custom file and level" do
-      logger = ::Bovem::Logger.create("/dev/null", ::Logger::WARN)
+      logger = Bovem::Logger.create("/dev/null", ::Logger::WARN)
       expect(logger.device).to eq("/dev/null")
       expect(logger.level).to eq(::Logger::WARN)
-      expect(logger.formatter).to eq(::Bovem::Logger.default_formatter)
+      expect(logger.formatter).to eq(Bovem::Logger.default_formatter)
     end
 
     it "should create a logger with a custom formatter" do
       formatter = Proc.new {|severity, datetime, progname, msg| msg }
-      logger = ::Bovem::Logger.create("/dev/null", ::Logger::WARN, formatter)
+      logger = Bovem::Logger.create("/dev/null", ::Logger::WARN, formatter)
       expect(logger.device).to eq("/dev/null")
       expect(logger.level).to eq(::Logger::WARN)
       expect(logger.formatter).to eq(formatter)
     end
 
     it "should raise exceptions for invalid files" do
-      expect { ::Bovem::Logger.create("/invalid/file") }.to raise_error(::Bovem::Errors::InvalidLogger)
+      expect { Bovem::Logger.create("/invalid/file") }.to raise_error(Bovem::Errors::InvalidLogger)
     end
   end
 
   describe ".default_formatter" do
     let(:output) { ::StringIO.new }
-    let(:logger) { ::Bovem::Logger.create(output, Logger::DEBUG) }
+    let(:logger) { Bovem::Logger.create(output, Logger::DEBUG) }
 
     def get_last_line(buffer)
       buffer.string.split("\n").last.strip.gsub(/ T\+\d+\.\d+/, "")
@@ -82,21 +86,27 @@ describe Bovem::Logger do
 
   describe ".get_real_file" do
     it "should return the standard ouput" do
-      expect(::Bovem::Logger.get_real_file("STDOUT")).to eq($stdout )
+      expect(Bovem::Logger.get_real_file("STDOUT")).to eq($stdout )
     end
     
     it "should return the standard error" do
-      expect(::Bovem::Logger.get_real_file("STDERR")).to eq($stderr )
+      expect(Bovem::Logger.get_real_file("STDERR")).to eq($stderr )
     end
     
     it "should return the file" do
-      expect(::Bovem::Logger.get_real_file("/dev/null")).to eq("/dev/null" )
+      expect(Bovem::Logger.get_real_file("/dev/null")).to eq("/dev/null" )
     end
   end
 
   describe ".default_file" do
     it "should return the standard output" do
-      expect(::Bovem::Logger.default_file).to eq($stdout)
+      expect(Bovem::Logger.default_file).to eq($stdout)
+    end
+  end
+
+  describe ".start_time" do
+    it "should store the start time" do
+      expect(Bovem::Logger.start_time).to eq(Time.at(10))
     end
   end
 end

data/spec/bovem/option_spec.rb

@@ -0,0 +1,307 @@
+# 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::Option do
+  let(:application) {
+    Bovem::Application.new {
+      action {}
+    }
+  }
+
+  let(:command) {
+    c = Bovem::Command.new
+    c.application = application
+    c
+  }
+
+  let(:option) {
+    o = Bovem::Option.new("NAME")
+    o.parent = command
+    o
+  }
+
+  describe "#initialize" do
+    it "should set good forms" do
+      option = Bovem::Option.new("NAME")
+      expect(option.name).to eq("NAME")
+      expect(option.short).to eq("N")
+      expect(option.long).to eq("NAME")
+
+      option = Bovem::Option.new("NAME", "O")
+      expect(option.name).to eq("NAME")
+      expect(option.short).to eq("O")
+      expect(option.long).to eq("NAME")
+
+      option = Bovem::Option.new("NAME", ["O", "OPTION"])
+      expect(option.name).to eq("NAME")
+      expect(option.short).to eq("O")
+      expect(option.long).to eq("OPTION")
+
+    end
+
+    it "should set options" do
+      option = Bovem::Option.new("NAME", ["O", "OPTION"], {required: true, help: "HELP", unused: "UNUSED"})
+      expect(option.help).to be_true
+      expect(option.help).to eq("HELP")
+    end
+  end
+
+  describe "#short=" do
+    it "should set good form" do
+      option.short = "a"
+      expect(option.short).to eq("a")
+
+      option.short = "-b"
+      expect(option.short).to eq("b")
+
+      option.short = "-c"
+      expect(option.short).to eq("c")
+
+      option.short = 1
+      expect(option.short).to eq("1")
+
+      option.short = true
+      expect(option.short).to eq("t")
+
+      option.short = nil
+      expect(option.short).to eq("N")
+    end
+  end
+
+  describe "#long=" do
+    it "should set good form" do
+      option.long = "a"
+      expect(option.long).to eq("a")
+
+      option.long = "abc"
+      expect(option.long).to eq("abc")
+
+      option.long = "-def"
+      expect(option.long).to eq("def")
+
+      option.long = "--ghi"
+      expect(option.long).to eq("ghi")
+
+      option.long = true
+      expect(option.long).to eq("true")
+
+      option.long = 1
+      expect(option.long).to eq("1")
+
+      option.long = nil
+      expect(option.long).to eq("NAME")
+    end
+  end
+
+  describe "#validator=" do
+    it "should set a good validator" do
+      proc = -> {}
+
+      option.validator = "VALUE"
+      expect(option.validator).to eq(["VALUE"])
+      option.validator = 1
+      expect(option.validator).to eq([1])
+      option.validator = ["VALUE", "VALUE"]
+      expect(option.validator).to eq(["VALUE"])
+      option.validator = [1, 2, 1]
+      expect(option.validator).to eq([1, 2])
+      option.validator = /VALUE/
+      expect(option.validator).to eq(/VALUE/)
+      option.validator = proc
+      expect(option.validator).to eq(proc)
+      option.validator = nil
+      expect(option.validator).to be_nil
+      option.validator = ""
+      expect(option.validator).to be_nil
+      option.validator = []
+      expect(option.validator).to be_nil
+      option.validator = //
+      expect(option.validator).to be_nil
+    end
+  end
+
+  describe "#complete_short" do
+    it "should return a good short form" do
+      expect(Bovem::Option.new("NAME").complete_short).to eq("-N")
+      expect(Bovem::Option.new("NAME", "A").complete_short).to eq("-A")
+      expect(Bovem::Option.new("NAME", ["A", "BC"]).complete_short).to eq("-A")
+      expect(Bovem::Option.new("NAME", [true, false]).complete_short).to eq("-t")
+    end
+  end
+
+  describe "#complete_long" do
+    it "should return a good short form" do
+      expect(Bovem::Option.new("NAME").complete_long).to eq("--NAME")
+      expect(Bovem::Option.new("NAME", "A").complete_long).to eq("--NAME")
+      expect(Bovem::Option.new("NAME", ["A", "BC"]).complete_long).to eq("--BC")
+      expect(Bovem::Option.new("NAME", [true, true]).complete_long).to eq("--true")
+    end
+  end
+
+  describe "#label" do
+    it "should return a good label" do
+      expect(Bovem::Option.new("NAME").label).to eq("-N/--NAME")
+      expect(Bovem::Option.new("NAME", "A").label).to eq("-A/--NAME")
+      expect(Bovem::Option.new("NAME", ["A", "BC"]).label).to eq("-A/--BC")
+      expect(Bovem::Option.new("NAME", [true, true]).label).to eq("-t/--true")
+    end
+
+  end
+
+  describe "#meta" do
+    it "should return the option meta" do
+      expect(Bovem::Option.new("NAME", []).meta).to be_nil
+      expect(Bovem::Option.new("NAME", [], {type: String}).meta).to eq("NAME")
+      expect(Bovem::Option.new("foo", [], {type: String}).meta).to eq("FOO")
+      expect(Bovem::Option.new("NAME", [], {type: String, meta: "STRING"}).meta).to eq("STRING")
+    end
+  end
+
+  describe "#set" do
+    it "should set the value" do
+      expect(option.set("VALUE")).to be_true
+      expect(option.value).to eq("VALUE")
+      expect(option.provided?).to be_true
+    end
+
+    it "should match against a regexp validator" do
+      option.validator = /^A|B$/
+
+      expect{ option.set("VALUE") }.to raise_error(Bovem::Errors::Error)
+      expect(option.value).to be_false
+      expect(option.provided?).to be_false
+
+      expect(option.set("VALUE", false)).to be_false
+      expect(option.value).to be_false
+      expect(option.provided?).to be_false
+
+      option.set("A")
+      expect(option.value).to eq("A")
+      expect(option.provided?).to be_true
+
+      option.set("B")
+      expect(option.value).to eq("B")
+      expect(option.provided?).to be_true
+    end
+
+    it "should match against an array validator" do
+      option.validator = ["A", "B"]
+
+      expect{ option.set("VALUE") }.to raise_error(Bovem::Errors::Error)
+      expect(option.value).to be_false
+      expect(option.provided?).to be_false
+
+      expect(option.set("VALUE", false)).to be_false
+      expect(option.value).to be_false
+      expect(option.provided?).to be_false
+
+      option.set("A")
+      expect(option.value).to eq("A")
+      expect(option.provided?).to be_true
+
+      option.set("B")
+      expect(option.value).to eq("B")
+      expect(option.provided?).to be_true
+
+      option.validator = [1, 2]
+      expect{ option.set("VALUE") }.to raise_error(Bovem::Errors::Error)
+      expect(option.value).to be_false
+      expect(option.provided?).to be_false
+
+      option.set(1)
+      expect(option.value).to eq(1)
+      expect(option.provided?).to be_true
+    end
+
+    it "should match against a Proc validator" do
+      option.validator = ->(v) { v % 2 == 0 }
+
+      expect{ option.set(1) }.to raise_error(Bovem::Errors::Error)
+      expect(option.value).to be_false
+      expect(option.provided?).to be_false
+
+      option.set(2)
+      expect(option.value).to eq(2)
+      expect(option.provided?).to be_true
+
+      option.set(4)
+      expect(option.value).to eq(4)
+      expect(option.provided?).to be_true
+    end
+  end
+
+  describe "#execute_action" do
+    it "should execute action if provided" do
+      check = false
+      option = Bovem::Option.new("NAME") { |_, _| check = true }
+      option.execute_action
+
+      expect(check).to be_true
+      expect(option.provided?).to be_true
+    end
+
+    it "should result in a no-op if the action is missing or doesn't take enough arguments" do
+      option.execute_action
+      expect(option.provided?).to be_false
+
+      option = Bovem::Option.new("NAME")
+      expect(option.provided?).to be_false
+    end
+  end
+
+  describe "#requires_argument?" do
+    it "should check if the option requires argument" do
+      expect(Bovem::Option.new("NAME", []).requires_argument?).to be_false
+      expect(Bovem::Option.new("NAME", [], {type: String}).requires_argument?).to be_true
+      expect(Bovem::Option.new("NAME", [], {type: Integer}).requires_argument?).to be_true
+      expect(Bovem::Option.new("NAME", [], {type: Float}).requires_argument?).to be_true
+      expect(Bovem::Option.new("NAME", [], {type: Array}).requires_argument?).to be_true
+      expect(Bovem::Option.new("NAME").requires_argument?).to be_false
+    end
+  end
+
+  describe "#provided?" do
+    it "should check if the option was provided" do
+      expect(Bovem::Option.new("NAME").provided?).to be_false
+      option.set(true)
+      expect(option.provided?).to be_true
+    end
+  end
+
+  describe "#has_help?" do
+    it "should check if the option has a help" do
+      expect(Bovem::Option.new("NAME").has_help?).to be_false
+      expect(Bovem::Option.new("NAME", [], help: "HELP").has_help?).to be_true
+    end
+  end
+
+  describe "#value" do
+    it "should return the set value" do
+      option.default = "DEFAULT VALUE"
+      expect(option.value).to eq("DEFAULT VALUE")
+
+      option.default = nil
+      expect(option.value).to be_false
+
+      option.set(true)
+      expect(option.value).to be_true
+
+      option.set("VALUE")
+      expect(option.value).to eq("VALUE")
+    end
+
+    it "should return good defaults" do
+      expect(Bovem::Option.new("NAME").value).to be_false
+      expect(Bovem::Option.new("NAME", [], {type: Regexp}).value).to be_false
+      expect(Bovem::Option.new("NAME", [], {type: String}).value).to eq("")
+      expect(Bovem::Option.new("NAME", [], {type: Integer}).value).to eq(0)
+      expect(Bovem::Option.new("NAME", [], {type: Float}).value).to eq(0.0)
+      expect(Bovem::Option.new("NAME", [], {type: Array}).value).to eq([])
+    end
+  end
+end