cvss-suite 1.0.8 → 1.1.0

data/vendor/cache/ruby/2.2.0/gems/docile-1.1.5/Rakefile

@@ -1,28 +0,0 @@
-require 'rake/clean'
-require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
-require File.expand_path('on_what', File.dirname(__FILE__))
-
-# Default task for `rake` is to run rspec
-task :default => [:spec]
-
-# Use default rspec rake task
-RSpec::Core::RakeTask.new
-
-# Configure `rake clobber` to delete all generated files
-CLOBBER.include('pkg', 'doc', 'coverage')
-
-# To limit needed compatibility with versions of dependencies, only configure
-#   yard doc generation when *not* on Travis, JRuby, or 1.8
-if !on_travis? && !on_jruby? && !on_1_8?
-  require 'github/markup'
-  require 'redcarpet'
-  require 'yard'
-  require 'yard/rake/yardoc_task'
-
-  YARD::Rake::YardocTask.new do |t|
-    OTHER_PATHS = %w()
-    t.files   = ['lib/**/*.rb', OTHER_PATHS]
-    t.options = %w(--markup-provider=redcarpet --markup=markdown --main=README.md)
-  end
-end

data/vendor/cache/ruby/2.2.0/gems/docile-1.1.5/docile.gemspec

@@ -1,43 +0,0 @@
-require File.expand_path('on_what', File.dirname(__FILE__))
-$:.push File.expand_path('../lib', __FILE__)
-require 'docile/version'
-
-Gem::Specification.new do |s|
-  s.name        = 'docile'
-  s.version     = Docile::VERSION
-  s.author      = 'Marc Siegel'
-  s.email       = 'marc@usainnov.com'
-  s.homepage    = 'https://ms-ati.github.io/docile/'
-  s.summary     = 'Docile keeps your Ruby DSLs tame and well-behaved'
-  s.description = 'Docile turns any Ruby object into a DSL. Especially useful with the Builder pattern.'
-  s.license     = 'MIT'
-
-  # Files included in the gem
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = %w(lib)
-
-  # Specify oldest supported Ruby version
-  s.required_ruby_version = '>= 1.8.7'
-
-  # Run rspec tests from rake
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'rspec', '~> 3.0.0'
-
-  # NOTE: needed for Travis builds on 1.8, but can't yet reproduce failure locally
-  s.add_development_dependency 'mime-types', '~> 1.25.1' if on_1_8?
-
-  # To limit needed compatibility with versions of dependencies, only configure
-  #   yard doc generation when *not* on Travis, JRuby, or 1.8
-  if !on_travis? && !on_jruby? && !on_1_8?
-    # Github flavored markdown in YARD documentation
-    # http://blog.nikosd.com/2011/11/github-flavored-markdown-in-yard.html
-    s.add_development_dependency 'yard'
-    s.add_development_dependency 'redcarpet'
-    s.add_development_dependency 'github-markup'
-  end
-
-  # Coveralls test coverage tool, basically hosted SimpleCov
-  s.add_development_dependency 'coveralls'
-end

data/vendor/cache/ruby/2.2.0/gems/docile-1.1.5/lib/docile.rb

@@ -1,84 +0,0 @@
-require 'docile/version'
-require 'docile/execution'
-require 'docile/fallback_context_proxy'
-require 'docile/chaining_fallback_context_proxy'
-
-# Docile keeps your Ruby DSLs tame and well-behaved.
-module Docile
-  extend Execution
-
-  # Execute a block in the context of an object whose methods represent the
-  # commands in a DSL.
-  #
-  # @note Use with an *imperative* DSL (commands modify the context object)
-  #
-  # Use this method to execute an *imperative* DSL, which means that:
-  #
-  #   1. Each command mutates the state of the DSL context object
-  #   2. The return value of each command is ignored
-  #   3. The final return value is the original context object
-  #
-  # @example Use a String as a DSL
-  #   Docile.dsl_eval("Hello, world!") do
-  #     reverse!
-  #     upcase!
-  #   end
-  #   #=> "!DLROW ,OLLEH"
-  #
-  # @example Use an Array as a DSL
-  #   Docile.dsl_eval([]) do
-  #     push 1
-  #     push 2
-  #     pop
-  #     push 3
-  #   end
-  #   #=> [1, 3]
-  #
-  # @param dsl   [Object] context object whose methods make up the DSL
-  # @param args  [Array]  arguments to be passed to the block
-  # @param block [Proc]   the block of DSL commands to be executed against the
-  #                         `dsl` context object
-  # @return      [Object] the `dsl` context object after executing the block
-  def dsl_eval(dsl, *args, &block)
-    exec_in_proxy_context(dsl, FallbackContextProxy, *args, &block)
-    dsl
-  end
-  module_function :dsl_eval
-
-  # Execute a block in the context of an immutable object whose methods,
-  # and the methods of their return values, represent the commands in a DSL.
-  #
-  # @note Use with a *functional* DSL (commands return successor
-  #       context objects)
-  #
-  # Use this method to execute a *functional* DSL, which means that:
-  #
-  #   1. The original DSL context object is never mutated
-  #   2. Each command returns the next DSL context object
-  #   3. The final return value is the value returned by the last command
-  #
-  # @example Use a frozen String as a DSL
-  #   Docile.dsl_eval_immutable("I'm immutable!".freeze) do
-  #     reverse
-  #     upcase
-  #   end
-  #   #=> "!ELBATUMMI M'I"
-  #
-  # @example Use a Float as a DSL
-  #   Docile.dsl_eval_immutable(84.5) do
-  #     fdiv(2)
-  #     floor
-  #   end
-  #   #=> 42
-  #
-  # @param dsl   [Object] immutable context object whose methods make up the
-  #                       initial DSL
-  # @param args  [Array]  arguments to be passed to the block
-  # @param block [Proc]   the block of DSL commands to be executed against the
-  #                         `dsl` context object and successor return values
-  # @return      [Object] the return value of the final command in the block
-  def dsl_eval_immutable(dsl, *args, &block)
-    exec_in_proxy_context(dsl, ChainingFallbackContextProxy, *args, &block)
-  end
-  module_function :dsl_eval_immutable
-end

data/vendor/cache/ruby/2.2.0/gems/docile-1.1.5/lib/docile/chaining_fallback_context_proxy.rb

@@ -1,20 +0,0 @@
-require 'docile/fallback_context_proxy'
-
-module Docile
-  # @api private
-  #
-  # Operates in the same manner as {FallbackContextProxy}, but replacing
-  # the primary `receiver` object with the result of each proxied method.
-  #
-  # This is useful for implementing DSL evaluation for immutable context
-  # objects.
-  #
-  # @see Docile.dsl_eval_immutable
-  class ChainingFallbackContextProxy < FallbackContextProxy
-    # Proxy methods as in {FallbackContextProxy#method_missing}, replacing
-    # `receiver` with the returned value.
-    def method_missing(method, *args, &block)
-      @__receiver__ = super(method, *args, &block)
-    end
-  end
-end

data/vendor/cache/ruby/2.2.0/gems/docile-1.1.5/lib/docile/execution.rb

@@ -1,35 +0,0 @@
-module Docile
-  # @api private
-  #
-  # A namespace for functions relating to the execution of a block against a
-  # proxy object.
-  module Execution
-    # Execute a block in the context of an object whose methods represent the
-    # commands in a DSL, using a specific proxy class.
-    #
-    # @param dsl        [Object] context object whose methods make up the
-    #                            (initial) DSL
-    # @param proxy_type [FallbackContextProxy, ChainingFallbackContextProxy]
-    #                            which class to instantiate as proxy context
-    # @param args       [Array]  arguments to be passed to the block
-    # @param block      [Proc]   the block of DSL commands to be executed
-    # @return           [Object] the return value of the block
-    def exec_in_proxy_context(dsl, proxy_type, *args, &block)
-      block_context = eval('self', block.binding)
-      proxy_context = proxy_type.new(dsl, block_context)
-      begin
-        block_context.instance_variables.each do |ivar|
-          value_from_block = block_context.instance_variable_get(ivar)
-          proxy_context.instance_variable_set(ivar, value_from_block)
-        end
-        proxy_context.instance_exec(*args, &block)
-      ensure
-        block_context.instance_variables.each do |ivar|
-          value_from_dsl_proxy = proxy_context.instance_variable_get(ivar)
-          block_context.instance_variable_set(ivar, value_from_dsl_proxy)
-        end
-      end
-    end
-    module_function :exec_in_proxy_context
-  end
-end

data/vendor/cache/ruby/2.2.0/gems/docile-1.1.5/lib/docile/fallback_context_proxy.rb

@@ -1,63 +0,0 @@
-require 'set'
-
-module Docile
-  # @api private
-  #
-  # A proxy object with a primary receiver as well as a secondary
-  # fallback receiver.
-  #
-  # Will attempt to forward all method calls first to the primary receiver,
-  # and then to the fallback receiver if the primary does not handle that
-  # method.
-  #
-  # This is useful for implementing DSL evaluation in the context of an object.
-  #
-  # @see Docile.dsl_eval
-  class FallbackContextProxy
-    # The set of methods which will **not** be proxied, but instead answered
-    # by this object directly.
-    NON_PROXIED_METHODS = Set[:__send__, :object_id, :__id__, :==, :equal?,
-                              :'!', :'!=', :instance_exec, :instance_variables,
-                              :instance_variable_get, :instance_variable_set,
-                              :remove_instance_variable]
-
-    # The set of instance variables which are local to this object and hidden.
-    # All other instance variables will be copied in and out of this object
-    # from the scope in which this proxy was created.
-    NON_PROXIED_INSTANCE_VARIABLES = Set[:@__receiver__, :@__fallback__]
-
-    # Undefine all instance methods except those in {NON_PROXIED_METHODS}
-    instance_methods.each do |method|
-      undef_method(method) unless NON_PROXIED_METHODS.include?(method.to_sym)
-    end
-
-    # @param [Object] receiver  the primary proxy target to which all methods
-    #                             initially will be forwarded
-    # @param [Object] fallback  the fallback proxy target to which any methods
-    #                             not handled by `receiver` will be forwarded
-    def initialize(receiver, fallback)
-      @__receiver__ = receiver
-      @__fallback__ = fallback
-    end
-
-    # @return [Array<Symbol>]  Instance variable names, excluding
-    #                            {NON_PROXIED_INSTANCE_VARIABLES}
-    #
-    # @note on Ruby 1.8.x, the instance variable names are actually of
-    #   type `String`.
-    def instance_variables
-      # Ruby 1.8.x returns string names, convert to symbols for compatibility
-      super.select { |v| !NON_PROXIED_INSTANCE_VARIABLES.include?(v.to_sym) }
-    end
-
-    # Proxy all methods, excluding {NON_PROXIED_METHODS}, first to `receiver`
-    # and then to `fallback` if not found.
-    def method_missing(method, *args, &block)
-      if @__receiver__.respond_to?(method.to_sym)
-        @__receiver__.__send__(method.to_sym, *args, &block)
-      else
-        @__fallback__.__send__(method.to_sym, *args, &block)
-      end
-    end
-  end
-end

data/vendor/cache/ruby/2.2.0/gems/docile-1.1.5/lib/docile/version.rb

@@ -1,4 +0,0 @@
-module Docile
-  # The current version of this library
-  VERSION = '1.1.5'
-end

data/vendor/cache/ruby/2.2.0/gems/docile-1.1.5/on_what.rb

@@ -1,14 +0,0 @@
-# NOTE: Very simple tests for what system we are on, extracted for sharing
-#   between Rakefile, gemspec, and spec_helper. Not for use in actual library.
-
-def on_travis?
-  ENV['CI'] == 'true'
-end
-
-def on_jruby?
-  (defined?(RUBY_ENGINE) && 'jruby' == RUBY_ENGINE)
-end
-
-def on_1_8?
-  RUBY_VERSION.start_with? '1.8'
-end

data/vendor/cache/ruby/2.2.0/gems/docile-1.1.5/spec/docile_spec.rb

@@ -1,339 +0,0 @@
-require 'spec_helper'
-require 'singleton'
-
-describe Docile do
-
-  describe '.dsl_eval' do
-
-    context 'when DSL context object is an Array' do
-      let(:array) { [] }
-      let!(:result) { execute_dsl_against_array }
-
-      def execute_dsl_against_array
-        Docile.dsl_eval(array) do
-          push 1
-          push 2
-          pop
-          push 3
-        end
-      end
-
-      it 'executes the block against the DSL context object' do
-        expect(array).to eq([1, 3])
-      end
-
-      it 'returns the DSL object after executing block against it' do
-        expect(result).to eq(array)
-      end
-
-      it "doesn't proxy #__id__" do
-        Docile.dsl_eval(array) { expect(__id__).not_to eq(array.__id__) }
-      end
-
-      it "raises NoMethodError if the DSL object doesn't implement the method" do
-        expect { Docile.dsl_eval(array) { no_such_method } }.to raise_error(NoMethodError)
-      end
-    end
-
-    Pizza = Struct.new(:cheese, :pepperoni, :bacon, :sauce)
-
-    class PizzaBuilder
-      def cheese(v=true);    @cheese    = v; end
-      def pepperoni(v=true); @pepperoni = v; end
-      def bacon(v=true);     @bacon     = v; end
-      def sauce(v=nil);      @sauce     = v; end
-      def build
-        Pizza.new(!!@cheese, !!@pepperoni, !!@bacon, @sauce)
-      end
-    end
-
-    context 'when DSL context object is a Builder pattern' do
-      let(:builder) { PizzaBuilder.new }
-      let(:result) { execute_dsl_against_builder_and_call_build }
-
-      def execute_dsl_against_builder_and_call_build
-        @sauce = :extra
-        Docile.dsl_eval(builder) do
-          bacon
-          cheese
-          sauce @sauce
-        end.build
-      end
-
-      it 'returns correctly built object' do
-        expect(result).to eq(Pizza.new(true, false, true, :extra))
-      end
-    end
-
-    class InnerDSL
-      def initialize; @b = 'b'; end
-      attr_accessor :b
-    end
-
-    class OuterDSL
-      def initialize; @a = 'a'; end
-      attr_accessor :a
-
-      def inner(&block)
-        Docile.dsl_eval(InnerDSL.new, &block)
-      end
-
-      def inner_with_params(param, &block)
-        Docile.dsl_eval(InnerDSL.new, param, :foo, &block)
-      end
-    end
-
-    def outer(&block)
-      Docile.dsl_eval(OuterDSL.new, &block)
-    end
-
-    context 'when given parameters for the DSL block' do
-      def parameterized(*args, &block)
-        Docile.dsl_eval(OuterDSL.new, *args, &block)
-      end
-
-      it 'passes parameters to the block' do
-        parameterized(1,2,3) do |x,y,z|
-          expect(x).to eq(1)
-          expect(y).to eq(2)
-          expect(z).to eq(3)
-        end
-      end
-
-      it 'finds parameters before methods' do
-        parameterized(1) { |a| expect(a).to eq(1) }
-      end
-
-      it 'find outer dsl parameters in inner dsl scope' do
-        parameterized(1,2,3) do |a,b,c|
-          inner_with_params(c) do |d,e|
-            expect(a).to eq(1)
-            expect(b).to eq(2)
-            expect(c).to eq(3)
-            expect(d).to eq(c)
-            expect(e).to eq(:foo)
-          end
-        end
-      end
-    end
-
-    class DSLWithNoMethod
-      def initialize(b); @b = b; end
-      attr_accessor :b
-      def push_element
-        @b.push 1
-      end
-    end
-
-    context 'when DSL have NoMethod error inside' do
-      it 'raise error from nil' do
-        Docile.dsl_eval(DSLWithNoMethod.new(nil)) do
-          expect { push_element }.to raise_error(NoMethodError, /undefined method `push' (for|on) nil:NilClass/)
-        end
-      end
-    end
-
-    context 'when DSL blocks are nested' do
-
-      context 'method lookup' do
-        it 'finds method of outer dsl in outer dsl scope' do
-          outer { expect(a).to eq('a') }
-        end
-
-        it 'finds method of inner dsl in inner dsl scope' do
-          outer { inner { expect(b).to eq('b') } }
-        end
-
-        it 'finds method of outer dsl in inner dsl scope' do
-          outer { inner { expect(a).to eq('a') } }
-        end
-
-        it "finds method of block's context in outer dsl scope" do
-          def c; 'c'; end
-          outer { expect(c).to eq('c') }
-        end
-
-        it "finds method of block's context in inner dsl scope" do
-          def c; 'c'; end
-          outer { inner { expect(c).to eq('c') } }
-        end
-
-        it 'finds method of outer dsl in preference to block context' do
-          def a; 'not a'; end
-          outer { expect(a).to eq('a') }
-          outer { inner { expect(a).to eq('a') } }
-        end
-      end
-
-      context 'local variable lookup' do
-        it 'finds local variable from block context in outer dsl scope' do
-          foo = 'foo'
-          outer { expect(foo).to eq('foo') }
-        end
-
-        it 'finds local variable from block definition in inner dsl scope' do
-          bar = 'bar'
-          outer { inner { expect(bar).to eq('bar') } }
-        end
-      end
-
-      context 'instance variable lookup' do
-        it 'finds instance variable from block definition in outer dsl scope' do
-          @iv1 = 'iv1'; outer { expect(@iv1).to eq('iv1') }
-        end
-
-        it "proxies instance variable assignments in block in outer dsl scope back into block's context" do
-          @iv1 = 'foo'; outer { @iv1 = 'bar' }; expect(@iv1).to eq('bar')
-        end
-
-        it 'finds instance variable from block definition in inner dsl scope' do
-          @iv2 = 'iv2'; outer { inner { expect(@iv2).to eq('iv2') } }
-        end
-
-        it "proxies instance variable assignments in block in inner dsl scope back into block's context" do
-          @iv2 = 'foo'; outer { inner { @iv2 = 'bar' } }; expect(@iv2).to eq('bar')
-        end
-      end
-
-    end
-
-    context 'when DSL context object is a Dispatch pattern' do
-      class DispatchScope
-        def params
-          { :a => 1, :b => 2, :c => 3 }
-        end
-      end
-
-      class MessageDispatch
-        include Singleton
-
-        def initialize
-          @responders = {}
-        end
-
-        def add_responder path, &block
-          @responders[path] = block
-        end
-
-        def dispatch path, request
-          Docile.dsl_eval(DispatchScope.new, request, &@responders[path])
-        end
-      end
-
-      def respond(path, &block)
-        MessageDispatch.instance.add_responder(path, &block)
-      end
-
-      def send_request(path, request)
-        MessageDispatch.instance.dispatch(path, request)
-      end
-
-      it 'dispatches correctly' do
-        @first = @second = nil
-
-        respond '/path' do |request|
-          @first = request
-        end
-
-        respond '/new_bike' do |bike|
-          @second = "Got a new #{bike}"
-        end
-
-        def x(y) ; "Got a #{y}"; end
-        respond '/third' do |third|
-          expect(x(third)).to eq('Got a third thing')
-        end
-
-        fourth = nil
-        respond '/params' do |arg|
-          fourth = params[arg]
-        end
-
-        send_request '/path', 1
-        send_request '/new_bike', 'ten speed'
-        send_request '/third', 'third thing'
-        send_request '/params', :b
-
-        expect(@first).to eq(1)
-        expect(@second).to eq('Got a new ten speed')
-        expect(fourth).to eq(2)
-      end
-
-    end
-
-  end
-
-  describe '.dsl_eval_immutable' do
-
-    context 'when DSL context object is a frozen String' do
-      let(:original) { "I'm immutable!".freeze }
-      let!(:result) { execute_non_mutating_dsl_against_string }
-
-      def execute_non_mutating_dsl_against_string
-        Docile.dsl_eval_immutable(original) do
-          reverse
-          upcase
-        end
-      end
-
-      it "doesn't modify the original string" do
-        expect(original).to eq("I'm immutable!")
-      end
-
-      it 'chains the commands in the block against the DSL context object' do
-        expect(result).to eq("!ELBATUMMI M'I")
-      end
-    end
-
-    context 'when DSL context object is a number' do
-      let(:original) { 84.5 }
-      let!(:result) { execute_non_mutating_dsl_against_number }
-
-      def execute_non_mutating_dsl_against_number
-        Docile.dsl_eval_immutable(original) do
-          fdiv(2)
-          floor
-        end
-      end
-
-      it 'chains the commands in the block against the DSL context object' do
-        expect(result).to eq(42)
-      end
-    end
-  end
-
-end
-
-describe Docile::FallbackContextProxy do
-
-  describe '#instance_variables' do
-    subject { create_fcp_and_set_one_instance_variable.instance_variables }
-    let(:expected_type_of_names) { type_of_ivar_names_on_this_ruby }
-    let(:actual_type_of_names) { subject.first.class }
-    let(:excluded) { Docile::FallbackContextProxy::NON_PROXIED_INSTANCE_VARIABLES }
-
-    def create_fcp_and_set_one_instance_variable
-      fcp = Docile::FallbackContextProxy.new(nil, nil)
-      fcp.instance_variable_set(:@foo, 'foo')
-      fcp
-    end
-
-    def type_of_ivar_names_on_this_ruby
-      @a = 1
-      instance_variables.first.class
-    end
-
-    it 'returns proxied instance variables' do
-      expect(subject.map(&:to_sym)).to include(:@foo)
-    end
-
-    it "doesn't return non-proxied instance variables" do
-      expect(subject.map(&:to_sym)).not_to include(*excluded)
-    end
-
-    it 'preserves the type (String or Symbol) of names on this ruby version' do
-      expect(actual_type_of_names).to eq(expected_type_of_names)
-    end
-  end
-
-end