watir 3.0.0.rc2 → 3.0.0.rc3

data/CHANGES

@@ -1,3 +1,22 @@
+== 3.0.0.rc3 - 2012/03/18
+
+* all html elements are now supported (even html5 ones)
+* CookieManager removed
+* cookies API support added (https://github.com/watir/watirspec/blob/master/cookies_spec.rb)
+* drag and drop API support added (https://github.com/watir/watirspec/blob/master/drag_and_drop_spec.rb)
+* Element#(before|after)? removed
+* Element#(before|after)_text removed
+* Browser#cell(s) and Browser#row(s) removed
+* Browser#Element camelCase methods removed, use under_score methods instead
+* Browser#element(s) supports only general attributes like :id, :title, :class_name, :text, :html and such
+* Browser#modal_dialog improved
+* Browser#send_keys and Element#send_keys have now same syntax as specified in WatirSpec
+* Element#style returns internal styles only for IE9, inline style will be returned for IE8
+* Table#each removed - use Table#(trs|rows).each instead
+* Table#row(s) and Table#cell(s) added which ignore inner tables - use #td/#tr for all.
+* raise an Exception if more locators are specified with :xpath/:css
+* searching by :xpath and :css code rewritten
+
 == 3.0.0.rc2 - 2012/02/04
 
 * Browser#textarea(s) method for searching <textarea> elements

data/VERSION

@@ -1 +1 @@
-3.0.0.rc2
+3.0.0.rc3

data/lib/watir/close_all.rb

@@ -23,9 +23,9 @@ module Watir
     # to appear and does not raise exception if no window is found.
     # returns true if modal was found and close, otherwise false
     def close_modal
-      while self.modal_dialog.exists?(0) do
+      while self.modal_dialog.exists? do
         self.modal_dialog.close
       end
     end
   end
-end
+end

data/lib/watir/container.rb

@@ -57,6 +57,10 @@ module Watir
         
     public
 
+    def modal_dialog
+      ModalDialog.new(self)
+    end
+
     # Searching for Page Elements
     # Not for external consumption
     #
@@ -98,10 +102,8 @@ module Watir
     # Not for external use, but cannot set to private due to usages in Element
     # classes.
 
-    def locator_for(locator_class, tags, how, what, klass)
-      locator = locator_class.new self, tags, klass
-      locator.set_specifier how, what
-      locator
+    def locator_for(locator_class, specifiers, klass)
+      locator_class.new self, specifiers, klass
     end
     
   end # module

data/lib/watir/cookies.rb

@@ -0,0 +1,80 @@
+require "uri"
+
+module Watir
+  class Cookies
+    include Enumerable
+
+    def initialize(page_container)
+      @page_container = page_container
+    end
+
+    def each
+      @page_container.document.cookie.split(";").each do |cookie|
+        name, value = cookie.strip.split("=")
+        yield({:name => name, :value => value})
+      end
+    end
+
+    def add name, value, options={}
+      options = options.map do |option|
+        k, v = option
+        if k == :expires
+          "#{k}=#{v.gmtime.strftime("%a, %d %b %Y %H:%M:%S UTC")}"
+        elsif k == :secure
+          "secure" if v
+        else
+          "#{k}=#{v}"
+        end
+      end.compact.join("; ")
+
+      options = "; #{options}" unless options.empty?
+      @page_container.document.cookie = "#{name}=#{value}#{options}" 
+    end
+
+    def delete name
+      options = {:expires => ::Time.now - 60 * 60 * 24}
+      delete_with_options name, options
+
+      # make sure that the cookie gets deleted
+      # there's got to be some easier way to do this
+      uri = URI.parse(@page_container.url)
+      domain = uri.host
+
+      paths = uri.path.split("/").reduce([]) do |paths, path|
+        paths << "#{paths.last}/#{path}".squeeze("/")
+      end << "/"
+
+      subdomains = domain.split(".").reverse.reduce([]) do |subdomains, part|
+        subdomain = "#{part}#{subdomains.last}"
+        subdomain = "." + subdomain unless subdomain == domain
+        subdomains << subdomain
+      end
+
+      subdomains.each do |subdomain|
+        domain_options = options.merge :domain => subdomain
+        delete_with_options name, domain_options
+        delete_with_options name, domain_options.merge(:secure => true)
+
+        paths.each do |path|
+          path_options = options.merge :path => path
+          delete_with_options name, path_options 
+          delete_with_options name, path_options.merge(:secure => true)
+
+          path_domain_options = domain_options.merge :path => path
+          delete_with_options name, path_domain_options 
+          delete_with_options name, path_domain_options.merge(:secure => true)
+        end
+      end
+    end
+
+    def clear
+      each {|cookie| delete cookie[:name]}
+    end
+
+    def delete_with_options name, options={}
+      add name, nil, options
+    end
+
+    private :delete_with_options
+  end
+end

data/lib/watir/core.rb

@@ -14,20 +14,22 @@ require 'watir/element_extensions'
 require 'logger'
 require 'watir/logger'
 require 'watir/container'
+require 'watir/xpath_locator'
 require 'watir/locator'
 require 'watir/page-container'
 require 'watir/ie-class'
+require 'watir/drag_and_drop_helper'
 require 'watir/element'
-require 'watir/element_collections'
+require 'watir/element_collection'
 require 'watir/form'
 require 'watir/frame'
-require 'watir/non_control_elements'
 require 'watir/input_elements'
+require 'watir/non_control_elements'
 require 'watir/table'
 require 'watir/image'
 require 'watir/link'
-require 'watir/html_element'
 require 'watir/window'
+require 'watir/cookies'
 
 require 'watir/win32'
 require 'watir/modal_dialog'
@@ -37,3 +39,5 @@ require 'watir/module'
 require 'rautomation'
 require 'watir/dialogs/file_field'
 require 'watir/dialogs/javascript'
+
+require 'watir/supported_elements'

data/lib/watir/dialogs/file_field.rb

@@ -1,9 +1,5 @@
 module Watir
   class FileField < InputElement
-    #:stopdoc:
-    INPUT_TYPES = ["file"]
-    #:startdoc:
-
     def set(file_path)
       assert_file_exists(file_path)
       assert_exists

data/lib/watir/drag_and_drop_helper.rb

@@ -0,0 +1,68 @@
+module Watir
+  module DragAndDropHelper
+
+    def drag_and_drop_on(target)
+      perform_action do
+        assert_target target
+        drop_x, drop_y = target.send :source_x_y
+        drag_to drop_x, drop_y
+      end
+    end
+
+    def drag_and_drop_by(distance_x, distance_y)
+      perform_action do
+        drag_x, drag_y = source_x_y
+        drag_to drag_x + distance_x, drag_y + distance_y
+      end
+    end
+
+    private
+
+    def drag_to(drop_x, drop_y)
+      drag_x, drag_y = source_x_y
+      mouse = page_container.rautomation.mouse
+      mouse.move :x => drag_x , :y => drag_y
+      mouse.press
+      mouse.move :x => drop_x, :y => drop_y
+      mouse.release
+    end
+
+    def source_x_y
+      center_x_y_absolute left_edge_absolute, top_edge_absolute
+    end
+
+    def assert_target(target)
+      target.assert_exists
+      target.assert_enabled
+    end
+
+    def top_edge
+      ole_object.getBoundingClientRect.top.to_i
+    end
+
+    def top_edge_absolute
+      top_edge + page_container.document.parentWindow.screenTop.to_i
+    end
+
+    def left_edge
+      ole_object.getBoundingClientRect.left.to_i
+    end
+
+    def left_edge_absolute
+      left_edge + page_container.document.parentWindow.screenLeft.to_i
+    end
+
+    def right_edge
+      ole_object.getBoundingClientRect.right.to_i
+    end
+
+    def bottom_edge
+      ole_object.getBoundingClientRect.bottom.to_i
+    end
+
+    def center_x_y_absolute x, y
+      return (right_edge - left_edge) / 2 + x, (bottom_edge - top_edge) / 2 + y
+    end
+
+  end
+end

data/lib/watir/element.rb

@@ -2,42 +2,35 @@ module Watir
   # Base class for html elements.
   # This is not a class that users would normally access.
   class Element # Wrapper
+    include Comparable
     include ElementExtensions
     include Exception
     include Container # presumes @container is defined
+    include DragAndDropHelper
+
     attr_accessor :container
 
     # number of spaces that separate the property from the value in the to_s method
     TO_S_SIZE = 14
 
-    def self.inherited subclass
-      class_name = Watir::Util.demodulize(subclass.to_s)
-      method_name = Watir::Util.underscore(class_name)
-      Watir::Container.module_eval <<-RUBY
-        def #{method_name}(how={}, what=nil)
-          #{class_name}.new(self, how, what)
-        end
+    def initialize(container, specifiers)
+      set_container container
+      raise ArgumentError, "#{specifiers.inspect} has to be Hash" unless specifiers.is_a?(Hash)
 
-        def #{method_name}s(how={}, what=nil)
-          #{class_name}s.new(self, how, what)
-        end         
-      RUBY
+      @o = specifiers[:ole_object]
+      @specifiers = specifiers
     end
 
-    # ole_object - the ole object for the element being wrapped
-    def initialize(ole_object)
-      @o = ole_object
-      @original_color = nil
+    def <=> other
+      assert_exists
+      other.assert_exists
+      ole_object.sourceindex <=> other.ole_object.sourceindex
     end
 
-    def locate
-      return if self.class == Element
+    alias_method :eql?, :==
 
-      tags = @how.is_a?(Hash) && @how[:tag_name] ? [@how[:tag_name].upcase] :
-             self.class.const_defined?(:TAG) ? [self.class::TAG] : 
-             self.class.const_defined?(:TAGS) ? self.class::TAGS :
-             [self.class.name.split("::").last.upcase]
-      @o = @container.locator_for(TaggedElementLocator, tags, @how, @what, self.class).locate
+    def locate
+      @o = @container.locator_for(TaggedElementLocator, @specifiers, self.class).locate
     end  
 
     # Return the ole object, allowing any methods of the DOM that Watir doesn't support to be used.
@@ -50,94 +43,45 @@ module Watir
     end
 
     def inspect
-      '#<%s:0x%x located=%s how=%s what=%s>' % [self.class, hash*2, !!ole_object, @how.inspect, @what.inspect]
+      '#<%s:0x%x located=%s specifiers=%s>' % [self.class, hash*2, !!ole_object, @specifiers.inspect]
     end
 
     private
-    def self.def_wrap(method_name, ole_method_name=nil)
-      class_eval "def #{method_name}
-                    assert_exists
-                    ole_object.invoke('#{ole_method_name || method_name}')
-                  end"
-    end
 
-    def self.def_wrap_guard(method_name, ole_method_name = nil)
-      class_eval "def #{method_name}
-                    assert_exists
-                    begin
-                      ole_object.invoke('#{ole_method_name || method_name}')
-                    rescue
-                      begin
-                        ole_object.getAttribute('#{ole_method_name || method_name}') || ''
-                      rescue
-                        ''
-                      end
-                    end
-                  end"
+    def self.attr_ole(method_name, ole_method_name=nil)
+      class_eval %Q[
+        def #{method_name}
+          assert_exists
+          ole_method_name = '#{ole_method_name || method_name.to_s.gsub(/\?$/, '')}'
+          ole_object.invoke(ole_method_name) rescue attribute_value(ole_method_name) || '' rescue ''
+        end]
     end
 
-
     public
+
     def assert_exists
       locate
       unless ole_object
-        if self.is_a?(Frame)
-          raise UnknownFrameException.new(Watir::Exception.message_for_unable_to_locate(@how, @what))
-        else
-          raise UnknownObjectException.new(
-                  Watir::Exception.message_for_unable_to_locate(@how, @what))
-        end
+        exception_class = self.is_a?(Frame) ? UnknownFrameException : UnknownObjectException
+        raise exception_class.new(Watir::Exception.message_for_unable_to_locate(@specifiers))
       end
     end
 
     def assert_enabled
-      unless enabled?
-        raise ObjectDisabledException, "object #{@how} and #{@what} is disabled"
-      end
+      raise ObjectDisabledException, "object #{@specifiers.inspect} is disabled" unless enabled?
     end
 
-    # return the name of the element (as defined in html)
-    def_wrap_guard :name
     # return the id of the element
-    def_wrap_guard :id
-    # return whether the element is disabled
-    def_wrap :disabled
-    alias disabled? disabled
-    # return the value of the element
-    def_wrap_guard :value
+    attr_ole :id
     # return the title of the element
-    def_wrap_guard :title
-
-    def_wrap_guard :alt
-    def_wrap_guard :src
-
-    # return the type of the element
-    def_wrap_guard :type # input elements only
-    # return the url the link points to
-    def_wrap :href # link only
+    attr_ole :title
     # return the class name of the element
     # raise an ObjectNotFound exception if the object cannot be found
-    def_wrap :class_name, :className
+    attr_ole :class_name, :className
     # return the unique COM number for the element
-    def_wrap :unique_number, :uniqueNumber
+    attr_ole :unique_number, :uniqueNumber
     # Return the outer html of the object - see http://msdn.microsoft.com/workshop/author/dhtml/reference/properties/outerhtml.asp?frame=true
-    def_wrap :html, :outerHTML
-    # Return the "for" attribute for label
-    def_wrap_guard :for, :htmlFor
-    # Return the content attribute for meta tag
-    def_wrap_guard :content
-    # Return the http-equiv attribute for meta tag
-    def_wrap_guard :http_equiv, :httpEquiv
-    # Return font tag attributes
-    def_wrap_guard :color
-    def_wrap_guard :face
-    def_wrap_guard :size
-    # Return option label attribute
-    def_wrap_guard :label
-    # Return table rules attribute
-    def_wrap_guard :rules
-    # Return td headers attribute
-    def_wrap_guard :headers
+    attr_ole :html, :outerHTML
 
     def tag_name
       assert_exists
@@ -150,50 +94,33 @@ module Watir
 
       tag = tag_name
       if tag == "html"
-        html_element(:ole_object, ole_object)
+        element(:ole_object => ole_object)
       elsif tag == "input"
-        self.send(ole_object.invoke('type'), :ole_object, ole_object)
+        send(ole_object.invoke('type'), :ole_object => ole_object)
       elsif tag == "select"
-        self.select_list(:ole_object, ole_object)
-      elsif self.respond_to?(tag.downcase)
-        self.send(tag.downcase, :ole_object, ole_object)
+        select_list(:ole_object => ole_object)
+      elsif respond_to?(tag.downcase)
+        send(tag.downcase, :ole_object => ole_object)
       else
         self
       end
     end
 
     # send keys to element
-    def send_keys(key_string)
+    def send_keys(*keys)
       focus
-      page_container.send_keys key_string
+      page_container.send_keys *keys
     end
 
     # return the css style as a string
     def style
       assert_exists
+      # this works for IE9
+      ole_object.currentStyle.cssText
+    rescue WIN32OLERuntimeError
       ole_object.style.cssText
     end
 
-    # return the text before the element
-    def before_text # label only
-      assert_exists
-      begin
-        ole_object.getAdjacentText("afterEnd").strip
-      rescue
-        ''
-      end
-    end
-
-    # return the text after the element
-    def after_text # label only
-      assert_exists
-      begin
-        ole_object.getAdjacentText("beforeBegin").strip
-      rescue
-        ''
-      end
-    end
-
     # Return the innerText of the object or an empty string if the object is
     # not visible
     # Raise an ObjectNotFound exception if the object cannot be found
@@ -202,20 +129,14 @@ module Watir
       visible? ? ole_object.innerText.strip : ""
     end
 
-    # IE9 only returns empty string for ole_object.name for non-input elements
-    # so get at it through the attribute which will make the matchers work
-    def name
-      attribute_value('name') || ''
-    end
-
     def __ole_inner_elements
       assert_exists
-      return ole_object.all
+      ole_object.all
     end
 
     def document
       assert_exists
-      return ole_object
+      ole_object
     end
 
     # Return the element immediately containing self. 
@@ -223,33 +144,15 @@ module Watir
       assert_exists
       parent_element = ole_object.parentelement
       return unless parent_element
-      result = Element.new(parent_element).to_subtype
-      result.set_container self
-      result
+      Element.new(self, :ole_object => parent_element).to_subtype
     end
 
-    include Comparable
-
-    def <=> other
-      assert_exists
-      other.assert_exists
-      ole_object.sourceindex <=> other.ole_object.sourceindex
-    end
-
-    alias_method :eql?, :==
-
-    # Return true if self is contained earlier in the html than other. 
-    alias :before? :<
-    # Return true if self is contained later in the html than other. 
-    alias :after? :>
-
     def typingspeed
       @container.typingspeed
     end
 
     def type_keys
-      return @container.type_keys if @type_keys.nil?
-      @type_keys
+      @type_keys || @container.type_keys
     end
 
     def activeObjectHighLightColor
@@ -259,11 +162,7 @@ module Watir
     # Return an array with many of the properties, in a format to be used by the to_s method
     def string_creator
       n = []
-      n <<   "type:".ljust(TO_S_SIZE) + self.type
       n <<   "id:".ljust(TO_S_SIZE) +         self.id.to_s
-      n <<   "name:".ljust(TO_S_SIZE) +       self.name.to_s
-      n <<   "value:".ljust(TO_S_SIZE) +      self.value.to_s
-      n <<   "disabled:".ljust(TO_S_SIZE) +   self.disabled.to_s
       return n
     end
 
@@ -344,11 +243,13 @@ module Watir
     private :build_method
 
     def generate_ruby_code(element, method_name, *args)
-      element = "#{self.class}.new(#{@page_container.attach_command}, :unique_number, #{self.unique_number})"
+      # needs to be done like this to avoid segfault on ruby 1.9.3
+      tag_name = @specifiers[:tag_name].join("' << '")
+      element = "#{self.class}.new(#{@page_container.attach_command}, :tag_name => Array.new << '#{tag_name}', :unique_number => #{unique_number})"
       method = build_method(method_name, *args)
       ruby_code = "$:.unshift(#{$LOAD_PATH.map {|p| "'#{p}'" }.join(").unshift(")});" <<
                     "require '#{File.expand_path(File.dirname(__FILE__))}/core';#{element}.#{method};"
-      return ruby_code
+      ruby_code
     end
 
     private :generate_ruby_code
@@ -400,12 +301,8 @@ module Watir
     def dispatch_event(event)
       assert_exists
 
-      if IE.version_parts.first.to_i >= 9
-        if @container.page_container.document_mode.to_i >= 9
-          ole_object.dispatchEvent(create_event(event))
-        else
-          ole_object.fireEvent(event)
-        end
+      if IE.version_parts.first.to_i >= 9 && container.page_container.document.documentMode.to_i >= 9
+        ole_object.dispatchEvent(create_event(event))
       else
         ole_object.fireEvent(event)
       end
@@ -477,7 +374,12 @@ module Watir
     #   raises: UnknownObjectException  if the object is not found
     def enabled?
       assert_exists
-      !disabled
+      !disabled?
+    end
+
+    def disabled?
+      assert_exists
+      false
     end
 
     # If any parent element isn't visible then we cannot write to the