celerity_thingista 0.9.2

data/lib/celerity/exception.rb

@@ -0,0 +1,83 @@
+module Celerity
+  module Exception
+
+    #
+    # Superclass for all Celerity exceptions.
+    #
+
+    class CelerityException < StandardError; end
+
+    #
+    # This exception is thrown if an attempt is made to access an object that doesn't exist
+    #
+
+    class UnknownObjectException < CelerityException; end
+
+    #
+    # This exception is thrown if an attempt is made to access an object that is in a disabled state
+    #
+
+    class ObjectDisabledException < CelerityException; end
+
+    #
+    # This exception is thrown if an attempt is made to access a frame that cannot be found
+    #
+
+    class UnknownFrameException < CelerityException; end
+
+    #
+    # This exception is thrown if an attempt is made to access a form that cannot be found
+    #
+
+    class UnknownFormException < CelerityException; end
+
+    #
+    # This exception is thrown if an attempt is made to access an object that is in a read-only state
+    #
+
+    class ObjectReadOnlyException < CelerityException; end
+
+    #
+    # This exception is thrown if an attempt is made to access an object when the specified value cannot be found
+    #
+
+    class NoValueFoundException < CelerityException; end
+
+    #
+    # This exception gets raised if the how argument is wrong.
+    #
+
+    class MissingWayOfFindingObjectException < CelerityException; end
+
+    #
+    # This exception is raised if an attempt is made to access a table row that doesn't exist
+    #
+
+    class UnknownRowException < CelerityException; end
+
+    #
+    # This exception is raised if an attempt is made to access a table cell that doesn't exist
+    #
+
+    class UnknownCellException < CelerityException; end
+
+    #
+    # This exception is thrown if an http error, such as a 404, 500 etc is encountered while navigating
+    #
+
+    class NavigationException < CelerityException; end
+
+    #
+    # This exception is thrown if an unexpected content type is returned by the server.
+    #
+
+    class UnexpectedPageException < CelerityException; end
+
+    #
+    # This exception is thrown if an unexpected content type is returned by the server.
+    #
+
+    class CookieNotFoundError < CelerityException; end
+
+  end # Exception
+end # Celerity

data/lib/celerity/htmlunit.rb

@@ -0,0 +1,64 @@
+module Celerity
+  Jars = Dir[File.dirname(__FILE__) + '/htmlunit/*.jar']
+  Jars.each { |jar| require(jar) }
+
+  module JsxHelper
+    def method_missing(meth, *args, &blk)
+      m = ["jsxGet_#{meth}", "jsx_get_#{meth}"].find { |m| respond_to?(m) }
+      m ? __send__(m) : super
+    end
+  end
+end
+
+module HtmlUnit
+  include_package 'com.gargoylesoftware.htmlunit'
+
+  module Html
+    include_package 'com.gargoylesoftware.htmlunit.html'
+  end
+
+  module Util
+    include_package 'com.gargoylesoftware.htmlunit.util'
+  end
+
+end
+
+module Java::OrgW3cDom::NamedNodeMap
+  include Enumerable
+
+  def each
+    0.upto(getLength - 1) do |idx|
+      yield item(idx)
+    end
+  end
+end
+
+module Java::JavaLang::Iterable
+  include Enumerable
+
+  def each
+    it = iterator
+    yield it.next while it.hasNext
+  end
+
+end unless Java::JavaLang::Iterable < Enumerable # depends on JRuby version
+
+class Java::ComGargoylesoftwareHtmlunitHtml::HtmlPage
+  def inspect
+    '#<HtmlPage:0x%s(%s)>' % [self.hash.to_s(16), getWebResponse.getWebRequest.getUrl.toString]
+  end
+end
+
+class Java::ComGargoylesoftwareHtmlunitHtml::HtmlElement
+  def inspect
+    '#<%s:0x%s>' % [self.class.name.split("::").last, self.hash.to_s(16)]
+  end
+end
+
+class Java::ComGargoylesoftwareHtmlunitJavascriptHostHtml::HTMLElement
+  include Celerity::JsxHelper
+end
+
+class Java::ComGargoylesoftwareHtmlunitJavascriptHostCss::CSSStyleDeclaration
+  include Celerity::JsxHelper
+end

data/lib/celerity/identifier.rb

@@ -0,0 +1,28 @@
+module Celerity
+
+  class Identifier
+    attr_accessor :text
+    attr_reader :tag, :attributes
+
+    def initialize(tag, attributes = {})
+      @tag        = tag
+      @attributes = attributes
+      @text       = nil
+    end
+
+    def match?(element)
+      return false unless @tag == element.getTagName
+
+      attr_result = @attributes.all? do |key, values|
+        values.any? { |val| Util.matches?(element.getAttribute(key.to_s), val) }
+      end
+
+      if @text
+        attr_result && Util.matches?(element.asText.strip, @text)
+      else
+        attr_result
+      end
+    end
+  end
+
+end

data/lib/celerity/ignoring_web_connection.rb

@@ -0,0 +1,15 @@
+module Celerity
+  class IgnoringWebConnection < HtmlUnit::Util::FalsifyingWebConnection
+
+    def initialize(web_client, pattern)
+      super(web_client)
+      @pattern = pattern
+    end
+
+    def getResponse(request_settings)
+      return super unless request_settings.getUrl.toString =~ @pattern
+      createWebResponse(request_settings, "", "text/html")
+    end
+
+  end
+end

data/lib/celerity/input_element.rb

@@ -0,0 +1,25 @@
+module Celerity
+  class InputElement < Element
+    include ClickableElement
+    include DisabledElement
+
+    ATTRIBUTES = BASE_ATTRIBUTES | [:type, :name, :value, :checked, :disabled, :readonly, :size, :maxlength,
+                                    :src, :alt, :usemap, :ismap, :tabindex, :accesskey, :onfocus, :onblur,
+                                    :onselect, :onchange, :accept, :align]
+
+    def readonly?
+      assert_exists
+      @object.hasAttribute 'readonly'
+    end
+
+    private
+
+    def assert_not_readonly
+      if readonly?
+        raise ObjectReadOnlyException,
+          "InputElement #{identifier_string} is read only."
+      end
+    end
+
+  end
+end

data/lib/celerity/javascript_debugger.rb

@@ -0,0 +1,32 @@
+module Celerity
+  class JavascriptDebugger
+    include Java::net.sourceforge.htmlunit.corejs.javascript.debug.Debugger
+
+    def handleCompilationDone(ctx, script, source)
+      p debug_info_for(script).merge(:source_code => source)
+    end
+
+    def getFrame(ctx, script)
+      p debug_info_for(script)
+    end
+
+    private
+
+    def string_for_context(ctx)
+      ctx.toString
+    end
+
+    def string_for_script(script)
+      script.toString
+    end
+
+    def debug_info_for(script)
+      {
+        :source        => "#{script.getSourceName}:#{script.getLineNumbers.to_a.join(",")}",
+        :function_name => script.getFunctionName,
+        :params        => (0...script.getParamAndVarCount).map { |idx| script.getParamOrVarName(idx) },
+        :function?     => script.isFunction,
+      }
+    end
+  end
+end

data/lib/celerity/listener.rb

@@ -0,0 +1,143 @@
+module Celerity
+
+  #
+  # This class is used to wrap some of the listeners available from HtmlUnit's WebClient.
+  #
+
+  class Listener
+    include com.gargoylesoftware.htmlunit.AlertHandler
+    include com.gargoylesoftware.htmlunit.ConfirmHandler
+    include com.gargoylesoftware.htmlunit.PromptHandler
+    include com.gargoylesoftware.htmlunit.html.HTMLParserListener
+    include com.gargoylesoftware.htmlunit.IncorrectnessListener
+    include com.gargoylesoftware.htmlunit.StatusHandler
+    include com.gargoylesoftware.htmlunit.WebWindowListener
+    include com.gargoylesoftware.htmlunit.attachment.AttachmentHandler
+
+    def initialize(webclient)
+      @webclient = webclient
+      @procs = Hash.new { |h, k| h[k] = [] }
+    end
+
+    #
+    # Add a listener block for one of the available types.
+    # @see Celerity::Browser#add_listener
+    #
+
+    def add_listener(type, &block)
+      case type
+      when :status
+        @webclient.setStatusHandler(self)
+      when :alert
+        @webclient.setAlertHandler(self)
+      when :attachment
+        @webclient.setAttachmentHandler(self)
+      when :web_window_event
+        @webclient.addWebWindowListener(self)
+      when :html_parser
+        @webclient.setHTMLParserListener(self)
+      when :incorrectness
+        @webclient.setIncorrectnessListener(self)
+      when :confirm
+        @webclient.setConfirmHandler(self)
+      when :prompt
+        @webclient.setPromptHandler(self)
+      else
+        raise ArgumentError, "unknown listener type #{type.inspect}"
+      end
+
+      @procs[type] << block
+    end
+
+    def remove_listener(type, proc_or_index)
+      unless @procs.has_key?(type)
+        raise ArgumentError, "unknown listener type #{type.inspect}"
+      end
+
+      procs = @procs[type]
+
+      case proc_or_index
+      when Fixnum
+        procs.delete_at proc_or_index
+      when Proc
+        procs.delete proc_or_index
+      else
+        raise TypeError, "must give proc or index"
+      end
+    end
+
+    #
+    # interface StatusHandler
+    #
+
+    def statusMessageChanged(page, message)
+      @procs[:status].each { |handler| handler.call(page, message) }
+    end
+
+    #
+    # interface AlertHandler
+    #
+
+    def handleAlert(page, message)
+      @procs[:alert].each { |handler| handler.call(page, message) }
+    end
+
+    #
+    # interface ConfirmHandler
+    #
+    # The returned value is determined by the last registered :confirm listener proc.
+    # If it is nil, return true, otherwise return that value as a boolean.
+    #
+    # @see Browser#confirm
+    #
+
+    def handleConfirm(page, message)
+      val = @procs[:confirm].map { |handler| handler.call(page, message) }.last
+      val.nil? || !!val
+    end
+
+    #
+    # interface AttachmentHandler
+    #
+
+    def handleAttachment(page)
+      @procs[:attachment].each { |handler| handler.call(page) }
+    end
+
+    #
+    # interface PromptHandler
+    #
+
+    def handlePrompt(page, message)
+      @procs[:prompt].each { |handler| handler.call(page, message) }
+    end
+
+    #
+    # interface WebWindowListener
+    #
+
+    def webWindowClosed(web_window_event)
+      @procs[:web_window_event].each { |handler| handler.call(web_window_event) }
+    end
+    alias_method :webWindowOpened, :webWindowClosed
+    alias_method :webWindowContentChanged, :webWindowClosed
+
+    #
+    # interface HTMLParserListener
+    #
+
+    def error(message, url, line, column, key)
+      @procs[:html_parser].each { |handler| handler.call(message, url, line, column, key) }
+    end
+    alias_method :warning, :error
+
+    #
+    # interface IncorrectnessListener
+    #
+
+    def notify(message, origin)
+      @procs[:incorrectness].each { |handler| handler.call(message, origin) }
+    end
+
+  end # Listener
+end # Celerity