site_prism 2.13 → 2.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4c6e366dcebe267faac30347ca1d1df9083a35a8
-  data.tar.gz: 073d46c7c242f29985a11f788d4647be3f1d0aa0
+  metadata.gz: 3b74604cbe9c1815149c4bce7c747d9087098ade
+  data.tar.gz: 5043802657e6d0f88d6f52ea8790b49b8e634dd5
 SHA512:
-  metadata.gz: cd48654ba019e204f5631b571f25e81d2a6dcdf4b8dda728fc40c1a1d8e26f74255cdd2b49dbf12dacd4dca489bc843b20c00cb711884b05cc43b0c94ee14c23
-  data.tar.gz: 1422a9b00a5a7a891e043d749bddb47efc1c65d85a01c2481d6bc420079171ea89a9ff63e289afd1a2bf4d91a888a9330d7508c7c8008d93bebf8ece9fc52e0f
+  metadata.gz: 4683666aa25142921dfab489841ef22eed10768978cd6c0ba69d768517a28cfcd7ef236fa5291c9a951836ea3bf3f762e2c25451ff5ad30940ec7db071c204cb
+  data.tar.gz: 5ade19c3956fbf314b096831c72f9c0d9f572ab5995384d389cfd795ada012b4e63e3036ca612fafa3b78658bb037391bddc19f09a1e6fa97f27772901a0a1c1

data/README.md

@@ -746,7 +746,6 @@ present in the browser, false if they're not all there.
 Then /^the friends page contains all the expected elements$/ do
   expect(@friends_page).to be_all_there
 end
-
 ```
 
 You may wish to have elements declared in a page object class that are not always guaranteed to be present (success or error messages, etc.). If you'd still like to test such a page with `all_there?` you can declare `expected_elements` on your page object class that narrows the elements included in `all_there?` check to those that definitely should be present.
@@ -761,6 +760,20 @@ class TestPage < SitePrism::Page
 end
 ```
 
+And if you aren't sure which elements are present and which are, Then ask SitePrism to tell you!
+
+```ruby
+class TestPage < SitePrism::Page
+  element :name_field, '#name'
+  element :address_field, '#address'
+  element :success_msg, 'span.alert-success'
+end
+
+# and... Only `address_field` is on the page
+
+@test_page.elements_present #=> [:address_field]
+```
+
 ## Sections
 
 SitePrism allows you to model sections of a page that appear on multiple
@@ -804,12 +817,44 @@ SitePrism allows adding sections to sections) is to call the `section`
 method. It takes 3 arguments: the first is the name of the section as
 referred to on the page (sections that appear on multiple pages can be
 named differently). The second argument is the class of which an
-instance will be created to represent the page section, and the third
-argument is a css selector that identifies the root node of the section
+instance will be created to represent the page section, and the following
+arguments are [Capybara::Node::Finders](https://www.rubydoc.info/github/teamcapybara/capybara/master/Capybara/Node/Finders).
+These identify the root node of the section
 on this page (note that the css selector can be different for different
 pages as the whole point of sections is that they can appear in
 different places on different pages).
 
+If you define a section as a class and as an Anonymous section,
+you can have some handy constructs like the one below
+
+```ruby
+class People < SitePrism::Section
+  element :headline, 'h2'
+end
+
+class HomePage < SitePrism::Page
+  # section people_with_block will have headline and
+  # headline_clone elements in it
+  section :people_with_block, People do
+    element :headline_clone, 'h2'
+  end
+end
+```
+
+The 3rd argument (Locators), can be omitted if you are re-using the same locator for all
+references to the section Class. In order to do this, simply tell SitePrism that
+you want to use a default search argument.
+
+```ruby
+class People < SitePrism::Section
+  set_default_search_arguments '.people'
+end
+
+class Home < SitePrism::Page
+  section :people, People
+end
+```
+
 #### Accessing a page's section
 
 The `section` method (like the `element` method) adds a few methods to
@@ -1265,7 +1310,7 @@ end
 
 ```ruby
 Then /^there are search results on the page$/ do
-  expect(@results.page).to have_search_results
+  expect(@results_page).to have_search_results
 end
 ```
 
@@ -1493,7 +1538,7 @@ into our page and section classes:
 
 ```ruby
 Then /^there are search results on the page$/ do
-  expect(@results.page).to have_search_results(count: 25)
+  expect(@results_page).to have_search_results(count: 25)
 end
 ```
 
@@ -1688,6 +1733,42 @@ with this:
 @search_page.search_results
 ```
 
+## Raising Errors on wait_for
+
+By default, when using `wait_for_*` and `wait_for_no_*` methods, SitePrism will not raise
+an error if an element does not appear or disappear within the timeout period and will
+simply return `false` and allow the test to continue. This is different from
+the other methods such as `wait_until_*_visible` which do raise errors.
+
+Add the following code your spec_helper file to enable errors to be
+raised immediately when a `wait_for_*` method does not find the element it is
+waiting for and when a `wait_for_no_*` method continues to find an element it is
+waiting to not exist:
+
+```ruby
+SitePrism.configure do |config|
+  config.raise_on_wait_fors = true
+end
+```
+
+This enables you to replace this:
+
+```ruby
+raise unless @search_page.wait_for_search_results
+# or...
+raise unless @search_page.wait_for_no_search_results
+```
+
+with this:
+
+```
+# With raise on wait_fors enabled, this will automatically raise
+# if no search results are found
+@search_page.wait_for_search_results
+# or automatically raise if search results are still found
+@search_page.wait_for_no_search_results
+```
+
 ## Using SitePrism with VCR
 
 There's a SitePrism plugin called `site_prism.vcr` that lets you use

data/lib/site_prism.rb

@@ -12,7 +12,7 @@ module SitePrism
   autoload :AddressableUrlMatcher, 'site_prism/addressable_url_matcher'
 
   class << self
-    attr_accessor :use_implicit_waits
+    attr_accessor :use_implicit_waits, :raise_on_wait_fors
 
     def configure
       yield self
@@ -20,4 +20,5 @@ module SitePrism
   end
 
   @use_implicit_waits = false
+  @raise_on_wait_fors = false
 end

data/lib/site_prism/addressable_url_matcher.rb

@@ -5,11 +5,10 @@ require 'base64'
 
 module SitePrism
   class AddressableUrlMatcher
-    COMPONENT_NAMES = %i[scheme user password host port path query fragment].freeze
-    COMPONENT_PREFIXES = {
-      query: '?',
-      fragment: '#'
-    }.freeze
+    COMPONENT_NAMES = %i[scheme user password host
+                         port path query fragment ].freeze
+
+    COMPONENT_PREFIXES = { query: '?', fragment: '#' }.freeze
 
     attr_reader :pattern
 
@@ -17,7 +16,8 @@ module SitePrism
       @pattern = pattern
     end
 
-    # @return the hash of extracted mappings from parsing the provided URL according to our pattern,
+    # @return the hash of extracted mappings from
+    # parsing the provided URL according to our pattern,
     # or nil if the URL doesn't conform to the matcher template.
     def mappings(url)
       uri = Addressable::URI.parse(url)
@@ -31,15 +31,15 @@ module SitePrism
       result
     end
 
-    # Determine whether URL matches our pattern, and optionally whether the extracted mappings match
-    # a hash of expected values.  You can specify values as strings, numbers or regular expressions.
+    # Determine whether URL matches our pattern, and
+    # optionally whether the extracted mappings match
+    # a hash of expected values.  You can specify values
+    # as strings, numbers or regular expressions.
     def matches?(url, expected_mappings = {})
       actual_mappings = mappings(url)
-      if actual_mappings
-        expected_mappings.empty? || all_expected_mappings_match?(expected_mappings, actual_mappings)
-      else
-        false
-      end
+      return false unless actual_mappings
+      expected_mappings.empty? ||
+        all_expected_mappings_match?(expected_mappings, actual_mappings)
     end
 
     private
@@ -72,29 +72,30 @@ module SitePrism
           component_url = component_url.sub(substituted_value, template_value)
         end
 
-        component_templates[component] = Addressable::Template.new(component_url.to_s)
+        component_templates[component] =
+          Addressable::Template.new(component_url.to_s)
       end
     end
 
-    # Returns empty hash if the template omits the component, a set of substitutions if the
-    # provided URI component matches the template component, or nil if the match fails.
+    # Returns empty hash if the template omits the component,
+    # a set of substitutions if the
+    # provided URI component matches the template component,
+    # or nil if the match fails.
     def component_matches(component, uri)
-      extracted_mappings = {}
       component_template = component_templates[component]
-      if component_template
-        component_url = uri.public_send(component).to_s
-        extracted_mappings = component_template.extract(component_url)
-        unless extracted_mappings
-          # to support Addressable's expansion of queries
-          # ensure it's parsing the fragment as appropriate (e.g. {?params*})
-          prefix = COMPONENT_PREFIXES[component]
-          return nil unless prefix && (extracted_mappings = component_template.extract(prefix + component_url))
-        end
-      end
-      extracted_mappings
+      return {} unless component_template
+      component_url = uri.public_send(component).to_s
+      mappings = component_template.extract(component_url)
+      return mappings if mappings
+      # to support Addressable's expansion of queries
+      # ensure it's parsing the fragment as appropriate (e.g. {?params*})
+      prefix = COMPONENT_PREFIXES[component]
+      return nil unless prefix
+      component_template.extract(prefix + component_url)
     end
 
-    # Convert the pattern into an Addressable URI by substituting the template slugs with nonsense strings.
+    # Convert the pattern into an Addressable URI by substituting
+    # the template slugs with nonsense strings.
     def to_substituted_uri
       url = pattern
       substitutions.each_pair do |slug, value|
@@ -115,28 +116,34 @@ module SitePrism
     end
 
     def reverse_substitutions
-      @reverse_substitutions ||= slugs.each_with_index.reduce({}) do |memo, slug_index|
-        slug, index = slug_index
-        memo.merge(slug_prefix(slug) + substitution_value(index) => slug, substitution_value(index) => slug)
-      end
+      @reverse_substitutions ||=
+        slugs.each_with_index.reduce({}) do |memo, slug_index|
+          slug, index = slug_index
+          memo.merge(
+            slug_prefix(slug) + substitution_value(index) => slug,
+            substitution_value(index) => slug
+          )
+        end
     end
 
     def slugs
       pattern.scan(/{[^}]+}/)
     end
 
-    # If a slug begins with non-alpha characters, it may denote the start of a new component
-    # (e.g. query or fragment). We emit this prefix as part of the substituted slug
+    # If a slug begins with non-alpha characters,
+    # it may denote the start of a new component (e.g. query or fragment).
+    # We emit this prefix as part of the substituted slug
     # so that Addressable's URI parser can see it as such.
     def slug_prefix(slug)
-      matches = slug.match(/\A{([^A-Za-z]+)/)
-      matches && matches[1] || ''
+      prefix = slug.match(/\A{([^A-Za-z]+)/)
+      prefix && prefix[1] || ''
     end
 
     # Generate a repeatable 5 character uniform alphabetical nonsense string
     # to allow parsing as a URI
     def substitution_value(index)
-      Base64.urlsafe_encode64(Digest::SHA1.digest(index.to_s)).gsub(/[^A-Za-z]/, '')[0..5]
+      sha = Digest::SHA1.digest(index.to_s)
+      Base64.urlsafe_encode64(sha).gsub(/[^A-Za-z]/, '')[0..5]
     end
   end
 end

data/lib/site_prism/element_checker.rb

@@ -3,15 +3,31 @@
 module SitePrism
   module ElementChecker
     def all_there?
-      elements_to_check.all? { |element| send "has_#{element}?" }
+      elements_to_check.all? { |element| present?(element) }
+    end
+
+    def elements_present
+      mapped_items.select { |item_name| present?(item_name) }
     end
 
     private
 
     def elements_to_check
-      elements = self.class.mapped_items
-      elements = elements.select { |el| self.class.expected_items.include?(el) } if self.class.expected_items
-      elements
+      if self.class.expected_items
+        mapped_items.select do |el|
+          self.class.expected_items.include?(el)
+        end
+      else
+        mapped_items
+      end
+    end
+
+    def mapped_items
+      self.class.mapped_items.uniq
+    end
+
+    def present?(element)
+      send("has_#{element}?")
     end
   end
 end

data/lib/site_prism/element_container.rb

@@ -2,222 +2,275 @@
 
 module SitePrism
   module ElementContainer
-    attr_reader :mapped_items, :expected_items
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
 
-    def element(element_name, *find_args)
-      build(element_name, *find_args) do
-        define_method(element_name.to_s) do |*runtime_args, &element_block|
-          self.class.raise_if_block(self, element_name.to_s, !element_block.nil?)
-          find_first(*find_args, *runtime_args)
-        end
-      end
+    private
+
+    def raise_if_block(obj, name, has_block)
+      return unless has_block
+
+      raise SitePrism::UnsupportedBlock, "#{obj.class}##{name}"
     end
 
-    def elements(collection_name, *find_args)
-      build(collection_name, *find_args) do
-        define_method(collection_name.to_s) do |*runtime_args, &element_block|
-          self.class.raise_if_block(self, collection_name.to_s, !element_block.nil?)
-          find_all(*find_args, *runtime_args)
-        end
-      end
+    def raise_wait_for_if_failed(obj, name, timeout, failed)
+      return unless SitePrism.raise_on_wait_fors && failed
+
+      raise SitePrism::TimeOutWaitingForExistenceError, \
+            "Timed out after #{timeout}s waiting for #{obj.class}##{name}"
     end
-    alias collection elements
 
-    def expected_elements(*elements)
-      @expected_items = elements
+    def raise_wait_for_no_if_failed(obj, name, timeout, failed)
+      return unless SitePrism.raise_on_wait_fors && failed
+
+      raise SitePrism::TimeOutWaitingForNonExistenceError, \
+            "Timed out after #{timeout}s waiting for no #{obj.class}##{name}"
     end
 
-    def section(section_name, *args, &block)
-      section_class, find_args = extract_section_options(args, &block)
-      build(section_name, *find_args) do
-        define_method section_name do |*runtime_args, &runtime_block|
-          section_class.new self, find_first(*find_args, *runtime_args), &runtime_block
+    def merge_args(find_args, runtime_args, override_options = {})
+      find_args = find_args.dup
+      runtime_args = runtime_args.dup
+      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.merge!(override_options)
+      [*find_args, *runtime_args, options]
+    end
+
+    module ClassMethods
+      attr_reader :mapped_items, :expected_items
+
+      def element(element_name, *find_args)
+        build(element_name, *find_args) do
+          define_method(element_name.to_s) do |*runtime_args, &element_block|
+            raise_if_block(self, element_name.to_s, !element_block.nil?)
+            find_first(*merge_args(find_args, runtime_args))
+          end
         end
       end
-    end
 
-    def sections(section_collection_name, *args, &block)
-      section_class, find_args = extract_section_options(args, &block)
-      build(section_collection_name, *find_args) do
-        define_method(section_collection_name) do |*runtime_args, &element_block|
-          self.class.raise_if_block(self, section_collection_name.to_s, !element_block.nil?)
-          find_all(*find_args, *runtime_args).map do |element|
-            section_class.new(self, element)
+      def elements(collection_name, *find_args)
+        build(collection_name, *find_args) do
+          define_method(collection_name.to_s) do |*runtime_args, &element_block|
+            raise_if_block(self, collection_name.to_s, !element_block.nil?)
+            find_all(*merge_args(find_args, runtime_args))
           end
         end
       end
-    end
+      alias collection elements
+
+      def expected_elements(*elements)
+        @expected_items = elements
+      end
 
-    def iframe(iframe_name, iframe_page_class, *args)
-      element_find_args = deduce_iframe_element_find_args(args)
-      scope_find_args = deduce_iframe_scope_find_args(args)
-      add_to_mapped_items(iframe_name)
-      add_iframe_helper_methods(iframe_name, *element_find_args)
-      define_method(iframe_name) do |&block|
-        within_frame(*scope_find_args) do
-          block.call iframe_page_class.new
+      def section(section_name, *args, &block)
+        section_class, find_args = extract_section_options(args, &block)
+        build(section_name, *find_args) do
+          define_method section_name do |*runtime_args, &runtime_block|
+            section_class.new self, find_first(*merge_args(find_args, runtime_args)), &runtime_block
+          end
         end
       end
-    end
 
-    def add_to_mapped_items(item)
-      @mapped_items ||= []
-      @mapped_items << item
-    end
+      def sections(section_collection_name, *args, &block)
+        section_class, find_args = extract_section_options(args, &block)
+        build(section_collection_name, *find_args) do
+          define_method(section_collection_name) do |*runtime_args, &element_block|
+            raise_if_block(self, section_collection_name.to_s, !element_block.nil?)
+            find_all(*merge_args(find_args, runtime_args)).map do |element|
+              section_class.new(self, element)
+            end
+          end
+        end
+      end
 
-    def raise_if_block(obj, name, has_block)
-      return unless has_block
+      def iframe(iframe_name, iframe_page_class, *args)
+        element_find_args = deduce_iframe_element_find_args(args)
+        scope_find_args = deduce_iframe_scope_find_args(args)
+        add_to_mapped_items(iframe_name)
+        add_iframe_helper_methods(iframe_name, *element_find_args)
+        define_method(iframe_name) do |&block|
+          within_frame(*scope_find_args) do
+            block.call iframe_page_class.new
+          end
+        end
+      end
 
-      raise SitePrism::UnsupportedBlock, "#{obj.class}##{name}"
-    end
+      def add_to_mapped_items(item)
+        @mapped_items ||= []
+        @mapped_items << item
+      end
 
-    private
+      private
 
-    def build(name, *find_args)
-      if find_args.empty?
-        create_no_selector(name)
-      else
-        add_to_mapped_items(name)
-        yield
+      def build(name, *find_args)
+        if find_args.empty?
+          create_no_selector(name)
+        else
+          add_to_mapped_items(name)
+          yield
+        end
+        add_helper_methods(name, *find_args)
       end
-      add_helper_methods(name, *find_args)
-    end
 
-    def add_helper_methods(name, *find_args)
-      create_existence_checker(name, *find_args)
-      create_nonexistence_checker(name, *find_args)
-      create_waiter(name, *find_args)
-      create_nonexistence_waiter(name, *find_args)
-      create_visibility_waiter(name, *find_args)
-      create_invisibility_waiter(name, *find_args)
-    end
+      def add_helper_methods(name, *find_args)
+        create_existence_checker(name, *find_args)
+        create_nonexistence_checker(name, *find_args)
+        create_waiter(name, *find_args)
+        create_nonexistence_waiter(name, *find_args)
+        create_visibility_waiter(name, *find_args)
+        create_invisibility_waiter(name, *find_args)
+      end
 
-    def add_iframe_helper_methods(name, *find_args)
-      create_existence_checker(name, *find_args)
-      create_nonexistence_checker(name, *find_args)
-      create_waiter(name, *find_args)
-      create_nonexistence_waiter(name, *find_args)
-    end
+      def add_iframe_helper_methods(name, *find_args)
+        create_existence_checker(name, *find_args)
+        create_nonexistence_checker(name, *find_args)
+        create_waiter(name, *find_args)
+        create_nonexistence_waiter(name, *find_args)
+      end
 
-    def create_helper_method(proposed_method_name, *find_args)
-      if find_args.empty?
-        create_no_selector(proposed_method_name)
-      else
-        yield
+      def create_helper_method(proposed_method_name, *find_args)
+        if find_args.empty?
+          create_no_selector(proposed_method_name)
+        else
+          yield
+        end
       end
-    end
 
-    def create_existence_checker(element_name, *find_args)
-      method_name = "has_#{element_name}?"
-      create_helper_method(method_name, *find_args) do
-        define_method(method_name) do |*runtime_args|
-          wait_time = SitePrism.use_implicit_waits ? Capybara.default_max_wait_time : 0
-          Capybara.using_wait_time(wait_time) do
-            element_exists?(*find_args, *runtime_args)
+      def create_existence_checker(element_name, *find_args)
+        method_name = "has_#{element_name}?"
+        create_helper_method(method_name, *find_args) do
+          define_method(method_name) do |*runtime_args|
+            wait_time = SitePrism.use_implicit_waits ? Capybara.default_max_wait_time : 0
+            Capybara.using_wait_time(wait_time) do
+              element_exists?(*merge_args(find_args, runtime_args))
+            end
           end
         end
       end
-    end
 
-    def create_nonexistence_checker(element_name, *find_args)
-      method_name = "has_no_#{element_name}?"
-      create_helper_method(method_name, *find_args) do
-        define_method(method_name) do |*runtime_args|
-          wait_time = SitePrism.use_implicit_waits ? Capybara.default_max_wait_time : 0
-          Capybara.using_wait_time(wait_time) do
-            element_does_not_exist?(*find_args, *runtime_args)
+      def create_nonexistence_checker(element_name, *find_args)
+        method_name = "has_no_#{element_name}?"
+        create_helper_method(method_name, *find_args) do
+          define_method(method_name) do |*runtime_args|
+            wait_time = SitePrism.use_implicit_waits ? Capybara.default_max_wait_time : 0
+            Capybara.using_wait_time(wait_time) do
+              element_does_not_exist?(*merge_args(find_args, runtime_args))
+            end
           end
         end
       end
-    end
 
-    def create_waiter(element_name, *find_args)
-      method_name = "wait_for_#{element_name}"
-      create_helper_method(method_name, *find_args) do
-        define_method(method_name) do |timeout = nil, *runtime_args|
-          timeout = timeout.nil? ? Capybara.default_max_wait_time : timeout
-          Capybara.using_wait_time(timeout) do
-            element_exists?(*find_args, *runtime_args)
+      def create_waiter(element_name, *find_args)
+        method_name = "wait_for_#{element_name}"
+        create_helper_method(method_name, *find_args) do
+          define_method(method_name) do |timeout = Capybara.default_max_wait_time, *runtime_args|
+            result = Capybara.using_wait_time(timeout) do
+              element_exists?(*merge_args(find_args, runtime_args))
+            end
+            raise_wait_for_if_failed(self, element_name.to_s, timeout, !result)
+            result
           end
         end
       end
-    end
 
-    def create_nonexistence_waiter(element_name, *find_args)
-      method_name = "wait_for_no_#{element_name}"
-      create_helper_method(method_name, *find_args) do
-        define_method(method_name) do |timeout = nil, *runtime_args|
-          timeout = timeout.nil? ? Waiter.default_wait_time : timeout
-          Capybara.using_wait_time(timeout) do
-            element_does_not_exist?(*find_args, *runtime_args)
+      def create_nonexistence_waiter(element_name, *find_args)
+        method_name = "wait_for_no_#{element_name}"
+        create_helper_method(method_name, *find_args) do
+          define_method(method_name) do |timeout = Capybara.default_max_wait_time, *runtime_args|
+            result = Capybara.using_wait_time(timeout) do
+              element_does_not_exist?(*merge_args(find_args, runtime_args))
+            end
+            raise_wait_for_no_if_failed(self, element_name.to_s, timeout, !result)
+            result
           end
         end
       end
-    end
 
-    def create_visibility_waiter(element_name, *find_args)
-      method_name = "wait_until_#{element_name}_visible"
-      create_helper_method(method_name, *find_args) do
-        define_method(method_name) do |timeout = Capybara.default_max_wait_time, *runtime_args|
-          Timeout.timeout(timeout, SitePrism::TimeOutWaitingForElementVisibility) do
-            Capybara.using_wait_time 0 do
-              sleep 0.05 until element_exists?(*find_args, *runtime_args, visible: true)
+      def create_visibility_waiter(element_name, *find_args)
+        method_name = "wait_until_#{element_name}_visible"
+        create_helper_method(method_name, *find_args) do
+          define_method(method_name) do |timeout = Capybara.default_max_wait_time, *runtime_args|
+            unless element_exists?(*merge_args(find_args, runtime_args, visible: true, wait: timeout))
+              raise SitePrism::TimeOutWaitingForElementVisibility
             end
           end
         end
       end
-    end
 
-    def create_invisibility_waiter(element_name, *find_args)
-      method_name = "wait_until_#{element_name}_invisible"
-      create_helper_method(method_name, *find_args) do
-        define_method(method_name) do |timeout = Capybara.default_max_wait_time, *runtime_args|
-          Timeout.timeout(timeout, SitePrism::TimeOutWaitingForElementInvisibility) do
-            Capybara.using_wait_time 0 do
-              sleep 0.05 while element_exists?(*find_args, *runtime_args, visible: true)
+      def create_invisibility_waiter(element_name, *find_args)
+        method_name = "wait_until_#{element_name}_invisible"
+        create_helper_method(method_name, *find_args) do
+          define_method(method_name) do |timeout = Capybara.default_max_wait_time, *runtime_args|
+            unless element_does_not_exist?(*merge_args(find_args, runtime_args, visible: true, wait: timeout))
+              raise SitePrism::TimeOutWaitingForElementInvisibility
             end
           end
         end
       end
-    end
 
-    def create_no_selector(method_name)
-      define_method(method_name) do
-        raise SitePrism::NoSelectorForElement.new, "#{self.class.name} => :#{method_name} needs a selector"
+      def create_no_selector(method_name)
+        define_method(method_name) do
+          raise SitePrism::NoSelectorForElement.new, "#{self.class.name} => :#{method_name} needs a selector"
+        end
       end
-    end
 
-    def deduce_iframe_scope_find_args(args)
-      case args[0]
-      when Integer
-        [args[0]]
-      when String
-        [:css, args[0]]
-      else
-        args
+      def deduce_iframe_scope_find_args(args)
+        case args[0]
+        when Integer
+          [args[0]]
+        when String
+          [:css, args[0]]
+        else
+          args
+        end
       end
-    end
 
-    def deduce_iframe_element_find_args(args)
-      case args[0]
-      when Integer
-        "iframe:nth-of-type(#{args[0] + 1})"
-      when String
-        [:css, args[0]]
-      else
-        args
+      def deduce_iframe_element_find_args(args)
+        case args[0]
+        when Integer
+          "iframe:nth-of-type(#{args[0] + 1})"
+        when String
+          [:css, args[0]]
+        else
+          args
+        end
+      end
+
+      def extract_section_options(args, &block)
+        if args.first.is_a?(Class)
+          klass = args.shift
+          section_class = klass if klass.ancestors.include?(SitePrism::Section)
+        end
+
+        section_class = deduce_section_class(section_class, &block)
+        arguments = deduce_search_arguments(section_class, args)
+        [section_class, arguments]
+      end
+
+      def deduce_section_class(base_class, &block)
+        klass = base_class
+
+        klass = Class.new(klass || SitePrism::Section, &block) if block_given?
+
+        unless klass
+          raise ArgumentError, "You should provide descendant of SitePrism::Section \
+class or/and a block as the second argument."
+        end
+        klass
+      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")
       end
-    end
 
-    def extract_section_options(args, &block)
-      if args.first.is_a?(Class)
-        section_class = args.shift
-      elsif block_given?
-        section_class = Class.new(SitePrism::Section, &block)
-      else
-        raise ArgumentError, 'You should provide section class either as a block, or as the second argument.'
+      def extract_search_arguments(args)
+        args if args && !args.empty?
       end
-      [section_class, args]
     end
   end
 end

data/lib/site_prism/exceptions.rb

@@ -6,7 +6,8 @@ module SitePrism
 
   class InvalidUrlMatcher < StandardError
     def message
-      'Could not automatically match your URL. Templated port numbers are unsupported.'
+      "Could not automatically match your URL. \
+Templated port numbers are unsupported."
     end
   end
 
@@ -18,6 +19,8 @@ module SitePrism
     end
   end
 
+  class TimeOutWaitingForExistenceError < StandardError; end
+  class TimeOutWaitingForNonExistenceError < StandardError; end
   class TimeOutWaitingForElementVisibility < StandardError; end
   class TimeOutWaitingForElementInvisibility < StandardError; end
 

data/lib/site_prism/loadable.rb

@@ -3,7 +3,8 @@
 module SitePrism
   module Loadable
     module ClassMethods
-      # The list of load_validations.  They will be executed in the order they are defined.
+      # The list of load_validations.
+      # They will be executed in the order they are defined.
       #
       # @return [Array]
       def load_validations
@@ -16,44 +17,53 @@ module SitePrism
 
       # Appends a load validation block to the page class.
       #
-      # When `loaded?` is called, these blocks are instance_eval'd against the current page
-      # instance.  This allows users to wait for specific events to occur on the page or certain elements
-      # to be loaded before performing any actions on the page.
+      # When `loaded?` is called, these blocks are instance_eval'd
+      # against the current page instance.
+      # This allows users to wait for specific events to occur on
+      # the page or certain elements to be loaded before performing
+      # any actions on the page.
       #
-      # @param block [&block] A block which returns true if the page loaded successfully, or false if it did not.
+      # @param block [&block] A block which returns true if the page
+      # loaded successfully, or false if it did not.
       def load_validation(&block)
         _load_validations << block
       end
 
+      private
+
       def _load_validations
         @_load_validations ||= []
       end
-      private :_load_validations
     end
 
     def self.included(base)
       base.extend(ClassMethods)
     end
 
-    # In certain circumstances, we cache that the page has already been confirmed to be loaded so that actions which
-    # call `loaded?` a second time do not need to perform the load_validation queries against the page a second time.
+    # In certain circumstances, we cache that the page has already
+    # been confirmed to be loaded so that actions which
+    # call `loaded?` a second time do not need to perform
+    # the load_validation queries against the page a second time.
     attr_accessor :loaded, :load_error
 
     # Executes the given block after the page is loaded.
     #
     # The loadable object instance is yielded into the block.
     #
-    # @param block [&block] The block to be executed once the page has finished loading.
+    # @param block [&block] The block to be executed once the page
+    # has finished loading.
     def when_loaded(&_block)
-      previously_loaded = loaded # Get original loaded value, in case we are nested inside another when_loaded block.
-      raise(ArgumentError, 'A block was expected, but none received.') unless block_given?
+      # Get original loaded value, in case we are nested
+      # inside another when_loaded block.
+      previously_loaded = loaded
+      message = 'A block was expected, but none received.'
+      raise ArgumentError, message unless block_given?
 
       # Within the block, cache loaded? to optimize performance.
       self.loaded = loaded?
-      unless loaded
-        message = "Failed to load because: #{load_error || 'no reason given'}"
-        raise(::SitePrism::NotLoadedError, message)
-      end
+
+      message = "Failed to load because: #{load_error || 'no reason given'}"
+      raise ::SitePrism::NotLoadedError, message unless loaded
 
       yield self
     ensure
@@ -62,7 +72,8 @@ module SitePrism
 
     # Check if the page is loaded.
     #
-    # On failure, if an error was reported by a failing validation, it will be available via the `load_error` accessor.
+    # On failure, if an error was reported by a failing validation,
+    # it will be available via the `load_error` accessor.
     #
     # @return [Boolean] True if the page loaded successfully; otherwise false.
     def loaded?
@@ -73,7 +84,10 @@ module SitePrism
       load_validations_pass?
     end
 
-    # If any load validations from page subclasses returns false, immediately return false.
+    private
+
+    # If any load validations from page subclasses returns false,
+    # immediately return false.
     def load_validations_pass?
       self.class.load_validations.all? do |validation|
         passed, message = instance_eval(&validation)
@@ -82,6 +96,5 @@ module SitePrism
         passed
       end
     end
-    private :load_validations_pass?
   end
 end

data/lib/site_prism/page.rb

@@ -3,14 +3,18 @@
 require 'site_prism/loadable'
 
 module SitePrism
+  # rubocop:disable Metrics/ClassLength
   class Page
     include Capybara::DSL
     include ElementChecker
     include Loadable
-    extend ElementContainer
+    include ElementContainer
 
     load_validation do
-      [displayed?, "Expected #{current_url} to match #{url_matcher} but it did not."]
+      [
+        displayed?,
+        "Expected #{current_url} to match #{url_matcher} but it did not."
+      ]
     end
 
     def page
@@ -40,7 +44,8 @@ module SitePrism
 
     def displayed?(*args)
       expected_mappings = args.last.is_a?(::Hash) ? args.pop : {}
-      seconds = !args.empty? ? args.first : Waiter.default_wait_time
+      seconds = !args.empty? ? args.first : Capybara.default_max_wait_time
+
       raise SitePrism::NoUrlMatcherForPage if url_matcher.nil?
       begin
         Waiter.wait_until_true(seconds) { url_matches?(expected_mappings) }
@@ -49,7 +54,7 @@ module SitePrism
       end
     end
 
-    def url_matches(seconds = Waiter.default_wait_time)
+    def url_matches(seconds = Capybara.default_max_wait_time)
       return unless displayed?(seconds)
 
       if url_matcher.is_a?(Regexp)
@@ -93,7 +98,7 @@ module SitePrism
     end
 
     def secure?
-      page.current_url.start_with? 'https'
+      page.current_url.start_with?('https')
     end
 
     private
@@ -133,7 +138,8 @@ module SitePrism
     end
 
     def matcher_template
-      @addressable_url_matcher ||= AddressableUrlMatcher.new(url_matcher)
+      @matcher_template ||= AddressableUrlMatcher.new(url_matcher)
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/site_prism/section.rb

@@ -7,10 +7,23 @@ module SitePrism
     include Capybara::DSL
     include ElementChecker
     include Loadable
-    extend ElementContainer
+    include ElementContainer
 
     attr_reader :root_element, :parent
 
+    def self.set_default_search_arguments(*args)
+      @default_search_arguments = args
+    end
+
+    def self.default_search_arguments
+      @default_search_arguments ||
+        (
+          superclass.respond_to?(:default_search_arguments) &&
+          superclass.default_search_arguments
+        ) ||
+        nil
+    end
+
     def initialize(parent, root_element)
       @parent = parent
       @root_element = root_element
@@ -18,8 +31,11 @@ module SitePrism
     end
 
     # Capybara::DSL module "delegates" Capybara methods to the "page" method
+    # as such we need to overload this method so that the correct scoping
+    # occurs and calls within a section (For example section.find(element))
+    # correctly scope to look within the section only
     def page
-      root_element || Capybara.current_session
+      root_element || super
     end
 
     def visible?
@@ -36,9 +52,7 @@ module SitePrism
 
     def parent_page
       candidate_page = parent
-      until candidate_page.is_a?(SitePrism::Page)
-        candidate_page = candidate_page.parent
-      end
+      candidate_page = candidate_page.parent until candidate_page.is_a?(SitePrism::Page)
       candidate_page
     end
 

data/lib/site_prism/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SitePrism
-  VERSION = '2.13'.freeze
+  VERSION = '2.14'.freeze
 end

data/lib/site_prism/waiter.rb

@@ -13,10 +13,5 @@ module SitePrism
 
       raise SitePrism::TimeoutException, wait_time
     end
-
-    def self.default_wait_time
-      warn 'default_wait_time is now deprecated. This will be removed in an upcoming release.'
-      Capybara.default_max_wait_time
-    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: site_prism
 version: !ruby/object:Gem::Version
-  version: '2.13'
+  version: '2.14'
 platform: ruby
 authors:
 - Nat Ritmeyer
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-21 00:00:00.000000000 Z
+date: 2018-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -54,95 +54,89 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 3.0.1
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: dotenv
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '2.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '12.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '12.0'
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.50.0
+        version: '3.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.50.0
+        version: '3.5'
 - !ruby/object:Gem::Dependency
-  name: selenium-webdriver
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.4.0
-    - - "<="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.10.0
+        version: '0.50'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.4.0
-    - - "<="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.10.0
+        version: '0.50'
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: selenium-webdriver
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.12'
+        version: '3.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.12'
+        version: '3.4'
 - !ruby/object:Gem::Dependency
-  name: dotenv
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '0.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '0.12'
 description: |-
   SitePrism gives you a simple, clean and semantic DSL for describing your site.
   SitePrism implements the Page Object Model pattern on top of Capybara.