capybara 2.7.1 → 2.8.0

data/lib/capybara/node/base.rb

@@ -23,7 +23,7 @@ module Capybara
     #     session.has_css?('#foobar')               # from Capybara::Node::Matchers
     #
     class Base
-      attr_reader :session, :base, :parent
+      attr_reader :session, :base, :query_scope
 
       include Capybara::Node::Finders
       include Capybara::Node::Actions
@@ -108,6 +108,12 @@ module Capybara
         base.find_xpath(xpath)
       end
 
+      # @deprecated Use query_scope instead
+      def parent
+        warn "DEPRECATED: #parent is deprecated in favor of #query_scope - Note: #parent was not the elements parent in the document so it's most likely not what you wanted anyway"
+        query_scope
+      end
+
     protected
 
       def catch_error?(error, errors = nil)

data/lib/capybara/node/element.rb

@@ -23,9 +23,9 @@ module Capybara
     #
     class Element < Base
 
-      def initialize(session, base, parent, query)
+      def initialize(session, base, query_scope, query)
         super(session, base)
-        @parent = parent
+        @query_scope = query_scope
         @query = query
       end
 
@@ -282,6 +282,26 @@ module Capybara
         synchronize { base.disabled? }
       end
 
+      ##
+      #
+      # Whether or not the element is readonly.
+      #
+      # @return [Boolean]     Whether the element is readonly
+      #
+      def readonly?
+        synchronize { base.readonly? }
+      end
+
+      ##
+      #
+      # Whether or not the element supports multiple results.
+      #
+      # @return [Boolean]     Whether the element supports multiple results.
+      #
+      def multiple?
+        synchronize { base.multiple? }
+      end
+
       ##
       #
       # An XPath expression describing where on the page the element can be found
@@ -320,7 +340,7 @@ module Capybara
       def reload
         if @allow_reload
           begin
-            reloaded = parent.reload.first(@query.name, @query.locator, @query.options)
+            reloaded = query_scope.reload.first(@query.name, @query.locator, @query.options)
             @base = reloaded.base if reloaded
           rescue => e
             raise e unless catch_error?(e)

data/lib/capybara/node/finders.rb

@@ -33,14 +33,14 @@ module Capybara
         synchronize(query.wait) do
           if query.match == :smart or query.match == :prefer_exact
             result = query.resolve_for(self, true)
-            result = query.resolve_for(self, false) if result.size == 0 && !query.exact?
+            result = query.resolve_for(self, false) if result.empty? && !query.exact?
           else
             result = query.resolve_for(self)
           end
           if query.match == :one or query.match == :smart and result.size > 1
             raise Capybara::Ambiguous.new("Ambiguous match, found #{result.size} elements matching #{query.description}")
           end
-          if result.size == 0
+          if result.empty?
             raise Capybara::ElementNotFound.new("Unable to find #{query.description}")
           end
           result.first
@@ -51,22 +51,30 @@ module Capybara
       #
       # Find a form field on the page. The field can be found by its name, id or label text.
       #
-      # @macro waiting_behavior
-      #
-      # @param [String] locator             Which field to find
-      #
-      # @option options [Boolean] checked  Match checked field?
-      # @option options [Boolean] unchecked   Match unchecked field?
-      # @option options [Boolean, Symbol] disabled (false)  Match disabled field?
-      #                                                     * true - only finds a disabled field
-      #                                                     * false - only finds an enabled field
-      #                                                     * :all - finds either an enabled or disabled field
-      # @option options [Boolean] readonly Match readonly field?
-      # @option options [String] with   Value of field to match on
-      # @option options [String] type   Type of field to match on
+      # @overload find_field([locator], options={})
+      #   @param [String] locator             name, id, placeholder or text of associated label element
+      #
+      #   @macro waiting_behavior
+      #
+      #
+      #   @option options [Boolean] checked       Match checked field?
+      #   @option options [Boolean] unchecked     Match unchecked field?
+      #   @option options [Boolean, Symbol] disabled (false)  Match disabled field?
+      #                                                       * true - only finds a disabled field
+      #                                                       * false - only finds an enabled field
+      #                                                       * :all - finds either an enabled or disabled field
+      #   @option options [Boolean] readonly      Match readonly field?
+      #   @option options [String, Regexp] with   Value of field to match on
+      #   @option options [String] type           Type of field to match on
+      #   @option options [Boolean] multiple      Match fields that can have multiple values?
+      #   @option options [String] id             Match fields that match the id attribute
+      #   @option options [String] name           Match fields that match the name attribute
+      #   @option options [String] placeholder    Match fields that match the placeholder attribute
       # @return [Capybara::Node::Element]   The found element
       #
-      def find_field(locator, options={})
+
+      def find_field(locator=nil, options={})
+        locator, options = nil, locator if locator.is_a? Hash
         find(:field, locator, options)
       end
       alias_method :field_labeled, :find_field
@@ -75,13 +83,16 @@ module Capybara
       #
       # Find a link on the page. The link can be found by its id or text.
       #
-      # @macro waiting_behavior
+      # @overload find_link([locator], options={})
+      #   @param [String] locator            id, title, text, or alt of enclosed img element
+      #
+      #   @macro waiting_behavior
       #
-      # @param [String] locator             Which link to find
-      # @option options [String,Regexp] href        Value to match against the links href
+      #   @option options [String,Regexp] href        Value to match against the links href
       # @return [Capybara::Node::Element]   The found element
       #
-      def find_link(locator, options={})
+      def find_link(locator=nil, options={})
+        locator, options = nil, locator if locator.is_a? Hash
         find(:link, locator, options)
       end
 
@@ -91,17 +102,22 @@ module Capybara
       # This can be any \<input> element of type submit, reset, image, button or it can be a
       # \<button> element. All buttons can be found by their id, value, or title. \<button> elements can also be found
       # by their text content, and image \<input> elements by their alt attribute
-
-      # @macro waiting_behavior
       #
-      # @param [String] locator             Which button to find
-      # @option options [Boolean, Symbol] disabled (false)  Match disabled button?
-      #                                                     * true - only finds a disabled button
-      #                                                     * false - only finds an enabled button
-      #                                                     * :all - finds either an enabled or disabled button
+      # @overload find_button([locator], options={})
+      #   @param [String] locator            id, value, title, text content, alt of image
+      #
+      #   @overload find_button(options={})
+      #
+      #   @macro waiting_behavior
+      #
+      #   @option options [Boolean, Symbol] disabled (false)  Match disabled button?
+      #                                                       * true - only finds a disabled button
+      #                                                       * false - only finds an enabled button
+      #                                                       * :all - finds either an enabled or disabled button
       # @return [Capybara::Node::Element]   The found element
       #
-      def find_button(locator, options={})
+      def find_button(locator=nil, options={})
+        locator, options = nil, locator if locator.is_a? Hash
         find(:button, locator, options)
       end
 
@@ -111,7 +127,7 @@ module Capybara
       #
       # @macro waiting_behavior
       #
-      # @param [String] id                  Which element to find
+      # @param [String] id                  id of element
       #
       # @return [Capybara::Node::Element]   The found element
       #

data/lib/capybara/node/matchers.rb

@@ -123,8 +123,7 @@ module Capybara
         query = Capybara::Queries::SelectorQuery.new(*args)
         synchronize(query.wait) do
           result = query.resolve_for(self)
-          matches_count = Capybara::Helpers.matches_count?(result.size, query.options)
-          unless matches_count && ((result.size > 0) || Capybara::Helpers.expects_none?(query.options))
+          unless result.matches_count? && ((!result.empty?) || Capybara::Helpers.expects_none?(query.options))
             raise Capybara::ExpectationNotMet, result.failure_message
           end
         end
@@ -151,8 +150,7 @@ module Capybara
         query = Capybara::Queries::SelectorQuery.new(*args)
         synchronize(query.wait) do
           result = query.resolve_for(self)
-          matches_count = Capybara::Helpers.matches_count?(result.size, query.options)
-          if matches_count && ((result.size > 0) || Capybara::Helpers.expects_none?(query.options))
+          if result.matches_count? && ((!result.empty?) || Capybara::Helpers.expects_none?(query.options))
             raise Capybara::ExpectationNotMet, result.negative_failure_message
           end
         end
@@ -179,7 +177,7 @@ module Capybara
       def assert_matches_selector(*args)
         query = Capybara::Queries::MatchQuery.new(*args)
         synchronize(query.wait) do
-          result = query.resolve_for(self.parent)
+          result = query.resolve_for(self.query_scope)
           unless result.include? self
             raise Capybara::ExpectationNotMet, "Item does not match the provided selector"
           end
@@ -190,7 +188,7 @@ module Capybara
       def assert_not_matches_selector(*args)
         query = Capybara::Queries::MatchQuery.new(*args)
         synchronize(query.wait) do
-          result = query.resolve_for(self.parent)
+          result = query.resolve_for(self.query_scope)
           if result.include? self
             raise Capybara::ExpectationNotMet, 'Item matched the provided selector'
           end
@@ -350,10 +348,10 @@ module Capybara
       #
       # Note: 'textarea' and 'select' are valid type values, matching the associated tag names.
       #
-      # @param [String] locator           The label, name or id of a field to check for
-      # @option options [String] :with    The text content of the field
-      # @option options [String] :type    The type attribute of the field
-      # @return [Boolean]                 Whether it exists
+      # @param [String] locator                  The label, name or id of a field to check for
+      # @option options [String, Regexp] :with   The text content of the field or a Regexp to match
+      # @option options [String] :type           The type attribute of the field
+      # @return [Boolean]                        Whether it exists
       #
       def has_field?(locator, options={})
         has_selector?(:field, locator, options)
@@ -364,10 +362,10 @@ module Capybara
       # Checks if the page or current node has no form field with the given
       # label, name or id. See {Capybara::Node::Matchers#has_field?}.
       #
-      # @param [String] locator           The label, name or id of a field to check for
-      # @option options [String] :with    The text content of the field
-      # @option options [String] :type    The type attribute of the field
-      # @return [Boolean]                 Whether it doesn't exist
+      # @param [String] locator                  The label, name or id of a field to check for
+      # @option options [String, Regexp] :with   The text content of the field or a Regexp to match
+      # @option options [String] :type           The type attribute of the field
+      # @return [Boolean]                        Whether it doesn't exist
       #
       def has_no_field?(locator, options={})
         has_no_selector?(:field, locator, options)
@@ -501,7 +499,7 @@ module Capybara
       #
       # @!macro text_query_params
       #   @overload $0(type, text, options = {})
-      #     @param [:all, :visible] type               Whether to check for only visible or all text
+      #     @param [:all, :visible] type               Whether to check for only visible or all text. If this parameter is missing or nil then we use the value of `Capybara.ignore_hidden_elements`, which defaults to `true`, corresponding to `:visible`.
       #     @param [String, Regexp] text               The string/regexp to check for. If it's a string, text is expected to include it. If it's a regexp, text is expected to match it.
       #     @option options [Integer] :count (nil)     Number of times the text is expected to occur
       #     @option options [Integer] :minimum (nil)   Minimum number of times the text is expected to occur

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]
+      VALID_KEYS = [:text, :visible, :between, :count, :maximum, :minimum, :exact, :match, :wait, :filter_set]
       VALID_MATCH = [:first, :smart, :prefer_exact, :one]
 
       def initialize(*args)
@@ -45,15 +45,19 @@ module Capybara
           regexp = options[:text].is_a?(Regexp) ? options[:text] : Regexp.escape(options[:text].to_s)
           return false if not node.text(visible).match(regexp)
         end
+
         case visible
           when :visible then return false unless node.visible?
           when :hidden then return false if node.visible?
         end
-        selector.custom_filters.each do |name, filter|
+
+        query_filters.all? do |name, filter|
           if options.has_key?(name)
-            return false unless filter.matches?(node, options[name])
+            filter.matches?(node, options[name])
           elsif filter.default?
-            return false unless filter.matches?(node, filter.default)
+            filter.matches?(node, filter.default)
+          else
+            true
           end
         end
       end
@@ -124,7 +128,20 @@ module Capybara
       private
 
       def valid_keys
-        COUNT_KEYS + [:text, :visible, :exact, :match, :wait] + @selector.custom_filters.keys
+       vk = COUNT_KEYS + [:text, :visible, :exact, :match, :wait, :filter_set]
+       vk + custom_keys
+      end
+
+      def query_filters
+        if options.has_key?(:filter_set)
+          Capybara::Selector::FilterSet.all[options[:filter_set]].filters
+        else
+          @selector.custom_filters
+        end
+      end
+
+      def custom_keys
+        query_filters.keys
       end
 
       def assert_valid_keys

data/lib/capybara/queries/text_query.rb

@@ -5,6 +5,7 @@ module Capybara
     class TextQuery < BaseQuery
       def initialize(*args)
         @type = (args.first.is_a?(Symbol) || args.first.nil?) ? args.shift : nil
+        @type = (Capybara.ignore_hidden_elements or Capybara.visible_text_only) ? :visible : :all if @type.nil?
         @expected_text, @options = args
         unless @expected_text.is_a?(Regexp)
           @expected_text = Capybara::Helpers.normalize_whitespace(@expected_text)
@@ -15,11 +16,22 @@ module Capybara
       end
 
       def resolve_for(node)
-        @actual_text = Capybara::Helpers.normalize_whitespace(node.text(@type))
+        @node = node
+        @actual_text = text(node, @type)
         @count = @actual_text.scan(@search_regexp).size
       end
 
       def failure_message
+        build_message(true)
+      end
+
+      def negative_failure_message
+        build_message(false).sub(/(to find)/, 'not \1')
+      end
+
+      private
+
+      def build_message(report_on_invisible)
         description =
           if @expected_text.is_a?(Regexp)
             "text matching #{@expected_text.inspect}"
@@ -32,17 +44,41 @@ module Capybara
           message << " but found #{@count} #{Capybara::Helpers.declension('time', 'times', @count)}"
         end
         message << " in #{@actual_text.inspect}"
-      end
 
-      def negative_failure_message
-        failure_message.sub(/(to find)/, 'not \1')
-      end
+        details_message = []
 
-      private
+        if @node and !@expected_text.is_a? Regexp
+          insensitive_regexp = Regexp.new(@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"
+          end
+        end
+
+        if @node and check_visible_text? and report_on_invisible
+          invisible_text = text(@node, :all)
+          invisible_count = invisible_text.scan(@search_regexp).size
+          if invisible_count != @count
+            details_message << ". it was found #{invisible_count} #{Capybara::Helpers.declension("time", "times", invisible_count)} including non-visible text"
+          end
+        end
+
+        message << ". (However, #{details_message.join(' and ')}.)" unless details_message.empty?
+
+        message
+      end
 
       def valid_keys
         COUNT_KEYS + [:wait]
       end
+
+      def check_visible_text?
+        @type == :visible
+      end
+
+      def text(node, query_type)
+        Capybara::Helpers.normalize_whitespace(node.text(query_type))
+      end
     end
   end
 end

data/lib/capybara/rack_test/node.rb

@@ -17,7 +17,7 @@ class Capybara::RackTest::Node < Capybara::Driver::Node
   end
 
   def set(value)
-    if (Array === value) && !self[:multiple]
+    if (Array === value) && !multiple?
       raise ArgumentError.new "Value cannot be an Array when 'multiple' attribute is not present. Not a #{value.class}"
     end
 
@@ -60,6 +60,16 @@ class Capybara::RackTest::Node < Capybara::Driver::Node
         ((tag_name == 'button') and type.nil? or type == "submit")
       associated_form = form
       Capybara::RackTest::Form.new(driver, associated_form).submit(self) if associated_form
+    elsif (tag_name == 'label')
+      labelled_control = if native[:for]
+        find_xpath("//input[@id='#{native[:for]}']").first
+      else
+        find_xpath(".//input").first
+      end
+
+      if labelled_control && (labelled_control.checkbox? || labelled_control.radio?)
+        labelled_control.set(!labelled_control.checked?)
+      end
     end
   end
 
@@ -183,6 +193,8 @@ private
     self[attribute] && !self[attribute].empty?
   end
 
+protected
+
   def checkbox?
     input_field? && type == 'checkbox'
   end

data/lib/capybara/result.rb

@@ -25,27 +25,74 @@ module Capybara
 
     def initialize(elements, query)
       @elements = elements
-      @result = elements.select { |node| query.matches_filters?(node) }
-      @rest = @elements - @result
+      @result_cache = []
+      @results_enum = lazy_select_elements { |node| query.matches_filters?(node) }
       @query = query
     end
 
-    def_delegators :@result, :each, :[], :at, :size, :count, :length,
-                   :first, :last, :values_at, :empty?, :inspect, :sample, :index
+    def_delegators :full_results, :size, :length, :last, :values_at, :inspect, :sample
+
+    alias :index :find_index
+
+    def each(&block)
+      @result_cache.each(&block)
+      loop do
+        next_result = @results_enum.next
+        @result_cache << next_result
+        block.call(next_result)
+      end
+      self
+    end
+
+    def [](*args)
+      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
+        full_results[*args]
+      end
+    rescue StopIteration
+      return nil
+    end
+    alias :at :[]
+
+    def empty?
+      !any?
+    end
 
     def matches_count?
-      Capybara::Helpers.matches_count?(@result.size, @query.options)
+      return Integer(@query.options[:count]) == count if @query.options[:count]
+
+      return false if @query.options[:between] && !(@query.options[:between] === count)
+
+      if @query.options[:minimum]
+        begin
+          @result_cache << @results_enum.next while @result_cache.size < Integer(@query.options[:minimum])
+        rescue StopIteration
+          return false
+        end
+      end
+
+      if @query.options[:maximum]
+        begin
+          @result_cache << @results_enum.next while @result_cache.size <= Integer(@query.options[:maximum])
+          return false
+        rescue StopIteration
+        end
+      end
+
+      return true
     end
 
     def failure_message
       message = Capybara::Helpers.failure_message(@query.description, @query.options)
       if count > 0
-        message << ", found #{count} #{Capybara::Helpers.declension("match", "matches", count)}: " << @result.map(&:text).map(&:inspect).join(", ")
+        message << ", found #{count} #{Capybara::Helpers.declension("match", "matches", count)}: " << full_results.map(&:text).map(&:inspect).join(", ")
       else
         message << " but there were no matches"
       end
-      unless @rest.empty?
-        elements = @rest.map(&:text).map(&:inspect).join(", ")
+      unless rest.empty?
+        elements = rest.map(&:text).map(&:inspect).join(", ")
         message << ". Also found " << elements << ", which matched the selector but not all filters."
       end
       message
@@ -54,5 +101,30 @@ module Capybara
     def negative_failure_message
       failure_message.sub(/(to find)/, 'not \1')
     end
+
+    private
+
+    def full_results
+      loop do
+        @result_cache << @results_enum.next
+      end
+      @result_cache
+    end
+
+    def rest
+      @rest ||= @elements - full_results
+    end
+
+    def lazy_select_elements(&block)
+      if @elements.respond_to? :lazy  #Ruby 2.0+
+        @elements.lazy.select &block
+      else
+        Enumerator.new do |yielder|
+          @elements.each do |val|
+            yielder.yield(val) if block.call(val)
+          end
+        end
+      end
+    end
   end
 end