cvss-suite 1.0.0

data/vendor/cache/ruby/2.2.0/gems/diff-lcs-1.2.5/spec/traverse_sequences_spec.rb

@@ -0,0 +1,139 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe "Diff::LCS.traverse_sequences" do
+  describe "callback with no finishers" do
+    describe "over (seq1, seq2)" do
+      before(:each) do
+        @callback_s1_s2 = simple_callback_no_finishers
+        Diff::LCS.traverse_sequences(seq1, seq2, @callback_s1_s2)
+
+        @callback_s2_s1 = simple_callback_no_finishers
+        Diff::LCS.traverse_sequences(seq2, seq1, @callback_s2_s1)
+      end
+
+      it "should have the correct LCS result on left-matches" do
+        @callback_s1_s2.matched_a.should == correct_lcs
+        @callback_s2_s1.matched_a.should == correct_lcs
+      end
+
+      it "should have the correct LCS result on right-matches" do
+        @callback_s1_s2.matched_b.should == correct_lcs
+        @callback_s2_s1.matched_b.should == correct_lcs
+      end
+
+      it "should have the correct skipped sequences with the left sequence" do
+        @callback_s1_s2.discards_a.should == skipped_seq1
+        @callback_s2_s1.discards_a.should == skipped_seq2
+      end
+
+      it "should have the correct skipped sequences with the right sequence" do
+        @callback_s1_s2.discards_b.should == skipped_seq2
+        @callback_s2_s1.discards_b.should == skipped_seq1
+      end
+
+      it "should not have anything done markers from the left or right sequences" do
+        @callback_s1_s2.done_a.should be_empty
+        @callback_s1_s2.done_b.should be_empty
+        @callback_s2_s1.done_a.should be_empty
+        @callback_s2_s1.done_b.should be_empty
+      end
+    end
+
+    describe "over (hello, hello)" do
+      before(:each) do
+        @callback = simple_callback_no_finishers
+        Diff::LCS.traverse_sequences(hello, hello, @callback)
+      end
+
+      it "should have the correct LCS result on left-matches" do
+        @callback.matched_a.should == hello.split(//)
+      end
+
+      it "should have the correct LCS result on right-matches" do
+        @callback.matched_b.should == hello.split(//)
+      end
+
+      it "should have the correct skipped sequences with the left sequence", :only => true do
+        @callback.discards_a.should be_empty
+      end
+
+      it "should have the correct skipped sequences with the right sequence" do
+        @callback.discards_b.should be_empty
+      end
+
+      it "should not have anything done markers from the left or right sequences" do
+        @callback.done_a.should be_empty
+        @callback.done_b.should be_empty
+      end
+    end
+
+    describe "over (hello_ary, hello_ary)" do
+      before(:each) do
+        @callback = simple_callback_no_finishers
+        Diff::LCS.traverse_sequences(hello_ary, hello_ary, @callback)
+      end
+
+      it "should have the correct LCS result on left-matches" do
+        @callback.matched_a.should == hello_ary
+      end
+
+      it "should have the correct LCS result on right-matches" do
+        @callback.matched_b.should == hello_ary
+      end
+
+      it "should have the correct skipped sequences with the left sequence" do
+        @callback.discards_a.should be_empty
+      end
+
+      it "should have the correct skipped sequences with the right sequence" do
+        @callback.discards_b.should be_empty
+      end
+
+      it "should not have anything done markers from the left or right sequences" do
+        @callback.done_a.should be_empty
+        @callback.done_b.should be_empty
+      end
+    end
+  end
+
+  describe "callback with finisher" do
+    before(:each) do
+      @callback_s1_s2 = simple_callback
+      Diff::LCS.traverse_sequences(seq1, seq2, @callback_s1_s2)
+      @callback_s2_s1 = simple_callback
+      Diff::LCS.traverse_sequences(seq2, seq1, @callback_s2_s1)
+    end
+
+    it "should have the correct LCS result on left-matches" do
+      @callback_s1_s2.matched_a.should == correct_lcs
+      @callback_s2_s1.matched_a.should == correct_lcs
+    end
+
+    it "should have the correct LCS result on right-matches" do
+      @callback_s1_s2.matched_b.should == correct_lcs
+      @callback_s2_s1.matched_b.should == correct_lcs
+    end
+
+    it "should have the correct skipped sequences for the left sequence" do
+      @callback_s1_s2.discards_a.should == skipped_seq1
+      @callback_s2_s1.discards_a.should == skipped_seq2
+    end
+
+    it "should have the correct skipped sequences for the right sequence" do
+      @callback_s1_s2.discards_b.should == skipped_seq2
+      @callback_s2_s1.discards_b.should == skipped_seq1
+    end
+
+    it "should have done markers differently-sized sequences" do
+      @callback_s1_s2.done_a.should == [[ "p", 9, "s", 10 ]]
+      @callback_s1_s2.done_b.should be_empty
+
+      # 20110731 I don't yet understand why this particular behaviour
+      # isn't transitive.
+      @callback_s2_s1.done_a.should be_empty
+      @callback_s2_s1.done_b.should be_empty
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg
+.idea
+doc
+.yardoc
+coverage
+vendor

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

@@ -0,0 +1,2 @@
+--color
+--format documentation

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

@@ -0,0 +1 @@
+docile

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

@@ -0,0 +1 @@
+ruby-2.1.0

data/vendor/cache/ruby/2.2.0/gems/docile-1.1.5/.travis.yml

@@ -0,0 +1,21 @@
+language: ruby
+cache: bundler
+rvm:
+  - ruby-head
+  - 2.1.2
+  - 2.1.1
+  - 2.1.0
+  - 2.0.0
+  - 1.9.3
+  - 1.9.2
+  - 1.8.7
+  - ree
+  - jruby-head
+  - jruby-19mode
+  - jruby-18mode
+  - rbx-2
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+  fast_finish: true

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

@@ -0,0 +1,7 @@
+--title 'Docile Documentation'
+
+--no-private
+--main=README.md
+
+--markup-provider=redcarpet
+--markup=markdown

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

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify gem's dependencies in docile.gemspec
+gemspec

data/vendor/cache/ruby/2.2.0/gems/docile-1.1.5/HISTORY.md

@@ -0,0 +1,61 @@
+# HISTORY
+
+## [v1.1.5 (Jun 15, 2014)](http://github.com/ms-ati/docile/compare/v1.1.4...v1.1.5)
+
+  - as much as possible, loosen version restrictions on development dependencies
+  - clarify gemspec settings as much as possible
+  - bump rspec dependency to 3.0.x
+
+## [v1.1.4 (Jun 11, 2014)](http://github.com/ms-ati/docile/compare/v1.1.3...v1.1.4)
+
+  - Special thanks to Ken Dreyer  (@ktdreyer):
+    - make simplecov/coveralls optional for running tests \[[33834852c7](https://github.com/ms-ati/docile/commit/33834852c7849912b97e109e8c5c193579cc5e98)\]
+    - update URL in gemspec \[[174e654a07](https://github.com/ms-ati/docile/commit/174e654a075c8350b3411b212cfb409bc605348a)\]
+
+## [v1.1.3 (Feb 4, 2014)](http://github.com/ms-ati/docile/compare/v1.1.2...v1.1.3)
+
+  - Special thanks to Alexey Vasiliev (@le0pard):
+    - fix problem to catch NoMethodError from non receiver object
+    - upgrade rspec format to new "expect" syntax
+
+## [v1.1.2 (Jan 10, 2014)](http://github.com/ms-ati/docile/compare/v1.1.1...v1.1.2)
+
+  - remove unnecessarily nested proxy objects (thanks @Ajedi32)!
+  - documentation updates and corrections
+
+## [v1.1.1 (Nov 26, 2013)](http://github.com/ms-ati/docile/compare/v1.1.0...v1.1.1)
+
+  - documentation updates and corrections
+  - fix Rubinius build in Travis CI
+
+## [v1.1.0 (Jul 29, 2013)](http://github.com/ms-ati/docile/compare/v1.0.5...v1.1.0)
+
+  - add functional-style DSL objects via `Docile#dsl_eval_immutable`
+
+## [v1.0.5 (Jul 28, 2013)](http://github.com/ms-ati/docile/compare/v1.0.4...v1.0.5)
+
+  - achieve 100% yard docs coverage
+  - fix rendering of docs at http://rubydoc.info/gems/docile
+
+## [v1.0.4 (Jul 25, 2013)](http://github.com/ms-ati/docile/compare/v1.0.3...v1.0.4)
+
+  - simplify and clarify code
+  - fix a minor bug where FallbackContextProxy#instance_variables would return
+    symbols rather than strings on Ruby 1.8.x
+
+## [v1.0.3 (Jul 6, 2013)](http://github.com/ms-ati/docile/compare/v1.0.2...v1.0.3)
+
+  - instrument code coverage via SimpleCov and publish to Coveralls.io
+
+## [v1.0.2 (Apr 1, 2013)](http://github.com/ms-ati/docile/compare/v1.0.1...v1.0.2)
+
+  - allow passing parameters to DSL blocks (thanks @dslh!)
+
+## [v1.0.1 (Nov 29, 2012)](http://github.com/ms-ati/docile/compare/v1.0.0...v1.0.1)
+
+  - relaxed rspec and rake dependencies to allow newer versions
+  - fixes to documentation
+
+## [v1.0.0 (Oct 29, 2012)](http://github.com/ms-ati/docile/compare/1b225c8a27...v1.0.0)
+
+  - Initial Feature Set

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

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2012-2014 Marc Siegel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/vendor/cache/ruby/2.2.0/gems/docile-1.1.5/README.md

@@ -0,0 +1,241 @@
+# Docile
+[![Gem Version](https://badge.fury.io/rb/docile.png)](http://badge.fury.io/rb/docile)
+[![Build Status](https://travis-ci.org/ms-ati/docile.png)](https://travis-ci.org/ms-ati/docile)
+[![Dependency Status](https://gemnasium.com/ms-ati/docile.png)](https://gemnasium.com/ms-ati/docile)
+[![Code Climate](https://codeclimate.com/github/ms-ati/docile.png)](https://codeclimate.com/github/ms-ati/docile)
+[![Coverage Status](https://coveralls.io/repos/ms-ati/docile/badge.png)](https://coveralls.io/r/ms-ati/docile)
+[![Inline docs](http://inch-ci.org/github/ms-ati/docile.png)](http://inch-ci.org/github/ms-ati/docile)
+[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/ms-ati/docile/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
+
+Ruby makes it possible to create very expressive **Domain Specific
+Languages**, or **DSL**'s for short. However, it requires some deep knowledge and
+somewhat hairy meta-programming to get the interface just right.
+
+"Docile" means *Ready to accept control or instruction; submissive* [[1]]
+
+Instead of each Ruby project reinventing this wheel, let's make our Ruby DSL
+coding a bit more docile...
+
+[1]: http://www.google.com/search?q=docile+definition   "Google"
+
+## Usage
+
+### Basic
+
+Let's say that we want to make a DSL for modifying Array objects.
+Wouldn't it be great if we could just treat the methods of Array as a DSL?
+
+```ruby
+with_array([]) do
+  push 1
+  push 2
+  pop
+  push 3
+end
+#=> [1, 3]
+```
+
+No problem, just define the method `with_array` like this:
+
+```ruby
+def with_array(arr=[], &block)
+  Docile.dsl_eval(arr, &block)
+end
+```
+
+Easy!
+
+### Advanced
+
+Mutating (changing) an Array instance is fine, but what usually makes a good DSL is a [Builder Pattern][2].
+
+For example, let's say you want a DSL to specify how you want to build a Pizza:
+
+```ruby
+@sauce_level = :extra
+
+pizza do
+  cheese
+  pepperoni
+  sauce @sauce_level
+end
+#=> #<Pizza:0x00001009dc398 @cheese=true, @pepperoni=true, @bacon=false, @sauce=:extra>
+```
+
+And let's say we have a PizzaBuilder, which builds a Pizza like this:
+
+```ruby
+Pizza = Struct.new(:cheese, :pepperoni, :bacon, :sauce)
+
+class PizzaBuilder
+  def cheese(v=true); @cheese = v; self; end
+  def pepperoni(v=true); @pepperoni = v; self; end
+  def bacon(v=true); @bacon = v; self; end
+  def sauce(v=nil); @sauce = v; self; end
+  def build
+    Pizza.new(!!@cheese, !!@pepperoni, !!@bacon, @sauce)
+  end
+end
+
+PizzaBuilder.new.cheese.pepperoni.sauce(:extra).build
+#=> #<Pizza:0x00001009dc398 @cheese=true, @pepperoni=true, @bacon=false, @sauce=:extra>
+```
+
+Then implement your DSL like this:
+
+``` ruby
+def pizza(&block)
+  Docile.dsl_eval(PizzaBuilder.new, &block).build
+end
+```
+
+It's just that easy!
+
+[2]: http://stackoverflow.com/questions/328496/when-would-you-use-the-builder-pattern  "Builder Pattern"
+
+### Block parameters
+
+Parameters can be passed to the DSL block.
+
+Supposing you want to make some sort of cheap [Sinatra][3] knockoff:
+
+```ruby
+@last_request = nil
+respond '/path' do |request|
+  puts "Request received: #{request}"
+  @last_request = request
+end
+
+def ride bike
+  # Play with your new bike
+end
+
+respond '/new_bike' do |bike|
+  ride(bike)
+end
+```
+
+You'd put together a dispatcher something like this:
+
+```ruby
+require 'singleton'
+
+class DispatchScope
+  def a_method_you_can_call_from_inside_the_block
+    :useful_huh?
+  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, &handler
+  MessageDispatch.instance.add_responder path, handler
+end
+
+def send_request path, request
+  MessageDispatch.instance.dispatch path, request
+end
+```
+
+[3]: http://www.sinatrarb.com "Sinatra"
+
+### Functional-Style DSL Objects
+
+Sometimes, you want to use an object as a DSL, but it doesn't quite fit the
+[imperative](http://en.wikipedia.org/wiki/Imperative_programming) pattern shown
+above.
+
+Instead of methods like
+[Array#push](http://www.ruby-doc.org/core-2.0/Array.html#method-i-push), which
+modifies the object at hand, it has methods like
+[String#reverse](http://www.ruby-doc.org/core-2.0/String.html#method-i-reverse),
+which returns a new object without touching the original. Perhaps it's even
+[frozen](http://www.ruby-doc.org/core-2.0/Object.html#method-i-freeze) in
+order to enforce [immutability](http://en.wikipedia.org/wiki/Immutable_object).
+
+Wouldn't it be great if we could just treat these methods as a DSL as well?
+
+```ruby
+s = "I'm immutable!".freeze
+
+with_immutable_string(s) do
+  reverse
+  upcase
+end
+#=> "!ELBATUMMI M'I"
+
+s
+#=> "I'm immutable!"
+```
+
+No problem, just define the method `with_immutable_string` like this:
+
+```ruby
+def with_immutable_string(str="", &block)
+  Docile.dsl_eval_immutable(str, &block)
+end
+```
+
+All set!
+
+## Features
+
+  1.  Method lookup falls back from the DSL object to the block's context
+  2.  Local variable lookup falls back from the DSL object to the block's
+        context
+  3.  Instance variables are from the block's context only
+  4.  Nested DSL evaluation, correctly chaining method and variable handling
+        from the inner to the outer DSL scopes
+  5.  Alternatives for both imperative and functional styles of DSL objects
+
+## Installation
+
+``` bash
+$ gem install docile
+```
+
+## Links
+* [Source](https://github.com/ms-ati/docile)
+* [Documentation](http://rubydoc.info/gems/docile)
+* [Bug Tracker](https://github.com/ms-ati/docile/issues)
+
+## Status
+
+Works on [all ruby versions since 1.8.7](https://github.com/ms-ati/docile/blob/master/.travis.yml), or so Travis CI [tells us](https://travis-ci.org/ms-ati/docile).
+
+Used by some pretty cool gems to implement their DSLs, notably including [SimpleCov](https://github.com/colszowka/simplecov). Keep an eye out for new gems using Docile at the [Ruby Toolbox](https://www.ruby-toolbox.com/projects/docile).
+
+## Note on Patches/Pull Requests
+
+  * Fork the project.
+  * Setup your development environment with:
+      `gem install bundler; bundle install`
+  * Make your feature addition or bug fix.
+  * Add tests for it. This is important so I don't break it in a future version
+      unintentionally.
+  * Commit, do not mess with rakefile, version, or history.
+      (if you want to have your own version, that is fine but bump version in a
+      commit by itself I can ignore when I pull)
+  * Send me a pull request. Bonus points for topic branches.
+
+## Copyright & License
+
+Copyright (c) 2012-2014 Marc Siegel.
+
+Licensed under the [MIT License](http://choosealicense.com/licenses/mit/), see [LICENSE](LICENSE) for details.
+
+