druid-s 1.0.0

data/lib/druid/elements/canvas.rb

@@ -0,0 +1,9 @@
+module Druid
+  module Elements
+    class Canvas < Element
+      
+    end
+
+    Druid::Elements.type_to_class[:canvas] = Druid::Elements::Canvas
+  end
+end

data/lib/druid/elements/check_box.rb

@@ -0,0 +1,9 @@
+module Druid
+  module Elements
+    class CheckBox < Element
+
+    end
+
+    Druid::Elements.type_to_class[:checkbox] = Druid::Elements::CheckBox
+  end
+end

data/lib/druid/elements/div.rb

@@ -0,0 +1,9 @@
+module Druid
+  module Elements
+    class Div < Element
+
+    end
+
+    Druid::Elements.tag_to_class[:div] = Druid::Elements::Div
+  end
+end

data/lib/druid/elements/element.rb

@@ -0,0 +1,187 @@
+require 'druid/nested_elements'
+require 'druid/assist'
+module Druid
+  module Elements
+    #
+    # Contains functionality that is common across all elements
+    #
+    class Element
+      include Druid::NestedElements
+      include Druid::Assist
+
+      attr_accessor :element
+      attr_accessor :driver
+
+      def initialize(element)
+        @element = element
+        @driver = @element
+      end
+
+      #
+      # return true if the element is not enabled
+      def disabled?
+        not enabled?
+      end
+
+      # 
+      # return true if the element exists and is visible
+      #
+      def present?
+        element.present?
+      end
+
+      #
+      # compare this element to another to determine if they are equal
+      # @return [Boolean]
+      #
+      def ==(other)
+        other.is_a? self.class and element == other.element
+      end
+
+      def check_visible(timeout=Druid.default_element_wait)
+        timed_loop(timeout) do |element|
+          element.present?
+        end
+        # wait_until(timeout: timeout, message: "Element not visible in #{timeout} seconds", &:present?)
+      end
+      # alias_method :when_present, :check_visible
+      # alias_method :when_visible, :check_visible
+
+      def check_exist(timeout=Druid.default_element_wait)
+        timed_loop(timeout) do |element|
+          element.exists?
+        end
+        # wait_until(timeout: timeout, &:exist?)
+      end
+
+      #
+      # find the parent element
+      #
+      def parent(opt = {})
+        parent = element.parent(opt)
+        druid_wrapper(parent)
+      end
+
+      #
+      # Return the element that exists at the same level of the DOM
+      # immediately prior to this element
+      #
+      def preceding_sibling(opt = {})
+        sibling = element.preceding_sibling(opt)
+        druid_wrapper(sibling)
+      end
+
+      #
+      # Return the element that exists at the same level of the DOM
+      # immediately after this element
+      #
+      def following_sibling(opt={})
+        sibling = element.following_sibling(opt)
+        druid_wrapper(sibling)
+      end
+
+      #
+      # Return all elements that are direct children of this element's parent
+      #
+      def siblings(opt={})
+        siblings = element.siblings(opt)
+        siblings.collect {|sibling| druid_wrapper(sibling)}
+      end
+
+      #
+      # Return all elements that are children of this element
+      #
+      def children(opt={})
+        children = element.children(opt)
+        children.collect {|child| druid_wrapper(child)}
+      end
+
+      #
+      # Return all elements that exist at the same level of the DOM
+      # immediately prior to this element
+      #
+      def preceding_siblings(opt={})
+        siblings = element.preceding_siblings(opt)
+        siblings.collect {|sibling| druid_wrapper(sibling)}
+      end
+
+      #
+      # Return all elements that exist at the same level of the DOM
+      # immediately after this element
+      #
+      def following_siblings(opt={})
+        siblings = element.following_siblings(opt)
+        siblings.collect {|sibling| druid_wrapper(sibling)}
+      end
+
+      #
+      # Wait until the element is present
+      #
+      # @param [Integer] (defaults to: 5) seconds to wait before timing out
+      #
+      def when_present(timeout=Druid.default_element_wait)
+        element.wait_until(timeout: timeout, message: "Element not present in #{timeout} seconds", &:present?)
+        self
+      end
+      alias_method :when_visible, :when_present
+
+      #
+      # Waits until the element is not present
+      #
+      # @param [Integer] (defaults to: 5) seconds to wait before
+      # timing out
+      #
+      def when_not_present(timeout=Druid.default_element_wait)
+        element.wait_while(timeout: timeout, message: "Element still present in #{timeout} seconds", &:present?)
+      end
+      alias_method :when_not_visible, :when_not_present
+
+      #
+      # 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=Druid.default_element_wait, message=nil, &block)
+        element.wait_until(timeout: timeout, message: message, &block)
+      end
+
+      def name
+        element.attribute(:name)
+      end
+
+      # @private
+      # delegate calls to driver element
+      def method_missing(*args, &block)
+        m = args.shift
+        element.send m, *args, &block
+      end
+
+      def respond_to_missing?(m,*args)
+        element.respond_to?(m) || super
+      end
+
+      protected
+
+      def druid_wrapper(object)
+        type = element.type if object.tag_name.to_sym == :input
+        cls = Druid::Elements.element_class_for(object.tag_name, type)
+        cls.new(object.to_subtype)
+      end
+
+      private
+
+      def timed_loop(timeout)
+        end_time = ::Time.now + timeout
+        until ::Time.now > end_time
+          result = yield(self)
+          return result if result
+          sleep 0.5
+        end
+        false
+      end
+
+    end
+  end
+end

data/lib/druid/elements/file_field.rb

@@ -0,0 +1,9 @@
+module Druid
+  module Elements
+    class FileField < Element
+
+    end
+
+    Druid::Elements.type_to_class[:file] = Druid::Elements::FileField
+  end
+end

data/lib/druid/elements/form.rb

@@ -0,0 +1,9 @@
+module Druid
+  module Elements
+    class Form < Element
+
+    end
+
+    Druid::Elements.tag_to_class[:form] = Druid::Elements::Form
+  end
+end

data/lib/druid/elements/heading.rb

@@ -0,0 +1,14 @@
+module Druid
+  module Elements
+     class Heading < Element
+
+     end
+
+     Druid::Elements.tag_to_class[:h1] = Druid::Elements::Heading
+     Druid::Elements.tag_to_class[:h2] = Druid::Elements::Heading
+     Druid::Elements.tag_to_class[:h3] = Druid::Elements::Heading
+     Druid::Elements.tag_to_class[:h4] = Druid::Elements::Heading
+     Druid::Elements.tag_to_class[:h5] = Druid::Elements::Heading
+     Druid::Elements.tag_to_class[:h6] = Druid::Elements::Heading
+  end
+end

data/lib/druid/elements/hidden_field.rb

@@ -0,0 +1,9 @@
+module Druid
+  module Elements
+    class HiddenField < Element
+
+    end
+
+    Druid::Elements.type_to_class[:hidden] = Druid::Elements::HiddenField
+  end
+end

data/lib/druid/elements/image.rb

@@ -0,0 +1,9 @@
+module Druid
+  module Elements
+    class Image < Element
+
+    end
+
+    Druid::Elements.tag_to_class[:img] = Druid::Elements::Image
+  end
+end

data/lib/druid/elements/italic.rb

@@ -0,0 +1,9 @@
+module Druid
+  module Elements
+    class Italic < Element
+
+    end
+
+    Druid::Elements.tag_to_class[:i] = Druid::Elements::Italic
+  end
+end

data/lib/druid/elements/label.rb

@@ -0,0 +1,8 @@
+module Druid
+  module Elements
+    class Label < Element
+
+      Druid::Elements.tag_to_class[:label] = Druid::Elements::Label
+    end
+  end
+end

data/lib/druid/elements/link.rb

@@ -0,0 +1,9 @@
+module Druid
+  module Elements
+    class Link < Element
+
+    end
+
+    Druid::Elements.tag_to_class[:a] = Druid::Elements::Link
+  end
+end

data/lib/druid/elements/list_item.rb

@@ -0,0 +1,9 @@
+module Druid
+  module Elements
+    class ListItem < Element
+
+    end
+
+    Druid::Elements.tag_to_class[:li] = Druid::Elements::ListItem
+  end
+end

data/lib/druid/elements/media.rb

@@ -0,0 +1,11 @@
+module Druid
+  module Elements
+    class Media < Element
+
+      def has_controls?
+        attribute(:controls)
+      end
+
+    end
+  end
+end

data/lib/druid/elements/option.rb

@@ -0,0 +1,9 @@
+module Druid
+  module Elements
+    class Option < Element
+
+    end
+
+    Druid::Elements.tag_to_class[:option] = Druid::Elements::Option
+  end
+end

data/lib/druid/elements/ordered_list.rb

@@ -0,0 +1,29 @@
+module Druid
+  module Elements
+    class OrderedList < Element
+      attr_accessor :li_element
+
+      def [](idx)
+        list_items[idx]
+      end
+
+      def items
+        list_items.size
+      end
+
+      def each(&block)
+        list_items.each(&block)
+      end
+
+      #
+      # Return Array of ListItem objects that are children of the OrderedList
+      #
+      def list_items
+        @list_items ||= children(tag_name: 'li')
+      end
+
+    end
+
+    Druid::Elements.tag_to_class[:ol] = Druid::Elements::OrderedList
+  end
+end

data/lib/druid/elements/paragraph.rb

@@ -0,0 +1,9 @@
+module Druid
+  module Elements
+    class Paragraph < Element
+
+    end
+
+    Druid::Elements.tag_to_class[:p] = Druid::Elements::Paragraph
+  end
+end

data/lib/druid/elements/radio_button.rb

@@ -0,0 +1,9 @@
+module Druid
+  module Elements
+    class RadioButton < Element
+
+    end
+
+    Druid::Elements.type_to_class[:radio] = Druid::Elements::RadioButton
+  end
+end

data/lib/druid/elements/select_list.rb

@@ -0,0 +1,30 @@
+module Druid
+  module Elements
+    class SelectList < Element
+
+      def [](idx)
+        options[idx]
+      end
+
+      def options
+        element.options.map { |e| Druid::Elements::Option.new(e)}
+      end
+
+      #
+      # @return [Array<String>] An array of strings representing the text of the currently selected options.
+      #
+      def selected_options
+        element.selected_options.map(&:text).compact
+      end
+
+      #
+      # @return [Array<String>] An array of strings representing the value of the currently selected options.
+      def selected_values
+        element.selected_options.map(&:value).compact
+      end
+
+    end
+
+    Druid::Elements.tag_to_class[:select] = Druid::Elements::SelectList
+  end
+end

data/lib/druid/elements/span.rb

@@ -0,0 +1,9 @@
+module Druid
+  module Elements
+    class Span < Element
+
+    end
+
+    Druid::Elements.tag_to_class[:span] = Druid::Elements::Span
+  end
+end

data/lib/druid/elements/table.rb

@@ -0,0 +1,92 @@
+module Druid
+  module Elements
+    class Table < Element
+      #
+      # Return the Druid::Elements::Table 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 [Druid::Elements::TableRow]
+      #
+      def [](what)
+        idx = find_index(what)
+        idx && row_items[idx]
+      end
+
+      #
+      # Returns the number of rows in the table.
+      #
+      def rows
+        row_items.size
+      end
+
+      #
+      # iterator that yields with a Druid::Elements::TableRow
+      #
+      # @return [Druid::Elements::TableRow]
+      #
+      def each(&block)
+        row_items.each(&block)
+      end
+
+      #
+      # return the first row
+      #
+      # @return Druid::Elements::TableRow
+      #
+      def first_row
+        self[0]
+      end
+
+      #
+      # return the last row
+      #
+      # @return Druid::Elements::TableRow
+      #
+      def last_row
+        self[-1]
+      end
+
+      #
+      # Returns the Array of values(String) in a column 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 header. The text can be a substring of the full header text
+      #
+      def column_values(what)
+        idx = find_index_of_header(what)
+        idx && row_items.drop(1).collect{ |row| row.cell(index: idx).text }
+      end
+
+      private
+
+      def row_items
+        meth = stragegy == :descendants ? :trs : :rows
+        @row_items ||= element.send(meth).map do |obj|
+          Druid::Elements::TableRow.new(obj)
+        end
+      end
+
+      def stragegy
+        :children
+      end
+
+      def find_index_of_header(what)
+        return what if what.is_a? Integer
+        row_items[0].cells.find_index do |cell|
+          cell.text.include? Regexp.escape(what)
+        end
+      end
+
+      def find_index(what)
+        return what if what.is_a? Integer
+        row_items.find_index do |row|
+          row.cell(text: /#{Regexp.escape(what)}/).exist?
+        end
+      end
+
+    end
+
+    Druid::Elements.tag_to_class[:table] = Druid::Elements::Table
+  end
+end

data/lib/druid/elements/table_cell.rb

@@ -0,0 +1,11 @@
+module Druid
+  module Elements
+    class TableCell < Element
+
+    end
+
+    Druid::Elements.tag_to_class[:td] = Druid::Elements::TableCell
+    Druid::Elements.tag_to_class[:th] = Druid::Elements::TableCell
+
+  end
+end

data/lib/druid/elements/table_row.rb

@@ -0,0 +1,50 @@
+require 'watir/elements/html_elements'
+module Druid
+  module Elements
+    class TableRow < Element
+
+      #
+      # Return the Druid::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.
+      #
+      def [](what)
+        idx = find_index(what)
+        idx && cell_items[idx]
+      end
+
+      #
+      # Returns the number of colums in the table
+      #
+      def columns
+        cell_items.size
+      end
+
+      #
+      # iterator that yields with a Druid::Elements::TableCell
+      #
+      def each(&block)
+        cell_items.each(&block)
+      end
+
+      private
+
+      def cell_items
+        @cell_items ||= element.cells.map do |obj|
+          Druid::Elements::TableCell.new(obj)
+        end
+      end
+
+      def find_index(what)
+        return what if what.is_a? Integer
+        parent(tag_name: 'table').headers.find_index do |header|
+          header.text.include? what
+        end
+      end
+
+    end
+
+    Druid::Elements.tag_to_class[:tr] = Druid::Elements::TableRow
+
+  end
+end

data/lib/druid/elements/text_area.rb

@@ -0,0 +1,10 @@
+module Druid
+  module Elements
+    class TextArea < Element
+
+    end
+
+    Druid::Elements.tag_to_class[:textarea] = Druid::Elements::TextArea
+
+  end
+end

data/lib/druid/elements/text_field.rb

@@ -0,0 +1,11 @@
+module Druid
+  module Elements
+    class TextField < Element
+
+    end
+
+    Druid::Elements.type_to_class[:text] = Druid::Elements::TextField
+    Druid::Elements.type_to_class[:password] = Druid::Elements::TextField
+
+  end
+end

data/lib/druid/elements/unordered_list.rb

@@ -0,0 +1,32 @@
+module Druid
+  module Elements
+    class UnOrderedList < Element
+
+      #
+      # @return [Druid::Elements::ListItem]
+      #
+      def [](idx)
+        list_items[idx]
+      end
+
+      def items
+        list_items.size
+      end
+
+      def each(&block)
+        list_items.each(&block)
+      end
+
+      #
+      # Return Array of ListItem objects that are children of the UnorderedList
+      #
+      def list_items
+        @list_items ||= children(tag_name: 'li')
+      end
+
+    end
+
+    Druid::Elements.tag_to_class[:ul] = Druid::Elements::UnOrderedList
+
+  end
+end

data/lib/druid/elements/video.rb

@@ -0,0 +1,8 @@
+module Druid
+  module Elements
+    class Video < Media
+
+    end
+    Druid::Elements.type_to_class[:video] = Druid::Elements::Video
+  end
+end