mkuklis-webrat 0.5.1 → 0.6.rc1

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

@@ -1,74 +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
+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/lib/webrat/core/matchers/have_tag.rb

@@ -1,21 +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
+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/lib/webrat/core/matchers/have_xpath.rb

@@ -1,122 +1,122 @@
-require "webrat/core/xml"
-
-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].to_i && (!@block || @block.call(matched))
-        else
-          matched.any? && (!@block || @block.call(matched))
-        end
-      end
-
-      def matches(stringlike)
-        nokogiri_matches(stringlike)
-      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
+require "webrat/core/xml"
+
+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].to_i && (!@block || @block.call(matched))
+        else
+          matched.any? && (!@block || @block.call(matched))
+        end
+      end
+
+      def matches(stringlike)
+        nokogiri_matches(stringlike)
+      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

data/lib/webrat/core/matchers.rb

@@ -1,4 +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"
+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/lib/webrat/core/methods.rb

@@ -1,64 +1,64 @@
-module Webrat
-  module Methods #:nodoc:
-
-    def self.delegate_to_session(*meths)
-      meths.each do |meth|
-        self.class_eval <<-RUBY
-          def #{meth}(*args, &blk)
-            webrat_session.#{meth}(*args, &blk)
-          end
-        RUBY
-      end
-    end
-
-    def webrat
-      webrat_session
-    end
-
-    def webrat_session
-      @_webrat_session ||= begin
-        session = Webrat.session_class.new
-        session.adapter = Webrat.adapter_class.new(self) if session.respond_to?(:adapter=)
-        session
-      end
-    end
-
-    # all of these methods delegate to the @session, which should
-    # be created transparently.
-    #
-    # Note that when using Webrat, #request also uses @session, so
-    # that #request and webrat native functions behave interchangably
-
-    delegate_to_session \
-      :visits, :visit,
-      :within,
-      :header, :http_accept, :basic_auth,
-      :save_and_open_page,
-      :fills_in, :fill_in,
-      :checks, :check,
-      :unchecks, :uncheck,
-      :chooses, :choose,
-      :selects, :select,
-      :unselects, :unselect,
-      :attaches_file, :attach_file,
-      :current_page,
-      :current_url,
-      :clicks_link, :click_link,
-      :clicks_area, :click_area,
-      :clicks_button, :click_button,
-      :reload, :reloads,
-      :clicks_link_within, :click_link_within,
-      :field_labeled,
-      :select_option,
-      :set_hidden_field, :submit_form,
-      :request_page, :current_dom,
-      :response_body,
-      :selects_date, :selects_time, :selects_datetime,
-      :select_date, :select_time, :select_datetime,
-      :field_by_xpath,
-      :field_with_id,
-      :selenium,
-      :simulate, :automate,
-      :field_named
-  end
-end
+module Webrat
+  module Methods #:nodoc:
+
+    def self.delegate_to_session(*meths)
+      meths.each do |meth|
+        self.class_eval <<-RUBY
+          def #{meth}(*args, &blk)
+            webrat_session.#{meth}(*args, &blk)
+          end
+        RUBY
+      end
+    end
+
+    def webrat
+      webrat_session
+    end
+
+    def webrat_session
+      @_webrat_session ||= begin
+        session = Webrat.session_class.new
+        session.adapter = Webrat.adapter_class.new(self) if session.respond_to?(:adapter=)
+        session
+      end
+    end
+
+    # all of these methods delegate to the @session, which should
+    # be created transparently.
+    #
+    # Note that when using Webrat, #request also uses @session, so
+    # that #request and webrat native functions behave interchangably
+
+    delegate_to_session \
+      :visits, :visit,
+      :within,
+      :header, :http_accept, :basic_auth,
+      :save_and_open_page,
+      :fills_in, :fill_in,
+      :checks, :check,
+      :unchecks, :uncheck,
+      :chooses, :choose,
+      :selects, :select,
+      :unselects, :unselect,
+      :attaches_file, :attach_file,
+      :current_page,
+      :current_url,
+      :clicks_link, :click_link,
+      :clicks_area, :click_area,
+      :clicks_button, :click_button,
+      :reload, :reloads,
+      :clicks_link_within, :click_link_within,
+      :field_labeled,
+      :select_option,
+      :set_hidden_field, :submit_form,
+      :request_page, :current_dom,
+      :response_body,
+      :selects_date, :selects_time, :selects_datetime,
+      :select_date, :select_time, :select_datetime,
+      :field_by_xpath,
+      :field_with_id,
+      :selenium,
+      :simulate, :automate,
+      :field_named
+  end
+end

data/lib/webrat/core/mime.rb

@@ -1,18 +1,18 @@
-module Webrat #:nodoc:
-  module MIME #:nodoc:
-    MIME_TYPES = Rack::Mime::MIME_TYPES.dup.merge(
-      ".multipart_form"   => "multipart/form-data",
-      ".url_encoded_form" => "application/x-www-form-urlencoded"
-    ).freeze
-
-    def mime_type(type)
-      return type if type.nil? || type.to_s.include?("/")
-      type = ".#{type}" unless type.to_s[0] == ?.
-      MIME_TYPES.fetch(type) { |type|
-        raise ArgumentError.new("Invalid Mime type: #{type}")
-      }
-    end
-
-    module_function :mime_type
-  end
-end
+module Webrat #:nodoc:
+  module MIME #:nodoc:
+    MIME_TYPES = Rack::Mime::MIME_TYPES.dup.merge(
+      ".multipart_form"   => "multipart/form-data",
+      ".url_encoded_form" => "application/x-www-form-urlencoded"
+    ).freeze
+
+    def mime_type(type)
+      return type if type.nil? || type.to_s.include?("/")
+      type = ".#{type}" unless type.to_s[0] == ?.
+      MIME_TYPES.fetch(type) { |type|
+        raise ArgumentError.new("Invalid Mime type: #{type}")
+      }
+    end
+
+    module_function :mime_type
+  end
+end