page-object 1.0.3 → 1.1.0

data/lib/page-object.rb

@@ -7,8 +7,15 @@ require 'page-object/page_factory'
 require 'page-object/page_populator'
 require 'page-object/javascript_framework_facade'
 require 'page-object/indexed_properties'
+require 'page-object/sections'
 require 'page-object/widgets'
 
+require 'watir-webdriver'
+require 'page-object/platforms/watir_webdriver/element'
+require 'page-object/platforms/watir_webdriver/page_object'
+require 'page-object/platforms/selenium_webdriver/element'
+require 'page-object/platforms/selenium_webdriver/page_object'
+
 require 'selenium/webdriver/common/error'
 #
 # Module that when included adds functionality to a page object.  This module
@@ -53,19 +60,20 @@ module PageObject
   # a method named initialize_accessors if it exists. Upon initialization of 
   # the page it will call a method named initialize_page if it exists.
   #
-  # @param [Watir::Browser or Selenium::WebDriver::Driver] the platform browser to use
+  # @param [Watir::Browser, Watir::HTMLElement or Selenium::WebDriver::Driver, Selenium::WebDriver::Element] the platform browser/element to use
   # @param [bool] open the page if page_url is set
   #
-  def initialize(browser, visit=false)
+  def initialize(root, visit=false)
     initialize_accessors if respond_to?(:initialize_accessors)
-    initialize_browser(browser)
+    initialize_browser(root)
     goto if visit && respond_to?(:goto)
     initialize_page if respond_to?(:initialize_page)
   end
 
-  def initialize_browser(browser)
-    @browser = browser
-    include_platform_driver(browser)
+  def initialize_browser(root)
+    @root_element = root_element_for root, PageObject::Platforms.get
+    @browser = browser_for root, PageObject::Platforms.get
+    include_platform_driver(root)
   end
 
   # @private
@@ -144,7 +152,7 @@ module PageObject
   # Returns the text of the current page
   #
   def text
-    platform.text
+    root.text
   end
 
   #
@@ -399,6 +407,10 @@ module PageObject
 
   private
 
+  def root
+    @root_element || browser_root_for(browser, PageObject::Platforms.get)
+  end
+
   def include_platform_driver(browser)
     @platform = load_platform(browser, PageObject::Platforms.get)
   end

data/lib/page-object/accessors.rb

@@ -1229,6 +1229,54 @@ module PageObject
       end
     end
 
+    #
+    # adds a method to return a page object rooted at an element
+    #
+    # @example
+    #   page_section(:navigation_bar, NavigationBar, :id => 'nav-bar')
+    #   # will generate 'navigation_bar' and 'navigation_bar?'
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Class] the class to instantiate for the element
+    # @param [Hash] identifier how we find an element.  You can use multiple parameters
+    #   by combining of any of the following except xpath.  The valid keys are:
+    #   * :class => Watir and Selenium
+    #   * :css => Selenium only
+    #   * :id => Watir and Selenium
+    #   * :index => Watir and Selenium
+    #   * :name => Watir and Selenium
+    #   * :xpath => Watir and Selenium
+    #
+    def page_section(name, section_class, identifier)
+      define_method(name) do
+        platform.page_for(identifier, section_class)
+      end
+    end
+
+    #
+    # adds a method to return a collection of page objects rooted at elements
+    #
+    # @example
+    #   page_sections(:articles, Article, :class => 'article')
+    #   # will generate 'articles'
+    #
+    # @param [Symbol] the name used for the generated method
+    # @param [Class] the class to instantiate for each element
+    # @param [Hash] identifier how we find an element.  You can use a multiple parameters
+    #   by combining of any of the following except xpath.  The valid keys are:
+    #   * :class => Watir and Selenium
+    #   * :css => Selenium only
+    #   * :id => Watir and Selenium
+    #   * :index => Watir and Selenium
+    #   * :name => Watir and Selenium
+    #   * :xpath => Watir and Selenium
+    #
+    def page_sections(name, section_class, identifier)
+      define_method(name) do
+        platform.pages_for(identifier, section_class)
+      end
+    end
+
     #
     # methods to generate accessors for types that follow the same
     # pattern as element

data/lib/page-object/elements/element.rb

@@ -208,19 +208,19 @@ module PageObject
 
       def include_platform_for platform
         if platform[:platform] == :watir_webdriver
-          require 'page-object/platforms/watir_webdriver/element'
-          require 'page-object/platforms/watir_webdriver/page_object'
           self.class.send :include,  ::PageObject::Platforms::WatirWebDriver::Element
           @platform = ::PageObject::Platforms::WatirWebDriver::PageObject.new(@element)
         elsif platform[:platform] == :selenium_webdriver
-          require 'page-object/platforms/selenium_webdriver/element'
-          require 'page-object/platforms/selenium_webdriver/page_object'
           self.class.send :include, ::PageObject::Platforms::SeleniumWebDriver::Element
           @platform = ::PageObject::Platforms::SeleniumWebDriver::PageObject.new(@element)
         else
           raise ArgumentError, "expect platform to be :watir_webdriver or :selenium_webdriver"
         end
       end
+
+      def to_ary
+        nil
+      end
     end
   end
 end

data/lib/page-object/indexed_properties.rb

@@ -20,16 +20,20 @@ module PageObject
               name = identifier[1]
               how_and_what = identifier[2].clone # Cannot modify the original...
               how_and_what.each do |key, value|
-                how_and_what[key] = value % index
+                if key == :index
+                  how_and_what[key] = (value % index).to_i
+                else
+                  how_and_what[key] = value % index
+                end
               end
-              self.class.send type, name, how_and_what unless self.class.instance_methods.include? name
+              self.class.send type, name, how_and_what unless Class.instance_methods.include? name
             end
           end
         }
       end
 
       def [] (index)
-        @indexed_property_class.new(@browser,index,@identifier_list)
+        @indexed_property_class.new(@browser, index, @identifier_list)
       end
     end
   end

data/lib/page-object/loads_platform.rb

@@ -15,12 +15,31 @@ module PageObject
     # @returns [PageObject] 
     #
     def load_platform(browser, adapters)
-      adapters.each_value { |adapter|
-        return adapter.create_page_object(browser) if adapter.is_for?(browser)
+      adapter_for(browser,adapters).create_page_object(browser)
+    end
+
+    def browser_for root,adapters
+      adapter_for(root,adapters).browser_for(root)
+    end
+
+    def adapter_for element_or_browser, adapters
+      adapter = adapters.values.find { |adapter|
+        adapter.is_for?(element_or_browser)
       }
-      message = 'Unable to pick a platform for the provided browser.'
-      message += "\nnil was passed to the PageObject constructor instead of a valid browser object." if browser.nil?
-      raise message 
+      unless adapter
+        message = "Unable to pick a platform for the provided browser or element: #{element_or_browser.inspect}."
+        message += "\nnil was passed to the PageObject constructor instead of a valid browser or element object." if element_or_browser.nil?
+        raise message
+      end
+      adapter
+    end
+
+    def root_element_for root, adapters
+      adapter_for(root,adapters).root_element_for(root)
+    end
+
+    def browser_root_for browser, adapters
+      adapter_for(browser,adapters).browser_root_for(browser)
     end
   end
 end

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

@@ -3,13 +3,25 @@ module PageObject
     module SeleniumWebDriver
 
       def self.create_page_object(browser)
-        require 'page-object/platforms/selenium_webdriver/page_object'
         SeleniumWebDriver::PageObject.new(browser)
       end
 
       def self.is_for?(browser)
         require 'selenium-webdriver'
-        browser.is_a? ::Selenium::WebDriver::Driver
+        browser.is_a?(::Selenium::WebDriver::Driver) || browser.is_a?(::Selenium::WebDriver::Element)
+      end
+
+      def self.browser_for root
+        return root if root.is_a?(::Selenium::WebDriver::Driver)
+        Selenium::WebDriver::Driver.new(root.send(:bridge))
+      end
+
+      def self.root_element_for root
+        Elements::Element.new root, platform: :selenium_webdriver if root.is_a?(::Selenium::WebDriver::Element)
+      end
+
+      def self.browser_root_for browser
+        browser.find_element(tag_name: 'html')
       end
     end
   end

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

@@ -3,11 +3,11 @@ module PageObject
     module SeleniumWebDriver
       module Button
         #
-        # Override PageObject::PLatforms::SeleniumElement#text because
-        # #text does not reliably return a value in Selenium
+        # Override PageObject::PLatforms::SeleniumElement#text
+        # to get #text from buttons and #attribute('value') from inputs
         #
         def text
-          raise "text is not available on button element in Selenium"
+          element.tag_name == 'button' ? element.text : element.attribute('value')
         end
       end
     end

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

@@ -67,7 +67,7 @@ module PageObject
         # compare this element to another to determine if they are equal
         #
         def ==(other)
-          element == other.element
+          other.is_a? self.class and element == other.element
         end
 
         #

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

@@ -988,6 +988,22 @@ module PageObject
           find_selenium_elements(identifier, Elements::Element, tag.to_s)
         end
 
+        #
+        # platform method to return a PageObject rooted at an element
+        # See PageObject::Accessors#page_section
+        #
+        def page_for(identifier, page_class)
+          find_selenium_page(identifier, page_class)
+        end
+
+        #
+        # platform method to return a collection of PageObjects rooted at elements
+        # See PageObject::Accessors#page_sections
+        #
+        def pages_for(identifier, page_class)
+          SectionCollection.new(find_selenium_pages(identifier, page_class))
+        end
+
        #
         # platform method to return a svg element
         #
@@ -1071,6 +1087,40 @@ module PageObject
           elements.map { |element| type.new(element, :platform => :selenium_webdriver) }
         end
 
+        def find_selenium_pages(identifier, page_class)
+          regexp = delete_regexp(identifier)
+          how, what, frame_identifiers = parse_identifiers(identifier, Elements::Element, 'element')
+          switch_to_frame(frame_identifiers)
+          unless regexp
+            elements = @browser.find_elements(how, what)
+          else
+            eles = @browser.find_elements(how, what)
+            elements = eles.find_all {|ele| matches_selector?(ele, regexp[0], regexp[1])}
+          end
+          @browser.switch_to.default_content unless frame_identifiers.nil?
+          elements.map { |element| page_class.new(element) }
+        end
+
+        def find_selenium_page(identifier, page_class)
+          type, tag = Elements::Element, 'element'
+          regexp = delete_regexp(identifier)
+          how, what, frame_identifiers = parse_identifiers(identifier, type, tag)
+          switch_to_frame(frame_identifiers)
+          begin
+            unless regexp
+              element = @browser.find_element(how, what)
+            else
+              elements = @browser.find_elements(how, what)
+              element = elements.find {|ele| matches_selector?(ele, regexp[0], regexp[1])}
+            end
+          rescue Selenium::WebDriver::Error::NoSuchElementError
+            @browser.switch_to.default_content unless frame_identifiers.nil?
+            return build_null_object(identifier, type, tag, nil)
+          end
+          @browser.switch_to.default_content unless frame_identifiers.nil?
+          page_class.new(element)
+        end
+
         def build_null_object(identifier, type, tag, other)
           null_element = SurrogateSeleniumElement.new
           null_element.identifier = identifier

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

@@ -1,15 +1,27 @@
 module PageObject
   module Platforms
     module WatirWebDriver
-      
+
       def self.create_page_object(browser)
-        require 'page-object/platforms/watir_webdriver/page_object'
         return WatirWebDriver::PageObject.new(browser)
       end
 
       def self.is_for?(browser)
         require 'watir-webdriver'
-        browser.is_a?(::Watir::Browser)
+        browser.is_a?(::Watir::Browser) || browser.is_a?(::Watir::HTMLElement)
+      end
+
+      def self.browser_for root
+        return root if root.is_a?(::Watir::Browser)
+        root.browser
+      end
+
+      def self.root_element_for root
+        Elements::Element.new root, :platform => :watir_webdriver if root.is_a? ::Watir::HTMLElement
+      end
+
+      def self.browser_root_for browser
+        browser.element
       end
     end
   end

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

@@ -60,7 +60,7 @@ module PageObject
         # compare this element to another to determine if they are equal
         #
         def ==(other)
-          element == other.element
+          other.is_a? self.class and element == other.element
         end
 
         #

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

@@ -917,6 +917,22 @@ module PageObject
           find_watir_elements("#{tag.to_s}s(identifier)", Elements::Element, identifier, tag.to_s)
         end
 
+        #
+        # platform method to return a PageObject rooted at an element
+        # See PageObject::Accessors#page_section
+        #
+        def page_for(identifier, page_class)
+          find_watir_page(identifier, page_class)
+        end
+
+        #
+        # platform method to return a collection of PageObjects rooted at elements
+        # See PageObject::Accessors#page_sections
+        #
+        def pages_for(identifier, page_class)
+          SectionCollection.new(find_watir_pages(identifier, page_class))
+        end
+
         #
         # platform method to return a svg element
         #
@@ -970,6 +986,20 @@ module PageObject
           type.new(element, :platform => :watir_webdriver)
         end
 
+        def find_watir_pages(identifier, page_class)
+          identifier, frame_identifiers = parse_identifiers(identifier, Elements::Element, 'element')
+          elements = @browser.instance_eval "#{nested_frames(frame_identifiers)}elements(identifier)"
+          switch_to_default_content(frame_identifiers)
+          elements.map { |element| page_class.new(element) }
+        end
+
+        def find_watir_page(identifier, page_class)
+          identifier, frame_identifiers = parse_identifiers(identifier, Elements::Element, 'element')
+          element = @browser.instance_eval "#{nested_frames(frame_identifiers)}element(identifier)"
+          switch_to_default_content(frame_identifiers)
+          page_class.new(element)
+        end
+
         def process_watir_call(the_call, type, identifier, value=nil, tag_name=nil)
           identifier, frame_identifiers = parse_identifiers(identifier, type, tag_name)
           value = @browser.instance_eval "#{nested_frames(frame_identifiers)}#{the_call}"

data/lib/page-object/sections.rb

@@ -0,0 +1,29 @@
+module PageObject
+  class SectionCollection
+    include Enumerable
+
+    def initialize sections
+      @sections = sections
+    end
+
+    def each &block
+      @sections.each &block
+    end
+
+    def [] index
+      @sections[index]
+    end
+
+    def find_by values_hash
+      @sections.find {|section|
+        values_hash.all? {|method,value| value === section.public_send(method)}
+      }
+    end
+
+    def select_by values_hash
+      SectionCollection.new @sections.select {|section|
+        values_hash.all? {|method,value| value === section.public_send(method)}
+      }
+    end
+  end
+end

data/lib/page-object/version.rb

@@ -1,4 +1,4 @@
 module PageObject
   # @private
-  VERSION = "1.0.3"
+  VERSION = "1.1.0"
 end