capybara 2.15.0 → 3.0.0

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))
@@ -59,18 +57,17 @@ module Capybara
     end
 
     class HaveSelector < Matcher
-
       def initialize(*args, &filter_block)
         @args = args
         @filter_block = filter_block
       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
@@ -82,6 +79,44 @@ module Capybara
       end
     end
 
+    class HaveAllSelectors < Matcher
+      def initialize(*args, &filter_block)
+        @args = args
+        @filter_block = filter_block
+      end
+
+      def matches?(actual)
+        wrap_matches?(actual) { |el| el.assert_all_of_selectors(*@args, &@filter_block) }
+      end
+
+      def does_not_match?(_actual)
+        raise ArgumentError, "The have_all_selectors matcher does not support use with not_to/should_not"
+      end
+
+      def description
+        "have all selectors"
+      end
+    end
+
+    class HaveNoSelectors < Matcher
+      def initialize(*args, &filter_block)
+        @args = args
+        @filter_block = filter_block
+      end
+
+      def matches?(actual)
+        wrap_matches?(actual) { |el| el.assert_none_of_selectors(*@args, &@filter_block) }
+      end
+
+      def does_not_match?(_actual)
+        raise ArgumentError, "The have_none_of_selectors matcher does not support use with not_to/should_not"
+      end
+
+      def description
+        "have no selectors"
+      end
+    end
+
     class MatchSelector < HaveSelector
       def matches?(actual)
         wrap_matches?(actual) { |el| el.assert_matches_selector(*@args, &@filter_block) }
@@ -101,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)
@@ -121,18 +150,15 @@ module Capybara
       end
 
       def description
-        "text #{format(content)}"
+        "text #{format(@content)}"
       end
 
       def format(content)
-        content = Capybara::Helpers.normalize_whitespace(content) unless content.is_a? Regexp
         content.inspect
       end
     end
 
     class HaveTitle < Matcher
-      attr_reader :title
-
       def initialize(*args)
         @args = args
 
@@ -149,17 +175,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
 
@@ -172,7 +194,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
 
@@ -199,10 +247,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
@@ -211,112 +255,126 @@ module Capybara
       HaveSelector.new(*args, &optional_filter_block)
     end
 
+    # RSpec matcher for whether the element(s) matching a group of selectors exist
+    # See {Capybara::Node::Matcher#assert_all_of_selectors}
+    def have_all_of_selectors(*args, &optional_filter_block)
+      HaveAllSelectors.new(*args, &optional_filter_block)
+    end
+
+    # RSpec matcher for whether no element(s) matching a group of selectors exist
+    # See {Capybara::Node::Matcher#assert_none_of_selectors}
+    def have_none_of_selectors(*args, &optional_filter_block)
+      HaveNoSelectors.new(*args, &optional_filter_block)
+    end
+
     # RSpec matcher for whether the current element matches a given selector
     # See {Capybara::Node::Matchers#assert_matches_selector}
     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

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/selector/css.rb

@@ -2,24 +2,19 @@ module Capybara
   class Selector
     class CSS
       def self.escape(str)
-        out = String.new("")
         value = str.dup
+        out = "".dup
         out << value.slice!(0...1) if value =~ /^[-_]/
-        out << if value[0] =~ NMSTART
-          value.slice!(0...1)
-        else
-          escape_char(value.slice!(0...1))
-        end
-        out << value.gsub(/[^a-zA-Z0-9_-]/) {|c| escape_char c}
+        out << (value[0] =~ NMSTART ? value.slice!(0...1) : escape_char(value.slice!(0...1)))
+        out << value.gsub(/[^a-zA-Z0-9_-]/) { |c| escape_char c }
         out
       end
 
       def self.escape_char(c)
-        return "\\%06x" % c.ord() unless c =~ %r{[ -/:-~]}
-        "\\#{c}"
+        c =~ %r{[ -/:-~]} ? "\\#{c}" : format("\\%06x", c.ord)
       end
 
-      S = '\u{80}-\u{D7FF}\u{E000}-\u{FFFD}\u{10000}-\u{10FFFF}'
+      S = '\u{80}-\u{D7FF}\u{E000}-\u{FFFD}\u{10000}-\u{10FFFF}'.freeze
       H = /[0-9a-fA-F]/
       UNICODE  = /\\#{H}{1,6}[ \t\r\n\f]?/
       NONASCII = /[#{S}]/
@@ -27,4 +22,4 @@ module Capybara
       NMSTART  = /[_a-zA-Z]|#{NONASCII}|#{ESCAPE}/
     end
   end
-end
+end

data/lib/capybara/selector/filter.rb

@@ -1,20 +1,4 @@
 # frozen_string_literal: true
+
 require 'capybara/selector/filters/node_filter'
 require 'capybara/selector/filters/expression_filter'
-
-module Capybara
-  class Selector
-    def self.const_missing(const_name)
-      case const_name
-      when :Filter
-        warn "DEPRECATED: Capybara::Selector::Filter is deprecated, please use Capybara::Selector::Filters::NodeFilter instead"
-        Filters::NodeFilter
-      when :ExpressionFilter
-        warn "DEPRECATED: Capybara::Selector::ExpressionFilter is deprecated, please use Capybara::Selector::Filters::ExpressionFilter instead"
-        Filters::ExpressionFilter
-      else
-        super
-      end
-    end
-  end
-end

data/lib/capybara/selector/filter_set.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'capybara/selector/filter'
 
 module Capybara
@@ -24,14 +25,10 @@ module Capybara
         descriptions.push block
       end
 
-      def description(options={})
-        options_with_defaults = options.dup
-        filters.each do |name, filter|
-          options_with_defaults[name] = filter.default if filter.default? && !options_with_defaults.has_key?(name)
-        end
-
+      def description(**options)
+        opts = options_with_defaults(options)
         @descriptions.map do |desc|
-          desc.call(options_with_defaults).to_s
+          desc.call(opts).to_s
         end.join
       end
 
@@ -44,13 +41,12 @@ module Capybara
       end
 
       def expression_filters
-        filters.select { |_n, f| f.nil? || f.is_a?(Filters::ExpressionFilter)  }.freeze
+        filters.select { |_n, f| f.nil? || f.is_a?(Filters::ExpressionFilter) }.freeze
       end
 
       class << self
-
         def all
-          @filter_sets ||= {}
+          @filter_sets ||= {} # rubocop:disable Naming/MemoizedInstanceVariableName
         end
 
         def add(name, &block)
@@ -62,13 +58,20 @@ module Capybara
         end
       end
 
-      private
+    private
+
+      def options_with_defaults(options)
+        options = options.dup
+        filters.each do |name, filter|
+          options[name] = filter.default if filter.default? && !options.key?(name)
+        end
+        options
+      end
 
-      def add_filter(name, filter_class, *types_and_options, &block)
-        options = types_and_options.last.is_a?(Hash) ? types_and_options.pop.dup : {}
-        types_and_options.each { |k| options[k] = true}
+      def add_filter(name, filter_class, *types, **options, &block)
+        types.each { |k| options[k] = true }
         filters[name] = filter_class.new(name, block, options)
       end
     end
   end
-end
+end

data/lib/capybara/selector/filters/base.rb

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
+
 module Capybara
   class Selector
     module Filters
       class Base
-        def initialize(name, block, options={})
+        def initialize(name, block, **options)
           @name = name
           @block = block
           @options = options
-          @options[:valid_values] = [true,false] if options[:boolean]
+          @options[:valid_values] = [true, false] if options[:boolean]
         end
 
         def default?
-          @options.has_key?(:default)
+          @options.key?(:default)
         end
 
         def default
@@ -19,13 +20,13 @@ module Capybara
         end
 
         def skip?(value)
-          @options.has_key?(:skip_if) && value == @options[:skip_if]
+          @options.key?(:skip_if) && value == @options[:skip_if]
         end
 
-        private
+      private
 
         def valid_value?(value)
-          !@options.has_key?(:valid_values) || Array(@options[:valid_values]).include?(value)
+          !@options.key?(:valid_values) || Array(@options[:valid_values]).include?(value)
         end
       end
     end

data/lib/capybara/selector/filters/expression_filter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'capybara/selector/filters/base'
 
 module Capybara
@@ -7,34 +8,16 @@ module Capybara
       class ExpressionFilter < Base
         def apply_filter(expr, value)
           return expr if skip?(value)
-
-          if !valid_value?(value)
-            msg = "Invalid value #{value.inspect} passed to expression filter #{@name} - "
-            if default?
-              warn msg + "defaulting to #{default}"
-              value = default
-            else
-              warn msg + "skipping"
-              return expr
-            end
-          end
-
+          raise "ArgumentError", "Invalid value #{value.inspect} passed to expression filter #{@name}" unless valid_value?(value)
           @block.call(expr, value)
         end
       end
 
       class IdentityExpressionFilter < ExpressionFilter
-        def initialize
-        end
-
-        def default?
-          false
-        end
-
-        def apply_filter(expr, _value)
-          return expr
-        end
+        def initialize; end
+        def default?; false; end
+        def apply_filter(expr, _value); expr; end
       end
     end
   end
-end
+end

data/lib/capybara/selector/filters/node_filter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'capybara/selector/filters/base'
 
 module Capybara
@@ -7,18 +8,7 @@ module Capybara
       class NodeFilter < Base
         def matches?(node, value)
           return true if skip?(value)
-
-          if !valid_value?(value)
-            msg = "Invalid value #{value.inspect} passed to filter #{@name} - "
-            if default?
-              warn msg + "defaulting to #{default}"
-              value = default
-            else
-              warn msg + "skipping"
-              return true
-            end
-          end
-
+          raise ArgumentError, "Invalid value #{value.inspect} passed to filter #{@name}" unless valid_value?(value)
           @block.call(node, value)
         end
       end