cvss-suite 1.0.8 → 1.1.0

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

@@ -1,210 +0,0 @@
-require "helper"
-require "thor/parser"
-
-describe Thor::Option do
-  def parse(key, value)
-    Thor::Option.parse(key, value)
-  end
-
-  def option(name, options = {})
-    @option ||= Thor::Option.new(name, options)
-  end
-
-  describe "#parse" do
-
-    describe "with value as a symbol" do
-      describe "and symbol is a valid type" do
-        it "has type equals to the symbol" do
-          expect(parse(:foo, :string).type).to eq(:string)
-          expect(parse(:foo, :numeric).type).to eq(:numeric)
-        end
-
-        it "has no default value" do
-          expect(parse(:foo, :string).default).to be nil
-          expect(parse(:foo, :numeric).default).to be nil
-        end
-      end
-
-      describe "equals to :required" do
-        it "has type equals to :string" do
-          expect(parse(:foo, :required).type).to eq(:string)
-        end
-
-        it "has no default value" do
-          expect(parse(:foo, :required).default).to be nil
-        end
-      end
-
-      describe "and symbol is not a reserved key" do
-        it "has type equal to :string" do
-          expect(parse(:foo, :bar).type).to eq(:string)
-        end
-
-        it "has no default value" do
-          expect(parse(:foo, :bar).default).to be nil
-        end
-      end
-    end
-
-    describe "with value as hash" do
-      it "has default type :hash" do
-        expect(parse(:foo, :a => :b).type).to eq(:hash)
-      end
-
-      it "has default value equal to the hash" do
-        expect(parse(:foo, :a => :b).default).to eq(:a => :b)
-      end
-    end
-
-    describe "with value as array" do
-      it "has default type :array" do
-        expect(parse(:foo, [:a, :b]).type).to eq(:array)
-      end
-
-      it "has default value equal to the array" do
-        expect(parse(:foo, [:a, :b]).default).to eq([:a, :b])
-      end
-    end
-
-    describe "with value as string" do
-      it "has default type :string" do
-        expect(parse(:foo, "bar").type).to eq(:string)
-      end
-
-      it "has default value equal to the string" do
-        expect(parse(:foo, "bar").default).to eq("bar")
-      end
-    end
-
-    describe "with value as numeric" do
-      it "has default type :numeric" do
-        expect(parse(:foo, 2.0).type).to eq(:numeric)
-      end
-
-      it "has default value equal to the numeric" do
-        expect(parse(:foo, 2.0).default).to eq(2.0)
-      end
-    end
-
-    describe "with value as boolean" do
-      it "has default type :boolean" do
-        expect(parse(:foo, true).type).to eq(:boolean)
-        expect(parse(:foo, false).type).to eq(:boolean)
-      end
-
-      it "has default value equal to the boolean" do
-        expect(parse(:foo, true).default).to eq(true)
-        expect(parse(:foo, false).default).to eq(false)
-      end
-    end
-
-    describe "with key as a symbol" do
-      it "sets the name equal to the key" do
-        expect(parse(:foo, true).name).to eq("foo")
-      end
-    end
-
-    describe "with key as an array" do
-      it "sets the first items in the array to the name" do
-        expect(parse([:foo, :bar, :baz], true).name).to eq("foo")
-      end
-
-      it "sets all other items as aliases" do
-        expect(parse([:foo, :bar, :baz], true).aliases).to eq([:bar, :baz])
-      end
-    end
-  end
-
-  it "returns the switch name" do
-    expect(option("foo").switch_name).to eq("--foo")
-    expect(option("--foo").switch_name).to eq("--foo")
-  end
-
-  it "returns the human name" do
-    expect(option("foo").human_name).to eq("foo")
-    expect(option("--foo").human_name).to eq("foo")
-  end
-
-  it "converts underscores to dashes" do
-    expect(option("foo_bar").switch_name).to eq("--foo-bar")
-  end
-
-  it "can be required and have default values" do
-    option = option("foo", :required => true, :type => :string, :default => "bar")
-    expect(option.default).to eq("bar")
-    expect(option).to be_required
-  end
-
-  it "boolean options cannot be required" do
-    expect do
-      option("foo", :required => true, :type => :boolean)
-    end.to raise_error(ArgumentError, "An option cannot be boolean and required.")
-  end
-
-  it "allows type predicates" do
-    expect(parse(:foo, :string)).to be_string
-    expect(parse(:foo, :boolean)).to be_boolean
-    expect(parse(:foo, :numeric)).to be_numeric
-  end
-
-  it "raises an error on method missing" do
-    expect do
-      parse(:foo, :string).unknown?
-    end.to raise_error(NoMethodError)
-  end
-
-  describe "#usage" do
-
-    it "returns usage for string types" do
-      expect(parse(:foo, :string).usage).to eq("[--foo=FOO]")
-    end
-
-    it "returns usage for numeric types" do
-      expect(parse(:foo, :numeric).usage).to eq("[--foo=N]")
-    end
-
-    it "returns usage for array types" do
-      expect(parse(:foo, :array).usage).to eq("[--foo=one two three]")
-    end
-
-    it "returns usage for hash types" do
-      expect(parse(:foo, :hash).usage).to eq("[--foo=key:value]")
-    end
-
-    it "returns usage for boolean types" do
-      expect(parse(:foo, :boolean).usage).to eq("[--foo], [--no-foo]")
-    end
-
-    it "does not use padding when no aliases are given" do
-      expect(parse(:foo, :boolean).usage).to eq("[--foo], [--no-foo]")
-    end
-
-    it "documents a negative option when boolean" do
-      expect(parse(:foo, :boolean).usage).to include("[--no-foo]")
-    end
-
-    it "uses banner when supplied" do
-      expect(option(:foo, :required => false, :type => :string, :banner => "BAR").usage).to eq("[--foo=BAR]")
-    end
-
-    it "checks when banner is an empty string" do
-      expect(option(:foo, :required => false, :type => :string, :banner => "").usage).to eq("[--foo]")
-    end
-
-    describe "with required values" do
-      it "does not show the usage between brackets" do
-        expect(parse(:foo, :required).usage).to eq("--foo=FOO")
-      end
-    end
-
-    describe "with aliases" do
-      it "does not show the usage between brackets" do
-        expect(parse([:foo, "-f", "-b"], :required).usage).to eq("-f, -b, --foo=FOO")
-      end
-
-      it "does not negate the aliases" do
-        expect(parse([:foo, "-f", "-b"], :boolean).usage).to eq("-f, -b, [--foo], [--no-foo]")
-      end
-    end
-  end
-end

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

@@ -1,414 +0,0 @@
-require "helper"
-require "thor/parser"
-
-describe Thor::Options do
-  def create(opts, defaults = {}, stop_on_unknown = false)
-    opts.each do |key, value|
-      opts[key] = Thor::Option.parse(key, value) unless value.is_a?(Thor::Option)
-    end
-
-    @opt = Thor::Options.new(opts, defaults, stop_on_unknown)
-  end
-
-  def parse(*args)
-    @opt.parse(args.flatten)
-  end
-
-  def check_unknown!
-    @opt.check_unknown!
-  end
-
-  def remaining
-    @opt.remaining
-  end
-
-  describe "#to_switches" do
-    it "turns true values into a flag" do
-      expect(Thor::Options.to_switches(:color => true)).to eq("--color")
-    end
-
-    it "ignores nil" do
-      expect(Thor::Options.to_switches(:color => nil)).to eq("")
-    end
-
-    it "ignores false" do
-      expect(Thor::Options.to_switches(:color => false)).to eq("")
-    end
-
-    it "writes --name value for anything else" do
-      expect(Thor::Options.to_switches(:format => "specdoc")).to eq('--format "specdoc"')
-    end
-
-    it "joins several values" do
-      switches = Thor::Options.to_switches(:color => true, :foo => "bar").split(" ").sort
-      expect(switches).to eq(%w["bar" --color --foo])
-    end
-
-    it "accepts arrays" do
-      expect(Thor::Options.to_switches(:count => [1, 2, 3])).to eq("--count 1 2 3")
-    end
-
-    it "accepts hashes" do
-      expect(Thor::Options.to_switches(:count => {:a => :b})).to eq("--count a:b")
-    end
-
-    it "accepts underscored options" do
-      expect(Thor::Options.to_switches(:under_score_option => "foo bar")).to eq('--under_score_option "foo bar"')
-    end
-
-  end
-
-  describe "#parse" do
-    it "allows multiple aliases for a given switch" do
-      create %w[--foo --bar --baz] => :string
-      expect(parse("--foo", "12")["foo"]).to eq("12")
-      expect(parse("--bar", "12")["foo"]).to eq("12")
-      expect(parse("--baz", "12")["foo"]).to eq("12")
-    end
-
-    it "allows custom short names" do
-      create "-f" => :string
-      expect(parse("-f", "12")).to eq("f" => "12")
-    end
-
-    it "allows custom short-name aliases" do
-      create %w[--bar -f] => :string
-      expect(parse("-f", "12")).to eq("bar" => "12")
-    end
-
-    it "accepts conjoined short switches" do
-      create %w[--foo -f] => true, %w[--bar -b] => true, %w[--app -a] => true
-      opts = parse("-fba")
-      expect(opts["foo"]).to be true
-      expect(opts["bar"]).to be true
-      expect(opts["app"]).to be true
-    end
-
-    it "accepts conjoined short switches with input" do
-      create %w[--foo -f] => true, %w[--bar -b] => true, %w[--app -a] => :required
-      opts = parse "-fba", "12"
-      expect(opts["foo"]).to be true
-      expect(opts["bar"]).to be true
-      expect(opts["app"]).to eq("12")
-    end
-
-    it "returns the default value if none is provided" do
-      create :foo => "baz", :bar => :required
-      expect(parse("--bar", "boom")["foo"]).to eq("baz")
-    end
-
-    it "returns the default value from defaults hash to required arguments" do
-      create Hash[:bar => :required], Hash[:bar => "baz"]
-      expect(parse["bar"]).to eq("baz")
-    end
-
-    it "gives higher priority to defaults given in the hash" do
-      create Hash[:bar => true], Hash[:bar => false]
-      expect(parse["bar"]).to eq(false)
-    end
-
-    it "raises an error for unknown switches" do
-      create :foo => "baz", :bar => :required
-      parse("--bar", "baz", "--baz", "unknown")
-      expect { check_unknown! }.to raise_error(Thor::UnknownArgumentError, "Unknown switches '--baz'")
-    end
-
-    it "skips leading non-switches" do
-      create(:foo => "baz")
-
-      expect(parse("asdf", "--foo", "bar")).to eq("foo" => "bar")
-    end
-
-    it "correctly recognizes things that look kind of like options, but aren't, as not options" do
-      create(:foo => "baz")
-      expect(parse("--asdf---asdf", "baz", "--foo", "--asdf---dsf--asdf")).to eq("foo" => "--asdf---dsf--asdf")
-      check_unknown!
-    end
-
-    it "accepts underscores in commandline args hash for boolean" do
-      create :foo_bar => :boolean
-      expect(parse("--foo_bar")["foo_bar"]).to eq(true)
-      expect(parse("--no_foo_bar")["foo_bar"]).to eq(false)
-    end
-
-    it "accepts underscores in commandline args hash for strings" do
-      create :foo_bar => :string, :baz_foo => :string
-      expect(parse("--foo_bar", "baz")["foo_bar"]).to eq("baz")
-      expect(parse("--baz_foo", "foo bar")["baz_foo"]).to eq("foo bar")
-    end
-
-    it "interprets everything after -- as args instead of options" do
-      create(:foo => :string, :bar => :required)
-      expect(parse(%w[--bar abc moo -- --foo def -a])).to eq("bar" => "abc")
-      expect(remaining).to eq(%w[moo --foo def -a])
-    end
-
-    it "ignores -- when looking for single option values" do
-      create(:foo => :string, :bar => :required)
-      expect(parse(%w[--bar -- --foo def -a])).to eq("bar" => "--foo")
-      expect(remaining).to eq(%w[def -a])
-    end
-
-    it "ignores -- when looking for array option values" do
-      create(:foo => :array)
-      expect(parse(%w[--foo a b -- c d -e])).to eq("foo" => %w[a b c d -e])
-      expect(remaining).to eq([])
-    end
-
-    it "ignores -- when looking for hash option values" do
-      create(:foo => :hash)
-      expect(parse(%w[--foo a:b -- c:d -e])).to eq("foo" => {"a" => "b", "c" => "d"})
-      expect(remaining).to eq(%w[-e])
-    end
-
-    it "ignores trailing --" do
-      create(:foo => :string)
-      expect(parse(%w[--foo --])).to eq("foo" => nil)
-      expect(remaining).to eq([])
-    end
-
-    describe "with no input" do
-      it "and no switches returns an empty hash" do
-        create({})
-        expect(parse).to eq({})
-      end
-
-      it "and several switches returns an empty hash" do
-        create "--foo" => :boolean, "--bar" => :string
-        expect(parse).to eq({})
-      end
-
-      it "and a required switch raises an error" do
-        create "--foo" => :required
-        expect { parse }.to raise_error(Thor::RequiredArgumentMissingError, "No value provided for required options '--foo'")
-      end
-    end
-
-    describe "with one required and one optional switch" do
-      before do
-        create "--foo" => :required, "--bar" => :boolean
-      end
-
-      it "raises an error if the required switch has no argument" do
-        expect { parse("--foo") }.to raise_error(Thor::MalformattedArgumentError)
-      end
-
-      it "raises an error if the required switch isn't given" do
-        expect { parse("--bar") }.to raise_error(Thor::RequiredArgumentMissingError)
-      end
-
-      it "raises an error if the required switch is set to nil" do
-        expect { parse("--no-foo") }.to raise_error(Thor::RequiredArgumentMissingError)
-      end
-
-      it "does not raises an error if the required option has a default value" do
-        options = {:required => true, :type => :string, :default => "baz"}
-        create :foo => Thor::Option.new("foo", options), :bar => :boolean
-        expect { parse("--bar") }.not_to raise_error
-      end
-    end
-
-    context "when stop_on_unknown is true" do
-      before do
-        create({:foo => :string, :verbose => :boolean}, {}, true)
-      end
-
-      it "stops parsing on first non-option" do
-        expect(parse(%w[foo --verbose])).to eq({})
-        expect(remaining).to eq(%w[foo --verbose])
-      end
-
-      it "stops parsing on unknown option" do
-        expect(parse(%w[--bar --verbose])).to eq({})
-        expect(remaining).to eq(%w[--bar --verbose])
-      end
-
-      it "retains -- after it has stopped parsing" do
-        expect(parse(%w[--bar -- whatever])).to eq({})
-        expect(remaining).to eq(%w[--bar -- whatever])
-      end
-
-      it "still accepts options that are given before non-options" do
-        expect(parse(%w[--verbose foo])).to eq("verbose" => true)
-        expect(remaining).to eq(%w[foo])
-      end
-
-      it "still accepts options that require a value" do
-        expect(parse(%w[--foo bar baz])).to eq("foo" => "bar")
-        expect(remaining).to eq(%w[baz])
-      end
-
-      it "still interprets everything after -- as args instead of options" do
-        expect(parse(%w[-- --verbose])).to eq({})
-        expect(remaining).to eq(%w[--verbose])
-      end
-    end
-
-    describe "with :string type" do
-      before do
-        create %w[--foo -f] => :required
-      end
-
-      it "accepts a switch <value> assignment" do
-        expect(parse("--foo", "12")["foo"]).to eq("12")
-      end
-
-      it "accepts a switch=<value> assignment" do
-        expect(parse("-f=12")["foo"]).to eq("12")
-        expect(parse("--foo=12")["foo"]).to eq("12")
-        expect(parse("--foo=bar=baz")["foo"]).to eq("bar=baz")
-      end
-
-      it "must accept underscores switch=value assignment" do
-        create :foo_bar => :required
-        expect(parse("--foo_bar=http://example.com/under_score/")["foo_bar"]).to eq("http://example.com/under_score/")
-      end
-
-      it "accepts a --no-switch format" do
-        create "--foo" => "bar"
-        expect(parse("--no-foo")["foo"]).to be nil
-      end
-
-      it "does not consume an argument for --no-switch format" do
-        create "--cheese" => :string
-        expect(parse("burger", "--no-cheese", "fries")["cheese"]).to be nil
-      end
-
-      it "accepts a --switch format on non required types" do
-        create "--foo" => :string
-        expect(parse("--foo")["foo"]).to eq("foo")
-      end
-
-      it "accepts a --switch format on non required types with default values" do
-        create "--baz" => :string, "--foo" => "bar"
-        expect(parse("--baz", "bang", "--foo")["foo"]).to eq("bar")
-      end
-
-      it "overwrites earlier values with later values" do
-        expect(parse("--foo=bar", "--foo", "12")["foo"]).to eq("12")
-        expect(parse("--foo", "12", "--foo", "13")["foo"]).to eq("13")
-      end
-
-      it "raises error when value isn't in enum" do
-        enum = %w[apple banana]
-        create :fruit => Thor::Option.new("fruit", :type => :string, :enum => enum)
-        expect { parse("--fruit", "orange") }.to raise_error(Thor::MalformattedArgumentError,
-                                                             "Expected '--fruit' to be one of #{enum.join(', ')}; got orange")
-      end
-    end
-
-    describe "with :boolean type" do
-      before do
-        create "--foo" => false
-      end
-
-      it "accepts --opt assignment" do
-        expect(parse("--foo")["foo"]).to eq(true)
-        expect(parse("--foo", "--bar")["foo"]).to eq(true)
-      end
-
-      it "uses the default value if no switch is given" do
-        expect(parse("")["foo"]).to eq(false)
-      end
-
-      it "accepts --opt=value assignment" do
-        expect(parse("--foo=true")["foo"]).to eq(true)
-        expect(parse("--foo=false")["foo"]).to eq(false)
-      end
-
-      it "accepts --[no-]opt variant, setting false for value" do
-        expect(parse("--no-foo")["foo"]).to eq(false)
-      end
-
-      it "accepts --[skip-]opt variant, setting false for value" do
-        expect(parse("--skip-foo")["foo"]).to eq(false)
-      end
-
-      it "will prefer 'no-opt' variant over inverting 'opt' if explicitly set" do
-        create "--no-foo" => true
-        expect(parse("--no-foo")["no-foo"]).to eq(true)
-      end
-
-      it "will prefer 'skip-opt' variant over inverting 'opt' if explicitly set" do
-        create "--skip-foo" => true
-        expect(parse("--skip-foo")["skip-foo"]).to eq(true)
-      end
-
-      it "accepts inputs in the human name format" do
-        create :foo_bar => :boolean
-        expect(parse("--foo-bar")["foo_bar"]).to eq(true)
-        expect(parse("--no-foo-bar")["foo_bar"]).to eq(false)
-        expect(parse("--skip-foo-bar")["foo_bar"]).to eq(false)
-      end
-
-      it "doesn't eat the next part of the param" do
-        create :foo => :boolean
-        expect(parse("--foo", "bar")).to eq("foo" => true)
-        expect(@opt.remaining).to eq(%w[bar])
-      end
-    end
-
-    describe "with :hash type" do
-      before do
-        create "--attributes" => :hash
-      end
-
-      it "accepts a switch=<value> assignment" do
-        expect(parse("--attributes=name:string", "age:integer")["attributes"]).to eq("name" => "string", "age" => "integer")
-      end
-
-      it "accepts a switch <value> assignment" do
-        expect(parse("--attributes", "name:string", "age:integer")["attributes"]).to eq("name" => "string", "age" => "integer")
-      end
-
-      it "must not mix values with other switches" do
-        expect(parse("--attributes", "name:string", "age:integer", "--baz", "cool")["attributes"]).to eq("name" => "string", "age" => "integer")
-      end
-    end
-
-    describe "with :array type" do
-      before do
-        create "--attributes" => :array
-      end
-
-      it "accepts a switch=<value> assignment" do
-        expect(parse("--attributes=a", "b", "c")["attributes"]).to eq(%w[a b c])
-      end
-
-      it "accepts a switch <value> assignment" do
-        expect(parse("--attributes", "a", "b", "c")["attributes"]).to eq(%w[a b c])
-      end
-
-      it "must not mix values with other switches" do
-        expect(parse("--attributes", "a", "b", "c", "--baz", "cool")["attributes"]).to eq(%w[a b c])
-      end
-    end
-
-    describe "with :numeric type" do
-      before do
-        create "n" => :numeric, "m" => 5
-      end
-
-      it "accepts a -nXY assignment" do
-        expect(parse("-n12")["n"]).to eq(12)
-      end
-
-      it "converts values to numeric types" do
-        expect(parse("-n", "3", "-m", ".5")).to eq("n" => 3, "m" => 0.5)
-      end
-
-      it "raises error when value isn't numeric" do
-        expect { parse("-n", "foo") }.to raise_error(Thor::MalformattedArgumentError,
-                                                     "Expected numeric value for '-n'; got \"foo\"")
-      end
-
-      it "raises error when value isn't in enum" do
-        enum = [1, 2]
-        create :limit => Thor::Option.new("limit", :type => :numeric, :enum => enum)
-        expect { parse("--limit", "3") }.to raise_error(Thor::MalformattedArgumentError,
-                                                        "Expected '--limit' to be one of #{enum.join(', ')}; got 3")
-      end
-    end
-
-  end
-end