capybara 3.8.0 → 3.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 814367062843328d421eb8c9db0476cabe5a16405866951855507dd63250bfb9
-  data.tar.gz: 2b6605e124b8eed5d4efbc7f2e06d56dcf2ddaa8775d2ec7f42b18aca4144f3a
+  metadata.gz: 42a9311d8f3e7670a90f5851cc9927db169022d550e1c9b2a086900145b7ad18
+  data.tar.gz: 8159deadf9826514634c55f9744d2b8f18a910434d71f66870eb299f6c5980ff
 SHA512:
-  metadata.gz: 76d6d964d8e204497e9f57b61e96ecf32631325c6c4b600ead18009817f45e324f241520d134881bfa62bba754d820f5e1d91710e4c78ca98ccdd06325a206fb
-  data.tar.gz: ee215bc20878dcce34e1df44f2081e3867528358bd1c7cae542b5996e945ca1f6c16decba834ec3c13bd46052873c6988ef7c141674648eae8f5894fec405f38
+  metadata.gz: 8d8256a0c4bc0ca9586d65aec40d4814c060226a7902f5122271d4c9e22b63eec1568c81315d327e02873d732062beef6a0c01d0a50df9d49e14fcd0189084c0
+  data.tar.gz: a86ce539c90c9fbaea0ac8165bbf6f1b66ee8fa4589c129c366d88730cb1881616a3260c3a710b546c0e833aa708de8791326cbaa9c5ffe5f8875ce249c779cd

data/History.md

@@ -1,9 +1,33 @@
+# Version 3.9.0
+Release date: 2018-10-03
+
+### Added
+
+* Selenium with Chrome removes all cookies at session reset instead of just cookies from current domain if possible
+* Support for Regexp for system :id and :class filters where possible
+* `using_session` now accepts a session object as well as the name of the session for users who  manually manage sessions
+* The `:field` selector will now find `type = "hidden"` fields if the `type: "hidden"` filter option is provided
+
+# Version 3.8.2
+Release date: 2018-09-26
+
+### Fixed
+
+* Fixed negated class selector option - Issue #2103
+
+# Version 3.8.1
+Release date: 2018-09-22
+
+### Fixed
+
+* Filling in of date fields with a string when using selenium chrome regression [Micah Geisel]
+
 # Version 3.8.0
 Release date: 2018-09-20
 
 ### Added
 
-* Workaround gecodriver 0.22 issue with undefined pause durations
+* Workaround geckodriver 0.22 issue with undefined pause durations
 * :element selector ignores XML namespaces
 
 ### Fixed

data/lib/capybara/config.rb

@@ -27,6 +27,7 @@ module Capybara
 
     def threadsafe=(bool)
       raise 'Threadsafe setting cannot be changed once a session is created' if (bool != threadsafe) && Session.instance_created?
+
       @threadsafe = bool
     end
 

data/lib/capybara/dsl.rb

@@ -18,8 +18,8 @@ module Capybara
     #
     # Shortcut to working in a different session.
     #
-    def using_session(name, &block)
-      Capybara.using_session(name, &block)
+    def using_session(name_or_session, &block)
+      Capybara.using_session(name_or_session, &block)
     end
 
     # Shortcut to using a different wait time.

data/lib/capybara/helpers.rb

@@ -87,6 +87,7 @@ module Capybara
 
       def expired?
         raise Capybara::FrozenInTime, 'Time appears to be frozen. Capybara does not work with libraries which freeze time, consider using time travelling instead' if stalled?
+
         current - @start >= @expire_in
       end
 

data/lib/capybara/node/actions.rb

@@ -274,6 +274,7 @@ module Capybara
             find(:select, from, options)
           rescue Capybara::ElementNotFound => select_error
             raise if %i[selected with_selected multiple].any? { |option| options.key?(option) }
+
             begin
               find(:datalist_input, from, options)
             rescue Capybara::ElementNotFound => dlinput_error
@@ -287,6 +288,7 @@ module Capybara
         datalist_options = input.evaluate_script(DATALIST_OPTIONS_SCRIPT)
         option = datalist_options.find { |opt| opt.values_at('value', 'label').include?(value) }
         raise ::Capybara::ElementNotFound, %(Unable to find datalist option "#{value}") unless option
+
         input.set(option['value'])
       rescue ::Capybara::NotSupportedByDriverError
         # Implement for drivers that don't support JS
@@ -299,6 +301,7 @@ module Capybara
         visible_css = { opacity: 1, display: 'block', visibility: 'visible' } if visible_css == true
         _update_style(element, visible_css)
         raise ExpectationNotMet, 'The style changes in :make_visible did not make the file input visible' unless element.visible?
+
         begin
           yield element
         ensure
@@ -326,6 +329,7 @@ module Capybara
             el.set(checked)
           rescue StandardError => err
             raise unless allow_label_click && catch_error?(err)
+
             begin
               el ||= find(selector, locator, options.merge(visible: :all))
               el.session.find(:label, for: el, visible: true).click unless el.checked? == checked

data/lib/capybara/node/base.rb

@@ -84,6 +84,7 @@ module Capybara
           session.raise_server_error!
           raise err unless driver.wait? && catch_error?(err, errors)
           raise err if timer.expired?
+
           sleep(0.05)
           reload if session_options.automatic_reload
           retry

data/lib/capybara/node/element.rb

@@ -84,6 +84,7 @@ module Capybara
       def style(*styles)
         styles = styles.flatten.map(&:to_s)
         raise ArgumentError, 'You must specify at least one CSS style' if styles.empty?
+
         begin
           synchronize { base.style(styles) }
         rescue NotImplementedError => err
@@ -113,6 +114,7 @@ module Capybara
       # @return [Capybara::Node::Element]  The element
       def set(value, **options)
         raise Capybara::ReadOnlyElementError, "Attempt to set readonly element with value: #{value}" if readonly?
+
         options = session_options.default_set_options.to_h.merge(options)
         synchronize { base.set(value, options) }
         self
@@ -442,6 +444,7 @@ module Capybara
         %(#<Capybara::Node::Element tag="#{base.tag_name}">)
       rescue StandardError => err
         raise unless session.driver.invalid_element_errors.any? { |et| err.is_a?(et) }
+
         %(Obsolete #<Capybara::Node::Element>)
       end
 

data/lib/capybara/node/finders.rb

@@ -252,10 +252,12 @@ module Capybara
           synchronize(query.wait) do
             result = query.resolve_for(self)
             raise Capybara::ExpectationNotMet, result.failure_message unless result.matches_count?
+
             result
           end
         rescue Capybara::ExpectationNotMet
           raise if minimum_specified || (result.compare_count == 1)
+
           Result.new([], nil)
         end
       end

data/lib/capybara/node/simple.rb

@@ -182,6 +182,7 @@ module Capybara
 
       def option_value(option)
         return nil if option.nil?
+
         option[:value] || option.content
       end
     end

data/lib/capybara/queries/base_query.rb

@@ -51,6 +51,7 @@ module Capybara
         return false if options[:maximum] && (Integer(options[:maximum]) < count)
         return false if options[:minimum] && (Integer(options[:minimum]) > count)
         return false if options[:between] && !options[:between].include?(count)
+
         true
       end
 

data/lib/capybara/queries/match_query.rb

@@ -14,6 +14,7 @@ module Capybara
         unless invalid_options.empty?
           raise ArgumentError, "Match queries don't support quantity options. Invalid keys - #{invalid_options.join(', ')}"
         end
+
         super
       end
 

data/lib/capybara/queries/selector_query.rb

@@ -59,8 +59,11 @@ module Capybara
 
       def matches_filters?(node)
         return true if (@resolved_node&.== node) && options[:allow_self]
+
         @applied_filters ||= :system
+        return false unless matches_id_filter?(node) && matches_class_filter?(node)
         return false unless matches_text_filter?(node) && matches_exact_text_filter?(node) && matches_visible_filter?(node)
+
         @applied_filters = :node
         matches_node_filters?(node) && matches_filter_block?(node)
       rescue *(node.respond_to?(:session) ? node.session.driver.invalid_element_errors : [])
@@ -68,7 +71,7 @@ module Capybara
       end
 
       def visible
-        case (vis = options.fetch(:visible) { @selector.default_visibility(session_options.ignore_hidden_elements) })
+        case (vis = options.fetch(:visible) { @selector.default_visibility(session_options.ignore_hidden_elements, options) })
         when true then :visible
         when false then :all
         else vis
@@ -174,6 +177,7 @@ module Capybara
 
       def matches_filter_block?(node)
         return true unless @filter_block
+
         if node.respond_to?(:session)
           node.session.using_wait_time(0) { @filter_block.call(node) }
         else
@@ -203,6 +207,7 @@ module Capybara
         unless VALID_MATCH.include?(match)
           raise ArgumentError, "invalid option #{match.inspect} for :match, should be one of #{VALID_MATCH.map(&:inspect).join(', ')}"
         end
+
         unhandled_options = @options.keys.reject do |option_name|
           valid_keys.include?(option_name) ||
             expression_filters.any? { |_name, ef| ef.handles_option? option_name } ||
@@ -210,28 +215,22 @@ module Capybara
         end
 
         return if unhandled_options.empty?
+
         invalid_names = unhandled_options.map(&:inspect).join(', ')
         valid_names = (valid_keys - [:allow_self]).map(&:inspect).join(', ')
         raise ArgumentError, "invalid keys #{invalid_names}, should be one of #{valid_names}"
       end
 
       def filtered_xpath(expr)
-        if use_default_id_filter?
-          id_xpath = if options[:id].is_a? XPath::Expression
-            XPath.attr(:id)[options[:id]]
-          else
-            XPath.attr(:id) == options[:id]
-          end
-          expr = "(#{expr})[#{id_xpath}]"
-        end
-        expr = "(#{expr})[#{xpath_from_classes}]" if use_default_class_filter?
+        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 += css_from_id if use_default_id_filter?
-          sel += css_from_classes if use_default_class_filter?
+          sel += conditions_from_id if use_default_id_filter?
+          sel += conditions_from_classes if use_default_class_filter?
           sel
         end.join(', ')
       end
@@ -244,33 +243,12 @@ module Capybara
         options.key?(:class) && !custom_keys.include?(:class)
       end
 
-      def css_from_classes
-        if options[:class].is_a?(XPath::Expression)
-          raise ArgumentError, 'XPath expressions are not supported for the :class filter with CSS based selectors'
-        end
-
-        classes = Array(options[:class]).group_by { |cl| cl.start_with? '!' }
-        (classes[false].to_a.map { |cl| ".#{Capybara::Selector::CSS.escape(cl)}" } +
-         classes[true].to_a.map { |cl| ":not(.#{Capybara::Selector::CSS.escape(cl.slice(1))})" }).join
+      def conditions_from_classes
+        builder.class_conditions(options[:class])
       end
 
-      def css_from_id
-        if options[:id].is_a?(XPath::Expression)
-          raise ArgumentError, 'XPath expressions are not supported for the :id filter with CSS based selectors'
-        end
-        "##{::Capybara::Selector::CSS.escape(options[:id])}"
-      end
-
-      def xpath_from_classes
-        return XPath.attr(:class)[options[:class]] if options[:class].is_a?(XPath::Expression)
-
-        Array(options[:class]).map do |klass|
-          if klass.start_with?('!')
-            !XPath.attr(:class).contains_word(klass.slice(1))
-          else
-            XPath.attr(:class).contains_word(klass)
-          end
-        end.reduce(:&)
+      def conditions_from_id
+        builder.attribute_conditions(id: options[:id])
       end
 
       def apply_expression_filters(expression)
@@ -294,6 +272,7 @@ module Capybara
 
       def warn_exact_usage
         return unless options.key?(:exact) && !supports_exact?
+
         warn "The :exact option only has an effect on queries using the XPath#is method. Using it with the query \"#{expression}\" has no effect."
       end
 
@@ -313,16 +292,30 @@ module Capybara
         node.is_a?(::Capybara::Node::Simple) && node.path == '/'
       end
 
+      def matches_id_filter?(node)
+        return true unless use_default_id_filter? && options[:id].is_a?(Regexp)
+
+        node[:id] =~ options[:id]
+      end
+
+      def matches_class_filter?(node)
+        return true unless use_default_class_filter? && options[:class].is_a?(Regexp)
+
+        node[:class] =~ options[:class]
+      end
+
       def matches_text_filter?(node)
         value = options[:text]
         return true unless value
         return matches_text_exactly?(node, value) if exact_text == true
+
         regexp = value.is_a?(Regexp) ? value : Regexp.escape(value.to_s)
         matches_text_regexp?(node, regexp)
       end
 
       def matches_exact_text_filter?(node)
         return true unless exact_text.is_a?(String)
+
         matches_text_exactly?(node, exact_text)
       end
 
@@ -348,6 +341,10 @@ module Capybara
         text_visible = :all if text_visible == :hidden
         !!node.text(text_visible, normalize_ws: normalize_ws).match(regexp)
       end
+
+      def builder
+        selector.builder
+      end
     end
   end
 end

data/lib/capybara/queries/text_query.rb

@@ -64,6 +64,7 @@ module Capybara
         insensitive_regexp = Capybara::Helpers.to_regexp(@expected_text, options: Regexp::IGNORECASE)
         insensitive_count = @actual_text.scan(insensitive_regexp).size
         return if insensitive_count == @count
+
         "it was found #{insensitive_count} #{Capybara::Helpers.declension('time', 'times', insensitive_count)} using a case insensitive search"
       end
 
@@ -71,6 +72,7 @@ module Capybara
         invisible_text = text(query_type: :all)
         invisible_count = invisible_text.scan(@search_regexp).size
         return if invisible_count == @count
+
         "it was found #{invisible_count} #{Capybara::Helpers.declension('time', 'times', invisible_count)} including non-visible text"
       rescue StandardError
         # An error getting the non-visible text (if element goes out of scope) should not affect the response

data/lib/capybara/rack_test/browser.rb

@@ -35,6 +35,7 @@ class Capybara::RackTest::Browser
 
   def follow(method, path, **attributes)
     return if fragment_or_script?(path)
+
     process_and_follow_redirects(method, path, attributes, 'HTTP_REFERER' => current_url)
   end
 

data/lib/capybara/rack_test/driver.rb

@@ -16,6 +16,7 @@ class Capybara::RackTest::Driver < Capybara::Driver::Base
 
   def initialize(app, **options)
     raise ArgumentError, 'rack-test requires a rack application, but none was given' unless app
+
     @app = app
     @options = DEFAULT_OPTIONS.merge(options)
   end
@@ -74,6 +75,10 @@ class Capybara::RackTest::Driver < Capybara::Driver::Base
 
   def find_css(selector)
     browser.find(:css, selector)
+  rescue Nokogiri::CSS::SyntaxError
+    raise unless selector.include?(' i]')
+
+    raise ArgumentError, "This driver doesn't support case insensitive attribute matching when using CSS base selectors"
   end
 
   def html

data/lib/capybara/rack_test/node.rb

@@ -50,12 +50,14 @@ class Capybara::RackTest::Node < Capybara::Driver::Node
 
   def select_option
     return if disabled?
+
     deselect_options unless select_node.multiple?
     native['selected'] = 'selected'
   end
 
   def unselect_option
     raise Capybara::UnselectNotAllowed, 'Cannot unselect option from single select box.' unless select_node.multiple?
+
     native.remove_attribute('selected')
   end
 

data/lib/capybara/result.rb

@@ -93,6 +93,7 @@ module Capybara
         min, max = between.minmax
         size = load_up_to(max + 1)
         return 0 if between.include? size
+
         return size <=> min
       end
 
@@ -130,6 +131,7 @@ module Capybara
     def load_up_to(num)
       loop do
         break if @result_cache.size >= num
+
         @result_cache << @results_enum.next
       end
       @result_cache.size

data/lib/capybara/rspec/compound.rb

@@ -43,6 +43,7 @@ if defined?(::RSpec::Expectations::Version)
               syncer.synchronize do
                 @evaluator.reset
                 raise ::Capybara::ElementNotFound unless [matcher_1_matches?, matcher_2_matches?].all?
+
                 true
               end
             rescue StandardError
@@ -71,6 +72,7 @@ if defined?(::RSpec::Expectations::Version)
               syncer.synchronize do
                 @evaluator.reset
                 raise ::Capybara::ElementNotFound unless [matcher_1_matches?, matcher_2_matches?].any?
+
                 true
               end
             rescue StandardError

data/lib/capybara/rspec/matchers.rb

@@ -242,6 +242,7 @@ module Capybara
         timer = Capybara::Helpers.timer(expire_in: @wait_time)
         while window.exists?
           return false if timer.expired?
+
           sleep 0.05
         end
         true

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'xpath'
+
+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?}]"
+              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
+        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
+            strs = Selector::RegexpDisassembler.new(classes).substrings
+            strs.map { |str| "[class*='#{str}'#{' i' if classes.casefold?}]" }.join
+          else
+            cls = Array(classes).group_by { |cl| cl.start_with? '!' }
+            (cls[false].to_a.map { |cl| ".#{Capybara::Selector::CSS.escape(cl)}" } +
+            cls[true].to_a.map { |cl| ":not(.#{Capybara::Selector::CSS.escape(cl.slice(1..-1))})" }).join
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'xpath'
+
+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 class_conditions(classes)
+          case classes
+          when XPath::Expression
+            XPath.attr(:class)[classes]
+          when Regexp
+            XPath.attr(:class)[regexp_to_xpath_conditions(classes)]
+          else
+            Array(classes).map do |klass|
+              if klass.start_with?('!')
+                !XPath.attr(:class).contains_word(klass.slice(1..-1))
+              else
+                XPath.attr(:class).contains_word(klass)
+              end
+            end.reduce(:&)
+          end
+        end
+
+      private
+
+        def regexp_to_xpath_conditions(regexp)
+          condition = XPath.current
+          condition = condition.uppercase if regexp.casefold?
+          Selector::RegexpDisassembler.new(regexp).substrings.map do |str|
+            condition.contains(str)
+          end.reduce(:&)
+        end
+      end
+    end
+  end
+end

data/lib/capybara/selector/filter_set.rb

@@ -106,6 +106,7 @@ module Capybara
       def add_filter(name, filter_class, *types, matcher: nil, **options, &block)
         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

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

@@ -41,6 +41,7 @@ module Capybara
         def apply(subject, name, value, skip_value)
           return skip_value if skip?(value)
           raise ArgumentError, "Invalid value #{value.inspect} passed to #{self.class.name.split('::').last} #{name}#{" : #{@name}" if @name.is_a?(Regexp)}" unless valid_value?(value)
+
           if @block.arity == 2
             @block.call(subject, value)
           else
@@ -50,6 +51,7 @@ module Capybara
 
         def valid_value?(value)
           return true unless @options.key?(:valid_values)
+
           Array(@options[:valid_values]).any? { |valid| valid === value } # rubocop:disable Style/CaseEquality
         end
       end

data/lib/capybara/selector/regexp_disassembler.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Capybara
+  class Selector
+    # @api private
+    class RegexpDisassembler
+      def initialize(regexp)
+        @regexp = regexp
+        @regexp_source = regexp.source
+      end
+
+      def substrings
+        @substrings ||= begin
+          source = @regexp_source.dup
+          source.gsub!(/\\[^pgk]/, '.') # replace escaped characters with wildcard
+          source.gsub!(/\\[gk](?:<[^>]*>)?/, '.') # replace sub expressions and back references with wildcard
+          source.gsub!(/\\p\{[[:alpha:]]+\}?/, '.') # replace character properties with wildcard
+          source.gsub!(/\[\[:[a-z]+:\]\]/, '.') # replace posix classes with wildcard
+          while source.gsub!(/\[(?:[^\[\]]+)\]/, '.'); end # replace character classes with wildcard
+          source.gsub!(/\(\?<?[=!][^)]*\)/, '') # remove lookahead/lookbehind assertions
+          source.gsub!(/\(\?(?:<[^>]+>|>|:)/, '(') # replace named, atomic, and non-matching groups with unnamed matching groups
+
+          while source.gsub!(GROUP_REGEX) { |_m| simplify_group(Regexp.last_match) }; end
+          source.gsub!(/.[*?]\??/, '.') # replace optional character with wildcard
+          source.gsub!(/(.)\+\??/, '\1.') # replace one or more with character plus wildcard
+          source.gsub!(/(?<char>.)#{COUNTED_REP_REGEX.source}/) do |_m| # repeat counted characters
+            (Regexp.last_match[:char] * Regexp.last_match[:min_rep].to_i).tap { |str| str << '.' if Regexp.last_match[:max_rep] }
+          end
+          return [] if source.include?('|') # can't handle alternation here
+
+          strs = source.match(/\A\^?(.*?)\$?\Z/).captures[0].split('.').reject(&:empty?).uniq
+          strs = strs.map(&:upcase) if @regexp.casefold?
+          strs
+        end
+      end
+
+    private
+
+      def simplify_group(matches)
+        if matches[:group].include?('|') # no support for alternation in groups
+          '.'
+        elsif matches[:one_or_more] # required but may repeat becomes text + wildcard
+          matches[:group][1..-2] + '.'
+        elsif matches[:optional] # optional group becomes wildcard
+          '.'
+        elsif matches[:min_rep]
+          (matches[:group] * matches[:min_rep].to_i).tap { |r| r << '.' if matches[:max_rep] }
+        else
+          matches[:group][1..-2]
+        end
+      end
+
+      COUNTED_REP_REGEX = /\{(?<min_rep>\d*)(?:,(?<max_rep>\d*))?\}/
+      GROUP_REGEX = /
+        (?<group>\([^()]*\))
+          (?:
+            (?:
+             (?<optional>[*?]) |
+             (?<one_or_more>\+) |
+             (?:#{COUNTED_REP_REGEX.source})
+            )\??
+          )?
+      /x
+    end
+  end
+end