cloudsmith-api 0.51.22 → 0.52.0

data/vendor/bundle/ruby/2.6.0/gems/{diff-lcs-1.3 → diff-lcs-1.4.4}/lib/diff/lcs/internals.rb

@@ -1,4 +1,4 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 class << Diff::LCS
   def diff_traversal(method, seq1, seq2, callbacks, &block)
@@ -45,8 +45,7 @@ class << Diff::LCS::Internals
     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]))
+    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
@@ -54,8 +53,7 @@ class << Diff::LCS::Internals
     b_start = a_start
 
     # Now the end...
-    while ((a_start <= a_finish) and (b_start <= b_finish) and
-           (a[a_finish] == b[b_finish]))
+    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
@@ -68,7 +66,7 @@ class << Diff::LCS::Internals
     links  = []
     string = a.kind_of?(String)
 
-    (a_start .. a_finish).each do |i|
+    (a_start..a_finish).each do |i|
       ai = string ? a[i, 1] : a[i]
       bm = b_matches[ai]
       k = nil
@@ -78,13 +76,13 @@ class << Diff::LCS::Internals
         else
           k = replace_next_larger(thresh, j, k)
         end
-        links[k] = [ (k > 0) ? links[k - 1] : nil, i, j ] unless k.nil?
+        links[k] = [k.positive? ? links[k - 1] : nil, i, j] unless k.nil?
       end
     end
 
     unless thresh.empty?
       link = links[thresh.size - 1]
-      while not link.nil?
+      until link.nil?
         vector[link[1]] = link[2]
         link = link[0]
       end
@@ -93,14 +91,15 @@ class << Diff::LCS::Internals
     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.
+  # 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
+    fail 'Patchset too complex' if depth > 1
 
     has_changes = false
+    new_patchset = []
 
     # Format:
     # [ # patchset
@@ -110,29 +109,28 @@ class << Diff::LCS::Internals
     #   ]
     # ]
 
-    patchset = patchset.map do |hunk|
+    patchset.each do |hunk|
       case hunk
       when Diff::LCS::Change
         has_changes ||= !hunk.unchanged?
-        hunk
+        new_patchset << hunk
       when Array
-        # Detect if the 'hunk' is actually an array-format
-        # Change object.
+        # 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
+          new_patchset << hunk
         else
           with_changes, hunk = analyze_patchset(hunk, depth + 1)
           has_changes ||= with_changes
-          hunk.flatten
+          new_patchset.concat(hunk)
         end
       else
-        raise ArgumentError, "Cannot normalise a hunk of class #{hunk.class}."
+        fail ArgumentError, "Cannot normalise a hunk of class #{hunk.class}."
       end
     end
 
-    [ has_changes, patchset.flatten(1) ]
+    [has_changes, new_patchset]
   end
 
   # Examine the patchset and the source to see in which direction the
@@ -173,13 +171,11 @@ class << Diff::LCS::Internals
         when '!'
           if le == change.old_element
             left_match += 1
+          elsif re == change.new_element
+            right_match += 1
           else
-            if re == change.new_element
-              right_match += 1
-            else
-              left_miss += 1
-              right_miss += 1
-            end
+            left_miss += 1
+            right_miss += 1
           end
         end
       when Diff::LCS::Change
@@ -209,16 +205,16 @@ class << Diff::LCS::Internals
         end
       end
 
-      break if (not limit.nil?) && (count > limit)
+      break if !limit.nil? && (count > limit)
     end
 
-    no_left = (left_match == 0) && (left_miss > 0)
-    no_right = (right_match == 0) && (right_miss > 0)
+    no_left = left_match.zero? && left_miss.positive?
+    no_right = right_match.zero? && right_miss.positive?
 
-    case [ no_left, no_right ]
-    when [ false, true ]
+    case [no_left, no_right]
+    when [false, true]
       :patch
-    when [ true, false ]
+    when [true, false]
       :unpatch
     else
       case left_match <=> right_match
@@ -235,7 +231,8 @@ class << Diff::LCS::Internals
           :patch
         end
       else
-        raise "The provided patchset does not appear to apply to the provided enumerable as either source or destination value."
+        fail "The provided patchset does not appear to apply to the provided \
+enumerable as either source or destination value."
       end
     end
   end
@@ -258,14 +255,14 @@ class << Diff::LCS::Internals
     # Binary search for the insertion point
     last_index ||= enum.size
     first_index = 0
-    while (first_index <= last_index)
+    while first_index <= last_index
       i = (first_index + last_index) >> 1
 
       found = enum[i]
 
-      if value == found
-        return nil
-      elsif value > found
+      return nil if value == found
+
+      if value > found
         first_index = i + 1
       else
         last_index = i - 1
@@ -275,7 +272,7 @@ class << Diff::LCS::Internals
     # The insertion point is in first_index; overwrite the next larger
     # value.
     enum[first_index] = value
-    return first_index
+    first_index
   end
   private :replace_next_larger
 

data/vendor/bundle/ruby/2.6.0/gems/{diff-lcs-1.3 → diff-lcs-1.4.4}/lib/diff/lcs/ldiff.rb

@@ -1,4 +1,4 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'optparse'
 require 'ostruct'
@@ -7,7 +7,7 @@ require 'diff/lcs/hunk'
 module Diff::LCS::Ldiff #:nodoc:
   BANNER = <<-COPYRIGHT
 ldiff #{Diff::LCS::VERSION}
-  Copyright 2004-2014 Austin Ziegler
+  Copyright 2004-2019 Austin Ziegler
 
   Part of Diff::LCS.
   https://github.com/halostatue/diff-lcs
@@ -15,7 +15,7 @@ ldiff #{Diff::LCS::VERSION}
   This program is free software. It may be redistributed and/or modified under
   the terms of the GPL version 2 (or later), the Perl Artistic licence, or the
   MIT licence.
-COPYRIGHT
+  COPYRIGHT
 end
 
 class << Diff::LCS::Ldiff
@@ -23,33 +23,42 @@ class << Diff::LCS::Ldiff
   attr_reader :file_old, :file_new #:nodoc:
   attr_reader :data_old, :data_new #:nodoc:
 
-  def run(args, input = $stdin, output = $stdout, error = $stderr) #:nodoc:
+  def run(args, _input = $stdin, output = $stdout, error = $stderr) #:nodoc:
     @binary = nil
 
     args.options do |o|
       o.banner = "Usage: #{File.basename($0)} [options] oldfile newfile"
-      o.separator ""
-      o.on('-c', '-C', '--context [LINES]', Numeric, 'Displays a context diff with LINES lines', 'of context. Default 3 lines.') do |ctx|
+      o.separator ''
+      o.on(
+        '-c', '-C', '--context [LINES]', Integer,
+        'Displays a context diff with LINES lines', 'of context. Default 3 lines.'
+      ) do |ctx|
         @format = :context
         @lines  = ctx || 3
       end
-      o.on('-u', '-U', '--unified [LINES]', Numeric, 'Displays a unified diff with LINES lines', 'of context. Default 3 lines.') do |ctx|
+      o.on(
+        '-u', '-U', '--unified [LINES]', Integer,
+        'Displays a unified diff with LINES lines', 'of context. Default 3 lines.'
+      ) do |ctx|
         @format = :unified
         @lines  = ctx || 3
       end
-      o.on('-e', 'Creates an \'ed\' script to change', 'oldfile to newfile.') do |ctx|
+      o.on('-e', 'Creates an \'ed\' script to change', 'oldfile to newfile.') do |_ctx|
         @format = :ed
       end
-      o.on('-f', 'Creates an \'ed\' script to change', 'oldfile to newfile in reverse order.') do |ctx|
+      o.on('-f', 'Creates an \'ed\' script to change', 'oldfile to newfile in reverse order.') do |_ctx|
         @format = :reverse_ed
       end
-      o.on('-a', '--text', 'Treat the files as text and compare them', 'line-by-line, even if they do not seem', 'to be text.') do |txt|
+      o.on(
+        '-a', '--text',
+        'Treat the files as text and compare them', 'line-by-line, even if they do not seem', 'to be text.'
+      ) do |_txt|
         @binary = false
       end
-      o.on('--binary', 'Treats the files as binary.') do |bin|
+      o.on('--binary', 'Treats the files as binary.') do |_bin|
         @binary = true
       end
-      o.on('-q', '--brief', 'Report only whether or not the files', 'differ, not the details.') do |ctx|
+      o.on('-q', '--brief', 'Report only whether or not the files', 'differ, not the details.') do |_ctx|
         @format = :report
       end
       o.on_tail('--help', 'Shows this text.') do
@@ -60,7 +69,7 @@ class << Diff::LCS::Ldiff
         error << Diff::LCS::Ldiff::BANNER
         return 0
       end
-      o.on_tail ""
+      o.on_tail ''
       o.on_tail 'By default, runs produces an "old-style" diff, with output like UNIX diff.'
       o.parse!
     end
@@ -89,25 +98,19 @@ class << Diff::LCS::Ldiff
     # items we've read from each file will differ by FLD (could be 0).
     file_length_difference = 0
 
-    if @binary.nil? or @binary
-      data_old = IO.read(file_old)
-      data_new = IO.read(file_new)
+    data_old = IO.read(file_old)
+    data_new = IO.read(file_new)
 
-      # Test binary status
-      if @binary.nil?
-        old_txt = data_old[0, 4096].scan(/\0/).empty?
-        new_txt = data_new[0, 4096].scan(/\0/).empty?
-        @binary = (not old_txt) or (not new_txt)
-        old_txt = new_txt = nil
-      end
+    # Test binary status
+    if @binary.nil?
+      old_txt = data_old[0, 4096].scan(/\0/).empty?
+      new_txt = data_new[0, 4096].scan(/\0/).empty?
+      @binary = !old_txt || !new_txt
+    end
 
-      unless @binary
-        data_old = data_old.split($/).map { |e| e.chomp }
-        data_new = data_new.split($/).map { |e| e.chomp }
-      end
-    else
-      data_old = IO.readlines(file_old).map { |e| e.chomp }
-      data_new = IO.readlines(file_new).map { |e| e.chomp }
+    unless @binary
+      data_old = data_old.lines.to_a
+      data_new = data_new.lines.to_a
     end
 
     # diff yields lots of pieces, each of which is basically a Block object
@@ -126,9 +129,9 @@ class << Diff::LCS::Ldiff
     end
 
     if (@format == :unified) or (@format == :context)
-      ft = File.stat(file_old).mtime.localtime.strftime('%Y-%m-%d %H:%M:%S.%N %z')
+      ft = File.stat(file_old).mtime.localtime.strftime('%Y-%m-%d %H:%M:%S.000000000 %z')
       output << "#{char_old} #{file_old}\t#{ft}\n"
-      ft = File.stat(file_new).mtime.localtime.strftime('%Y-%m-%d %H:%M:%S.%N %z')
+      ft = File.stat(file_new).mtime.localtime.strftime('%Y-%m-%d %H:%M:%S.000000000 %z')
       output << "#{char_new} #{file_new}\t#{ft}\n"
     end
 
@@ -142,26 +145,27 @@ class << Diff::LCS::Ldiff
     end
 
     diffs.each do |piece|
-      begin
-        hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, @lines,
-                                   file_length_difference)
+      begin # rubocop:disable Style/RedundantBegin
+        hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, @lines, file_length_difference)
         file_length_difference = hunk.file_length_difference
 
         next unless oldhunk
-        next if (@lines > 0) and hunk.merge(oldhunk)
+        next if @lines.positive? and hunk.merge(oldhunk)
 
-        output << oldhunk.diff(@format) << "\n"
+        output << oldhunk.diff(@format)
+        output << "\n" if @format == :unified
       ensure
         oldhunk = hunk
       end
     end
 
-    output << oldhunk.diff(@format) << "\n"
+    last = oldhunk.diff(@format, true)
+    last << "\n" if last.respond_to?(:end_with?) && !last.end_with?("\n")
 
-    if @format == :ed
-      output.reverse_each { |e| real_output << e.diff(:ed_finish) }
-    end
+    output << last
+
+    output.reverse_each { |e| real_output << e.diff(:ed_finish) } if @format == :ed
 
-    return 1
+    1
   end
 end

data/vendor/bundle/ruby/2.6.0/gems/{diff-lcs-1.3 → diff-lcs-1.4.4}/lib/diff/lcs/string.rb

@@ -1,4 +1,4 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 class String
   include Diff::LCS

data/vendor/bundle/ruby/2.6.0/gems/{diff-lcs-1.3 → diff-lcs-1.4.4}/spec/change_spec.rb

@@ -1,9 +1,9 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'spec_helper'
 
 describe Diff::LCS::Change do
-  describe "an add" do
+  describe 'an add' do
     subject { described_class.new('+', 0, 'element') }
     it { should_not be_deleting   }
     it { should     be_adding     }
@@ -13,7 +13,7 @@ describe Diff::LCS::Change do
     it { should_not be_finished_b }
   end
 
-  describe "a delete" do
+  describe 'a delete' do
     subject { described_class.new('-', 0, 'element') }
     it { should     be_deleting   }
     it { should_not be_adding     }
@@ -23,7 +23,7 @@ describe Diff::LCS::Change do
     it { should_not be_finished_b }
   end
 
-  describe "an unchanged" do
+  describe 'an unchanged' do
     subject { described_class.new('=', 0, 'element') }
     it { should_not be_deleting   }
     it { should_not be_adding     }
@@ -33,7 +33,7 @@ describe Diff::LCS::Change do
     it { should_not be_finished_b }
   end
 
-  describe "a changed" do
+  describe 'a changed' do
     subject { described_class.new('!', 0, 'element') }
     it { should_not be_deleting   }
     it { should_not be_adding     }
@@ -43,7 +43,7 @@ describe Diff::LCS::Change do
     it { should_not be_finished_b }
   end
 
-  describe "a finished_a" do
+  describe 'a finished_a' do
     subject { described_class.new('>', 0, 'element') }
     it { should_not be_deleting   }
     it { should_not be_adding     }
@@ -53,7 +53,7 @@ describe Diff::LCS::Change do
     it { should_not be_finished_b }
   end
 
-  describe "a finished_b" do
+  describe 'a finished_b' do
     subject { described_class.new('<', 0, 'element') }
     it { should_not be_deleting   }
     it { should_not be_adding     }
@@ -62,4 +62,28 @@ describe Diff::LCS::Change do
     it { should_not be_finished_a }
     it { should     be_finished_b }
   end
+
+  describe 'as array' do
+    it 'should be converted' do
+      action, position, element = described_class.new('!', 0, 'element')
+      expect(action).to eq '!'
+      expect(position).to eq 0
+      expect(element).to eq 'element'
+    end
+  end
+end
+
+describe Diff::LCS::ContextChange do
+  describe 'as array' do
+    it 'should be converted' do
+      action, (old_position, old_element), (new_position, new_element) =
+        described_class.new('!', 1, 'old_element', 2, 'new_element')
+
+      expect(action).to eq '!'
+      expect(old_position).to eq 1
+      expect(old_element).to eq 'old_element'
+      expect(new_position).to eq 2
+      expect(new_element).to eq 'new_element'
+    end
+  end
 end

data/vendor/bundle/ruby/2.6.0/gems/{diff-lcs-1.3/spec/ldiff_spec.rb → diff-lcs-1.4.4/spec/diff_spec.rb}

@@ -1,8 +1,8 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'spec_helper'
 
-describe "Diff::LCS.diff" do
+describe Diff::LCS, '.diff' do
   include Diff::LCS::SpecHelper::Matchers
 
   it 'correctly diffs seq1 to seq2' do
@@ -18,16 +18,20 @@ describe "Diff::LCS.diff" do
   it 'correctly diffs against an empty sequence' do
     diff = Diff::LCS.diff(word_sequence, [])
     correct_diff = [
-      [ [ '-', 0, 'abcd'           ],
-        [ '-', 1, 'efgh'           ],
-        [ '-', 2, 'ijkl'           ],
-        [ '-', 3, 'mnopqrstuvwxyz' ] ]
+      [
+        ['-', 0, 'abcd'],
+        ['-', 1, 'efgh'],
+        ['-', 2, 'ijkl'],
+        ['-', 3, 'mnopqrstuvwxyz']
+      ]
     ]
 
     expect(change_diff(correct_diff)).to eq(diff)
 
     diff = Diff::LCS.diff([], word_sequence)
-    correct_diff.each { |hunk| hunk.each { |change| change[0] = '+' } }
+    correct_diff.each do |hunk|
+      hunk.each do |change| change[0] = '+' end
+    end
     expect(change_diff(correct_diff)).to eq(diff)
   end
 
@@ -37,11 +41,11 @@ describe "Diff::LCS.diff" do
     expect(Diff::LCS.patch(left, Diff::LCS.diff(left, right))).to eq(right)
   end
 
-  it "returns an empty diff with (hello, hello)" do
-    expect(Diff::LCS.diff(hello, hello)).to eq([])
+  it 'returns an empty diff with (hello, hello)' do
+    expect(Diff::LCS.diff(hello, hello)).to be_empty
   end
 
-  it "returns an empty diff with (hello_ary, hello_ary)" do
-    expect(Diff::LCS.diff(hello_ary, hello_ary)).to eq([])
+  it 'returns an empty diff with (hello_ary, hello_ary)' do
+    expect(Diff::LCS.diff(hello_ary, hello_ary)).to be_empty
   end
 end