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/diff-lcs-1.2.5/lib/diff/lcs/htmldiff.rb DELETED

@@ -1,149 +0,0 @@
-# -*- ruby encoding: utf-8 -*-
-require 'cgi'
-class Diff::LCS::HTMLDiff
-  class << self
-    attr_accessor :can_expand_tabs #:nodoc:
-  end
-  self.can_expand_tabs = true
-  class Callbacks
-    attr_accessor :output
-    attr_accessor :match_class
-    attr_accessor :only_a_class
-    attr_accessor :only_b_class
-    def initialize(output, options = {})
-      @output = output
-      options ||= {}
-      @match_class = options[:match_class] || "match"
-      @only_a_class = options[:only_a_class] || "only_a"
-      @only_b_class = options[:only_b_class] || "only_b"
-    end
-    def htmlize(element, css_class)
-      element = "&nbsp;" if element.empty?
-      %Q|<pre class="#{__send__(css_class)}">#{element}</pre>\n|
-    end
-    private :htmlize
-    # This will be called with both lines are the same
-    def match(event)
-      @output << htmlize(event.old_element, :match_class)
-    end
-    # This will be called when there is a line in A that isn't in B
-    def discard_a(event)
-      @output << htmlize(event.old_element, :only_a_class)
-    end
-    # This will be called when there is a line in B that isn't in A
-    def discard_b(event)
-      @output << htmlize(event.new_element, :only_b_class)
-    end
-  end
-  DEFAULT_OPTIONS = {
-    :expand_tabs => nil,
-    :output => nil,
-    :css => nil,
-    :title => nil,
-  }
-  DEFAULT_CSS = <<-CSS
-body { margin: 0; }
-.diff
-{
-  border: 1px solid black;
-  margin: 1em 2em;
-}
-p
-{
-  margin-left: 2em;
-}
-pre
-{
-  padding-left: 1em;
-  margin: 0;
-  font-family: Inconsolata, Consolas, Lucida, Courier, monospaced;
-	white-space: pre;
-}
-.match { }
-.only_a
-{
-  background-color: #fdd;
-  color: red;
-  text-decoration: line-through;
-}
-.only_b
-{
-  background-color: #ddf;
-  color: blue;
-  border-left: 3px solid blue
-}
-h1 { margin-left: 2em; }
-  CSS
-  def initialize(left, right, options = nil)
-    @left     = left
-    @right    = right
-    @options  = options
-    @options = DEFAULT_OPTIONS.dup if @options.nil?
-  end
-  def verify_options
-    @options[:expand_tabs] ||= 4
-    @options[:expand_tabs] = 4 if @options[:expand_tabs] < 0
-    @options[:output] ||= $stdout
-    @options[:css] ||= DEFAULT_CSS.dup
-    @options[:title] ||= "diff"
-  end
-  private :verify_options
-  attr_reader :options
-  def run
-    verify_options
-    if @options[:expand_tabs] > 0 && self.class.can_expand_tabs
-      formatter = Text::Format.new
-      formatter.tabstop = @options[:expand_tabs]
-      @left = left.map { |line| formatter.expand(line.chomp) }
-      @right = right.map { |line| formatter.expand(line.chomp) }
-    end
-    @left.map! { |line| CGI.escapeHTML(line.chomp) }
-    @right.map! { |line| CGI.escapeHTML(line.chomp) }
-    @options[:output] << <<-OUTPUT
-<html>
-  <head>
-    <title>#{@options[:title]}</title>
-    <style type="text/css">
-    #{@options[:css]}
-    </style>
-  </head>
-  <body>
-    <h1>#{@options[:title]}</h1>
-    <p>Legend: <span class="only_a">Only in Old</span>&nbsp;
-    <span class="only_b">Only in New</span></p>
-    <div class="diff">
-    OUTPUT
-    callbacks = Callbacks.new(@options[:output])
-    Diff::LCS.traverse_sequences(@left, @right, callbacks)
-    @options[:output] << <<-OUTPUT
-    </div>
-  </body>
-</html>
-    OUTPUT
-  end
-end

data/vendor/cache/ruby/2.2.0/gems/diff-lcs-1.2.5/lib/diff/lcs/hunk.rb DELETED

@@ -1,276 +0,0 @@
-# -*- ruby encoding: utf-8 -*-
-require 'diff/lcs/block'
-# A Hunk is a group of Blocks which overlap because of the context
-# surrounding each block. (So if we're not using context, every hunk will
-# contain one block.) Used in the diff program (bin/diff).
-class Diff::LCS::Hunk
-  # Create a hunk using references to both the old and new data, as well as
-  # the piece of data.
-  def initialize(data_old, data_new, piece, flag_context, file_length_difference)
-    # At first, a hunk will have just one Block in it
-    @blocks = [ Diff::LCS::Block.new(piece) ]
-    if String.method_defined?(:encoding)
-      @preferred_data_encoding = data_old.fetch(0, data_new.fetch(0,'') ).encoding
-    end
-    @data_old = data_old
-    @data_new = data_new
-    before = after = file_length_difference
-    after += @blocks[0].diff_size
-    @file_length_difference = after # The caller must get this manually
-    # Save the start & end of each array. If the array doesn't exist (e.g.,
-    # we're only adding items in this block), then figure out the line
-    # number based on the line number of the other file and the current
-    # difference in file lengths.
-    if @blocks[0].remove.empty?
-      a1 = a2 = nil
-    else
-      a1 = @blocks[0].remove[0].position
-      a2 = @blocks[0].remove[-1].position
-    end
-    if @blocks[0].insert.empty?
-      b1 = b2 = nil
-    else
-      b1 = @blocks[0].insert[0].position
-      b2 = @blocks[0].insert[-1].position
-    end
-    @start_old = a1 || (b1 - before)
-    @start_new = b1 || (a1 + before)
-    @end_old   = a2 || (b2 - after)
-    @end_new   = b2 || (a2 + after)
-    self.flag_context = flag_context
-  end
-  attr_reader :blocks
-  attr_reader :start_old, :start_new
-  attr_reader :end_old, :end_new
-  attr_reader :file_length_difference
-  # Change the "start" and "end" fields to note that context should be added
-  # to this hunk.
-  attr_accessor :flag_context
-  undef :flag_context=;
-  def flag_context=(context) #:nodoc:
-    return if context.nil? or context.zero?
-    add_start = (context > @start_old) ? @start_old : context
-    @start_old -= add_start
-    @start_new -= add_start
-    if (@end_old + context) > @data_old.size
-      add_end = @data_old.size - @end_old
-    else
-      add_end = context
-    end
-    @end_old += add_end
-    @end_new += add_end
-  end
-  # Merges this hunk and the provided hunk together if they overlap. Returns
-  # a truthy value so that if there is no overlap, you can know the merge
-  # was skipped.
-  def merge(hunk)
-    if overlaps?(hunk)
-      @start_old = hunk.start_old
-      @start_new = hunk.start_new
-      blocks.unshift(*hunk.blocks)
-    else
-      nil
-    end
-  end
-  alias_method :unshift, :merge
-  # Determines whether there is an overlap between this hunk and the
-  # provided hunk. This will be true if the difference between the two hunks
-  # start or end positions is within one position of each other.
-  def overlaps?(hunk)
-    hunk and (((@start_old - hunk.end_old) <= 1) or
-              ((@start_new - hunk.end_new) <= 1))
-  end
-  # Returns a diff string based on a format.
-  def diff(format)
-    case format
-    when :old
-      old_diff
-    when :unified
-      unified_diff
-    when :context
-      context_diff
-    when :ed
-      self
-    when :reverse_ed, :ed_finish
-      ed_diff(format)
-    else
-      raise "Unknown diff format #{format}."
-    end
-  end
-  # Note that an old diff can't have any context. Therefore, we know that
-  # there's only one block in the hunk.
-  def old_diff
-    warn "Expecting only one block in an old diff hunk!" if @blocks.size > 1
-    op_act = { "+" => 'a', "-" => 'd', "!" => "c" }
-    block = @blocks[0]
-    # Calculate item number range. Old diff range is just like a context
-    # diff range, except the ranges are on one line with the action between
-    # them.
-    s = encode("#{context_range(:old)}#{op_act[block.op]}#{context_range(:new)}\n")
-    # If removing anything, just print out all the remove lines in the hunk
-    # which is just all the remove lines in the block.
-    @data_old[@start_old .. @end_old].each { |e| s << encode("< ") + e + encode("\n") } unless block.remove.empty?
-    s << encode("---\n") if block.op == "!"
-    @data_new[@start_new .. @end_new].each { |e| s << encode("> ") + e + encode("\n") } unless block.insert.empty?
-    s
-  end
-  private :old_diff
-  def unified_diff
-    # Calculate item number range.
-    s = encode("@@ -#{unified_range(:old)} +#{unified_range(:new)} @@\n")
-    # Outlist starts containing the hunk of the old file. Removing an item
-    # just means putting a '-' in front of it. Inserting an item requires
-    # getting it from the new file and splicing it in. We splice in
-    # +num_added+ items. Remove blocks use +num_added+ because splicing
-    # changed the length of outlist.
-    #
-    # We remove +num_removed+ items. Insert blocks use +num_removed+
-    # because their item numbers -- corresponding to positions in the NEW
-    # file -- don't take removed items into account.
-    lo, hi, num_added, num_removed = @start_old, @end_old, 0, 0
-    outlist = @data_old[lo .. hi].map { |e| e.insert(0, encode(' ')) }
-    @blocks.each do |block|
-      block.remove.each do |item|
-        op     = item.action.to_s # -
-        offset = item.position - lo + num_added
-        outlist[offset][0, 1] = encode(op)
-        num_removed += 1
-      end
-      block.insert.each do |item|
-        op     = item.action.to_s # +
-        offset = item.position - @start_new + num_removed
-        outlist[offset, 0] = encode(op) + @data_new[item.position]
-        num_added += 1
-      end
-    end
-    s << outlist.join(encode("\n"))
-  end
-  private :unified_diff
-  def context_diff
-    s = encode("***************\n")
-    s << encode("*** #{context_range(:old)} ****\n")
-    r = context_range(:new)
-    # Print out file 1 part for each block in context diff format if there
-    # are any blocks that remove items
-    lo, hi = @start_old, @end_old
-    removes = @blocks.select { |e| not e.remove.empty? }
-    if removes
-      outlist = @data_old[lo .. hi].map { |e| e.insert(0, encode(' ')) }
-      removes.each do |block|
-        block.remove.each do |item|
-          outlist[item.position - lo][0, 1] = encode(block.op) # - or !
-        end
-      end
-      s << outlist.join("\n")
-    end
-    s << encode("\n--- #{r} ----\n")
-    lo, hi = @start_new, @end_new
-    inserts = @blocks.select { |e| not e.insert.empty? }
-    if inserts
-      outlist = @data_new[lo .. hi].collect { |e| e.insert(0, encode(' ')) }
-      inserts.each do |block|
-        block.insert.each do |item|
-          outlist[item.position - lo][0, 1] = encode(block.op) # + or !
-        end
-      end
-      s << outlist.join("\n")
-    end
-    s
-  end
-  private :context_diff
-  def ed_diff(format)
-    op_act = { "+" => 'a', "-" => 'd', "!" => "c" }
-    warn "Expecting only one block in an old diff hunk!" if @blocks.size > 1
-    if format == :reverse_ed
-      s = encode("#{op_act[@blocks[0].op]}#{context_range(:old)}\n")
-    else
-      s = encode("#{context_range(:old, ' ')}#{op_act[@blocks[0].op]}\n")
-    end
-    unless @blocks[0].insert.empty?
-      @data_new[@start_new .. @end_new].each { |e| s << e + encode("\n") }
-      s << encode(".\n")
-    end
-    s
-  end
-  private :ed_diff
-  # Generate a range of item numbers to print. Only print 1 number if the
-  # range has only one item in it. Otherwise, it's 'start,end'
-  def context_range(mode, op = ',')
-    case mode
-    when :old
-      s, e = (@start_old + 1), (@end_old + 1)
-    when :new
-      s, e = (@start_new + 1), (@end_new + 1)
-    end
-    (s < e) ? "#{s}#{op}#{e}" : "#{e}"
-  end
-  private :context_range
-  # Generate a range of item numbers to print for unified diff. Print number
-  # where block starts, followed by number of lines in the block
-  # (don't print number of lines if it's 1)
-  def unified_range(mode)
-    case mode
-    when :old
-      s, e = (@start_old + 1), (@end_old + 1)
-    when :new
-      s, e = (@start_new + 1), (@end_new + 1)
-    end
-    length = e - s + 1
-    first = (length < 2) ? e : s # "strange, but correct"
-    (length == 1) ? "#{first}" : "#{first},#{length}"
-  end
-  private :unified_range
-  if String.method_defined?(:encoding)
-    def encode(literal, target_encoding = @preferred_data_encoding)
-      literal.encode target_encoding
-    end
-    def encode_as(string, *args)
-      args.map { |arg| arg.encode(string.encoding) }
-    end
-  else
-    def encode(literal, target_encoding = nil)
-      literal
-    end
-    def encode_as(string, *args)
-      args
-    end
-  end
-  private :encode
-  private :encode_as
-end

data/vendor/cache/ruby/2.2.0/gems/diff-lcs-1.2.5/lib/diff/lcs/internals.rb DELETED

@@ -1,301 +0,0 @@
-# -*- ruby encoding: utf-8 -*-
-class << Diff::LCS
-  def diff_traversal(method, seq1, seq2, callbacks, &block)
-    callbacks = callbacks_for(callbacks)
-    case method
-    when :diff
-      traverse_sequences(seq1, seq2, callbacks)
-    when :sdiff
-      traverse_balanced(seq1, seq2, callbacks)
-    end
-    callbacks.finish if callbacks.respond_to? :finish
-    if block
-      callbacks.diffs.map do |hunk|
-        if hunk.kind_of? Array
-          hunk.map { |hunk_block| block[hunk_block] }
-        else
-          block[hunk]
-        end
-      end
-    else
-      callbacks.diffs
-    end
-  end
-  private :diff_traversal
-end
-module Diff::LCS::Internals # :nodoc:
-end
-class << Diff::LCS::Internals
-  # Compute the longest common subsequence between the sequenced
-  # Enumerables +a+ and +b+. The result is an array whose contents is such
-  # that
-  #
-  #     result = Diff::LCS::Internals.lcs(a, b)
-  #     result.each_with_index do |e, i|
-  #       assert_equal(a[i], b[e]) unless e.nil?
-  #     end
-  def lcs(a, b)
-    a_start = b_start = 0
-    a_finish = a.size - 1
-    b_finish = b.size - 1
-    vector = []
-    # Prune off any common elements at the beginning...
-    while ((a_start <= a_finish) and (b_start <= b_finish) and
-           (a[a_start] == b[b_start]))
-      vector[a_start] = b_start
-      a_start += 1
-      b_start += 1
-    end
-    b_start = a_start
-    # Now the end...
-    while ((a_start <= a_finish) and (b_start <= b_finish) and
-           (a[a_finish] == b[b_finish]))
-      vector[a_finish] = b_finish
-      a_finish -= 1
-      b_finish -= 1
-    end
-    # Now, compute the equivalence classes of positions of elements.
-    b_matches = position_hash(b, b_start..b_finish)
-    thresh = []
-    links  = []
-    string = a.kind_of?(String)
-    (a_start .. a_finish).each do |i|
-      ai = string ? a[i, 1] : a[i]
-      bm = b_matches[ai]
-      k = nil
-      bm.reverse_each do |j|
-        if k and (thresh[k] > j) and (thresh[k - 1] < j)
-          thresh[k] = j
-        else
-          k = replace_next_larger(thresh, j, k)
-        end
-        links[k] = [ (k > 0) ? links[k - 1] : nil, i, j ] unless k.nil?
-      end
-    end
-    unless thresh.empty?
-      link = links[thresh.size - 1]
-      while not link.nil?
-        vector[link[1]] = link[2]
-        link = link[0]
-      end
-    end
-    vector
-  end
-  # This method will analyze the provided patchset to provide a
-  # single-pass normalization (conversion of the array form of
-  # Diff::LCS::Change objects to the object form of same) and detection of
-  # whether the patchset represents changes to be made.
-  def analyze_patchset(patchset, depth = 0)
-    raise "Patchset too complex" if depth > 1
-    has_changes = false
-    # Format:
-    # [ # patchset
-    #   # hunk (change)
-    #   [ # hunk
-    #     # change
-    #   ]
-    # ]
-    patchset = patchset.map do |hunk|
-      case hunk
-      when Diff::LCS::Change
-        has_changes ||= !hunk.unchanged?
-        hunk
-      when Array
-        # Detect if the 'hunk' is actually an array-format
-        # Change object.
-        if Diff::LCS::Change.valid_action? hunk[0]
-          hunk = Diff::LCS::Change.from_a(hunk)
-          has_changes ||= !hunk.unchanged?
-          hunk
-        else
-          with_changes, hunk = analyze_patchset(hunk, depth + 1)
-          has_changes ||= with_changes
-          hunk.flatten
-        end
-      else
-        raise ArgumentError, "Cannot normalise a hunk of class #{hunk.class}."
-      end
-    end
-    [ has_changes, patchset.flatten(1) ]
-  end
-  # Examine the patchset and the source to see in which direction the
-  # patch should be applied.
-  #
-  # WARNING: By default, this examines the whole patch, so this could take
-  # some time. This also works better with Diff::LCS::ContextChange or
-  # Diff::LCS::Change as its source, as an array will cause the creation
-  # of one of the above.
-  #
-  # Note: This will be deprecated as a public function in a future release.
-  def intuit_diff_direction(src, patchset, limit = nil)
-    string = src.kind_of?(String)
-    count = left_match = left_miss = right_match = right_miss = 0
-    patchset.each do |change|
-      count += 1
-      case change
-      when Diff::LCS::ContextChange
-        le = string ? src[change.old_position, 1] : src[change.old_position]
-        re = string ? src[change.new_position, 1] : src[change.new_position]
-        case change.action
-        when '-' # Remove details from the old string
-          if le == change.old_element
-            left_match += 1
-          else
-            left_miss += 1
-          end
-        when '+'
-          if re == change.new_element
-            right_match += 1
-          else
-            right_miss += 1
-          end
-        when '='
-          left_miss += 1 if le != change.old_element
-          right_miss += 1 if re != change.new_element
-        when '!'
-          if le == change.old_element
-            left_match += 1
-          else
-            if re == change.new_element
-              right_match += 1
-            else
-              left_miss += 1
-              right_miss += 1
-            end
-          end
-        end
-      when Diff::LCS::Change
-        # With a simplistic change, we can't tell the difference between
-        # the left and right on '!' actions, so we ignore those. On '='
-        # actions, if there's a miss, we miss both left and right.
-        element = string ? src[change.position, 1] : src[change.position]
-        case change.action
-        when '-'
-          if element == change.element
-            left_match += 1
-          else
-            left_miss += 1
-          end
-        when '+'
-          if element == change.element
-            right_match += 1
-          else
-            right_miss += 1
-          end
-        when '='
-          if element != change.element
-            left_miss += 1
-            right_miss += 1
-          end
-        end
-      end
-      break if (not limit.nil?) && (count > limit)
-    end
-    no_left = (left_match == 0) && (left_miss > 0)
-    no_right = (right_match == 0) && (right_miss > 0)
-    case [no_left, no_right]
-    when [false, true]
-      :patch
-    when [true, false]
-      :unpatch
-    else
-      case left_match <=> right_match
-      when 1
-        :patch
-      when -1
-        :unpatch
-      else
-        raise "The provided patchset does not appear to apply to the provided value as either source or destination value."
-      end
-    end
-  end
-  # Find the place at which +value+ would normally be inserted into the
-  # Enumerable. If that place is already occupied by +value+, do nothing
-  # and return +nil+. If the place does not exist (i.e., it is off the end
-  # of the Enumerable), add it to the end. Otherwise, replace the element
-  # at that point with +value+. It is assumed that the Enumerable's values
-  # are numeric.
-  #
-  # This operation preserves the sort order.
-  def replace_next_larger(enum, value, last_index = nil)
-    # Off the end?
-    if enum.empty? or (value > enum[-1])
-      enum << value
-      return enum.size - 1
-    end
-    # Binary search for the insertion point
-    last_index ||= enum.size
-    first_index = 0
-    while (first_index <= last_index)
-      i = (first_index + last_index) >> 1
-      found = enum[i]
-      if value == found
-        return nil
-      elsif value > found
-        first_index = i + 1
-      else
-        last_index = i - 1
-      end
-    end
-    # The insertion point is in first_index; overwrite the next larger
-    # value.
-    enum[first_index] = value
-    return first_index
-  end
-  private :replace_next_larger
-  # If +vector+ maps the matching elements of another collection onto this
-  # Enumerable, compute the inverse of +vector+ that maps this Enumerable
-  # onto the collection. (Currently unused.)
-  def inverse_vector(a, vector)
-    inverse = a.dup
-    (0...vector.size).each do |i|
-      inverse[vector[i]] = i unless vector[i].nil?
-    end
-    inverse
-  end
-  private :inverse_vector
-  # Returns a hash mapping each element of an Enumerable to the set of
-  # positions it occupies in the Enumerable, optionally restricted to the
-  # elements specified in the range of indexes specified by +interval+.
-  def position_hash(enum, interval)
-    string = enum.kind_of?(String)
-    hash = Hash.new { |h, k| h[k] = [] }
-    interval.each do |i|
-      k = string ? enum[i, 1] : enum[i]
-      hash[k] << i
-    end
-    hash
-  end
-  private :position_hash
-end