cvss-suite 1.0.8 → 1.1.0

data/vendor/cache/ruby/2.2.0/gems/thor-0.19.1/spec/fixtures/invoke.thor

@@ -1,131 +0,0 @@
-class A < Thor
-  include Thor::Actions
-
-  desc "one", "invoke one"
-  def one
-    p 1
-    invoke :two
-    invoke :three
-  end
-
-  desc "two", "invoke two"
-  def two
-    p 2
-    invoke :three
-  end
-
-  desc "three", "invoke three"
-  def three
-    p 3
-  end
-
-  desc "four", "invoke four"
-  def four
-    p 4
-    invoke "defined:five"
-  end
-
-  desc "five N", "check if number is equal 5"
-  def five(number)
-    number == 5
-  end
-
-  desc "invoker", "invoke a b command"
-  def invoker(*args)
-    invoke :b, :one, ["Jose"]
-  end
-end
-
-class B < Thor
-  class_option :last_name, :type => :string
-
-  desc "one FIRST_NAME", "invoke one"
-  def one(first_name)
-    "#{options.last_name}, #{first_name}"
-  end
-
-  desc "two", "invoke two"
-  def two
-    options
-  end
-
-  desc "three", "invoke three"
-  def three
-    self
-  end
-
-  desc "four", "invoke four"
-  option :defaulted_value, :type => :string, :default => 'default'
-  def four
-    options.defaulted_value
-  end
-end
-
-class C < Thor::Group
-  include Thor::Actions
-
-  def one
-    p 1
-  end
-
-  def two
-    p 2
-  end
-
-  def three
-    p 3
-  end
-end
-
-class Defined < Thor::Group
-  class_option :unused, :type => :boolean, :desc => "This option has no use"
-
-  def one
-    p 1
-    invoke "a:two"
-    invoke "a:three"
-    invoke "a:four"
-    invoke "defined:five"
-  end
-
-  def five
-    p 5
-  end
-
-  def print_status
-    say_status :finished, :counting
-  end
-end
-
-class E < Thor::Group
-  invoke Defined
-end
-
-class F < Thor::Group
-  invoke "b:one" do |instance, klass, command|
-    instance.invoke klass, command, [ "Jose" ], :last_name => "Valim"
-  end
-end
-
-class G < Thor::Group
-  class_option :invoked, :type => :string, :default => "defined"
-  invoke_from_option :invoked
-end
-
-class H < Thor::Group
-  class_option :defined, :type => :boolean, :default => true
-  invoke_from_option :defined
-end
-
-class I < Thor
-  desc "two", "Two"
-  def two
-    current_command_chain
-  end
-end
-
-class J < Thor
-  desc "i", "I"
-  subcommand :one, I
-end
-

data/vendor/cache/ruby/2.2.0/gems/thor-0.19.1/spec/fixtures/preserve/script.sh

@@ -1,3 +0,0 @@
-#!/bin/sh
-
-exit 0

data/vendor/cache/ruby/2.2.0/gems/thor-0.19.1/spec/fixtures/script.thor

@@ -1,220 +0,0 @@
-class MyScript < Thor
-  check_unknown_options! :except => :with_optional
-
-  attr_accessor :some_attribute
-  attr_writer :another_attribute
-  attr_reader :another_attribute
-
-  private
-  attr_reader :private_attribute
-
-  public
-  group :script
-  default_command :example_default_command
-
-  map "-T" => :animal, ["-f", "--foo"] => :foo
-
-  map "animal_prison" => "zoo"
-
-  desc "zoo", "zoo around"
-  def zoo
-    true
-  end
-
-  desc "animal TYPE", "horse around"
-
-  no_commands do
-    def this_is_not_a_command
-    end
-  end
-
-  def animal(type)
-    [type]
-  end
-
-  map "hid" => "hidden"
-
-  desc "hidden TYPE", "this is hidden", :hide => true
-  def hidden(type)
-    [type]
-  end
-
-  map "fu" => "zoo"
-
-  desc "foo BAR", <<END
-do some fooing
-  This is more info!
-  Everyone likes more info!
-END
-  method_option :force, :type => :boolean, :desc => "Force to do some fooing"
-  def foo(bar)
-    [bar, options]
-  end
-
-  desc "example_default_command", "example!"
-  method_options :with => :string
-  def example_default_command
-    options.empty? ? "default command" : options
-  end
-
-  desc "call_myself_with_wrong_arity", "get the right error"
-  def call_myself_with_wrong_arity
-    call_myself_with_wrong_arity(4)
-  end
-
-  desc "call_unexistent_method", "Call unexistent method inside a command"
-  def call_unexistent_method
-    boom!
-  end
-
-  desc "long_description", "a" * 80
-  long_desc <<-D
-    This is a really really really long description.
-    Here you go. So very long.
-
-    It even has two paragraphs.
-  D
-  def long_description
-  end
-
-  desc "name-with-dashes", "Ensure normalization of command names"
-  def name_with_dashes
-  end
-
-  method_options :all => :boolean
-  method_option :lazy, :lazy_default => "yes"
-  method_option :lazy_numeric, :type => :numeric, :lazy_default => 42
-  method_option :lazy_array,   :type => :array,   :lazy_default => %w[eat at joes]
-  method_option :lazy_hash,    :type => :hash,    :lazy_default => {'swedish' => 'meatballs'}
-  desc "with_optional NAME", "invoke with optional name"
-  def with_optional(name=nil, *args)
-    [name, options, args]
-  end
-
-  class AnotherScript < Thor
-    desc "baz", "do some bazing"
-    def baz
-    end
-  end
-
-  desc "send", "send as a command name"
-  def send
-    true
-  end
-
-  private
-
-    def method_missing(meth, *args)
-      if meth == :boom!
-        super
-      else
-        [meth, args]
-      end
-    end
-
-    desc "what", "what"
-    def what
-    end
-end
-
-class MyChildScript < MyScript
-  remove_command :bar
-
-  method_options :force => :boolean, :param => :numeric
-  def initialize(*args)
-    super
-  end
-
-  desc "zoo", "zoo around"
-  method_options :param => :required
-  def zoo
-    options
-  end
-
-  desc "animal TYPE", "horse around"
-  def animal(type)
-    [type, options]
-  end
-  method_option :other, :type => :string, :default => "method default", :for => :animal
-  desc "animal KIND", "fish around", :for => :animal
-
-  desc "boom", "explodes everything"
-  def boom
-  end
-
-  remove_command :boom, :undefine => true
-end
-
-class Barn < Thor
-  desc "open [ITEM]", "open the barn door"
-  def open(item = nil)
-    if item == "shotgun"
-      puts "That's going to leave a mark."
-    else
-      puts "Open sesame!"
-    end
-  end
-
-  desc "paint [COLOR]", "paint the barn"
-  method_option :coats, :type => :numeric, :default => 2, :desc => 'how many coats of paint'
-  def paint(color='red')
-    puts "#{options[:coats]} coats of #{color} paint"
-  end
-end
-
-class PackageNameScript < Thor
-  package_name "Baboon"
-end
-
-module Scripts
-  class MyScript < MyChildScript
-    argument :accessor, :type => :string
-    class_options :force => :boolean
-    method_option :new_option, :type => :string, :for => :example_default_command
-
-    def zoo
-      self.accessor
-    end
-  end
-
-  class MyDefaults < Thor
-    check_unknown_options!
-
-    namespace :default
-    desc "cow", "prints 'moo'"
-    def cow
-      puts "moo"
-    end
-
-    desc "command_conflict", "only gets called when prepended with a colon"
-    def command_conflict
-      puts "command"
-    end
-
-    desc "barn", "commands to manage the barn"
-    subcommand "barn", Barn
-  end
-
-  class ChildDefault < Thor
-    namespace "default:child"
-  end
-
-  class Arities < Thor
-    desc "zero_args", "takes zero args"
-    def zero_args
-    end
-
-    desc "one_arg ARG", "takes one arg"
-    def one_arg(arg)
-    end
-
-    desc "two_args ARG1 ARG2", "takes two args"
-    def two_args(arg1, arg2)
-    end
-
-    desc "optional_arg [ARG]", "takes an optional arg"
-    def optional_arg(arg='default')
-    end
-  end
-end
-

data/vendor/cache/ruby/2.2.0/gems/thor-0.19.1/spec/fixtures/subcommand.thor

@@ -1,17 +0,0 @@
-module TestSubcommands
-
-  class Subcommand < Thor
-    desc "print_opt", "My method"
-    def print_opt
-      print options["opt"]
-    end
-  end
-
-  class Parent < Thor
-    class_option "opt"
-
-    desc "sub", "My subcommand"
-    subcommand "sub", Subcommand
-  end
-
-end

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

@@ -1,222 +0,0 @@
-require "helper"
-
-describe Thor::Group do
-  describe "command" do
-    it "allows to use private methods from parent class as commands" do
-      expect(ChildGroup.start).to eq(%w[bar foo baz])
-      expect(ChildGroup.new.baz("bar")).to eq("bar")
-    end
-  end
-
-  describe "#start" do
-    it "invokes all the commands under the Thor group" do
-      expect(MyCounter.start(%w[1 2 --third 3])).to eq([1, 2, 3, nil, nil, nil])
-    end
-
-    it "uses argument's default value" do
-      expect(MyCounter.start(%w[1 --third 3])).to eq([1, 2, 3, nil, nil, nil])
-    end
-
-    it "invokes all the commands in the Thor group and its parents" do
-      expect(BrokenCounter.start(%w[1 2 --third 3])).to eq([nil, 2, 3, false, 5, nil])
-    end
-
-    it "raises an error if a required argument is added after a non-required" do
-      expect do
-        MyCounter.argument(:foo, :type => :string)
-      end.to raise_error(ArgumentError, 'You cannot have "foo" as required argument after the non-required argument "second".')
-    end
-
-    it "raises when an exception happens within the command call" do
-      expect { BrokenCounter.start(%w[1 2 --fail]) }.to raise_error
-    end
-
-    it "raises an error when a Thor group command expects arguments" do
-      expect { WhinyGenerator.start }.to raise_error(ArgumentError, /thor wrong_arity takes 1 argument, but it should not/)
-    end
-
-    it "invokes help message if any of the shortcuts are given" do
-      expect(MyCounter).to receive(:help)
-      MyCounter.start(%w[-h])
-    end
-  end
-
-  describe "#desc" do
-    it "sets the description for a given class" do
-      expect(MyCounter.desc).to eq("Description:\n  This generator runs three commands: one, two and three.\n")
-    end
-
-    it "can be inherited" do
-      expect(BrokenCounter.desc).to eq("Description:\n  This generator runs three commands: one, two and three.\n")
-    end
-
-    it "can be nil" do
-      expect(WhinyGenerator.desc).to be nil
-    end
-  end
-
-  describe "#help" do
-    before do
-      @content = capture(:stdout) { MyCounter.help(Thor::Base.shell.new) }
-    end
-
-    it "provides usage information" do
-      expect(@content).to match(/my_counter N \[N\]/)
-    end
-
-    it "shows description" do
-      expect(@content).to match(/Description:/)
-      expect(@content).to match(/This generator runs three commands: one, two and three./)
-    end
-
-    it "shows options information" do
-      expect(@content).to match(/Options/)
-      expect(@content).to match(/\[\-\-third=THREE\]/)
-    end
-  end
-
-  describe "#invoke" do
-    before do
-      @content = capture(:stdout) { E.start }
-    end
-
-    it "allows to invoke a class from the class binding" do
-      expect(@content).to match(/1\n2\n3\n4\n5\n/)
-    end
-
-    it "shows invocation information to the user" do
-      expect(@content).to match(/invoke  Defined/)
-    end
-
-    it "uses padding on status generated by the invoked class" do
-      expect(@content).to match(/finished    counting/)
-    end
-
-    it "allows invocation to be configured with blocks" do
-      capture(:stdout) do
-        expect(F.start).to eq(["Valim, Jose"])
-      end
-    end
-
-    it "shows invoked options on help" do
-      content = capture(:stdout) { E.help(Thor::Base.shell.new) }
-      expect(content).to match(/Defined options:/)
-      expect(content).to match(/\[--unused\]/)
-      expect(content).to match(/# This option has no use/)
-    end
-  end
-
-  describe "#invoke_from_option" do
-    describe "with default type" do
-      before do
-        @content = capture(:stdout) { G.start }
-      end
-
-      it "allows to invoke a class from the class binding by a default option" do
-        expect(@content).to match(/1\n2\n3\n4\n5\n/)
-      end
-
-      it "does not invoke if the option is nil" do
-        expect(capture(:stdout) { G.start(%w[--skip-invoked]) }).not_to match(/invoke/)
-      end
-
-      it "prints a message if invocation cannot be found" do
-        content = capture(:stdout) { G.start(%w[--invoked unknown]) }
-        expect(content).to match(/error  unknown \[not found\]/)
-      end
-
-      it "allows to invoke a class from the class binding by the given option" do
-        error = nil
-        content = capture(:stdout) do
-          error = capture(:stderr) do
-            G.start(%w[--invoked e])
-          end
-        end
-        expect(content).to match(/invoke  e/)
-        expect(error).to match(/ERROR: "thor two" was called with arguments/)
-      end
-
-      it "shows invocation information to the user" do
-        expect(@content).to match(/invoke  defined/)
-      end
-
-      it "uses padding on status generated by the invoked class" do
-        expect(@content).to match(/finished    counting/)
-      end
-
-      it "shows invoked options on help" do
-        content = capture(:stdout) { G.help(Thor::Base.shell.new) }
-        expect(content).to match(/defined options:/)
-        expect(content).to match(/\[--unused\]/)
-        expect(content).to match(/# This option has no use/)
-      end
-    end
-
-    describe "with boolean type" do
-      before do
-        @content = capture(:stdout) { H.start }
-      end
-
-      it "allows to invoke a class from the class binding by a default option" do
-        expect(@content).to match(/1\n2\n3\n4\n5\n/)
-      end
-
-      it "does not invoke if the option is false" do
-        expect(capture(:stdout) { H.start(%w[--no-defined]) }).not_to match(/invoke/)
-      end
-
-      it "shows invocation information to the user" do
-        expect(@content).to match(/invoke  defined/)
-      end
-
-      it "uses padding on status generated by the invoked class" do
-        expect(@content).to match(/finished    counting/)
-      end
-
-      it "shows invoked options on help" do
-        content = capture(:stdout) { H.help(Thor::Base.shell.new) }
-        expect(content).to match(/defined options:/)
-        expect(content).to match(/\[--unused\]/)
-        expect(content).to match(/# This option has no use/)
-      end
-    end
-  end
-
-  describe "edge-cases" do
-    it "can handle boolean options followed by arguments" do
-      klass = Class.new(Thor::Group) do
-        desc "say hi to name"
-        argument :name, :type => :string
-        class_option :loud, :type => :boolean
-
-        def hi
-          name.upcase! if options[:loud]
-          "Hi #{name}"
-        end
-      end
-
-      expect(klass.start(%w[jose])).to eq(["Hi jose"])
-      expect(klass.start(%w[jose --loud])).to eq(["Hi JOSE"])
-      expect(klass.start(%w[--loud jose])).to eq(["Hi JOSE"])
-    end
-
-    it "provides extra args as `args`" do
-      klass = Class.new(Thor::Group) do
-        desc "say hi to name"
-        argument :name, :type => :string
-        class_option :loud, :type => :boolean
-
-        def hi
-          name.upcase! if options[:loud]
-          out = "Hi #{name}"
-          out << ": " << args.join(", ") unless args.empty?
-          out
-        end
-      end
-
-      expect(klass.start(%w[jose])).to eq(["Hi jose"])
-      expect(klass.start(%w[jose --loud])).to eq(["Hi JOSE"])
-      expect(klass.start(%w[--loud jose])).to eq(["Hi JOSE"])
-    end
-  end
-end