site_prism 3.4.1 → 3.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5d3515d35ccf73d1d9678c9f299ddfbe224783c0d324fbb8151d2e7dbac8afa
-  data.tar.gz: cd63c3947bee0fce01954e7156fcf67dda5c774307910c10afc8fdfb2fc3dd0b
+  metadata.gz: c5deda0d9df9e83e2a66663a217cf5c434fd3ed25abae0d14778d99cd5db1c0f
+  data.tar.gz: 6c86aff27c00c5e91b01667f7da1f9ee6e2d33d4f95d18fbb0cfdd9fd44779c5
 SHA512:
-  metadata.gz: 3a7906d90c8f83154f15c84422712638c547b855774dea30abc8b2bc229abf965352cbb32ac76bee9033909d321ada772e581ab9aa866738cfde23eaa1af2e08
-  data.tar.gz: 86f98bed36557c418ca65f681c88c1461a4d52518f0b264e87844fd643711da7902068f5836755a2f7126165a05a0ace87863d3af4a93f45e294b28b32b74c08
+  metadata.gz: 254398e151d390326bf085d0746391aedd247d1ed8bf47909d8fb87752b6cedd056ff32c14f324d5b33f4b922734ed01ec2467f64be59a8d97a07cf8aa002eea
+  data.tar.gz: 652781ebe825ed5f943ca0f8480a9b5fbd511e81e6c12d9ce95de7c3239073d4499f4165044c8c58888aeabf0cf2d9bc76e4ca6f2ae6baa6996093117577005a

data/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2011-2019, The SitePrism team
+Copyright (c) 2011-2021, The SitePrism team
 
 All rights reserved.
 

data/README.md

@@ -7,23 +7,34 @@ _A Page Object Model DSL for Capybara_
 SitePrism gives you a simple, clean and semantic DSL for describing your site using the Page Object Model pattern,
 for use with Capybara in automated acceptance testing.
 
-Find the pretty documentation here: http://rdoc.info/gems/site_prism/frames
+Find the pretty documentation here: https://rdoc.info/gems/site_prism/frames
 
 Make sure to add your project/company to https://github.com/site-prism/site_prism/wiki/Who-is-using-SitePrism
 
+## Support
+
+Support us with a monthly donation and help us continue our activities by supporting us as a [backer](https://opencollective.com/site-prism#backer)
+
+Become a sponsor and get your logo on our README on Github with a link to your site. [How to Sponsor SitePrism?](https://opencollective.com/site-prism#sponsor)
+
+Free Open Source software can only be maintained with the support of you. If you and/or your company find
+value in SitePrism and would like to contribute financially to its ongoing maintenance and development, 
+then please do so. Visit the OpenCollective links above for more details.
+
 ## Developing / Contributing to SitePrism
 
 We love it when people want to get involved with our Open Source Project.
 
-We have a brief set of setup docs [HERE](https://github.com/site-prism/site_prism/blob/master/development_setup.md)
+We have a brief set of setup docs [HERE](https://github.com/site-prism/site_prism/blob/main/HACKING.md)
 
 ## Supported Rubies / Browsers
 
-SitePrism is built and tested to work on Ruby 2.4 - 2.6. Ruby 2.3 (Now EOL), is supported but not tested against.
-If you are using SitePrism with Ruby 2.3 it is highly advisable to upgrade to a more modern Ruby
-such as 2.5 or 2.6, if for any other reason, to get a noticeable speed boost!
+SitePrism is built and tested to work on Ruby 2.4 - 2.7. Ruby 2.4 (Now EOL), is supported but
+this version will be removed from the Support Matrix in the coming months.
+If you are using SitePrism with Ruby 2.4 it is highly advisable to upgrade to a more modern Ruby
+such as 2.7, if for any other reason, to get a noticeable speed boost!
 
-SitePrism should run on all major browsers. The gem's integration tests are ran on Chrome and Firefox.
+SitePrism should run on all major browsers. The gem's integration tests are run on Chrome and Firefox.
 
 If you find you cannot integrate nicely with SitePrism, please open an
 [issue request](https://github.com/site-prism/site_prism/issues/new)
@@ -124,6 +135,7 @@ require 'capybara'
 require 'capybara/cucumber'
 require 'selenium-webdriver'
 require 'site_prism'
+require 'site_prism/all_there' # Optional but needed to perform more complex matching
 ```
 
 The driver creation is identical to how you would normally create a Capybara driver,
@@ -135,6 +147,7 @@ Capybara.register_driver :site_prism do |app|
   Capybara::Selenium::Driver.new(app, browser: browser, desired_capabilities: capabilities)
 end
 
+# Then tell Capybara to use the Driver you've just defined as its default driver
 Capybara.configure do |config|
   config.default_driver = :site_prism
 end
@@ -149,6 +162,7 @@ require 'capybara'
 require 'capybara/rspec'
 require 'selenium-webdriver'
 require 'site_prism'
+require 'site_prism/all_there' # Optional but needed to perform more complex matching
 ```
 
 And again, as above, a sample driver is no different to a normal driver instantiation in Capybara.
@@ -295,7 +309,13 @@ expect(@account_page).to be_displayed
 ```
 
 Calling `#displayed?` will return true if the browser's current URL
-matches the page's template and false if it doesn't.
+matches the page's template and false if it doesn't. It will wait for
+`Capybara.default_max_wait_time` seconds or you can pass an explicit
+wait time in seconds as the first argument like this:
+
+```ruby
+@account_page.displayed?(10) # wait up to 10 seconds for display
+```
 
 #### Specifying parameter values for templated URLs
 
@@ -422,8 +442,11 @@ as a string.
 #### Accessing the individual element
 
 The `element` method will add a number of methods to instances of the
-particular Page class. The first method to be added is the name of the
-element. So using the following example:
+particular Page class. The first method added is the name of the
+element. It finds the element using [Capybara::Node::Finders#find](https://www.rubydoc.info/github/teamcapybara/capybara/master/Capybara/Node/Finders#find-instance_method)
+returning a [Capybara::Node::Element](https://www.rubydoc.info/github/teamcapybara/capybara/master/Capybara/Node/Element) or
+raising [Capybara::ElementNotFound](https://www.rubydoc.info/github/teamcapybara/capybara/master/Capybara/ElementNotFound)
+if the element can not be found.
 
 ```ruby
 class Home < SitePrism::Page
@@ -447,7 +470,9 @@ end
 #### Testing for the existence of the element
 
 Another method added to the Page class by the `element` method is the
-`has_<element_name>?` method. Using the same example as above:
+`has_<element_name>?` method.
+This method delegates to [Capybara::Node::Matchers#has_selector?](https://www.rubydoc.info/github/teamcapybara/capybara/master/Capybara/Node/Matchers#has_selector%3F-instance_method).
+Using the same example as above:
 
 ```ruby
 class Home < SitePrism::Page
@@ -477,7 +502,9 @@ end
 
 To test that an element does not exist on the page, it is not possible to just call
 `#not_to have_search_field`. SitePrism supplies the `#has_no_<element>?` method
-that should be used to test for non-existence. Using the above example:
+that should be used to test for non-existence.
+This method delegates to [Capybara::Node::Matchers#has_no_selector?](https://www.rubydoc.info/github/teamcapybara/capybara/master/Capybara/Node/Matchers#has_no_selector%3F-instance_method)
+Using the above example:
 
 ```ruby
 @home = Home.new
@@ -495,9 +522,10 @@ end
 
 #### Waiting for an element to become visible
 
-A method that gets added by calling `element` is the 
-`wait_until_<element_name>_visible` method. Calling this method will
-cause the test to wait for Capybara's default wait time for the element
+A method that gets added by calling `element` is the
+`wait_until_<element_name>_visible` method.
+This method delegates to [Capybara::Node::Matchers#has_selector?](https://www.rubydoc.info/github/teamcapybara/capybara/master/Capybara/Node/Matchers#has_selector%3F-instance_method).
+Calling this method will cause the test to wait for Capybara's default wait time for the element
 to become visible. You can customise the wait time by supplying a number
 of seconds to wait in-line or configuring the default wait time.
 
@@ -510,10 +538,11 @@ of seconds to wait in-line or configuring the default wait time.
 #### Waiting for an element to become invisible
 
 Another method added by calling `element` is the
-`wait_until_<element_name>_invisible` method. Calling this method will
-cause the test to wait for Capybara's default wait time for the element
-to become invisible. You can as with the visibility waiter, customise
-the wait time in the same way.
+`wait_until_<element_name>_invisible` method.
+This method delegates to [Capybara::Node::Matchers#has_no_selector?](https://www.rubydoc.info/github/teamcapybara/capybara/master/Capybara/Node/Matchers#has_no_selector%3F-instance_method).
+Calling this method will cause the test to wait for Capybara's default
+wait time for the element to become invisible. You can as with the visibility
+waiter, customise the wait time in the same way.
 
 ```ruby
 @home.wait_until_search_field_invisible
@@ -717,8 +746,8 @@ through them to find out if all of your items are present then you can also do t
 Simply pass a recursion parameter to the `#all_there?` check. Note that the only valid values
 for this at the moment are `:none` and `:one`
 
-Passing `:none` in (default), will not change the functionality. However passing in `:one` will cause
-site_prism to recurse through all section / sections items defined in your current scope.
+Passing `:none` (default), will not change the functionality. However passing in `:one` will cause
+`site_prism` to recurse through all `section` / `sections` items defined in your present scope.
 
 Work alongside developing this functionality further is being continued in the
 [site_prism-all_there](http://www.github.com/site-prism/site_prism-all_there) repo. So head on over
@@ -727,11 +756,33 @@ there if you're interested in how this feature will work going forwards
 NB: At the moment a "primitive" but working copy of this is hosted inside this gem. But if you wish to
 use the bleeding edge version of the logic. Then simply set the following configuration parameter
 
-```rb
+```ruby
+`require 'site_prism/all_there'`
+
 SitePrism.use_all_there_gem = true
 ```
 
-Make sure as well to require the gem code by doing `require 'site_prism/all_there'`
+### Getting the list of missing elements
+
+If `#all_there?` returns false and you wish to get the list of missing elements for debugging purposes
+you may want to use `#elements_missing` method. It will return all missing elements from the expected_elements list
+
+If you do not provide a list of `expected_elements` this method will return all elements that are missing on the page;
+from those which are defined.
+
+```ruby
+class Home < SitePrism::Page
+  element :name, '#name'
+  element :address, '#address'
+  element :success_message, 'span.alert-success'
+
+  expected_elements :name, :address
+end
+
+# and... Only `address` is on the page
+
+@test_page.elements_missing #=> [:name]
+```
 
 ## Sections
 
@@ -918,14 +969,13 @@ end
 
 ##### Accessing section elements using a block
 
-A Section can be scoped so it is only accessible inside a block. This is
+You can execute a block within the context of a Section. This is
 similar to Capybara's `within` method and allows for shorter test code
-particularly with nested sections. Some of this test code can be
-made a little prettier by simply passing a block in.
+particularly with nested sections. Test code that might have to repeat the block name can be shortened up this way.
 
 ```ruby
 Then(/^the home page menu contains a link to the various search functions$/) do
-  @home.menu do |menu|
+  @home.menu.within do |menu|
     expect(menu).to have_search
     expect(menu.search['href']).to include('google.com')
     expect(menu).to have_images
@@ -934,6 +984,16 @@ Then(/^the home page menu contains a link to the various search functions$/) do
 end
 ```
 
+Note that on an individual section it's possible to pass a block directly to the section without using `within`.  Because the block is executed only during `Section` initialization this won't work when accessing a single Section from an array of Sections.  For that reason we recommend using `within` which works in either case.
+
+```ruby
+Then(/^the home page menu contains a link to the various search functions$/) do
+  @home.menu do |menu|  # possible, but prefer: `@home.menu.within`
+    expect(menu).to have_search
+  end
+end
+```
+
 #### Getting a section's parent
 
 It is possible to ask a section for its parent (page, or section if this
@@ -1172,7 +1232,7 @@ This allows for pretty tests ...
 ```ruby
 Then(/^there are lots of search_results$/) do
   expect(@results_page.search_results.size).to eq(10)
-  
+
   @home.search_results.each do |result|
     expect(result).to have_title
     expect(result.blurb.text).not_to be_empty
@@ -1188,6 +1248,26 @@ element. So if the css selector finds 3 `li` elements, calling
 `search_results` will return an array containing 3 instances of
 `SearchResults`, each with one of the `li` elements as it's root element.
 
+##### Accessing Within a Collection of Sections
+
+When using an iterator such as `each` to pass a block through to a collection of sections it is possible to skip using `within`.  However some caution is warranted when accessing the Sections directly from an array, as the block can only be executed when the section is being initialized.  The following does not work:
+
+```rb
+  @home.search_results.first do |result|
+    # This block is silently ignored.
+    expect(result).to have_title
+  end
+```
+Instead use `within` to access the inner-context of the Section.
+
+```rb
+  @home.search_results.first.within do |result|
+    # This block is run within the context of the Section.
+    expect(result).to have_title
+  end
+```
+
+
 #### Anonymous Section Collections
 
 You can define collections of anonymous sections the same way you would
@@ -1384,7 +1464,7 @@ instance of the class when created.
 
 ### Skipping load Validations
 
-Defined load validations can be skipped for one `load` call by 
+Defined load validations can be skipped for one `load` call by
 passing in `with_validations: false`.
 
 ```ruby
@@ -1435,7 +1515,7 @@ the validations will be performed in the following order:
 **NB:** `SitePrism::Page` **used to** include a default load validation on
 `page.displayed?` however for v3 this has been removed. It is therefore
 necessary to re-define this if you want to retain the behaviour
-from site_prism v2. See [UPGRADING.md](https://github.com/site-prism/site_prism/blob/master/UPGRADING.md#default-load-validations)
+from site_prism v2. See [UPGRADING.md](https://github.com/site-prism/site_prism/blob/main/UPGRADING.md#default-load-validations)
 for more info on this.
 
 ## Using Capybara Query Options
@@ -1651,12 +1731,12 @@ as per the code below
 Capybara.configure do |config|
   config.default_max_wait_time = 11 #=> Wait up to 11 seconds for all queries to fail
   # or if you don't want to ever wait
-  config.default_max_wait_time = 0 #=> Don't ever wait! 
+  config.default_max_wait_time = 0 #=> Don't ever wait!
 end
 ```
 
 Note that even with implicit waits on you can dynamically modify the wait times
-in any SitePrism method to help work-around special circumstances.  
+in any SitePrism method to help work-around special circumstances.
 
 ```ruby
 # Option 1: using wait key assignment

data/lib/site_prism.rb

@@ -3,15 +3,20 @@
 require 'site_prism/error'
 require 'addressable/template'
 
+# [SitePrism] namespace
+# We autoload our files underneath here to provide a slightly more optimal load solution
 module SitePrism
   autoload :AddressableUrlMatcher, 'site_prism/addressable_url_matcher'
-  autoload :Deprecator, 'site_prism/deprecator'
   autoload :DSL, 'site_prism/dsl'
+  autoload :Deprecator, 'site_prism/deprecator'
   autoload :ElementChecker, 'site_prism/element_checker'
-  autoload :RecursionChecker, 'site_prism/recursion_checker'
+  autoload :Loadable, 'site_prism/loadable'
   autoload :Logger, 'site_prism/logger'
   autoload :Page, 'site_prism/page'
+  autoload :RecursionChecker, 'site_prism/recursion_checker'
+  autoload :RspecMatchers, 'site_prism/rspec_matchers'
   autoload :Section, 'site_prism/section'
+  autoload :Timer, 'site_prism/timer'
   autoload :Waiter, 'site_prism/waiter'
 
   class << self

data/lib/site_prism/addressable_url_matcher.rb

@@ -4,6 +4,10 @@ require 'digest'
 require 'base64'
 
 module SitePrism
+  # [SitePrism::AddressableUrlMatcher]
+  # Used in a couple of places to allow users to ...
+  #   Specify patterns for loading webpages
+  #   Pass in hashable args or query parameters for loading dynamic pages
   class AddressableUrlMatcher
     attr_reader :pattern
 
@@ -43,12 +47,10 @@ module SitePrism
     def all_expected_mappings_match?(expected_mappings, actual_mappings)
       expected_mappings.all? do |key, expected_value|
         actual_value = actual_mappings[key.to_s]
-        if expected_value.is_a?(Numeric)
-          actual_value == expected_value.to_s
-        elsif expected_value.is_a?(Regexp)
-          actual_value.match(expected_value)
-        else
-          expected_value == actual_value
+        case expected_value
+        when Numeric; then actual_value == expected_value.to_s
+        when Regexp;  then actual_value.match(expected_value)
+        else               expected_value == actual_value
         end
       end
     end

data/lib/site_prism/deprecator.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
 module SitePrism
+  # [SitePrism::Deprecator]
   class Deprecator
     class << self
+      # @return SitePrism.logger.warn(msg)
+      # Tells the user that they are using old functionality, which needs removing in the
+      # next major version
       def deprecate(old, new = nil)
         if new
           warn("#{old} is being deprecated and should no longer be used. Use #{new} instead.")
@@ -13,6 +17,13 @@ module SitePrism
         warn("#{old} will be removed in SitePrism v4. You have been warned!")
       end
 
+      # @return SitePrism.logger.debug(msg)
+      # Tells the user that they are using functionality which is non-optimal
+      #   The functionality should usually provide a reason for it being poor, as well as an
+      #   optional way of upgrading to something different
+      #
+      # NB: As this is bubbled up at debug level, often users will not see this. So it will
+      # never be a candidate for removal directly
       def soft_deprecate(old, reason, new = nil)
         debug("The #{old} method is changing, as is SitePrism, and is now configurable.")
         debug("REASON: #{reason}.")

data/lib/site_prism/dsl.rb

@@ -1,6 +1,13 @@
 # frozen_string_literal: true
 
 module SitePrism
+  # [SitePrism::DSL]
+  #
+  # This is the core Module Namespace for all of the public-facing DSL methods
+  #   such as `element`. The code here is designed to be used through the defining
+  #   of said items, and not to be instantiated directly.
+  #
+  # The whole package here can be thought of as [@api private]
   module DSL
     def self.included(klass)
       klass.extend ClassMethods
@@ -8,9 +15,28 @@ module SitePrism
 
     private
 
-    # The default waiting time set by Capybara's configuration settings.
-    def wait_time
-      Capybara.default_max_wait_time
+    # Call `find` inside context set on page/section
+    def _find(*find_args)
+      kwargs = find_args.pop
+      page.find(*find_args, **kwargs)
+    end
+
+    # Call `all` inside context set on page/section
+    def _all(*find_args)
+      kwargs = find_args.pop
+      page.all(*find_args, **kwargs)
+    end
+
+    # Call `has_selector?` inside context set on page/section
+    def element_exists?(*find_args)
+      kwargs = find_args.pop
+      page.has_selector?(*find_args, **kwargs)
+    end
+
+    # Call `has_no_selector?` inside context set on page/section
+    def element_does_not_exist?(*find_args)
+      kwargs = find_args.pop
+      page.has_no_selector?(*find_args, **kwargs)
     end
 
     # Prevent users from calling methods with blocks when they shouldn't be.
@@ -36,6 +62,14 @@ module SitePrism
       raise SitePrism::UnsupportedBlockError
     end
 
+    # Warn users from naming the elements starting with no_
+    def warn_if_dsl_collision(obj, name)
+      return unless name.to_s.start_with?('no_')
+
+      SitePrism.logger.warn("#{obj.class}##{name} should not start with no_")
+      SitePrism::Deprecator.deprecate('Using no_ prefix in DSL definition')
+    end
+
     # Sanitize method called before calling any SitePrism DSL method or
     # meta-programmed method. This ensures that the Capybara query is correct.
     #
@@ -49,7 +83,7 @@ module SitePrism
 
       recombine_args(find_args, runtime_args, options)
 
-      return [*find_args, *runtime_args] if options.empty?
+      return [*find_args, *runtime_args, {}] if options.empty?
 
       [*find_args, *runtime_args, options]
     end
@@ -60,55 +94,84 @@ module SitePrism
     #
     # If the hash is empty, then the hash is omitted from the payload sent
     # to Capybara, and the find / runtime arguments are sent alone.
+    #
+    # NB: If the +wait+ key is present in the options hash, even as false or 0, It will
+    # be set as the user-supplied value (So user error can be the cause for issues).
     def recombine_args(find_args, runtime_args, options)
       options.merge!(find_args.pop) if find_args.last.is_a? Hash
       options.merge!(runtime_args.pop) if runtime_args.last.is_a? Hash
-      options[:wait] = wait_time unless wait_key_present?(options)
-    end
-
-    # Detect if the +wait+ key is present in the options hash.
-    # Note that setting it to to false or 0, still will return true here.
-    def wait_key_present?(options)
-      options.key?(:wait)
+      options[:wait] = Capybara.default_max_wait_time unless options.key?(:wait)
     end
 
+    # SitePrism::DSL::ClassMethods
+    # This exposes all of the DSL definitions users will use when generating
+    # their POM classes.
+    #
+    # Many of these methods will be used in-line to allow users to generate a multitude of
+    # methods and locators for finding elements / sections on a page or section of a page
     module ClassMethods
       attr_reader :expected_items
 
+      # Creates an instance of a SitePrism Element - This will create several methods designed to
+      # Locate the element -> @return [Capybara::Node::Element]
+      # Check the elements presence or non-presence -> @return [Boolean]
+      # Wait for the elements to be present or not -> @return [TrueClass, SitePrism::Error]
+      # Validate certain properties about the element
       def element(name, *find_args)
         SitePrism::Deprecator.deprecate('Passing a block to :element') if block_given?
         build(:element, name, *find_args) do
           define_method(name) do |*runtime_args, &element_block|
+            warn_if_dsl_collision(self, name)
             raise_if_block(self, name, !element_block.nil?, :element)
             _find(*merge_args(find_args, runtime_args))
           end
         end
       end
 
+      # Creates a enumerable instance of a SitePrism Element - This will create several methods designed to
+      # Locate the enumerable element -> @return [Capybara::Result]
+      # Check the elements presence or non-presence -> @return [Boolean]
+      # Wait for the elements to be present or not -> @return [TrueClass, SitePrism::Error]
+      # Validate certain properties about the elements
       def elements(name, *find_args)
         SitePrism::Deprecator.deprecate('Passing a block to :elements') if block_given?
         build(:elements, name, *find_args) do
           define_method(name) do |*runtime_args, &element_block|
+            warn_if_dsl_collision(self, name)
             raise_if_block(self, name, !element_block.nil?, :elements)
             _all(*merge_args(find_args, runtime_args))
           end
         end
       end
 
+      # Sets the `expected_items` iVar on a class. This property is used in conjunction with
+      # `all_there?` to provide a way of granularising the check made to only interrogate a sub-set
+      # of DSL defined items
       def expected_elements(*elements)
         @expected_items = elements
       end
 
+      # Creates an instance of a SitePrism Section - This will create several methods designed to
+      # Locate the section -> @return [SitePrism::Section]
+      # Check the section presence or non-presence -> @return [Boolean]
+      # Wait for the section to be present or not -> @return [TrueClass, SitePrism::Error]
+      # Validate certain properties about the section
       def section(name, *args, &block)
         section_class, find_args = extract_section_options(args, &block)
         build(:section, name, *find_args) do
           define_method(name) do |*runtime_args, &runtime_block|
+            warn_if_dsl_collision(self, name)
             section_element = _find(*merge_args(find_args, runtime_args))
             section_class.new(self, section_element, &runtime_block)
           end
         end
       end
 
+      # Creates an enumerable instance of a SitePrism Section - This will create several methods designed to
+      # Locate the sections -> @return [Array]
+      # Check the sections presence or non-presence -> @return [Boolean]
+      # Wait for the sections to be present or not -> @return [TrueClass, SitePrism::Error]
+      # Validate certain properties about the section
       def sections(name, *args, &block)
         section_class, find_args = extract_section_options(args, &block)
         build(:sections, name, *find_args) do
@@ -135,11 +198,9 @@ module SitePrism
       end
 
       def mapped_items(legacy: true)
-        if legacy
-          old_mapped_items
-        else
-          new_mapped_items
-        end
+        return old_mapped_items if legacy
+
+        new_mapped_items
       end
 
       private
@@ -154,13 +215,7 @@ module SitePrism
       end
 
       def new_mapped_items
-        @new_mapped_items ||= {
-          element: [],
-          elements: [],
-          section: [],
-          sections: [],
-          iframe: [],
-        }
+        @new_mapped_items ||= { element: [], elements: [], section: [], sections: [], iframe: [] }
       end
 
       def build(type, name, *find_args)
@@ -181,27 +236,15 @@ module SitePrism
       def add_helper_methods(name, *find_args)
         create_existence_checker(name, *find_args)
         create_nonexistence_checker(name, *find_args)
-        create_rspec_existence_matchers(name) if defined?(RSpec)
+        SitePrism::RspecMatchers.new(name)._create_rspec_existence_matchers if defined?(RSpec)
         create_visibility_waiter(name, *find_args)
         create_invisibility_waiter(name, *find_args)
       end
 
       def create_helper_method(proposed_method_name, *find_args)
-        if find_args.empty?
-          create_error_method(proposed_method_name)
-        else
-          yield
-        end
-      end
+        return create_error_method(proposed_method_name) if find_args.empty?
 
-      def create_rspec_existence_matchers(element_name)
-        matcher = "has_#{element_name}?"
-        negated_matcher = "has_no_#{element_name}?"
-
-        RSpec::Matchers.define "have_#{element_name}" do |*args|
-          match { |actual| actual.public_send(matcher, *args) }
-          match_when_negated { |actual| actual.public_send(negated_matcher, *args) }
-        end
+        yield
       end
 
       def create_existence_checker(element_name, *find_args)
@@ -250,6 +293,10 @@ module SitePrism
 
       def create_error_method(name)
         SitePrism.logger.error("#{name} has come from an item with no locators.")
+        SitePrism::Deprecator.soft_deprecate(
+          'DSL definition with no find_args',
+          'All DSL elements should have find_args'
+        )
         define_method(name) { raise SitePrism::InvalidElementError }
       end
 
@@ -285,7 +332,7 @@ module SitePrism
       def extract_section_options(args, &block)
         if args.first.is_a?(Class)
           klass = args.shift
-          section_class = klass if klass.ancestors.include?(SitePrism::Section)
+          section_class = klass if klass <= SitePrism::Section
         end
 
         section_class = deduce_section_class(section_class, &block)
@@ -298,20 +345,23 @@ module SitePrism
         klass = Class.new(klass || SitePrism::Section, &block) if block_given?
         return klass if klass
 
-        raise ArgumentError, "You should provide descendant of \
-SitePrism::Section class or/and a block as the second argument."
+        raise ArgumentError, 'You should provide descendant of SitePrism::Section class or/and a block as the second argument.'
       end
 
       def deduce_search_arguments(section_class, args)
         extract_search_arguments(args) ||
           extract_search_arguments(section_class.default_search_arguments) ||
-          raise(ArgumentError, "You should provide search arguments \
-in section creation or set_default_search_arguments within section class")
+          invalidate_search_arguments!
       end
 
       def extract_search_arguments(args)
         args if args && !args.empty?
       end
+
+      def invalidate_search_arguments!
+        SitePrism.logger.error('Could not deduce search_arguments')
+        raise(ArgumentError, 'search arguments are needed in `section` definition or alternatively use `set_default_search_arguments`')
+      end
     end
   end
 end