RubyGems - cvss-suite - Versions diffs - 1.0.8 → 1.1.0 - Mend

cvss-suite 1.0.8 → 1.1.0

Files changed (821) hide show

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

@@ -1,30 +0,0 @@
-require File.expand_path('on_what', File.dirname(File.dirname(__FILE__)))
-begin
-  require 'simplecov'
-  require 'coveralls'
-  # On Ruby 1.9+ use SimpleCov and publish to Coveralls.io
-  if !on_1_8?
-    SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-      SimpleCov::Formatter::HTMLFormatter,
-      Coveralls::SimpleCov::Formatter
-    ]
-    SimpleCov.start do
-      add_filter '/spec/'    # exclude test code
-      add_filter '/vendor/'  # exclude gems which are vendored on Travis CI
-    end
-    # Remove Docile, which was required by SimpleCov, to require again later
-    Object.send(:remove_const, :Docile)
-    $LOADED_FEATURES.reject! { |f| f =~ /\/docile\// }
-  end
-rescue LoadError
-  warn 'warning: simplecov/coveralls gems not found; skipping coverage'
-end
-lib_dir = File.join(File.dirname(File.dirname(__FILE__)), 'lib')
-$LOAD_PATH.unshift lib_dir unless $LOAD_PATH.include? lib_dir
-# Require Docile again, now with coverage enabled on 1.9+
-require 'docile'

data/vendor/cache/ruby/2.2.0/gems/git-1.3.0/CHANGELOG DELETED

@@ -1,84 +0,0 @@
-== 1.3.0
- * Dropping Ruby 1.8.x support
-== 1.2.10
- * Adding Git::Diff.name_status
- * Checking and fixing encoding on commands output to prevent encoding errors afterwards
-== 1.2.9
-* Adding Git.configure (to configure the git env)
-* Adding Git.ls_remote [Git.ls_remote(repo_path_or_url='.')]
-* Adding Git.describe [repo.describe(objectish, opts)]
-* Adding Git.show [repo.show(objectish=nil, path=nil)]
-* Fixing Git::Diff to support default references (implicit references)
-* Fixing Git::Diff to support diff over git .patch files
-* Fixing Git.checkout when using :new_branch opt
-* Fixing Git::Object::Commit to preserve its sha after fetching metadata
-* Fixing Git.is_remote_branch? to actually check against remote branches
-* Improvements over how ENV variables are modified
-* Improving thrade safety (using --git-dir and --work-tree git opts)
-* Improving Git::Object::Tag. Adding annotated?, tagger and message
-* Supporting a submodule path as a valid repo
-* Git.checkout - supporting -f and -b
-* Git.clone - supporting --branch
-* Git.fetch - supporting --prune
-* Git.tag - supporting
-== 1.2.8
-* Keeping the old escape format for windows users
-* revparse: Supporting ref names containing SHA like substrings (40-hex strings)
-* Fix warnings on Ruby 2.1.2
-== 1.2.7
-* Fixing mesages encoding
-* Fixing -f flag in git push
-* Fixing log parser for multiline messages
-* Supporting object references on Git.add_tag
-* Including dotfiles on Git.status
-* Git.fetch - supporting --tags
-* Git.clean - supporting -x
-* Git.add_tag options - supporting -a, -m and -s
-* Added Git.delete_tag
-== 1.2.6
-* Ruby 1.9.X/2.0 fully supported
-* JRuby 1.8/1.9 support
-* Rubinius support
-* Git.clone - supporting --recursive and --config
-* Git.log - supporting last and [] over the results
-* Git.add_remote - supporting -f and -t
-* Git.add - supporting --fore
-* Git.init - supporting --bare
-* Git.commit - supporting --all and --amend
-* Added Git.remote_remote, Git.revert and Git.clean
-* Added Bundler to the formula
-* Travis configuration
-* Licence included with the gem
-== 1.0.4
-* added camping/gitweb.rb frontend
-* added a number of speed-ups
-== 1.0.3
-* Sped up most of the operations
-* Added some predicate functions (commit?, tree?, etc)
-* Added a number of lower level operations (read-tree, write-tree, checkout-index, etc)
-* Fixed a bug with using bare repositories
-* Updated a good amount of the documentation
-== 1.0.2
-* Added methods to the git objects that might be helpful
-== 1.0.1
-* Initial version

data/vendor/cache/ruby/2.2.0/gems/git-1.3.0/LICENSE DELETED

@@ -1,21 +0,0 @@
-The MIT License
-Copyright (c) 2008 Scott Chacon
-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/git-1.3.0/README.md DELETED

@@ -1,297 +0,0 @@
-# Git Library for Ruby
-Library for using Git in Ruby.
-## Homepage
-Git public hosting of the project source code is at:
-http://github.com/schacon/ruby-git
-## Install
-You can install Ruby/Git like this:
-    $ sudo gem install git
-## Code Status
-* [![Build Status](https://api.travis-ci.org/schacon/ruby-git.png)](https://travis-ci.org/schacon/ruby-git)
-* [![Code Climate](https://codeclimate.com/github/schacon/ruby-git.png)](https://codeclimate.com/github/schacon/ruby-git)
-* [![Gem Version](https://badge.fury.io/rb/git.png)](http://badge.fury.io/rb/git)
-* [![Dependencies](https://gemnasium.com/schacon/ruby-git.png?travis)](https://gemnasium.com/schacon/ruby-git)
-## Major Objects
-**Git::Base** - The object returned from a `Git.open` or `Git.clone`. Most major actions are called from this object.
-**Git::Object** - The base object for your tree, blob and commit objects, returned from `@git.gtree` or `@git.object` calls.  the `Git::AbstractObject` will have most of the calls in common for all those objects.
-**Git::Diff** - returns from a `@git.diff` command.  It is an Enumerable that returns `Git::Diff:DiffFile` objects from which you can get per file patches and insertion/deletion statistics.  You can also get total statistics from the Git::Diff object directly.
-**Git::Status** - returns from a `@git.status` command.  It is an Enumerable that returns
-`Git:Status::StatusFile` objects for each object in git, which includes files in the working
-directory, in the index and in the repository.  Similar to running 'git status' on the command line to determine untracked and changed files.
-**Git::Branches** - Enumerable object that holds `Git::Branch objects`.  You can call .local or .remote on it to filter to just your local or remote branches.
-**Git::Remote**- A reference to a remote repository that is tracked by this repository.
-**Git::Log** - An Enumerable object that references all the `Git::Object::Commit` objects that encompass your log query, which can be constructed through methods on the `Git::Log object`,
-like:
- `@git.log(20).object("some_file").since("2 weeks ago").between('v2.6', 'v2.7').each { |commit| [block] }`
-## Examples
-Here are a bunch of examples of how to use the Ruby/Git package.
-Ruby < 1.9 will require rubygems to be loaded.
-```ruby
-    require 'rubygems'
-```
-Require the 'git' gem.
-```ruby
-    require 'git'
-```
-Git env config
-```ruby
-  Git.configure do |config|
-    # If you want to use a custom git binary
-    config.binary_path = '/git/bin/path'
-    # If you need to use a custom SSH script
-    config.git_ssh = '/path/to/ssh/script'
-  end
-```
-Here are the operations that need read permission only.
-```ruby
-    g = Git.open(working_dir, :log => Logger.new(STDOUT))
-    g.index
-    g.index.readable?
-    g.index.writable?
-    g.repo
-    g.dir
-    g.log   # returns array of Git::Commit objects
-    g.log.since('2 weeks ago')
-    g.log.between('v2.5', 'v2.6')
-    g.log.each {|l| puts l.sha }
-    g.gblob('v2.5:Makefile').log.since('2 weeks ago')
-    g.object('HEAD^').to_s  # git show / git rev-parse
-    g.object('HEAD^').contents
-    g.object('v2.5:Makefile').size
-    g.object('v2.5:Makefile').sha
-    g.gtree(treeish)
-    g.gblob(treeish)
-    g.gcommit(treeish)
-    commit = g.gcommit('1cc8667014381')
-    commit.gtree
-    commit.parent.sha
-    commit.parents.size
-    commit.author.name
-    commit.author.email
-    commit.author.date.strftime("%m-%d-%y")
-    commit.committer.name
-    commit.date.strftime("%m-%d-%y")
-    commit.message
-    tree = g.gtree("HEAD^{tree}")
-    tree.blobs
-    tree.subtrees
-    tree.children # blobs and subtrees
-    g.revparse('v2.5:Makefile')
-    g.branches # returns Git::Branch objects
-    g.branches.local
-    g.branches.remote
-    g.branches[:master].gcommit
-    g.branches['origin/master'].gcommit
-    g.grep('hello')  # implies HEAD
-    g.blob('v2.5:Makefile').grep('hello')
-    g.tag('v2.5').grep('hello', 'docs/')
-    g.describe()
-    g.describe('0djf2aa')
-    g.describe('HEAD', {:all => true, :tags => true})
-    g.diff(commit1, commit2).size
-    g.diff(commit1, commit2).stats
-    g.diff(commit1, commit2).name_status
-    g.gtree('v2.5').diff('v2.6').insertions
-    g.diff('gitsearch1', 'v2.5').path('lib/')
-    g.diff('gitsearch1', @git.gtree('v2.5'))
-    g.diff('gitsearch1', 'v2.5').path('docs/').patch
-    g.gtree('v2.5').diff('v2.6').patch
-    g.gtree('v2.5').diff('v2.6').each do |file_diff|
-       puts file_diff.path
-       puts file_diff.patch
-       puts file_diff.blob(:src).contents
-    end
-    g.config('user.name')  # returns 'Scott Chacon'
-    g.config # returns whole config hash
-    g.tags # returns array of Git::Tag objects
-    g.show()
-    g.show('HEAD')
-    g.show('v2.8', 'README.md')
-    Git.ls_remote('https://github.com/schacon/ruby-git.git') # returns a hash containing the available references of the repo.
-    Git.ls_remote('/path/to/local/repo')
-    Git.ls_remote() # same as Git.ls_remote('.')
-```
-And here are the operations that will need to write to your git repository.
-```ruby
-      g = Git.init
-       Git.init('project')
-       Git.init('/home/schacon/proj',
-        { :repository => '/opt/git/proj.git',
-           :index => '/tmp/index'} )
-     g = Git.clone(URI, NAME, :path => '/tmp/checkout')
-     g.config('user.name', 'Scott Chacon')
-     g.config('user.email', 'email@email.com')
-     g.add                                   # git add -- "."
-     g.add(:all=>true)                       # git add --all -- "."
-     g.add('file_path')                      # git add -- "file_path"
-     g.add(['file_path_1', 'file_path_2'])   # git add -- "file_path_1" "file_path_2"
-     g.remove()									# git rm -f -- "."
-     g.remove('file.txt')						# git rm -f -- "file.txt"
-     g.remove(['file.txt', 'file2.txt'])		# git rm -f -- "file.txt" "file2.txt"
-     g.remove('file.txt', :recursive => true) 	# git rm -f -r -- "file.txt"
-     g.remove('file.txt', :cached => true)		# git rm -f --cached -- "file.txt"
-     g.commit('message')
-     g.commit_all('message')
-     g = Git.clone(repo, 'myrepo')
-     g.chdir do
-      new_file('test-file', 'blahblahblah')
-      g.status.changed.each do |file|
-       puts file.blob(:index).contents
-      end
-     end
-     g.reset # defaults to HEAD
-     g.reset_hard(Git::Commit)
-     g.branch('new_branch') # creates new or fetches existing
-     g.branch('new_branch').checkout
-     g.branch('new_branch').delete
-     g.branch('existing_branch').checkout
-     g.checkout('new_branch')
-     g.checkout(g.branch('new_branch'))
-     g.branch(name).merge(branch2)
-     g.branch(branch2).merge  # merges HEAD with branch2
-     g.branch(name).in_branch(message) { # add files }  # auto-commits
-     g.merge('new_branch')
-     g.merge('origin/remote_branch')
-     g.merge(g.branch('master'))
-     g.merge([branch1, branch2])
-     r = g.add_remote(name, uri)  # Git::Remote
-     r = g.add_remote(name, Git::Base)  # Git::Remote
-     g.remotes  # array of Git::Remotes
-     g.remote(name).fetch
-     g.remote(name).remove
-     g.remote(name).merge
-     g.remote(name).merge(branch)
-     g.fetch
-     g.fetch(g.remotes.first)
-     g.pull
-     g.pull(Git::Repo, Git::Branch) # fetch and a merge
-     g.add_tag('tag_name') # returns Git::Tag
-     g.add_tag('tag_name', 'object_reference')
-     g.add_tag('tag_name', 'object_reference', {:options => 'here'})
-     g.add_tag('tag_name', {:options => 'here'})
-     Options:
-       :a | :annotate
-       :d
-       :f
-       :m | :message
-       :s
-     g.delete_tag('tag_name')
-     g.repack
-     g.push
-     g.push(g.remote('name'))
-```
-Some examples of more low-level index and tree operations
-```ruby
-     g.with_temp_index do
-       g.read_tree(tree3) # calls self.index.read_tree
-       g.read_tree(tree1, :prefix => 'hi/')
-       c = g.commit_tree('message')
-       # or #
-       t = g.write_tree
-       c = g.commit_tree(t, :message => 'message', :parents => [sha1, sha2])
-       g.branch('branch_name').update_ref(c)
-       g.update_ref(branch, c)
-       g.with_temp_working do # new blank working directory
-         g.checkout
-         g.checkout(another_index)
-         g.commit # commits to temp_index
-       end
-     end
-     g.set_index('/path/to/index')
-     g.with_index(path) do
-       # calls set_index, then switches back after
-     end
-     g.with_working(dir) do
-     # calls set_working, then switches back after
-     end
-     g.with_temp_working(dir) do
-       g.checkout_index(:prefix => dir, :path_limiter => path)
-       # do file work
-       g.commit # commits to index
-     end
-```
-## License
-licensed under MIT License Copyright (c) 2008  Scott Chacon. See LICENSE for further details.

data/vendor/cache/ruby/2.2.0/gems/git-1.3.0/VERSION DELETED

	@@ -1,2 +0,0 @@
1	- 1.3.0
2	-

data/vendor/cache/ruby/2.2.0/gems/git-1.3.0/lib/git.rb DELETED

@@ -1,166 +0,0 @@
-# Add the directory containing this file to the start of the load path if it
-# isn't there already.
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
-require 'git/author'
-require 'git/base'
-require 'git/branch'
-require 'git/branches'
-require 'git/config'
-require 'git/diff'
-require 'git/index'
-require 'git/lib'
-require 'git/log'
-require 'git/object'
-require 'git/path'
-require 'git/remote'
-require 'git/repository'
-require 'git/status'
-require 'git/stash'
-require 'git/stashes'
-require 'git/working_directory'
-lib = Git::Lib.new(nil, nil)
-unless lib.meets_required_version?
-  $stderr.puts "[WARNING] The git gem requires git #{lib.required_command_version.join('.')} or later, but only found #{lib.current_command_version.join('.')}. You should probably upgrade."
-end
-# Git/Ruby Library
-#
-# This provides bindings for working with git in complex
-# interactions, including branching and merging, object
-# inspection and manipulation, history, patch generation
-# and more.  You should be able to do most fundamental git
-# operations with this library.
-#
-# This module provides the basic functions to open a git
-# reference to work with. You can open a working directory,
-# open a bare repository, initialize a new repo or clone an
-# existing remote repository.
-#
-# Author::    Scott Chacon (mailto:schacon@gmail.com)
-# License::   MIT License
-module Git
-  #g.config('user.name', 'Scott Chacon') # sets value
-  #g.config('user.email', 'email@email.com')  # sets value
-  #g.config('user.name')  # returns 'Scott Chacon'
-  #g.config # returns whole config hash
-  def config(name = nil, value = nil)
-    lib = Git::Lib.new
-    if(name && value)
-      # set value
-      lib.config_set(name, value)
-    elsif (name)
-      # return value
-      lib.config_get(name)
-    else
-      # return hash
-      lib.config_list
-    end
-  end
-  def self.configure
-    yield Base.config
-  end
-  def self.config
-    return Base.config
-  end
-  def global_config(name = nil, value = nil)
-    self.class.global_config(name, value)
-  end
-  # open a bare repository
-  #
-  # this takes the path to a bare git repo
-  # it expects not to be able to use a working directory
-  # so you can't checkout stuff, commit things, etc.
-  # but you can do most read operations
-  def self.bare(git_dir, options = {})
-    Base.bare(git_dir, options)
-  end
-  # clones a remote repository
-  #
-  # options
-  #   :bare => true (does a bare clone)
-  #   :repository => '/path/to/alt_git_dir'
-  #   :index => '/path/to/alt_index_file'
-  #
-  # example
-  #  Git.clone('git://repo.or.cz/rubygit.git', 'clone.git', :bare => true)
-  #
-  def self.clone(repository, name, options = {})
-    Base.clone(repository, name, options)
-  end
-  # Export the current HEAD (or a branch, if <tt>options[:branch]</tt>
-  # is specified) into the +name+ directory, then remove all traces of git from the
-  # directory.
-  #
-  # See +clone+ for options.  Does not obey the <tt>:remote</tt> option,
-  # since the .git info will be deleted anyway; always uses the default
-  # remote, 'origin.'
-  def self.export(repository, name, options = {})
-    options.delete(:remote)
-    repo = clone(repository, name, {:depth => 1}.merge(options))
-    repo.checkout("origin/#{options[:branch]}") if options[:branch]
-    Dir.chdir(repo.dir.to_s) { FileUtils.rm_r '.git' }
-  end
-  # Same as g.config, but forces it to be at the global level
-  #
-  #g.config('user.name', 'Scott Chacon') # sets value
-  #g.config('user.email', 'email@email.com')  # sets value
-  #g.config('user.name')  # returns 'Scott Chacon'
-  #g.config # returns whole config hash
-  def self.global_config(name = nil, value = nil)
-    lib = Git::Lib.new(nil, nil)
-    if(name && value)
-      # set value
-      lib.global_config_set(name, value)
-    elsif (name)
-      # return value
-      lib.global_config_get(name)
-    else
-      # return hash
-      lib.global_config_list
-    end
-  end
-  # initialize a new git repository, defaults to the current working directory
-  #
-  # options
-  #   :repository => '/path/to/alt_git_dir'
-  #   :index => '/path/to/alt_index_file'
-  def self.init(working_dir = '.', options = {})
-    Base.init(working_dir, options)
-  end
-  # returns a Hash containing information about the references
-  # of the target repository
-  #
-  # @param [String|NilClass] location the target repository location or nil for '.'
-  # @return [{String=>Hash}] the available references of the target repo.
-  def self.ls_remote(location=nil)
-    Git::Lib.new.ls_remote(location)
-  end
-  # open an existing git working directory
-  #
-  # this will most likely be the most common way to create
-  # a git reference, referring to a working directory.
-  # if not provided in the options, the library will assume
-  # your git_dir and index are in the default place (.git/, .git/index)
-  #
-  # options
-  #   :repository => '/path/to/alt_git_dir'
-  #   :index => '/path/to/alt_index_file'
-  def self.open(working_dir, options = {})
-    Base.open(working_dir, options)
-  end
-end