capybara 2.6.2 → 2.7.0

data/lib/capybara/queries/text_query.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Capybara
   # @api private
   module Queries

data/lib/capybara/queries/title_query.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Capybara
   # @api private
   module Queries

data/lib/capybara/query.rb

@@ -1,135 +1,7 @@
+# frozen_string_literal: true
+require 'capybara/queries/selector_query'
 module Capybara
   # @deprecated This class and its methods are not supposed to be used by users of Capybara's public API.
   #   It may be removed in future versions of Capybara.
-  class Query < Queries::BaseQuery
-    attr_accessor :selector, :locator, :options, :expression, :find, :negative
-
-    VALID_KEYS = [:text, :visible, :between, :count, :maximum, :minimum, :exact, :match, :wait]
-    VALID_MATCH = [:first, :smart, :prefer_exact, :one]
-
-    def initialize(*args)
-      @options = if args.last.is_a?(Hash) then args.pop.dup else {} end
-
-      if args[0].is_a?(Symbol)
-        @selector = Selector.all[args[0]]
-        @locator = args[1]
-      else
-        @selector = Selector.all.values.find { |s| s.match?(args[0]) }
-        @locator = args[0]
-      end
-      @selector ||= Selector.all[Capybara.default_selector]
-
-      # for compatibility with Capybara 2.0
-      if Capybara.exact_options and @selector == Selector.all[:option]
-        @options[:exact] = true
-      end
-
-      @expression = @selector.call(@locator)
-      assert_valid_keys
-    end
-
-    def name; selector.name; end
-    def label; selector.label or selector.name; end
-
-    def description
-      @description = "#{label} #{locator.inspect}"
-      @description << " with text #{options[:text].inspect}" if options[:text]
-      @description << selector.description(options)
-      @description
-    end
-
-    def matches_filters?(node)
-      if options[:text]
-        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|
-        if options.has_key?(name)
-          return false unless filter.matches?(node, options[name])
-        elsif filter.default?
-          return false unless filter.matches?(node, filter.default)
-        end
-      end
-    end
-
-    def visible
-      if options.has_key?(:visible)
-        case @options[:visible]
-          when true then :visible
-          when false then :all
-          else @options[:visible]
-        end
-      else
-        if Capybara.ignore_hidden_elements
-          :visible
-        else
-          :all
-        end
-      end
-    end
-
-    def exact?
-      if options.has_key?(:exact)
-        @options[:exact]
-      else
-        Capybara.exact
-      end
-    end
-
-    def match
-      if options.has_key?(:match)
-        @options[:match]
-      else
-        Capybara.match
-      end
-    end
-
-    def xpath(exact=nil)
-      exact = self.exact? if exact == nil
-      if @expression.respond_to?(:to_xpath) and exact
-        @expression.to_xpath(:exact)
-      else
-        @expression.to_s
-      end
-    end
-
-    def css
-      @expression
-    end
-
-    # @api private
-    def resolve_for(node, exact = nil)
-      node.synchronize do
-        children = if selector.format == :css
-          node.find_css(self.css)
-        else
-          node.find_xpath(self.xpath(exact))
-        end.map do |child|
-          if node.is_a?(Capybara::Node::Base)
-            Capybara::Node::Element.new(node.session, child, node, self)
-          else
-            Capybara::Node::Simple.new(child)
-          end
-        end
-        Capybara::Result.new(children, self)
-      end
-    end
-
-    private
-
-    def valid_keys
-      COUNT_KEYS + [:text, :visible, :exact, :match, :wait] + @selector.custom_filters.keys
-    end
-
-    def assert_valid_keys
-      super
-      unless VALID_MATCH.include?(match)
-        raise ArgumentError, "invalid option #{match.inspect} for :match, should be one of #{VALID_MATCH.map(&:inspect).join(", ")}"
-      end
-    end
-  end
+  Query = Queries::SelectorQuery
 end

data/lib/capybara/rack_test/browser.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class Capybara::RackTest::Browser
   include ::Rack::Test::Methods
 

data/lib/capybara/rack_test/css_handlers.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class Capybara::RackTest::CSSHandlers < BasicObject
   include ::Kernel
   

data/lib/capybara/rack_test/driver.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'rack/test'
 require 'rack/utils'
 require 'mime/types'
@@ -65,11 +66,11 @@ class Capybara::RackTest::Driver < Capybara::Driver::Base
   def find_xpath(selector)
     browser.find(:xpath, selector)
   end
-  
+
   def find_css(selector)
     browser.find(:css,selector)
   end
-  
+
   def html
     browser.html
   end
@@ -77,7 +78,7 @@ class Capybara::RackTest::Driver < Capybara::Driver::Base
   def dom
     browser.dom
   end
-  
+
   def title
     browser.title
   end
@@ -86,8 +87,9 @@ class Capybara::RackTest::Driver < Capybara::Driver::Base
     @browser = nil
   end
 
+  # @deprecated This method is being removed
   def browser_initialized?
-    !@browser.nil?
+    super && !@browser.nil?
   end
 
   def get(*args, &block); browser.get(*args, &block); end

data/lib/capybara/rack_test/form.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class Capybara::RackTest::Form < Capybara::RackTest::Node
   # This only needs to inherit from Rack::Test::UploadedFile because Rack::Test checks for
   # the class specifically when determining whether to construct the request as multipart.

data/lib/capybara/rack_test/node.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class Capybara::RackTest::Node < Capybara::Driver::Node
   def all_text
     Capybara::Helpers.normalize_whitespace(native.text)

data/lib/capybara/rails.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'capybara/dsl'
 
 Capybara.app = Rack::Builder.new do
@@ -11,7 +12,7 @@ Capybara.app = Rack::Builder.new do
   end
 end.to_app
 
-Capybara.save_and_open_page_path = Rails.root.join('tmp/capybara')
+Capybara.save_path = Rails.root.join('tmp/capybara')
 
 # Override default rack_test driver to respect data-method attributes.
 Capybara.register_driver :rack_test do |app|

data/lib/capybara/result.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'forwardable'
 
 module Capybara

data/lib/capybara/rspec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'capybara/dsl'
 require 'rspec/core'
 require 'capybara/rspec/matchers'

data/lib/capybara/rspec/features.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 if RSpec::Core::Version::STRING.to_f >= 3.0
   RSpec.shared_context "Capybara Features", :capybara_feature => true do
     instance_eval do

data/lib/capybara/rspec/matchers.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
 module Capybara
   module RSpecMatchers
     class Matcher
-      include ::RSpec::Matchers::Composable if defined?(::RSpec::Expectations::Version) && RSpec::Expectations::Version::STRING.to_f >= 3.0
+      include ::RSpec::Matchers::Composable if defined?(::RSpec::Expectations::Version) && (Gem::Version.new(RSpec::Expectations::Version::STRING) >= Gem::Version.new('3.0'))
 
       def wrap(actual)
         if actual.respond_to?("has_selector?")
@@ -38,7 +39,7 @@ module Capybara
       end
 
       def query
-        @query ||= Capybara::Query.new(*@args)
+        @query ||= Capybara::Queries::SelectorQuery.new(*@args)
       end
 
       # RSpec 2 compatibility:
@@ -160,7 +161,7 @@ module Capybara
 
     class BecomeClosed
       def initialize(options)
-        @wait_time = Capybara::Query.new(options).wait
+        @wait_time = Capybara::Queries::SelectorQuery.new(options).wait
       end
 
       def matches?(window)
@@ -186,18 +187,68 @@ module Capybara
       alias_method :failure_message_for_should_not, :failure_message_when_negated
     end
 
+    class MatchSelector < Matcher
+      attr_reader :failure_message, :failure_message_when_negated
+
+      def initialize(*args)
+        @args = args
+      end
+
+      def matches?(actual)
+        actual.assert_matches_selector(*@args)
+      rescue Capybara::ExpectationNotMet => e
+        @failure_message = e.message
+        return false
+      end
+
+      def does_not_match?(actual)
+        actual.assert_not_matches_selector(*@args)
+      rescue Capybara::ExpectationNotMet => e
+        @failure_message_when_negated = e.message
+        return false
+      end
+
+      def description
+        "match #{query.description}"
+      end
+
+      def query
+        @query ||= Capybara::Queries::MatchQuery.new(*@args)
+      end
+
+      # RSpec 2 compatibility:
+      alias_method :failure_message_for_should, :failure_message
+      alias_method :failure_message_for_should_not, :failure_message_when_negated
+    end
+
     def have_selector(*args)
       HaveSelector.new(*args)
     end
 
+    def match_selector(*args)
+      MatchSelector.new(*args)
+    end
+    # defined_negated_matcher was added in RSpec 3.1 - it's syntactic sugar only since a user can do
+    # expect(page).not_to match_selector, so not sure we really need to support not_match_selector for prior to RSpec 3.1
+    ::RSpec::Matchers.define_negated_matcher :not_match_selector, :match_selector if defined?(::RSpec::Expectations::Version) && (Gem::Version.new(RSpec::Expectations::Version::STRING) >= Gem::Version.new('3.1'))
+
+
     def have_xpath(xpath, options={})
       HaveSelector.new(:xpath, xpath, options)
     end
 
+    def match_xpath(xpath, options={})
+      MatchSelector.new(:xpath, xpath, options)
+    end
+
     def have_css(css, options={})
       HaveSelector.new(:css, css, options)
     end
 
+    def match_css(css, options={})
+      MatchSelector.new(:css, css, options)
+    end
+
     def have_text(*args)
       HaveText.new(*args)
     end

data/lib/capybara/selector.rb

@@ -1,42 +1,8 @@
+# frozen_string_literal: true
+require 'capybara/selector/filter'
+
 module Capybara
   class Selector
-    class Filter
-      def initialize(name, block, options={})
-        @name = name
-        @block = block
-        @options = options
-        @options[:valid_values] = [true,false] if options[:boolean]
-      end
-
-      def default?
-        @options.has_key?(:default)
-      end
-
-      def default
-        @options[:default]
-      end
-
-      def matches?(node, value)
-        return true if skip?(value)
-
-        if @options.has_key?(:valid_values) && !Array(@options[:valid_values]).include?(value)
-          msg = "Invalid value #{value.inspect} passed to filter #{@name} - "
-          if default?
-            warn msg + "defaulting to #{default}"
-            value = default
-          else
-            warn msg + "skipping"
-            return true
-          end
-        end
-
-        @block.call(node, value)
-      end
-
-      def skip?(value)
-        @options.has_key?(:skip_if) && value == @options[:skip_if]
-      end
-    end
 
     attr_reader :name, :custom_filters, :format
 
@@ -65,24 +31,19 @@ module Capybara
       @label = nil
       @failure_message = nil
       @description = nil
+      @format = nil
+      @expression = nil
       instance_eval(&block)
     end
 
     def xpath(&block)
-      if block
-        @format = :xpath
-        @xpath, @css = block, nil
-      end
-      @xpath
+      @format, @expression = :xpath, block if block
+      format == :xpath ? @expression : nil
     end
 
-    # Same as xpath, but wrap in XPath.css().
     def css(&block)
-      if block
-        @format = :css
-        @css, @xpath = block, nil
-      end
-      @css
+      @format, @expression = :css, block if block
+      format == :css ? @expression : nil
     end
 
     def match(&block)
@@ -100,10 +61,10 @@ module Capybara
     end
 
     def call(locator)
-      if @format==:css
-        @css.call(locator)
+      if format
+        @expression.call(locator)
       else
-        @xpath.call(locator)
+        warn "Selector has no format"
       end
     end
 
@@ -118,6 +79,17 @@ module Capybara
     def describe &block
       @description = block
     end
+
+    private
+
+    def locate_field(xpath, locator)
+      locate_field = xpath[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))]
+      locate_field += XPath.descendant(:label)[XPath.string.n.is(locator)].descendant(xpath)
+      locate_field
+    end
   end
 end
 
@@ -134,7 +106,11 @@ Capybara.add_selector(:id) do
 end
 
 Capybara.add_selector(:field) do
-  xpath { |locator| XPath::HTML.field(locator) }
+  xpath do |locator|
+    xpath = XPath.descendant(:input, :textarea, :select)[~XPath.attr(:type).one_of('submit', 'image', 'hidden')]
+    xpath = locate_field(xpath, locator.to_s) unless locator.nil?
+    xpath
+  end
   filter(:checked, boolean: true) { |node, value| not(value ^ node.checked?) }
   filter(:unchecked, boolean: true) { |node, value| (value ^ node.checked?) }
   filter(:disabled, default: false, boolean: true, skip_if: :all) { |node, value| not(value ^ node.disabled?) }
@@ -147,31 +123,42 @@ Capybara.add_selector(:field) do
       node[:type] == type
     end
   end
+  filter(:multiple, boolean: true) { |node, value| !(value ^ node[:multiple]) }
   describe do |options|
-    desc, states = "", []
+    desc, states = String.new, []
     desc << " of type #{options[:type].inspect}" if options[:type]
     desc << " with value #{options[:with].to_s.inspect}" if options.has_key?(:with)
     states << 'checked' if options[:checked] || (options.has_key?(:unchecked) && !options[:unchecked])
     states << 'not checked' if options[:unchecked] || (options.has_key?(:checked) && !options[:checked])
     states << 'disabled' if options[:disabled] == true
     desc << " that is #{states.join(' and ')}" unless states.empty?
+    desc << " with the multiple attribute" if options[:multiple] == true
+    desc << " without the multiple attribute" if options[:multiple] === false
     desc
   end
 end
 
 Capybara.add_selector(:fieldset) do
-  xpath { |locator| XPath::HTML.fieldset(locator) }
-end
-
-Capybara.add_selector(:link_or_button) do
-  label "link or button"
-  xpath { |locator| XPath::HTML.link_or_button(locator) }
-  filter(:disabled, default: false, boolean: true) { |node, value| node.tag_name == "a" or not(value ^ node.disabled?) }
-  describe { |options| " that is disabled" if options[:disabled] }
+  xpath do |locator|
+    xpath = XPath.descendant(:fieldset)
+    xpath = xpath[XPath.attr(:id).equals(locator.to_s) | XPath.child(:legend)[XPath.string.n.is(locator.to_s)]] unless locator.nil?
+    xpath
+  end
 end
 
 Capybara.add_selector(:link) do
-  xpath { |locator| XPath::HTML.link(locator) }
+  xpath do |locator|
+    xpath = XPath.descendant(:a)[XPath.attr(:href)]
+    unless locator.nil?
+      locator = locator.to_s
+      xpath = xpath[XPath.attr(:id).equals(locator) |
+                    XPath.string.n.is(locator) |
+                    XPath.attr(:title).is(locator) |
+                    XPath.descendant(:img)[XPath.attr(:alt).is(locator)]]
+    end
+    xpath
+  end
+
   filter(:href) do |node, href|
     if href.is_a? Regexp
       node[:href].match href
@@ -179,31 +166,77 @@ Capybara.add_selector(:link) do
       node.first(:xpath, XPath.axis(:self)[XPath.attr(:href).equals(href.to_s)], minimum: 0)
     end
   end
+
   describe { |options| " with href #{options[:href].inspect}" if options[:href] }
 end
 
 Capybara.add_selector(:button) do
-  xpath { |locator| XPath::HTML.button(locator) }
+  xpath do |locator|
+    input_btn_xpath = XPath.descendant(:input)[XPath.attr(:type).one_of('submit', 'reset', 'image', 'button')]
+    btn_xpath = XPath.descendant(:button)
+    image_btn_xpath = XPath.descendant(:input)[XPath.attr(:type).equals('image')]
+
+    unless locator.nil?
+      locator = locator.to_s
+      input_btn_xpath = input_btn_xpath[XPath.attr(:id).equals(locator) | XPath.attr(:value).is(locator) | XPath.attr(:title).is(locator)]
+      btn_xpath = btn_xpath[XPath.attr(:id).equals(locator) | XPath.attr(:value).is(locator) | XPath.string.n.is(locator) | XPath.attr(:title).is(locator)]
+      image_btn_xpath = image_btn_xpath[XPath.attr(:alt).is(locator)]
+    end
+
+    input_btn_xpath + btn_xpath + image_btn_xpath
+  end
+
   filter(:disabled, default: false, boolean: true, skip_if: :all) { |node, value| not(value ^ node.disabled?) }
+
   describe { |options| " that is disabled" if options[:disabled] == true }
 end
 
+Capybara.add_selector(:link_or_button) do
+  label "link or button"
+  xpath do |locator|
+    self.class.all.values_at(:link, :button).map {|selector| selector.xpath.call(locator)}.reduce(:+)
+  end
+
+  filter(:disabled, default: false, boolean: true) { |node, value| node.tag_name == "a" or not(value ^ node.disabled?) }
+
+  describe { |options| " that is disabled" if options[:disabled] }
+end
+
 Capybara.add_selector(:fillable_field) do
   label "field"
-  xpath { |locator| XPath::HTML.fillable_field(locator) }
+  xpath do |locator|
+    xpath = XPath.descendant(:input, :textarea)[~XPath.attr(:type).one_of('submit', 'image', 'radio', 'checkbox', 'hidden', 'file')]
+    xpath = locate_field(xpath, locator.to_s) unless locator.nil?
+    xpath
+  end
+
   filter(:disabled, default: false, boolean: true, skip_if: :all) { |node, value| not(value ^ node.disabled?) }
-  describe { |options| " that is disabled" if options[:disabled] == true }
+  filter(:multiple, boolean: true) { |node, value| !(value ^ node[:multiple]) }
+
+  describe do |options|
+    desc = String.new
+    desc << " that is disabled" if options[:disabled] == true
+    desc << " with the multiple attribute" if options[:multiple] == true
+    desc << " without the multiple attribute" if options[:multiple] === false
+    desc
+  end
 end
 
 Capybara.add_selector(:radio_button) do
   label "radio button"
-  xpath { |locator| XPath::HTML.radio_button(locator) }
+  xpath do |locator|
+    xpath = XPath.descendant(:input)[XPath.attr(:type).equals('radio')]
+    xpath = locate_field(xpath, locator.to_s) unless locator.nil?
+    xpath
+  end
+
   filter(:checked, boolean: true) { |node, value| not(value ^ node.checked?) }
   filter(:unchecked, boolean: true) { |node, value| (value ^ node.checked?) }
   filter(:option)  { |node, value|  node.value == value.to_s }
   filter(:disabled, default: false, boolean: true, skip_if: :all) { |node, value| not(value ^ node.disabled?) }
+
   describe do |options|
-    desc, states = "", []
+    desc, states = String.new, []
     desc << " with value #{options[:option].inspect}" if options[:option]
     states << 'checked' if options[:checked] || (options.has_key?(:unchecked) && !options[:unchecked])
     states << 'not checked' if options[:unchecked] || (options.has_key?(:checked) && !options[:checked])
@@ -214,13 +247,19 @@ Capybara.add_selector(:radio_button) do
 end
 
 Capybara.add_selector(:checkbox) do
-  xpath { |locator| XPath::HTML.checkbox(locator) }
+  xpath do |locator|
+    xpath = XPath.descendant(:input)[XPath.attr(:type).equals('checkbox')]
+    xpath = locate_field(xpath, locator.to_s) unless locator.nil?
+    xpath
+  end
+
   filter(:checked, boolean: true) { |node, value| not(value ^ node.checked?) }
   filter(:unchecked, boolean: true) { |node, value| (value ^ node.checked?) }
   filter(:option)  { |node, value|  node.value == value.to_s }
   filter(:disabled, default: false, boolean: true, skip_if: :all) { |node, value| not(value ^ node.disabled?) }
+
   describe do |options|
-    desc, states = "", []
+    desc, states = String.new, []
     desc << " with value #{options[:option].inspect}" if options[:option]
     states << 'checked' if options[:checked] || (options.has_key?(:unchecked) && !options[:unchecked])
     states << 'not checked' if options[:unchecked] || (options.has_key?(:checked) && !options[:checked])
@@ -232,7 +271,12 @@ end
 
 Capybara.add_selector(:select) do
   label "select box"
-  xpath { |locator| XPath::HTML.select(locator) }
+  xpath do |locator|
+    xpath = XPath.descendant(:select)
+    xpath = locate_field(xpath, locator.to_s) unless locator.nil?
+    xpath
+  end
+
   filter(:options) do |node, options|
     if node.visible?
       actual = node.all(:xpath, './/option').map { |option| option.text }
@@ -253,27 +297,83 @@ Capybara.add_selector(:select) do
     [selected].flatten.sort == actual.sort
   end
   filter(:disabled, default: false, boolean: true, skip_if: :all) { |node, value| not(value ^ node.disabled?) }
+  filter(:multiple, boolean: true) { |node, value| !(value ^ node[:multiple]) }
+
   describe do |options|
-    desc = ""
+    desc = String.new
     desc << " with options #{options[:options].inspect}" if options[:options]
     desc << " with at least options #{options[:with_options].inspect}" if options[:with_options]
     desc << " with #{options[:selected].inspect} selected" if options[:selected]
     desc << " that is disabled" if options[:disabled] == true
+    desc << " that allows multiple selection" if options[:multiple] == true
+    desc << " that only allows single selection" if options[:multiple] === false
     desc
   end
 end
 
 Capybara.add_selector(:option) do
-  xpath { |locator| XPath::HTML.option(locator) }
+  xpath do |locator|
+    xpath = XPath.descendant(:option)
+    xpath = xpath[XPath.string.n.is(locator.to_s)] unless locator.nil?
+    xpath
+  end
+
+  filter(:disabled, boolean: true) { |node, value| not(value ^ node.disabled?) }
+  filter(:selected, boolean: true) { |node, value| not(value ^ node.selected?) }
+
+  describe do |options|
+    desc = String.new
+    desc << " that is#{' not' unless options[:disabled]} disabled" if options.has_key?(:disabled)
+    desc << " that is#{' not' unless options[:selected]} selected" if options.has_key?(:selected)
+    desc
+  end
 end
 
 Capybara.add_selector(:file_field) do
   label "file field"
-  xpath { |locator| XPath::HTML.file_field(locator) }
+  xpath do |locator|
+    xpath = XPath.descendant(:input)[XPath.attr(:type).equals('file')]
+    xpath = locate_field(xpath, locator.to_s) unless locator.nil?
+    xpath
+  end
+
   filter(:disabled, default: false, boolean: true, skip_if: :all) { |node, value| not(value ^ node.disabled?) }
-  describe { |options| " that is disabled" if options[:disabled] == true}
+  filter(:multiple, boolean: true) { |node, value| !(value ^ node[:multiple]) }
+
+  describe do |options|
+    desc = String.new
+    desc << " that is disabled" if options[:disabled] == true
+    desc << " that allows multiple files" if options[:multiple] == true
+    desc << " that only allows a single file" if options[:multiple] === false
+    desc
+  end
+end
+
+Capybara.add_selector(:label) do
+  label "label"
+  xpath do |locator|
+    xpath = XPath.descendant(:label)
+    xpath = xpath[XPath.string.n.is(locator.to_s) | XPath.attr(:id).equals(locator.to_s)] unless locator.nil?
+    xpath
+  end
+
+  filter(:for) do |node, field_or_value|
+    if field_or_value.is_a? Capybara::Node::Element
+      if field_or_value[:id] && (field_or_value[:id] == node[:for])
+        true
+      else
+        field_or_value.find_xpath('./ancestor::label[1]').include? node.base
+      end
+    else
+      node[:for] == field_or_value.to_s
+    end
+  end
 end
 
 Capybara.add_selector(:table) do
-  xpath { |locator| XPath::HTML.table(locator) }
+  xpath do |locator|
+    xpath = XPath.descendant(:table)
+    xpath = xpath[XPath.attr(:id).equals(locator.to_s) | XPath.descendant(:caption).is(locator.to_s)] unless locator.nil?
+    xpath
+  end
 end