cvss-suite 1.0.0

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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,14 @@
+# 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

@@ -0,0 +1,339 @@
+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