cvss-suite 1.0.8 → 1.1.0

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

@@ -1,331 +0,0 @@
-require "helper"
-
-describe Thor::Actions do
-  def runner(options = {})
-    @runner ||= MyCounter.new([1], options, :destination_root => destination_root)
-  end
-
-  def action(*args, &block)
-    capture(:stdout) { runner.send(*args, &block) }
-  end
-
-  def file
-    File.join(destination_root, "foo")
-  end
-
-  describe "on include" do
-    it "adds runtime options to the base class" do
-      expect(MyCounter.class_options.keys).to include(:pretend)
-      expect(MyCounter.class_options.keys).to include(:force)
-      expect(MyCounter.class_options.keys).to include(:quiet)
-      expect(MyCounter.class_options.keys).to include(:skip)
-    end
-  end
-
-  describe "#initialize" do
-    it "has default behavior invoke" do
-      expect(runner.behavior).to eq(:invoke)
-    end
-
-    it "can have behavior revoke" do
-      expect(MyCounter.new([1], {}, :behavior => :revoke).behavior).to eq(:revoke)
-    end
-
-    it "when behavior is set to force, overwrite options" do
-      runner = MyCounter.new([1], {:force => false, :skip => true}, :behavior => :force)
-      expect(runner.behavior).to eq(:invoke)
-      expect(runner.options.force).to be true
-      expect(runner.options.skip).not_to be true
-    end
-
-    it "when behavior is set to skip, overwrite options" do
-      runner = MyCounter.new([1], %w[--force], :behavior => :skip)
-      expect(runner.behavior).to eq(:invoke)
-      expect(runner.options.force).not_to be true
-      expect(runner.options.skip).to be true
-    end
-  end
-
-  describe "accessors" do
-    describe "#destination_root=" do
-      it "gets the current directory and expands the path to set the root" do
-        base = MyCounter.new([1])
-        base.destination_root = "here"
-        expect(base.destination_root).to eq(File.expand_path(File.join(File.dirname(__FILE__), "..", "here")))
-      end
-
-      it "does not use the current directory if one is given" do
-        root = File.expand_path("/")
-        base = MyCounter.new([1])
-        base.destination_root = root
-        expect(base.destination_root).to eq(root)
-      end
-
-      it "uses the current directory if none is given" do
-        base = MyCounter.new([1])
-        expect(base.destination_root).to eq(File.expand_path(File.join(File.dirname(__FILE__), "..")))
-      end
-    end
-
-    describe "#relative_to_original_destination_root" do
-      it "returns the path relative to the absolute root" do
-        expect(runner.relative_to_original_destination_root(file)).to eq("foo")
-      end
-
-      it "does not remove dot if required" do
-        expect(runner.relative_to_original_destination_root(file, false)).to eq("./foo")
-      end
-
-      it "always use the absolute root" do
-        runner.inside("foo") do
-          expect(runner.relative_to_original_destination_root(file)).to eq("foo")
-        end
-      end
-
-      it "creates proper relative paths for absolute file location" do
-        expect(runner.relative_to_original_destination_root("/test/file")).to eq("/test/file")
-      end
-
-      it "does not fail with files containing regexp characters" do
-        runner = MyCounter.new([1], {}, :destination_root => File.join(destination_root, "fo[o-b]ar"))
-        expect(runner.relative_to_original_destination_root("bar")).to eq("bar")
-      end
-
-      describe "#source_paths_for_search" do
-        it "add source_root to source_paths_for_search" do
-          expect(MyCounter.source_paths_for_search).to include(File.expand_path("fixtures", File.dirname(__FILE__)))
-        end
-
-        it "keeps only current source root in source paths" do
-          expect(ClearCounter.source_paths_for_search).to include(File.expand_path("fixtures/bundle", File.dirname(__FILE__)))
-          expect(ClearCounter.source_paths_for_search).not_to include(File.expand_path("fixtures", File.dirname(__FILE__)))
-        end
-
-        it "customized source paths should be before source roots" do
-          expect(ClearCounter.source_paths_for_search[0]).to eq(File.expand_path("fixtures/doc", File.dirname(__FILE__)))
-          expect(ClearCounter.source_paths_for_search[1]).to eq(File.expand_path("fixtures/bundle", File.dirname(__FILE__)))
-        end
-
-        it "keeps inherited source paths at the end" do
-          expect(ClearCounter.source_paths_for_search.last).to eq(File.expand_path("fixtures/broken", File.dirname(__FILE__)))
-        end
-      end
-    end
-
-    describe "#find_in_source_paths" do
-      it "raises an error if source path is empty" do
-        expect do
-          A.new.find_in_source_paths("foo")
-        end.to raise_error(Thor::Error, /Currently you have no source paths/)
-      end
-
-      it "finds a template inside the source path" do
-        expect(runner.find_in_source_paths("doc")).to eq(File.expand_path("doc", source_root))
-        expect { runner.find_in_source_paths("README") }.to raise_error
-
-        new_path = File.join(source_root, "doc")
-        runner.instance_variable_set(:@source_paths, nil)
-        runner.source_paths.unshift(new_path)
-        expect(runner.find_in_source_paths("README")).to eq(File.expand_path("README", new_path))
-      end
-    end
-  end
-
-  describe "#inside" do
-    it "executes the block inside the given folder" do
-      runner.inside("foo") do
-        expect(Dir.pwd).to eq(file)
-      end
-    end
-
-    it "changes the base root" do
-      runner.inside("foo") do
-        expect(runner.destination_root).to eq(file)
-      end
-    end
-
-    it "creates the directory if it does not exist" do
-      runner.inside("foo") do
-        expect(File.exist?(file)).to be true
-      end
-    end
-
-    describe "when pretending" do
-      it "no directories should be created" do
-        runner.inside("bar", :pretend => true) {}
-        expect(File.exist?("bar")).to be false
-      end
-    end
-
-    describe "when verbose" do
-      it "logs status" do
-        expect(capture(:stdout) do
-          runner.inside("foo", :verbose => true) {}
-        end).to match(/inside  foo/)
-      end
-
-      it "uses padding in next status" do
-        expect(capture(:stdout) do
-          runner.inside("foo", :verbose => true) do
-            runner.say_status :cool, :padding
-          end
-        end).to match(/cool    padding/)
-      end
-
-      it "removes padding after block" do
-        expect(capture(:stdout) do
-          runner.inside("foo", :verbose => true) {}
-          runner.say_status :no, :padding
-        end).to match(/no  padding/)
-      end
-    end
-  end
-
-  describe "#in_root" do
-    it "executes the block in the root folder" do
-      runner.inside("foo") do
-        runner.in_root { expect(Dir.pwd).to eq(destination_root) }
-      end
-    end
-
-    it "changes the base root" do
-      runner.inside("foo") do
-        runner.in_root { expect(runner.destination_root).to eq(destination_root) }
-      end
-    end
-
-    it "returns to the previous state" do
-      runner.inside("foo") do
-        runner.in_root {}
-        expect(runner.destination_root).to eq(file)
-      end
-    end
-  end
-
-  describe "#apply" do
-    before do
-      @template = <<-TEMPLATE
-        @foo = "FOO"
-        say_status :cool, :padding
-      TEMPLATE
-      allow(@template).to receive(:read).and_return(@template)
-
-      @file = "/"
-      allow(runner).to receive(:open).and_return(@template)
-    end
-
-    it "accepts a URL as the path" do
-      @file = "http://gist.github.com/103208.txt"
-      expect(runner).to receive(:open).with(@file, "Accept" => "application/x-thor-template").and_return(@template)
-      action(:apply, @file)
-    end
-
-    it "accepts a secure URL as the path" do
-      @file = "https://gist.github.com/103208.txt"
-      expect(runner).to receive(:open).with(@file, "Accept" => "application/x-thor-template").and_return(@template)
-      action(:apply, @file)
-    end
-
-    it "accepts a local file path with spaces" do
-      @file = File.expand_path("fixtures/path with spaces", File.dirname(__FILE__))
-      expect(runner).to receive(:open).with(@file).and_return(@template)
-      action(:apply, @file)
-    end
-
-    it "opens a file and executes its content in the instance binding" do
-      action :apply, @file
-      expect(runner.instance_variable_get("@foo")).to eq("FOO")
-    end
-
-    it "applies padding to the content inside the file" do
-      expect(action(:apply, @file)).to match(/cool    padding/)
-    end
-
-    it "logs its status" do
-      expect(action(:apply, @file)).to match(/       apply  #{@file}\n/)
-    end
-
-    it "does not log status" do
-      content = action(:apply, @file, :verbose => false)
-      expect(content).to match(/cool  padding/)
-      expect(content).not_to match(/apply http/)
-    end
-  end
-
-  describe "#run" do
-    before do
-      expect(runner).to receive(:system).with("ls")
-    end
-
-    it "executes the command given" do
-      action :run, "ls"
-    end
-
-    it "logs status" do
-      expect(action(:run, "ls")).to eq("         run  ls from \".\"\n")
-    end
-
-    it "does not log status if required" do
-      expect(action(:run, "ls", :verbose => false)).to be_empty
-    end
-
-    it "accepts a color as status" do
-      expect(runner.shell).to receive(:say_status).with(:run, 'ls from "."', :yellow)
-      action :run, "ls", :verbose => :yellow
-    end
-  end
-
-  describe "#run_ruby_script" do
-    before do
-      allow(Thor::Util).to receive(:ruby_command).and_return("/opt/jruby")
-      expect(runner).to receive(:system).with("/opt/jruby script.rb")
-    end
-
-    it "executes the ruby script" do
-      action :run_ruby_script, "script.rb"
-    end
-
-    it "logs status" do
-      expect(action(:run_ruby_script, "script.rb")).to eq("         run  jruby script.rb from \".\"\n")
-    end
-
-    it "does not log status if required" do
-      expect(action(:run_ruby_script, "script.rb", :verbose => false)).to be_empty
-    end
-  end
-
-  describe "#thor" do
-    it "executes the thor command" do
-      expect(runner).to receive(:system).with("thor list")
-      action :thor, :list, :verbose => true
-    end
-
-    it "converts extra arguments to command arguments" do
-      expect(runner).to receive(:system).with("thor list foo bar")
-      action :thor, :list, "foo", "bar"
-    end
-
-    it "converts options hash to switches" do
-      expect(runner).to receive(:system).with("thor list foo bar --foo")
-      action :thor, :list, "foo", "bar", :foo => true
-
-      expect(runner).to receive(:system).with("thor list --foo 1 2 3")
-      action :thor, :list, :foo => [1, 2, 3]
-    end
-
-    it "logs status" do
-      expect(runner).to receive(:system).with("thor list")
-      expect(action(:thor, :list)).to eq("         run  thor list from \".\"\n")
-    end
-
-    it "does not log status if required" do
-      expect(runner).to receive(:system).with("thor list --foo 1 2 3")
-      expect(action(:thor, :list, :foo => [1, 2, 3], :verbose => false)).to be_empty
-    end
-
-    it "captures the output when :capture is given" do
-      expect(runner).to receive(:`).with("thor foo bar")
-      action(:thor, "foo", "bar", :capture => true)
-    end
-  end
-end

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

@@ -1,298 +0,0 @@
-require "helper"
-require "thor/base"
-
-class Amazing
-  desc "hello", "say hello"
-  def hello
-    puts "Hello"
-  end
-end
-
-describe Thor::Base do
-  describe "#initialize" do
-    it "sets arguments array" do
-      base = MyCounter.new [1, 2]
-      expect(base.first).to eq(1)
-      expect(base.second).to eq(2)
-    end
-
-    it "sets arguments default values" do
-      base = MyCounter.new [1]
-      expect(base.second).to eq(2)
-    end
-
-    it "sets options default values" do
-      base = MyCounter.new [1, 2]
-      expect(base.options[:third]).to eq(3)
-    end
-
-    it "allows options to be given as symbols or strings" do
-      base = MyCounter.new [1, 2], :third => 4
-      expect(base.options[:third]).to eq(4)
-
-      base = MyCounter.new [1, 2], "third" => 4
-      expect(base.options[:third]).to eq(4)
-    end
-
-    it "creates options with indifferent access" do
-      base = MyCounter.new [1, 2], :third => 3
-      expect(base.options["third"]).to eq(3)
-    end
-
-    it "creates options with magic predicates" do
-      base = MyCounter.new [1, 2], :third => 3
-      expect(base.options.third).to eq(3)
-    end
-  end
-
-  describe "#no_commands" do
-    it "avoids methods being added as commands" do
-      expect(MyScript.commands.keys).to include("animal")
-      expect(MyScript.commands.keys).not_to include("this_is_not_a_command")
-    end
-  end
-
-  describe "#argument" do
-    it "sets a value as required and creates an accessor for it" do
-      expect(MyCounter.start(%w[1 2 --third 3])[0]).to eq(1)
-      expect(Scripts::MyScript.start(%w[zoo my_special_param --param=normal_param])).to eq("my_special_param")
-    end
-
-    it "does not set a value in the options hash" do
-      expect(BrokenCounter.start(%w[1 2 --third 3])[0]).to be nil
-    end
-  end
-
-  describe "#arguments" do
-    it "returns the arguments for the class" do
-      expect(MyCounter.arguments.size).to be(2)
-    end
-  end
-
-  describe ":aliases" do
-    it "supports string aliases without a dash prefix" do
-      expect(MyCounter.start(%w[1 2 -z 3])[4]).to eq(3)
-    end
-
-    it "supports symbol aliases" do
-      expect(MyCounter.start(%w[1 2 -y 3])[5]).to eq(3)
-      expect(MyCounter.start(%w[1 2 -r 3])[5]).to eq(3)
-    end
-  end
-
-  describe "#class_option" do
-    it "sets options class wise" do
-      expect(MyCounter.start(%w[1 2 --third 3])[2]).to eq(3)
-    end
-
-    it "does not create an accessor for it" do
-      expect(BrokenCounter.start(%w[1 2 --third 3])[3]).to be false
-    end
-  end
-
-  describe "#class_options" do
-    it "sets default options overwriting superclass definitions" do
-      options = Scripts::MyScript.class_options
-      expect(options[:force]).not_to be_required
-    end
-  end
-
-  describe "#remove_argument" do
-    it "removes previously defined arguments from class" do
-      expect(ClearCounter.arguments).to be_empty
-    end
-
-    it "undefine accessors if required" do
-      expect(ClearCounter.new).not_to respond_to(:first)
-      expect(ClearCounter.new).not_to respond_to(:second)
-    end
-  end
-
-  describe "#remove_class_option" do
-    it "removes previous defined class option" do
-      expect(ClearCounter.class_options[:third]).to be nil
-    end
-  end
-
-  describe "#class_options_help" do
-    before do
-      @content = capture(:stdout) { MyCounter.help(Thor::Base.shell.new) }
-    end
-
-    it "shows option's description" do
-      expect(@content).to match(/# The third argument/)
-    end
-
-    it "shows usage with banner content" do
-      expect(@content).to match(/\[\-\-third=THREE\]/)
-    end
-
-    it "shows default values below descriptions" do
-      expect(@content).to match(/# Default: 3/)
-    end
-
-    it "shows options in different groups" do
-      expect(@content).to match(/Options\:/)
-      expect(@content).to match(/Runtime options\:/)
-      expect(@content).to match(/\-p, \[\-\-pretend\]/)
-    end
-
-    it "use padding in options that do not have aliases" do
-      expect(@content).to match(/^  -t, \[--third/)
-      expect(@content).to match(/^          \[--fourth/)
-    end
-
-    it "allows extra options to be given" do
-      hash = {"Foo" => B.class_options.values}
-
-      content = capture(:stdout) { MyCounter.send(:class_options_help, Thor::Base.shell.new, hash) }
-      expect(content).to match(/Foo options\:/)
-      expect(content).to match(/--last-name=LAST_NAME/)
-    end
-
-    it "displays choices for enums" do
-      content = capture(:stdout) { Enum.help(Thor::Base.shell.new) }
-      expect(content).to match(/Possible values\: apple, banana/)
-    end
-  end
-
-  describe "#namespace" do
-    it "returns the default class namespace" do
-      expect(Scripts::MyScript.namespace).to eq("scripts:my_script")
-    end
-
-    it "sets a namespace to the class" do
-      expect(Scripts::MyDefaults.namespace).to eq("default")
-    end
-  end
-
-  describe "#group" do
-    it "sets a group" do
-      expect(MyScript.group).to eq("script")
-    end
-
-    it "inherits the group from parent" do
-      expect(MyChildScript.group).to eq("script")
-    end
-
-    it "defaults to standard if no group is given" do
-      expect(Amazing.group).to eq("standard")
-    end
-  end
-
-  describe "#subclasses" do
-    it "tracks its subclasses in an Array" do
-      expect(Thor::Base.subclasses).to include(MyScript)
-      expect(Thor::Base.subclasses).to include(MyChildScript)
-      expect(Thor::Base.subclasses).to include(Scripts::MyScript)
-    end
-  end
-
-  describe "#subclass_files" do
-    it "returns tracked subclasses, grouped by the files they come from" do
-      thorfile = File.join(File.dirname(__FILE__), "fixtures", "script.thor")
-      expect(Thor::Base.subclass_files[File.expand_path(thorfile)]).to eq([
-        MyScript, MyScript::AnotherScript, MyChildScript, Barn,
-        PackageNameScript, Scripts::MyScript, Scripts::MyDefaults,
-        Scripts::ChildDefault, Scripts::Arities
-      ])
-    end
-
-    it "tracks a single subclass across multiple files" do
-      thorfile = File.join(File.dirname(__FILE__), "fixtures", "command.thor")
-      expect(Thor::Base.subclass_files[File.expand_path(thorfile)]).to include(Amazing)
-      expect(Thor::Base.subclass_files[File.expand_path(__FILE__)]).to include(Amazing)
-    end
-  end
-
-  describe "#commands" do
-    it "returns a list with all commands defined in this class" do
-      expect(MyChildScript.new).to respond_to("animal")
-      expect(MyChildScript.commands.keys).to include("animal")
-    end
-
-    it "raises an error if a command with reserved word is defined" do
-      expect do
-        klass = Class.new(Thor::Group)
-        klass.class_eval "def shell; end"
-      end.to raise_error(RuntimeError, /"shell" is a Thor reserved word and cannot be defined as command/)
-    end
-  end
-
-  describe "#all_commands" do
-    it "returns a list with all commands defined in this class plus superclasses" do
-      expect(MyChildScript.new).to respond_to("foo")
-      expect(MyChildScript.all_commands.keys).to include("foo")
-    end
-  end
-
-  describe "#remove_command" do
-    it "removes the command from its commands hash" do
-      expect(MyChildScript.commands.keys).not_to include("bar")
-      expect(MyChildScript.commands.keys).not_to include("boom")
-    end
-
-    it "undefines the method if desired" do
-      expect(MyChildScript.new).not_to respond_to("boom")
-    end
-  end
-
-  describe "#from_superclass" do
-    it "does not send a method to the superclass if the superclass does not respond to it" do
-      expect(MyCounter.get_from_super).to eq(13)
-    end
-  end
-
-  describe "#start" do
-    it "raises an error instead of rescuing if THOR_DEBUG=1 is given" do
-      begin
-        ENV["THOR_DEBUG"] = "1"
-
-        expect do
-          MyScript.start %w[what --debug]
-        end.to raise_error(Thor::UndefinedCommandError, 'Could not find command "what" in "my_script" namespace.')
-      ensure
-        ENV["THOR_DEBUG"] = nil
-      end
-    end
-
-    it "raises an error instead of rescuing if :debug option is given" do
-      expect do
-        MyScript.start %w[what], :debug => true
-      end.to raise_error(Thor::UndefinedCommandError, 'Could not find command "what" in "my_script" namespace.')
-    end
-
-    it "does not steal args" do
-      args = %w[foo bar --force true]
-      MyScript.start(args)
-      expect(args).to eq(%w[foo bar --force true])
-    end
-
-    it "checks unknown options" do
-      expect(capture(:stderr) do
-        MyScript.start(%w[foo bar --force true --unknown baz])
-      end.strip).to eq("Unknown switches '--unknown'")
-    end
-
-    it "checks unknown options except specified" do
-      expect(capture(:stderr) do
-        expect(MyScript.start(%w[with_optional NAME --omg --invalid])).to eq(["NAME", {}, %w[--omg --invalid]])
-      end.strip).to be_empty
-    end
-  end
-
-  describe "attr_*" do
-    it "does not add attr_reader as a command" do
-      expect(capture(:stderr) { MyScript.start(%w[another_attribute]) }).to match(/Could not find/)
-    end
-
-    it "does not add attr_writer as a command" do
-      expect(capture(:stderr) { MyScript.start(%w[another_attribute= foo]) }).to match(/Could not find/)
-    end
-
-    it "does not add attr_accessor as a command" do
-      expect(capture(:stderr) { MyScript.start(["some_attribute"]) }).to match(/Could not find/)
-      expect(capture(:stderr) { MyScript.start(["some_attribute=", "foo"]) }).to match(/Could not find/)
-    end
-  end
-end