cvss-suite 1.0.0

data/vendor/cache/ruby/2.2.0/gems/thor-0.19.1/spec/helper.rb

@@ -0,0 +1,80 @@
+$TESTING = true
+
+require "simplecov"
+require "coveralls"
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+
+SimpleCov.start do
+  add_filter "/spec/"
+  minimum_coverage(92.21)
+end
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "thor"
+require "thor/group"
+require "stringio"
+
+require "rdoc"
+require "rspec"
+require "diff/lcs" # You need diff/lcs installed to run specs (but not to run Thor).
+require "fakeweb"  # You need fakeweb installed to run specs (but not to run Thor).
+
+# Set shell to basic
+$0 = "thor"
+$thor_runner = true
+ARGV.clear
+Thor::Base.shell = Thor::Shell::Basic
+
+# Load fixtures
+load File.join(File.dirname(__FILE__), "fixtures", "enum.thor")
+load File.join(File.dirname(__FILE__), "fixtures", "group.thor")
+load File.join(File.dirname(__FILE__), "fixtures", "invoke.thor")
+load File.join(File.dirname(__FILE__), "fixtures", "script.thor")
+load File.join(File.dirname(__FILE__), "fixtures", "subcommand.thor")
+load File.join(File.dirname(__FILE__), "fixtures", "command.thor")
+
+RSpec.configure do |config|
+  config.before do
+    ARGV.replace []
+  end
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  def capture(stream)
+    begin
+      stream = stream.to_s
+      eval "$#{stream} = StringIO.new"
+      yield
+      result = eval("$#{stream}").string
+    ensure
+      eval("$#{stream} = #{stream.upcase}")
+    end
+
+    result
+  end
+
+  def source_root
+    File.join(File.dirname(__FILE__), "fixtures")
+  end
+
+  def destination_root
+    File.join(File.dirname(__FILE__), "sandbox")
+  end
+
+  # This code was adapted from Ruby on Rails, available under MIT-LICENSE
+  # Copyright (c) 2004-2013 David Heinemeier Hansson
+  def silence_warnings
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+
+  alias silence capture
+end

data/vendor/cache/ruby/2.2.0/gems/thor-0.19.1/spec/invocation_spec.rb

@@ -0,0 +1,120 @@
+require "helper"
+require "thor/base"
+
+describe Thor::Invocation do
+  describe "#invoke" do
+    it "invokes a command inside another command" do
+      expect(capture(:stdout) { A.new.invoke(:two) }).to eq("2\n3\n")
+    end
+
+    it "invokes a command just once" do
+      expect(capture(:stdout) { A.new.invoke(:one) }).to eq("1\n2\n3\n")
+    end
+
+    it "invokes a command just once even if they belongs to different classes" do
+      expect(capture(:stdout) { Defined.new.invoke(:one) }).to eq("1\n2\n3\n4\n5\n")
+    end
+
+    it "invokes a command with arguments" do
+      expect(A.new.invoke(:five, [5])).to be true
+      expect(A.new.invoke(:five, [7])).to be false
+    end
+
+    it "invokes the default command if none is given to a Thor class" do
+      content = capture(:stdout) { A.new.invoke("b") }
+      expect(content).to match(/Commands/)
+      expect(content).to match(/LAST_NAME/)
+    end
+
+    it "accepts a class as argument without a command to invoke" do
+      content = capture(:stdout) { A.new.invoke(B) }
+      expect(content).to match(/Commands/)
+      expect(content).to match(/LAST_NAME/)
+    end
+
+    it "accepts a class as argument with a command to invoke" do
+      base = A.new([], :last_name => "Valim")
+      expect(base.invoke(B, :one, %w[Jose])).to eq("Valim, Jose")
+    end
+
+    it "allows customized options to be given" do
+      base = A.new([], :last_name => "Wrong")
+      expect(base.invoke(B, :one, %w[Jose], :last_name => "Valim")).to eq("Valim, Jose")
+    end
+
+    it "reparses options in the new class" do
+      expect(A.start(%w[invoker --last-name Valim])).to eq("Valim, Jose")
+    end
+
+    it "shares initialize options with invoked class" do
+      expect(A.new([], :foo => :bar).invoke("b:two")).to eq("foo" => :bar)
+    end
+
+    it "uses default options from invoked class if no matching arguments are given" do
+      expect(A.new([]).invoke("b:four")).to eq("default")
+    end
+
+    it "overrides default options if options are passed to the invoker" do
+      expect(A.new([], :defaulted_value => "not default").invoke("b:four")).to eq("not default")
+    end
+
+    it "returns the command chain" do
+      expect(I.new.invoke("two")).to eq([:two])
+
+      if RUBY_VERSION < "1.9.3"
+        result = J.start(["one", "two" ])
+        expect(result).to include(:one)
+        expect(result).to include(:two)
+      else
+        expect(J.start(["one", "two" ])).to eq([:one, :two])
+      end
+    end
+
+    it "dump configuration values to be used in the invoked class" do
+      base = A.new
+      expect(base.invoke("b:three").shell).to eq(base.shell)
+    end
+
+    it "allow extra configuration values to be given" do
+      base, shell = A.new, Thor::Base.shell.new
+      expect(base.invoke("b:three", [], {}, :shell => shell).shell).to eq(shell)
+    end
+
+    it "invokes a Thor::Group and all of its commands" do
+      expect(capture(:stdout) { A.new.invoke(:c) }).to eq("1\n2\n3\n")
+    end
+
+    it "does not invoke a Thor::Group twice" do
+      base = A.new
+      silence(:stdout) { base.invoke(:c) }
+      expect(capture(:stdout) { base.invoke(:c) }).to be_empty
+    end
+
+    it "does not invoke any of Thor::Group commands twice" do
+      base = A.new
+      silence(:stdout) { base.invoke(:c) }
+      expect(capture(:stdout) { base.invoke("c:one") }).to be_empty
+    end
+
+    it "raises Thor::UndefinedCommandError if the command can't be found" do
+      expect do
+        A.new.invoke("foo:bar")
+      end.to raise_error(Thor::UndefinedCommandError)
+    end
+
+    it "raises Thor::UndefinedCommandError if the command can't be found even if all commands were already executed" do
+      base = C.new
+      silence(:stdout) { base.invoke_all }
+
+      expect do
+        base.invoke("foo:bar")
+      end.to raise_error(Thor::UndefinedCommandError)
+    end
+
+    it "raises an error if a non Thor class is given" do
+      expect do
+        A.new.invoke(Object)
+      end.to raise_error(RuntimeError, "Expected Thor class, got Object")
+    end
+  end
+end

data/vendor/cache/ruby/2.2.0/gems/thor-0.19.1/spec/line_editor/basic_spec.rb

@@ -0,0 +1,28 @@
+require "helper"
+
+describe Thor::LineEditor::Basic do
+  describe ".available?" do
+    it "returns true" do
+      expect(Thor::LineEditor::Basic).to be_available
+    end
+  end
+
+  describe "#readline" do
+    it "uses $stdin and $stdout to get input from the user" do
+      expect($stdout).to receive(:print).with("Enter your name ")
+      expect($stdin).to receive(:gets).and_return("George")
+      expect($stdin).not_to receive(:noecho)
+      editor = Thor::LineEditor::Basic.new("Enter your name ", {})
+      expect(editor.readline).to eq("George")
+    end
+
+    it "disables echo when asked to" do
+      expect($stdout).to receive(:print).with("Password: ")
+      noecho_stdin = double("noecho_stdin")
+      expect(noecho_stdin).to receive(:gets).and_return("secret")
+      expect($stdin).to receive(:noecho).and_yield(noecho_stdin)
+      editor = Thor::LineEditor::Basic.new("Password: ", :echo => false)
+      expect(editor.readline).to eq("secret")
+    end
+  end
+end

data/vendor/cache/ruby/2.2.0/gems/thor-0.19.1/spec/line_editor/readline_spec.rb

@@ -0,0 +1,69 @@
+require "helper"
+
+describe Thor::LineEditor::Readline do
+  before do
+    unless defined? ::Readline
+      ::Readline = double("Readline")
+      allow(::Readline).to receive(:completion_append_character=).with(nil)
+    end
+  end
+
+  describe ".available?" do
+    it "returns true when ::Readline exists" do
+      allow(Object).to receive(:const_defined?).with(:Readline).and_return(true)
+      expect(described_class).to be_available
+    end
+
+    it "returns false when ::Readline does not exist" do
+      allow(Object).to receive(:const_defined?).with(:Readline).and_return(false)
+      expect(described_class).not_to be_available
+    end
+  end
+
+  describe "#readline" do
+    it "invokes the readline library" do
+      expect(::Readline).to receive(:readline).with("> ", true).and_return("foo")
+      expect(::Readline).not_to receive(:completion_proc=)
+      editor = Thor::LineEditor::Readline.new("> ", {})
+      expect(editor.readline).to eq("foo")
+    end
+
+    it "supports the add_to_history option" do
+      expect(::Readline).to receive(:readline).with("> ", false).and_return("foo")
+      expect(::Readline).not_to receive(:completion_proc=)
+      editor = Thor::LineEditor::Readline.new("> ", :add_to_history => false)
+      expect(editor.readline).to eq("foo")
+    end
+
+    it "provides tab completion when given a limited_to option" do
+      expect(::Readline).to receive(:readline)
+      expect(::Readline).to receive(:completion_proc=) do |proc|
+        expect(proc.call("")).to eq %w[Apples Chicken Chocolate]
+        expect(proc.call("Ch")).to eq %w[Chicken Chocolate]
+        expect(proc.call("Chi")).to eq ["Chicken"]
+      end
+
+      editor = Thor::LineEditor::Readline.new("Best food: ", :limited_to => %w[Apples Chicken Chocolate])
+      editor.readline
+    end
+
+    it "provides path tab completion when given the path option" do
+      expect(::Readline).to receive(:readline)
+      expect(::Readline).to receive(:completion_proc=) do |proc|
+        expect(proc.call("../line_ed").sort).to eq ["../line_editor/", "../line_editor_spec.rb"].sort
+      end
+
+      editor = Thor::LineEditor::Readline.new("Path to file: ", :path => true)
+      Dir.chdir(File.dirname(__FILE__)) { editor.readline }
+    end
+
+    it "uses STDIN when asked not to echo input" do
+      expect($stdout).to receive(:print).with("Password: ")
+      noecho_stdin = double("noecho_stdin")
+      expect(noecho_stdin).to receive(:gets).and_return("secret")
+      expect($stdin).to receive(:noecho).and_yield(noecho_stdin)
+      editor = Thor::LineEditor::Readline.new("Password: ", :echo => false)
+      expect(editor.readline).to eq("secret")
+    end
+  end
+end

data/vendor/cache/ruby/2.2.0/gems/thor-0.19.1/spec/line_editor_spec.rb

@@ -0,0 +1,43 @@
+require "helper"
+
+describe Thor::LineEditor, "on a system with Readline support" do
+  before do
+    @original_readline = ::Readline if defined? ::Readline
+    silence_warnings { ::Readline = double("Readline") }
+  end
+
+  after do
+    silence_warnings { ::Readline = @original_readline }
+  end
+
+  describe ".readline" do
+    it "uses the Readline line editor" do
+      editor = double("Readline")
+      expect(Thor::LineEditor::Readline).to receive(:new).with("Enter your name ", :default => "Brian").and_return(editor)
+      expect(editor).to receive(:readline).and_return("George")
+      expect(Thor::LineEditor.readline("Enter your name ", :default => "Brian")).to eq("George")
+    end
+  end
+end
+
+describe Thor::LineEditor, "on a system without Readline support" do
+  before do
+    if defined? ::Readline
+      @original_readline = ::Readline
+      Object.send(:remove_const, :Readline)
+    end
+  end
+
+  after do
+    silence_warnings { ::Readline = @original_readline }
+  end
+
+  describe ".readline" do
+    it "uses the Basic line editor" do
+      editor = double("Basic")
+      expect(Thor::LineEditor::Basic).to receive(:new).with("Enter your name ", :default => "Brian").and_return(editor)
+      expect(editor).to receive(:readline).and_return("George")
+      expect(Thor::LineEditor.readline("Enter your name ", :default => "Brian")).to eq("George")
+    end
+  end
+end

data/vendor/cache/ruby/2.2.0/gems/thor-0.19.1/spec/parser/argument_spec.rb

@@ -0,0 +1,53 @@
+require "helper"
+require "thor/parser"
+
+describe Thor::Argument do
+
+  def argument(name, options = {})
+    @argument ||= Thor::Argument.new(name, options)
+  end
+
+  describe "errors" do
+    it "raises an error if name is not supplied" do
+      expect do
+        argument(nil)
+      end.to raise_error(ArgumentError, "Argument name can't be nil.")
+    end
+
+    it "raises an error if type is unknown" do
+      expect do
+        argument(:command, :type => :unknown)
+      end.to raise_error(ArgumentError, "Type :unknown is not valid for arguments.")
+    end
+
+    it "raises an error if argument is required and has default values" do
+      expect do
+        argument(:command, :type => :string, :default => "bar", :required => true)
+      end.to raise_error(ArgumentError, "An argument cannot be required and have default value.")
+    end
+
+    it "raises an error if enum isn't an array" do
+      expect do
+        argument(:command, :type => :string, :enum => "bar")
+      end.to raise_error(ArgumentError, "An argument cannot have an enum other than an array.")
+    end
+  end
+
+  describe "#usage" do
+    it "returns usage for string types" do
+      expect(argument(:foo, :type => :string).usage).to eq("FOO")
+    end
+
+    it "returns usage for numeric types" do
+      expect(argument(:foo, :type => :numeric).usage).to eq("N")
+    end
+
+    it "returns usage for array types" do
+      expect(argument(:foo, :type => :array).usage).to eq("one two three")
+    end
+
+    it "returns usage for hash types" do
+      expect(argument(:foo, :type => :hash).usage).to eq("key:value")
+    end
+  end
+end

data/vendor/cache/ruby/2.2.0/gems/thor-0.19.1/spec/parser/arguments_spec.rb

@@ -0,0 +1,66 @@
+require "helper"
+require "thor/parser"
+
+describe Thor::Arguments do
+  def create(opts = {})
+    arguments = opts.map do |type, default|
+      options = {:required => default.nil?, :type => type, :default => default}
+      Thor::Argument.new(type.to_s, options)
+    end
+
+    arguments.sort! { |a, b| b.name <=> a.name }
+    @opt = Thor::Arguments.new(arguments)
+  end
+
+  def parse(*args)
+    @opt.parse(args)
+  end
+
+  describe "#parse" do
+    it "parses arguments in the given order" do
+      create :string => nil, :numeric => nil
+      expect(parse("name", "13")["string"]).to eq("name")
+      expect(parse("name", "13")["numeric"]).to eq(13)
+    end
+
+    it "accepts hashes" do
+      create :string => nil, :hash => nil
+      expect(parse("product", "title:string", "age:integer")["string"]).to eq("product")
+      expect(parse("product", "title:string", "age:integer")["hash"]).to eq("title" => "string", "age" => "integer")
+      expect(parse("product", "url:http://www.amazon.com/gp/product/123")["hash"]).to eq("url" => "http://www.amazon.com/gp/product/123")
+    end
+
+    it "accepts arrays" do
+      create :string => nil, :array => nil
+      expect(parse("product", "title", "age")["string"]).to eq("product")
+      expect(parse("product", "title", "age")["array"]).to eq(%w[title age])
+    end
+
+    describe "with no inputs" do
+      it "and no arguments returns an empty hash" do
+        create
+        expect(parse).to eq({})
+      end
+
+      it "and required arguments raises an error" do
+        create :string => nil, :numeric => nil
+        expect { parse }.to raise_error(Thor::RequiredArgumentMissingError, "No value provided for required arguments 'string', 'numeric'")
+      end
+
+      it "and default arguments returns default values" do
+        create :string => "name", :numeric => 13
+        expect(parse).to eq("string" => "name", "numeric" => 13)
+      end
+    end
+
+    it "returns the input if it's already parsed" do
+      create :string => nil, :hash => nil, :array => nil, :numeric => nil
+      expect(parse("", 0, {}, [])).to eq("string" => "", "numeric" => 0, "hash" => {}, "array" => [])
+    end
+
+    it "returns the default value if none is provided" do
+      create :string => "foo", :numeric => 3.0
+      expect(parse("bar")).to eq("string" => "bar", "numeric" => 3.0)
+    end
+  end
+end