celerity 0.0.1 → 0.0.2

data/lib/celerity/disabled_element.rb

@@ -5,7 +5,7 @@ module Celerity
     end
 
     def disabled?
-      assert_exists
+      assert_exists unless @object
       @object.isDisabled
     end
     alias_method :disabled, :disabled?

data/lib/celerity/element.rb

@@ -4,38 +4,43 @@ module Celerity
     include Container
     attr_accessor :container, :object
     
+    # number of spaces that separate the property from the value in the create_string method
+    TO_S_SIZE = 14
+    
     # 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
+    HTML_401_TRANSITIONAL = { 
+      :core        => [:class, :id, :style, :title], # Not valid in base, head, html, meta, param, script, style, and title elements.
+      :cell_halign => [:align, :char, :charoff],
+      :cell_valign => [:valign],
+      :i18n        => [:dir, :lang],  # Not valid in base, br, frame, frameset, hr, iframe, param, and script elements.
+      :event       => [:onclick, :ondblclick, :onmousedown, :onmouseup, :onmouseover, :onmousemove, :onmouseout, :onkeypress, :onkeydown, :onkeyup],
+      :sloppy      => [:name, :value]
+    }
+    
+    CELLHALIGN_ATTRIBUTES = HTML_401_TRANSITIONAL[:cell_halign]
+    CELLVALIGN_ATTRIBUTES = HTML_401_TRANSITIONAL[:cell_valign]
+    BASE_ATTRIBUTES       = HTML_401_TRANSITIONAL.values_at(:core, :i18n, :event, :sloppy).flatten
+    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
+      
+      case args.size
+      when 2
+        @conditions = {args[0] => args[1]}
+      when 1
+        if Hash === args.first
+          @conditions = args.first
+        elsif defined?(self.class::DEFAULT_HOW)
+          @conditions = {self.class::DEFAULT_HOW => args.first}
+        else
+          raise ArgumentError, "wrong number of arguments (1 for 2)"
+        end
       end
     end
     
     def locate
-        @object = @container.locate_tagged_element(self, @how, @what)
+      @object ||= ElementLocator.new(@container.object, self.class).find_by_conditions(@conditions)
     end
     
     def to_s
@@ -43,30 +48,15 @@ module Celerity
       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)
+      locate
       unless @object
-        raise UnknownObjectException, "Unable to locate object, using #{@how.inspect} and #{@what.inspect}"
+        raise UnknownObjectException, "Unable to locate object, using #{identifier_string}"
       end
     end
 
@@ -74,7 +64,7 @@ module Celerity
       begin
         assert_exists
         true
-      rescue UnknownObjectException
+      rescue UnknownObjectException, UnknownFrameException
         false
       end
     end
@@ -88,6 +78,18 @@ module Celerity
     alias_method :innerText, :text
     alias_method :inner_text, :text
 
+    def contains_text(expected_text)
+      assert_exists
+      case expected_text
+      when Regexp
+        text().match(expected_text)
+      when String
+        text().index(expected_text)
+      else
+        raise ArgumentError, "Argument #{expected_text.inspect} should be a String or Regexp."
+      end
+    end
+
     def to_xml
       assert_exists
       @object.asXml
@@ -98,17 +100,46 @@ module Celerity
     
     # used to get attributes
     def method_missing(meth, *args, &blk)
-      assert_exists
-      meth = :class if meth == :class_name
-      meth = :value if meth == :caption
-      
+      case meth
+      when :class_name
+        meth = :class
+      when :caption
+        meth = :value
+      when :url
+        meth = :href
+      end
+
       if self.class::ATTRIBUTES.include?(meth)
+        assert_exists
         @object.getAttributeValue(meth.to_s)
       else
-        Log.info "Element\#method_missing calling super with #{meth.inspect}"
+        Log.warn "Element\#method_missing calling super with #{meth.inspect}"
         super
       end
     end
+
+    private
+    
+    def create_string(element)
+      n = []
+      n << "tag:".ljust(TO_S_SIZE) + element.getTagName unless element.getTagName.empty?
+      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 unless element.asText.empty?
+      return n.join("\n")
+    end
+    
+    def identifier_string
+      if @conditions.size == 1
+        how, what = @conditions.shift
+        "#{how.inspect} and #{what.inspect}"
+      else
+        @conditions.inspect
+      end
+    end
     
   end # Element
 end # Celerity

data/lib/celerity/element_collections.rb

@@ -4,6 +4,12 @@ module Celerity
   class ElementCollections
     include Enumerable
     
+    def initialize(container, how = nil, what = nil)
+      @container = container
+      @object = (how == :object ? what : nil)
+      @length = length # defined by subclasses
+    end
+
     def element_tags
       element_class::TAGS
     end
@@ -11,54 +17,32 @@ module Celerity
     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
+        @elements = ElementLocator.new(@container.object, element_class).elements_by_idents
+        @elements.size
       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) }
+      if @elements
+        @elements.each { |e| yield(element_class.new(@container, :object, e)) }
+      else
+        0.upto(@length - 1) { |i| yield iterator_object(i) }
+      end
     end
     
     def [](n)
-      return iterator_object(n-1)
+      @elements ? element_class.new(@container, :object, @elements[n - 1]) : 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
+
+    # this method creates an object of the correct type that the iterators use
     def iterator_object(i)
       element_class.new(@container, :index, i+1)
     end

data/lib/celerity/element_locator.rb

@@ -0,0 +1,135 @@
+module Celerity
+  
+  # What we essentially want is the ability to perform a fast SQLish 'select' against the DOM. 
+  # Instead of iterating twice through a lot of elements, we could modify the Identifier objects to contain 
+  # everything in our 'query'. 
+  # Jari - 2008-05-11
+  class ElementLocator
+    attr_accessor :idents
+    
+    
+    def initialize(object, element_class)
+      @object = object
+      @element_class = element_class
+      @attributes = @element_class::ATTRIBUTES # could check for 'strict' here?
+      @idents = @element_class::TAGS
+      @tags = @idents.map { |e| e.tag.downcase }
+    end
+
+    def find_by_conditions(conditions)
+      @condition_idents = []
+      attributes = Hash.new { |h, k| h[k] = [] }
+      index = 0 # by default, return the first matching element
+      text = nil 
+      
+      begin 
+        conditions.each do |how, what|
+          case how
+          when :object
+            return what
+          when :id
+            return find_by_id(what)
+          when :xpath
+            return find_by_xpath(what)
+          when :class_name
+            how = :class
+          when :url
+            how = :href
+          when :caption
+            how = :text
+          end
+        
+          if @attributes.include?(how)
+            attributes[how] << what  
+          elsif how == :index
+            index = what.to_i - 1
+          elsif how == :text
+            text = what
+          else
+            raise MissingWayOfFindingObjectException, "No how #{how.inspect}"
+          end
+
+        end
+
+        @idents.each do |ident|
+          merged = attributes.merge(ident.attributes) do |key, v1, v2|
+            attributes[key] = v1 | v2
+          end
+            
+          id = Identifier.new(ident.tag, merged)
+          # «original» identifier takes precedence for :text
+          id.text = ident.text || text
+          @condition_idents << id
+        end
+        
+        if index == 0
+          element_by_idents(@condition_idents)
+        else
+          elements_by_idents(@condition_idents)[index]
+        end
+
+      rescue HtmlUnit::ElementNotFoundException
+        nil # for rcov
+      end
+    end
+    
+    def find_by_id(what)
+      case what
+      when Regexp
+        elements_by_tag_names.find { |elem| elem.getIdAttribute =~ what }
+      when String
+        @object.getHtmlElementById(what)
+      else
+        raise ArgumentError, "Argument #{what.inspect} should be a String or Regexp"
+      end
+    end
+    
+    def find_by_xpath(what)
+      what = ".#{what}" if what[0] == ?/
+      @object.getByXPath(what).to_a.first
+    end
+
+    def elements_by_idents(idents = nil)
+      get_by_idents(:select, idents || @idents)
+    end
+    
+    def element_by_idents(idents = nil)
+      get_by_idents(:find, idents || @idents)
+    end
+
+    private 
+
+    def get_by_idents(meth, idents)
+      @object.getAllHtmlChildElements.iterator.to_a.send(meth) do |e|
+        if @tags.include?(e.getTagName)
+          idents.any? do |ident|
+            next unless ident.tag == e.getTagName
+            attr_result = ident.attributes.all? do |key, value| 
+              value.any? { |val| matches?(e.getAttributeValue(key.to_s), val) } 
+            end 
+            
+            if ident.text
+              attr_result && matches?(e.asText, ident.text) 
+            else
+              attr_result
+            end
+            
+          end
+        end
+      end
+    end
+
+    def matches?(string, what)
+      Regexp === what ? string.match(what) : string == what.to_s
+    end
+
+    def elements_by_tag_names
+      # HtmlUnit's getHtmlElementsByTagNames won't get elements in the correct order, making :index fail
+      @object.getAllHtmlChildElements.iterator.to_a.select do |elem|
+        @tags.include?(elem.getTagName)
+      end
+    end
+
+
+  end # ElementLocator
+end # Celerity

data/lib/celerity/elements/button.rb

@@ -8,6 +8,21 @@ module Celerity
     TAGS = [ Identifier.new('button'), 
              Identifier.new('input', :type => %w(submit reset image button)) ]
     DEFAULT_HOW = :value
+
+    def locate
+      # ugly..
+      if (val = @conditions.delete(:value))
+        locator = ElementLocator.new(@container.object, self.class)
+        button_ident = Identifier.new('button')
+        button_ident.text = val
+        input_ident = Identifier.new('input', :type => %w(submit reset image button), :value => [val])
+        locator.idents = [button_ident, input_ident]
+        @object = locator.find_by_conditions(@conditions)
+      else
+        super
+      end
+    end
+    
   end
   
 end

data/lib/celerity/elements/file_field.rb

@@ -1,4 +1,3 @@
-
 module Celerity
   # For fields that accept file uploads
   class FileField < InputElement
@@ -6,6 +5,7 @@ module Celerity
   
     def set(value)
       assert_exists
+      # TODO: trigger events?
       @object.setValueAttribute(value.to_s)
     end
   end

data/lib/celerity/elements/form.rb

@@ -1,7 +1,7 @@
 module Celerity
   class Form < Element
     include Container
-    TAGS = ['form']
+    TAGS = [Identifier.new('form')]
     # HTML 4.01 Transitional DTD
     ATTRIBUTES = BASE_ATTRIBUTES | [:action, :method, :enctype, :accept, :name, :onsubmit, :onreset, :target, :'accept-charset']
     DEFAULT_HOW = :name
@@ -9,6 +9,7 @@ module Celerity
     def submit
       assert_exists
       raise NotImplementedError      
+      # waiting for HtmlUnit fix?
     end
 
   end