capybara 2.18.0 → 3.0.0.rc1

data/lib/capybara/node/simple.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Capybara
   module Node
-
     ##
     #
     # A {Capybara::Node::Simple} is a simpler version of {Capybara::Node::Base} which
@@ -28,7 +28,7 @@ module Capybara
       #
       # @return [String]    The text of the element
       #
-      def text(type=nil)
+      def text(_type = nil)
         native.text
       end
 
@@ -45,7 +45,7 @@ module Capybara
         attr_name = name.to_s
         if attr_name == 'value'
           value
-        elsif 'input' == tag_name and 'checkbox' == native[:type] and 'checked' == attr_name
+        elsif tag_name == 'input' and native[:type] == 'checkbox' and attr_name == 'checked'
           native['checked'] == 'checked'
         else
           native[attr_name]
@@ -79,12 +79,12 @@ module Capybara
           native['_capybara_raw_value']
         elsif tag_name == 'select'
           if native['multiple'] == 'multiple'
-            native.xpath(".//option[@selected='selected']").map { |option| option[:value] || option.content  }
+            native.xpath(".//option[@selected='selected']").map { |option| option[:value] || option.content }
           else
             option = native.xpath(".//option[@selected='selected']").first || native.xpath(".//option").first
             option[:value] || option.content if option
           end
-        elsif tag_name == 'input' && %w(radio checkbox).include?(native[:type])
+        elsif tag_name == 'input' && %w[radio checkbox].include?(native[:type])
           native[:value] || 'on'
         else
           native[:value]
@@ -100,14 +100,13 @@ module Capybara
       # @return [Boolean]     Whether the element is visible
       #
       def visible?(check_ancestors = true)
-        return false if (tag_name == 'input') && (native[:type]=="hidden")
+        return false if (tag_name == 'input') && (native[:type] == "hidden")
 
         if check_ancestors
-          #check size because oldest supported nokogiri doesnt support xpath boolean() function
-          native.xpath("./ancestor-or-self::*[contains(@style, 'display:none') or contains(@style, 'display: none') or @hidden or name()='script' or name()='head']").size() == 0
+          !native.xpath("boolean(./ancestor-or-self::*[contains(@style, 'display:none') or contains(@style, 'display: none') or @hidden or name()='script' or name()='head'])")
         else
-          #no need for an xpath if only checking the current element
-          !(native.has_attribute?('hidden') || (native[:style] =~ /display:\s?none/) || %w(script head).include?(tag_name))
+          # No need for an xpath if only checking the current element
+          !(native.has_attribute?('hidden') || (native[:style] =~ /display:\s?none/) || %w[script head].include?(tag_name))
         end
       end
 
@@ -140,7 +139,7 @@ module Capybara
         native.has_attribute?('selected')
       end
 
-      def synchronize(seconds=nil)
+      def synchronize(_seconds = nil)
         yield # simple nodes don't need to wait
       end
 
@@ -152,12 +151,7 @@ module Capybara
       #
       # @return [String]     The title of the document
       def title
-        if native.respond_to? :title
-          native.title
-        else
-          #old versions of nokogiri don't have #title - remove in 3.0
-          native.xpath('/html/head/title | /html/title').first.text
-        end
+        native.title
       end
 
       def inspect

data/lib/capybara/queries/ancestor_query.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Capybara
   module Queries
     class AncestorQuery < MatchQuery
@@ -7,17 +8,14 @@ module Capybara
         @child_node = node
         node.synchronize do
           match_results = super(node.session.current_scope, exact)
-          node.all(:xpath, XPath.ancestor) do |el|
-            match_results.include?(el)
-          end
+          node.all(:xpath, XPath.ancestor) { |el| match_results.include?(el) }
         end
       end
 
       def description
+        child_query = @child_node && @child_node.instance_variable_get(:@query)
         desc = super
-        if @child_node && (child_query = @child_node.instance_variable_get(:@query))
-          desc += " that is an ancestor of #{child_query.description}"
-        end
+        desc += " that is an ancestor of #{child_query.description}" if child_query
         desc
       end
     end

data/lib/capybara/queries/base_query.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
+
 module Capybara
   # @api private
   module Queries
     class BaseQuery
-      COUNT_KEYS = [:count, :minimum, :maximum, :between]
+      COUNT_KEYS = %i[count minimum maximum between].freeze
 
       attr_reader :options
       attr_writer :session_options
@@ -20,7 +21,7 @@ module Capybara
         self.class.wait(options, session_options.default_max_wait_time)
       end
 
-      def self.wait(options, default=Capybara.default_max_wait_time)
+      def self.wait(options, default = Capybara.default_max_wait_time)
         options.fetch(:wait, default) || 0
       end
 
@@ -30,11 +31,7 @@ module Capybara
       # Returns false if query does not have any count options specified.
       #
       def expects_none?
-        if COUNT_KEYS.any? { |k| options.has_key? k }
-          matches_count?(0)
-        else
-          false
-        end
+        count_specified? ? matches_count?(0) : false
       end
 
       ##
@@ -47,11 +44,11 @@ module Capybara
       # @param [Integer] count     The actual number. Should be coercible via Integer()
       #
       def matches_count?(count)
-        return (Integer(options[:count]) == count)     if options[:count]
+        return (Integer(options[:count]) == count) if options[:count]
         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] === count)
-        return true
+        return false if options[:between] && !options[:between].include?(count)
+        true
       end
 
       ##
@@ -66,10 +63,14 @@ module Capybara
         String.new("expected not to find #{description}") << count_message
       end
 
-      private
+    private
+
+      def count_specified?
+        COUNT_KEYS.any? { |k| options.key? k }
+      end
 
       def count_message
-        message = String.new()
+        message = "".dup
         if options[:count]
           message << " #{options[:count]} #{Capybara::Helpers.declension('time', 'times', options[:count])}"
         elsif options[:between]
@@ -84,11 +85,11 @@ module Capybara
 
       def assert_valid_keys
         invalid_keys = @options.keys - valid_keys
-        unless invalid_keys.empty?
-          invalid_names = invalid_keys.map(&:inspect).join(", ")
-          valid_names = valid_keys.map(&:inspect).join(", ")
-          raise ArgumentError, "invalid keys #{invalid_names}, should be one of #{valid_names}"
-        end
+        return if invalid_keys.empty?
+
+        invalid_names = invalid_keys.map(&:inspect).join(", ")
+        valid_names = valid_keys.map(&:inspect).join(", ")
+        raise ArgumentError, "invalid keys #{invalid_names}, should be one of #{valid_names}"
       end
     end
   end

data/lib/capybara/queries/current_path_query.rb

@@ -1,34 +1,25 @@
 # frozen_string_literal: true
+
 require 'addressable/uri'
 
 module Capybara
   # @api private
   module Queries
     class CurrentPathQuery < BaseQuery
-      def initialize(expected_path, options = {})
+      def initialize(expected_path, **options)
         super(options)
         @expected_path = expected_path
-        warn "DEPRECATED: The :only_path option is deprecated in favor of the :ignore_query option" if options.has_key?(:only_path)
-
         @options = {
           url: !@expected_path.is_a?(Regexp) && !::Addressable::URI.parse(@expected_path || "").hostname.nil?,
-          only_path: false,
-          ignore_query: false }.merge(options)
+          ignore_query: false
+        }.merge(options)
         assert_valid_keys
       end
 
       def resolves_for?(session)
         uri = ::Addressable::URI.parse(session.current_url)
         uri.query = nil if uri && options[:ignore_query]
-        @actual_path = if options[:url]
-          uri.to_s
-        else
-          if options[:only_path]
-            uri && uri.path
-          else
-            uri && uri.request_uri
-          end
-        end
+        @actual_path = options[:url] ? uri.to_s : uri && uri.request_uri
 
         if @expected_path.is_a? Regexp
           @actual_path.to_s.match(@expected_path)
@@ -45,22 +36,15 @@ module Capybara
         failure_message_helper(' not')
       end
 
-      private
+    private
 
       def failure_message_helper(negated = '')
-        verb = (@expected_path.is_a?(Regexp))? 'match' : 'equal'
+        verb = @expected_path.is_a?(Regexp) ? 'match' : 'equal'
         "expected #{@actual_path.inspect}#{negated} to #{verb} #{@expected_path.inspect}"
       end
 
       def valid_keys
-        [:wait, :url, :only_path, :ignore_query]
-      end
-
-      def assert_valid_keys
-        super
-        if options[:url] && options[:only_path]
-          raise ArgumentError, "the :url and :only_path options cannot both be true"
-        end
+        %i[wait url ignore_query]
       end
     end
   end

data/lib/capybara/queries/match_query.rb

@@ -2,18 +2,14 @@ module Capybara
   module Queries
     class MatchQuery < Capybara::Queries::SelectorQuery
       def visible
-        if options.has_key?(:visible)
-          super
-        else
-          :all
-        end
+        options.key?(:visible) ? super : :all
       end
 
-      private
+    private
 
       def valid_keys
         super - COUNT_KEYS
       end
     end
   end
-end
+end

data/lib/capybara/queries/selector_query.rb

@@ -1,36 +1,24 @@
 # frozen_string_literal: true
+
 module Capybara
   module Queries
     class SelectorQuery < Queries::BaseQuery
       attr_accessor :selector, :locator, :options, :expression, :find, :negative
 
-      VALID_KEYS = COUNT_KEYS + [:text, :id, :class, :visible, :exact, :exact_text, :match, :wait, :filter_set]
-      VALID_MATCH = [:first, :smart, :prefer_exact, :one]
+      VALID_KEYS = COUNT_KEYS + %i[text id class visible exact exact_text match wait filter_set]
+      VALID_MATCH = %i[first smart prefer_exact one].freeze
 
-      def initialize(*args, &filter_block)
+      def initialize(*args, session_options:, **options, &filter_block)
         @resolved_node = nil
-        @options = if args.last.is_a?(Hash) then args.pop.dup else {} end
+        @options = options.dup
         super(@options)
+        self.session_options = session_options
 
+        @selector = find_selector(args[0].is_a?(Symbol) ? args.shift : args[0])
+        @locator = args.shift
         @filter_block = filter_block
 
-        if args[0].is_a?(Symbol)
-          @selector = Selector.all.fetch(args.shift) do |selector_type|
-            raise ArgumentError, "Unknown selector type (:#{selector_type})"
-          end
-          @locator = args.shift
-        else
-          @selector = Selector.all.values.find { |s| s.match?(args[0]) }
-          @locator = args.shift
-        end
-        @selector ||= Selector.all[session_options.default_selector]
-
-        warn "Unused parameters passed to #{self.class.name} : #{args}" unless args.empty?
-
-        # for compatibility with Capybara 2.0
-        if session_options.exact_options and @selector == Selector.all[:option]
-          @options[:exact] = true
-        end
+        raise ArgumentError, "Unused parameters passed to #{self.class.name} : #{args}" unless args.empty?
 
         @expression = @selector.call(@locator, @options.merge(enable_aria_label: session_options.enable_aria_label))
 
@@ -40,10 +28,10 @@ module Capybara
       end
 
       def name; selector.name; end
-      def label; selector.label or selector.name; end
+      def label; selector.label || selector.name; end
 
       def description
-        @description = String.new()
+        @description = "".dup
         @description << "visible " if visible == :visible
         @description << "non-visible " if visible == :hidden
         @description << "#{label} #{locator.inspect}"
@@ -58,80 +46,39 @@ module Capybara
       end
 
       def matches_filters?(node)
-        if options[:text]
-          regexp = if options[:text].is_a?(Regexp)
-            options[:text]
-          else
-            if exact_text == true
-              /\A#{Regexp.escape(options[:text].to_s)}\z/
-            else
-              Regexp.escape(options[:text].to_s)
-            end
-          end
-          text_visible = visible
-          text_visible = :all if text_visible == :hidden
-          return false if not node.text(text_visible).match(regexp)
-        end
-
-        if exact_text.is_a?(String)
-          regexp = /\A#{Regexp.escape(options[:exact_text])}\z/
-          text_visible = visible
-          text_visible = :all if text_visible == :hidden
-          return false if not node.text(text_visible).match(regexp)
-        end
+        return false if options[:text] && !matches_text_filter(node, options[:text])
+        return false if exact_text.is_a?(String) && !matches_exact_text_filter(node, exact_text)
 
         case visible
-          when :visible then return false unless node.visible?
-          when :hidden then return false if node.visible?
+        when :visible then return false unless node.visible?
+        when :hidden then return false if node.visible?
         end
 
-        res = node_filters.all? do |name, filter|
-          if options.has_key?(name)
-            filter.matches?(node, options[name])
-          elsif filter.default?
-            filter.matches?(node, filter.default)
-          else
-            true
-          end
-        end
-
-        res &&= if node.respond_to?(:session)
-          node.session.using_wait_time(0){ @filter_block.call(node) }
-        else
-          @filter_block.call(node)
-        end unless @filter_block.nil?
-
-        res
-
+        matches_node_filters?(node) && matches_filter_block?(node)
       rescue *(node.respond_to?(:session) ? node.session.driver.invalid_element_errors : [])
         return false
       end
 
       def visible
-        case (vis = options.fetch(:visible){ @selector.default_visibility(session_options.ignore_hidden_elements) })
-          when true then :visible
-          when false then :all
-          else vis
+        case (vis = options.fetch(:visible) { @selector.default_visibility(session_options.ignore_hidden_elements) })
+        when true then :visible
+        when false then :all
+        else vis
         end
       end
 
       def exact?
-        return false if !supports_exact?
-        options.fetch(:exact, session_options.exact)
+        supports_exact? ? options.fetch(:exact, session_options.exact) : false
       end
 
       def match
         options.fetch(:match, session_options.match)
       end
 
-      def xpath(exact=nil)
-        exact = self.exact? if exact.nil?
+      def xpath(exact = nil)
+        exact = exact? if exact.nil?
         expr = apply_expression_filters(@expression)
-        expr = if expr.respond_to?(:to_xpath) and exact
-          expr.to_xpath(:exact)
-        else
-          expr.to_s
-        end
+        expr = exact ? expr.to_xpath(:exact) : expr.to_s if expr.respond_to?(:to_xpath)
         filtered_xpath(expr)
       end
 
@@ -144,9 +91,9 @@ module Capybara
         @resolved_node = node
         node.synchronize do
           children = if selector.format == :css
-            node.find_css(self.css)
+            node.find_css(css)
           else
-            node.find_xpath(self.xpath(exact))
+            node.find_xpath(xpath(exact))
           end.map do |child|
             if node.is_a?(Capybara::Node::Base)
               Capybara::Node::Element.new(node.session, child, node, self)
@@ -163,14 +110,45 @@ module Capybara
         @expression.respond_to? :to_xpath
       end
 
-      private
+    private
+
+      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 { |s| s.match?(locator) }
+        end
+        selector || Selector.all[session_options.default_selector]
+      end
 
       def valid_keys
         VALID_KEYS + custom_keys
       end
 
+      def matches_node_filters?(node)
+        node_filters.all? do |name, filter|
+          if options.key?(name)
+            filter.matches?(node, options[name])
+          elsif filter.default?
+            filter.matches?(node, filter.default)
+          else
+            true
+          end
+        end
+      end
+
+      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
+          @filter_block.call(node)
+        end
+      end
+
       def node_filters
-        if options.has_key?(:filter_set)
+        if options.key?(:filter_set)
           ::Capybara::Selector::FilterSet.all[options[:filter_set]].node_filters
         else
           @selector.node_filters
@@ -179,7 +157,7 @@ module Capybara
 
       def expression_filters
         filters = @selector.expression_filters
-        filters.merge ::Capybara::Selector::FilterSet.all[options[:filter_set]].expression_filters if options.has_key?(:filter_set)
+        filters.merge ::Capybara::Selector::FilterSet.all[options[:filter_set]].expression_filters if options.key?(:filter_set)
         filters
       end
 
@@ -195,13 +173,13 @@ module Capybara
       end
 
       def filtered_xpath(expr)
-        if options.has_key?(:id) || options.has_key?(:class)
+        if options.key?(:id) || options.key?(:class)
           expr = "(#{expr})"
-          expr = "#{expr}[#{XPath.attr(:id) == options[:id]}]" if options.has_key?(:id) && !custom_keys.include?(:id)
-          if options.has_key?(:class) && !custom_keys.include?(:class)
+          expr = "#{expr}[#{XPath.attr(:id) == options[:id]}]" if options.key?(:id) && !custom_keys.include?(:id)
+          if options.key?(:class) && !custom_keys.include?(:class)
             class_xpath = Array(options[:class]).map do |klass|
-              "contains(concat(' ',normalize-space(@class),' '),' #{klass} ')"
-            end.join(" and ")
+              XPath.attr(:class).contains_word(klass)
+            end.reduce(:&)
             expr = "#{expr}[#{class_xpath}]"
           end
         end
@@ -209,12 +187,12 @@ module Capybara
       end
 
       def filtered_css(expr)
-        if options.has_key?(:id) || options.has_key?(:class)
+        if options.key?(:id) || options.key?(:class)
           css_selectors = expr.split(',').map(&:rstrip)
           expr = css_selectors.map do |sel|
-           sel += "##{Capybara::Selector::CSS.escape(options[:id])}" if options.has_key?(:id) && !custom_keys.include?(:id)
-           sel += Array(options[:class]).map { |k| ".#{Capybara::Selector::CSS.escape(k)}"}.join if options.has_key?(:class) && !custom_keys.include?(:class)
-           sel
+            sel += "##{Capybara::Selector::CSS.escape(options[:id])}" if options.key?(:id) && !custom_keys.include?(:id)
+            sel += Array(options[:class]).map { |k| ".#{Capybara::Selector::CSS.escape(k)}" }.join if options.key?(:class) && !custom_keys.include?(:class)
+            sel
           end.join(", ")
         end
         expr
@@ -222,7 +200,7 @@ module Capybara
 
       def apply_expression_filters(expr)
         expression_filters.inject(expr) do |memo, (name, ef)|
-          if options.has_key?(name)
+          if options.key?(name)
             ef.apply_filter(memo, options[name])
           elsif ef.default?
             ef.apply_filter(memo, ef.default)
@@ -233,9 +211,8 @@ module Capybara
       end
 
       def warn_exact_usage
-        if options.has_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
+        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
 
       def exact_text
@@ -246,6 +223,26 @@ module Capybara
         @resolved_node && !(@resolved_node.is_a?(::Capybara::Node::Document) ||
                             (@resolved_node.is_a?(::Capybara::Node::Simple) && @resolved_node.path == '/'))
       end
+
+      def matches_text_filter(node, text_option)
+        regexp = if text_option.is_a?(Regexp)
+          text_option
+        elsif exact_text == true
+          /\A#{Regexp.escape(text_option.to_s)}\z/
+        else
+          Regexp.escape(text_option.to_s)
+        end
+        text_visible = visible
+        text_visible = :all if text_visible == :hidden
+        node.text(text_visible).match(regexp)
+      end
+
+      def matches_exact_text_filter(node, exact_text_option)
+        regexp = /\A#{Regexp.escape(exact_text_option)}\z/
+        text_visible = visible
+        text_visible = :all if text_visible == :hidden
+        node.text(text_visible).match(regexp)
+      end
     end
   end
 end