capybara 2.18.0 → 3.0.0.rc1

data/lib/capybara/rails.rb

@@ -1,14 +1,10 @@
 # frozen_string_literal: true
+
 require 'capybara/dsl'
 
 Capybara.app = Rack::Builder.new do
   map "/" do
-    if Gem::Version.new(Rails.version) >= Gem::Version.new("3.0")
-      run Rails.application
-    else # Rails 2
-      use Rails::Rack::Static
-      run ActionController::Dispatcher.new
-    end
+    run Rails.application
   end
 end.to_app
 

data/lib/capybara/result.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
+
 require 'forwardable'
 
 module Capybara
-
   ##
   # A {Capybara::Result} represents a collection of {Capybara::Node::Element} on the page. It is possible to interact with this
   # collection similar to an Array because it implements Enumerable and offers the following Array methods through delegation:
@@ -41,7 +41,7 @@ module Capybara
       loop do
         next_result = @results_enum.next
         @result_cache << next_result
-        block.call(next_result)
+        yield next_result
       end
       self
     end
@@ -62,7 +62,7 @@ module Capybara
       !any?
     end
 
-    def matches_count?
+    def compare_count
       # Only check filters for as many elements as necessary to determine result
       if @query.options[:count]
         count_opt = Integer(@query.options[:count])
@@ -70,7 +70,7 @@ module Capybara
           break if @result_cache.size > count_opt
           @result_cache << @results_enum.next
         end
-        return @result_cache.size == count_opt
+        return @result_cache.size <=> count_opt
       end
 
       if @query.options[:minimum]
@@ -78,7 +78,7 @@ module Capybara
         begin
           @result_cache << @results_enum.next while @result_cache.size < min_opt
         rescue StopIteration
-          return false
+          return -1
         end
       end
 
@@ -86,32 +86,38 @@ module Capybara
         max_opt = Integer(@query.options[:maximum])
         begin
           @result_cache << @results_enum.next while @result_cache.size <= max_opt
-          return false
+          return 1
         rescue StopIteration
         end
       end
 
       if @query.options[:between]
-        max =  Integer(@query.options[:between].max)
+        min, max = @query.options[:between].minmax
         loop do
           break if @result_cache.size > max
           @result_cache << @results_enum.next
         end
-        return false unless (@query.options[:between] === @result_cache.size)
+        return 0 if @query.options[:between].include?(@result_cache.size)
+        return -1 if @result_cache.size < min
+        return 1
       end
 
-      return true
+      return 0
+    end
+
+    def matches_count?
+      compare_count.zero?
     end
 
     def failure_message
       message = @query.failure_message
-      if count > 0
-        message << ", found #{count} #{Capybara::Helpers.declension("match", "matches", count)}: " << full_results.map(&:text).map(&:inspect).join(", ")
-      else
+      if count.zero?
         message << " but there were no matches"
+      else
+        message << ", found #{count} #{Capybara::Helpers.declension("match", "matches", count)}: " << full_results.map(&:text).map(&:inspect).join(", ")
       end
       unless rest.empty?
-        elements = rest.map(&:text).map(&:inspect).join(", ")
+        elements = rest.map { |el| el.text rescue "<<ERROR>>" }.map(&:inspect).join(", ")
         message << ". Also found " << elements << ", which matched the selector but not all filters."
       end
       message
@@ -121,7 +127,7 @@ module Capybara
       failure_message.sub(/(to find)/, 'not \1')
     end
 
-    private
+  private
 
     def full_results
       loop { @result_cache << @results_enum.next }
@@ -137,15 +143,9 @@ module Capybara
       # causes a concurrency issue with network requests here
       # https://github.com/jruby/jruby/issues/4212
       if RUBY_PLATFORM == 'java'
-        @elements.select(&block).to_enum  # non-lazy evaluation
-      elsif @elements.respond_to? :lazy  #Ruby 2.0+
-        @elements.lazy.select(&block)
+        @elements.select(&block).to_enum # non-lazy evaluation
       else
-        Enumerator.new do |yielder|
-          @elements.each do |val|
-            yielder.yield(val) if block.call(val)
-          end
-        end
+        @elements.lazy.select(&block)
       end
     end
   end

data/lib/capybara/rspec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'rspec/core'
 require 'capybara/dsl'
 require 'capybara/rspec/matchers'
@@ -6,14 +7,9 @@ require 'capybara/rspec/features'
 require 'capybara/rspec/matcher_proxies'
 
 RSpec.configure do |config|
-  config.include Capybara::DSL, :type => :feature
-  config.include Capybara::RSpecMatchers, :type => :feature
-  config.include Capybara::RSpecMatchers, :type => :view
-
-  # A work-around to support accessing the current example that works in both
-  # RSpec 2 and RSpec 3.
-  fetch_current_example = RSpec.respond_to?(:current_example) ?
-    proc { RSpec.current_example } : proc { |context| context.example }
+  config.include Capybara::DSL, type: :feature
+  config.include Capybara::RSpecMatchers, type: :feature
+  config.include Capybara::RSpecMatchers, type: :view
 
   # The before and after blocks must run instantaneously, because Capybara
   # might not actually be used in all examples where it's included.
@@ -26,10 +22,9 @@ RSpec.configure do |config|
 
   config.before do
     if self.class.include?(Capybara::DSL)
-      example = fetch_current_example.call(self)
+      example = RSpec.current_example
       Capybara.current_driver = Capybara.javascript_driver if example.metadata[:js]
       Capybara.current_driver = example.metadata[:driver] if example.metadata[:driver]
     end
   end
 end
-

data/lib/capybara/rspec/compound.rb

@@ -4,7 +4,7 @@ module Capybara
       include ::RSpec::Matchers::Composable
 
       def and(matcher)
-        Capybara::RSpecMatchers::Compound::And.new(self,matcher)
+        Capybara::RSpecMatchers::Compound::And.new(self, matcher)
       end
 
       def and_then(matcher)
@@ -15,12 +15,9 @@ module Capybara
         Capybara::RSpecMatchers::Compound::Or.new(self, matcher)
       end
 
-
       class CapybaraEvaluator
-        def initialize(actual, matcher_1, matcher_2)
-          @actual        = actual
-          @matcher_1     = matcher_1
-          @matcher_2     = matcher_2
+        def initialize(actual)
+          @actual = actual
           @match_results = Hash.new { |h, matcher| h[matcher] = matcher.matches?(@actual) }
         end
 
@@ -34,11 +31,10 @@ module Capybara
       end
 
       class And < ::RSpec::Matchers::BuiltIn::Compound::And
-
       private
 
         def match(_expected, actual)
-          @evaluator = CapybaraEvaluator.new(actual, matcher_1, matcher_2)
+          @evaluator = CapybaraEvaluator.new(actual)
           syncer = sync_element(actual)
           begin
             syncer.synchronize do
@@ -63,11 +59,10 @@ module Capybara
       end
 
       class Or < ::RSpec::Matchers::BuiltIn::Compound::Or
-
       private
 
         def match(_expected, actual)
-          @evaluator = CapybaraEvaluator.new(actual, matcher_1, matcher_2)
+          @evaluator = CapybaraEvaluator.new(actual)
           syncer = sync_element(actual)
           begin
             syncer.synchronize do

data/lib/capybara/rspec/features.rb

@@ -1,56 +1,25 @@
 # frozen_string_literal: true
-if RSpec::Core::Version::STRING.to_f >= 3.0
-  RSpec.shared_context "Capybara Features", capybara_feature: true do
-    instance_eval do
-      alias background before
-      alias given let
-      alias given! let!
-    end
-  end
 
-  # ensure shared_context is included if default shared_context_metadata_behavior is changed
-  if RSpec::Core::Version::STRING.to_f >= 3.5
-    RSpec.configure do |config|
-      config.include_context "Capybara Features", capybara_feature: true
-    end
+RSpec.shared_context "Capybara Features", capybara_feature: true do
+  instance_eval do
+    alias background before
+    alias given let
+    alias given! let!
   end
+end
 
+# ensure shared_context is included if default shared_context_metadata_behavior is changed
+if RSpec::Core::Version::STRING.to_f >= 3.5
   RSpec.configure do |config|
-    config.alias_example_group_to :feature, capybara_feature: true, type: :feature
-    config.alias_example_group_to :xfeature, capybara_feature: true, type: :feature, skip: "Temporarily disabled with xfeature"
-    config.alias_example_group_to :ffeature, capybara_feature: true, type: :feature, focus: true
-    config.alias_example_to :scenario
-    config.alias_example_to :xscenario, skip: "Temporarily disabled with xscenario"
-    config.alias_example_to :fscenario, focus: true
-  end
-else
-  module Capybara
-    module Features
-      def self.included(base)
-        base.instance_eval do
-          alias :background :before
-          alias :scenario :it
-          alias :xscenario :xit
-          alias :given :let
-          alias :given! :let!
-          alias :feature :describe
-        end
-      end
-    end
-  end
-
-  def self.feature(*args, &block)
-    options = if args.last.is_a?(Hash) then args.pop else {} end
-    options[:capybara_feature] = true
-    options[:type] = :feature
-    options[:caller] ||= caller
-    args.push(options)
-
-    #call describe on RSpec in case user has expose_dsl_globally set to false
-    RSpec.describe(*args, &block)
+    config.include_context "Capybara Features", capybara_feature: true
   end
+end
 
-  RSpec.configure do |config|
-    config.include(Capybara::Features, capybara_feature: true)
-  end
+RSpec.configure do |config|
+  config.alias_example_group_to :feature, capybara_feature: true, type: :feature
+  config.alias_example_group_to :xfeature, capybara_feature: true, type: :feature, skip: "Temporarily disabled with xfeature"
+  config.alias_example_group_to :ffeature, capybara_feature: true, type: :feature, focus: true
+  config.alias_example_to :scenario
+  config.alias_example_to :xscenario, skip: "Temporarily disabled with xscenario"
+  config.alias_example_to :fscenario, focus: true
 end

data/lib/capybara/rspec/matcher_proxies.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
+
 module Capybara
   module RSpecMatcherProxies
-    def all(*args)
+    def all(*args, &block)
       if defined?(::RSpec::Matchers::BuiltIn::All) && args.first.respond_to?(:matches?)
         ::RSpec::Matchers::BuiltIn::All.new(*args)
       else
-        find_all(*args)
+        find_all(*args, &block)
       end
     end
 
@@ -18,28 +19,43 @@ module Capybara
     end
   end
 
-  module DSL
-    class <<self
-      remove_method :included
-
+  module DSLRSpecProxyInstaller
+    module ClassMethods
       def included(base)
-        warn "including Capybara::DSL in the global scope is not recommended!" if base == Object
-
-        if defined?(::RSpec::Matchers) && base.include?(::RSpec::Matchers)
-          base.send(:include, ::Capybara::RSpecMatcherProxies)
+        if defined?(::RSpec::Matchers)
+          base.include(::Capybara::RSpecMatcherProxies) if base.include?(::RSpec::Matchers)
         end
+        super
+      end
+    end
+
+    def self.prepended(base)
+      class <<base
+        prepend ClassMethods
+      end
+    end
+  end
 
+  module RSpecMatcherProxyInstaller
+    module ClassMethods
+      def included(base)
+        base.include(::Capybara::RSpecMatcherProxies) if base.include?(::Capybara::DSL)
         super
       end
     end
+
+    def self.prepended(base)
+      class <<base
+        prepend ClassMethods
+      end
+    end
   end
+
+  DSL.prepend ::Capybara::DSLRSpecProxyInstaller
 end
 
 if defined?(::RSpec::Matchers)
-  module  ::RSpec::Matchers
-    def self.included(base)
-      base.send(:include, ::Capybara::RSpecMatcherProxies) if base.include?(::Capybara::DSL)
-      super
-    end
+  module ::RSpec::Matchers
+    prepend ::Capybara::RSpecMatcherProxyInstaller
   end
 end

data/lib/capybara/rspec/matchers.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
+
 module Capybara
   module RSpecMatchers
     class Matcher
-      if defined?(::RSpec::Expectations::Version) && (Gem::Version.new(RSpec::Expectations::Version::STRING) >= Gem::Version.new('3.0'))
+      if defined?(::RSpec::Expectations::Version)
         require 'capybara/rspec/compound'
         include ::Capybara::RSpecMatchers::Compound
       end
@@ -10,18 +11,15 @@ module Capybara
       attr_reader :failure_message, :failure_message_when_negated
 
       def wrap(actual)
-        @context_el = if actual.respond_to?("has_selector?")
+        actual = actual.to_capybara_node if actual.respond_to?(:to_capybara_node)
+        @context_el = if actual.respond_to?(:has_selector?)
           actual
         else
           Capybara.string(actual.to_s)
         end
       end
 
-      # RSpec 2 compatibility:
-      def failure_message_for_should; failure_message end
-      def failure_message_for_should_not; failure_message_when_negated end
-
-      private
+    private
 
       def wrap_matches?(actual)
         yield(wrap(actual))
@@ -65,11 +63,11 @@ module Capybara
       end
 
       def matches?(actual)
-        wrap_matches?(actual){ |el| el.assert_selector(*@args, &@filter_block) }
+        wrap_matches?(actual) { |el| el.assert_selector(*@args, &@filter_block) }
       end
 
       def does_not_match?(actual)
-        wrap_does_not_match?(actual){ |el| el.assert_no_selector(*@args, &@filter_block) }
+        wrap_does_not_match?(actual) { |el| el.assert_no_selector(*@args, &@filter_block) }
       end
 
       def description
@@ -88,10 +86,10 @@ module Capybara
       end
 
       def matches?(actual)
-        wrap_matches?(actual){ |el| el.assert_all_of_selectors(*@args, &@filter_block) }
+        wrap_matches?(actual) { |el| el.assert_all_of_selectors(*@args, &@filter_block) }
       end
 
-      def does_not_match?(actual)
+      def does_not_match?(_actual)
         raise ArgumentError, "The have_all_selectors matcher does not support use with not_to/should_not"
       end
 
@@ -107,10 +105,10 @@ module Capybara
       end
 
       def matches?(actual)
-        wrap_matches?(actual){ |el| el.assert_none_of_selectors(*@args, &@filter_block) }
+        wrap_matches?(actual) { |el| el.assert_none_of_selectors(*@args, &@filter_block) }
       end
 
-      def does_not_match?(actual)
+      def does_not_match?(_actual)
         raise ArgumentError, "The have_none_of_selectors matcher does not support use with not_to/should_not"
       end
 
@@ -138,15 +136,9 @@ module Capybara
     end
 
     class HaveText < Matcher
-      attr_reader :type, :content, :options
-
       def initialize(*args)
         @args = args.dup
-
-        # are set just for backwards compatability
-        @type = args.shift if args.first.is_a?(Symbol)
-        @content = args.shift
-        @options = (args.first.is_a?(Hash))? args.first : {}
+        @content = args[0].is_a?(Symbol) ? args[1] : args[0]
       end
 
       def matches?(actual)
@@ -158,7 +150,7 @@ module Capybara
       end
 
       def description
-        "text #{format(content)}"
+        "text #{format(@content)}"
       end
 
       def format(content)
@@ -168,8 +160,6 @@ module Capybara
     end
 
     class HaveTitle < Matcher
-      attr_reader :title
-
       def initialize(*args)
         @args = args
 
@@ -186,17 +176,13 @@ module Capybara
       end
 
       def description
-        "have title #{title.inspect}"
+        "have title #{@title.inspect}"
       end
     end
 
     class HaveCurrentPath < Matcher
-      attr_reader :current_path
-
       def initialize(*args)
         @args = args
-
-        # are set just for backwards compatability
         @current_path = args.first
       end
 
@@ -209,7 +195,33 @@ module Capybara
       end
 
       def description
-        "have current path #{current_path.inspect}"
+        "have current path #{@current_path.inspect}"
+      end
+    end
+
+    class NegatedMatcher
+      def initialize(matcher)
+        @matcher = matcher
+      end
+
+      def matches?(actual)
+        @matcher.does_not_match?(actual)
+      end
+
+      def does_not_match?(actual)
+        @matcher.matches?(actual)
+      end
+
+      def description
+        "not #{@matcher.description}"
+      end
+
+      def failure_message
+        @matcher.failure_message_when_negated
+      end
+
+      def failure_message_when_negated
+        @matcher.failure_message
       end
     end
 
@@ -236,10 +248,6 @@ module Capybara
       def failure_message_when_negated
         "expected #{@window.inspect} not to become closed after #{@wait_time} seconds"
       end
-
-      # RSpec 2 compatibility:
-      alias_method :failure_message_for_should, :failure_message
-      alias_method :failure_message_for_should_not, :failure_message_when_negated
     end
 
     # RSpec matcher for whether the element(s) matching a given selector exist
@@ -265,107 +273,109 @@ module Capybara
     def match_selector(*args, &optional_filter_block)
       MatchSelector.new(*args, &optional_filter_block)
     end
-    # defined_negated_matcher was added in RSpec 3.1 - it's syntactic sugar only since a user can do
-    # expect(page).not_to match_selector, so not sure we really need to support not_match_selector for prior to RSpec 3.1
-    ::RSpec::Matchers.define_negated_matcher :not_match_selector, :match_selector if defined?(::RSpec::Expectations::Version) && (Gem::Version.new(RSpec::Expectations::Version::STRING) >= Gem::Version.new('3.1'))
-
 
     # RSpec matcher for whether elements(s) matching a given xpath selector exist
     # See {Capybara::Node::Matchers#has_xpath?}
-    def have_xpath(xpath, options={}, &optional_filter_block)
+    def have_xpath(xpath, **options, &optional_filter_block)
       HaveSelector.new(:xpath, xpath, options, &optional_filter_block)
     end
 
     # RSpec matcher for whether the current element matches a given xpath selector
-    def match_xpath(xpath, options={}, &optional_filter_block)
+    def match_xpath(xpath, **options, &optional_filter_block)
       MatchSelector.new(:xpath, xpath, options, &optional_filter_block)
     end
 
     # RSpec matcher for whether elements(s) matching a given css selector exist
     # See {Capybara::Node::Matchers#has_css?}
-    def have_css(css, options={}, &optional_filter_block)
+    def have_css(css, **options, &optional_filter_block)
       HaveSelector.new(:css, css, options, &optional_filter_block)
     end
 
     # RSpec matcher for whether the current element matches a given css selector
-    def match_css(css, options={}, &optional_filter_block)
+    def match_css(css, **options, &optional_filter_block)
       MatchSelector.new(:css, css, options, &optional_filter_block)
     end
 
-    # RSpec matcher for text on the page
+    # RSpec matcher for text content
     # See {Capybara::SessionMatchers#assert_text}
     def have_text(*args)
       HaveText.new(*args)
     end
     alias_method :have_content, :have_text
 
-    def have_title(title, options = {})
+    def have_title(title, **options)
       HaveTitle.new(title, options)
     end
 
     # RSpec matcher for the current path
     # See {Capybara::SessionMatchers#assert_current_path}
-    def have_current_path(path, options = {})
+    def have_current_path(path, **options)
       HaveCurrentPath.new(path, options)
     end
 
     # RSpec matcher for links
     # See {Capybara::Node::Matchers#has_link?}
-    def have_link(locator=nil, options={}, &optional_filter_block)
-      locator, options = nil, locator if locator.is_a? Hash
+    def have_link(locator = nil, **options, &optional_filter_block)
       HaveSelector.new(:link, locator, options, &optional_filter_block)
     end
 
     # RSpec matcher for buttons
     # See {Capybara::Node::Matchers#has_button?}
-    def have_button(locator=nil, options={}, &optional_filter_block)
-      locator, options = nil, locator if locator.is_a? Hash
+    def have_button(locator = nil, **options, &optional_filter_block)
       HaveSelector.new(:button, locator, options, &optional_filter_block)
     end
 
     # RSpec matcher for links
     # See {Capybara::Node::Matchers#has_field?}
-    def have_field(locator=nil, options={}, &optional_filter_block)
-      locator, options = nil, locator if locator.is_a? Hash
+    def have_field(locator = nil, **options, &optional_filter_block)
       HaveSelector.new(:field, locator, options, &optional_filter_block)
     end
 
     # RSpec matcher for checked fields
     # See {Capybara::Node::Matchers#has_checked_field?}
-    def have_checked_field(locator=nil, options={}, &optional_filter_block)
-      locator, options = nil, locator if locator.is_a? Hash
+    def have_checked_field(locator = nil, **options, &optional_filter_block)
       HaveSelector.new(:field, locator, options.merge(checked: true), &optional_filter_block)
     end
 
     # RSpec matcher for unchecked fields
     # See {Capybara::Node::Matchers#has_unchecked_field?}
-    def have_unchecked_field(locator=nil, options={}, &optional_filter_block)
-      locator, options = nil, locator if locator.is_a? Hash
+    def have_unchecked_field(locator = nil, **options, &optional_filter_block)
       HaveSelector.new(:field, locator, options.merge(unchecked: true), &optional_filter_block)
     end
 
     # RSpec matcher for select elements
     # See {Capybara::Node::Matchers#has_select?}
-    def have_select(locator=nil, options={}, &optional_filter_block)
-      locator, options = nil, locator if locator.is_a? Hash
+    def have_select(locator = nil, **options, &optional_filter_block)
       HaveSelector.new(:select, locator, options, &optional_filter_block)
     end
 
     # RSpec matcher for table elements
     # See {Capybara::Node::Matchers#has_table?}
-    def have_table(locator=nil, options={}, &optional_filter_block)
-      locator, options = nil, locator if locator.is_a? Hash
+    def have_table(locator = nil, **options, &optional_filter_block)
       HaveSelector.new(:table, locator, options, &optional_filter_block)
     end
 
+    %w[selector css xpath text title current_path link button field checked_field unchecked_field select table].each do |matcher_type|
+      define_method "have_no_#{matcher_type}" do |*args, &optional_filter_block|
+        NegatedMatcher.new(send("have_#{matcher_type}", *args, &optional_filter_block))
+      end
+    end
+    alias_method :have_no_content, :have_no_text
+
+    %w[selector css xpath].each do |matcher_type|
+      define_method "not_match_#{matcher_type}" do |*args, &optional_filter_block|
+        NegatedMatcher.new(send("match_#{matcher_type}", *args, &optional_filter_block))
+      end
+    end
+
     ##
     # Wait for window to become closed.
     # @example
     #   expect(window).to become_closed(wait: 0.8)
     # @param options [Hash] optional param
     # @option options [Numeric] :wait (Capybara.default_max_wait_time) Maximum wait time
-    def become_closed(options = {})
+    def become_closed(**options)
       BecomeClosed.new(options)
     end
   end
-end
+end