safariwatir 0.3.8 → 0.4.0

data/lib/safariwatir/element_attributes.rb

@@ -0,0 +1,15 @@
+module ElementAttributes
+  def html_method_reader(m_name, html_attribute = nil)
+    attr_to_reference = (html_attribute ? html_attribute : m_name.to_s)
+    define_method(m_name) do
+      html_method(attr_to_reference) ? html_method(attr_to_reference) : ""
+    end
+  end
+
+  def html_attr_reader(m_name, html_attribute = nil)
+    attr_to_reference = (html_attribute ? html_attribute : m_name.to_s)
+    define_method(m_name) do
+      attr(attr_to_reference) ? attr(attr_to_reference) : ""
+    end
+  end
+end

data/lib/safariwatir/locators.rb

@@ -0,0 +1,127 @@
+require File.dirname(__FILE__) + '/../watir/exceptions'
+
+module Locators
+  
+  def document_locator
+    parent.document_locator
+  end
+
+  def locator
+    self.send("locator_by_#{how.to_s}".to_sym)
+  end
+
+  def locator_by_text
+    locator_by_method("innerText")
+  end
+
+  def locator_by_value
+    locator_by_method("value")
+  end
+
+  def locator_by_src
+    locator_by_attribute("src")
+  end
+
+  def locator_by_alt
+    locator_by_attribute("alt")
+  end
+
+  def locator_by_src
+    locator_by_attribute("src")
+  end
+
+  def locator_by_href
+    locator_by_attribute("href")
+  end
+
+  def locator_by_url
+    locator_by_attribute("href")
+  end
+
+  def locator_by_title
+    locator_by_attribute("title")
+  end
+
+  def locator_by_method(m_name)
+    "findByMethodValue(#{parent.locator}, #{tag_names}, \"#{m_name}\", #{encode_what})[0]"
+  end
+
+  def locator_by_attribute(attribute_name)
+    "findByAttributeValue(#{parent.locator}, #{tag_names}, \"#{attribute_name}\", #{encode_what})[0]"
+  end
+
+  def locator_by_xpath
+    xpath = what.gsub(/"/, "\'")
+    "findByXPath(#{document_locator}, #{parent.locator}, \"#{xpath}\")"
+  end
+
+  def locator_by_name
+    locator_by_attribute("name")
+  end
+
+  def locator_by_index
+    "findByTagNames(#{parent.locator}, #{tag_names})[#{what.to_i - 1}]"
+  end
+
+  def locator_by_class
+    locator_by_attribute("class")
+  end
+
+  def locator_by_id
+    locator_by_method("id")
+  end
+
+  def tag_names
+      t_names = tag.kind_of?(Array) ? tag : [tag]
+      "[" + (t_names.map { |t_name| "\"#{t_name.upcase}\"" }.join(", ")) + "]"
+  end
+
+  def encode_what
+    what.kind_of?(Regexp) ? "new RegexValueMatcher(/#{what.source}/)" : "new ExactValueMatcher(\"#{what.to_s}\")"
+  end
+
+  def method_missing(*args)
+    if args[0].to_s =~ /locator_by_/
+      raise Watir::Exception::MissingWayOfFindingObjectException
+    end
+    super(*args)
+  end
+
+end
+
+module InputLocators
+  include Locators
+
+  def locator_by_method(m_name)
+    "findInputByMethodValue(#{parent.locator}, \"#{input_type}\", \"#{m_name}\", #{encode_what})[0]"
+  end
+
+  def locator_by_attribute(attribute_name)
+    "findInputByAttributeValue(#{parent.locator}, \"#{input_type}\", \"#{attribute_name}\", #{encode_what})[0]"
+  end
+
+  def locator_by_index
+    "findInputsByType(#{parent.locator}, \"#{input_type}\")[#{what.to_i - 1}]"
+  end
+
+end
+
+module ButtonLocators
+  include Locators
+
+  def locator_by_index
+    "findAllMatching(#{parent.locator}, new ButtonMatcher())[#{what.to_i - 1}]"
+  end
+
+  def locator_by_attribute(attribute_name)
+    "filterToAttributeValue(findAllMatching(#{parent.locator}, new ButtonMatcher()), \"#{attribute_name}\", #{encode_what})[0]"
+  end
+
+  def locator_by_method(attribute_name)
+    "filterToMethodValue(findAllMatching(#{parent.locator}, new ButtonMatcher()), \"#{attribute_name}\", #{encode_what})[0]"
+  end
+
+  def locator_by_value
+    locator_by_attribute("value")
+  end
+end

data/lib/safariwatir/scripter.rb

@@ -9,12 +9,144 @@ module Watir # :nodoc:
   TABLE_CELL_NOT_FOUND = "__safari_watir_cell_unfound__"
   EXTRA_ACTION_SUCCESS = "__safari_watir_extra_action__"
   
-  JS_LIBRARY = %|
-function dispatchOnChange(element) {
-  var event = document.createEvent('HTMLEvents');
+  JS_LIBRARY = <<JSCODE
+/* Library functions */
+
+var ButtonMatcher = function() {
+  this.match = function(ele) {
+    if (ele.tagName == "BUTTON") { 
+      return(true);
+    }
+
+    if (ele.tagName == 'INPUT') {
+      return(["submit", "button", "reset"].indexOf(ele.type) != -1);
+    }
+
+    return(false);
+  }
+}
+
+
+var ExactValueMatcher = function(exactVal) {
+  this.match = function (val) {
+    return(val == exactVal);
+  }
+}
+
+var RegexValueMatcher = function(regEx) {
+  this.match = function (val) {
+    return(regEx.test(val));
+  }
+}
+
+function dispatchOnChange(scope, element) {
+  var event = scope.createEvent('HTMLEvents');
   event.initEvent('change', true, true);  
   element.dispatchEvent(event);
-}|
+}
+
+function findByXPath(dscope, scope, expr) {
+  var result = dscope.evaluate(expr, scope, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+  return(result ? result.singleNodeValue : null );
+}
+
+function filterToMethodValue(found_tags, m_name, m_value) {
+  var result_array = [];
+
+  for (var i = 0; i < found_tags.length; i++) {
+    if (m_value.match(found_tags[i][m_name])) {
+      result_array.push(found_tags[i]);
+    }
+  }
+  return(result_array);
+}
+
+function filterToAttributeValue(found_tags, attr_name, attr_value) {
+  var result_array = [];
+
+  for (var i = 0; i < found_tags.length; i++) {
+    if (attr_value.match(found_tags[i].getAttribute(attr_name))) {
+      result_array.push(found_tags[i]);
+    }
+  }
+  return(result_array);
+}
+
+function filterToTagNames(found_tags, tags) {
+  var result_array = [];
+
+  for (var i = 0; i < found_tags.length; i++) {
+    if (found_tags[i].tagName != 'META' && tags.indexOf(found_tags[i].tagName) != -1) {
+      result_array.push(found_tags[i]);
+    }
+  }
+  return(result_array);
+}
+
+function findByClassName(scope, cname, tags) {
+  var found_tags = scope.getElementsByClassName(cname);
+  return( filterToTagNames(tags) );
+}
+
+function findInputByMethodValue(scope, input_type, attribute, value) {
+  var found_tags = findInputsByType(scope, input_type);
+  return( filterToMethodValue(found_tags, attribute, value) );
+}
+
+function findInputByAttributeValue(scope, input_type, attribute, value) {
+  var found_tags = findInputsByType(scope, input_type);
+  return( filterToAttributeValue(found_tags, attribute, value) );
+}
+
+function findByMethodValue(scope, names, attribute, value) {
+  var found_tags = findByTagNames(scope, names);
+  return( filterToMethodValue(found_tags, attribute, value) );
+}
+
+function findByAttributeValue(scope, names, attribute, value) {
+  var found_tags = findByTagNames(scope, names);
+  return( filterToAttributeValue(found_tags, attribute, value) );
+}
+
+function findAllMatching(scope, ele_matcher) {
+  var result_array = [];
+  var found_tags = scope.getElementsByTagName('*');
+
+  for (var i = 0; i < found_tags.length; i++) {
+    if (ele_matcher.match(found_tags[i])) {
+      result_array.push(found_tags[i]);
+    }
+  }
+  return(result_array);
+}
+
+function findInputsByType(scope, input_type) {
+  var result_array = [];
+  var found_tags = scope.getElementsByTagName("input");
+
+  for (var i = 0; i < found_tags.length; i++) {
+    if (found_tags[i].type == input_type) {
+      result_array.push(found_tags[i]);
+    }
+  }
+  return(result_array);
+}
+
+function findByTagNames(scope, names) {
+  var result_array = [];
+  var found_tags = null;
+
+  for (var i = 0; i < names.length; i++) {
+    found_tags = scope.getElementsByTagName(names[i]);
+    for (var j = 0; j < found_tags.length; j++) {
+      result_array.push(found_tags[j]);
+    }
+  }
+  return(result_array);
+}
+
+/* Action Code */
+JSCODE
 
   class JavaScripter # :nodoc:
     def operate(locator, operation)
@@ -64,19 +196,6 @@ if (element) {
     end
   end
 
-  class FrameJavaScripter < JavaScripter # :nodoc:
-    def initialize(frame)
-      @page_container = "parent.#{frame.name}"
-    end
-
-    def wrap(script)
-      # add in frame name when referencing parent or document
-      script.gsub! /\bparent\b/, "parent.#{@page_container}"
-      script.gsub! /\bdocument\b/, "#{@page_container}.document"
-      super(script)
-    end
-  end
-
   class TableJavaScripter < JavaScripter # :nodoc:
     def_init :cell
     
@@ -100,6 +219,7 @@ if (element) {
       @appname = opts[:appname] || "Safari"
       @app = Appscript.app(@appname)
       @document = @app.documents[1]
+      @typing_lag = 0.08
     end
               
     def ensure_window_ready
@@ -161,10 +281,14 @@ if (element == undefined) {
     def get_attribute(name, element = @element)
       execute(element.operate { %|return element.getAttribute('#{name}')| }, element)
     end
+
+    def get_method_value(name, element = @element)
+      execute(element.operate { %|return element.#{name}| }, element)
+    end
     
       
-    def document_text
-      execute(%|return document.getElementsByTagName('BODY').item(0).innerText;|)
+    def document_text(element)
+      execute(%|return #{element.locator}.getElementsByTagName('BODY').item(0).innerText;|)
     end
 
     def document_html
@@ -197,32 +321,32 @@ element.style.backgroundColor = 'yellow';|
     end
 
     def element_exists?(element = @element, &block)
-      block ||= Proc.new {}
-      execute(element.operate(&block), element)
-      return true
-    rescue UnknownObjectException
+      response = eval_js(element.operate do
+<<JSCODE
+if (element == undefined || element == null) {
+  return(false);
+}
+return(true);
+JSCODE
+end)
+    case response
+    when ELEMENT_NOT_FOUND
       return false
+    else
+      return response
+    end
     end
 
     def select_option(element = @element)
-      execute(element.operate do
-%|var selected = -1;
-var previous_selection = -2;
-for (var i = 0; i < element.options.length; i++) {
-  if (element.options[i].selected) {
-    previous_selection = i;
-  }
-  if (element.options[i].#{element.how} == '#{element.what}') {
-    element.options[i].selected = true;
-    selected = i;
+      execute(element.operate do %|
+  var other_options = element.parentNode.options;
+  for (var i = 0; i < other_options.length; i++) {
+    other_options[i].selected = undefined;
   }
-}
-if (selected == -1) {
-  return '#{ELEMENT_NOT_FOUND}';
-} else if (previous_selection != selected) {        
-  element.selectedIndex = selected;
-  dispatchOnChange(element.options[selected]);
-}
+  element.selected = "selected";
+  element.parentNode.selectedIndex = element.index;
+  dispatchOnChange(#{element.document_locator}, element);
+  dispatchOnChange(#{element.document_locator}, element.parentNode);
 |
       end, element)
     end
@@ -267,11 +391,32 @@ return selected;|
       sleep typing_lag
       execute(element.operate do 
 %|element.value += '#{value}';
-dispatchOnChange(element);
-element.setSelectionRange(element.value.length, element.value.length);| 
+dispatchOnChange(#{element.document_locator}, element);
+element.setSelectionRange(element.value.length, element.value.length);
+| 
       end, element)
     end
 
+    def set_file_field(element, value)
+      file_base_name = File.basename(value)
+      click_element(element)
+      sleep 0.4
+      se = Appscript.app("System Events")
+      open_popup = se.processes["Safari"].windows[1].sheets[1]
+      choose_button = open_popup.buttons[1]
+      search_field = open_popup.groups[1].text_fields[1]
+      search_by_file_name = open_popup.groups[1].splitter_groups[1].radio_groups[1].checkboxes[6]
+      sr_outline = open_popup.groups[1].splitter_groups[1].scroll_areas[2].outlines[1]
+      confirm_search_action = search_field.actions[2].get    
+      search_field.value.set(file_base_name)
+      search_field.perform(confirm_search_action)
+      sleep 2
+      search_by_file_name.click
+      sleep 1
+      sr_outline.rows[1].select
+      choose_button.click
+    end
+
     def click_element(element = @element)
       page_load do
 # Not sure if these events should be either/or. But if you have an image with an onclick, it fires twice without the else clause.
@@ -384,6 +529,11 @@ for (var i = 0; i < document.links.length; i++) {
     def element_disabled?(element = @element)      
       execute(element.operate { %|return element.disabled;| }, element)
     end
+
+    def operate_by_locator(element)
+      js.operate(%|var element = #{element.locator};
+|, yield)
+    end
   
     def operate_by_input_value(element)
       js.operate(%|
@@ -397,23 +547,6 @@ for (var i = 0; i < elements.length; i++) {
 }|, yield)
     end
 
-    def operate_by_name(element)
-      js.operate(%|
-var elements = document.getElementsByName('#{element.what}');
-var element = undefined;
-for (var i = 0; i < elements.length; i++) {
-  if (elements[i].tagName != 'META' && elements[i].tagName == '#{element.tag}') {
-    #{handle_form_element_name_match(element)}
-  }
-}|, yield)
-    end
-
-    def operate_by_class(element)
-      js.operate(%|
-var elements = document.getElementsByClassName('#{element.what}');
-var element = elements[0];|, yield)
-    end
-    
     # Checkboxes/Radios have the same name, different values    
     def handle_form_element_name_match(element)
       element_capture = %|element = elements[i];break;|
@@ -427,22 +560,6 @@ var element = elements[0];|, yield)
     end
     private :handle_form_element_name_match
 
-    def operate_by_id(element)
-      js.operate("var element = document.getElementById('#{element.what}');", yield)
-    end
-
-    def operate_by_index(element)
-      js.operate(%|var element = document.getElementsByTagName('#{element.tag}')[#{element.what-1}];|, yield)
-    end
-
-    def operate_by_src(element, &block)
-      operate_by(element, 'src', &block)
-    end
-
-    def operate_by_alt(element, &block)
-      operate_by(element, 'alt', &block)
-    end
-
     def operate_by_title(element, &block)
       operate_by(element, 'title', &block)
     end
@@ -455,14 +572,6 @@ var element = elements[0];|, yield)
       operate_by(element, 'innerText', &block)
     end
 
-    def operate_by_xpath(element)
-      xpath = element.what.gsub(/"/, "\'")
-      js.operate(%|
-var result = document.evaluate("#{xpath}", document.documentElement, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
-var element = result ? result.singleNodeValue : null;
-|, yield)
-    end
-
     def operate_by(element, attribute)
       js.operate(%|var elements = document.getElementsByTagName('#{element.tag}');
 var element = undefined;
@@ -507,15 +616,6 @@ end tell|, true)
       AppleScripter.new(TableJavaScripter.new(element))
     end
 
-    def for_frame(frame)
-      # verify the frame exists
-      execute(
-%|if (parent.#{frame.name} == undefined) {
-  return '#{FRAME_NOT_FOUND}';
-}|, frame)
-      AppleScripter.new(FrameJavaScripter.new(frame))
-    end
-
     def speak_value_of(element = @element)
       speak(get_value_for(element))
     end
@@ -547,13 +647,18 @@ SCRIPT`
 
     private
 
+    def tag_names(element = @element)
+      t_names = element.tag.kind_of?(Array) ? element.tag : [element.tag]
+      "[" + (t_names.map { |t_name| "\"#{t_name.downcase}\"" }.join(", ")) + "]"
+    end
+
     def execute(script, element = nil)
       response = eval_js(script)
       case response
         when NO_RESPONSE
           nil
         when ELEMENT_NOT_FOUND
-          raise UnknownObjectException, "Unable to locate #{element.element_name} element with #{element.how} of #{element.what}"
+          raise element_not_found_exception(element)
         when TABLE_CELL_NOT_FOUND
           raise UnknownCellException, "Unable to locate a table cell with #{element.how} of #{element.what}"
         when FRAME_NOT_FOUND
@@ -562,6 +667,13 @@ SCRIPT`
           response
       end
     end
+
+    def element_not_found_exception(element)
+      if element.is_frame?
+        return UnknownFrameException.new("Unable to locate a frame, using :#{element.how} and \"#{element.what}\"")
+      end
+      UnknownObjectException.new("Unable to locate #{element.element_name}, using :#{element.how} and \"#{element.what}\"")
+    end
     
     def execute_and_ignore(script)
       eval_js(script)