walidhalabi-celerity 0.0.6.11

data/lib/celerity/clickable_element.rb

@@ -0,0 +1,69 @@
+module Celerity
+  module ClickableElement
+
+    #
+    # click the element
+    #
+
+    def click
+      assert_exists_and_enabled
+      rescue_status_code_exception { @container.update_page(@object.click) }
+    end
+
+    #
+    # double click the element (Celerity only)
+    #
+
+    def double_click
+      assert_exists_and_enabled
+      rescue_status_code_exception { @container.update_page(@object.dblClick) }
+    end
+
+    #
+    # right click the element (Celerity only)
+    #
+
+    def right_click
+      assert_exists_and_enabled
+      rescue_status_code_exception { @container.update_page(@object.rightClick) }
+    end
+
+    #
+    # Click the element and return a new Browser instance with the resulting page.
+    # This is useful for elements that trigger popups when clicked.
+    #
+    # @return [Celerity::Browser]
+    #
+
+    def click_and_attach
+      assert_exists_and_enabled
+      browser = Browser.new(@browser.options.dup)
+      browser.webclient.set_cookie_manager(
+        @browser.webclient.get_cookie_manager
+      ) # hirobumi: we do want cookies as well.
+
+      rescue_status_code_exception { browser.update_page(@object.click) }
+
+      browser
+    end
+
+    #
+    # Click the element and just return the content as IO. Current page stays unchanged.
+    # This can be used to download content that normally isn't rendered in a browser.
+    #
+    # @return [IO]
+    #
+
+    def download
+      assert_exists_and_enabled
+      @object.click.getWebResponse.getContentAsStream.to_io
+    end
+
+    private
+
+    def assert_exists_and_enabled
+      assert_exists
+      assert_enabled if respond_to?(:assert_enabled)
+    end
+  end
+end

data/lib/celerity/collections.rb

@@ -0,0 +1,156 @@
+module Celerity
+
+ class Frames < ElementCollection
+    def element_class; Frame; end
+  end
+
+ class Buttons < ElementCollection
+    def element_class; Button; end
+  end
+
+  class FileFields < ElementCollection
+    def element_class; FileField; end
+  end
+
+  class CheckBoxes < ElementCollection
+    def element_class; CheckBox; end
+  end
+
+  class Radios < ElementCollection
+    def element_class; Radio; end
+  end
+
+  class SelectLists < ElementCollection
+    def element_class; SelectList; end
+  end
+
+  class Links < ElementCollection
+    def element_class; Link; end
+  end
+
+  class Uls < ElementCollection
+    def element_class; Ul; end
+  end
+
+  class Ols < ElementCollection
+    def element_class; Ol; end
+  end
+
+  class Lis < ElementCollection
+    def element_class; Li; end
+  end
+
+  class Dds < ElementCollection
+    def element_class; Dd; end
+  end
+
+  class Dls < ElementCollection
+    def element_class; Dl; end
+  end
+
+  class Dts < ElementCollection
+    def element_class; Dt; end
+  end
+
+  class Ems < ElementCollection
+    def element_class; Em; end
+  end
+
+  class Maps < ElementCollection
+    def element_class; Map; end
+  end
+
+  class Areas < ElementCollection
+    def element_class; Area; end
+  end
+
+  class Images < ElementCollection
+    def element_class; Image; end
+  end
+
+  class TextFields < ElementCollection
+    def element_class; TextField; end
+  end
+
+  class Hiddens < ElementCollection
+    def element_class; Hidden; end
+  end
+
+  class Tables < ElementCollection
+    def element_class; Table; end
+  end
+
+  class TableHeaders < ElementCollection
+    def element_class; TableHeader; end
+  end
+  class TableBodies < ElementCollection
+    def element_class; TableBody; end
+  end
+  class TableFooters < ElementCollection
+    def element_class; TableFooter; end
+  end
+
+  class TableRows < ElementCollection
+    def element_class; TableRow; end
+  end
+
+  class TableCells < ElementCollection
+    def element_class; TableCell; end
+  end
+
+  class Labels < ElementCollection
+    def element_class; Label; end
+  end
+
+  class Pres < ElementCollection
+    def element_class; Pre; end
+  end
+
+  class Ps < ElementCollection
+    def element_class; P; end
+  end
+
+  class Spans < ElementCollection
+    def element_class; Span; end
+  end
+
+  class Strongs < ElementCollection
+    def element_class; Strong; end
+  end
+
+  class Divs < ElementCollection
+    def element_class; Div; end
+  end
+
+  class Forms < ElementCollection
+    def element_class; Form; end
+  end
+
+  class Options < ElementCollection
+    def element_class; Option; end
+  end
+
+  class Metas < ElementCollection
+    def element_class; Meta; end
+  end
+
+  class H1s < ElementCollection
+    def element_class; H1; end
+  end
+  class H2s < ElementCollection
+    def element_class; H2; end
+  end
+  class H3s < ElementCollection
+    def element_class; H3; end
+  end
+  class H4s < ElementCollection
+    def element_class; H4; end
+  end
+  class H5s < ElementCollection
+    def element_class; H5; end
+  end
+  class H6s < ElementCollection
+    def element_class; H6; end
+  end
+
+end

data/lib/celerity/container.rb

@@ -0,0 +1,788 @@
+module Celerity
+
+  #
+  # This class contains methods for accessing elements inside a container,
+  # usually the Browser object, meaning the current page.
+  # The most common syntax is
+  #   browser.elem(:attribute, 'value')
+  #
+  # Note that the element is located lazily, so no exceptions will be raised
+  # if the element doesn't exist until you call a method on the resulting object.
+  # To do this you would normally use Element#exists? or an action method,
+  # like ClickableElement#click.
+  # You can also pass in a hash:
+  #
+  #   browser.link(:index => 1).click
+  #
+  # All elements support multiple attributes identification using the
+  # hash syntax (though this might not always be compatible with Watir):
+  #
+  #   browser.span(:class_name => 'product', :index => 5).text
+  #
+  # Checkboxes and radio buttons support a special three-argument syntax:
+  #
+  #   browser.check_box(:name, 'a_name', '1234').set
+  #
+  # You can also get all the elements of a certain type by using the plural form (@see Celerity::ElementCollection):
+  #
+  #   browser.links # => #<Celerity::Links:0x7a1c2da2 ...>
+  #
+
+  module Container
+    include Celerity::Exception
+    include Celerity::ShortInspect
+
+    # Points back to the Browser instance that contains this element
+    attr_reader :browser
+
+    #
+    # Check if the element contains the given text.
+    #
+    # @param  [String, Regexp] expected_text The text to look for.
+    # @return [Fixnum, nil]  The index of the matched text, or nil if it doesn't match.
+    #
+
+    def contains_text(expected_text)
+      assert_exists
+      return nil unless respond_to? :text
+
+      case expected_text
+      when Regexp
+        text() =~ expected_text
+      when String
+        text().index(expected_text)
+      else
+        raise TypeError, "expected String or Regexp, got #{expected_text.inspect}:#{expected_text.class}"
+      end
+    end
+
+    #
+    # Override inspect for readability
+    #
+
+    def inspect
+      short_inspect :include => %w[@conditions @object]
+    end
+
+    #
+    # Used internally to update the container object.
+    # @api private
+    #
+
+    def container=(container)
+      @container = container
+      @browser = container.browser
+      container
+    end
+
+    #
+    # Used internally to update the page object.
+    # @api private
+    #
+
+    def update_page(page)
+      @browser.page = page
+    end
+
+    #--
+    # below methods sorted alphabetically
+    #++
+
+    #
+    # @return [Celerity::Area]
+    #
+
+    def area(*args)
+      Area.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Areas]
+    #
+
+    def areas
+      Areas.new(self)
+    end
+
+    #
+    # @return [Celerity::Button]
+    #
+
+    def button(*args)
+      Button.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Buttons]
+    #
+
+    def buttons
+      Buttons.new(self)
+    end
+
+    #
+    # @return [Celerity::TableCell]
+    #
+
+    def cell(*args)
+      TableCell.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::TableCells]
+    #
+
+    def cells
+      TableCells.new(self)
+    end
+
+    #
+    # Since finding checkboxes by value is very common, you can use this shorthand:
+    #
+    #   browser.check_box(:name, 'a_name', '1234').set
+    #
+    # or
+    #
+    #   browser.check_box(:name => 'a_name', :value => '1234').set
+    #
+    # @return [Celerity::CheckBox]
+    #
+
+    def check_box(*args)
+      CheckBox.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::CheckBoxes]
+    #
+
+    def checkboxes
+      CheckBoxes.new(self)
+    end
+
+    #
+    # @return [Celerity::Dd]
+    #
+
+    def dd(*args)
+      Dd.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Dds]
+    #
+
+    def dds
+      Dds.new(self)
+    end
+
+    #
+    # @return [Celerity::Div]
+    #
+
+    def div(*args)
+      Div.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Divs]
+    #
+
+    def divs
+      Divs.new(self)
+    end
+
+    #
+    # @return [Celerity::Dl]
+    #
+
+    def dl(*args)
+      Dl.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Dls]
+    #
+
+    def dls
+      Dls.new(self)
+    end
+
+    #
+    # @return [Celerity::Dt]
+    #
+
+    def dt(*args)
+      Dt.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Dts]
+    #
+
+    def dts
+      Dts.new(self)
+    end
+
+    #
+    # @return [Celerity::Em]
+    #
+
+    def em(*args)
+      Em.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Ems]
+    #
+
+    def ems
+      Ems.new(self)
+    end
+
+    #
+    # @return [Celerity::FileField]
+    #
+
+    def file_field(*args)
+      FileField.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::FileFields]
+    #
+
+    def file_fields
+      FileFields.new(self)
+    end
+
+    #
+    # @return [Celerity::Form]
+    #
+
+    def form(*args)
+      Form.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Forms]
+    #
+
+    def forms
+      Forms.new(self)
+    end
+
+    #
+    # @return [Celerity::Frame]
+    #
+
+    def frame(*args)
+      Frame.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Frames]
+    #
+
+    def frames
+      Frames.new(self)
+    end
+
+    #
+    # @return [Celerity::H1]
+    #
+
+    def h1(*args)
+      H1.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::H1s]
+    #
+
+    def h1s
+      H1s.new(self)
+    end
+
+    #
+    # @return [Celerity::H2]
+    #
+
+    def h2(*args)
+      H2.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::H2s]
+    #
+
+    def h2s
+      H2s.new(self)
+    end
+
+    #
+    # @return [Celerity::H3]
+    #
+
+    def h3(*args)
+      H3.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::H3s]
+    #
+
+    def h3s
+      H3s.new(self)
+    end
+
+    #
+    # @return [Celerity::H4]
+    #
+
+    def h4(*args)
+      H4.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::H4s]
+    #
+
+    def h4s
+      H4s.new(self)
+    end
+
+    #
+    # @return [Celerity::H5]
+    #
+
+    def h5(*args)
+      H5.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::H5s]
+    #
+
+    def h5s
+      H5s.new(self)
+    end
+
+    #
+    # @return [Celerity::H6]
+    #
+
+    def h6(*args)
+      H6.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::H6s]
+    #
+
+    def h6s
+      H6s.new(self)
+    end
+
+    #
+    # @return [Celerity::Hidden]
+    #
+
+    def hidden(*args)
+      Hidden.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Hiddens]
+    #
+
+    def hiddens
+      Hiddens.new(self)
+    end
+
+    #
+    # @return [Celerity::Image]
+    #
+
+    def image(*args)
+      Image.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Images]
+    #
+
+    def images
+      Images.new(self)
+    end
+
+    #
+    # @return [Celerity::Label]
+    #
+
+    def label(*args)
+      Label.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Labels]
+    #
+
+    def labels
+      Labels.new(self)
+    end
+
+    #
+    # @return [Celerity::Li]
+    #
+
+    def li(*args)
+      Li.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Lis]
+    #
+
+    def lis
+      Lis.new(self)
+    end
+
+    #
+    # @return [Celerity::Link]
+    #
+
+    def link(*args)
+      Link.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Links]
+    #
+
+    def links
+      Links.new(self)
+    end
+
+    #
+    # @return [Celerity::Map]
+    #
+
+    def map(*args)
+      Map.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Maps]
+    #
+
+    def maps
+      Maps.new(self)
+    end
+
+    #
+    # @return [Celerity::Meta]
+    #
+
+    def meta(*args)
+      Meta.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Metas]
+    #
+
+    def metas(*args)
+      Metas.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Ol]
+    #
+
+    def ol(*args)
+      Ol.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Ols]
+    #
+
+    def ols
+      Ols.new(self)
+    end
+
+    #
+    # @return [Celerity::Option]
+    #
+
+    def option(*args)
+      Option.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::P]
+    #
+
+    def p(*args)
+      P.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Ps]
+    #
+
+    def ps
+      Ps.new(self)
+    end
+
+    #
+    # @return [Celerity::Pre]
+    #
+
+    def pre(*args)
+      Pre.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Pres]
+    #
+
+    def pres
+      Pres.new(self)
+    end
+
+    #
+    # Since finding radios by value is very common, you can use this shorthand:
+    #
+    #   browser.radio(:name, 'a_name', '1234').set
+    #
+    # or
+    #
+    #   browser.radio(:name => 'a_name', :value => '1234').set
+    #
+    # @return [Celerity::Radio]
+    #
+
+    def radio(*args)
+      Radio.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Radios]
+    #
+
+    def radios
+      Radios.new(self)
+    end
+
+    #
+    # @return [Celerity::TableRow]
+    #
+
+    def row(*args)
+      TableRow.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::TableRows]
+    #
+
+    def rows
+      TableRows.new(self)
+    end
+
+    #
+    # @return [Celerity::SelectList]
+    #
+
+    def select_list(*args)
+      SelectList.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::SelectLists]
+    #
+
+    def select_lists
+      SelectLists.new(self)
+    end
+
+    #
+    # @return [Celerity::Span]
+    #
+
+    def span(*args)
+      Span.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Spans]
+    #
+
+    def spans
+      Spans.new(self)
+    end
+
+    #
+    # @return [Celerity::Spans]
+    #
+
+    def strong(*args)
+      Strong.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Strongs]
+    #
+
+    def strongs
+      Strongs.new(self)
+    end
+
+    #
+    # @return [Celerity::Table]
+    #
+
+    def table(*args)
+      Table.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Tables]
+    #
+
+    def tables
+      Tables.new(self)
+    end
+
+    #
+    # @return [Celerity::TableBody]
+    #
+
+    def tbody(*args)
+      TableBody.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::TableBodies]
+    #
+
+    def tbodies
+      TableBodies.new(self)
+    end
+
+    #
+    # @return [Celerity::TextField]
+    #
+
+    def text_field(*args)
+      TextField.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::TextFields]
+    #
+
+    def text_fields
+      TextFields.new(self)
+    end
+
+    #
+    # @return [Celerity::TableFooter]
+    #
+
+    def tfoot(*args)
+      TableFooter.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::TableFooters]
+    #
+
+    def tfoots
+      TableFooters.new(self)
+    end
+    alias_method :tfeet, :tfoots # :-)
+
+    #
+    # Watir's cells() won't find <th> elements.
+    # This is a workaround.
+    #
+    # @return [Celerity::Th]
+    #
+
+    def th(*args)
+      Th.new(self, *args)
+    end
+
+    #
+    # FIXME: implement or change api,
+    # @see th
+    #
+
+    def ths
+      raise NotImplementedError
+    end
+
+    #
+    # @return [Celerity::TableHeader]
+    #
+
+    def thead(*args)
+      TableHeader.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::TableHeaders]
+    #
+
+    def theads
+      TableHeaders.new(self)
+    end
+
+    #
+    # @return [Celerity::Ul]
+    #
+
+    def ul(*args)
+      Ul.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Uls]
+    #
+
+    def uls
+      Uls.new(self)
+    end
+
+    private
+
+    #
+    # Used internally.
+    #
+    # @param [String] string The string to match against.
+    # @param [Regexp, String, #to_s] what The match we're looking for.
+    # @return [Fixnum, true, false, nil]
+    #
+    # @api private
+    #
+
+    def matches?(string, what)
+      Regexp === what ? string =~ what : string == what.to_s
+    end
+
+    #
+    # Rescues HtmlUnit::FailingHttpStatusCodeException and re-raises as
+    # Celerity::NavigationException to avoid the huge JRuby backtrace
+    #
+
+    def rescue_status_code_exception(&blk)
+      yield
+    rescue HtmlUnit::FailingHttpStatusCodeException => e
+      raise NavigationException, e.message, caller
+    end
+
+  end # Container
+end # Celerity