page-object-lds 0.0.1

data/lib/page-object/loads_platform.rb

@@ -0,0 +1,26 @@
+module PageObject
+  #
+  # module which provides a function for determining
+  # which platform to provide to the page object
+  # 
+  module LoadsPlatform
+    #
+    # Determines which platform the Page Object should use based upon browser
+    #
+    # @example
+    #  platform =  load_platform(watir_webdriver_browser, PageObject.Adapters.list).send(:new, watir_webdriver_browser)
+    # 
+    # @param [Object] A browser driver that has a supported adapter
+    # @param [adapters] a list of adapters that are currently supported
+    # @returns [PageObject] 
+    #
+    def load_platform(browser, adapters)
+      adapters.each_value { |adapter|
+        return adapter.create_page_object(browser) if adapter.is_for?(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 
+    end
+  end
+end

data/lib/page-object/locator_generator.rb

@@ -0,0 +1,130 @@
+module PageObject
+  module LocatorGenerator
+
+    BASIC_ELEMENTS = [:abbr,
+                      :address,
+                      :article,
+                      :as,
+                      :aside,
+                      :bdi,
+                      :bdo,
+                      :blockquote,
+                      :body,
+                      :br,
+                      :caption,
+                      :cite,
+                      :code,
+                      :col,
+                      :colgroup,
+                      :command,
+                      :data,
+                      :datalist,
+                      :dd,
+                      :del,
+                      :details,
+                      :dfn,
+                      :dialog,
+                      :dl,
+                      :dt,
+                      :em,
+                      :embed,
+                      :fieldset,
+                      :figcaption,
+                      :figure,
+                      :footer,
+                      :head,
+                      :header,
+                      :hgroup,
+                      :hr,
+                      :ins,
+                      :kbd,
+                      :keygen,
+                      :legend,
+                      :map,
+                      :mark,
+                      :menu,
+                      :meta,
+                      :meter,
+                      :nav,
+                      :noscript,
+                      :object,
+                      :optgroup,
+                      :output,
+                      :param,
+                      :pre,
+                      :progress,
+                      :rp,
+                      :rt,
+                      :ruby,
+                      :samp,
+                      :section,
+                      :small,
+                      :strong,
+                      :style,
+                      :sub,
+                      :summary,
+                      :sup,
+                      :time,
+                      :title,
+                      :track,
+                      :var,
+                      :wbr]
+
+
+    ADVANCED_ELEMENTS = [:text_field,
+                         :hidden_field,
+                         :text_area,
+                         :select_list,
+                         :link,
+                         :checkbox,
+                         :radio_button,
+                         :button,
+                         :div,
+                         :span,
+                         :table,
+                         :cell,
+                         :image,
+                         :form,
+                         :list_item,
+                         :ordered_list,
+                         :unordered_list,
+                         :h1,
+                         :h2,
+                         :h3,
+                         :h4,
+                         :h5,
+                         :h6,
+                         :paragraph,
+                         :label,
+                         :file_field,
+                         :area,
+                         :canvas,
+                         :audio,
+                         :video,
+                         :b,
+                         :svg]
+
+    def self.generate_locators(target)
+      ADVANCED_ELEMENTS.each do |tag|
+        target.send(:define_method, "#{tag.to_s}_element") do |*identifier|
+          @platform.send "#{tag.to_s}_for", locator(identifier)
+        end
+
+        target.send(:define_method, "#{tag.to_s}_elements") do |*identifier|
+          @platform.send("#{tag.to_s}s_for", identifier[0] ? identifier[0] : {})
+        end
+      end
+
+      BASIC_ELEMENTS.each do |tag|
+        target.send(:define_method, "#{tag.to_s}_element") do |*identifier|
+          @platform.send :element_for, tag, locator(identifier)
+        end
+
+        target.send(:define_method, "#{tag.to_s}_elements") do |*identifier|
+          @platform.send(:elements_for, tag, identifier[0] ? identifier[0] : {})
+        end
+      end
+    end
+
+  end
+end

data/lib/page-object/nested_elements.rb

@@ -0,0 +1,17 @@
+require 'page-object/locator_generator'
+
+module PageObject
+  module NestedElements
+
+    def self.included(cls)
+      ::PageObject::LocatorGenerator.generate_locators(cls)
+    end
+
+    private
+
+    def locator(identifier)
+      identifier[0] ? identifier[0] : {:index => 0}
+    end
+    
+  end
+end

data/lib/page-object/page_factory.rb

@@ -0,0 +1,108 @@
+require 'page_navigation'
+
+module PageObject
+  #
+  # Module to facilitate to creating of page objects in step definitions.  You
+  # can make the methods below available to all of your step definitions by adding
+  # this module to World.  This idea was first discussed in Alister Scott's blog
+  # entry http://watirmelon.com/2011/06/07/removing-local-page-references-from-cucumber-steps/.
+  #
+  # @example Making the PageFactory available to your step definitions
+  #   World PageObject::PageFactory
+  #
+  # @example Visiting a page for the first time in a Scenario
+  #   visit_page MyPageObject do |page|
+  #     page.name = 'Cheezy'
+  #   end
+  #
+  # @example using a page that has already been visited in a Scenario
+  #   on_page MyPageObject do |page|
+  #     page.name.should == 'Cheezy'
+  #   end
+  #
+  # If you plan to use the navigate_to method you will need to ensure
+  # you setup the possible routes ahead of time.  You must always have
+  # a default route in order for this to work.  Here is an example of
+  # how you define routes:
+  #
+  # @example Example routes defined in env.rb
+  #   PageObject::PageFactory.routes = {
+  #     :default => [[PageOne,:method1], [PageTwoA,:method2], [PageThree,:method3]],
+  #     :another_route => [[PageOne,:method1, "arg1"], [PageTwoB,:method2b], [PageThree,:method3]]
+  #   }
+  #
+  # Notice the first entry of :another_route is passing an argument
+  # to the method.
+  #
+  module PageFactory
+    include PageNavigation
+
+
+    #
+    # Create and navigate to a page object.  The navigation will only work if the
+    # 'page_url' method was call on the page object.
+    #
+    # @param [PageObject, String] a class that has included the
+    # PageObject module or a string containing the name of the class
+    # @param Hash values that is pass through to page class a
+    # available in the @params instance variable.
+    # @param an optional block to be called
+    # @return [PageObject] the newly created page object
+    #
+    def visit_page(page_class, params={:using_params => {}}, &block)
+      on_page page_class, params, true, &block
+    end
+
+    # Support 'visit' for readability of usage
+    alias_method :visit, :visit_page
+
+    #
+    # Create a page object.
+    #
+    # @param [PageObject, String]  a class that has included the PageObject module or a string containing the name of the class
+    # @param Hash values that is pass through to page class a
+    # available in the @params instance variable.
+    # @param [Boolean]  a boolean indicating if the page should be visited?  default is false.
+    # @param [block]  an optional block to be called
+    # @return [PageObject] the newly created page object
+    #
+    def on_page(page_class, params={:using_params => {}}, visit=false, &block)
+      page_class = class_from_string(page_class) if page_class.is_a? String
+      return super(page_class, params, visit, &block) unless page_class.ancestors.include? PageObject
+      merged = page_class.params.merge(params[:using_params])
+      page_class.instance_variable_set("@merged_params", merged) unless merged.empty?
+      @current_page = page_class.new(@browser, visit)
+      block.call @current_page if block
+      @current_page
+    end
+
+    # Support 'on' for readability of usage
+    alias_method :on, :on_page
+    
+    #
+    # Create a page object if and only if the current page is the same page to be created
+    #
+    # @param [PageObject, String]  a class that has included the PageObject module or a string containing the name of the class
+    # @param Hash values that is pass through to page class a
+    # available in the @params instance variable.
+    # @param [block]  an optional block to be called
+    # @return [PageObject] the newly created page object
+    #
+    def if_page(page_class, params={:using_params => {}},&block)
+      page_class = class_from_string(page_class) if page_class.is_a? String
+      return @current_page unless @current_page.class == page_class
+      on_page(page_class, params, false, &block)
+    end
+
+    # Support 'if' for readability of usage
+    alias_method :if, :if_page
+
+    private
+    
+    def class_from_string(str)
+      str.split('::').inject(Object) do |mod, class_name|
+        mod.const_get(class_name)
+      end
+    end
+  end
+end

data/lib/page-object/page_populator.rb

@@ -0,0 +1,83 @@
+module PageObject
+  module PagePopulator
+
+    #
+    # This method will populate all matched page TextFields,
+    # TextAreas, SelectLists, FileFields, Checkboxes, and Radio Buttons from the
+    # Hash passed as an argument.  The way it find an element is by
+    # matching the Hash key to the name you provided when declaring
+    # the element on your page.
+    #
+    # Checkboxe and Radio Button values must be true or false.
+    #
+    # @example
+    #   class ExamplePage
+    #     include PageObject
+    #
+    #     text_field(:username, :id => 'username_id')
+    #     checkbox(:active, :id => 'active_id')
+    #   end
+    #
+    #   ...
+    #
+    #   @browser = Watir::Browser.new :firefox
+    #   example_page = ExamplePage.new(@browser)
+    #   example_page.populate_page_with :username => 'a name', :active => true
+    #
+    # @param [Hash] the data to use to populate this page.  The key
+    # can be either a string or a symbol.  The value must be a string
+    # for TextField, TextArea, SelectList, and FileField and must be true or
+    # false for a Checkbox or RadioButton.
+    #
+    def populate_page_with(data)
+      data.each do |key, value|
+        populate_checkbox(key, value) if is_checkbox?(key) and is_enabled?(key)
+        populate_radiobuttongroup(key, value) if is_radiobuttongroup?(key)
+        populate_radiobutton(key, value) if is_radiobutton?(key) and is_enabled?(key)
+        populate_text(key, value) if is_text?(key) and is_enabled?(key)
+      end
+    end
+
+    private
+    
+    def populate_text(key, value)
+      self.send "#{key}=", value
+    end
+
+    def populate_checkbox(key, value)
+      return self.send "check_#{key}" if value
+      return self.send "uncheck_#{key}"
+    end
+
+    def populate_radiobutton(key, value)
+      return self.send "select_#{key}" if value
+    end
+
+    def populate_radiobuttongroup(key, value)
+      return self.send("select_#{key}", value)
+    end
+
+    def is_text?(key)
+      respond_to?("#{key}=".to_sym)
+    end
+
+    def is_checkbox?(key)
+      respond_to?("check_#{key}".to_sym)
+    end
+
+    def is_radiobutton?(key)
+      respond_to?("select_#{key}".to_sym)
+    end
+
+    def is_radiobuttongroup?(key)
+      respond_to?("select_#{key}".to_sym) and respond_to?("#{key}_values")
+    end
+
+    def is_enabled?(key)
+      return false if is_radiobuttongroup?(key)
+      return true if (self.send "#{key}_element").tag_name == "textarea"
+      element = self.send("#{key}_element")
+      element.enabled? and element.visible?
+    end
+  end
+end

data/lib/page-object/platforms.rb

@@ -0,0 +1,19 @@
+require 'page-object/loads_platform'
+
+module PageObject
+  module Platforms
+    @@adapters = {}
+
+    def self.get
+      @@adapters
+    end
+
+    def self.register(key, adapter)
+      @@adapters[key] = adapter
+    end
+  end
+end
+require 'page-object/platforms/watir_webdriver'
+require 'page-object/platforms/lds_watir_webdriver'
+require 'page-object/platforms/selenium_webdriver'
+

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

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

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

@@ -0,0 +1,29 @@
+module PageObject
+  module Platforms
+    module LdsWatirWebDriver
+      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/lds_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 LdsWatirWebDriver
+      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 => :lds_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