cvss-suite 1.0.8 → 1.1.0

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

@@ -1,75 +0,0 @@
-module Git
-
-  class Base
-
-    module Factory
-      
-      # returns a Git::Branch object for branch_name
-      def branch(branch_name = 'master')
-        Git::Branch.new(self, branch_name)
-      end
-
-      # returns a Git::Branches object of all the Git::Branch 
-      # objects for this repo
-      def branches
-        Git::Branches.new(self)
-      end
-      
-      def commit_tree(tree = nil, opts = {})
-        Git::Object::Commit.new(self, self.lib.commit_tree(tree, opts))
-      end
-
-      # returns a Git::Diff object
-      def diff(objectish = 'HEAD', obj2 = nil)
-        Git::Diff.new(self, objectish, obj2)
-      end
-      
-      def gblob(objectish)
-        Git::Object.new(self, objectish, 'blob')
-      end
-      
-      def gcommit(objectish)
-        Git::Object.new(self, objectish, 'commit')
-      end
-
-      def gtree(objectish)
-        Git::Object.new(self, objectish, 'tree')
-      end
-      
-      # returns a Git::Log object with count commits
-      def log(count = 30)
-        Git::Log.new(self, count)
-      end
-      
-      # returns a Git::Object of the appropriate type
-      # you can also call @git.gtree('tree'), but that's 
-      # just for readability.  If you call @git.gtree('HEAD') it will
-      # still return a Git::Object::Commit object.  
-      #
-      # @git.object calls a factory method that will run a rev-parse 
-      # on the objectish and determine the type of the object and return 
-      # an appropriate object for that type 
-      def object(objectish)
-        Git::Object.new(self, objectish)
-      end
-  
-      # returns a Git::Remote object
-      def remote(remote_name = 'origin')
-        Git::Remote.new(self, remote_name)
-      end
-
-      # returns a Git::Status object
-      def status
-        Git::Status.new(self)
-      end
-    
-      # returns a Git::Tag object
-      def tag(tag_name)
-        Git::Object.new(self, tag_name, 'tag', true)
-      end
-
-    end
-
-  end
-
-end

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

@@ -1,122 +0,0 @@
-require 'git/path'
-
-module Git
-
-  class Branch < Path
-    
-    attr_accessor :full, :remote, :name
-    
-    def initialize(base, name)
-      @full = name
-      @base = base
-      @gcommit = nil
-      @stashes = nil
-      @remote, @name = parse_name(name)
-    end
-    
-    def gcommit
-      @gcommit ||= @base.gcommit(@full)
-      @gcommit
-    end
-    
-    def stashes
-      @stashes ||= Git::Stashes.new(@base)
-    end
-    
-    def checkout
-      check_if_create
-      @base.checkout(@full)
-    end
-    
-    def archive(file, opts = {})
-      @base.lib.archive(@full, file, opts)
-    end
-    
-    # g.branch('new_branch').in_branch do
-    #   # create new file
-    #   # do other stuff
-    #   return true # auto commits and switches back
-    # end
-    def in_branch (message = 'in branch work')
-      old_current = @base.lib.branch_current
-      checkout
-      if yield
-        @base.commit_all(message)
-      else
-        @base.reset_hard
-      end
-      @base.checkout(old_current)
-    end
-    
-    def create
-      check_if_create
-    end
-    
-    def delete
-      @base.lib.branch_delete(@name)
-    end
-    
-    def current
-      determine_current
-    end
-    
-    def merge(branch = nil, message = nil)
-      if branch
-        in_branch do 
-          @base.merge(branch, message)
-          false
-        end
-        # merge a branch into this one
-      else
-        # merge this branch into the current one
-        @base.merge(@name)
-      end
-    end
-    
-    def update_ref(commit)
-      @base.lib.update_ref(@full, commit)
-    end
-    
-    def to_a
-      [@full]
-    end
-    
-    def to_s
-      @full
-    end
-    
-    private 
-
-      def check_if_create
-        @base.lib.branch_new(@name) rescue nil
-      end
-      
-      def determine_current
-        @base.lib.branch_current == @name
-      end
-    
-      # Given a full branch name return an Array containing the remote and branch names.
-      #
-      # Removes 'remotes' from the beggining of the name (if present).
-      # Takes the second part (splittign by '/') as the remote name.
-      # Takes the rest as the repo name (can also hold one or more '/').
-      #
-      # Example:
-      #   parse_name('master') #=> [nil, 'master']
-      #   parse_name('origin/master') #=> ['origin', 'master']
-      #   parse_name('remotes/origin/master') #=> ['origin', 'master']
-      #   parse_name('origin/master/v2') #=> ['origin', 'master/v2'] 
-      #
-      # param [String] name branch full name.
-      # return [<Git::Remote,NilClass,String>] an Array containing the remote and branch names. 
-      def parse_name(name)
-        if name.match(/^(?:remotes)?\/([^\/]+)\/(.+)/)
-          return [Git::Remote.new(@base, $1), $2]
-        end
-
-        return [nil, name]
-      end
-    
-  end
-  
-end

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

@@ -1,71 +0,0 @@
-module Git
-  
-  # object that holds all the available branches
-  class Branches
-
-    include Enumerable
-    
-    def initialize(base)
-      @branches = {}
-      
-      @base = base
-            
-      @base.lib.branches_all.each do |b|
-        @branches[b[0]] = Git::Branch.new(@base, b[0])
-      end
-    end
-
-    def local
-      self.select { |b| !b.remote }
-    end
-    
-    def remote
-      self.select { |b| b.remote }
-    end
-    
-    # array like methods
-
-    def size
-      @branches.size
-    end    
-    
-    def each(&block)
-      @branches.values.each(&block)
-    end
-    
-    # Returns the target branch
-    #
-    # Example:
-    #   Given (git branch -a):
-    #    master
-    #    remotes/working/master
-    #
-    #   g.branches['master'].full #=> 'master'
-    #   g.branches['working/master'].full => 'remotes/working/master'
-    #   g.branches['remotes/working/master'].full => 'remotes/working/master'
-    #
-    # @param [#to_s] branch_name the target branch name.
-    # @return [Git::Branch] the target branch.
-    def [](branch_name)
-      @branches.values.inject(@branches) do |branches, branch|
-        branches[branch.full] ||= branch
-
-        # This is how Git (version 1.7.9.5) works. 
-        # Lets you ignore the 'remotes' if its at the beginning of the branch full name (even if is not a real remote branch). 
-        branches[branch.full.sub('remotes/', '')] ||= branch if branch.full =~ /^remotes\/.+/
-        
-        branches
-      end[branch_name.to_s]
-    end
-    
-    def to_s
-      out = ''
-      @branches.each do |k, b|
-        out << (b.current ? '* ' : '  ') << b.to_s << "\n"
-      end
-      out
-    end
-    
-  end
-
-end

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

@@ -1,22 +0,0 @@
-module Git
-
-  class Config
-
-    attr_writer :binary_path, :git_ssh
-
-    def initialize
-      @binary_path = nil
-      @git_ssh = nil
-    end
-
-    def binary_path
-      @binary_path || 'git'
-    end
-
-    def git_ssh
-      @git_ssh || ENV['GIT_SSH']
-    end
-
-  end
-
-end

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

@@ -1,158 +0,0 @@
-module Git
-
-  # object that holds the last X commits on given branch
-  class Diff
-    include Enumerable
-
-    def initialize(base, from = nil, to = nil)
-      @base = base
-      @from = from && from.to_s
-      @to = to && to.to_s
-
-      @path = nil
-      @full_diff = nil
-      @full_diff_files = nil
-      @stats = nil
-    end
-    attr_reader :from, :to
-
-    def name_status
-      cache_name_status
-    end
-
-    def path(path)
-      @path = path
-      return self
-    end
-
-    def size
-      cache_stats
-      @stats[:total][:files]
-    end
-
-    def lines
-      cache_stats
-      @stats[:total][:lines]
-    end
-
-    def deletions
-      cache_stats
-      @stats[:total][:deletions]
-    end
-
-    def insertions
-      cache_stats
-      @stats[:total][:insertions]
-    end
-
-    def stats
-      cache_stats
-      @stats
-    end
-
-    # if file is provided and is writable, it will write the patch into the file
-    def patch(file = nil)
-      cache_full
-      @full_diff
-    end
-    alias_method :to_s, :patch
-
-    # enumerable methods
-
-    def [](key)
-      process_full
-      @full_diff_files.assoc(key)[1]
-    end
-
-    def each(&block) # :yields: each Git::DiffFile in turn
-      process_full
-      @full_diff_files.map { |file| file[1] }.each(&block)
-    end
-
-    class DiffFile
-      attr_accessor :patch, :path, :mode, :src, :dst, :type
-      @base = nil
-
-      def initialize(base, hash)
-        @base = base
-        @patch = hash[:patch]
-        @path = hash[:path]
-        @mode = hash[:mode]
-        @src = hash[:src]
-        @dst = hash[:dst]
-        @type = hash[:type]
-        @binary = hash[:binary]
-      end
-
-      def binary?
-        !!@binary
-      end
-
-      def blob(type = :dst)
-        if type == :src
-          @base.object(@src) if @src != '0000000'
-        else
-          @base.object(@dst) if @dst != '0000000'
-        end
-      end
-    end
-
-    private
-
-      def cache_full
-        @full_diff ||= @base.lib.diff_full(@from, @to, {:path_limiter => @path})
-      end
-
-      def process_full
-        return if @full_diff_files
-        cache_full
-        @full_diff_files = process_full_diff
-      end
-
-      def cache_stats
-        @stats ||=  @base.lib.diff_stats(@from, @to, {:path_limiter => @path})
-      end
-
-      def cache_name_status
-        @name_status ||= @base.lib.diff_name_status(@from, @to, {:path => @path})
-      end
-
-      # break up @diff_full
-      def process_full_diff
-        defaults = {
-          :mode => '',
-          :src => '',
-          :dst => '',
-          :type => 'modified'
-        }
-        final = {}
-        current_file = nil
-        full_diff_utf8_encoded = @full_diff.encode("UTF-8", "binary", {
-			:invalid => :replace,
-			:undef => :replace
-		})
-        full_diff_utf8_encoded.split("\n").each do |line|
-          if m = /^diff --git a\/(.*?) b\/(.*?)/.match(line)
-            current_file = m[1]
-            final[current_file] = defaults.merge({:patch => line, :path => current_file})
-          else
-            if m = /^index (.......)\.\.(.......)( ......)*/.match(line)
-              final[current_file][:src] = m[1]
-              final[current_file][:dst] = m[2]
-              final[current_file][:mode] = m[3].strip if m[3]
-            end
-            if m = /^([[:alpha:]]*?) file mode (......)/.match(line)
-              final[current_file][:type] = m[1]
-              final[current_file][:mode] = m[2]
-            end
-            if m = /^Binary files /.match(line)
-              final[current_file][:binary] = true
-            end
-            final[current_file][:patch] << "\n" + line
-          end
-        end
-        final.map { |e| [e[0], DiffFile.new(@base, e[1])] }
-      end
-
-  end
-end