aslakhellesoy-webrat 0.3.2.2 → 0.4.4.1

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

@@ -2,18 +2,18 @@ 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
+end

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

@@ -3,23 +3,23 @@ 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
+          text(label_element) =~ /^\W*#{Regexp.escape(@value.to_s)}(\b|\Z)/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","")
@@ -27,8 +27,8 @@ module Webrat
         str.squeeze!(" ")
         str
       end
-      
+
     end
-    
+
   end
-end
+end

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

@@ -2,24 +2,24 @@ 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
@@ -39,11 +39,11 @@ module Webrat
           (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
@@ -51,16 +51,16 @@ module Webrat
       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
+end

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

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

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

@@ -3,20 +3,20 @@ 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
@@ -32,15 +32,15 @@ module Webrat
               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"
@@ -48,12 +48,12 @@ module Webrat
           "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
+end

data/lib/webrat/core/logging.rb

@@ -1,6 +1,6 @@
 module Webrat
   module Logging #:nodoc:
-    
+
     def debug_log(message) # :nodoc:
       return unless logger
       logger.debug message
@@ -13,9 +13,12 @@ module Webrat
       when :merb
         Merb.logger
       else
-        nil
+        @logger ||= begin
+          require "logger"
+          ::Logger.new("webrat.log")
+        end
       end
     end
-  
+
   end
-end
+end

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

@@ -1,20 +1,20 @@
 module Webrat
   module Matchers
-  
+
     class HasContent #:nodoc:
       def initialize(content)
         @content = content
       end
-      
+
       def matches?(stringlike)
         if Webrat.configuration.parse_with_nokogiri?
           @document = Webrat.nokogiri_document(stringlike)
         else
           @document = Webrat.hpricot_document(stringlike)
         end
-        
+
         @element = Webrat::XML.inner_text(@document)
-      
+
         case @content
         when String
           @element.include?(@content)
@@ -22,19 +22,23 @@ module Webrat
           @element.match(@content)
         end
       end
-      
+
       # ==== Returns
       # String:: The failure message.
       def failure_message
-        "expected the following element's content to #{content_message}:\n#{@element}"
+        "expected the following element's content to #{content_message}:\n#{squeeze_space(@element)}"
       end
 
       # ==== Returns
       # String:: The failure message to be displayed in negative matches.
       def negative_failure_message
-        "expected the following element's content to not #{content_message}:\n#{@element}"
+        "expected the following element's content to not #{content_message}:\n#{squeeze_space(@element)}"
+      end
+
+      def squeeze_space(inner_text)
+        inner_text.gsub(/^\s*$/, "").squeeze("\n")
       end
-    
+
       def content_message
         case @content
         when String
@@ -44,26 +48,26 @@ module Webrat
         end
       end
     end
-    
+
     # Matches the contents of an HTML document with
     # whatever string is supplied
     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)
-      raise Test::Unit::AssertionFailedError.new(hc.failure_message) unless hc.matches?(response_body)
+      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)
-      raise Test::Unit::AssertionFailedError.new(hc.negative_failure_message) if hc.matches?(response_body)
+      assert !hc.matches?(response_body), hc.negative_failure_message
     end
-    
+
   end
-end
+end

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

@@ -1,26 +1,48 @@
+require "webrat/core/matchers/have_xpath"
+
 module Webrat
   module Matchers
-    
-    class HaveSelector < HaveXpath #:nodoc:
 
+    class HaveSelector < HaveXpath #:nodoc:
       # ==== Returns
       # String:: The failure message.
       def failure_message
-        "expected following text to match selector #{@expected}:\n#{@document}"
+        "expected following output to contain a #{tag_inspect} tag:\n#{@document}"
       end
-    
+
       # ==== Returns
       # String:: The failure message to be displayed in negative matches.
       def negative_failure_message
-        "expected following text to not match selector #{@expected}:\n#{@document}"
+        "expected following output to omit a #{tag_inspect}:\n#{@document}"
+      end
+
+      def tag_inspect
+        options = @options.dup
+        count = options.delete(:count)
+        content = options.delete(:content)
+
+        html = "<#{@expected}"
+        options.each do |k,v|
+          html << " #{k}='#{v}'"
+        end
+
+        if content
+          html << ">#{content}</#{@expected}>"
+        else
+          html << "/>"
+        end
+
+        html
       end
-    
+
       def query
-        Nokogiri::CSS::Parser.parse(*super).map { |ast| ast.to_xpath }
+        Nokogiri::CSS.parse(@expected.to_s).map do |ast|
+          ast.to_xpath
+        end.first
       end
-  
+
     end
-    
+
     # Matches HTML content against a CSS 3 selector.
     #
     # ==== Parameters
@@ -28,25 +50,25 @@ module Webrat
     #
     # ==== Returns
     # HaveSelector:: A new have selector matcher.
-    def have_selector(expected, &block)
-      HaveSelector.new(expected, &block)
+    def have_selector(name, attributes = {}, &block)
+      HaveSelector.new(name, attributes, &block)
     end
     alias_method :match_selector, :have_selector
-    
-    
+
+
     # Asserts that the body of the response contains
     # the supplied selector
-    def assert_have_selector(expected)
-      hs = HaveSelector.new(expected)
-      raise Test::Unit::AssertionFailedError.new(hs.failure_message) unless hs.matches?(response_body)
+    def assert_have_selector(name, attributes = {}, &block)
+      matcher = HaveSelector.new(name, attributes, &block)
+      assert matcher.matches?(response_body), matcher.failure_message
     end
-    
+
     # Asserts that the body of the response
     # does not contain the supplied string or regepx
-    def assert_have_no_selector(expected)
-      hs = HaveSelector.new(expected)
-      raise Test::Unit::AssertionFailedError.new(hs.negative_failure_message) if hs.matches?(response_body)
+    def assert_have_no_selector(name, attributes = {}, &block)
+      matcher = HaveSelector.new(name, attributes, &block)
+      assert !matcher.matches?(response_body), matcher.negative_failure_message
     end
-    
+
   end
-end
+end

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

@@ -1,71 +1,21 @@
+require "webrat/core/matchers/have_selector"
+
 module Webrat
-  
   module HaveTagMatcher
 
-    class HaveTag < ::Webrat::Matchers::HaveSelector #:nodoc:
-      # ==== Returns
-      # String:: The failure message.
-      def failure_message
-        "expected following output to contain a #{tag_inspect} tag:\n#{@document}"
-      end
-
-      # ==== Returns
-      # String:: The failure message to be displayed in negative matches.
-      def negative_failure_message
-        "expected following output to omit a #{tag_inspect}:\n#{@document}"
-      end
-
-      def tag_inspect
-        options = @expected.last.dup
-        content = options.delete(:content)
-
-        html = "<#{@expected.first}"
-        options.each do |k,v|
-          html << " #{k}='#{v}'"
-        end
-
-        if content
-          html << ">#{content}</#{@expected.first}>"
-        else
-          html << "/>"
-        end
-
-        html
-      end
-
-      def query
-        options  = @expected.last.dup
-        selector = @expected.first.to_s
-
-        selector << ":contains('#{options.delete(:content)}')" if options[:content]
-
-        options.each do |key, value|
-          selector << "[#{key}='#{value}']"
-        end
-
-        Nokogiri::CSS::Parser.parse(selector).map { |ast| ast.to_xpath }
-      end
+    def have_tag(*args, &block)
+      have_selector(*args, &block)
     end
 
-    def have_tag(name, attributes = {}, &block)
-      HaveTag.new([name, attributes], &block)
-    end
-    
     alias_method :match_tag, :have_tag
-    
-    # Asserts that the body of the response contains
-    # the supplied tag with the associated selectors
-    def assert_have_tag(name, attributes = {})
-      ht = HaveTag.new([name, attributes])
-      raise Test::Unit::AssertionFailedError.new(ht.failure_message) unless ht.matches?(response_body)
+
+    def assert_have_tag(*args, &block)
+      assert_have_selector(*args, &block)
     end
-    
-    # Asserts that the body of the response
-    # does not contain the supplied string or regepx
-    def assert_have_no_tag(name, attributes = {})
-      ht = HaveTag.new([name, attributes])
-      raise Test::Unit::AssertionFailedError.new(ht.negative_failure_message) if ht.matches?(response_body)
+
+    def assert_have_no_tag(*args, &block)
+      assert_have_no_selector(*args, &block)
     end
 
   end
-end
+end