integrity 0.1.8 → 0.1.9

data/vendor/webrat/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/vendor/webrat/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/vendor/webrat/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/vendor/webrat/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/vendor/webrat/lib/webrat/core/logging.rb

@@ -0,0 +1,21 @@
+module Webrat
+  module Logging #:nodoc:
+    
+    def debug_log(message) # :nodoc:
+      return unless logger
+      logger.debug message
+    end
+
+    def logger # :nodoc:
+      case Webrat.configuration.mode
+      when :rails
+        defined?(RAILS_DEFAULT_LOGGER) ? RAILS_DEFAULT_LOGGER : nil
+      when :merb
+        Merb.logger
+      else
+        nil
+      end
+    end
+  
+  end
+end

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

@@ -0,0 +1,4 @@
+require "webrat/core/matchers/have_xpath"
+require "webrat/core/matchers/have_selector"
+require "webrat/core/matchers/have_tag"
+require "webrat/core/matchers/have_content"

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

@@ -0,0 +1,73 @@
+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)
+        when Regexp
+          @element.match(@content)
+        end
+      end
+      
+      # ==== Returns
+      # String:: The failure message.
+      def failure_message
+        "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#{squeeze_space(@element)}"
+      end
+      
+      def squeeze_space(inner_text)
+        inner_text.gsub(/^\s*$/, "").squeeze("\n")
+      end
+      
+      def content_message
+        case @content
+        when String
+          "include \"#{@content}\""
+        when Regexp
+          "match #{@content.inspect}"
+        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)
+      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

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

@@ -0,0 +1,74 @@
+require "webrat/core/matchers/have_xpath"
+
+module Webrat
+  module Matchers
+    
+    class HaveSelector < HaveXpath #: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 = @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.parse(@expected.to_s).map do |ast|
+          ast.to_xpath
+        end.first
+      end
+      
+    end
+    
+    # Matches HTML content against a CSS 3 selector.
+    #
+    # ==== Parameters
+    # expected<String>:: The CSS selector to look for.
+    #
+    # ==== Returns
+    # HaveSelector:: A new have selector matcher.
+    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(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(name, attributes = {}, &block)
+      matcher = HaveSelector.new(name, attributes, &block)
+      assert !matcher.matches?(response_body), matcher.negative_failure_message
+    end
+    
+  end
+end

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

@@ -0,0 +1,21 @@
+require "webrat/core/matchers/have_selector"
+
+module Webrat
+  module HaveTagMatcher
+
+    def have_tag(*args, &block)
+      have_selector(*args, &block)
+    end
+    
+    alias_method :match_tag, :have_tag
+    
+    def assert_have_tag(*args, &block)
+      assert_have_selector(*args, &block)
+    end
+    
+    def assert_have_no_tag(*args, &block)
+      assert_have_no_selector(*args, &block)
+    end
+
+  end
+end

data/vendor/webrat/lib/webrat/core/matchers/have_xpath.rb

@@ -0,0 +1,147 @@
+require "webrat/core/xml/nokogiri"
+require "webrat/core/xml/rexml"
+
+module Webrat
+  module Matchers
+    
+    class HaveXpath #:nodoc:
+      def initialize(expected, options = {}, &block)
+        @expected = expected
+        @options  = options
+        @block    = block
+      end
+    
+      def matches?(stringlike, &block)
+        @block ||= block
+        matched = matches(stringlike)
+        
+        if @options[:count]
+          matched.size == @options[:count] && (!@block || @block.call(matched))
+        else
+          matched.any? && (!@block || @block.call(matched))
+        end
+      end
+      
+      def matches(stringlike)
+        if Webrat.configuration.parse_with_nokogiri?
+          nokogiri_matches(stringlike)
+        else
+          rexml_matches(stringlike)
+        end
+      end
+    
+      def rexml_matches(stringlike)
+        if REXML::Node === stringlike || Array === stringlike
+          @query = query.map { |q| q.gsub(%r'//', './') }
+        else
+          @query = query
+        end
+
+        add_options_conditions_to(@query)
+
+        @document = Webrat.rexml_document(stringlike)
+
+        @query.map do |q|
+          if @document.is_a?(Array)
+            @document.map { |d| REXML::XPath.match(d, q) }
+          else
+            REXML::XPath.match(@document, q)
+          end
+        end.flatten.compact
+      end
+    
+      def nokogiri_matches(stringlike)
+        if Nokogiri::XML::NodeSet === stringlike
+          @query = query.gsub(%r'//', './')
+        else
+          @query = query
+        end
+        
+        add_options_conditions_to(@query)
+        
+        @document = Webrat::XML.document(stringlike)
+        @document.xpath(*@query)
+      end
+      
+      def add_options_conditions_to(query)
+        add_attributes_conditions_to(query)
+        add_content_condition_to(query)
+      end
+      
+      def add_attributes_conditions_to(query)
+        attribute_conditions = []
+        
+        @options.each do |key, value|
+          next if [:content, :count].include?(key)
+          attribute_conditions << "@#{key} = #{xpath_escape(value)}"
+        end
+        
+        if attribute_conditions.any?
+          query << "[#{attribute_conditions.join(' and ')}]"
+        end
+      end
+      
+      def add_content_condition_to(query)
+        if @options[:content]
+          query << "[contains(., #{xpath_escape(@options[:content])})]"
+        end
+      end
+      
+      def query
+        @expected
+      end
+    
+      # ==== Returns
+      # String:: The failure message.
+      def failure_message
+        "expected following text to match xpath #{@expected}:\n#{@document}"
+      end
+
+      # ==== Returns
+      # String:: The failure message to be displayed in negative matches.
+      def negative_failure_message
+        "expected following text to not match xpath #{@expected}:\n#{@document}"
+      end
+      
+    protected
+    
+      def xpath_escape(string)
+        if string.include?("'") && string.include?('"')
+          parts = string.split("'").map do |part|
+            "'#{part}'"
+          end
+          
+          "concat(" + parts.join(", \"'\", ") + ")"
+        elsif string.include?("'")
+          "\"#{string}\""
+        else
+          "'#{string}'"
+        end
+      end
+      
+    end
+    
+    # Matches HTML content against an XPath query
+    #
+    # ==== Parameters
+    # expected<String>:: The XPath query to look for.
+    #
+    # ==== Returns
+    # HaveXpath:: A new have xpath matcher.
+    def have_xpath(expected, options = {}, &block)
+      HaveXpath.new(expected, options, &block)
+    end
+    alias_method :match_xpath, :have_xpath
+    
+    def assert_have_xpath(expected, options = {}, &block)
+      hs = HaveXpath.new(expected, options, &block)
+      assert hs.matches?(response_body), hs.failure_message
+    end
+    
+    def assert_have_no_xpath(expected, options = {}, &block)
+      hs = HaveXpath.new(expected, options, &block)
+      assert !hs.matches?(response_body), hs.negative_failure_message
+    end
+    
+  end
+end