gless 1.2.0 → 1.3.1

data/Changelog.txt

@@ -3,3 +3,7 @@
   behaviour.
 - 1.2.0: 10 Jun 2013: Changes by bairyn.  Added caching, finding
 based on parent element, and block validators.
+- 1.3.0: 8 Aug 2013: Detect and work around errors caused by incorrect caching,
+and add support for element arguments, evaluating elements under new parents,
+finding based on children, and the :unique option to ensure only one element
+matches a specification.

data/examples/test_github/lib/pages/test_github/search_page.rb

@@ -3,14 +3,20 @@
 module TestGithub
   class SearchPage < TestGithub::BasePage
 
-    element :search_form   , :form       , :id    => 'search_form'       , :validator => true
-    element :search_input  , :text_field , :class => 'search-page-input' , :validator => true , :parent => :search_form
+    element :search_form   , :form       , :id    => 'search_form'       , :validator => true , :child  => :search_input
+    element :search_input  , :text_field , :name  => 'q'                 , :validator => true , :parent => :search_form
     element :search_button , :button     , :text  => 'Search'            , :validator => true , :parent => :search_form
 
+    element :repository_list  , :ul   , :class => /\brepolist\b/
+    element :repository_link  , :link , :click_destination => :RepoPage , :parent => :repository_list , :proc => -> repos, page, name do
+      repos.a(:text => name)
+    end
+    element :repository_elems , :lis  , :class => 'public source'       , :parent => :repository_list
+
     # Test validator blocks.
-	add_validator do |browser, session|
-	  browser.url =~ /search/
-	end
+    add_validator do |browser, session|
+      browser.url =~ /search/
+    end
 
     url %r{^:base_url/search}
     set_entry_url ':base_url/search'
@@ -24,8 +30,7 @@ module TestGithub
 
     def goto_repository name
       @session.log.debug "SearchPage: goto_repository: name: #{name}"
-      (find_repository name)[:link].click
-      @session.acceptable_pages = TestGithub::RepoPage
+      repository_link(name).click
     end
 
     def find_repository name
@@ -42,7 +47,7 @@ module TestGithub
     end
 
     def repositories
-      repos = self.lis.select { |li| li.class_name == 'public source' }
+      repos = repository_elems
 
       @session.log.debug "SearchPage: repositories: repos: #{repos.inspect}"
 

data/lib/gless/base_page.rb

@@ -119,13 +119,25 @@ module Gless
       # That's about as complicated as it gets.
       #
       # The first two arguments (name and type) are required.  The
-      # rest is a hash.  +:validator+, +:click_destination+, +:parent+,
-      # +:proc+, and +:cache+ (see below) have special meaning.
+      # rest is a hash.  Six options (see below) have special meaning:
+      # +:validator+, +:click_destination+, +:parent+, +:child+
+      # +:proc+, +:cache+, and +:unique+ (see below) have special meaning.
       #
       # Anything else is taken to be a Watir selector.  If no
       # selector is forthcoming, the name is taken to be the element
       # id.
       #
+      # The element can also be a collection of elements with the appropriate
+      # element type (e.g. +lis+, plural of +li+); however, if it is restricted
+      # by non-watir selectors (e.g. with :child), the collection is returned
+      # as an +Array+, since watir-webdriver does not support arbitrarily
+      # filtering elements from an +ElementCollection+.  For
+      # reliability, the user can either ensure that the element is only used
+      # after being coerced into an array with +.to_a+ to ensure that the
+      # collection ends up as an Array in each case (unless the method used
+      # is supported by both element collections and arrays), or use a
+      # low-level +:proc+ to bypass gless's element finding procedure.
+      #
       # @param [Symbol] basename The name used in the Gless user's code
       #   to refer to this element.  This page object ends up with a
       #   method of this name.
@@ -149,18 +161,66 @@ module Gless
       # 
       # @option opts [Symbol] :parent (nil) A symbol of a parent element
       #   to which matching is restricted.
-      # 
+      #
+      # @option opts [Symbol, Array<Symbol>, Array<Array<Symbol>>] :child (nil)
+      #   If present, this restricts element selection to elements that
+      #   contain the child element.  The parent of the child element is
+      #   overridden with the element being tested; it is therefore safe to
+      #   set the child element's parent to this one, since it won't result
+      #   in circular reference.  This is useful if an element on a page,
+      #   that must contain a child element that can be located with its
+      #   selectors, is used in another way.  This can be set to an array to
+      #   specify multiple children elements.  Arguments can be specified in
+      #   an Array.  A :child can point to the Symbol of the child element.  To
+      #   specify multiple children, set :child to an Array of Symbols.  To
+      #   specify arguments to pass to each child, set :child to an Array of
+      #   Arrays each containing the symbol of the child element and then the
+      #   arguments passed to it.  Examples of each usage:
+      #
+      #   element :games_pane   , :div , :class => 'pane' , :child => :tbs_list
+      #   element :tbs_list     , :ul  , :class => 'list' , :child => [:tbs_header, :tbs_popular_list]
+      #   element :tbs_pop_list , :ul  , :class => 'list' , :child => [[:tbs_link, 'Battle Game 2'], [:tbs_link, 'Wars']]
+      #
+      #   element :tbs_header   , :h3  , :text  => 'Turn Based Strategy Games'
+      #   element :tbs_link     , :link , :proc => -> parent, page, name {...}
+      #
       # @option opts [Symbol] :cache (nil) If non-nil, overrides the default
       #   cache setting and determines whether caching is enabled for this
       #   element.  If false, a new look-up will be performed each time the
       #   element is accessed, and, if true, a look-up will only be performed
       #   once until the session changes the page.
+      #
+      # @option opts [Symbol] :unique (false) If true, fail if multiple
+      #   elements match the element's specification when the element is
+      #   accessed.  Note that this option has no effect on elements with
+      #   +:proc+s.
       # 
       # @option opts [Symbol] :proc (nil) If present, specifies a manual,
       #   low-level procedure to return a watir element, which overrides other
       #   selectors.  When the watir element is needed, this procedure is
-      #   called with the parent watir element passed as the argument (see
-      #   +:parent+) if it exists, and otherwise the browser.
+      #   called with the parent watir element passed as the first argument (see
+      #   +:parent+) if it exists, and otherwise the browser, along with the
+      #   page as the second argument.  Any arguments given to the element
+      #   at runtime are passed to the procedure after the first, parent,
+      #   argument.  For example, given the definition
+      #
+      #     element :book_list, :ul, :click_destination => :HomePage, :parent => :nonfiction, :proc => -> parent, page, author {...}
+      #
+      #   then whenever +session.book_list "Robyn Dawes"+ is invoked, the procedure will be passed the
+      #   +:nonfiction+ element, the page for which +:book_list+ was defined,
+      #   and the string "Robyn Dawes", and should return a Watir element.  In
+      #   the block itself, +parent+ could be used as the root element (the
+      #   browser with no root element), which can be different if the user
+      #   decides to restrict the +:book_list+ element under a new parent (e.g.
+      #   in invoking +@session.bilingual_pane.book_list, in which case parent
+      #   would be set to the :bilingual_pane element).  +page+ refers to the
+      #   page object in which +:book_list+ is defined, which can be used to
+      #   refer to other elements and methods on the same page.  Any arguments
+      #   passed to the element are given to the block.
+      #
+      #   Different elements are cached for different
+      #   arguments.  Caching can be disabled for an individual
+      #   element by passing :cache => false.
       # 
       # @option opts [Object] ANY All other opts keys are used as
       #   Watir selectors to find the element on the page.
@@ -170,7 +230,7 @@ module Gless
 
         # Promote various other things into selectors; do this before
         # we add in the default below
-        non_selector_opts = [ :validator, :click_destination, :parent, :cache ]
+        non_selector_opts = [ :validator, :click_destination, :parent, :cache, :unique, :child ]
         if ! opts[:selector]
           opts[:selector] = {} if ! opts.keys.empty?
           opts.keys.each do |key|
@@ -190,7 +250,19 @@ module Gless
         click_destination = opts[:click_destination]
         validator = opts[:validator]
         parent = opts[:parent]
+        child = opts[:child]
+        if child.nil?
+          # No child
+          child = []
+        elsif child.kind_of? Symbol
+          # Single child
+          child = [[child]]
+        elsif (child.kind_of? Array) && (!child.empty?) && (child[0].kind_of? Symbol)
+          # Multiple children w/out arguments
+          child.map! {|s| [s]}
+        end
         cache = opts[:cache]
+        unique = opts[:unique]
 
         methname = basename.to_s.tr('-', '_').to_sym
 
@@ -206,8 +278,8 @@ module Gless
           # $master_logger.debug "In GenericBasePage, for #{self.name}, element: #{basename} has a special destination when clicked, #{click_destination}"
         end
 
-        define_method methname do
-          cached_elements[methname] ||= Gless::WrapWatir.new(@browser, @session, self, type, selector, click_destination, parent, cache)
+        define_method methname do |*args|
+          cached_elements[[methname, *args]] ||= Gless::WrapWatir.new(methname, @browser, @session, self, type, selector, click_destination, parent, child, cache, unique, *args)
         end
       end
 
@@ -398,10 +470,6 @@ module Gless
       end
     end
 
-    #******************************
-    # Object Level
-    #******************************
-
     # @return [Hash] A hash of cached +WrapWatir+ elements indexed by the
     #   symbol name.  This hash is cleared whenever the page changes.
     attr_writer :cached_elements

data/lib/gless/config.rb

@@ -27,10 +27,10 @@ module Gless
     #
     # @return [Gless::EnvConfig]
     def initialize
-      env = (ENV['ENVIRONMENT'] || 'development').to_sym
+      @env = (ENV['ENVIRONMENT'] || 'development').to_sym
 
-      env_file = "#{@@env_dir}/config/#{env}.yml"
-      raise "You need to create a configuration file named '#{env}.yml' (generated from the ENVIRONMENT environment variable) under #{@@env_dir}/lib/config" unless File.exists? env_file
+      env_file = "#{@@env_dir}/config/#{@env}.yml"
+      raise "You need to create a configuration file named '#{@env}.yml' (generated from the ENVIRONMENT environment variable) under #{@@env_dir}/lib/config" unless File.exists? env_file
 
       @config = YAML::load_file env_file
     end
@@ -54,28 +54,62 @@ module Gless
     # @return [Object] what's left after following each key; could be
     #   basically anything.
     def get( *args )
+      r = get_default nil, *args
+      raise "Could not locate '#{args.join '.'}' in YAML config; please ensure that '#{@env}.yml' is up to date." if r.nil?
+      r
+    end
+
+    # Optionally get an element from the configuration, otherwise returning the
+    # default value.
+    #
+    # @example
+    #
+    #  @config.get_default false, :global, :cache
+    #
+    # @return [Object] what's left after following each key, or else the
+    #   default value.
+    def get_default( default, *args )
       if args.empty?
         return @config
       end
 
-      return get_sub_tree( @config, *args )
+      r = get_sub_tree( @config, *args )
+      r.nil? ? default : r
     end
 
     def merge(hash)
       @config.merge!(hash)
     end
 
+    # Set an element in the configuration to the given value, passed after all
+    # of the indices.
+    #
+    # @example
+    #
+    #  @config.set :global, :debug, true
+    def set(*indices, value)
+      set_root @config, value, *indices
+    end
+
     private
 
+    def set_root root, value, *indices
+      if indices.length > 1
+        set_root root[indices[0]], value, *indices[1..-1]
+      else
+        root[indices[0]] = value
+      end
+    end
+
     # Recursively does all the heavy lifting for get
     def get_sub_tree items, elem, *args
       # Can't use debug logging here, as it maybe isn't turned on yet
       # puts "In Gless::EnvConfig, get_sub_tree: items: #{items}, elem: #{elem}, args: #{args}"
 
-      raise "Could not locate '#{elem}' in YAML config" if items.nil?
+      return nil if items.nil?
 
       new_items = items[elem.to_sym]
-      raise "Could not locate '#{elem}' in YAML config" if new_items.nil?
+      return nil if new_items.nil?
 
       if args.empty?
         return new_items

data/lib/gless/session.rb

@@ -83,6 +83,12 @@ module Gless
       @config.get(*args)
     end
 
+    # Just passes through to the Gless::EnvConfig component's +get_default+
+    # method.
+    def get_config_default(*args)
+      @config.get_default(*args)
+    end
+
     # Just a shortcut to get to the Gless::Logger object.
     def log
       @logger
@@ -174,12 +180,18 @@ module Gless
     #
     # @param [Class] pklas The class for the page object that has a
     #   set_entry_url that we are using.
-    def enter(pklas)
+    # @param [Boolean] always (true) Whether to enter the given page even
+    def enter(pklas, always = true)
       log.info "Session: Entering the site directly using the entry point for the #{pklas.name} page class"
-      @current_page = pklas
-      @pages[pklas].enter
-      # Needs to run through our custom acceptable_pages= method
-      self.acceptable_pages = pklas
+
+      if always || pklas != @current_page
+        @current_page = pklas
+        @pages[pklas].enter
+        # Needs to run through our custom acceptable_pages= method
+        self.acceptable_pages = pklas
+      else
+        log.debug "Session: Already on page"
+      end
     end
 
     # Wait for long-term AJAX-style processing, i.e. watch the page

data/lib/gless/wrap_watir.rb

@@ -21,9 +21,10 @@ module Gless
     require 'rspec'
     include RSpec::Matchers
 
-    # @return [Gless::WrapWatir] The symbol for the parent of this element,
+    # @return [Symbol, Gless::WrapWatir, Watir::Element, Watir::ElementCollection]
+    #   The symbol for the parent of this element,
     #   restricting the scope of its selectorselement.
-    attr_accessor :parent
+    attr_accessor :gless_parent
 
     # Sets up the wrapping.
     #
@@ -40,6 +41,7 @@ module Gless
     # The wrapper only considers *visible* matching elements, unless
     # the selectors include ":invisible => true".
     #
+    # @param [Symbol] name The name of this method; used for debugging.
     # @param [Gless::Browser] browser
     # @param [Gless::Session] session
     # @param [Gless::BasePage] page
@@ -56,13 +58,18 @@ module Gless
     #
     #   is the selector arguments.
     # @param [Gless::BasePage, Array<Gless::BasePage>] click_destination Optional. A list of pages that are OK places to end up after we click on this element
-    # @param [Gless:WrapWatir] parents The symbol for the parent element under which the wrapped element is restricted.
+    # @param [Symbol] gless_parent The symbol for the parent element under which the wrapped element is restricted.
+    # @param [Array<Array<Object>>] child The list of of the children over which
+    #   element selection is restricted.  Each Array contains the symbol of the
+    #   element and the arguments passed to it.
     # @param [Boolean] cache Whether to cache this element.  If false,
     #   +find_elem+, unless overridden with its argument, performs a lookup
     #   each time it is invoked; otherwise, the watir element is recorded
     #   and kept until the session changes the page.  If nil, the default value
     #   is retrieved from the config.
-    def initialize(browser, session, page, orig_type, orig_selector_args, click_destination, parent, cache)
+    # @param [Boolean] unique Whether to require element matches to be unique.
+    def initialize(name, browser, session, page, orig_type, orig_selector_args, click_destination, gless_parent, child, cache, unique, *args)
+      @name = name
       @browser = browser
       @session = session
       @page = page
@@ -71,8 +78,11 @@ module Gless
       @num_retries = 3
       @wait_time = 30
       @click_destination = click_destination
-      @parent = parent
+      @gless_parent = gless_parent
+      @child = child
       @cache = cache.nil? ? @session.get_config(:global, :cache) : cache
+      @unique = unique
+      @args = [*args]
     end
 
     # Finds the element in question; deals with the fact that the
@@ -85,32 +95,56 @@ module Gless
     # just passes those variables to the Watir browser as normal.
     #
     # @param [Boolean] use_cache If not nil, overrides the element's +cache+
-    # value.  If false, the element is re-located; otherwise, if the element
-    # has already been found, return it.
-    def find_elem use_cache = nil
+    #   value.  If false, the element is re-located; otherwise, if the element
+    #   has already been found, return it.
+    # @param [Boolean] must_exist (true) Assume the element exists; otherwise,
+    #   return nil if an exception is thrown while locating the element.
+    def find_elem use_cache = nil, must_exist = true
       use_cache = @cache if use_cache.nil?
       if use_cache
         @cached_elem ||= find_elem_directly
       else
         @cached_elem = find_elem_directly
       end
+
+      if @temporary
+        e = @cached_elem
+        @cached_elem = nil
+        e
+      else
+        @cached_elem
+      end
     end
 
     # Find the element in question, regardless of whether the element has
     # already been identified.  The cache is complete ignored and is not
     # updated.  To update the cache and re-locate the element, use +find_elem
     # false+
-    def find_elem_directly
+    #
+    # @param [Boolean] must_exist (true) Assume the element exists; otherwise,
+    #   return nil if an exception is thrown while locating the element.
+    def find_elem_directly must_exist = true
       tries=0
       begin
         # Do we want to return more than one element?
         multiples = false
 
-        par = parent ? @page.send(parent).find_elem : @browser
+        case gless_parent
+        when NilClass
+          par = @browser
+        when Symbol
+          par = @page.send(gless_parent).find_elem
+        when WrapWatir
+          par = gless_parent.find_elem
+        when Watir::Element
+          par = gless_parent
+        when Watir::ElementCollection
+          par = gless_parent
+        end
 
         if @orig_selector_args.has_key? :proc
           # If it's a Proc, it can handle its own visibility checking
-          return @orig_selector_args[:proc].call par
+          return @orig_selector_args[:proc].call par, @page, *@args
         else
           # We want all the relevant elements, so force that if it's
           # not what was asked for
@@ -125,21 +159,50 @@ module Gless
             end
           end
           @session.log.debug "WrapWatir: find_elem: elements type: #{type}"
-          elems = par.send(type, @orig_selector_args)
+          elems = @child.inject(par.send(type, @orig_selector_args)) do |watir_elems, child_gless_elem_arg|
+            watir_elems.select do |watir_elem|
+              child_watir_elem = @page.send(child_gless_elem_arg[0], *child_gless_elem_arg[1..-1]).with_parent(watir_elem).find_elem nil, false
+              if child_watir_elem.nil?
+                false
+              else
+                if child_watir_elem.kind_of? Watir::Element
+                  child_watir_elem.exists?
+                else
+                  child_watir_elem.length >= 1
+                end
+              end
+            end
+          end
         end
 
         @session.log.debug "WrapWatir: find_elem: elements identified by #{trimmed_selectors.inspect} initial version: #{elems.inspect}"
 
-        if elems.nil? or elems.length == 0
+        if @unique && elems && elems.length > 1
+          @session.log.debug "WrapWatir: find_elem: '#{@name}' is not unique"
+          return par.send(@orig_type, :id => /$^ ('#{@name}' is not unique)/)
+        elsif elems.nil? || elems.length == 0
           @session.log.debug "WrapWatir: find_elem: can't find any element identified by #{trimmed_selectors.inspect}"
           # Generally, watir-webdriver code expects *something*
           # back, and uses .present? to see if it's really there, so
           # we get the singleton to satisfy that need.
-          return par.send(@orig_type, @orig_selector_args)
+
+          # Check for non-watir selectors, in which case we approximate by
+          # creating a watir-selector that never matches.
+          if elems.kind_of? Array
+            # Rather than proceeding silently without the non-watir selectors,
+            # we return an element that is never present, requiring a new
+            # element to be returned.
+            #
+            # Set temporary to avoid caching this element.
+            @temporary = true
+            return par.send(@orig_type, :id => /$^ ('#{@name}' not found)/)
+          else
+            return par.send(@orig_type, @orig_selector_args)
+          end
         end
 
         # We got something unexpected; just give it back
-        if ! elems.is_a?(Watir::ElementCollection)
+        if ! elems.is_a?(Watir::ElementCollection) && !elems.is_a?(Array)
           @session.log.debug "WrapWatir: find_elem: elements aren't a collection; returning them"
           return elems
         end
@@ -147,12 +210,15 @@ module Gless
         if multiples
           # We're OK returning the whole set
           @session.log.debug "WrapWatir: find_elem: multiples were requested; returning #{elems.inspect}"
+          @session.log.info "WrapWatir: find_elem: #{@name} returns an array due to non-watir element filtering; :proc can be used to override behaviour" if elems.kind_of? Array
           return elems
         elsif elems.length == 1
           # It's not a collection; just return it.
           @session.log.debug "WrapWatir: find_elem: only one item found; returning #{elems[0].inspect}"
           return elems[0]
         else
+          return nil if elems.length < 1 unless must_exist
+
           unless @orig_selector_args.has_key? :invisible and @orig_selector_args[:invisible]
             if trimmed_selectors.inspect !~ /password/i
               @session.log.debug "WrapWatir: find_elem: elements identified by #{trimmed_selectors.inspect} before visibility selection: #{elems.inspect}"
@@ -186,14 +252,23 @@ module Gless
 
         if tries < 3
           @session.log.debug "WrapWatir: find_elem: Retrying after exception."
+          tries += 1
           retry
         else
-          @session.log.debug "WrapWatir: find_elem: Giving up after exception."
+          @session.log.warn "WrapWatir: find_elem: Giving up after exception."
+          raise
         end
-        tries += 1
       end
     end
 
+    # Retrieve a copy of the gless element with a different parent.  With a
+    # different parent, the copy may refer to a different element.
+    def with_parent(gless_parent)
+      copy = clone
+      copy.gless_parent = gless_parent
+      copy
+    end
+
     # Pulls any procs out of the selectors for debugging purposes
     def trimmed_selectors
       @orig_selector_args.reject { |k,v| k == :proc }
@@ -201,9 +276,99 @@ module Gless
 
     # Passes everything through to the underlying Watir object, but
     # with logging.
-    def method_missing(m, *args, &block)
+    #
+    # If caching is enabled, wraps the element to check for stale element
+    # reference errors.
+    def wrap_watir_call(m, *args, &block)
       wrapper_logging(m, args)
-      find_elem.send(m, *args, &block)
+      if ! @cache
+        find_elem.send(m, *args, &block)
+      else
+        # Caching is enabled for this element.  We do some complex processing
+        # here to appropriately respond to cases in which caching causes
+        # issues, in which case we let the user know by emitting a helpful
+        # warning and trying again without caching.
+
+        # catch_stale takes an WatirElement with a block and tries running the
+        # block, trying it again with caching disabled if it fails with a
+        # +StaleElementReferenceError+.  This exists to avoid repetition in the
+        # code.
+        catch_stale = -> &block do
+          begin
+            block.call
+          rescue Selenium::WebDriver::Error::StaleElementReferenceError => e
+            warn_prefix = "#{@name}: "
+
+            # The method call did something directly but raised the relevant
+            # exception.  Try without caching enabled.
+
+            @session.log.warn "#{warn_prefix}caught a StaleElementReferenceError; trying without caching..."
+
+            begin
+              r = block.call false
+              @session.log.warn "#{warn_prefix}the call succeeded without caching.  Please add \":cache => false\" to prevent this from occurring; disabling caching for this elem."
+              @cache = false
+              r
+            rescue Selenium::WebDriver::Error::StaleElementReferenceError => e
+              @session.log.error "#{warn_prefix}disabled caching but caught the same type of exception; failing."
+              raise
+            end
+          end
+        end
+
+        # Each method call might do something directly to an element, or it
+        # might return a child element.  In case of the former, we catch
+        # +StaleElementReferenceError+s.  In the case of the latter, wrap the
+        # element.
+        wrap_object = -> wrap_meth, *wrap_args, wrap_block, &gen_elem do
+          catch_stale.call do |use_cache|
+            r = gen_elem.call(use_cache).send(wrap_meth, *wrap_args, &wrap_block)
+
+            # The call itself succeeded, whether we tried disabling caching or
+            # not.
+            if ! ((r.kind_of? Watir::Element) || (r.kind_of? Watir::ElementCollection))
+              # Safe to return.
+              r
+            else
+              # Wrap the result in a new object that catches stale element
+              # reference exceptions and responds appropriately.
+              #
+              # Using a proxy class as a child of +BasicObject+ would be much
+              # simpler, but to avoid problems with code that analyzes the
+              # object's class, we have some more work to do.
+              #
+              # Override each instance method with a wrapper that checks for
+              # stale element reference errors, and then similarly override
+              # +method_missing+.
+              wrapped = r.clone
+              wrapped.class.instance_methods.each do |inst_meth|
+                if inst_meth != :define_singleton_method
+                  wrapped.define_singleton_method inst_meth do |*inst_args, &inst_block|
+                    wrap_object.call(inst_meth, *inst_args, inst_block) {|use_cache| gen_elem.call(use_cache).send(wrap_meth, *wrap_args, &wrap_block)}
+                  end
+                end
+              end
+              wrapped.define_singleton_method :method_missing do |inst_meth, *inst_args, &inst_block|
+                wrap_object.call(inst_meth, *inst_args, inst_block) {|use_cache| gen_elem.call(use_cache).send(wrap_meth, *wrap_args, &wrap_block)}
+              end
+              wrapped
+            end
+          end
+        end
+
+        wrap_object.call(m, *args, block) {|use_cache| find_elem use_cache}
+      end
+    end
+
+    # Passes everything through to the underlying Watir object, first checking
+    # whether the method call is the name for another element on the same page,
+    # in which case the second element is re-evaluated with a different parent.
+    def method_missing(m, *args, &block)
+      if @page.class.elements.member? m
+        @page.send(m, *args, &block).with_parent self
+      else
+        wrap_watir_call(m, *args, &block)
+      end
     end
 
     # Used to log all pass through behaviours.  In debug mode,
@@ -221,7 +386,7 @@ module Gless
 
         @session.log.debug "WrapWatir: Calling #{m} with arguments #{args.inspect} on a #{elem.class.name} element identified by: #{trimmed_selectors.inspect}"
 
-        if elem.present? && elem.class.name == 'Watir::HTMLElement'
+        if (elem.respond_to? :present?) && elem.present? && elem.class.name == 'Watir::HTMLElement'
           @session.log.warn "FIXME: You have been lazy and said that something is of type 'element'; its actual type is  #{elem.to_subtype.class.name}; the element is identified by #{trimmed_selectors.inspect}"
         end
       end
@@ -264,7 +429,7 @@ module Gless
           wrapper_logging('click', nil)
           @session.log.debug "WrapWatir: click: Calling click on a #{elem.class.name} element identified by: #{trimmed_selectors.inspect}"
           if elem.exists?
-            elem.click
+            wrap_watir_call :click
           end
           if block_given?
             yield
@@ -277,7 +442,7 @@ module Gless
       else
         wrapper_logging('click', nil)
         @session.log.debug "WrapWatir: click: Calling click on a #{elem.class.name} element identified by: #{trimmed_selectors.inspect}"
-        elem.click
+        wrap_watir_call :click
       end
     end
 
@@ -309,21 +474,21 @@ module Gless
       if elem.class.name == 'Watir::TextField'
         set_text = args[0]
         @session.log.debug "WrapWatir: set: setting text on #{elem.inspect}/#{elem.html} to #{set_text}"
-        elem.set(set_text)
+        wrap_watir_call :set, set_text
 
         @num_retries.times do |x|
           @session.log.debug "WrapWatir: Checking that text entry worked"
-          if elem.value == set_text
+          if wrap_watir_call(:value) == set_text
             break
           else
             @session.log.debug "WrapWatir: It did not; sleeping for #{@wait_time} seconds"
             sleep @wait_time
             @session.log.debug "WrapWatir: Retrying."
             wrapper_logging('set', set_text)
-            elem.set(set_text)
+            wrap_watir_call :set, set_text
           end
         end
-        elem.value.to_s.should == set_text.to_s
+        wrap_watir_call(:value).to_s.should == set_text.to_s
         @session.log.debug "WrapWatir: The text entry worked"
 
         return self
@@ -331,27 +496,27 @@ module Gless
         # Double-check radio buttons
       elsif elem.class.name == 'Watir::Radio'
         wrapper_logging('set', [])
-        elem.set
+        wrap_watir_call :set
 
         @num_retries.times do |x|
           @session.log.debug "WrapWatir: Checking that the radio selection worked"
-          if elem.set? == true
+          if wrap_watir_call(:set?) == true
             break
           else
             @session.log.debug "WrapWatir: It did not; sleeping for #{@wait_time} seconds"
             sleep @wait_time
             @session.log.debug "WrapWatir: Retrying."
             wrapper_logging('set', [])
-            elem.set
+            wrap_watir_call :set
           end
         end
-        elem.set?.should be_true
+        wrap_watir_call(:set?).should be_true
         @session.log.debug "WrapWatir: The radio set worked"
 
         return self
 
       else
-        elem.set(*args)
+        wrap_watir_call(:set, *args)
       end
     end
   end

data/lib/gless.rb

@@ -6,10 +6,15 @@
 # project.
 module Gless
   # The current version number.
-  VERSION = '1.2.0'
+  VERSION = '1.3.1'
 
   # Sets up the config, logger and browser instances, the ordering
-  # of which is slightly tricky.
+  # of which is slightly tricky.  If a block is given, the config, after being
+  # initialized from the config file, is passed to the block, which should
+  # return the new, updated config.
+  #
+  # @yield [config] The config loaded from the development file.  The
+  #   optional block should return an updated config if given.
   #
   # @return [Gless::Logger, Gless::EnvConfig, Gless::Browser] logger, config, browser (in that order)
   def self.setup( tag )
@@ -17,6 +22,7 @@ module Gless
 
     # Create the config reading/storage object
     config = Gless::EnvConfig.new( )
+    config = yield config if block_given?
 
     # Get the whole backtrace, please.
     if config.get :global, :debug

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gless
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-10 00:00:00.000000000 Z
+date: 2013-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec