capybara 3.11.0 → 3.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c349d493d1d6639b40265451f5b357aa7b5d29d279e1095284071fba9bc8a59
-  data.tar.gz: 23350dd400ffd3e11fdda081f12331ab7518b94061fb104355e30cfbee0d9935
+  metadata.gz: 8b3b4d3a612269d9ee165e7ed94e1e62f91c6fd85bcc5c5ae614c25d0c22bd32
+  data.tar.gz: a2bdfa0c2398789bd15d791e3b2d0d03d9c3371033e4f4e4d21e302db845c93f
 SHA512:
-  metadata.gz: caa9124c0465dcc82b15109c4cbd841dbc8e214ff87fd928a712abd6896155c6c8b3be00d0ec09cb1fbbea9da8206773b799766da5fd08ac9bc0a9d36d81dd85
-  data.tar.gz: 18b0c515e7be809183bc26d6d2ce38692561e30760b96a26992d44b96027484ae942f7c25e48b803323ef0534ca616fd20c503ec2cfefbf1da47416eb30b2443
+  metadata.gz: f4815632f5bc14c932e9b5181d68584ac3088f11241e8ee3c19f3ee0a27190f8ad1544b88a532f901eaf79f9ae3c2f721dfca1d2d6d20d098a40438042b9f64a
+  data.tar.gz: eb2765462cdbdda76a4ca5d100b93688029d1ca727c00579c5e9e5d77f26fc4a0fe64bbe3616bb3f89b34e730c337e242b319b2ea606b5287a780f8219ee5b08

data/History.md

@@ -1,3 +1,27 @@
+# Version 3.12.0
+Release date: 2018-11-28
+
+### Added
+
+* Support Ruby 2.6 endless range in Result#[] and query `:between` option
+* Pre-registered headless firefox driver :selenium_headless [Andrew Havens]
+* Selenium driver now defaults to clearing `sessionStorage` and `localStorage`. To disable pass `clear_local_storage: false` and/or `clear_session_storage: false` when creating Capybara::Selenium::Driver instance in your driver registration
+
+### Fixed
+
+* Raise error if only :x or :y are passed as an offset to click methods
+
+### Removed
+
+* Support for RSpec < 3.5
+
+# Version 3.11.1
+Release date: 2018-11-16
+
+### Fixed
+
+* Fixed :link_or_button XPath generation when it has had an expression filter added
+
 # Version 3.11.0
 Release date: 2018-11-14
 

data/README.md

@@ -6,8 +6,7 @@
 [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/jnicklas/capybara?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![SemVer](https://api.dependabot.com/badges/compatibility_score?dependency-name=capybara&package-manager=bundler&version-scheme=semver)](https://dependabot.com/compatibility-score.html?dependency-name=capybara&package-manager=bundler&version-scheme=semver)
 
-**Note** You are viewing the README for the 3.11.0 version of Capybara.
-
+**Note** You are viewing the README for the 3.12.x version of Capybara.
 
 Capybara helps you test web applications by simulating how a real user would
 interact with your app. It is agnostic about the driver running your tests and
@@ -139,7 +138,7 @@ There are also explicit tags for each registered driver set up for you (`@seleni
 
 ## <a name="using-capybara-with-rspec"></a>Using Capybara with RSpec
 
-Load RSpec 3.x support by adding the following line (typically to your
+Load RSpec 3.5+ support by adding the following line (typically to your
 `spec_helper.rb` file):
 
 ```ruby
@@ -394,6 +393,7 @@ and add it to your Gemfile if you're using bundler.
 Capybara pre-registers a number of named drives that use Selenium - they are:
 
   * :selenium                 => Selenium driving Firefox
+  * :selenium_headless        => Selenium driving Firefox in a headless configuration
   * :selenium_chrome          => Selenium driving Chrome
   * :selenium_chrome_headless => Selenium driving Chrome in a headless configuration
 
@@ -404,7 +404,7 @@ to the browsers.  See the section on adding and configuring drivers.
 
 **Note**: drivers which run the server in a different thread may not share the
 same transaction as your tests, causing data not to be shared between your test
-and test server, see "Transactions and database setup" below.
+and test server, see [Transactions and database setup](#transactions-and-database-setup) below.
 
 ### <a name="capybara-webkit"></a>Capybara-webkit
 

data/lib/capybara/node/element.rb

@@ -153,7 +153,9 @@ module Capybara
       #     @option offset [Integer] y  Y coordinate to offset the click location from the top left corner of the element
       # @return [Capybara::Node::Element]  The element
       def click(*keys, wait: nil, **offset)
-        synchronize(wait) { base.click(keys, offset) }
+        raise ArgumentError, 'You must specify both x: and y: for a click offset' if nil ^ offset[:x] ^ offset[:y]
+
+        synchronize(wait) { base.click(Array(keys), offset) }
         self
       end
 
@@ -164,6 +166,8 @@ module Capybara
       # @macro click_modifiers
       # @return [Capybara::Node::Element]  The element
       def right_click(*keys, wait: nil, **offset)
+        raise ArgumentError, 'You must specify both x: and y: for a click offset' if nil ^ offset[:x] ^ offset[:y]
+
         synchronize(wait) { base.right_click(keys, offset) }
         self
       end
@@ -175,6 +179,8 @@ module Capybara
       # @macro click_modifiers
       # @return [Capybara::Node::Element]  The element
       def double_click(*keys, wait: nil, **offset)
+        raise ArgumentError, 'You must specify both x: and y: for a click offset' if nil ^ offset[:x] ^ offset[:y]
+
         synchronize(wait) { base.double_click(keys, offset) }
         self
       end

data/lib/capybara/node/matchers.rb

@@ -546,24 +546,6 @@ module Capybara
         end
       end
 
-      # Deprecated
-      # TODO: remove
-      def refute_selector(*args, &optional_filter_block)
-        warn '`refute_selector` was never meant to be in this scope unless ' \
-             'using minitest.  Either replace with `assert_no_selector` ' \
-             "or require 'capybara/minitest'."
-        assert_no_selector(*args, &optional_filter_block)
-      end
-
-      # Deprecated
-      # TODO: remove
-      def refute_matches_selector(*args, &optional_filter_block)
-        warn '`refute_matches_selector` was never meant to be in this scope unless ' \
-             'using minitest.  Either replace with `assert_not_matches_selector` ' \
-             "or require 'capybara/minitest'."
-        assert_not_matches_selector(*args, &optional_filter_block)
-      end
-
       ##
       #
       # Checks if the current node matches given selector

data/lib/capybara/queries/base_query.rb

@@ -79,7 +79,7 @@ module Capybara
         if count
           message << " #{occurrences count}"
         elsif between
-          message << " between #{between.first} and #{between.last} times"
+          message << " between #{between.first} and #{between.end ? between.last : 'infinite'} times"
         elsif maximum
           message << " at most #{occurrences maximum}"
         elsif minimum

data/lib/capybara/queries/selector_query.rb

@@ -62,13 +62,11 @@ module Capybara
 
       def matches_filters?(node, node_filter_errors = [])
         return true if (@resolved_node&.== node) && options[:allow_self]
-        return false unless matches_locator_filter?(node)
 
-        applied_filters << :system
-        return false unless matches_system_filters?(node)
-
-        applied_filters << :node
-        matches_node_filters?(node, node_filter_errors) && matches_filter_block?(node)
+        matches_locator_filter?(node) &&
+          matches_system_filters?(node) &&
+          matches_node_filters?(node, node_filter_errors) &&
+          matches_filter_block?(node)
       rescue *(node.respond_to?(:session) ? node.session.driver.invalid_element_errors : [])
         false
       end
@@ -93,11 +91,11 @@ module Capybara
         exact = exact? if exact.nil?
         expr = apply_expression_filters(@expression)
         expr = exact ? expr.to_xpath(:exact) : expr.to_s if expr.respond_to?(:to_xpath)
-        filtered_xpath(expr)
+        filtered_expression(expr)
       end
 
       def css
-        filtered_css(apply_expression_filters(@expression))
+        filtered_expression(apply_expression_filters(@expression))
       end
 
       # @api private
@@ -136,12 +134,10 @@ module Capybara
       end
 
       def find_selector(locator)
-        selector = if locator.is_a?(Symbol)
-          Selector.all.fetch(locator) { |sel_type| raise ArgumentError, "Unknown selector type (:#{sel_type})" }
-        else
-          Selector.all.values.find { |sel| sel.match?(locator) }
-        end
-        selector || Selector.all[session_options.default_selector]
+        case locator
+        when Symbol then Selector[locator]
+        else Selector.for(locator)
+        end || Selector[session_options.default_selector]
       end
 
       def find_nodes_by_selector_format(node, exact)
@@ -165,6 +161,8 @@ module Capybara
       end
 
       def matches_node_filters?(node, errors)
+        applied_filters << :node
+
         unapplied_options = options.keys - valid_keys
         @selector.with_filter_errors(errors) do
           node_filters.all? do |filter_name, filter|
@@ -196,7 +194,7 @@ module Capybara
       end
 
       def filter_set(name)
-        ::Capybara::Selector::FilterSet.all[name]
+        ::Capybara::Selector::FilterSet[name]
       end
 
       def node_filters
@@ -235,18 +233,11 @@ module Capybara
         raise ArgumentError, "invalid keys #{invalid_names}, should be one of #{valid_names}"
       end
 
-      def filtered_xpath(expr)
-        expr = "(#{expr})[#{conditions_from_id}]" if use_default_id_filter?
-        expr = "(#{expr})[#{conditions_from_classes}]" if use_default_class_filter?
-        expr
-      end
-
-      def filtered_css(expr)
-        ::Capybara::Selector::CSS.split(expr).map do |sel|
-          sel += conditions_from_id if use_default_id_filter?
-          sel += conditions_from_classes if use_default_class_filter?
-          sel
-        end.join(', ')
+      def filtered_expression(expr)
+        conditions = {}
+        conditions[:id] = options[:id] if use_default_id_filter?
+        conditions[:class] = options[:class] if use_default_class_filter?
+        builder(expr).add_attribute_conditions(conditions)
       end
 
       def use_default_id_filter?
@@ -257,14 +248,6 @@ module Capybara
         options.key?(:class) && !custom_keys.include?(:class)
       end
 
-      def conditions_from_classes
-        builder.class_conditions(options[:class])
-      end
-
-      def conditions_from_id
-        builder.attribute_conditions(id: options[:id])
-      end
-
       def apply_expression_filters(expression)
         unapplied_options = options.keys - valid_keys
         expression_filters.inject(expression) do |expr, (name, ef)|
@@ -307,12 +290,14 @@ module Capybara
       end
 
       def matches_locator_filter?(node)
-        return true if @selector.locator_filter.nil?
+        return true unless @selector.locator_filter
 
-        @selector.locator_filter.call(node, @locator)
+        @selector.locator_filter.matches?(node, @locator, @selector)
       end
 
       def matches_system_filters?(node)
+        applied_filters << :system
+
         matches_id_filter?(node) &&
           matches_class_filter?(node) &&
           matches_text_filter?(node) &&
@@ -374,8 +359,8 @@ module Capybara
         @selector.default_visibility(session_options.ignore_hidden_elements, options)
       end
 
-      def builder
-        selector.builder
+      def builder(expr)
+        selector.builder(expr)
       end
     end
   end

data/lib/capybara/result.rb

@@ -59,7 +59,7 @@ module Capybara
           nil
         end
       when Range
-        idx.max
+        idx.end && idx.max # endless range will have end == nil
       end
 
       if max_idx.nil?
@@ -92,9 +92,9 @@ module Capybara
       end
 
       if between
-        min, max = between.minmax
-        size = load_up_to(max + 1)
-        return between.include?(size) ? 0 : size <=> min
+        min, max = between.min, (between.end && between.max)
+        size = load_up_to(max ? max + 1 : min)
+        return size <=> min unless between.include?(size)
       end
 
       0

data/lib/capybara/selector/builders/css_builder.rb

@@ -6,41 +6,73 @@ module Capybara
   class Selector
     # @api private
     class CSSBuilder
-      class << self
-        def attribute_conditions(attributes)
-          attributes.map do |attribute, value|
-            case value
-            when XPath::Expression
-              raise ArgumentError, "XPath expressions are not supported for the :#{attribute} filter with CSS based selectors"
-            when Regexp
-              Selector::RegexpDisassembler.new(value).substrings.map do |str|
-                "[#{attribute}*='#{str}'#{' i' if value.casefold?}]"
+      def initialize(expression)
+        @expression = expression || ''
+      end
+
+      attr_reader :expression
+
+      def add_attribute_conditions(**attributes)
+        @expression = attributes.inject(expression) do |css, (name, value)|
+          conditions = if name == :class
+            class_conditions(value)
+          elsif value.is_a? Regexp
+            Selector::RegexpDisassembler.new(value).alternated_substrings.map do |strs|
+              strs.map do |str|
+                "[#{name}*='#{str}'#{' i' if value.casefold?}]"
               end.join
-            when true
-              "[#{attribute}]"
-            when false
-              ':not([attribute])'
-            else
-              if attribute == :id
-                "##{::Capybara::Selector::CSS.escape(value)}"
-              else
-                "[#{attribute}='#{value}']"
-              end
             end
-          end.join
+          else
+            [attribute_conditions(name => value)]
+          end
+
+          ::Capybara::Selector::CSS.split(css).map do |sel|
+            next sel if conditions.empty?
+
+            conditions.map { |cond| sel + cond }.join(', ')
+          end.join(', ')
         end
+      end
+
+    private
 
-        def class_conditions(classes)
-          case classes
+      def attribute_conditions(attributes)
+        attributes.map do |attribute, value|
+          case value
           when XPath::Expression
-            raise ArgumentError, 'XPath expressions are not supported for the :class filter with CSS based selectors'
+            raise ArgumentError, "XPath expressions are not supported for the :#{attribute} filter with CSS based selectors"
           when Regexp
-            attribute_conditions(class: classes)
+            Selector::RegexpDisassembler.new(value).substrings.map do |str|
+              "[#{attribute}*='#{str}'#{' i' if value.casefold?}]"
+            end.join
+          when true
+            "[#{attribute}]"
+          when false
+            ':not([attribute])'
           else
-            cls = Array(classes).group_by { |cl| cl.start_with?('!') && !cl.start_with?('!!!') }
-            (cls[false].to_a.map { |cl| ".#{Capybara::Selector::CSS.escape(cl.sub(/^!!/, ''))}" } +
-            cls[true].to_a.map { |cl| ":not(.#{Capybara::Selector::CSS.escape(cl.slice(1..-1))})" }).join
+            if attribute == :id
+              "##{::Capybara::Selector::CSS.escape(value)}"
+            else
+              "[#{attribute}='#{value}']"
+            end
+          end
+        end.join
+      end
+
+      def class_conditions(classes)
+        case classes
+        when XPath::Expression
+          raise ArgumentError, 'XPath expressions are not supported for the :class filter with CSS based selectors'
+        when Regexp
+          Selector::RegexpDisassembler.new(classes).alternated_substrings.map do |strs|
+            strs.map do |str|
+              "[class*='#{str}'#{' i' if classes.casefold?}]"
+            end.join
           end
+        else
+          cls = Array(classes).group_by { |cl| cl.start_with?('!') && !cl.start_with?('!!!') }
+          [(cls[false].to_a.map { |cl| ".#{Capybara::Selector::CSS.escape(cl.sub(/^!!/, ''))}" } +
+          cls[true].to_a.map { |cl| ":not(.#{Capybara::Selector::CSS.escape(cl.slice(1..-1))})" }).join]
         end
       end
     end

data/lib/capybara/selector/builders/xpath_builder.rb

@@ -6,49 +6,64 @@ module Capybara
   class Selector
     # @api private
     class XPathBuilder
-      class << self
-        def attribute_conditions(attributes)
-          attributes.map do |attribute, value|
-            case value
-            when XPath::Expression
-              XPath.attr(attribute)[value]
-            when Regexp
-              XPath.attr(attribute)[regexp_to_xpath_conditions(value)]
-            when true
-              XPath.attr(attribute)
-            when false, nil
-              !XPath.attr(attribute)
-            else
-              XPath.attr(attribute) == value.to_s
-            end
-          end.reduce(:&)
-        end
+      def initialize(expression)
+        @expression = expression || ''
+      end
+
+      attr_reader :expression
 
-        def class_conditions(classes)
-          case classes
-          when XPath::Expression, Regexp
-            attribute_conditions(class: classes)
+      def add_attribute_conditions(**conditions)
+        @expression = conditions.inject(expression) do |xp, (name, value)|
+          conditions = name == :class ? class_conditions(value) : attribute_conditions(name => value)
+          if xp.is_a? XPath::Expression
+            xp[conditions]
           else
-            Array(classes).map do |klass|
-              if klass.start_with?('!') && !klass.start_with?('!!!')
-                !XPath.attr(:class).contains_word(klass.slice(1..-1))
-              else
-                XPath.attr(:class).contains_word(klass.sub(/^!!/, ''))
-              end
-            end.reduce(:&)
+            "(#{xp})[#{conditions}]"
           end
         end
+      end
+
+    private
 
-      private
+      def attribute_conditions(attributes)
+        attributes.map do |attribute, value|
+          case value
+          when XPath::Expression
+            XPath.attr(attribute)[value]
+          when Regexp
+            XPath.attr(attribute)[regexp_to_xpath_conditions(value)]
+          when true
+            XPath.attr(attribute)
+          when false, nil
+            !XPath.attr(attribute)
+          else
+            XPath.attr(attribute) == value.to_s
+          end
+        end.reduce(:&)
+      end
 
-        def regexp_to_xpath_conditions(regexp)
-          condition = XPath.current
-          condition = condition.uppercase if regexp.casefold?
-          Selector::RegexpDisassembler.new(regexp).alternated_substrings.map do |strs|
-            strs.map { |str| condition.contains(str) }.reduce(:&)
-          end.reduce(:|)
+      def class_conditions(classes)
+        case classes
+        when XPath::Expression, Regexp
+          attribute_conditions(class: classes)
+        else
+          Array(classes).map do |klass|
+            if klass.start_with?('!') && !klass.start_with?('!!!')
+              !XPath.attr(:class).contains_word(klass.slice(1..-1))
+            else
+              XPath.attr(:class).contains_word(klass.sub(/^!!/, ''))
+            end
+          end.reduce(:&)
         end
       end
+
+      def regexp_to_xpath_conditions(regexp)
+        condition = XPath.current
+        condition = condition.uppercase if regexp.casefold?
+        Selector::RegexpDisassembler.new(regexp).alternated_substrings.map do |strs|
+          strs.map { |str| condition.contains(str) }.reduce(:&)
+        end.reduce(:|)
+      end
     end
   end
 end

data/lib/capybara/selector/css.rb

@@ -31,22 +31,22 @@ module Capybara
         def split(css)
           selectors = []
           StringIO.open(css.to_s) do |str|
-            selector = ''
+            selector = +''
             while (char = str.getc)
               case char
               when '['
-                selector += parse_square(str)
+                selector << parse_square(str)
               when '('
-                selector += parse_paren(str)
+                selector << parse_paren(str)
               when '"', "'"
-                selector += parse_string(char, str)
+                selector << parse_string(char, str)
               when '\\'
-                selector += char + str.getc
+                selector << char + str.getc
               when ','
                 selectors << selector.strip
-                selector = ''
+                selector.clear
               else
-                selector += char
+                selector << char
               end
             end
             selectors << selector.strip

data/lib/capybara/selector/filter.rb

@@ -2,3 +2,4 @@
 
 require 'capybara/selector/filters/node_filter'
 require 'capybara/selector/filters/expression_filter'
+require 'capybara/selector/filters/locator_filter'

data/lib/capybara/selector/filter_set.rb

@@ -40,9 +40,9 @@ module Capybara
       def description(node_filters: true, expression_filters: true, **options)
         opts = options_with_defaults(options)
         description = +''
-        description += undeclared_descriptions.map { |desc| desc.call(opts).to_s }.join
-        description += expression_filter_descriptions.map { |desc| desc.call(opts).to_s }.join if expression_filters
-        description += node_filter_descriptions.map { |desc| desc.call(opts).to_s }.join if node_filters
+        description << undeclared_descriptions.map { |desc| desc.call(opts).to_s }.join
+        description << expression_filter_descriptions.map { |desc| desc.call(opts).to_s }.join if expression_filters
+        description << node_filter_descriptions.map { |desc| desc.call(opts).to_s }.join if node_filters
         description
       end
 
@@ -52,15 +52,16 @@ module Capybara
       end
 
       def import(name, filters = nil)
-        f_set = self.class.all[name]
         filter_selector = filters.nil? ? ->(*) { true } : ->(filter_name, _) { filters.include? filter_name }
 
-        expression_filters.merge!(f_set.expression_filters.select(&filter_selector))
-        node_filters.merge!(f_set.node_filters.select(&filter_selector))
-
-        f_set.undeclared_descriptions.each { |desc| describe(&desc) }
-        f_set.expression_filter_descriptions.each { |desc| describe(:expression_filters, &desc) }
-        f_set.node_filter_descriptions.each { |desc| describe(:node_filters, &desc) }
+        self.class[name].tap do |f_set|
+          expression_filters.merge!(f_set.expression_filters.select(&filter_selector))
+          node_filters.merge!(f_set.node_filters.select(&filter_selector))
+          f_set.undeclared_descriptions.each { |desc| describe(&desc) }
+          f_set.expression_filter_descriptions.each { |desc| describe(:expression_filters, &desc) }
+          f_set.node_filter_descriptions.each { |desc| describe(:node_filters, &desc) }
+        end
+        self
       end
 
       class << self
@@ -68,6 +69,10 @@ module Capybara
           @filter_sets ||= {} # rubocop:disable Naming/MemoizedInstanceVariableName
         end
 
+        def [](name)
+          all.fetch(name.to_sym) { |set_name| raise ArgumentError, "Unknown filter set (:#{set_name})" }
+        end
+
         def add(name, &block)
           all[name.to_sym] = FilterSet.new(name.to_sym, &block)
         end
@@ -107,11 +112,8 @@ module Capybara
         types.each { |type| options[type] = true }
         raise 'ArgumentError', ':default option is not supported for filters with a :matcher option' if matcher && options[:default]
 
-        if filter_class <= Filters::ExpressionFilter
-          @expression_filters[name] = filter_class.new(name, matcher, block, options)
-        else
-          @node_filters[name] = filter_class.new(name, matcher, block, options)
-        end
+        filter = filter_class.new(name, matcher, block, options)
+        (filter_class <= Filters::ExpressionFilter ? @expression_filters : @node_filters)[name] = filter
       end
     end
   end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'capybara/selector/filters/base'
+
+module Capybara
+  class Selector
+    module Filters
+      class LocatorFilter < NodeFilter
+        def initialize(block, **options)
+          super(nil, nil, block, options)
+        end
+
+        def matches?(node, value, context = nil)
+          super(node, nil, value, context)
+        end
+      end
+    end
+  end
+end