webrat 0.3.4 → 0.4.0

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

@@ -0,0 +1,37 @@
+require "webrat/core/locators/locator"
+
+module Webrat
+  module Locators
+    
+    class FieldByIdLocator < Locator # :nodoc:
+  
+      def locate
+        Field.load(@session, field_element)
+      end
+  
+      def field_element
+        field_elements.detect do |field_element|
+          if @value.is_a?(Regexp)
+            Webrat::XML.attribute(field_element, "id") =~ @value
+          else
+            Webrat::XML.attribute(field_element, "id") == @value.to_s
+          end
+        end
+      end
+  
+      def field_elements
+        Webrat::XML.xpath_search(@dom, *Field.xpath_search)
+      end
+
+      def error_message
+        "Could not find field with id #{@value.inspect}"
+      end
+      
+    end
+    
+    def field_with_id(id, *field_types)
+      FieldByIdLocator.new(@session, dom, id, *field_types).locate!
+    end
+    
+  end
+end

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

@@ -0,0 +1,56 @@
+require "webrat/core_extensions/detect_mapped"
+require "webrat/core/locators/locator"
+
+module Webrat
+  module Locators
+    
+    class FieldLabeledLocator < Locator # :nodoc:
+  
+      def locate
+        matching_labels.any? && matching_labels.detect_mapped { |label| label.field }
+      end
+      
+      def matching_labels
+        matching_label_elements.sort_by do |label_element|
+          text(label_element).length
+        end.map do |label_element|
+          Label.load(@session, label_element)
+        end
+      end
+      
+      def matching_label_elements
+        label_elements.select do |label_element|
+          text(label_element) =~ /^\W*#{Regexp.escape(@value.to_s)}\b/i
+        end
+      end
+      
+      def label_elements
+        Webrat::XML.xpath_search(@dom, Label.xpath_search)
+      end
+  
+      def error_message
+        "Could not find field labeled #{@value.inspect}"
+      end
+      
+      def text(element)
+        str = Webrat::XML.all_inner_text(element)
+        str.gsub!("\n","")
+        str.strip!
+        str.squeeze!(" ")
+        str
+      end
+      
+    end
+    
+    # Locates a form field based on a <tt>label</tt> element in the HTML source.
+    # This can be useful in order to verify that a field is pre-filled with the
+    # correct value.
+    #
+    # Example:
+    #   field_labeled("First name").value.should == "Bryan"
+    def field_labeled(label, *field_types)
+      FieldLabeledLocator.new(@session, dom, label, *field_types).locate!
+    end
+    
+  end
+end

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

@@ -0,0 +1,25 @@
+require "webrat/core/locators/locator"
+
+module Webrat
+  module Locators
+    
+    class FieldLocator < Locator # :nodoc:
+  
+      def locate
+        FieldByIdLocator.new(@session, @dom, @value).locate   ||
+        FieldNamedLocator.new(@session, @dom, @value, *@field_types).locate   ||
+        FieldLabeledLocator.new(@session, @dom, @value, *@field_types).locate
+      end
+      
+      def error_message
+        "Could not find field: #{@value.inspect}"
+      end
+      
+    end
+    
+    def field(*args) # :nodoc:
+      FieldLocator.new(@session, dom, *args).locate!
+    end
+    
+  end
+end

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

@@ -0,0 +1,41 @@
+require "webrat/core/locators/locator"
+
+module Webrat
+  module Locators
+    
+    class FieldNamedLocator < Locator # :nodoc:
+  
+      def locate
+        Field.load(@session, field_element)
+      end
+  
+      def field_element
+        field_elements.detect do |field_element|
+          Webrat::XML.attribute(field_element, "name") == @value.to_s
+        end
+      end
+  
+      def field_elements
+        Webrat::XML.xpath_search(@dom, *xpath_searches)
+      end
+  
+      def xpath_searches
+        if @field_types.any?
+          @field_types.map { |field_type| field_type.xpath_search }.flatten
+        else
+          Array(Field.xpath_search)
+        end
+      end
+  
+      def error_message
+        "Could not find field named #{@value.inspect}"
+      end
+      
+    end
+    
+    def field_named(name, *field_types)
+      FieldNamedLocator.new(@session, dom, name, *field_types).locate!
+    end
+    
+  end
+end

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

@@ -0,0 +1,19 @@
+require "webrat/core/locators/locator"
+
+module Webrat
+  module Locators
+    
+    class FormLocator < Locator # :nodoc:
+  
+      def locate
+        Form.load(@session, form_element)
+      end
+      
+      def form_element
+        Webrat::XML.css_at(@dom, "#" + @value)
+      end
+      
+    end
+    
+  end
+end

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

@@ -0,0 +1,34 @@
+require "webrat/core_extensions/detect_mapped"
+require "webrat/core/locators/locator"
+
+module Webrat
+  module Locators
+    
+    class LabelLocator < Locator # :nodoc:
+  
+      def locate
+        Label.load(@session, label_element)
+      end
+      
+      def label_element
+        label_elements.detect do |label_element|
+          text(label_element) =~ /^\W*#{Regexp.escape(@value.to_s)}\b/i
+        end
+      end
+  
+      def label_elements
+        Webrat::XML.xpath_search(@dom, Label.xpath_search)
+      end
+      
+      def text(label_element)
+        str = Webrat::XML.all_inner_text(label_element)
+        str.gsub!("\n","")
+        str.strip!
+        str.squeeze!(" ")
+        str
+      end
+      
+    end
+    
+  end
+end

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

@@ -0,0 +1,66 @@
+require "webrat/core/locators/locator"
+
+module Webrat
+  module Locators
+    
+    class LinkLocator < Locator # :nodoc:
+  
+      def locate
+        Link.load(@session, link_element)
+      end
+  
+      def link_element
+        matching_links.min { |a, b| Webrat::XML.all_inner_text(a).length <=> Webrat::XML.all_inner_text(b).length }
+      end
+  
+      def matching_links
+        @matching_links ||= link_elements.select do |link_element|
+          matches_text?(link_element) ||
+          matches_id?(link_element)
+        end
+      end
+  
+      def matches_text?(link)
+        if @value.is_a?(Regexp)
+          matcher = @value
+        else
+          matcher = /#{Regexp.escape(@value.to_s)}/i
+        end
+
+        replace_nbsp(Webrat::XML.all_inner_text(link)) =~ matcher ||
+        replace_nbsp_ref(Webrat::XML.inner_html(link)) =~ matcher ||
+        Webrat::XML.attribute(link, "title")=~ matcher
+      end
+
+      def matches_id?(link)
+        if @value.is_a?(Regexp)
+          (Webrat::XML.attribute(link, "id") =~ @value) ? true : false
+        else
+          (Webrat::XML.attribute(link, "id") == @value) ? true : false
+        end
+      end
+  
+      def link_elements
+        Webrat::XML.xpath_search(@dom, *Link.xpath_search)
+      end
+  
+      def replace_nbsp(str)
+        str.gsub([0xA0].pack('U'), ' ')
+      end
+
+      def replace_nbsp_ref(str)
+        str.gsub('&#xA0;',' ').gsub('&nbsp;', ' ')
+      end
+  
+      def error_message
+        "Could not find link with text or title or id #{@value.inspect}"
+      end
+      
+    end
+    
+    def find_link(text_or_title_or_id) #:nodoc:
+      LinkLocator.new(@session, dom, text_or_title_or_id).locate!
+    end
+    
+  end
+end

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

@@ -0,0 +1,20 @@
+module Webrat
+  module Locators
+  
+    class Locator # :nodoc:
+
+      def initialize(session, dom, value, *field_types)
+        @session = session
+        @dom = dom
+        @value = value
+        @field_types = field_types
+      end
+  
+      def locate!
+        locate || raise(NotFoundError.new(error_message))
+      end
+      
+    end
+    
+  end
+end

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

@@ -0,0 +1,59 @@
+require "webrat/core_extensions/detect_mapped"
+require "webrat/core/locators/locator"
+
+module Webrat
+  module Locators
+    
+    class SelectOptionLocator < Locator # :nodoc:
+  
+      def initialize(session, dom, option_text, id_or_name_or_label)
+        @session = session
+        @dom = dom
+        @option_text = option_text
+        @id_or_name_or_label = id_or_name_or_label
+      end
+      
+      def locate
+        if @id_or_name_or_label
+          field = FieldLocator.new(@session, @dom, @id_or_name_or_label, SelectField).locate!
+          
+          field.options.detect do |o|
+            if @option_text.is_a?(Regexp)
+              Webrat::XML.inner_html(o.element) =~ @option_text
+            else
+              Webrat::XML.inner_html(o.element) == @option_text.to_s
+            end
+          end
+        else
+          option_element = option_elements.detect do |o|
+            if @option_text.is_a?(Regexp)
+              Webrat::XML.inner_html(o) =~ @option_text
+            else
+              Webrat::XML.inner_html(o) == @option_text.to_s
+            end
+          end
+          
+          SelectOption.load(@session, option_element)
+        end
+      end
+      
+      def option_elements
+        Webrat::XML.xpath_search(@dom, *SelectOption.xpath_search)
+      end
+      
+      def error_message
+        if @id_or_name_or_label
+          "The '#{@option_text}' option was not found in the #{@id_or_name_or_label.inspect} select box"
+        else
+          "Could not find option #{@option_text.inspect}"
+        end
+      end
+  
+    end
+    
+    def select_option(option_text, id_or_name_or_label = nil) #:nodoc:
+      SelectOptionLocator.new(@session, dom, option_text, id_or_name_or_label).locate!
+    end
+    
+  end
+end

data/lib/webrat/core/logging.rb

@@ -1,10 +1,5 @@
 module Webrat
   module Logging #:nodoc:
-
-    def warn_log(message) # :nodoc:
-      return unless logger
-      logger.warn message
-    end
     
     def debug_log(message) # :nodoc:
       return unless logger
@@ -12,10 +7,11 @@ module Webrat
     end
 
     def logger # :nodoc:
-      if defined? RAILS_DEFAULT_LOGGER
-        RAILS_DEFAULT_LOGGER
-      elsif defined? Merb
-        Merb.logger        
+      case Webrat.configuration.mode
+      when :rails
+        defined?(RAILS_DEFAULT_LOGGER) ? RAILS_DEFAULT_LOGGER : nil
+      when :merb
+        Merb.logger
       else
         nil
       end

data/lib/webrat/core/matchers/have_content.rb

@@ -7,28 +7,13 @@ module Webrat
       end
       
       def matches?(stringlike)
-        if defined?(Nokogiri::XML)
-          matches_nokogiri?(stringlike)
+        if Webrat.configuration.parse_with_nokogiri?
+          @document = Webrat.nokogiri_document(stringlike)
         else
-          matches_rexml?(stringlike)
+          @document = Webrat.hpricot_document(stringlike)
         end
-      end
-    
-      def matches_rexml?(stringlike)
-        @document = rexml_document(stringlike)
-        @element = @document.inner_text
-      
-        case @content
-        when String
-          @element.include?(@content)
-        when Regexp
-          @element.match(@content)
-        end
-      end
-    
-      def matches_nokogiri?(stringlike)
-        @document = Webrat.nokogiri_document(stringlike)
-        @element = @document.inner_text
+        
+        @element = Webrat::XML.inner_text(@document)
       
         case @content
         when String
@@ -37,27 +22,6 @@ module Webrat
           @element.match(@content)
         end
       end
-    
-      def rexml_document(stringlike)
-        stringlike = stringlike.body.to_s if stringlike.respond_to?(:body)
-        
-        case stringlike
-        when REXML::Document
-          stringlike.root
-        when REXML::Node
-          stringlike
-        when StringIO, String
-          begin
-            REXML::Document.new(stringlike.to_s).root
-          rescue REXML::ParseException => e
-            if e.message.include?("second root element")
-              REXML::Document.new("<fake-root-element>#{stringlike}</fake-root-element>").root
-            else
-              raise e
-            end
-          end
-        end
-      end
       
       # ==== Returns
       # String:: The failure message.
@@ -83,12 +47,23 @@ module Webrat
     
     # Matches the contents of an HTML document with
     # whatever string is supplied
-    #
-    # ---
-    # @api public
     def contain(content)
       HasContent.new(content)
     end
     
+    # Asserts that the body of the response contain
+    # the supplied string or regexp
+    def assert_contain(content)
+      hc = HasContent.new(content)
+      assert hc.matches?(response_body), hc.failure_message
+    end
+    
+    # Asserts that the body of the response
+    # does not contain the supplied string or regepx
+    def assert_not_contain(content)
+      hc = HasContent.new(content)
+      assert !hc.matches?(response_body), hc.negative_failure_message
+    end
+    
   end
 end