page-object-lds 0.0.1

data/lib/page-object/platforms/selenium_webdriver/radio_button.rb

@@ -0,0 +1,22 @@
+module PageObject
+  module Platforms
+    module SeleniumWebDriver
+      module RadioButton
+
+        #
+        # select the radiobutton
+        #
+        def select
+          element.click unless selected?
+        end
+
+        #
+        # return if it is selected
+        #
+        def selected?
+          element.selected?
+        end
+      end
+    end
+  end
+end

data/lib/page-object/platforms/selenium_webdriver/select_list.rb

@@ -0,0 +1,93 @@
+module PageObject
+  module Platforms
+    module SeleniumWebDriver
+      module SelectList
+
+        #
+        # Return the PageObject::Elements::Option for the index provided.  Index
+        # is zero based.
+        #
+        # @return [PageObject::Elements::Option]
+        #
+        def [](idx)
+          options[idx]
+        end
+
+        #
+        # Select a value from the list
+        #
+        def select(value)
+          find_options.find do |option|
+            option.text == value
+          end.click
+        end
+
+        #
+        # Select the option(s) whose value attribute matches the given
+        # string
+        #
+        def select_value(value)
+          options = find_options.find_all do |option|
+            option.attribute('value') == value
+          end
+          options.each {|opt| opt.click}
+        end
+
+        #
+        # Return an array of Options contained in the select list.
+        #
+        # @return [array of PageObject::Elements::Option]
+        def options
+          find_options.map { |e| ::PageObject::Elements::Option.new(e, :platform => :selenium_webdriver) }
+        end
+
+        #
+        # @return [Array<String>] An array of strings representing the text of the currently selected options.
+        #
+        def selected_options
+          find_options.map { |e| e.text if e.selected? }.compact
+        end
+
+        #
+        # @return [Array<String>] An array of strings representing the value of the currently selected options.
+        #
+        def selected_values
+          find_options.map { |e| e.attribute('value') if e.selected? }.compact
+        end
+
+        #
+        # Returns true if the select list has one or more options where text or label matches the given value.
+        #
+        # @param [String, Regexp] value A value.
+        # @return [Boolean]
+        def include?(value)
+          find_options.any? { |e| e.text == value }
+        end
+
+        #
+        # Returns true if any of the selected options' text match the given value.
+        #
+        # @param [String, Regexp] value A value.
+        # @return [Boolean]
+        def selected?(value)
+          selected = find_options.select { |e| e if e.selected? }
+          selected.any? { |e| e.text == value }
+        end
+
+        #
+        # Deselect all selected options.
+        #
+        def clear
+          find_options.select { |e| e.selected? }.each { |o| o.click }
+        end
+
+        private
+
+        def find_options
+          element.find_elements(:xpath, child_xpath)
+        end
+      end
+    end
+  end
+
+end

data/lib/page-object/platforms/selenium_webdriver/surrogate_selenium_element.rb

@@ -0,0 +1,42 @@
+module PageObject
+  module Platforms
+    module SeleniumWebDriver
+      class SurrogateSeleniumElement
+        attr_accessor :identifier, :type, :tag, :other, :platform
+        
+        def exists?
+          attempt_to_find_element unless @element
+          @element ? (not @element.element.nil?) : false
+        end
+        
+        def visible?
+          attempt_to_find_element unless @element
+          @element ? @element.element.displayed? : false
+        end
+
+        def nil?
+          attempt_to_find_element unless @element
+          @element ? @element.element.nil? : true
+        end
+
+        def displayed?
+          attempt_to_find_element unless @element
+          @element ? @element.element.displayed? : false
+        end
+
+        def method_missing(meth, *args)
+          return @element.send(meth, *args) if @element
+          $stderr.puts "You are calling #{meth} on an element that does not yet exist."
+          raise Selenium::WebDriver::Error::NoSuchElementError
+        end
+
+        private
+
+        def attempt_to_find_element
+          @element = platform.send(:find_selenium_element, identifier, type, tag, other) unless @element
+          @element = nil if @element.element.instance_of?(::PageObject::Platforms::SeleniumWebDriver::SurrogateSeleniumElement)
+        end
+      end
+    end
+  end
+end

data/lib/page-object/platforms/selenium_webdriver/table.rb

@@ -0,0 +1,42 @@
+module PageObject
+  module Platforms
+    module SeleniumWebDriver
+      module Table
+
+        #
+        # Return the PageObject::Elements::TableRow for the index provided.  Index
+        # is zero based.  If the index provided is a String then it
+        # will be matched with the text from any column. The text can be a substring of the full column text.
+        #
+        # @return [PageObject::Elements::TableRow]
+        #
+        def [](idx)
+          eles = table_rows
+          idx = find_index_by_title(idx, eles) if idx.kind_of?(String)
+          return nil unless idx
+          initialize_row(eles[idx], :platform => :selenium_webdriver)
+        end
+
+        #
+        # Returns the number of rows in the table.
+        #
+        def rows
+          table_rows.size
+        end
+
+        private
+
+        def find_index_by_title(row_title, eles)
+          eles.find_index do |row|
+            columns = row.find_elements(:xpath, ".//child::td|th")
+            columns.any? { |col| col.text.include? row_title }
+          end
+        end
+
+        def table_rows
+          element.find_elements(:xpath, child_xpath)
+        end
+      end
+    end
+  end
+end

data/lib/page-object/platforms/selenium_webdriver/table_row.rb

@@ -0,0 +1,43 @@
+module PageObject
+  module Platforms
+    module SeleniumWebDriver
+
+      module TableRow
+
+        #
+        # Return the PageObject::Elements::TableCell for the index provided.  Index
+        # is zero based.  If the index provided is a String then it
+        # will be matched with the text from the columns in the first row.
+        # The text can be a substring of the full column text.
+        #
+        def [](idx)
+          els = table_cells
+          idx = find_index_by_title(idx) if idx.kind_of?(String)
+          return nil unless idx  && columns >= idx + 1
+          initialize_cell(els[idx], :platform => :selenium_webdriver)
+        end
+
+        #
+        # Returns the number of columns in the table.
+        #
+        def columns
+          table_cells.size
+        end
+
+        private
+
+        def find_index_by_title(title)
+          table = parent
+          parent_tag_name = parent.element.tag_name
+          table = table.parent if (parent_tag_name == 'tbody' || parent_tag_name == 'thead')
+          table[0].find_index { |column| column.text.include? title }
+        end
+
+        def table_cells
+          element.find_elements(:xpath, child_xpath)
+        end
+
+      end
+    end
+  end
+end

data/lib/page-object/platforms/selenium_webdriver/text_area.rb

@@ -0,0 +1,17 @@
+module PageObject
+  module Platforms
+    module SeleniumWebDriver
+
+      module TextArea
+        
+        #
+        # Set the value of the TextArea
+        #
+        def value=(new_value)
+          element.clear
+          element.send_keys(new_value)
+        end
+      end
+    end
+  end
+end

data/lib/page-object/platforms/selenium_webdriver/text_field.rb

@@ -0,0 +1,17 @@
+module PageObject
+  module Platforms
+    module SeleniumWebDriver
+
+      module TextField
+        
+        #
+        # Set the value of the TextField
+        #
+        def value=(new_value)
+          element.clear
+          element.send_keys(new_value)
+        end
+      end
+    end
+  end
+end

data/lib/page-object/platforms/selenium_webdriver/unordered_list.rb

@@ -0,0 +1,39 @@
+module PageObject
+  module Platforms
+    module SeleniumWebDriver
+      module UnorderedList
+
+        #
+        # Return the PageObject::Elements::ListItem for the index provided.  Index
+        # is zero based.
+        #
+        # @return [PageObject::Elements::ListItem]
+        #
+        def [](idx)
+          children[idx]
+        end
+
+        #
+        # Return the number of items contained in the unordered list
+        #
+        def items
+          children.size
+        end
+
+        private
+
+        def children
+          items = list_items.map do |item|
+            ::PageObject::Elements::ListItem.new(item, :platform => :selenium_webdriver)
+          end
+          items.find_all { |item| item.parent.element == element }
+        end
+
+        def list_items
+          element.find_elements(:xpath, child_xpath)
+        end
+
+      end
+    end
+  end
+end

data/lib/page-object/platforms/watir_webdriver.rb

@@ -0,0 +1,17 @@
+module PageObject
+  module Platforms
+    module WatirWebDriver
+      
+      def self.create_page_object(browser)
+        return WatirWebDriver::PageObject.new(browser)
+      end
+
+      def self.is_for?(browser)
+        require 'watir-webdriver'
+        browser.is_a?(::Watir::Browser)
+      end
+    end
+  end
+end
+
+PageObject::Platforms.register(:watir_webdriver, PageObject::Platforms::WatirWebDriver)

data/lib/page-object/platforms/watir_webdriver/check_box.rb

@@ -0,0 +1,29 @@
+module PageObject
+  module Platforms
+    module WatirWebDriver
+      module CheckBox
+        
+        #
+        # check the checkbox
+        #
+        def check
+          element.set
+        end
+
+        #
+        # uncheck the checkbox
+        #
+        def uncheck
+          element.clear
+        end
+
+        #
+        # return true if checkbox is checked
+        #
+        def checked?
+          element.set?
+        end
+      end
+    end
+  end
+end

data/lib/page-object/platforms/watir_webdriver/element.rb

@@ -0,0 +1,249 @@
+require 'watir-webdriver/extensions/select_text'
+
+module PageObject
+  module Platforms
+    #
+    # Watir implementation of the common functionality found across all elements
+    #
+    module WatirWebDriver
+      module Element
+
+        #
+        # return true if an element is visible
+        #
+        def visible?
+          element.present?
+        end
+
+        #
+        # return true if an element exists
+        #
+        def exists?
+          element.exists?
+        end
+
+        #
+        # flash the element by temporarily changing the background color
+        #
+        def flash
+          element.flash
+        end
+        
+        #
+        # Get the text for the element
+        #
+        # @return [String]
+        #
+        def text
+          element.text
+        end
+
+        #
+        # Get the html for the element
+        #
+        # @return [String]
+        #
+        def html
+          element.html
+        end
+
+        #
+        # Get the value of this element
+        #
+        # @return [String]
+        #
+        def value
+          element.value
+        end
+
+        #
+        # compare this element to another to determine if they are equal
+        #
+        def ==(other)
+          element == other.element
+        end
+
+        #
+        # Get the tag name of this element
+        #
+        # @return [String]
+        #
+        def tag_name
+          element.tag_name
+        end
+
+        #
+        # Get the value of a the given attribute of the element.  Will
+        # return the current value, even if this has been modified
+        # after the page has been loaded. More exactly, this method
+        # will  return the value of the given attribute, unless that
+        # attribute is not present, in which case the value of the
+        # property with the same name is returned. If neither value is
+        # set, nil is returned. The "style" attribute is converted as
+        # best can be to a text representation with a trailing
+        # semi-colon. The following are deemed to be "boolean"
+        # attributes, and will return either "true" or "false":
+        #
+        # async, autofocus, autoplay, checked, compact, complete,
+        # controls, declare, defaultchecked, defaultselected, defer,
+        # disabled, draggable, ended, formnovalidate, hidden, indeterminate,
+        # iscontenteditable, ismap, itemscope, loop, multiple, muted,
+        # nohref, noresize, noshade, novalidate, nowrap, open, paused,
+        # pubdate, readonly, required, reversed, scoped, seamless, seeking,
+        # selected, spellcheck, truespeed, willvalidate
+        #
+        # Finally, the following commonly mis-capitalized
+        # attribute/property names are evaluated as expected:
+        #
+        # class, readonly
+        #
+        # @param [String]
+        #   attribute name
+        # @return [String,nil]
+        #   attribute value
+        #
+        def attribute(attribute_name)
+          element.attribute_value attribute_name
+        end
+
+        #
+        # Fire the provided event on the current element
+        #
+        def fire_event(event_name)
+          element.fire_event(event_name)
+        end
+
+        #
+        # hover over the element
+        #
+        def hover
+          element.hover
+        end
+
+        #
+        # double click the element
+        #
+        def double_click
+          element.double_click
+        end
+
+        #
+        # find the parent element
+        #
+        def parent
+          parent = element.parent
+          type = element.type if parent.tag_name.to_sym == :input
+          cls = ::PageObject::Elements.element_class_for(parent.tag_name, type)
+          cls.new(parent, :platform => :watir_webdriver)
+        end
+
+        #
+        # Set the focus to the current element
+        #
+        def focus
+          element.focus
+        end
+
+        #
+        # Select the provided text
+        #
+        def select_text(text)
+          element.select_text text
+        end
+        
+        #
+        # Waits until the element is present
+        #
+        # @param [Integer] (defaults to: 5) seconds to wait before timing out
+        #
+        def when_present(timeout=::PageObject.default_element_wait)
+          element.wait_until_present(timeout)
+          self
+        end
+
+        #
+        # Waits until the element is not present
+        #
+        # @param [Integer] (defaults to: 5) seconds to wait before
+        # timing out
+        #
+        def when_not_present(timeout=::PageObject.default_element_wait)
+          element.wait_while_present(timeout)
+        end
+
+        #
+        # Waits until the element is visible
+        #
+        # @param [Integer] (defaults to: 5) seconds to wait before timing out
+        #
+        def when_visible(timeout=::PageObject.default_element_wait)
+          Object::Watir::Wait.until(timeout, "Element was not visible in #{timeout} seconds") do
+            visible?
+          end
+          self
+        end
+
+        #
+        # Waits until the element is not visible
+        #
+        # @param [Integer] (defaults to: 5) seconds to wait before timing out
+        #
+        def when_not_visible(timeout=::PageObject.default_element_wait)
+          Object::Watir::Wait.while(timeout, "Element still visible after #{timeout} seconds") do
+            visible?
+          end
+          self
+        end
+
+        #
+        # Waits until the block returns true
+        #
+        # @param [Integer] (defaults to: 5) seconds to wait before timing out
+        # @param [String] the message to display if the event timeouts
+        # @param the block to execute when the event occurs
+        #
+        def wait_until(timeout=::PageObject.default_element_wait, message=nil, &block)
+          Object::Watir::Wait.until(timeout, message, &block)
+        end
+        
+        #
+        # Send keystrokes to this element
+        #
+        # @param [String, Symbol, Array]
+        #
+        # Examples:
+        #
+        #     element.send_keys "foo"                     #=> value: 'foo'
+        #     element.send_keys "tet", :arrow_left, "s"   #=> value: 'test'
+        #     element.send_keys [:control, 'a'], :space   #=> value: ' '
+        #
+        # @see Selenium::WebDriver::Keys::KEYS
+        #
+        def send_keys(*args)
+          element.send_keys(*args)
+        end
+
+        #
+        # clear the contents of the element
+        #
+        def clear
+          element.clear
+        end
+
+        #
+        # get the id of the element
+        #
+        def id
+          element.id
+        end
+
+        #
+        # Scroll until the element is viewable
+        #
+        def scroll_into_view
+          element.wd.location_once_scrolled_into_view
+        end
+      end
+    end
+  end
+end