capybara 3.12.0 → 3.13.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b3b4d3a612269d9ee165e7ed94e1e62f91c6fd85bcc5c5ae614c25d0c22bd32
-  data.tar.gz: a2bdfa0c2398789bd15d791e3b2d0d03d9c3371033e4f4e4d21e302db845c93f
+  metadata.gz: 535d547d5a25d769afa754066f54cc0d873a2997ebfbc1ed12dd418d80cbb3f0
+  data.tar.gz: c576db6d285f055bfc3e030ff4973f7c3fecaf54bff9e74c64070408a2a579ac
 SHA512:
-  metadata.gz: f4815632f5bc14c932e9b5181d68584ac3088f11241e8ee3c19f3ee0a27190f8ad1544b88a532f901eaf79f9ae3c2f721dfca1d2d6d20d098a40438042b9f64a
-  data.tar.gz: eb2765462cdbdda76a4ca5d100b93688029d1ca727c00579c5e9e5d77f26fc4a0fe64bbe3616bb3f89b34e730c337e242b319b2ea606b5287a780f8219ee5b08
+  metadata.gz: 37be4e1475274ec82574b4839eb7a06b4db262ebacbd6534669561b92b4a87fcbfc73d57d058657a58b800ec95b86804d16ea663beb4407c6cb9247af100e283
+  data.tar.gz: b6b5996ff037790502bb89783f48441c6288e5241b967739a463dcf339c17bc1d3a2c5c4226bf7ab3eb502b82e56079347c96c5a55737edcd84477a85a4fa92e

data/History.md

@@ -1,3 +1,30 @@
+# Version 3.13.2
+Release date: 2019-01-24
+
+### Fixed
+
+* Remove extraneous output
+
+# Version 3.13.1
+Release date: 2019-01-24
+
+### Fixed
+
+* Only use Selenium visibility optimization when JS atom is available - Issue #2151
+
+# Version 3.13.0
+Release date: 2019-01-23
+
+### Added
+
+* Session#quit added
+* #scroll_to added to allow scrolling page/elements to specified locations
+* Speed optimizations around multiple element location and path generation when using the Selenium driver
+* Support for locator type checking in custom selectors
+* Allow configuration of gumbo use - defaults to off
+* `assert_style`/`has_style`/`have_style` depreacted in favor of `assert_matches_style`/`matches_styles?`/`match_style`
+* :style filter added to selectors
+
 # Version 3.12.0
 Release date: 2018-11-28
 

data/README.md

@@ -6,7 +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.12.x version of Capybara.
+**Note** You are viewing the README for the version 3.13.x 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
@@ -35,6 +35,7 @@ GitHub): http://groups.google.com/group/ruby-capybara
     - [Selecting the Driver](#selecting-the-driver)
     - [RackTest](#racktest)
     - [Selenium](#selenium)
+    - [Apparition](#apparition)
     - [Capybara-webkit](#capybara-webkit)
     - [Poltergeist](#poltergeist)
 - [The DSL](#the-dsl)
@@ -217,7 +218,7 @@ feature "Signing in" do
 end
 ```
 
-`feature` is in fact just an alias for `describe ..., type:> :feature`,
+`feature` is in fact just an alias for `describe ..., type: :feature`,
 `background` is an alias for `before`, `scenario` for `it`, and
 `given`/`given!` aliases for `let`/`let!`, respectively.
 
@@ -406,6 +407,15 @@ to the browsers.  See the section on adding and configuring drivers.
 same transaction as your tests, causing data not to be shared between your test
 and test server, see [Transactions and database setup](#transactions-and-database-setup) below.
 
+### <a name="apparition"></a>Apparition
+
+The [apparition driver](https://github.com/twalpole/apparition) in a new driver thatallows you to run tests using Chrome in a headless
+or headed configuration. It attempts to provide backwards compatibility with the [Poltergeist driver API](https://github.com/teampoltergeist/poltergeist)
+while allowing for the use of modern JS/CSS. It uses CDP to communicate with Chrome, thereby obviating the need for chromedriver.
+A compatibility layer for capybara-webkit is planned, although has not yet been started. This driver is being developed by the
+maintainer of Capybara and will attempt to keep up to date with new Capybara releases. It will probably be moved into the
+teamcapybara repo once completely stable.
+
 ### <a name="capybara-webkit"></a>Capybara-webkit
 
 Note: `capybara-webkit` depends on QtWebkit which went EOL quite some time ago. There has been an attempt to revive the project but `capybara-webkit` is not yet (AFAIK) compatible with the revived version of QtWebKit (could be a good OSS project for someone) and as such is still limited to an old version of QtWebKit.  This means its support for modern JS and CSS is severely limited.
@@ -428,7 +438,7 @@ Capybara.javascript_driver = :webkit
 
 ### <a name="poltergeist"></a>Poltergeist
 
-Note: `poltergeist` depends on PhantomJS for which active development ended quite some time ago (2.1.1). As such it is roughly equivalent to a 6-7 year old version of Safari, meaning lack of support for modern JS And CSS. If any effort to update PhantomJS succeeds in the future this situation could change.
+Note: `poltergeist` depends on PhantomJS for which active development ended quite some time ago (2.1.1). As such it is roughly equivalent to a 6-7 year old version of Safari, meaning lack of support for modern JS and CSS. If any effort to update PhantomJS succeeds in the future this situation could change.
 
 [Poltergeist](https://github.com/teampoltergeist/poltergeist) is another
 headless driver which integrates Capybara with

data/lib/capybara/config.rb

@@ -7,12 +7,14 @@ module Capybara
   class Config
     extend Forwardable
 
-    OPTIONS = %i[app reuse_server threadsafe default_wait_time server default_driver javascript_driver].freeze
+    OPTIONS = %i[app reuse_server threadsafe default_wait_time server
+                 default_driver javascript_driver allow_gumbo].freeze
 
     attr_accessor :app
     attr_reader :reuse_server, :threadsafe
     attr_reader :session_options
     attr_writer :default_driver, :javascript_driver
+    attr_accessor :allow_gumbo
 
     SessionConfig::OPTIONS.each do |method|
       def_delegators :session_options, method, "#{method}="

data/lib/capybara/driver/base.rb

@@ -15,11 +15,11 @@ class Capybara::Driver::Base
     raise NotImplementedError
   end
 
-  def find_xpath(query)
+  def find_xpath(query, **options)
     raise NotImplementedError
   end
 
-  def find_css(query)
+  def find_css(query, **options)
     raise NotImplementedError
   end
 

data/lib/capybara/driver/node.rb

@@ -3,11 +3,12 @@
 module Capybara
   module Driver
     class Node
-      attr_reader :driver, :native
+      attr_reader :driver, :native, :initial_cache
 
-      def initialize(driver, native)
+      def initialize(driver, native, initial_cache = {})
         @driver = driver
         @native = native
+        @initial_cache = initial_cache
       end
 
       def all_text
@@ -68,6 +69,14 @@ module Capybara
         raise NotImplementedError
       end
 
+      def scroll_by(x, y)
+        raise NotImplementedError
+      end
+
+      def scroll_to(element, alignment, position = nil)
+        raise NotImplementedError
+      end
+
       def tag_name
         raise NotImplementedError
       end

data/lib/capybara/minitest/spec.rb

@@ -17,7 +17,7 @@ module Capybara
       end + [%w[assert_all_of_selectors must_have_all_of_selectors],
              %w[assert_none_of_selectors must_have_none_of_selectors],
              %w[assert_any_of_selectors must_have_any_of_selectors],
-             %w[assert_style must_have_style]] +
+             %w[assert_matches_style must_match_style]] +
       %w[selector xpath css].flat_map do |assertion|
         [%W[assert_matches_#{assertion} must_match_#{assertion}],
          %W[refute_matches_#{assertion} wont_match_#{assertion}]]
@@ -36,6 +36,13 @@ module Capybara
       end
       # rubocop:enable Style/MultilineBlockChain
 
+      ##
+      # @deprecated
+      def must_have_style(*args, &block)
+        warn 'must_have_style is deprecated, please use must_match_style'
+        must_match_style(*args, &block)
+      end
+
       ##
       # Expectation that there is xpath
       #
@@ -169,8 +176,8 @@ module Capybara
       ##
       # Expectation that element has style
       #
-      # @!method must_have_style
-      #   see {Capybara::Node::Matchers#assert_style}
+      # @!method must_match_style
+      #   see {Capybara::Node::Matchers#assert_matches_style}
     end
   end
 end

data/lib/capybara/minitest.rb

@@ -83,10 +83,10 @@ module Capybara
 
       ## Assert element has the provided CSS styles
       #
-      # @!method assert_style
-      #   see {Capybara::Node::Matchers#assert_style}
+      # @!method assert_matches_style
+      #   see {Capybara::Node::Matchers#assert_matches_style}
 
-      %w[selector no_selector style
+      %w[selector no_selector matches_style
          all_of_selectors none_of_selectors any_of_selectors
          matches_selector not_matches_selector].each do |assertion_name|
         class_eval <<-ASSERTION, __FILE__, __LINE__ + 1

data/lib/capybara/node/actions.rb

@@ -195,6 +195,8 @@ module Capybara
       #
       # @return [Capybara::Node::Element]  The option element selected
       def select(value = nil, from: nil, **options)
+        raise ArgumentError, 'The :from option does not take an element' if from.is_a? Capybara::Node::Element
+
         el = from ? find_select_or_datalist_input(from, options) : self
 
         if el.respond_to?(:tag_name) && (el.tag_name == 'input')
@@ -221,6 +223,8 @@ module Capybara
       #
       # @return [Capybara::Node::Element]  The option element unselected
       def unselect(value = nil, from: nil, **options)
+        raise ArgumentError, 'The :from option does not take an element' if from.is_a? Capybara::Node::Element
+
         scope = from ? find(:select, from, options) : self
         scope.find(:option, value, options).unselect_option
       end

data/lib/capybara/node/base.rb

@@ -86,7 +86,7 @@ module Capybara
           raise err unless driver.wait? && catch_error?(err, errors)
           raise err if timer.expired?
 
-          sleep(0.05)
+          sleep(0.01)
           reload if session_options.automatic_reload
           retry
         ensure
@@ -95,13 +95,21 @@ module Capybara
       end
 
       # @api private
-      def find_css(css)
-        base.find_css(css)
+      def find_css(css, **options)
+        if base.method(:find_css).arity != 1
+          base.find_css(css, **options)
+        else
+          base.find_css(css)
+        end
       end
 
       # @api private
-      def find_xpath(xpath)
-        base.find_xpath(xpath)
+      def find_xpath(xpath, **options)
+        if base.method(:find_xpath).arity != 1
+          base.find_xpath(xpath, **options)
+        else
+          base.find_xpath(xpath)
+        end
       end
 
       # @api private

data/lib/capybara/node/document.rb

@@ -31,6 +31,18 @@ module Capybara
       def title
         session.driver.title
       end
+
+      def execute_script(*args)
+        find(:xpath, '/html').execute_script(*args)
+      end
+
+      def evaluate_script(*args)
+        find(:xpath, '/html').evaluate_script(*args)
+      end
+
+      def scroll_to(*args)
+        find(:xpath, '//body').scroll_to(*args)
+      end
     end
   end
 end

data/lib/capybara/node/element.rb

@@ -381,6 +381,38 @@ module Capybara
         self
       end
 
+      ##
+      #
+      # Scroll the page or element
+      #
+      # Scroll the page or element to its top, bottom or middle
+      # @overload scroll_to(position, offset: [0,0])
+      #   @param [:top, :bottom, :center, :current] position
+      #   @param :offset
+      #
+      # Scroll the page or current element until the given element is aligned at the top, bottom, or center of it
+      # @overload scroll_to(element, align: :top)
+      #   @param [Capybara::Node::Element] element   The element to be scrolled into view
+      #   @param [:top, :bottom, :center] :align Where to align the element being scrolled into view with relation to the current page/element if possible
+      #
+      # @overload scroll_to(x,y)
+      #   @param [Integer] x    Horizontal scroll offset
+      #   @param [Integer] y    Vertical scroll offset
+      #
+      # @return [Capybara::Node::Element]  The element
+      def scroll_to(pos_or_el_or_x, y = nil, align: :top, offset: nil)
+        case pos_or_el_or_x
+        when Symbol
+          synchronize { base.scroll_to(nil, pos_or_el_or_x) } unless pos_or_el_or_x == :current
+        when Capybara::Node::Element
+          synchronize { base.scroll_to(pos_or_el_or_x.base, align) }
+        else
+          synchronize { base.scroll_to(nil, nil, [pos_or_el_or_x, y]) }
+        end
+        synchronize { base.scroll_by(*offset) } unless offset.nil?
+        self
+      end
+
       ##
       #
       # Execute the given JS in the context of the element not returning a result. This is useful for scripts that return
@@ -454,6 +486,11 @@ module Capybara
         %(Obsolete #<Capybara::Node::Element>)
       end
 
+      # @api private
+      def initial_cache
+        base.respond_to?(:initial_cache) ? base.initial_cache : {}
+      end
+
       STYLE_SCRIPT = <<~JS
         (function(){
           var s = window.getComputedStyle(this);

data/lib/capybara/node/finders.rb

@@ -36,6 +36,7 @@ module Capybara
       #                                            + Absence of a class can be checked by prefixing the class name with !
       #                                            + If you need to check for existence of a class name that starts with ! then prefix with !!
       #                                            + ```class:['a', '!b', '!!!c'] # limit to elements with class 'a' and '!c' but not class 'b'```
+      #   @option options [String, Regexp, Hash] style  Only find elements with matching style. String and Regexp will be checked against text of the elements `style` attribute, while a Hash will be compared against the elements full style
       #   @option options [Boolean] exact            Control whether `is` expressions in the given XPath match exactly or partially
       # @option options [Symbol] match        The matching strategy to use.
       #

data/lib/capybara/node/matchers.rb

@@ -56,13 +56,21 @@ module Capybara
       #
       # Checks if a an element has the specified CSS styles
       #
-      #     element.has_style?( 'color' => 'rgb(0,0,255)', 'font-size' => /px/ )
+      #     element.matches_style?( 'color' => 'rgb(0,0,255)', 'font-size' => /px/ )
       #
       # @param styles [Hash]
       # @return [Boolean]                       If the styles match
       #
+      def matches_style?(styles, **options)
+        make_predicate(options) { assert_matches_style(styles, options) }
+      end
+
+      ##
+      # @deprecated
+      #
       def has_style?(styles, **options)
-        make_predicate(options) { assert_style(styles, options) }
+        warn 'DEPRECATED: has_style? is deprecated, please use matches_style?'
+        matches_style?(styles, **options)
       end
 
       ##
@@ -108,12 +116,12 @@ module Capybara
       #
       # Asserts that an element has the specified CSS styles
       #
-      #     element.assert_style( 'color' => 'rgb(0,0,255)', 'font-size' => /px/ )
+      #     element.assert_matches_style( 'color' => 'rgb(0,0,255)', 'font-size' => /px/ )
       #
       # @param styles [Hash]
       # @raise [Capybara::ExpectationNotMet]    If the element doesn't have the specified styles
       #
-      def assert_style(styles, **options)
+      def assert_matches_style(styles, **options)
         query_args = _set_query_session_options(styles, options)
         query = Capybara::Queries::StyleQuery.new(*query_args)
         synchronize(query.wait) do
@@ -122,6 +130,13 @@ module Capybara
         true
       end
 
+      ##
+      # @deprecated
+      def assert_style(styles, **options)
+        warn 'assert_style is deprecated, please use assert_matches_style instead'
+        assert_matches_style(styles, **options)
+      end
+
       # Asserts that all of the provided selectors are present on the given page
       # or descendants of the current node.  If options are provided, the assertion
       # will check that each locator is present with those options as well (other than :wait).

data/lib/capybara/node/simple.rb

@@ -164,12 +164,12 @@ module Capybara
       end
 
       # @api private
-      def find_css(css)
+      def find_css(css, **_options)
         native.css(css)
       end
 
       # @api private
-      def find_xpath(xpath)
+      def find_xpath(xpath, **_options)
         native.xpath(xpath)
       end
 
@@ -178,6 +178,11 @@ module Capybara
         Capybara.session_options
       end
 
+      # @api private
+      def initial_cache
+        {}
+      end
+
     private
 
       def option_value(option)

data/lib/capybara/queries/selector_query.rb

@@ -4,7 +4,7 @@ module Capybara
   module Queries
     class SelectorQuery < Queries::BaseQuery
       attr_reader :expression, :selector, :locator, :options
-      VALID_KEYS = COUNT_KEYS + %i[text id class visible exact exact_text normalize_ws match wait filter_set]
+      VALID_KEYS = COUNT_KEYS + %i[text id class style visible exact exact_text normalize_ws match wait filter_set]
       VALID_MATCH = %i[first smart prefer_exact one].freeze
 
       def initialize(*args,
@@ -14,6 +14,7 @@ module Capybara
                      **options,
                      &filter_block)
         @resolved_node = nil
+        @resolved_count = 0
         @options = options.dup
         super(@options)
         self.session_options = session_options
@@ -50,9 +51,24 @@ module Capybara
         end
         desc << " with id #{options[:id]}" if options[:id]
         desc << " with classes [#{Array(options[:class]).join(',')}]" if options[:class]
+        desc << case options[:style]
+        when String
+          " with style attribute #{options[:style].inspect}"
+        when Regexp
+          " with style attribute matching #{options[:style].inspect}"
+        when Hash
+          " with styles #{options[:style].inspect}"
+        else ''
+        end
         desc << selector.description(node_filters: show_for[:node], **options)
         desc << ' that also matches the custom filter block' if @filter_block && show_for[:node]
         desc << " within #{@resolved_node.inspect}" if describe_within?
+        if locator.is_a?(String) && locator.start_with?('#', './/', '//')
+          unless selector.raw_locator?
+            desc << "\nNote: It appears you may be passing a CSS selector or XPath expression rather than a locator. " \
+                    "Please see the documentation for acceptable locator values.\n\n"
+          end
+        end
         desc
       end
 
@@ -91,7 +107,9 @@ 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_expression(expr)
+        expr = filtered_expression(expr)
+        expr = "(#{expr})[#{xpath_text_conditions}]" if try_text_match_in_expression?
+        expr
       end
 
       def css
@@ -102,6 +120,7 @@ module Capybara
       def resolve_for(node, exact = nil)
         applied_filters.clear
         @resolved_node = node
+        @resolved_count += 1
         node.synchronize do
           children = find_nodes_by_selector_format(node, exact).map(&method(:to_element))
           Capybara::Result.new(children, self)
@@ -123,6 +142,26 @@ module Capybara
 
     private
 
+      def text_fragments
+        text = (options[:text] || options[:exact_text])
+        text.is_a?(String) ? text.split : []
+      end
+
+      def xpath_text_conditions
+        (options[:text] || options[:exact_text]).split.map { |txt| XPath.contains(txt) }.reduce(&:&)
+      end
+
+      def try_text_match_in_expression?
+        first_try? &&
+          (options[:text] || options[:exact_text]).is_a?(String) &&
+          @resolved_node&.respond_to?(:session) &&
+          @resolved_node.session.driver.wait?
+      end
+
+      def first_try?
+        @resolved_count == 1
+      end
+
       def show_for_stage(only_applied)
         lambda do |stage = :any|
           !only_applied || (stage == :any ? applied_filters.any? : applied_filters.include?(stage))
@@ -141,10 +180,25 @@ module Capybara
       end
 
       def find_nodes_by_selector_format(node, exact)
+        hints = {}
+        hints[:uses_visibility] = true unless visible == :all
+        hints[:texts] = text_fragments unless selector.format == :xpath
+        hints[:styles] = options[:style] if use_default_style_filter?
+
         if selector.format == :css
-          node.find_css(css)
+          if node.method(:find_css).arity != 1
+            node.find_css(css, **hints)
+          else
+            node.find_css(css)
+          end
+        elsif selector.format == :xpath
+          if node.method(:find_xpath).arity != 1
+            node.find_xpath(xpath(exact), **hints)
+          else
+            node.find_xpath(xpath(exact))
+          end
         else
-          node.find_xpath(xpath(exact))
+          raise ArgumentError, "Unknown format: #{selector.format}"
         end
       end
 
@@ -237,6 +291,7 @@ module Capybara
         conditions = {}
         conditions[:id] = options[:id] if use_default_id_filter?
         conditions[:class] = options[:class] if use_default_class_filter?
+        conditions[:style] = options[:style] if use_default_style_filter? && !options[:style].is_a?(Hash)
         builder(expr).add_attribute_conditions(conditions)
       end
 
@@ -248,6 +303,10 @@ module Capybara
         options.key?(:class) && !custom_keys.include?(:class)
       end
 
+      def use_default_style_filter?
+        options.key?(:style) && !custom_keys.include?(:style)
+      end
+
       def apply_expression_filters(expression)
         unapplied_options = options.keys - valid_keys
         expression_filters.inject(expression) do |expr, (name, ef)|
@@ -298,11 +357,12 @@ module Capybara
       def matches_system_filters?(node)
         applied_filters << :system
 
-        matches_id_filter?(node) &&
+        matches_visible_filter?(node) &&
+          matches_id_filter?(node) &&
           matches_class_filter?(node) &&
+          matches_style_filter?(node) &&
           matches_text_filter?(node) &&
-          matches_exact_text_filter?(node) &&
-          matches_visible_filter?(node)
+          matches_exact_text_filter?(node)
       end
 
       def matches_id_filter?(node)
@@ -317,6 +377,28 @@ module Capybara
         node[:class] =~ options[:class]
       end
 
+      def matches_style_filter?(node)
+        case options[:style]
+        when String, nil
+          true
+        when Regexp
+          node[:style] =~ options[:style]
+        when Hash
+          matches_style?(node, options[:style])
+        end
+      end
+
+      def matches_style?(node, styles)
+        @actual_styles = node.initial_cache[:style] || node.style(*styles.keys)
+        styles.all? do |style, value|
+          if value.is_a? Regexp
+            @actual_styles[style.to_s] =~ value
+          else
+            @actual_styles[style.to_s] == value
+          end
+        end
+      end
+
       def matches_text_filter?(node)
         value = options[:text]
         return true unless value
@@ -334,8 +416,10 @@ module Capybara
 
       def matches_visible_filter?(node)
         case visible
-        when :visible then node.visible?
-        when :hidden then !node.visible?
+        when :visible then
+          node.initial_cache[:visible] || (node.initial_cache[:visible].nil? && node.visible?)
+        when :hidden then
+          (node.initial_cache[:visible] == false) || (node.initial_cache[:visbile].nil? && !node.visible?)
         else true
         end
       end

data/lib/capybara/rspec/matchers/become_closed.rb

@@ -15,7 +15,7 @@ module Capybara
           while window.exists?
             return false if timer.expired?
 
-            sleep 0.05
+            sleep 0.01
           end
           true
         end

data/lib/capybara/rspec/matchers/match_style.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'capybara/rspec/matchers/base'
+
+module Capybara
+  module RSpecMatchers
+    module Matchers
+      class MatchStyle < WrappedElementMatcher
+        def element_matches?(el)
+          el.assert_matches_style(*@args)
+        end
+
+        def does_not_match?(_actual)
+          raise ArgumentError, 'The match_style matcher does not support use with not_to/should_not'
+        end
+
+        def description
+          'match style'
+        end
+      end
+    end
+  end
+end
+
+module Capybara
+  module RSpecMatchers
+    module Matchers
+      ##
+      # @deprecated
+      class HaveStyle < MatchStyle
+        def initialize(*args, &filter_block)
+          warn 'HaveStyle matcher is deprecated, please use the MatchStyle matcher instead'
+          super
+        end
+      end
+    end
+  end
+end