From 9905de43f90d9739b2a35e9a040ac210e367d86d Mon Sep 17 00:00:00 2001
From: Thomas Walpole <twalpole@gmail.com>
Date: Mon, 3 Feb 2020 17:48:36 -0800
Subject: [PATCH] Fix results with negative max bounded ranges

---
 lib/capybara/result.rb |  1 +
 spec/result_spec.rb    | 57 +++++++++++++++++++++++++++++-------------
 2 files changed, 41 insertions(+), 17 deletions(-)

diff --git a/lib/capybara/result.rb b/lib/capybara/result.rb
index 2d9c72d9..616c7a70 100644
--- a/lib/capybara/result.rb
+++ b/lib/capybara/result.rb
@@ -63,6 +63,7 @@ module Capybara
         # idx.max is broken with beginless ranges
         # idx.end && idx.max # endless range will have end == nil
         max = idx.end
+        max = nil if max&.negative?
         max -= 1 if max && idx.exclude_end?
         max
       end
diff --git a/spec/result_spec.rb b/spec/result_spec.rb
index a4f0d527..d6bc15aa 100644
--- a/spec/result_spec.rb
+++ b/spec/result_spec.rb
@@ -65,25 +65,48 @@ RSpec.describe Capybara::Result do
     end).to eq(2)
   end
 
-  it 'supports all modes of []' do
-    expect(result[1].text).to eq 'Beta'
-    expect(result[0, 2].map(&:text)).to eq %w[Alpha Beta]
-    expect(result[1..3].map(&:text)).to eq %w[Beta Gamma Delta]
-    expect(result[-1].text).to eq 'Delta'
-    expect(result[-2, 3].map(&:text)).to eq %w[Gamma Delta]
-    expect(result[1..7].map(&:text)).to eq %w[Beta Gamma Delta]
-    expect(result[1...3].map(&:text)).to eq %w[Beta Gamma]
-    expect(result[2..-1].map(&:text)).to eq %w[Gamma Delta]
-    expect(result[2...-1].map(&:text)).to eq %w[Gamma]
-    eval <<~TEST, binding, __FILE__, __LINE__ + 1 if RUBY_VERSION.to_f > 2.5
-      expect(result[2..].map(&:text)).to eq %w[Gamma Delta]
-    TEST
-    eval <<~TEST, binding, __FILE__, __LINE__ + 1 if RUBY_VERSION.to_f > 2.6
-      expect(result[..2].map(&:text)).to eq %w[Alpha Beta Gamma]
-      expect(result[...2].map(&:text)).to eq %w[Alpha Beta]
-    TEST
+  def recalc_result
+    string.all '//li', minimum: 0 # pass minimum: 0 so lazy evaluation doesn't get triggered yet
   end
 
+  it 'supports all modes of []' do
+    expect(recalc_result[1].text).to eq 'Beta'
+    expect(recalc_result[0, 2].map(&:text)).to eq %w[Alpha Beta]
+    expect(recalc_result[1..3].map(&:text)).to eq %w[Beta Gamma Delta]
+    expect(recalc_result[-1].text).to eq 'Delta'
+    expect(recalc_result[-2, 3].map(&:text)).to eq %w[Gamma Delta]
+    expect(recalc_result[1...3].map(&:text)).to eq %w[Beta Gamma]
+    expect(recalc_result[1..7].map(&:text)).to eq %w[Beta Gamma Delta]
+    expect(recalc_result[2...-1].map(&:text)).to eq %w[Gamma]
+    expect(recalc_result[2..-1].map(&:text)).to eq %w[Gamma Delta]
+  end
+
+  eval <<~TEST, binding, __FILE__, __LINE__ + 1 if RUBY_VERSION.to_f > 2.5
+    it 'supports endless ranges' do
+      expect(result[2..].map(&:text)).to eq %w[Gamma Delta]
+    end
+  TEST
+
+  eval <<~TEST, binding, __FILE__, __LINE__ + 1 if RUBY_VERSION.to_f > 2.6
+    it 'supports inclusive positive beginless ranges' do
+      expect(result[..2].map(&:text)).to eq %w[Alpha Beta Gamma]
+    end
+
+    it 'supports inclusive negative beginless ranges' do
+      expect(result[..-2].map(&:text)).to eq %w[Alpha Beta Gamma]
+      expect(result[..-1].map(&:text)).to eq %w[Alpha Beta Gamma Delta]
+    end
+
+    it 'supports exclusive positive beginless ranges' do
+      expect(result[...2].map(&:text)).to eq %w[Alpha Beta]
+    end
+
+    it 'supports exclusive negative beginless ranges' do
+      expect(result[...-2].map(&:text)).to eq %w[Alpha Beta]
+      expect(result[...-1].map(&:text)).to eq %w[Alpha Beta Gamma]
+    end
+  TEST
+
   it 'works with filter blocks' do
     result = string.all('//li') { |node| node.text == 'Alpha' }
     expect(result.size).to eq 1