honey-do 0.5.0

data/js/user-extensions.js

@@ -0,0 +1,359 @@
+/*  reference to Selenium's browserbot window -- use this to access app window, else you'll get sel runner window*/
+  function aut_window(page) {return page.browserbot.getCurrentWindow();}
+  
+/*  document reference in our frame or window of interest */
+  function aut_document(page) {return aut_window(page).document;}
+  
+/*   Form_ class  */
+  // Form_ class constructor: provides reference to aut document and either a specified form or the first one by default
+  // form can be identified by name or index
+  // if using name, caller responsible for wrapping in single quotes: e.g. Form_(this, "'searchForm'")
+  function Form_(page, form_name_or_index) {
+      form_identifier = form_name_or_index || 0;  // default to first in collection
+      this.doc = aut_document(page);
+      this.form = this.doc.forms[form_identifier];
+  }
+  
+  Form_.FIELD_DELIMITER = '|'
+  Form_.PAIR_DELIMITER = ':::'
+  
+  Form_.prototype.set_values = function(big_string, ok_if_not_found){
+      var pairs = big_string.split(Form_.FIELD_DELIMITER),  pair = [], error_values = '';
+      
+      for(var i = 0; i < pairs.length; i++){
+          pair = pairs[i].split(Form_.PAIR_DELIMITER);
+          error_values += this.set_value(pair[0], pair[1], ok_if_not_found);
+      }
+      return error_values;       
+  }
+  
+  Form_.prototype.set_value = function(name, value, ok_if_not_found){
+      var error_text = '', e = null;
+      var selectable   = /(select-one|select-multiple)/i;
+      var settable     = /(text|textarea|password)/i;
+      var clickable    = /(button|submit|reset|radio|image)/i;
+      try {
+          // if you wanted to do something to explicitly wait for Ajax, you would do it here, before the element lookup
+          e = this.form.elements[name];
+  
+          // complain if not found
+          if (e == null && ok_if_not_found == null) throw new Error("Form_.set_value: element '" + name + "' not found");
+  
+          if (ok_if_not_found && e == null) return;
+          
+          // query type to infer action
+          if (e.type == undefined)        Form_.grouped_item(e, value).click();
+          if (settable.test(e.type))      e.value = value;
+          if (selectable.test(e.type))    Form_.select_option(e, value);
+          if ((/checkbox/i).test(e.type)) Form_.set_checkbox(e, value);
+          if (clickable.test(e.type))     e.click();
+  
+          // fire any event handlers synthetically.
+          if (this.doc.createEventObject) Form_.fire_ie_event_handlers(e, this.doc.createEventObject());
+          if (this.doc.createEvent)       Form_.fire_ff_event_handlers(e, this.doc);
+      }
+      catch(ex) { error_text = name + Form_.PAIR_DELIMITER + value + Form_.FIELD_DELIMITER + ex.message + '\n';}
+      finally {return error_text;}
+  }
+  
+  Form_.fire_event_handlers = function(e, obj, method){
+      var handlers = ['onclick', 'onchange', 'onblur'];
+  
+      for (var h = 0; h < handlers.length; h++)
+          if (e[handlers[h]]) {method(e, obj, handlers[h]);}
+  }
+  
+  Form_.fire_ie_event_handlers = function(e, event_obj){
+      Form_.fire_event_handlers(e, event_obj, function(e, event_obj, handler) { e.fireEvent(handler, event_obj)})
+  }
+  
+  Form_.fire_ff_event_handlers = function(e, doc){
+      Form_.fire_event_handlers(e, doc, function(e, doc, handler) {Form_.fire_ff_event(e, doc, handler)})
+  }
+  
+  Form_.fire_ff_event = function(element, doc, handler) {
+      event = doc.createEvent("Events");// DOM initEvent requires a new object each time
+      event.initEvent(handler.replace(/on/,'').toLowerCase(), true, false);
+      element.dispatchEvent(event);
+  }
+  
+  // find particular radio button or checkbox from group sharing common 'name' attribute
+  Form_.grouped_item = function(e, unique_value) {
+      var checkable = /(radio|checkbox)/i;
+  
+      if (e.length == undefined) throw new Error("Form_.grouped_item: element type and length properties undefined");
+      for (var i = 0; i < e.length; i++)
+          if (checkable.test(e[i].type)) {
+              if (i == unique_value || e[i].value == unique_value) return e[i];
+          }
+  }
+  
+  Form_.select_option = function(e, value) {
+      var i = Form_.option_index(e, value);
+      e.options[i].selected = true;
+  }
+  
+  Form_.option_index = function(e, in_value){
+      if (isNaN(parseInt(in_value))) {
+          return Form_.index_of_text(e, in_value);
+      }
+      return in_value;    // Todo: 'range' error if index too high
+  }
+  
+  Form_.set_checkbox = function(e, in_value){
+      var check = /^(true|check|on)$/i;
+      var uncheck = /^(false|uncheck|off)$/i;
+  
+      if (check.test(in_value)) {e.checked = true; return;}
+      if (uncheck.test(in_value)) {e.checked = null; return;}
+      e.click();
+  }
+  
+  Form_.index_of_text = function(e, text_value) {
+       var i;
+       switch(text_value) {
+           case 'random':  
+              i = Math.round(Math.random() * Form_.index_of_last(e));
+              break;
+           case 'last':
+              i = Form_.index_of_last(e);
+              break;
+           default:  // search for visible text
+              i = Form_.index_of_match(e, text_value);
+      }
+      if (i == null) throw new Error("Form_.index_of_text '" + text_value + "' not found");
+      return i;
+  }
+  
+  // last item in list
+  Form_.index_of_last = function(e) { return e.options.length - 1; }
+  
+  Form_.index_of_match = function(e, text_value) {
+      for ( var i = 0; i < e.options.length; i++)  {
+          if (Form_.match_to_beginning(e.options[i].text, text_value)) return i;
+          if (Form_.match_to_beginning(e.options[i].value, text_value)) return i;
+      }
+  }
+  
+  Form_.match_to_beginning = function(within_string, sought_text_value) {
+      return (within_string.search(new RegExp('^' + sought_text_value.custom_escape_special(),'i')) > -1);
+  }
+  
+  Form_.prototype.droplist_size = function(element_name) {return Form_.index_of_last( this.form.elements[element_name] )}
+  
+  Form_.prototype.visible_elements = function() {
+      var element_list = [];
+      var e = this.form.elements;
+      for(var i = 0; i < e.length; i++){
+          if (e[i].type != 'hidden') {
+              if (e[i].name)
+                 element_list.push(e[i].name);
+              else
+                 element_list.push(e[i].value);
+          }
+      }
+      return element_list;
+  }
+  
+  Form_.prototype.enabled_elements = function() {
+      var element_list = [];
+      var e = this.form.elements;
+      for(var i = 0; i < e.length; i++){
+          if (!e[i].disabled && e[i].type != 'hidden') {
+              if (e[i].name)
+                 element_list.push(e[i].name);
+              else
+                 element_list.push(e[i].value);
+          }
+      }
+      return element_list;
+  }
+  
+  Form_.prototype.element_indexes = function() {
+      var element_list = [];
+      var e = this.form.elements;
+      for(var i = 0; i < e.length; i++){
+          element_list.push(e[i].name + '|' + i);
+      }
+      return element_list;
+  }
+  
+  // returns double delimited list of name-value pairs, but only for elements having values
+  Form_.prototype.values = function() {
+      var opt_index, element_name, element_text;
+      var values = '';
+      var target_types = /(text|select|radio|checkbox|password|file)/i;
+      var checkable = /(radio|checkbox)/i;
+      
+      var e = this.form.elements;
+  
+      for(var i = 0;i < e.length; i++){
+         if (target_types.test(e[i].type)) {
+             element_name = e[i].name;
+             element_text = e[i].value.custom_trim();
+             if ('selectedIndex' in e[i] && e[i].selectedIndex > -1) {
+                 if (e[i].type == 'select-multiple') {
+                     values += Form_.multiple_selections(element_name, e[i].options);
+                     continue;
+                 }
+                 opt_index = e[i].selectedIndex;
+                 element_text = e[i].options[opt_index].text.custom_trim();
+             }
+             if (checkable.test(e[i].type) && 'checked' in e[i]) {
+                 if (!e[i].checked) element_text = '';
+             }
+             if (element_text) values += element_name + '=>' + element_text + Form_.FIELD_DELIMITER;
+         }
+      }
+      return values;
+  }
+  
+  Form_.multiple_selections = function(element_name, option_collection) {
+      var values = '';
+      for(var i = 0; i < option_collection.length; i++) {
+         if (option_collection[i].selected)
+             values += element_name + '=>' + option_collection[i].text.custom_trim() + Form_.FIELD_DELIMITER;
+      }
+      return values;
+  }
+  
+  Form_.prototype.all_checked = function() {
+      var element_list = [];
+      var e = this.form.elements;
+      for(var i = 0; i < e.length; i++) {
+          if (e[i].type == 'checkbox' && e[i].checked) element_list.push(e[i].name);
+      }
+      return element_list;
+  }
+  
+  Form_.prototype.type_count = function(element_type) {
+      var e = this.form.elements;
+      var count = 0;
+      for(var i = 0; i < e.length; i++)   {
+         if (e[i].type.toLowerCase() == element_type) count++;
+      }
+      return count;
+  }
+  
+  Form_.prototype.all_button_names = function() {
+      var a = [];
+      var buttons = this.buttons();
+      for(var i = 0; i < buttons.length; i++){
+          if (buttons[i].name)
+              a.push(buttons[i].name);
+          else
+              a.push(buttons[i].value);
+      }
+      return a;
+  }
+  
+  // collection of button objects, NOT names
+  Form_.prototype.buttons = function()  {
+      var a = [];
+      var button_types = /(button|submit|reset)/i;
+      var e = this.form.elements;
+      for(var i = 0; i < e.length; i++){ if (button_types.test(e[i].type)) a.push(e[i]); }
+      return a;
+  }
+  
+  Form_.prototype.first_checkbox = function(name_pattern) {
+      var e = this.form.elements;
+      for(var i = 0;i < e.length; i++)
+          if (e[i].type.toLowerCase() == 'checkbox' && name_pattern.test(e[i].name))
+              return e[i].name;
+  }
+  
+  Form_.prototype.checkbox_names = function() {
+      var a = [];
+      var e = this.form.elements;
+      for(var i = 0;i < e.length; i++){
+          if (e[i].type.toLowerCase() == 'checkbox') a.push(e[i].name);
+      }
+      return a;
+  }
+  
+  Form_.prototype.clear_checkboxes = function() {
+      var e = this.form.elements;
+      for(var i = 0;i < e.length; i++)
+          if (e[i].type.toLowerCase() == 'checkbox') e[i].checked = null;
+  }
+  
+  Form_.prototype.set_checkboxes = function() {
+      var e = this.form.elements;
+      for(var i = 0;i < e.length; i++)
+          if (e[i].type.toLowerCase() == 'checkbox') e[i].checked = true;
+  }
+  
+/*    Table_ Class        */
+  // Table_ class constructor: provides reference to aut document and a specified table
+  // table can be identified by name or index
+  // if using name, caller responsible for wrapping in single quotes: e.g. Table_(this, "'tblDocsGenerated'")
+  function Table_(page, table_id_or_index) {
+      this.table = aut_document(page).getElementsByTagName('table')[table_id_or_index];
+  }
+  
+  // 'TD's or cells for all rows
+  Table_.prototype.cells = function() { return this.table.getElementsByTagName('td') }
+  
+  Table_.prototype.size = function(){ return this.table.rows.length;}
+  
+  
+  Table_.text_from_cell_collection = function(cells){
+      var cell_text, values = '';
+      for(var i = 0; i < cells.length; i++){
+          cell_text = text(cells[i]).custom_trim();
+          if (cell_text) values += cell_text + '|';
+      }
+      return values;
+  }
+  
+  Table_.prototype.all_cell_ids_and_text = function(){
+      var values = '';
+      var cell_text;
+      var cells = this.cells();
+  
+      for(var i = 0; i < cells.length; i++){
+          if (cells[i].id) {
+              cell_text = text(cells[i]).custom_trim();
+              if (cell_text) values += cells[i].id + '=>' + cell_text + '|';
+          }
+      }
+      return values;
+  }
+  
+  Table_.prototype.all_cell_text = function(){
+      return Table_.text_from_cell_collection(this.cells());
+  }
+  
+/*   Extensions of built-in String Class    */
+  String.prototype.custom_trim = function() { return this.replace(/^\s\s*/,'').replace(/\s\s*$/, '').replace(/^\xa0+$/, ''); }
+  
+  String.prototype.custom_escape_special = function()  {
+      var special_characters = /([.*+?^${}()|[\]\/\\])/g;
+      return this.replace(special_characters, '\\$1');
+  }
+  
+/*   Stand-alone Functions    */
+  function all_form_names(page)  {
+      var names = [];
+      var forms_collection = aut_document(page).forms;
+  
+      for (var f = 0; f < forms_collection.length; f++)  {
+          if (forms_collection[f].name)
+              names.push(forms_collection[f].name);
+          else
+              names.push(f);
+  
+      }
+      return names;
+  }
+  
+  // IE or W3C
+  function text(obj) {
+    var text_value = obj.innerText || obj.textContent;
+    // windows IE: some cases the above '||' returns 'undefined'; explicit assignment without '||' works for some reason
+    if (text_value == undefined) {text_value = obj.innerText;}
+    
+    return text_value;
+  }
+  

data/lib/hash.rb

@@ -0,0 +1,28 @@
+class Hash  
+  # used by HoneyDo methods
+  def keys_to_sym
+    sym_key_hash = Hash.new()
+    self.each { |k, v|  sym_key_hash[k.to_sym] = v}
+    return sym_key_hash
+  end
+
+  # if a value is non-scalar, i.e. not a single value but a list of delimited ones, put each into its own pair
+  def split_compound_values(delimiter = "|")
+    new_pairs = Hash.new()
+    self.each do |key, value|
+      if value.include?(delimiter)
+        value_array = value.split(delimiter)
+        value_array.each_index do |i|
+          unless new_pairs.has_key?(key)
+            new_pairs[key] = value_array[i]  # first value goes in pair with original key name
+          else
+            new_pairs[(key.to_s + "_" + i.to_s).to_sym] = value_array[i] # add index, starting with 1, to new key names for remaining values
+          end
+        end
+      end
+    end
+    #merge in new pairs, which replaces any that had a compound value with a pair having the original key and the first value only
+    return self.merge(new_pairs)
+  end
+
+end

data/lib/honey_do.rb

@@ -0,0 +1,257 @@
+# HoneyDo
+# Selenium#SeleniumDriver
+require 'hash'
+require 'symbol'
+require 'selenium'
+
+# =Just give it a list!  
+# ==== set_form_values provides a simple, consistent interface to any collection of HTML form elements.
+# * Set one or many values and click one or many controls with one call
+# * No element type or "action" command is ever needed
+# * List can be a Ruby string, array, hash, or symbol
+# * Freely mix name/value pairs with just names, at your convenience
+# * Event handlers are fired normally, and Ajax calls just seem to work
+#
+# ==== get_form_values and other methods provide simple, consistent means of reading all form data at once
+#
+# ==== user-extensions.js[link:\files\js\user-extensions_js.html] 
+# * class <tt>Form_</tt> enables passing collections to and from HTML forms.
+# * class <tt>Table_</tt> provides a couple of HTML table readers, which return collections of cell values.  Non-form HTML is not at all generic so this isn't fleshed out for the release version.  It's included mostly for demo purposes.
+module HoneyDo
+
+  # ==_input_list_
+  # * <b>meant to be flexible and tolerant</b> so you can code your data in whatever way is handy to the situation
+  # * any mix of HTML form element <tt>name</tt>s and pairs of element <tt>name</tt>s and values.
+  # * can be a single string, single symbol, single integer, hash map, or array consisting of any number of strings, symbols, or 2 element arrays
+  #
+  # ====HTML +form+ element identifiers
+  # <b><tt>name</tt> attribute</b>:: YES
+  # <b><tt>form.elements</tt> index</b>:: YES
+  # <b><tt>id</tt> attribute</b>:: NO
+  # <b><tt>value</tt> attribute</b>:: NO
+  #
+  # <b>element names (or indexes) without values get <i>clicked </i></b> if they are
+  # clickable:: <tt>button, submit, reset, radio, checkbox</tt>
+  #       sel.set_form_values(:clearButton)
+  #
+  #       sel.set_form_values([:includeDocuments_cb, :requireSig_cb])
+  #
+  #       sel.set_form_values("resetButton")
+  #
+  #       sel.set_form_values(0)
+  #
+  # <b>element names (or indexes) with values get <i>set</i></b> if they are 
+  # 1. settable: <tt>text, textarea, password</tt>
+  # 1. selectable: <tt>select-one, select-mulitple</tt>
+  # 1. a grouped item with a value: <tt>checkbox, radio</tt>
+  #       sel.set_form_values(:city => "Appleton")
+  #
+  #       sel.set_form_values(:dealerid => "Foster-Stevens", :includeDocuments_cb => :check)
+  #
+  #       sel.set_form_values(:state => "IL", :street_1 => "113 Foo St.", :city => "Sandwich", :zip => 60548, :same_as_shipping => true)
+  #
+  #       sel.set_form_values(:color => 8,
+  #                       :hobbies => "hacking",
+  #                       :username => "ernie",  
+  #                       :password => "bert",  
+  #                       :further_description => "Test Input String blah " * 50,
+  #                       :extras => 1,
+  #                       :browser => "safari")
+  #
+  #
+  # <b>values for _clickable_ elements are ignored</b>.  They are useless but harmless.
+  #       sel.set_form_values(:clearButton => "Clear")  
+  #
+  #       sel.set_form_values(3 => "Clear")  
+  # <tt>"Clear"</tt> is the element's +value+ attribute (or visible text) and is ignored in both cases. 
+  # <tt>:clearButton</tt> is the +name+ attribute and is used; 
+  # <tt>3</tt> is the element's index (within <tt>form.elements</tt>) and would also be used.
+  #
+  # <b>input as array guarantees input order</b> and allows us to mix in _clickables_ without dummy values
+  #       sel.set_form_values([[:search_customer_name, "Foster"], [:search_customer_city, "Wentworth"], :submitSearchForm])
+  #
+  # ==_processing_params_
+  # <b>These aren't usually necessary</b>.
+  # <tt>:form_name_or_index</tt>:: Defaults to 0, because there is usually just one form per page.  +String+ or +Integer+
+  # <tt>:ok_if_not_found</tt>:: +true+ to swallow the error, +nil+/+false+/+null+ if not present (the default).  Useful for testing multiple versions of your app when names have changed, or widgets have been added or removed.
+  # <tt>:one_field_at_a_time</tt>:: +true+ to use mulitple-call mode.  Makes Ruby loop on the list, instead JavaScript, forcing a separate <tt>get_eval</tt> call for each item.  Effectively slows it down as a means of handling _Ajax_ refreshes in _Firefox_.
+  # <tt>:retry_max</tt>:: 0 or 1 to *_not_* retry at all.  Anything > 2 (the default, which means 1 try and 1 retry) is probably useless, but I don't know your app.   +Integer+ 
+  # <tt>:retry_interval</tt>:: To change the default wait time (0.75 seconds) between retries.  +Float+ 
+  #
+  # <b>Make sure your +input_list+ items and +processing_params+ are in separate data structures in the arg list</b>
+  #       sel.set_form_values(:search_customer_name => "Foster", :form_name_or_index => "form_2")  # WRONG!  that's a 2-item input list
+  #
+  #       sel.set_form_values({:search_customer_name => "Foster"}, :form_name_or_index => "form_2")  # RIGHT!  Ruby will make the 2nd hash for you
+  def set_form_values(input_list, processing_params = {})
+    which_form     = processing_params[:form_name_or_index] ? processing_params[:form_name_or_index] : 0
+    retry_max      = processing_params[:retry_max] ? processing_params[:retry_max] : 2
+    retry_interval = processing_params[:retry_interval] ? processing_params[:retry_interval] : 0.75
+
+    js_open  = "dom=new Form_( this, '#{which_form}' )." 
+    js_close = ", '#{processing_params[:ok_if_not_found]}' )"
+    errors   = ""
+  
+    # when input is a single symbol or int
+    input_list = input_list.to_s if [Symbol, Fixnum].include?(input_list.class)
+    
+    re_try(retry_max, retry_interval) do 
+      if processing_params[:one_field_at_a_time]
+        # we can be a hash, array, or string here: 'each' with a single |arg| treats us as an array.
+        input_list.each { |pair| errors << get_eval(js_open + "set_value( #{pair_to_args(pair)}" + js_close) }
+      else
+        errors = get_eval(js_open + "set_values( '#{list_to_big_string(input_list)}'" + js_close)
+      end
+      raise_js_errors(errors)
+    end
+  end
+
+  # hash map of element names to values, but only for those elements that have values.
+  def get_form_values(form_name_or_index=0)
+    js = "dom=new Form_(this, '#{form_name_or_index}').values()"
+    to_hash(get_eval(js)).keys_to_sym
+  end
+  
+  # gets comma separated list of non-hidden form element names
+  def get_form_elements(form_name_or_index=0)
+    get_eval("dom=new Form_(this, '#{form_name_or_index}').visible_elements()")
+  end
+  
+  # table (nested array) of element names and indices.  0 based because the DOM is.
+  def get_form_element_indexes(form_name_or_index=0)
+    element_index_table = []
+    element_indexes = get_eval("dom=new Form_(this, '#{form_name_or_index}').element_indexes()").split(',')
+    element_indexes.each {|item| element_index_table << item.split(FIELD_DELIMITER)}
+    return element_index_table
+  end
+  
+  # gets comma separated list of non-hidden, non-disabled form element names
+  def get_enabled_form_elements(form_name_or_index=0)
+    get_eval("dom=new Form_(this, '#{form_name_or_index}').enabled_elements()")
+  end
+  
+  def get_all_button_names(form_name_or_index=0)
+    get_eval("dom=new Form_(this, '#{form_name_or_index}').all_button_names()")
+  end
+  
+  # given a javascript friendly regex, returns the first matching name
+  def get_checkbox_name_by_pattern(form_name, name_pattern)
+    get_eval("dom=new Form_(this, '#{form_name}').first_checkbox(#{name_pattern})").to_sym
+  end
+  
+  def get_all_checkbox_names(form_name_or_index = 0)
+    get_eval("dom=new Form_(this, '#{form_name_or_index}').checkbox_names()")
+  end
+  
+  def get_droplist_size(element_name, form_name_or_index = 0)
+     get_eval("dom=new Form_(this, '#{form_name_or_index}').droplist_size('#{element_name}')").to_i
+  end
+  
+  def get_all_checked(form_name_or_index = 0)
+    get_eval("dom=new Form_(this, '#{form_name_or_index}').all_checked()").split(',')
+  end
+  
+  def clear_checkboxes(form_name_or_index = 0)
+    get_eval("dom=new Form_(this, '#{form_name_or_index}').clear_checkboxes()")
+  end
+  
+  def set_all_checkboxes(form_name_or_index = 0)
+    clear_checkboxes
+    get_eval("dom=new Form_(this, '#{form_name_or_index}').set_checkboxes()")
+  end
+  
+  # HTML element count of checkboxes
+  def checkbox_count(form_name_or_index = 0)
+    get_eval("dom=new Form_(this, '#{form_name_or_index}').type_count('checkbox')").to_i
+  end
+
+  # comma delimited list of form names.  could include index value if no name attribute on the form
+  def get_all_form_names
+    get_eval("dom=all_form_names(this)")
+  end
+
+  # table reader - hash of <td> id's and text for cells that have text
+  def get_cell_ids_and_text(table_id_or_index=0)
+    js = "dom=new Table_(this, '#{table_id_or_index}').all_cell_ids_and_text()"
+    to_hash(get_eval(js)).keys_to_sym
+  end
+
+  # table reader - returns comma delimited string of all <td> text
+  def get_all_cell_text(table_id_or_index)
+    js = "dom=new Table_(this, '#{table_id_or_index}').all_cell_text()"
+    get_eval(js)
+  end
+
+  # HTML table row count
+  def get_table_size(table_id_or_index)
+    get_eval("dom=new Table_(this, '#{table_id_or_index}').size()").to_i
+  end
+
+  protected
+  
+  FIELD_DELIMITER = "|"
+  PAIR_DELIMITER = ":::"
+
+  # convert string from Form_.values
+  def to_hash(fields_string, delimiter = FIELD_DELIMITER)
+    fields_hash = {}
+    fields_string.split(delimiter).each do |field_name|
+      key_field_name, value_text = field_name.split('=>')
+      
+      if fields_hash[key_field_name] # group items (checkboxes, radio buttons); duplicate 'id's 
+        fields_hash[key_field_name] += delimiter + value_text
+      else
+        fields_hash[key_field_name] = value_text
+      end
+      
+    end
+    return fields_hash
+  end
+  
+  private
+  
+  # try again if input chokes
+  def re_try(max_tries, interval) # :doc:
+    tries = 0
+    begin
+      tries += 1
+      yield
+    rescue SeleniumCommandError, RuntimeError => ex
+      sleep interval
+      retry if tries < max_tries
+      raise "#{ex.message}:  tries = #{tries}"
+    rescue Exception => ex
+      raise "Exception: #{ex.message}"
+    end
+  end
+
+  # prepares input list for Form_.prototype.set_values(), which sets all fields with one call
+  def list_to_big_string(input_list)
+    array_of_strings = input_list.collect {|i| i.respond_to?(:join) ? i.join(PAIR_DELIMITER) : i }
+    
+    return array_of_strings.join(FIELD_DELIMITER) if array_of_strings.respond_to?(:join)
+    return array_of_strings
+  end
+  
+  # when Ruby loops on the input list, ensure the name and possible value is in 2 arguments
+  def pair_to_args(input_pair)
+    return "'#{input_pair[0]}', '#{input_pair[1]}'" if input_pair.instance_of?(Array)
+    return "'#{input_pair}', ''"
+  end
+  
+  # handle errors from Form_.prototype.set_values() or Form_.prototype.set_value()
+  def raise_js_errors(error_string) # :doc:
+    unless error_string.empty?
+      errors = error_string.split("\n")
+      formatted_errors = errors.collect{|error_text| "\njavascript error:\n" + error_text.gsub(PAIR_DELIMITER, "=")}
+      raise RuntimeError.new(formatted_errors)
+    end
+  end
+
+end
+
+# Mix HoneyDo methods in so they can be called on SeleniumDriver object
+#
+# Note that within HoneyDo scope, +get_eval+ calls work because of this mixin
+class Selenium::SeleniumDriver
+  include HoneyDo
+end

data/lib/symbol.rb

@@ -0,0 +1,6 @@
+# to sort arrays or hashes with Symbol items or keys
+class Symbol
+  def <=>(other)
+    self.to_s <=> other.to_s
+  end
+end