webrat 0.3.4 → 0.4.0

data/lib/webrat/core/elements/form.rb

@@ -0,0 +1,103 @@
+require "webrat/core/elements/field"
+require "webrat/core_extensions/blank"
+
+require "webrat/core/elements/element"
+require "webrat/core/locators/field_named_locator"
+
+module Webrat
+  class Form < Element #:nodoc:
+    attr_reader :element
+    
+    def self.xpath_search
+      ".//form"
+    end
+
+    def fields
+      @fields ||= Field.load_all(@session, @element)
+    end
+    
+    def submit
+      @session.request_page(form_action, form_method, params)
+    end
+    
+    def field_named(name, *field_types)
+      Webrat::Locators::FieldNamedLocator.new(@session, dom, name, *field_types).locate
+    end
+    
+  protected
+  
+    def dom
+      Webrat::XML.xpath_at(@session.dom, path)
+    end
+    
+    def fields_by_type(field_types)
+      if field_types.any?
+        fields.select { |f| field_types.include?(f.class) }
+      else
+        fields
+      end
+    end
+    
+    def params
+      all_params = {}
+      
+      fields.each do |field|
+        next if field.to_param.nil?
+        merge(all_params, field.to_param)
+      end
+      
+      all_params
+    end
+    
+    def form_method
+      Webrat::XML.attribute(@element, "method").blank? ? :get : Webrat::XML.attribute(@element, "method").downcase
+    end
+    
+    def form_action
+      Webrat::XML.attribute(@element, "action").blank? ? @session.current_url : Webrat::XML.attribute(@element, "action")
+    end
+    
+    def merge(all_params, new_param)
+      new_param.each do |key, value|
+        case all_params[key]
+        when *hash_classes
+          merge_hash_values(all_params[key], value)
+        when Array
+          all_params[key] += value
+        else
+          all_params[key] = value
+        end
+      end
+    end
+  
+    def merge_hash_values(a, b) # :nodoc:
+      a.keys.each do |k|
+        if b.has_key?(k)
+          case [a[k], b[k]].map{|value| value.class}
+          when *hash_classes.zip(hash_classes)
+            a[k] = merge_hash_values(a[k], b[k])
+            b.delete(k)
+          when [Array, Array]
+            a[k] += b[k]
+            b.delete(k)
+          end
+        end
+      end
+      a.merge!(b)
+    end
+    
+    def hash_classes
+      klasses = [Hash]
+      
+      case Webrat.configuration.mode
+      when :rails
+        klasses << HashWithIndifferentAccess
+      when :merb
+        klasses << Mash
+      end
+      
+      klasses
+    end
+    
+  end
+end

data/lib/webrat/core/elements/label.rb

@@ -0,0 +1,31 @@
+require "webrat/core/elements/element"
+
+module Webrat
+  class Label < Element #:nodoc:
+    
+    attr_reader :element
+    
+    def self.xpath_search
+      ".//label"
+    end
+
+    def for_id
+      Webrat::XML.attribute(@element, "for")
+    end
+    
+    def field
+      Field.load(@session, field_element)
+    end
+    
+  protected
+  
+    def field_element
+      if for_id.blank?
+        Webrat::XML.xpath_at(@element, *Field.xpath_search)
+      else
+        Webrat::XML.css_search(@session.dom, "#" + for_id).first
+      end
+    end
+    
+  end
+end

data/lib/webrat/core/{link.rb → elements/link.rb}

@@ -1,11 +1,12 @@
 require "webrat/core_extensions/blank"
 
+require "webrat/core/elements/element"
+
 module Webrat
-  class Link #:nodoc:
+  class Link < Element #:nodoc:
     
-    def initialize(session, element)
-      @session  = session
-      @element  = element
+    def self.xpath_search
+      ".//a[@href]"
     end
     
     def click(options = {})
@@ -21,40 +22,28 @@ module Webrat
       end
     end
     
-    def matches_text?(link_text)
-      html = text.gsub('&#xA0;',' ')
-      
-      if link_text.is_a?(Regexp)
-        matcher = link_text
-      else
-        matcher = /#{Regexp.escape(link_text.to_s)}/i
-      end
-      
-      html =~ matcher || title =~ matcher
-    end
-    
-    def text
-      @element.inner_html
-    end
-    
   protected
   
+    def id
+      Webrat::XML.attribute(@element, "id")
+    end
+  
     def data
       authenticity_token.blank? ? {} : {"authenticity_token" => authenticity_token}
     end
 
     def title
-      @element['title']
+      Webrat::XML.attribute(@element, "title")
     end
 
     def href
-      @element["href"]
+      Webrat::XML.attribute(@element, "href")
     end
 
     def absolute_href
       if href =~ /^\?/
         "#{@session.current_url}#{href}"
-      elsif href !~ %r{^https?://www.example.com(/.*)} && (href !~ /^\//)
+      elsif href !~ %r{^https?://} && (href !~ /^\//)
         "#{@session.current_url}/#{href}"
       else
         href
@@ -68,7 +57,7 @@ module Webrat
     end
     
     def onclick
-      @element["onclick"]
+      Webrat::XML.attribute(@element, "onclick")
     end
     
     def http_method
@@ -93,9 +82,9 @@ module Webrat
       elsif onclick.include?("m.setAttribute('value', 'put')")
         :put
       else
-        raise "No HTTP method for _method param in #{onclick.inspect}"
+        raise Webrat::WebratError.new("No HTTP method for _method param in #{onclick.inspect}")
       end
     end
-
+    
   end
 end

data/lib/webrat/core/elements/select_option.rb

@@ -0,0 +1,35 @@
+require "webrat/core/elements/element"
+
+module Webrat
+  class SelectOption < Element #:nodoc:
+    
+    def self.xpath_search
+      ".//option"
+    end
+    
+    def choose
+      select.raise_error_if_disabled
+      select.set(value)
+    end
+    
+  protected
+    
+    def select
+      SelectField.load(@session, select_element)
+    end
+    
+    def select_element
+      parent = @element.parent
+      
+      while parent.respond_to?(:parent)
+        return parent if parent.name == 'select'
+        parent = parent.parent
+      end
+    end
+    
+    def value
+      Webrat::XML.attribute(@element, "value") || Webrat::XML.inner_html(@element)
+    end
+    
+  end
+end

data/lib/webrat/core/locators.rb

@@ -1,92 +1,20 @@
-require "webrat/core_extensions/detect_mapped"
+require "webrat/core/locators/area_locator"
+require "webrat/core/locators/button_locator"
+require "webrat/core/locators/field_labeled_locator"
+require "webrat/core/locators/label_locator"
+require "webrat/core/locators/field_named_locator"
+require "webrat/core/locators/field_by_id_locator"
+require "webrat/core/locators/select_option_locator"
+require "webrat/core/locators/link_locator"
+require "webrat/core/locators/field_locator"
+require "webrat/core/locators/form_locator"
 
 module Webrat
   module Locators
-
-    def field(*args)
-      # This is the default locator strategy
-      find_field_with_id(*args) ||
-      find_field_named(*args)   ||
-      field_labeled(*args)      ||
-      flunk("Could not find field: #{args.inspect}")
-    end
-    
-    def field_labeled(label, *field_types)
-      find_field_labeled(label, *field_types) ||
-      flunk("Could not find field labeled #{label.inspect}")
-    end
-
-    def field_named(name, *field_types)
-      find_field_named(name, *field_types) ||
-      flunk("Could not find field named #{name.inspect}")
-    end
-    
-    def field_with_id(id, *field_types)
-      find_field_with_id(id, *field_types) ||
-      flunk("Could not find field with id #{id.inspect}")
-    end
-    
-    def find_field_labeled(label, *field_types) #:nodoc:
-      forms.detect_mapped do |form|
-        form.field_labeled(label, *field_types)
-      end
-    end
-    
-    def find_field_named(name, *field_types) #:nodoc:
-      forms.detect_mapped do |form|
-        form.field_named(name, *field_types)
-      end
-    end
-    
-    def find_field_with_id(id, *field_types) #:nodoc:
-      forms.detect_mapped do |form|
-        form.field_with_id(id, *field_types)
-      end
-    end
-    
-    def find_select_option(option_text, id_or_name_or_label) #:nodoc:
-      if id_or_name_or_label
-        field = field(id_or_name_or_label, SelectField)
-        return field.find_option(option_text)
-      else
-        select_option = forms.detect_mapped do |form|
-          form.find_select_option(option_text)
-        end
-        
-        return select_option if select_option
-      end
-        
-      flunk("Could not find option #{option_text.inspect}")
-    end
-    
-    def find_button(value) #:nodoc:
-      button = forms.detect_mapped do |form|
-        form.find_button(value)
-      end
-      
-      if button
-        return button
-      else
-        flunk("Could not find button #{value.inspect}")
-      end
-    end
-    
-    def find_area(area_name) #:nodoc:
-      areas.detect { |area| area.matches_text?(area_name) } ||
-      flunk("Could not find area with name #{area_name}")
-    end
     
-    def find_link(text) #:nodoc:
-      matching_links = links.select do |possible_link|
-        possible_link.matches_text?(text)
-      end
-      
-      if matching_links.any?
-        matching_links.min { |a, b| a.text.length <=> b.text.length }
-      else
-        flunk("Could not find link with text #{text.inspect}")
-      end
+    def field_by_xpath(xpath)
+      Field.load(@session, Webrat::XML.xpath_at(dom, xpath))
     end
     
   end
-end
+end

data/lib/webrat/core/locators/area_locator.rb

@@ -0,0 +1,38 @@
+require "webrat/core/locators/locator"
+
+module Webrat
+  module Locators
+    
+    class AreaLocator < Locator # :nodoc:
+      
+      def locate
+        Area.load(@session, area_element)
+      end
+  
+      def area_element
+        area_elements.detect do |area_element|
+          Webrat::XML.attribute(area_element, "title") =~ matcher ||
+          Webrat::XML.attribute(area_element, "id") =~ matcher
+        end
+      end
+  
+      def matcher
+        /#{Regexp.escape(@value.to_s)}/i
+      end
+  
+      def area_elements
+        Webrat::XML.xpath_search(@dom, Area.xpath_search)
+      end
+  
+      def error_message
+        "Could not find area with name #{@value}"
+      end
+      
+    end
+    
+    def find_area(id_or_title) #:nodoc:
+      AreaLocator.new(@session, dom, id_or_title).locate!
+    end
+    
+  end
+end

data/lib/webrat/core/locators/button_locator.rb

@@ -0,0 +1,54 @@
+require "webrat/core/locators/locator"
+
+module Webrat
+  module Locators
+    
+    class ButtonLocator < Locator # :nodoc:
+  
+      def locate
+        ButtonField.load(@session, button_element)
+      end
+  
+      def button_element
+        button_elements.detect do |element|
+          @value.nil?             ||
+          matches_id?(element)    ||
+          matches_value?(element) ||
+          matches_html?(element)  ||
+          matches_alt?(element)
+        end
+      end
+  
+      def matches_id?(element)
+        (@value.is_a?(Regexp) && Webrat::XML.attribute(element, "id") =~ @value) ||
+        (!@value.is_a?(Regexp) && Webrat::XML.attribute(element, "id") == @value.to_s)
+      end
+  
+      def matches_value?(element)
+        Webrat::XML.attribute(element, "value") =~ /^\W*#{Regexp.escape(@value.to_s)}/i
+      end
+  
+      def matches_html?(element)
+        Webrat::XML.inner_html(element) =~ /#{Regexp.escape(@value.to_s)}/i
+      end
+  
+      def matches_alt?(element)
+        Webrat::XML.attribute(element, "alt") =~ /^\W*#{Regexp.escape(@value.to_s)}/i
+      end
+  
+      def button_elements
+        Webrat::XML.xpath_search(@dom, *ButtonField.xpath_search)
+      end
+  
+      def error_message
+        "Could not find button #{@value.inspect}"
+      end
+      
+    end
+    
+    def find_button(value) #:nodoc:
+      ButtonLocator.new(@session, dom, value).locate!
+    end
+    
+  end
+end