aslakhellesoy-webrat 0.3.2.1

data/lib/webrat/core_extensions/blank.rb

@@ -0,0 +1,58 @@
+class Object #:nodoc:
+  # An object is blank if it's false, empty, or a whitespace string.
+  # For example, "", "   ", +nil+, [], and {} are blank.
+  #
+  # This simplifies
+  #
+  #   if !address.nil? && !address.empty?
+  #
+  # to
+  #
+  #   if !address.blank?
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+    
+  # An object is present if it's not blank.
+  def present?
+    !blank?
+  end
+end
+
+class NilClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class FalseClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class TrueClass #:nodoc:
+  def blank?
+    false
+  end
+end
+
+class Array #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class Hash #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class String #:nodoc:
+  def blank?
+    self !~ /\S/
+  end
+end
+
+class Numeric #:nodoc:
+  def blank?
+    false
+  end
+end

data/lib/webrat/core_extensions/deprecate.rb

@@ -0,0 +1,8 @@
+class Module #:nodoc:
+  def webrat_deprecate(old_method_name, new_method_name)
+    define_method old_method_name do |*args|
+      warn "#{old_method_name} is deprecated. Use #{new_method_name} instead."
+      __send__(new_method_name, *args)
+    end
+  end
+end

data/lib/webrat/core_extensions/detect_mapped.rb

@@ -0,0 +1,12 @@
+class Array #:nodoc:
+  
+  def detect_mapped
+    each do |element|
+      result = yield element
+      return result if result
+    end
+    
+    return nil
+  end
+  
+end

data/lib/webrat/core_extensions/hash_with_indifferent_access.rb

@@ -0,0 +1,131 @@
+# This class has dubious semantics and we only have it so that
+# people can write params[:key] instead of params['key']
+# and they get the same value for both keys.
+class HashWithIndifferentAccess < Hash #:nodoc:
+  def initialize(constructor = {})
+    if constructor.is_a?(Hash)
+      super()
+      update(constructor)
+    else
+      super(constructor)
+    end
+  end
+
+  def default(key = nil)
+    if key.is_a?(Symbol) && include?(key = key.to_s)
+      self[key]
+    else
+      super
+    end
+  end
+
+  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+  alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+  #
+  # Assigns a new value to the hash.
+  #
+  # Example:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash[:key] = "value"
+  #
+  def []=(key, value)
+    regular_writer(convert_key(key), convert_value(value))
+  end
+
+  # 
+  # Updates the instantized hash with values from the second.
+  # 
+  # Example:
+  # 
+  #   >> hash_1 = HashWithIndifferentAccess.new
+  #   => {}
+  # 
+  #   >> hash_1[:key] = "value"
+  #   => "value"
+  # 
+  #   >> hash_2 = HashWithIndifferentAccess.new
+  #   => {}
+  # 
+  #   >> hash_2[:key] = "New Value!"
+  #   => "New Value!"
+  # 
+  #   >> hash_1.update(hash_2)
+  #   => {"key"=>"New Value!"}
+  # 
+  def update(other_hash)
+    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+    self
+  end
+
+  alias_method :merge!, :update
+
+  # Checks the hash for a key matching the argument passed in
+  def key?(key)
+    super(convert_key(key))
+  end
+
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  # Fetches the value for the specified key, same as doing hash[key]
+  def fetch(key, *extras)
+    super(convert_key(key), *extras)
+  end
+
+  # Returns an array of the values at the specified indicies. 
+  def values_at(*indices)
+    indices.collect {|key| self[convert_key(key)]}
+  end
+
+  # Returns an exact copy of the hash.
+  def dup
+    HashWithIndifferentAccess.new(self)
+  end
+
+  # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
+  # Does not overwrite the existing hash.
+  def merge(hash)
+    self.dup.update(hash)
+  end
+
+  # Removes a specified key from the hash.
+  def delete(key)
+    super(convert_key(key))
+  end
+
+  def stringify_keys!; self end
+  def symbolize_keys!; self end
+  def to_options!; self end
+
+  # Convert to a Hash with String keys.
+  def to_hash
+    Hash.new(default).merge(self)
+  end
+
+  protected
+    def convert_key(key)
+      key.kind_of?(Symbol) ? key.to_s : key
+    end
+
+    def convert_value(value)
+      case value
+      when Hash
+        value.with_indifferent_access
+      when Array
+        value.collect { |e| e.is_a?(Hash) ? e.with_indifferent_access : e }
+      else
+        value
+      end
+    end
+end
+
+class Hash #:nodoc:
+  def with_indifferent_access
+    hash = HashWithIndifferentAccess.new(self)
+    hash.default = self.default
+    hash
+  end
+end

data/lib/webrat/core_extensions/meta_class.rb

@@ -0,0 +1,6 @@
+class ::Object #:nodoc:
+  def meta_class
+    class << self; self end
+  end
+end
+    

data/lib/webrat/core_extensions/nil_to_param.rb

@@ -0,0 +1,5 @@
+class NilClass #:nodoc:
+  def to_param
+    nil
+  end
+end

data/lib/webrat/mechanize.rb

@@ -0,0 +1,43 @@
+require "mechanize"
+
+module Webrat #:nodoc:
+  class MechanizeSession < Session #:nodoc:
+    
+    attr_accessor :response
+    alias :page :response
+    
+    def get(url, data, headers_argument_not_used = nil)
+      @response = mechanize.get(url, data)
+    end
+
+    def post(url, data, headers_argument_not_used = nil)
+      post_data = data.inject({}) do |memo, param|
+        case param.last
+        when Hash
+          param.last.each {|attribute, value| memo["#{param.first}[#{attribute}]"] = value }
+        else
+          memo[param.first] = param.last
+        end
+        memo
+      end
+      @response = mechanize.post(url, post_data)
+    end
+    
+    def response_body
+      @response.content
+    end
+
+    def response_code
+      @response.code.to_i
+    end
+    
+    def mechanize
+      @mechanize = WWW::Mechanize.new
+    end
+
+    def_delegators :mechanize, :basic_auth
+      
+  end
+end
+
+Webrat.configuration.mode = :mechanize

data/lib/webrat/merb.rb

@@ -0,0 +1,77 @@
+require "webrat"
+
+require "cgi"
+gem "extlib"
+require "extlib"
+require "merb-core"
+
+HashWithIndifferentAccess = Mash
+
+module Webrat
+  class MerbSession < Session #:nodoc:
+    include Merb::Test::MakeRequest
+    
+    attr_accessor :response
+    
+    def get(url, data, headers = nil)
+      do_request(url, data, headers, "GET")
+    end
+  
+    def post(url, data, headers = nil)
+      do_request(url, data, headers, "POST")
+    end
+  
+    def put(url, data, headers = nil)
+      do_request(url, data, headers, "PUT")
+    end
+  
+    def delete(url, data, headers = nil)
+      do_request(url, data, headers, "DELETE")
+    end
+    
+    def response_body
+      @response.body.to_s
+    end
+    
+    def response_code
+      @response.status
+    end
+    
+    def do_request(url, data, headers, method)
+      @response = request(url, 
+        :params => (data && data.any?) ? data : nil, 
+        :headers => headers,
+        :method => method)
+      follow_redirect
+    end
+    
+    def follow_redirect
+      self.get(@response.headers['Location'], nil, @response.headers) if @response.status == 302
+    end
+
+  end
+end
+
+module Merb #:nodoc:
+  module Test #:nodoc:
+    module RequestHelper #:nodoc:
+      def request(uri, env = {})
+        @_webrat_session ||= Webrat::MerbSession.new
+        @_webrat_session.response = @_webrat_session.request(uri, env)
+      end
+  
+      def follow_redirect
+        @_webrat_session.follow_redirect
+      end
+    end
+  end
+end
+
+class Merb::Test::RspecStory #:nodoc:
+  def browser
+    @browser ||= Webrat::MerbSession.new
+  end
+end
+
+Webrat.configuration.mode = :merb
+

data/lib/webrat/rack.rb

@@ -0,0 +1,26 @@
+require 'webrat'
+
+class CGIMethods #:nodoc:
+  def self.parse_query_parameters(params)
+    hash = {}
+    params.split('&').each do |p|
+      pair = p.split('=')
+      hash[pair[0]] = pair[1]
+    end
+    hash
+  end
+end
+
+module Webrat
+  class RackSession < Session #:nodoc:
+    def response_body
+      @response.body
+    end
+
+    def response_code
+      @response.status
+    end
+  end
+end
+
+Webrat.configuration.mode = :rack

data/lib/webrat/rails.rb

@@ -0,0 +1,96 @@
+require "webrat"
+require "action_controller/integration"
+
+module Webrat
+  class RailsSession < Session #:nodoc:
+
+    def doc_root
+      File.expand_path(File.join(RAILS_ROOT, 'public'))
+    end
+    
+    def saved_page_dir
+      File.expand_path(File.join(RAILS_ROOT, "tmp"))
+    end
+    
+    def get(url, data, headers = nil)
+      do_request(:get, url, data, headers)
+    end
+    
+    def post(url, data, headers = nil)
+      do_request(:post, url, data, headers)
+    end
+    
+    def put(url, data, headers = nil)
+      do_request(:put, url, data, headers)
+    end
+    
+    def delete(url, data, headers = nil)
+      do_request(:delete, url, data, headers)
+    end
+    
+    def response_body
+      response.body
+    end
+    
+    def response_code
+      response.code.to_i
+    end
+    
+    def xml_content_type?
+      response.headers["Content-Type"].to_s =~ /xml/
+    end
+    
+  protected
+    
+    def integration_session
+      @context
+    end
+    
+    def do_request(http_method, url, data, headers) #:nodoc:
+      update_protocol(url)
+      url = normalize_url(url)
+      integration_session.request_via_redirect(http_method, url, data, headers)
+    end
+  
+    # remove protocol, host and anchor
+    def normalize_url(href) #:nodoc:
+      uri = URI.parse(href)
+      normalized_url = uri.path
+      if uri.query
+        normalized_url += "?" + uri.query
+      end
+      normalized_url
+    end
+    
+    def update_protocol(href) #:nodoc:
+      if href =~ /^https:/
+        integration_session.https!(true)
+      elsif href =~ /^http:/
+        integration_session.https!(false)
+      end
+    end
+    
+    def response #:nodoc:
+      integration_session.response
+    end
+    
+  end
+end
+
+module ActionController #:nodoc:
+  module Integration #:nodoc:
+    Session.class_eval do
+      unless instance_methods.include?("put_via_redirect")
+        require "webrat/rails/redirect_actions"
+        include Webrat::RedirectActions
+      end
+    end
+  end
+  
+  IntegrationTest.class_eval do
+    include Webrat::Methods
+    include Webrat::Matchers
+  end
+end
+
+Webrat.configuration.mode = :rails