celerity 0.0.1

data/lib/celerity/disabled_element.rb

@@ -0,0 +1,20 @@
+module Celerity
+  module DisabledElement
+    def enabled?
+      !disabled?
+    end
+
+    def disabled?
+      assert_exists
+      @object.isDisabled
+    end
+    alias_method :disabled, :disabled?
+    
+    def assert_enabled
+      if disabled?
+        raise ObjectDisabledException, "Object #{@how.inspect} and #{@what.inspect} is disabled"
+      end
+    end
+    
+  end
+end

data/lib/celerity/element.rb

@@ -0,0 +1,114 @@
+module Celerity
+  class Element
+    include Exception
+    include Container
+    attr_accessor :container, :object
+    
+    # HTML 4.01 Transitional DTD
+    CELLHALIGN_ATTRIBUTES = [:align, :char, :charoff]
+    CELLVALIGN_ATTRIBUTES = [:valign]
+    CORE_ATTRIBUTES = [:class, :id, :style, :title] # Not valid in base, head, html, meta, param, script, style, and title elements.
+    I18N_ATTRIBUTES = [:dir, :lang] # Not valid in base, br, frame, frameset, hr, iframe, param, and script elements.
+    EVENT_ATTRIBUTES = [:onclick, :ondblclick, :onmousedown, :onmouseup, :onmouseover, :onmousemove, :onmouseout, :onkeypress, :onkeydown, :onkeyup]
+    SLOPPY_ATTRIBUTES = [:name, :value]
+    BASE_ATTRIBUTES = CORE_ATTRIBUTES | I18N_ATTRIBUTES | EVENT_ATTRIBUTES | SLOPPY_ATTRIBUTES
+    ATTRIBUTES = BASE_ATTRIBUTES
+    
+    class Identifier < Struct.new(:tag, :attributes)
+      def initialize(t, a={}); super(t, a); end
+    end
+
+    def initialize(container, *args)
+      set_container container
+      process_arguments(*args)
+    end
+    
+    def process_arguments(*args)
+      if args.size == 1 #&& !args.first.kind_of?(Hash) #(support multiple attributes)
+        raise ArgumentError, "wrong number of arguments (1 for 2), DEFAULT_HOW not defined" unless defined? self.class::DEFAULT_HOW
+        raise NotImplementedError if args[0].class == Hash
+        @how = self.class::DEFAULT_HOW
+        @what = args.shift
+      else
+        @how, @what = *args
+      end
+    end
+    
+    def locate
+        @object = @container.locate_tagged_element(self, @how, @what)
+    end
+    
+    def to_s
+      assert_exists
+      create_string(@object)
+    end
+
+    # number of spaces that separate the property from the value in the create_string method
+    TO_S_SIZE = 14
+    
+    def create_string(element)
+      n = []
+      n << "tag:".ljust(TO_S_SIZE) + element.getTagName if element.getTagName.length > 0
+      iterator = element.getAttributeEntriesIterator
+      while (iterator.hasNext)
+        attribute = iterator.next
+        n << "  #{attribute.getName}:".ljust(TO_S_SIZE+2) + attribute.getHtmlValue.to_s
+      end
+      n << "  text:".ljust(TO_S_SIZE+2) + element.asText if element.asText.length > 0
+      return n.join("\n")
+    end
+    
+    def attribute_value(attribute)
+      assert_exists
+      @object.getAttribute(attribute)
+    end
+
+    def assert_exists
+      locate if defined?(locate)
+      unless @object
+        raise UnknownObjectException, "Unable to locate object, using #{@how.inspect} and #{@what.inspect}"
+      end
+    end
+
+    def exists?
+      begin
+        assert_exists
+        true
+      rescue UnknownObjectException
+        false
+      end
+    end
+    alias_method :exist?, :exists?
+    alias_method :exists, :exists?
+
+    def text
+      assert_exists
+      @object.asText.strip
+    end
+    alias_method :innerText, :text
+    alias_method :inner_text, :text
+
+    def to_xml
+      assert_exists
+      @object.asXml
+    end
+    alias_method :asXml, :to_xml
+    alias_method :as_xml, :to_xml
+    alias_method :html, :to_xml
+    
+    # used to get attributes
+    def method_missing(meth, *args, &blk)
+      assert_exists
+      meth = :class if meth == :class_name
+      meth = :value if meth == :caption
+      
+      if self.class::ATTRIBUTES.include?(meth)
+        @object.getAttributeValue(meth.to_s)
+      else
+        Log.info "Element\#method_missing calling super with #{meth.inspect}"
+        super
+      end
+    end
+    
+  end # Element
+end # Celerity

data/lib/celerity/element_collections.rb

@@ -0,0 +1,67 @@
+module Celerity
+  # this class is the super class for the iterator classes (buttons, links, spans etc
+  # it would normally only be accessed by the iterator methods (spans, links etc) of IE
+  class ElementCollections
+    include Enumerable
+    
+    def element_tags
+      element_class::TAGS
+    end
+    
+    def length
+      if @object
+        @object.length
+      elsif Element::Identifier === element_tags.first
+        idents = element_tags
+        tags   = idents.map { |e| e.tag }    
+        tags.map! { |t| t.downcase }
+        elements = @container.object.getAllHtmlChildElements.iterator.to_a.select do |elem|
+          tags.include?(elem.getTagName)
+        end
+        elements = elements.select do |e| 
+          idents.any? do |ident| 
+            next unless ident.tag == e.getTagName
+            if ident.attributes.empty?
+              true
+            else
+              ident.attributes.any? { |key, value| value.include?(e.getAttributeValue(key.to_s)) } 
+            end
+          end
+        end
+        return elements.length
+      else
+        length = 0
+        element_tags.each { |element_tag| length += @container.object.getHtmlElementsByTagName(element_tag).toArray.size }
+        return length
+      end
+    end
+    alias_method :size, :length
+    
+    def initialize(container, how = nil, what = nil)
+      @container = container
+      if how == :object
+        @object = what
+      end
+      @length = length # defined by subclasses
+    end
+    
+    def each
+      0.upto(@length-1) { |i| yield iterator_object(i) }
+    end
+    
+    def [](n)
+      return iterator_object(n-1)
+    end
+    
+    def to_s
+      return self.collect { |i| i.to_s }.join("\n")
+    end
+    
+    # this method creates an object of the correct type that the iterators use
+    private
+    def iterator_object(i)
+      element_class.new(@container, :index, i+1)
+    end
+  
+  end # ElementCollections
+end # Celerity

data/lib/celerity/elements/button.rb

@@ -0,0 +1,13 @@
+module Celerity
+  # 
+  # Input: Button
+  #
+  # Class representing button elements
+  #
+  class Button < InputElement
+    TAGS = [ Identifier.new('button'), 
+             Identifier.new('input', :type => %w(submit reset image button)) ]
+    DEFAULT_HOW = :value
+  end
+  
+end

data/lib/celerity/elements/file_field.rb

@@ -0,0 +1,12 @@
+
+module Celerity
+  # For fields that accept file uploads
+  class FileField < InputElement
+    TAGS = [ Identifier.new('input', :type => %w(file)) ]
+  
+    def set(value)
+      assert_exists
+      @object.setValueAttribute(value.to_s)
+    end
+  end
+end

data/lib/celerity/elements/form.rb

@@ -0,0 +1,15 @@
+module Celerity
+  class Form < Element
+    include Container
+    TAGS = ['form']
+    # HTML 4.01 Transitional DTD
+    ATTRIBUTES = BASE_ATTRIBUTES | [:action, :method, :enctype, :accept, :name, :onsubmit, :onreset, :target, :'accept-charset']
+    DEFAULT_HOW = :name
+  
+    def submit
+      assert_exists
+      raise NotImplementedError      
+    end
+
+  end  
+end

data/lib/celerity/elements/frame.rb

@@ -0,0 +1,44 @@
+module Celerity
+  class Frame < Element
+    include Container
+    attr_accessor :page
+    TAGS = {'frame' => nil, 'iframe' => nil}
+    ATTRIBUTES = BASE_ATTRIBUTES | [:longdesc, :name, :src, :frameborder, :marginwidth, :marginheight, :noresize, :scrolling]
+    DEFAULT_HOW = :name
+    
+    def locate
+      # Log.debug(@container.object.inspect)
+      frame_elements = @container.object.getByXPath(".//iframe | .//frame").collect { |frame| frame.getEnclosedWindow.getFrameElement }
+      unless frame_elements.empty?
+        case @how
+          when :id, :name, :src, :class
+            matching_frame_elements = frame_elements.select { |frame_element| matches?(frame_element.getAttribute(@how.to_s), @what) }
+            if @frame_element = matching_frame_elements.first
+              @object = @frame_element.getEnclosedPage.getDocumentElement  
+            end
+          when :index
+            if @frame_element = frame_elements[@what-1]
+              @object = @frame_element.getEnclosedPage.getDocumentElement
+            end
+          when :xpath
+            raise NotImplementedError
+          else
+            raise MissingWayOfFindingObjectException
+        end
+      end
+      raise UnknownFrameException unless @object
+    end
+    
+    def update_page(value)
+      # Log.debug(value.asXml) 
+      @page_container.set_page(value.getEnclosingWindow.getTopWindow.getEnclosedPage)
+    end
+
+    def to_s
+      assert_exists
+      create_string(@frame_element)
+    end
+    
+  end
+
+end

data/lib/celerity/elements/image.rb

@@ -0,0 +1,70 @@
+module Celerity
+  
+  # This class is the means of accessing an image on a page.
+  # Normally a user would not need to create this object as it is returned by the Watir::Container#image method
+  #
+  # many of the methods available to this object are inherited from the Element class
+  #
+  class Image < Element
+    include ClickableElement
+    include DisabledElement
+    
+    TAGS = ['img']
+    ATTRIBUTES = BASE_ATTRIBUTES | [:src, :alt, :longdesc, :name, :height, :width, :usemap, :ismap, :align, :border, :hspace, :vspace]
+    
+    # this method returns the file created date of the image
+    def file_created_date
+      assert_exists
+      web_response = @object.getWebResponse(true)      
+      return Time.parse(web_response.getResponseHeaderValue("Last-Modified").to_s)    
+    end
+    alias_method :fileCreatedDate, :file_created_date
+    
+    # this method returns the filesize of the image
+    def file_size
+      assert_exists
+      web_response = @object.getWebResponse(true)      
+      return web_response.getResponseBody().length  
+    end
+    alias_method :fileSize, :file_size
+    
+    # returns the width in pixels of the image, as a string
+    def width
+      assert_exists
+      @object.getWidth
+    end
+    
+    # returns the height in pixels of the image, as a string
+    def height
+      assert_exists
+      @object.getHeight
+    end
+    
+    def disabled?
+      assert_exists
+      raise NotImplementedError
+    end
+    alias_method :disabled, :disabled?
+    
+    def loaded?
+      assert_exists
+      begin 
+        @object.getImageReader
+        return true
+      rescue
+        return false
+      end
+    end
+    alias_method :hasLoaded?, :loaded?
+    alias_method :has_loaded?, :loaded?
+    
+    def save(filename)
+      assert_exists
+      image_reader = @object.getImageReader
+      file = java.io.File.new(filename)
+      buffered_image = image_reader.read(0);
+      return javax.imageio.ImageIO.write(buffered_image, image_reader.getFormatName(), file);
+    end
+  end
+
+end

data/lib/celerity/elements/label.rb

@@ -0,0 +1,10 @@
+module Celerity
+  
+  class Label < Element
+    TAGS = ['label']
+    ATTRIBUTES = BASE_ATTRIBUTES | [:for, :accesskey, :onfocus, :onblur]
+    
+    
+  end
+  
+end

data/lib/celerity/elements/link.rb

@@ -0,0 +1,13 @@
+module Celerity
+  class Link < Element
+    TAGS = ['a']
+    ATTRIBUTES = BASE_ATTRIBUTES | [:charset, :type, :name, :href, :hreflang, :target, :rel, :rev, :accesskey, :shape, :coords, :tabindex, :onfocus, :onblur]
+    
+    def click
+      assert_exists
+      @container.update_page @object.click
+    end
+    
+  end
+  
+end

data/lib/celerity/elements/radio_check.rb

@@ -0,0 +1,59 @@
+module Celerity
+  # This class is the class for radio buttons and check boxes.
+  # It contains methods common to both.
+  # Normally a user would not need to create this object as it is returned by the Watir::Container#checkbox or Watir::Container#radio methods
+  #
+  # most of the methods available to this element are inherited from the Element class
+  #
+  class RadioCheckCommon < InputElement
+    def locate
+      @object = @container.locate_input_element(self, @how, @what, @value)
+    end
+    
+    def initialize(container, how, what, type, value = nil)
+      @type = type
+      @value = value
+      super(container, how, what)
+    end
+    
+    def set?
+      assert_exists
+      @object.isChecked
+    end
+    alias_method :is_set?, :set?
+    alias_method :isSet?, :set?
+    alias_method :get_state, :set?
+    alias_method :getState, :set?
+    alias_method :checked?, :set?
+    
+    def clear
+      set(false)
+    end
+  end
+  
+  # This class is the celerity representation of a radio button.
+  class Radio < RadioCheckCommon
+    TAGS = [Identifier.new('input', :type => %w(radio))]
+
+    def set(value = true)
+      assert_exists
+      assert_enabled
+      @container.update_page(value ? @object.click : @object.setChecked(value))
+    end
+
+  end
+  
+  # This class is the celerity representation of a check box.
+  class CheckBox < RadioCheckCommon
+    TAGS = [Identifier.new('input', :type => %w(checkbox))]
+
+    def set(value = true)
+      assert_exists
+      assert_enabled
+      if (value && !set?) || (!value && set?)
+        @container.update_page(@object.click)
+      end
+    end
+  end
+
+end