capybara 2.8.0 → 2.9.0

data/lib/capybara/queries/selector_query.rb

@@ -4,7 +4,7 @@ module Capybara
     class SelectorQuery < Queries::BaseQuery
       attr_accessor :selector, :locator, :options, :expression, :find, :negative
 
-      VALID_KEYS = [:text, :visible, :between, :count, :maximum, :minimum, :exact, :match, :wait, :filter_set]
+      VALID_KEYS = COUNT_KEYS + [:text, :visible, :exact, :match, :wait, :filter_set]
       VALID_MATCH = [:first, :smart, :prefer_exact, :one]
 
       def initialize(*args)
@@ -26,7 +26,10 @@ module Capybara
           @options[:exact] = true
         end
 
-        @expression = @selector.call(@locator)
+        @expression = @selector.call(@locator, @options)
+
+        warn_exact_usage
+
         assert_valid_keys
       end
 
@@ -79,23 +82,16 @@ module Capybara
       end
 
       def exact?
-        if options.has_key?(:exact)
-          @options[:exact]
-        else
-          Capybara.exact
-        end
+        return false if !supports_exact?
+        options.fetch(:exact, Capybara.exact)
       end
 
       def match
-        if options.has_key?(:match)
-          @options[:match]
-        else
-          Capybara.match
-        end
+        options.fetch(:match, Capybara.match)
       end
 
       def xpath(exact=nil)
-        exact = self.exact? if exact == nil
+        exact = self.exact? if exact.nil?
         if @expression.respond_to?(:to_xpath) and exact
           @expression.to_xpath(:exact)
         else
@@ -125,11 +121,15 @@ module Capybara
         end
       end
 
+      # @api private
+      def supports_exact?
+        @expression.respond_to? :to_xpath
+      end
+
       private
 
       def valid_keys
-       vk = COUNT_KEYS + [:text, :visible, :exact, :match, :wait, :filter_set]
-       vk + custom_keys
+        VALID_KEYS + custom_keys
       end
 
       def query_filters
@@ -141,7 +141,7 @@ module Capybara
       end
 
       def custom_keys
-        query_filters.keys
+        query_filters.keys + @selector.expression_filters
       end
 
       def assert_valid_keys
@@ -150,6 +150,12 @@ module Capybara
           raise ArgumentError, "invalid option #{match.inspect} for :match, should be one of #{VALID_MATCH.map(&:inspect).join(", ")}"
         end
       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.to_s}\" has no effect."
+        end
+      end
     end
   end
 end

data/lib/capybara/queries/text_query.rb

@@ -22,24 +22,25 @@ module Capybara
       end
 
       def failure_message
-        build_message(true)
+        super << build_message(true)
       end
 
       def negative_failure_message
-        build_message(false).sub(/(to find)/, 'not \1')
+        super << build_message(false)
+      end
+
+      def description
+        if @expected_text.is_a?(Regexp)
+          "text matching #{@expected_text.inspect}"
+        else
+          "text #{@expected_text.inspect}"
+        end
       end
 
       private
 
       def build_message(report_on_invisible)
-        description =
-          if @expected_text.is_a?(Regexp)
-            "text matching #{@expected_text.inspect}"
-          else
-            "text #{@expected_text.inspect}"
-          end
-
-        message = Capybara::Helpers.failure_message(description, @options)
+        message = String.new()
         unless (COUNT_KEYS & @options.keys).empty?
           message << " but found #{@count} #{Capybara::Helpers.declension('time', 'times', @count)}"
         end
@@ -48,7 +49,7 @@ module Capybara
         details_message = []
 
         if @node and !@expected_text.is_a? Regexp
-          insensitive_regexp = Regexp.new(@expected_text, Regexp::IGNORECASE)
+          insensitive_regexp = Capybara::Helpers.to_regexp(@expected_text, Regexp::IGNORECASE)
           insensitive_count = @actual_text.scan(insensitive_regexp).size
           if insensitive_count != @count
             details_message << "it was found #{insensitive_count} #{Capybara::Helpers.declension("time", "times", insensitive_count)} using a case insensitive search"

data/lib/capybara/rack_test/form.rb

@@ -42,7 +42,8 @@ class Capybara::RackTest::Form < Capybara::RackTest::Node
               if (value = field['value']).to_s.empty?
                 NilUploadedFile.new
               else
-                content_type = MIME::Types.type_for(value).first.to_s
+                types = MIME::Types.type_for(value)
+                content_type = types.sort_by.with_index { |type, idx| [type.obsolete? ? 1 : 0, idx] }.first.to_s
                 Rack::Test::UploadedFile.new(value, content_type)
               end
             merge_param!(params, field['name'].to_s, file)

data/lib/capybara/result.rb

@@ -45,7 +45,7 @@ module Capybara
     end
 
     def [](*args)
-      if (args.size == 1) && ((idx = args[0]).is_a? Integer) && (idx > 0)
+      if (args.size == 1) && ((idx = args[0]).is_a? Integer) && (idx >= 0)
         @result_cache << @results_enum.next while @result_cache.size <= idx
         @result_cache[idx]
       else
@@ -61,31 +61,48 @@ module Capybara
     end
 
     def matches_count?
-      return Integer(@query.options[:count]) == count if @query.options[:count]
-
-      return false if @query.options[:between] && !(@query.options[:between] === count)
+      # Only check filters for as many elements as necessary to determine result
+      if @query.options[:count]
+        count_opt = Integer(@query.options[:count])
+        loop do
+          break if @result_cache.size > count_opt
+          @result_cache << @results_enum.next
+        end
+        return @result_cache.size == count_opt
+      end
 
       if @query.options[:minimum]
+        min_opt = Integer(@query.options[:minimum])
         begin
-          @result_cache << @results_enum.next while @result_cache.size < Integer(@query.options[:minimum])
+          @result_cache << @results_enum.next while @result_cache.size < min_opt
         rescue StopIteration
           return false
         end
       end
 
       if @query.options[:maximum]
+        max_opt = Integer(@query.options[:maximum])
         begin
-          @result_cache << @results_enum.next while @result_cache.size <= Integer(@query.options[:maximum])
+          @result_cache << @results_enum.next while @result_cache.size <= max_opt
           return false
         rescue StopIteration
         end
       end
 
+      if @query.options[:between]
+        max =  Integer(@query.options[:between].max)
+        loop do
+          break if @result_cache.size > max
+          @result_cache << @results_enum.next
+        end
+        return false unless (@query.options[:between] === @result_cache.size)
+      end
+
       return true
     end
 
     def failure_message
-      message = Capybara::Helpers.failure_message(@query.description, @query.options)
+      message = @query.failure_message
       if count > 0
         message << ", found #{count} #{Capybara::Helpers.declension("match", "matches", count)}: " << full_results.map(&:text).map(&:inspect).join(", ")
       else
@@ -105,9 +122,7 @@ module Capybara
     private
 
     def full_results
-      loop do
-        @result_cache << @results_enum.next
-      end
+      loop { @result_cache << @results_enum.next }
       @result_cache
     end
 

data/lib/capybara/rspec/features.rb

@@ -39,7 +39,6 @@ else
     end
   end
 
-
   def self.feature(*args, &block)
     options = if args.last.is_a?(Hash) then args.pop else {} end
     options[:capybara_feature] = true
@@ -51,5 +50,7 @@ else
     RSpec.describe(*args, &block)
   end
 
-  RSpec.configuration.include Capybara::Features, :capybara_feature => true
+  RSpec.configure do |config|
+    config.include(Capybara::Features, :capybara_feature => true)
+  end
 end

data/lib/capybara/rspec/matchers.rb

@@ -161,7 +161,7 @@ module Capybara
 
     class BecomeClosed
       def initialize(options)
-        @wait_time = Capybara::Queries::SelectorQuery.new(options).wait
+        @wait_time = Capybara::Queries::BaseQuery.wait(options)
       end
 
       def matches?(window)

data/lib/capybara/selector/filter_set.rb

@@ -12,7 +12,9 @@ module Capybara
         instance_eval(&block)
       end
 
-      def filter(name, options={}, &block)
+      def filter(name, *types_and_options, &block)
+        options = types_and_options.last.is_a?(Hash) ? types_and_options.pop.dup : {}
+        types_and_options.each { |k| options[k] = true}
         filters[name] = Filter.new(name, block, options)
       end
 

data/lib/capybara/selector/selector.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+require 'capybara/selector/filter_set'
+require 'xpath'
+
+#Patch XPath to allow a nil condition in where
+module XPath
+  class Renderer
+    def where(on, condition)
+      condition = condition.to_s
+      if !condition.empty?
+        "#{on}[#{condition}]"
+      else
+        "#{on}"
+      end
+    end
+  end
+end
+
+module Capybara
+  class Selector
+
+    attr_reader :name, :format, :expression_filters
+
+    class << self
+      def all
+        @selectors ||= {}
+      end
+
+      def add(name, &block)
+        all[name.to_sym] = Capybara::Selector.new(name.to_sym, &block)
+      end
+
+      def update(name, &block)
+        all[name.to_sym].instance_eval(&block)
+      end
+
+      def remove(name)
+        all.delete(name.to_sym)
+      end
+    end
+
+    def initialize(name, &block)
+      @name = name
+      @filter_set = FilterSet.add(name){}
+      @match = nil
+      @label = nil
+      @failure_message = nil
+      @description = nil
+      @format = nil
+      @expression = nil
+      @expression_filters = []
+      instance_eval(&block)
+    end
+
+    def custom_filters
+      @filter_set.filters
+    end
+
+    ##
+    #
+    # Define a selector by an xpath expression
+    #
+    # @overload xpath(*expression_filters, &block)
+    #   @param [Array<Symbol>] expression_filters ([])  Names of filters that can be implemented via this expression
+    #   @yield [locator, options]                       The block to use to generate the XPath expression
+    #   @yieldparam [String] locator                    The locator string passed to the query
+    #   @yieldparam [Hash] options                      The options hash passed to the query
+    #   @yieldreturn [#to_xpath, #to_s]                 An object that can produce an xpath expression
+    #
+    # @overload xpath()
+    # @return [#call]                             The block that will be called to generate the XPath expression
+    #
+    def xpath(*expression_filters, &block)
+      @format, @expression_filters, @expression = :xpath, expression_filters.flatten, block if block
+      format == :xpath ? @expression : nil
+    end
+
+    ##
+    #
+    # Define a selector by a CSS selector
+    #
+    # @overload css(*expression_filters, &block)
+    #   @param [Array<Symbol>] expression_filters ([])  Names of filters that can be implemented via this CSS selector
+    #   @yield [locator, options]                   The block to use to generate the CSS selector
+    #   @yieldparam [String] locator               The locator string passed to the query
+    #   @yieldparam [Hash] options                 The options hash passed to the query
+    #   @yieldreturn [#to_s]                        An object that can produce a CSS selector
+    #
+    # @overload css()
+    # @return [#call]                             The block that will be called to generate the CSS selector
+    #
+    def css(*expression_filters, &block)
+      @format, @expression_filters, @expression = :css, expression_filters.flatten, block if block
+      format == :css ? @expression : nil
+    end
+
+    ##
+    #
+    # Automatic selector detection
+    #
+    # @yield [locator]                   This block takes the passed in locator string and returns whether or not it matches the selector
+    # @yieldparam [String], locator      The locator string used to determin if it matches the selector
+    # @yieldreturn [Boolean]             Whether this selector matches the locator string
+    # @return [#call]                    The block that will be used to detect selector match
+    #
+    def match(&block)
+      @match = block if block
+      @match
+    end
+
+    ##
+    #
+    # Set/get a descriptive label for the selector
+    #
+    # @overload label(label)
+    #   @param [String] label            A descriptive label for this selector - used in error messages
+    # @overload label()
+    # @return [String]                 The currently set label
+    #
+    def label(label=nil)
+      @label = label if label
+      @label
+    end
+
+    ##
+    #
+    # Description of the selector
+    #
+    # @param [Hash] options            The options of the query used to generate the description
+    # @return [String]                 Description of the selector when used with the options passed
+    #
+    def description(options={})
+      @filter_set.description(options)
+    end
+
+    def call(locator, options={})
+      if format
+        # @expression.call(locator, options.select {|k,v| @expression_filters.include?(k)})
+        @expression.call(locator, options)
+      else
+        warn "Selector has no format"
+      end
+    end
+
+    ##
+    #
+    #  Should this selector be used for the passed in locator
+    #
+    #  This is used by the automatic selector selection mechanism when no selector type is passed to a selector query
+    #
+    # @param [String] locator     The locator passed to the query
+    # @return [Boolean]           Whether or not to use this selector
+    #
+    def match?(locator)
+      @match and @match.call(locator)
+    end
+
+    ##
+    #
+    # Define a non-expression filter for use with this selector
+    #
+    # @overload filter(name, *types, options={}, &block)
+    #   @param [Symbol] name            The filter name
+    #   @param [Array<Symbol>] types    The types of the filter - currently valid types are [:boolean]
+    #   @param [Hash] options ({})      Options of the filter
+    #   @option options [Array<>] :valid_values Valid values for this filter
+    #   @option options :default        The default value of the filter (if any)
+    #   @option options :skip_if        Value of the filter that will cause it to be skipped
+    #
+    def filter(name, *types_and_options, &block)
+      options = types_and_options.last.is_a?(Hash) ? types_and_options.pop.dup : {}
+      types_and_options.each { |k| options[k] = true}
+      custom_filters[name] = Filter.new(name, block, options)
+    end
+
+    def filter_set(name, filters_to_use = nil)
+      f_set = FilterSet.all[name]
+      f_set.filters.each do | name, filter |
+        custom_filters[name] = filter if filters_to_use.nil? || filters_to_use.include?(name)
+      end
+      f_set.descriptions.each { |desc| @filter_set.describe &desc }
+    end
+
+    def describe &block
+      @filter_set.describe &block
+    end
+
+    private
+
+    def locate_field(xpath, locator, options={})
+      locate_xpath = xpath #need to save original xpath for the label wrap
+      if locator
+        locator = locator.to_s
+        attr_matchers =  XPath.attr(:id).equals(locator) |
+                         XPath.attr(:name).equals(locator) |
+                         XPath.attr(:placeholder).equals(locator) |
+                         XPath.attr(:id).equals(XPath.anywhere(:label)[XPath.string.n.is(locator)].attr(:for))
+        attr_matchers |= XPath.attr(:'aria-label').is(locator) if Capybara.enable_aria_label
+
+        locate_xpath = locate_xpath[attr_matchers]
+        locate_xpath += XPath.descendant(:label)[XPath.string.n.is(locator)].descendant(xpath)
+      end
+
+      locate_xpath = [:id, :name, :placeholder, :class].inject(locate_xpath) { |memo, ef| memo[find_by_attr(ef, options[ef])] }
+      locate_xpath
+    end
+
+    def find_by_attr(attribute, value)
+      finder_name = "find_by_#{attribute.to_s}_attr"
+      if respond_to?(finder_name, true)
+        send(finder_name, value)
+      else
+        value ? XPath.attr(attribute).equals(value) : nil
+      end
+    end
+
+    def find_by_class_attr(classes)
+      if classes
+        Array(classes).map do |klass|
+          "contains(concat(' ',normalize-space(@class),' '),' #{klass} ')"
+        end.join(" and ").to_sym
+      else
+        nil
+      end
+    end
+  end
+end