cybrid_api_bank_ruby 0.113.109 → 0.113.115

data/vendor/bundle/ruby/3.2.0/gems/diff-lcs-1.5.1/spec/change_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Diff::LCS::Change do
+  describe "an add" do
+    subject { described_class.new("+", 0, "element") }
+    it { should_not be_deleting }
+    it { should be_adding }
+    it { should_not be_unchanged }
+    it { should_not be_changed }
+    it { should_not be_finished_a }
+    it { should_not be_finished_b }
+  end
+
+  describe "a delete" do
+    subject { described_class.new("-", 0, "element") }
+    it { should be_deleting }
+    it { should_not be_adding }
+    it { should_not be_unchanged }
+    it { should_not be_changed }
+    it { should_not be_finished_a }
+    it { should_not be_finished_b }
+  end
+
+  describe "an unchanged" do
+    subject { described_class.new("=", 0, "element") }
+    it { should_not be_deleting }
+    it { should_not be_adding }
+    it { should be_unchanged }
+    it { should_not be_changed }
+    it { should_not be_finished_a }
+    it { should_not be_finished_b }
+  end
+
+  describe "a changed" do
+    subject { described_class.new("!", 0, "element") }
+    it { should_not be_deleting }
+    it { should_not be_adding }
+    it { should_not be_unchanged }
+    it { should be_changed }
+    it { should_not be_finished_a }
+    it { should_not be_finished_b }
+  end
+
+  describe "a finished_a" do
+    subject { described_class.new(">", 0, "element") }
+    it { should_not be_deleting }
+    it { should_not be_adding }
+    it { should_not be_unchanged }
+    it { should_not be_changed }
+    it { should be_finished_a }
+    it { should_not be_finished_b }
+  end
+
+  describe "a finished_b" do
+    subject { described_class.new("<", 0, "element") }
+    it { should_not be_deleting }
+    it { should_not be_adding }
+    it { should_not be_unchanged }
+    it { should_not be_changed }
+    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/3.2.0/gems/{diff-lcs-1.5.0 → diff-lcs-1.5.1}/spec/diff_spec.rb

@@ -1,28 +1,28 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+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
+  it "correctly diffs seq1 to seq2" do
     diff_s1_s2 = Diff::LCS.diff(seq1, seq2)
     expect(change_diff(correct_forward_diff)).to eq(diff_s1_s2)
   end
 
-  it 'correctly diffs seq2 to seq1' do
+  it "correctly diffs seq2 to seq1" do
     diff_s2_s1 = Diff::LCS.diff(seq2, seq1)
     expect(change_diff(correct_backward_diff)).to eq(diff_s2_s1)
   end
 
-  it 'correctly diffs against an empty sequence' 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"]
       ]
     ]
 
@@ -30,22 +30,22 @@ describe Diff::LCS, '.diff' do
 
     diff = Diff::LCS.diff([], word_sequence)
     correct_diff.each do |hunk|
-      hunk.each do |change| change[0] = '+' end
+      hunk.each { |change| change[0] = "+" }
     end
     expect(change_diff(correct_diff)).to eq(diff)
   end
 
   it "correctly diffs 'xx' and 'xaxb'" do
-    left = 'xx'
-    right = 'xaxb'
+    left = "xx"
+    right = "xaxb"
     expect(Diff::LCS.patch(left, Diff::LCS.diff(left, right))).to eq(right)
   end
 
-  it 'returns an empty diff with (hello, hello)' do
+  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
+  it "returns an empty diff with (hello_ary, hello_ary)" do
     expect(Diff::LCS.diff(hello_ary, hello_ary)).to be_empty
   end
 end

data/vendor/bundle/ruby/3.2.0/gems/{diff-lcs-1.5.0 → diff-lcs-1.5.1}/spec/hunk_spec.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 if String.method_defined?(:encoding)
-  require 'diff/lcs/hunk'
+  require "diff/lcs/hunk"
 
   describe Diff::LCS::Hunk do
-    let(:old_data) { ['Tu a un carté avec {count} itéms'.encode('UTF-16LE')] }
-    let(:new_data) { ['Tu a un carte avec {count} items'.encode('UTF-16LE')] }
-    let(:pieces)   { Diff::LCS.diff old_data, new_data }
-    let(:hunk)     { Diff::LCS::Hunk.new(old_data, new_data, pieces[0], 3, 0) }
+    let(:old_data) { ["Tu a un carté avec {count} itéms".encode("UTF-16LE")] }
+    let(:new_data) { ["Tu a un carte avec {count} items".encode("UTF-16LE")] }
+    let(:pieces) { Diff::LCS.diff old_data, new_data }
+    let(:hunk) { Diff::LCS::Hunk.new(old_data, new_data, pieces[0], 3, 0) }
 
-    it 'produces a unified diff from the two pieces' do
-      expected = <<-EXPECTED.gsub(/^\s+/, '').encode('UTF-16LE').chomp
+    it "produces a unified diff from the two pieces" do
+      expected = <<-EXPECTED.gsub(/^\s+/, "").encode("UTF-16LE").chomp
         @@ -1 +1 @@
         -Tu a un carté avec {count} itéms
         +Tu a un carte avec {count} items
@@ -21,8 +21,8 @@ if String.method_defined?(:encoding)
       expect(hunk.diff(:unified)).to eq(expected)
     end
 
-    it 'produces a unified diff from the two pieces (last entry)' do
-      expected = <<-EXPECTED.gsub(/^\s+/, '').encode('UTF-16LE').chomp
+    it "produces a unified diff from the two pieces (last entry)" do
+      expected = <<-EXPECTED.gsub(/^\s+/, "").encode("UTF-16LE").chomp
         @@ -1 +1 @@
         -Tu a un carté avec {count} itéms
         +Tu a un carte avec {count} items
@@ -32,8 +32,8 @@ if String.method_defined?(:encoding)
       expect(hunk.diff(:unified, true)).to eq(expected)
     end
 
-    it 'produces a context diff from the two pieces' do
-      expected = <<-EXPECTED.gsub(/^\s+/, '').encode('UTF-16LE').chomp
+    it "produces a context diff from the two pieces" do
+      expected = <<-EXPECTED.gsub(/^\s+/, "").encode("UTF-16LE").chomp
         ***************
         *** 1 ****
         ! Tu a un carté avec {count} itéms
@@ -44,8 +44,8 @@ if String.method_defined?(:encoding)
       expect(hunk.diff(:context)).to eq(expected)
     end
 
-    it 'produces an old diff from the two pieces' do
-      expected = <<-EXPECTED.gsub(/^ +/, '').encode('UTF-16LE').chomp
+    it "produces an old diff from the two pieces" do
+      expected = <<-EXPECTED.gsub(/^ +/, "").encode("UTF-16LE").chomp
         1c1
         < Tu a un carté avec {count} itéms
         ---
@@ -56,8 +56,8 @@ if String.method_defined?(:encoding)
       expect(hunk.diff(:old)).to eq(expected)
     end
 
-    it 'produces a reverse ed diff from the two pieces' do
-      expected = <<-EXPECTED.gsub(/^ +/, '').encode('UTF-16LE').chomp
+    it "produces a reverse ed diff from the two pieces" do
+      expected = <<-EXPECTED.gsub(/^ +/, "").encode("UTF-16LE").chomp
         c1
         Tu a un carte avec {count} items
         .
@@ -67,11 +67,11 @@ if String.method_defined?(:encoding)
       expect(hunk.diff(:reverse_ed)).to eq(expected)
     end
 
-    context 'with empty first data set' do
+    context "with empty first data set" do
       let(:old_data) { [] }
 
-      it 'produces a unified diff' do
-        expected = <<-EXPECTED.gsub(/^\s+/, '').encode('UTF-16LE').chomp
+      it "produces a unified diff" do
+        expected = <<-EXPECTED.gsub(/^\s+/, "").encode("UTF-16LE").chomp
           @@ -1 +1,2 @@
           +Tu a un carte avec {count} items
         EXPECTED

data/vendor/bundle/ruby/3.2.0/gems/diff-lcs-1.5.1/spec/issues_spec.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "diff/lcs/hunk"
+
+describe "Diff::LCS Issues" do
+  include Diff::LCS::SpecHelper::Matchers
+
+  describe "issue #1" do
+    shared_examples "handles simple diffs" do |s1, s2, forward_diff|
+      before do
+        @diff_s1_s2 = Diff::LCS.diff(s1, s2)
+      end
+
+      it "creates the correct diff" do
+        expect(change_diff(forward_diff)).to eq(@diff_s1_s2)
+      end
+
+      it "creates the correct patch s1->s2" do
+        expect(Diff::LCS.patch(s1, @diff_s1_s2)).to eq(s2)
+      end
+
+      it "creates the correct patch s2->s1" do
+        expect(Diff::LCS.patch(s2, @diff_s1_s2)).to eq(s1)
+      end
+    end
+
+    describe "string" do
+      it_has_behavior "handles simple diffs", "aX", "bXaX", [
+        [
+          ["+", 0, "b"],
+          ["+", 1, "X"]
+        ]
+      ]
+      it_has_behavior "handles simple diffs", "bXaX", "aX", [
+        [
+          ["-", 0, "b"],
+          ["-", 1, "X"]
+        ]
+      ]
+    end
+
+    describe "array" do
+      it_has_behavior "handles simple diffs", %w[a X], %w[b X a X], [
+        [
+          ["+", 0, "b"],
+          ["+", 1, "X"]
+        ]
+      ]
+      it_has_behavior "handles simple diffs", %w[b X a X], %w[a X], [
+        [
+          ["-", 0, "b"],
+          ["-", 1, "X"]
+        ]
+      ]
+    end
+  end
+
+  describe "issue #57" do
+    it "should fail with a correct error" do
+      # standard:disable Style/HashSyntax
+      expect {
+        actual = {:category => "app.rack.request"}
+        expected = {:category => "rack.middleware", :title => "Anonymous Middleware"}
+        expect(actual).to eq(expected)
+      }.to raise_error(RSpec::Expectations::ExpectationNotMetError)
+      # standard:enable Style/HashSyntax
+    end
+  end
+
+  describe "issue #60" do
+    it "should produce unified output with correct context" do
+      # standard:disable Layout/HeredocIndentation
+      old_data = <<-DATA_OLD.strip.split("\n").map(&:chomp)
+{
+  "name": "x",
+  "description": "hi"
+}
+      DATA_OLD
+
+      new_data = <<-DATA_NEW.strip.split("\n").map(&:chomp)
+{
+  "name": "x",
+  "description": "lo"
+}
+      DATA_NEW
+
+      diff = ::Diff::LCS.diff(old_data, new_data)
+      hunk = ::Diff::LCS::Hunk.new(old_data, new_data, diff.first, 3, 0)
+
+      expect(hunk.diff(:unified)).to eq(<<-EXPECTED.chomp)
+@@ -1,5 +1,5 @@
+ {
+   "name": "x",
+-  "description": "hi"
++  "description": "lo"
+ }
+      EXPECTED
+      # standard:enable Layout/HeredocIndentation
+    end
+  end
+
+  describe "issue #65" do
+    def diff_lines(old_lines, new_lines)
+      file_length_difference = 0
+      previous_hunk = nil
+      output = []
+
+      Diff::LCS.diff(old_lines, new_lines).each do |piece|
+        hunk = Diff::LCS::Hunk.new(old_lines, new_lines, piece, 3, file_length_difference)
+        file_length_difference = hunk.file_length_difference
+        maybe_contiguous_hunks = previous_hunk.nil? || hunk.merge(previous_hunk)
+
+        output << "#{previous_hunk.diff(:unified)}\n" unless maybe_contiguous_hunks
+
+        previous_hunk = hunk
+      end
+      output << "#{previous_hunk.diff(:unified, true)}\n" unless previous_hunk.nil?
+      output.join
+    end
+
+    it "should not misplace the new chunk" do
+      old_data = [
+        "recipe[a::default]", "recipe[b::default]", "recipe[c::default]",
+        "recipe[d::default]", "recipe[e::default]", "recipe[f::default]",
+        "recipe[g::default]", "recipe[h::default]", "recipe[i::default]",
+        "recipe[j::default]", "recipe[k::default]", "recipe[l::default]",
+        "recipe[m::default]", "recipe[n::default]"
+      ]
+
+      new_data = [
+        "recipe[a::default]", "recipe[c::default]", "recipe[d::default]",
+        "recipe[e::default]", "recipe[f::default]", "recipe[g::default]",
+        "recipe[h::default]", "recipe[i::default]", "recipe[j::default]",
+        "recipe[k::default]", "recipe[l::default]", "recipe[m::default]",
+        "recipe[n::default]", "recipe[o::new]", "recipe[p::new]",
+        "recipe[q::new]", "recipe[r::new]"
+      ]
+
+      # standard:disable Layout/HeredocIndentation
+      expect(diff_lines(old_data, new_data)).to eq(<<-EODIFF)
+@@ -1,5 +1,4 @@
+ recipe[a::default]
+-recipe[b::default]
+ recipe[c::default]
+ recipe[d::default]
+ recipe[e::default]
+@@ -12,3 +11,7 @@
+ recipe[l::default]
+ recipe[m::default]
+ recipe[n::default]
++recipe[o::new]
++recipe[p::new]
++recipe[q::new]
++recipe[r::new]
+      EODIFF
+      # standard:enable Layout/HeredocIndentation
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/{diff-lcs-1.5.0 → diff-lcs-1.5.1}/spec/lcs_spec.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
-describe Diff::LCS::Internals, '.lcs' do
+describe Diff::LCS::Internals, ".lcs" do
   include Diff::LCS::SpecHelper::Matchers
 
-  it 'returns a meaningful LCS array with (seq1, seq2)' do
+  it "returns a meaningful LCS array with (seq1, seq2)" do
     res = Diff::LCS::Internals.lcs(seq1, seq2)
     # The result of the LCS (less the +nil+ values) must be as long as the
     # correct result.
@@ -20,37 +20,37 @@ describe Diff::LCS::Internals, '.lcs' do
     expect(x_seq2).to eq(correct_lcs)
   end
 
-  it 'returns all indexes with (hello, hello)' do
+  it "returns all indexes with (hello, hello)" do
     expect(Diff::LCS::Internals.lcs(hello, hello)).to \
       eq((0...hello.size).to_a)
   end
 
-  it 'returns all indexes with (hello_ary, hello_ary)' do
+  it "returns all indexes with (hello_ary, hello_ary)" do
     expect(Diff::LCS::Internals.lcs(hello_ary, hello_ary)).to \
       eq((0...hello_ary.size).to_a)
   end
 end
 
-describe Diff::LCS, '.LCS' do
+describe Diff::LCS, ".LCS" do
   include Diff::LCS::SpecHelper::Matchers
 
-  it 'returns the correct compacted values from Diff::LCS.LCS' do
+  it "returns the correct compacted values from Diff::LCS.LCS" do
     res = Diff::LCS.LCS(seq1, seq2)
     expect(res).to eq(correct_lcs)
     expect(res.compact).to eq(res)
   end
 
-  it 'is transitive' do
+  it "is transitive" do
     res = Diff::LCS.LCS(seq2, seq1)
     expect(res).to eq(correct_lcs)
     expect(res.compact).to eq(res)
   end
 
-  it 'returns %W(h e l l o) with (hello, hello)' do
-    expect(Diff::LCS.LCS(hello, hello)).to eq(hello.split(//))
+  it "returns %W(h e l l o) with (hello, hello)" do
+    expect(Diff::LCS.LCS(hello, hello)).to eq(hello.chars)
   end
 
-  it 'returns hello_ary with (hello_ary, hello_ary)' do
+  it "returns hello_ary with (hello_ary, hello_ary)" do
     expect(Diff::LCS.LCS(hello_ary, hello_ary)).to eq(hello_ary)
   end
 end

data/vendor/bundle/ruby/3.2.0/gems/{diff-lcs-1.5.0 → diff-lcs-1.5.1}/spec/ldiff_spec.rb

@@ -1,29 +1,31 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
-RSpec.describe 'bin/ldiff' do
+RSpec.describe "bin/ldiff" do
   include CaptureSubprocessIO
 
+  # standard:disable Style/HashSyntax
   fixtures = [
-    { :name => 'output.diff', :left => 'aX', :right => 'bXaX' },
-    { :name => 'output.diff.chef', :left => 'old-chef', :right => 'new-chef' },
-    { :name => 'output.diff.chef2', :left => 'old-chef2', :right => 'new-chef2' }
-  ].product([nil, '-e', '-f', '-c', '-u']).map { |(fixture, flag)|
+    {:name => "output.diff", :left => "aX", :right => "bXaX"},
+    {:name => "output.diff.chef", :left => "old-chef", :right => "new-chef"},
+    {:name => "output.diff.chef2", :left => "old-chef2", :right => "new-chef2"}
+  ].product([nil, "-e", "-f", "-c", "-u"]).map { |(fixture, flag)|
     fixture = fixture.dup
     fixture[:flag] = flag
     fixture
   }
+  # standard:enable Style/HashSyntax
 
   def self.test_ldiff(fixture)
     desc = [
       fixture[:flag],
       "spec/fixtures/#{fixture[:left]}",
       "spec/fixtures/#{fixture[:right]}",
-      '#',
-      '=>',
+      "#",
+      "=>",
       "spec/fixtures/ldiff/#{fixture[:name]}#{fixture[:flag]}"
-    ].join(' ')
+    ].join(" ")
 
     it desc do
       expect(run_ldiff(fixture)).to eq(read_fixture(fixture))
@@ -45,7 +47,7 @@ RSpec.describe 'bin/ldiff' do
   def clean_data(data, flag)
     data =
       case flag
-      when '-c', '-u'
+      when "-c", "-u"
         clean_output_timestamp(data)
       else
         data
@@ -80,7 +82,7 @@ RSpec.describe 'bin/ldiff' do
       system("ruby -Ilib bin/ldiff #{flag} spec/fixtures/#{left} spec/fixtures/#{right}")
     end
 
-    expect(stderr).to be_empty if RUBY_VERSION >= '1.9'
+    expect(stderr).to be_empty if RUBY_VERSION >= "1.9"
     expect(stdout).not_to be_empty
     clean_data(stdout, flag)
   end