capybara 2.9.2 → 2.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db09e9654963783c82ada646c4814ddc80c2ddb7
-  data.tar.gz: 17cd310533f903c6074ab255346e37c40046f3e9
+  metadata.gz: 0e04794fbb1724e14269beeff9388b53a6f8603b
+  data.tar.gz: 377ee4cf8d61e2c1420ad7bc44b400e1f991ac30
 SHA512:
-  metadata.gz: e20f671c5012aa0edcc8b51e9cd75fcac85ef8e8d784131e12cba87a1d89d6464f64d77f529787803b702d628022a48bf114ad37550995c354c409e25bb2f0b8
-  data.tar.gz: 3257116b6f9eb2584a154aecdc82342a1486a420eff1ebccb9df680ad0816d1f7a15aa1bc5aa8b321dc09471c6c991f035c35aa1c731fa17aa2d6827135a9667
+  metadata.gz: afcaeaf6eb1aa0690b74ffa21acbaea6282b2ed0aba4382bc926ec6a6fbdd43bff3facc886e2d5558f7cf9af167a8278ef9ded0e946dbc9052168fc6583e94f4
+  data.tar.gz: b6be9f0cd07cc125a46f14c9a322b789547eb875252a10d217b4c1410080bf4be0c146c83361846a17a114b1c648416dca1a3301eefdb26087f215a0fa120872

data/History.md

@@ -1,9 +1,18 @@
+#2.10.0
+Release date: 2016-10-05
+
+### Added
+* Select `<button>` elements with descendant images with `alt` attributes matching the locator [Ian Lesperance]
+* Locator string is optional in selector based matchers [Thomas Walpole]
+* Selectors can specify their default visible setting [Thomas Walpole]
+* Selector based finders and matchers can be passed a block to filter the results within the retry behavior [Thomas Walpole]
+
 #Version 2.9.2
 Release date: 2016-09-29
 
 ### Fixed
 * :label built-in selector finds nested label/control by control id if the label has no 'for' attribute [Thomas Walpole]
-* Warning issued if an unknown selector type is specified
+* Warning issued if an unknown selector type is specified [Thomas Walpole]
 
 #Version 2.9.1
 Release date: 2016-09-23

data/README.md

@@ -107,8 +107,8 @@ You can use the Capybara DSL in your steps, like so:
 ```ruby
 When /I sign in/ do
   within("#session") do
-    fill_in 'Email', :with => 'user@example.com'
-    fill_in 'Password', :with => 'password'
+    fill_in 'Email', with: 'user@example.com'
+    fill_in 'Password', with: 'password'
   end
   click_button 'Sign in'
 end
@@ -150,14 +150,14 @@ You can now write your specs like so:
 ```ruby
 describe "the signin process", :type => :feature do
   before :each do
-    User.make(:email => 'user@example.com', :password => 'password')
+    User.make(email: 'user@example.com', password: 'password')
   end
 
   it "signs me in" do
     visit '/sessions/new'
     within("#session") do
-      fill_in 'Email', :with => 'user@example.com'
-      fill_in 'Password', :with => 'password'
+      fill_in 'Email', with: 'user@example.com'
+      fill_in 'Password', with: 'password'
     end
     click_button 'Sign in'
     expect(page).to have_content 'Success'
@@ -165,12 +165,12 @@ describe "the signin process", :type => :feature do
 end
 ```
 
-Use `:js => true` to switch to the `Capybara.javascript_driver`
+Use `js: true` to switch to the `Capybara.javascript_driver`
 (`:selenium` by default), or provide a `:driver` option to switch
 to one specific driver. For example:
 
 ```ruby
-describe 'some stuff which requires js', :js => true do
+describe 'some stuff which requires js', js: true do
   it 'will use the default js driver'
   it 'will switch to one specific driver', :driver => :webkit
 end
@@ -181,26 +181,26 @@ Capybara also comes with a built in DSL for creating descriptive acceptance test
 ```ruby
 feature "Signing in" do
   background do
-    User.make(:email => 'user@example.com', :password => 'caplin')
+    User.make(email: 'user@example.com', password: 'caplin')
   end
 
   scenario "Signing in with correct credentials" do
     visit '/sessions/new'
     within("#session") do
-      fill_in 'Email', :with => 'user@example.com'
-      fill_in 'Password', :with => 'caplin'
+      fill_in 'Email', with: 'user@example.com'
+      fill_in 'Password', with: 'caplin'
     end
     click_button 'Sign in'
     expect(page).to have_content 'Success'
   end
 
-  given(:other_user) { User.make(:email => 'other@example.com', :password => 'rous') }
+  given(:other_user) { User.make(email: 'other@example.com', password: 'rous') }
 
   scenario "Signing in as another user" do
     visit '/sessions/new'
     within("#session") do
-      fill_in 'Email', :with => other_user.email
-      fill_in 'Password', :with => other_user.password
+      fill_in 'Email', with: other_user.email
+      fill_in 'Password', with: other_user.password
     end
     click_button 'Sign in'
     expect(page).to have_content 'Invalid email or password'
@@ -308,7 +308,7 @@ Capybara.default_driver = :selenium
 
 However, if you are using RSpec or Cucumber, you may instead want to consider
 leaving the faster `:rack_test` as the __default_driver__, and marking only those
-tests that require a JavaScript-capable driver using `:js => true` or
+tests that require a JavaScript-capable driver using `js: true` or
 `@javascript`, respectively.  By default, JavaScript tests are run using the
 `:selenium` driver. You can change this by setting
 `Capybara.javascript_driver`.
@@ -344,7 +344,7 @@ RackTest can be configured with a set of headers like this:
 
 ```ruby
 Capybara.register_driver :rack_test do |app|
-  Capybara::RackTest::Driver.new(app, :headers => { 'HTTP_USER_AGENT' => 'Capybara' })
+  Capybara::RackTest::Driver.new(app, headers: { 'HTTP_USER_AGENT' => 'Capybara' })
 end
 ```
 
@@ -448,14 +448,14 @@ click_on('Button Value')
 There are a number of tools for interacting with form elements:
 
 ```ruby
-fill_in('First Name', :with => 'John')
-fill_in('Password', :with => 'Seekrit')
-fill_in('Description', :with => 'Really Long Text...')
+fill_in('First Name', with: 'John')
+fill_in('Password', with: 'Seekrit')
+fill_in('Description', with: 'Really Long Text...')
 choose('A Radio Button')
 check('A Checkbox')
 uncheck('A Checkbox')
 attach_file('Image', '/path/to/image.jpg')
-select('Option', :from => 'Select Box')
+select('Option', from: 'Select Box')
 ```
 
 ### <a name="querying"></a>Querying
@@ -504,6 +504,13 @@ find("#overlay").find("h1").click
 all('a').each { |a| a[:href] }
 ```
 
+If you need to find elements by additional attributes/properties you can also pass a filter block, which will be checked inside the normal waiting behavior.
+If you find yourself needing to use this a lot you may be better off adding a [custom selector](http://www.rubydoc.info/github/jnicklas/capybara/Capybara#add_selector-class_method) or [adding a filter to an existing selector](http://www.rubydoc.info/github/jnicklas/capybara/Capybara#modify_selector-class_method).
+
+```ruby
+find_field('First Name'){ |el| el['data-xyz'] == '123' }
+````
+
 **Note**: `find` will wait for an element to appear on the page, as explained in the
 Ajax section. If the element does not appear it will raise an error.
 
@@ -525,11 +532,11 @@ method. Optionally you can specify which kind of selector to use.
 
 ```ruby
 within("li#employee") do
-  fill_in 'Name', :with => 'Jimmy'
+  fill_in 'Name', with: 'Jimmy'
 end
 
 within(:xpath, "//li[@id='employee']") do
-  fill_in 'Name', :with => 'Jimmy'
+  fill_in 'Name', with: 'Jimmy'
 end
 ```
 
@@ -539,11 +546,11 @@ specific table, identified by either id or text of the table's caption tag.
 
 ```ruby
 within_fieldset('Employee') do
-  fill_in 'Name', :with => 'Jimmy'
+  fill_in 'Name', with: 'Jimmy'
 end
 
 within_table('Employee') do
-  fill_in 'Name', :with => 'Jimmy'
+  fill_in 'Name', with: 'Jimmy'
 end
 ```
 
@@ -782,8 +789,8 @@ module MyModule
 
   def login!
     within(:xpath, "//form[@id='session']") do
-      fill_in 'Email', :with => 'user@example.com'
-      fill_in 'Password', :with => 'password'
+      fill_in 'Email', with: 'user@example.com'
+      fill_in 'Password', with: 'password'
     end
     click_button 'Sign in'
   end
@@ -853,8 +860,8 @@ require 'capybara'
 
 session = Capybara::Session.new(:webkit, my_rack_app)
 session.within("form#session") do
-  session.fill_in 'Email', :with => 'user@example.com'
-  session.fill_in 'Password', :with => 'password'
+  session.fill_in 'Email', with: 'user@example.com'
+  session.fill_in 'Password', with: 'password'
 end
 session.click_button 'Sign in'
 ```

data/lib/capybara.rb

@@ -225,7 +225,7 @@ module Capybara
     #     HTML
     #
     #     node.find('#projects').text # => 'Projects'
-    #     node.has_selector?('li#home', :text => 'Home')
+    #     node.has_selector?('li#home', text: 'Home')
     #     node.has_selector?('#projects')
     #     node.find('ul').find('li:first-child').text # => 'Home'
     #
@@ -475,7 +475,7 @@ end
 
 Capybara.register_server :webrick do |app, port, host|
   require 'rack/handler/webrick'
-  Rack::Handler::WEBrick.run(app, :Host => host, :Port => port, :AccessLog => [], :Logger => WEBrick::Log::new(nil, 0))
+  Rack::Handler::WEBrick.run(app, Host: host, Port: port, AccessLog: [], Logger: WEBrick::Log::new(nil, 0))
 end
 
 Capybara.register_server :puma do |app, port, host|

data/lib/capybara/node/actions.rb

@@ -62,7 +62,7 @@ module Capybara
       # Locate a text field or text area and fill it in with the given text
       # The field can be found via its name, id or label text.
       #
-      #     page.fill_in 'Name', :with => 'Bob'
+      #     page.fill_in 'Name', with: 'Bob'
       #
       #
       # @overload fill_in([locator], options={})
@@ -206,7 +206,7 @@ module Capybara
       # one option.
       # The select box can be found via its name, id or label text. The option can be found by its text.
       #
-      #     page.select 'March', :from => 'Month'
+      #     page.select 'March', from: 'Month'
       #
       # @macro waiting_behavior
       #
@@ -228,7 +228,7 @@ module Capybara
       # box is a multiple select, +unselect+ can be called multiple times to unselect more than
       # one option. The select box can be found via its name, id or label text.
       #
-      #     page.unselect 'March', :from => 'Month'
+      #     page.unselect 'March', from: 'Month'
       #
       # @macro waiting_behavior
       #

data/lib/capybara/node/base.rb

@@ -17,9 +17,9 @@ module Capybara
     #
     #     session = Capybara::Session.new(:rack_test, my_app)
     #     session.visit('/')
-    #     session.fill_in('Foo', :with => 'Bar')    # from Capybara::Node::Actions
+    #     session.fill_in('Foo', with: 'Bar')    # from Capybara::Node::Actions
     #     bar = session.find('#bar')                # from Capybara::Node::Finders
-    #     bar.select('Baz', :from => 'Quox')        # from Capybara::Node::Actions
+    #     bar.select('Baz', from: 'Quox')        # from Capybara::Node::Actions
     #     session.has_css?('#foobar')               # from Capybara::Node::Matchers
     #
     class Base

data/lib/capybara/node/element.rb

@@ -10,7 +10,7 @@ module Capybara
     #     session = Capybara::Session.new(:rack_test, my_app)
     #
     #     bar = session.find('#bar')              # from Capybara::Node::Finders
-    #     bar.select('Baz', :from => 'Quox')      # from Capybara::Node::Actions
+    #     bar.select('Baz', from: 'Quox')      # from Capybara::Node::Actions
     #
     # {Capybara::Node::Element} also has access to HTML attributes and other properties of the
     # element:

data/lib/capybara/node/finders.rb

@@ -19,7 +19,7 @@ module Capybara
       #
       #     page.find('#foo').find('.bar')
       #     page.find(:xpath, '//div[contains(., "bar")]')
-      #     page.find('li', :text => 'Quox').click_link('Delete')
+      #     page.find('li', text: 'Quox').click_link('Delete')
       #
       # @param (see Capybara::Node::Finders#all)
       #
@@ -28,8 +28,8 @@ module Capybara
       # @return [Capybara::Node::Element]      The found element
       # @raise  [Capybara::ElementNotFound]    If the element can't be found before time expires
       #
-      def find(*args)
-        query = Capybara::Queries::SelectorQuery.new(*args)
+      def find(*args, &optional_filter_block)
+        query = Capybara::Queries::SelectorQuery.new(*args, &optional_filter_block)
         synchronize(query.wait) do
           if (query.match == :smart or query.match == :prefer_exact) and query.supports_exact?
             result = query.resolve_for(self, true)
@@ -74,9 +74,9 @@ module Capybara
       # @return [Capybara::Node::Element]   The found element
       #
 
-      def find_field(locator=nil, options={})
+      def find_field(locator=nil, options={}, &optional_filter_block)
         locator, options = nil, locator if locator.is_a? Hash
-        find(:field, locator, options)
+        find(:field, locator, options, &optional_filter_block)
       end
       alias_method :field_labeled, :find_field
 
@@ -96,9 +96,9 @@ module Capybara
       #   @option options [String, Array<String>] class    Match links that match the class(es) provided
       # @return [Capybara::Node::Element]   The found element
       #
-      def find_link(locator=nil, options={})
+      def find_link(locator=nil, options={}, &optional_filter_block)
         locator, options = nil, locator if locator.is_a? Hash
-        find(:link, locator, options)
+        find(:link, locator, options, &optional_filter_block)
       end
 
       ##
@@ -125,9 +125,9 @@ module Capybara
       #   @option options [String, Array<String>] class    Match links that match the class(es) provided
       # @return [Capybara::Node::Element]   The found element
       #
-      def find_button(locator=nil, options={})
+      def find_button(locator=nil, options={}, &optional_filter_block)
         locator, options = nil, locator if locator.is_a? Hash
-        find(:button, locator, options)
+        find(:button, locator, options, &optional_filter_block)
       end
 
       ##
@@ -140,11 +140,12 @@ module Capybara
       #
       # @return [Capybara::Node::Element]   The found element
       #
-      def find_by_id(id, options={})
-        find(:id, id, options)
+      def find_by_id(id, options={}, &optional_filter_block)
+        find(:id, id, options, &optional_filter_block)
       end
 
       ##
+      # @!method all([kind = Capybara.default_selector], locator = nil, options = {})
       #
       # Find all elements on the page matching the given selector
       # and options.
@@ -168,42 +169,45 @@ module Capybara
       # The set of found elements can further be restricted by specifying
       # options. It's possible to select elements by their text or visibility:
       #
-      #     page.all('a', :text => 'Home')
-      #     page.all('#menu li', :visible => true)
+      #     page.all('a', text: 'Home')
+      #     page.all('#menu li', visible: true)
       #
       # By default if no elements are found, an empty array is returned;
       # however, expectations can be set on the number of elements to be found which
       # will trigger Capybara's waiting behavior for the expectations to match.The
       # expectations can be set using
       #
-      #     page.assert_selector('p#foo', :count => 4)
-      #     page.assert_selector('p#foo', :maximum => 10)
-      #     page.assert_selector('p#foo', :minimum => 1)
-      #     page.assert_selector('p#foo', :between => 1..10)
+      #     page.assert_selector('p#foo', count: 4)
+      #     page.assert_selector('p#foo', maximum: 10)
+      #     page.assert_selector('p#foo', minimum: 1)
+      #     page.assert_selector('p#foo', between: 1..10)
       #
       # See {Capybara::Helpers#matches_count?} for additional information about
       # count matching.
       #
-      # @overload all([kind], locator, options)
-      #   @param [:css, :xpath] kind                 The type of selector
-      #   @param [String] locator                    The selector
-      #   @option options [String, Regexp] text      Only find elements which contain this text or match this regexp
-      #   @option options [Boolean, Symbol] visible  Only find elements with the specified visibility:
+      # @param [Symbol] kind                       Optional selector type (:css, :xpath, :field, etc.) - Defaults to Capybara.default_selector
+      # @param [String] locator                    The selector
+      # @option options [String, Regexp] text      Only find elements which contain this text or match this regexp
+      # @option options [Boolean, Symbol] visible  Only find elements with the specified visibility:
       #                                              * true - only finds visible elements.
       #                                              * false - finds invisible _and_ visible elements.
       #                                              * :all - same as false; finds visible and invisible elements.
       #                                              * :hidden - only finds invisible elements.
       #                                              * :visible - same as true; only finds visible elements.
-      #   @option options [Integer] count            Exact number of matches that are expected to be found
-      #   @option options [Integer] maximum          Maximum number of matches that are expected to be found
-      #   @option options [Integer] minimum          Minimum number of matches that are expected to be found
-      #   @option options [Range]   between          Number of matches found must be within the given range
-      #   @option options [Boolean] exact            Control whether `is` expressions in the given XPath match exactly or partially
-      #   @option options [Integer] wait (Capybara.default_max_wait_time)  The time to wait for element count expectations to become true
+      # @option options [Integer] count            Exact number of matches that are expected to be found
+      # @option options [Integer] maximum          Maximum number of matches that are expected to be found
+      # @option options [Integer] minimum          Minimum number of matches that are expected to be found
+      # @option options [Range]   between          Number of matches found must be within the given range
+      # @option options [Boolean] exact            Control whether `is` expressions in the given XPath match exactly or partially
+      # @option options [Integer] wait (Capybara.default_max_wait_time)  The time to wait for element count expectations to become true
+      # @overload all([kind = Capybara.default_selector], locator = nil, options = {})
+      # @overload all([kind = Capybara.default_selector], locator = nil, options = {}, &filter_block)
+      #   @yieldparam element [Capybara::Node::Element]  The element being considered for inclusion in the results
+      #   @yieldreturn [Boolean]                     Should the element be considered in the results?
       # @return [Capybara::Result]                   A collection of found elements
       #
-      def all(*args)
-        query = Capybara::Queries::SelectorQuery.new(*args)
+      def all(*args, &optional_filter_block)
+        query = Capybara::Queries::SelectorQuery.new(*args, &optional_filter_block)
         synchronize(query.wait) do
           result = query.resolve_for(self)
           raise Capybara::ExpectationNotMet, result.failure_message unless result.matches_count?
@@ -227,15 +231,16 @@ module Capybara
       #   @param [Hash] options                      Additional options; see {#all}
       # @return [Capybara::Node::Element]            The found element or nil
       #
-      def first(*args)
+      def first(*args, &optional_filter_block)
         if Capybara.wait_on_first_by_default
           options = if args.last.is_a?(Hash) then args.pop.dup else {} end
           args.push({minimum: 1}.merge(options))
         end
-        all(*args).first
+        all(*args, &optional_filter_block).first
       rescue Capybara::ExpectationNotMet
         nil
       end
+
     end
   end
 end

data/lib/capybara/node/matchers.rb

@@ -14,14 +14,14 @@ module Capybara
       # By default it will check if the expression occurs at least once,
       # but a different number can be specified.
       #
-      #     page.has_selector?('p.foo', :count => 4)
+      #     page.has_selector?('p.foo', count: 4)
       #
       # This will check if the expression occurs exactly 4 times.
       #
       # It also accepts all options that {Capybara::Node::Finders#all} accepts,
       # such as :text and :visible.
       #
-      #     page.has_selector?('li', :text => 'Horse', :visible => true)
+      #     page.has_selector?('li', text: 'Horse', visible: true)
       #
       # has_selector? can also accept XPath expressions generated by the
       # XPath gem:
@@ -36,8 +36,8 @@ module Capybara
       # @option args [Range]   :between (nil)   Range of times that should contain number of times text occurs
       # @return [Boolean]                       If the expression exists
       #
-      def has_selector?(*args)
-        assert_selector(*args)
+      def has_selector?(*args, &optional_filter_block)
+        assert_selector(*args, &optional_filter_block)
       rescue Capybara::ExpectationNotMet
         return false
       end
@@ -50,83 +50,12 @@ module Capybara
       # @param (see Capybara::Node::Finders#has_selector?)
       # @return [Boolean]
       #
-      def has_no_selector?(*args)
-        assert_no_selector(*args)
+      def has_no_selector?(*args, &optional_filter_block)
+        assert_no_selector(*args, &optional_filter_block)
       rescue Capybara::ExpectationNotMet
         return false
       end
 
-      ##
-      #
-      # Checks if the current node matches given selector
-      #
-      # @param (see Capybara::Node::Finders#has_selector?)
-      # @return [Boolean]
-      #
-      def matches_selector?(*args)
-        assert_matches_selector(*args)
-      rescue Capybara::ExpectationNotMet
-        return false
-      end
-
-      ##
-      #
-      # Checks if the current node matches given XPath expression
-      #
-      # @param [String, XPath::Expression] xpath The XPath expression to match against the current code
-      # @return [Boolean]
-      #
-      def matches_xpath?(xpath, options={})
-        matches_selector?(:xpath, xpath, options)
-      end
-
-      ##
-      #
-      # Checks if the current node matches given CSS selector
-      #
-      # @param [String] css The CSS selector to match against the current code
-      # @return [Boolean]
-      #
-      def matches_css?(css, options={})
-        matches_selector?(:css, css, options)
-      end
-
-      ##
-      #
-      # Checks if the current node does not match given selector
-      # Usage is identical to Capybara::Node::Matchers#has_selector?
-      #
-      # @param (see Capybara::Node::Finders#has_selector?)
-      # @return [Boolean]
-      #
-      def not_matches_selector?(*args)
-        assert_not_matches_selector(*args)
-      rescue Capybara::ExpectationNotMet
-        return false
-      end
-
-      ##
-      #
-      # Checks if the current node does not match given XPath expression
-      #
-      # @param [String, XPath::Expression] xpath The XPath expression to match against the current code
-      # @return [Boolean]
-      #
-      def not_matches_xpath?(xpath, options={})
-        not_matches_selector?(:xpath, xpath, options)
-      end
-
-      ##
-      #
-      # Checks if the current node does not match given CSS selector
-      #
-      # @param [String] css The CSS selector to match against the current code
-      # @return [Boolean]
-      #
-      def not_matches_css?(css, options={})
-        not_matches_selector?(:css, css, options)
-      end
-
       ##
       #
       # Asserts that a given selector is on the page or a descendant of the current node.
@@ -138,7 +67,7 @@ module Capybara
       # By default it will check if the expression occurs at least once,
       # but a different number can be specified.
       #
-      #     page.assert_selector('p#foo', :count => 4)
+      #     page.assert_selector('p#foo', count: 4)
       #
       # This will check if the expression occurs exactly 4 times. See
       # {Capybara::Node::Finders#all} for other available result size options.
@@ -149,7 +78,7 @@ module Capybara
       # It also accepts all options that {Capybara::Node::Finders#all} accepts,
       # such as :text and :visible.
       #
-      #     page.assert_selector('li', :text => 'Horse', :visible => true)
+      #     page.assert_selector('li', text: 'Horse', visible: true)
       #
       # `assert_selector` can also accept XPath expressions generated by the
       # XPath gem:
@@ -160,8 +89,8 @@ module Capybara
       # @option options [Integer] :count (nil)    Number of times the expression should occur
       # @raise [Capybara::ExpectationNotMet]      If the selector does not exist
       #
-      def assert_selector(*args)
-        query = Capybara::Queries::SelectorQuery.new(*args)
+      def assert_selector(*args, &optional_filter_block)
+        query = Capybara::Queries::SelectorQuery.new(*args, &optional_filter_block)
         synchronize(query.wait) do
           result = query.resolve_for(self)
           unless result.matches_count? && ((!result.empty?) || query.expects_none?)
@@ -180,15 +109,15 @@ module Capybara
       # considered to be an integral part of the selector. This will return
       # true, for example, if a page contains 4 anchors but the query expects 5:
       #
-      #     page.assert_no_selector('a', :minimum => 1) # Found, raises Capybara::ExpectationNotMet
-      #     page.assert_no_selector('a', :count => 4)   # Found, raises Capybara::ExpectationNotMet
-      #     page.assert_no_selector('a', :count => 5)   # Not Found, returns true
+      #     page.assert_no_selector('a', minimum: 1) # Found, raises Capybara::ExpectationNotMet
+      #     page.assert_no_selector('a', count: 4)   # Found, raises Capybara::ExpectationNotMet
+      #     page.assert_no_selector('a', count: 5)   # Not Found, returns true
       #
       # @param (see Capybara::Node::Finders#assert_selector)
       # @raise [Capybara::ExpectationNotMet]      If the selector exists
       #
-      def assert_no_selector(*args)
-        query = Capybara::Queries::SelectorQuery.new(*args)
+      def assert_no_selector(*args, &optional_filter_block)
+        query = Capybara::Queries::SelectorQuery.new(*args, &optional_filter_block)
         synchronize(query.wait) do
           result = query.resolve_for(self)
           if result.matches_count? && ((!result.empty?) || query.expects_none?)
@@ -199,45 +128,6 @@ module Capybara
       end
       alias_method :refute_selector, :assert_no_selector
 
-      ##
-      #
-      # Asserts that the current_node matches a given selector
-      #
-      #     node.assert_matches_selector('p#foo')
-      #     node.assert_matches_selector(:xpath, '//p[@id="foo"]')
-      #     node.assert_matches_selector(:foo)
-      #
-      # It also accepts all options that {Capybara::Node::Finders#all} accepts,
-      # such as :text and :visible.
-      #
-      #     node.assert_matches_selector('li', :text => 'Horse', :visible => true)
-      #
-      # @param (see Capybara::Node::Finders#all)
-      # @raise [Capybara::ExpectationNotMet]      If the selector does not match
-      #
-      def assert_matches_selector(*args)
-        query = Capybara::Queries::MatchQuery.new(*args)
-        synchronize(query.wait) do
-          result = query.resolve_for(self.query_scope)
-          unless result.include? self
-            raise Capybara::ExpectationNotMet, "Item does not match the provided selector"
-          end
-        end
-        return true
-      end
-
-      def assert_not_matches_selector(*args)
-        query = Capybara::Queries::MatchQuery.new(*args)
-        synchronize(query.wait) do
-          result = query.resolve_for(self.query_scope)
-          if result.include? self
-            raise Capybara::ExpectationNotMet, 'Item matched the provided selector'
-          end
-        end
-        return true
-      end
-      alias_method :refute_matches_selector, :assert_not_matches_selector
-
       ##
       #
       # Checks if a given XPath expression is on the page or a descendant of the current node.
@@ -247,14 +137,14 @@ module Capybara
       # By default it will check if the expression occurs at least once,
       # but a different number can be specified.
       #
-      #     page.has_xpath?('.//p[@id="foo"]', :count => 4)
+      #     page.has_xpath?('.//p[@id="foo"]', count: 4)
       #
       # This will check if the expression occurs exactly 4 times.
       #
       # It also accepts all options that {Capybara::Node::Finders#all} accepts,
       # such as :text and :visible.
       #
-      #     page.has_xpath?('.//li', :text => 'Horse', :visible => true)
+      #     page.has_xpath?('.//li', text: 'Horse', visible: true)
       #
       # has_xpath? can also accept XPath expressions generate by the
       # XPath gem:
@@ -267,8 +157,8 @@ module Capybara
       # @option options [Integer] :count (nil)    Number of times the expression should occur
       # @return [Boolean]                         If the expression exists
       #
-      def has_xpath?(path, options={})
-        has_selector?(:xpath, path, options)
+      def has_xpath?(path, options={}, &optional_filter_block)
+        has_selector?(:xpath, path, options, &optional_filter_block)
       end
 
       ##
@@ -279,8 +169,8 @@ module Capybara
       # @param (see Capybara::Node::Finders#has_xpath?)
       # @return [Boolean]
       #
-      def has_no_xpath?(path, options={})
-        has_no_selector?(:xpath, path, options)
+      def has_no_xpath?(path, options={}, &optional_filter_block)
+        has_no_selector?(:xpath, path, options, &optional_filter_block)
       end
 
       ##
@@ -292,22 +182,22 @@ module Capybara
       # By default it will check if the selector occurs at least once,
       # but a different number can be specified.
       #
-      #     page.has_css?('p#foo', :count => 4)
+      #     page.has_css?('p#foo', count: 4)
       #
       # This will check if the selector occurs exactly 4 times.
       #
       # It also accepts all options that {Capybara::Node::Finders#all} accepts,
       # such as :text and :visible.
       #
-      #     page.has_css?('li', :text => 'Horse', :visible => true)
+      #     page.has_css?('li', text: 'Horse', visible: true)
       #
       # @param [String] path                      A CSS selector
       # @param options                            (see Capybara::Node::Finders#all)
       # @option options [Integer] :count (nil)    Number of times the selector should occur
       # @return [Boolean]                         If the selector exists
       #
-      def has_css?(path, options={})
-        has_selector?(:css, path, options)
+      def has_css?(path, options={}, &optional_filter_block)
+        has_selector?(:css, path, options, &optional_filter_block)
       end
 
       ##
@@ -318,8 +208,8 @@ module Capybara
       # @param (see Capybara::Node::Finders#has_css?)
       # @return [Boolean]
       #
-      def has_no_css?(path, options={})
-        has_no_selector?(:css, path, options)
+      def has_no_css?(path, options={}, &optional_filter_block)
+        has_no_selector?(:css, path, options, &optional_filter_block)
       end
 
       ##
@@ -332,8 +222,9 @@ module Capybara
       # @option options [String, Regexp] :href    The value the href attribute must be
       # @return [Boolean]                 Whether it exists
       #
-      def has_link?(locator, options={})
-        has_selector?(:link, locator, options)
+      def has_link?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_selector?(:link, locator, options, &optional_filter_block)
       end
 
       ##
@@ -344,8 +235,9 @@ module Capybara
       # @param (see Capybara::Node::Finders#has_link?)
       # @return [Boolean]            Whether it doesn't exist
       #
-      def has_no_link?(locator, options={})
-        has_no_selector?(:link, locator, options)
+      def has_no_link?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_no_selector?(:link, locator, options, &optional_filter_block)
       end
 
       ##
@@ -356,8 +248,9 @@ module Capybara
       # @param [String] locator      The text, value or id of a button to check for
       # @return [Boolean]            Whether it exists
       #
-      def has_button?(locator, options={})
-        has_selector?(:button, locator, options)
+      def has_button?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_selector?(:button, locator, options, &optional_filter_block)
       end
 
       ##
@@ -368,8 +261,9 @@ module Capybara
       # @param [String] locator      The text, value or id of a button to check for
       # @return [Boolean]            Whether it doesn't exist
       #
-      def has_no_button?(locator, options={})
-        has_no_selector?(:button, locator, options)
+      def has_no_button?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_no_selector?(:button, locator, options, &optional_filter_block)
       end
 
       ##
@@ -381,11 +275,11 @@ module Capybara
       # HTML5 email/url/etc. fields, it's possible to specify a :with
       # option to specify the text the field should contain:
       #
-      #     page.has_field?('Name', :with => 'Jonas')
+      #     page.has_field?('Name', with: 'Jonas')
       #
       # It is also possible to filter by the field type attribute:
       #
-      #     page.has_field?('Email', :type => 'email')
+      #     page.has_field?('Email', type: 'email')
       #
       # Note: 'textarea' and 'select' are valid type values, matching the associated tag names.
       #
@@ -394,8 +288,9 @@ module Capybara
       # @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)
+      def has_field?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_selector?(:field, locator, options, &optional_filter_block)
       end
 
       ##
@@ -408,8 +303,9 @@ module Capybara
       # @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)
+      def has_no_field?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_no_selector?(:field, locator, options, &optional_filter_block)
       end
 
       ##
@@ -421,8 +317,9 @@ module Capybara
       # @param [String] locator           The label, name or id of a checked field
       # @return [Boolean]                 Whether it exists
       #
-      def has_checked_field?(locator, options={})
-        has_selector?(:field, locator, options.merge(:checked => true))
+      def has_checked_field?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_selector?(:field, locator, options.merge(checked: true), &optional_filter_block)
       end
 
       ##
@@ -434,8 +331,9 @@ module Capybara
       # @param [String] locator           The label, name or id of a checked field
       # @return [Boolean]                 Whether it doesn't exist
       #
-      def has_no_checked_field?(locator, options={})
-        has_no_selector?(:field, locator, options.merge(:checked => true))
+      def has_no_checked_field?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_no_selector?(:field, locator, options.merge(checked: true))
       end
 
       ##
@@ -447,8 +345,9 @@ module Capybara
       # @param [String] locator           The label, name or id of an unchecked field
       # @return [Boolean]                 Whether it exists
       #
-      def has_unchecked_field?(locator, options={})
-        has_selector?(:field, locator, options.merge(:unchecked => true))
+      def has_unchecked_field?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_selector?(:field, locator, options.merge(unchecked: true), &optional_filter_block)
       end
 
       ##
@@ -460,8 +359,9 @@ module Capybara
       # @param [String] locator           The label, name or id of an unchecked field
       # @return [Boolean]                 Whether it doesn't exist
       #
-      def has_no_unchecked_field?(locator, options={})
-        has_no_selector?(:field, locator, options.merge(:unchecked => true))
+      def has_no_unchecked_field?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_no_selector?(:field, locator, options.merge(unchecked: true), &optional_filter_block)
       end
 
       ##
@@ -471,20 +371,20 @@ module Capybara
       #
       # It can be specified which option should currently be selected:
       #
-      #     page.has_select?('Language', :selected => 'German')
+      #     page.has_select?('Language', selected: 'German')
       #
       # For multiple select boxes, several options may be specified:
       #
-      #     page.has_select?('Language', :selected => ['English', 'German'])
+      #     page.has_select?('Language', selected: ['English', 'German'])
       #
       # It's also possible to check if the exact set of options exists for
       # this select box:
       #
-      #     page.has_select?('Language', :options => ['English', 'German', 'Spanish'])
+      #     page.has_select?('Language', options: ['English', 'German', 'Spanish'])
       #
       # You can also check for a partial set of options:
       #
-      #     page.has_select?('Language', :with_options => ['English', 'German'])
+      #     page.has_select?('Language', with_options: ['English', 'German'])
       #
       # @param [String] locator                      The label, name or id of a select box
       # @option options [Array] :options             Options which should be contained in this select box
@@ -492,8 +392,9 @@ module Capybara
       # @option options [String, Array] :selected    Options which should be selected
       # @return [Boolean]                            Whether it exists
       #
-      def has_select?(locator, options={})
-        has_selector?(:select, locator, options)
+      def has_select?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_selector?(:select, locator, options, &optional_filter_block)
       end
 
       ##
@@ -504,8 +405,9 @@ module Capybara
       # @param (see Capybara::Node::Matchers#has_select?)
       # @return [Boolean]     Whether it doesn't exist
       #
-      def has_no_select?(locator, options={})
-        has_no_selector?(:select, locator, options)
+      def has_no_select?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_no_selector?(:select, locator, options, &optional_filter_block)
       end
 
       ##
@@ -518,8 +420,9 @@ module Capybara
       # @param [String] locator                        The id or caption of a table
       # @return [Boolean]                              Whether it exist
       #
-      def has_table?(locator, options={})
-        has_selector?(:table, locator, options)
+      def has_table?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_selector?(:table, locator, options, &optional_filter_block)
       end
 
       ##
@@ -530,10 +433,122 @@ module Capybara
       # @param (see Capybara::Node::Matchers#has_table?)
       # @return [Boolean]       Whether it doesn't exist
       #
-      def has_no_table?(locator, options={})
-        has_no_selector?(:table, locator, options)
+      def has_no_table?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_no_selector?(:table, locator, options, &optional_filter_block)
+      end
+
+      ##
+      #
+      # Asserts that the current_node matches a given selector
+      #
+      #     node.assert_matches_selector('p#foo')
+      #     node.assert_matches_selector(:xpath, '//p[@id="foo"]')
+      #     node.assert_matches_selector(:foo)
+      #
+      # It also accepts all options that {Capybara::Node::Finders#all} accepts,
+      # such as :text and :visible.
+      #
+      #     node.assert_matches_selector('li', text: 'Horse', visible: true)
+      #
+      # @param (see Capybara::Node::Finders#all)
+      # @raise [Capybara::ExpectationNotMet]      If the selector does not match
+      #
+      def assert_matches_selector(*args, &optional_filter_block)
+        query = Capybara::Queries::MatchQuery.new(*args, &optional_filter_block)
+        synchronize(query.wait) do
+          result = query.resolve_for(self.query_scope)
+          unless result.include? self
+            raise Capybara::ExpectationNotMet, "Item does not match the provided selector"
+          end
+        end
+        return true
+      end
+
+      def assert_not_matches_selector(*args, &optional_filter_block)
+        query = Capybara::Queries::MatchQuery.new(*args, &optional_filter_block)
+        synchronize(query.wait) do
+          result = query.resolve_for(self.query_scope)
+          if result.include? self
+            raise Capybara::ExpectationNotMet, 'Item matched the provided selector'
+          end
+        end
+        return true
+      end
+      alias_method :refute_matches_selector, :assert_not_matches_selector
+
+      ##
+      #
+      # Checks if the current node matches given selector
+      #
+      # @param (see Capybara::Node::Finders#has_selector?)
+      # @return [Boolean]
+      #
+      def matches_selector?(*args, &optional_filter_block)
+        assert_matches_selector(*args, &optional_filter_block)
+      rescue Capybara::ExpectationNotMet
+        return false
+      end
+
+      ##
+      #
+      # Checks if the current node matches given XPath expression
+      #
+      # @param [String, XPath::Expression] xpath The XPath expression to match against the current code
+      # @return [Boolean]
+      #
+      def matches_xpath?(xpath, options={}, &optional_filter_block)
+        matches_selector?(:xpath, xpath, options, &optional_filter_block)
+      end
+
+      ##
+      #
+      # Checks if the current node matches given CSS selector
+      #
+      # @param [String] css The CSS selector to match against the current code
+      # @return [Boolean]
+      #
+      def matches_css?(css, options={}, &optional_filter_block)
+        matches_selector?(:css, css, options, &optional_filter_block)
       end
 
+      ##
+      #
+      # Checks if the current node does not match given selector
+      # Usage is identical to Capybara::Node::Matchers#has_selector?
+      #
+      # @param (see Capybara::Node::Finders#has_selector?)
+      # @return [Boolean]
+      #
+      def not_matches_selector?(*args, &optional_filter_block)
+        assert_not_matches_selector(*args, &optional_filter_block)
+      rescue Capybara::ExpectationNotMet
+        return false
+      end
+
+      ##
+      #
+      # Checks if the current node does not match given XPath expression
+      #
+      # @param [String, XPath::Expression] xpath The XPath expression to match against the current code
+      # @return [Boolean]
+      #
+      def not_matches_xpath?(xpath, options={}, &optional_filter_block)
+        not_matches_selector?(:xpath, xpath, options, &optional_filter_block)
+      end
+
+      ##
+      #
+      # Checks if the current node does not match given CSS selector
+      #
+      # @param [String] css The CSS selector to match against the current code
+      # @return [Boolean]
+      #
+      def not_matches_css?(css, options={}, &optional_filter_block)
+        not_matches_selector?(:css, css, options, &optional_filter_block)
+      end
+
+
       ##
       # Asserts that the page or current node has the given text content,
       # ignoring any HTML tags.
@@ -629,6 +644,7 @@ module Capybara
       def ==(other)
         self.eql?(other) || (other.respond_to?(:base) && base == other.base)
       end
+
     end
   end
 end