sum 0.1.1 → 0.1.2

data/vendor/webrat/lib/webrat/core/xml/rexml.rb

@@ -1,24 +0,0 @@
-module Webrat
-
-  def self.rexml_document(stringlike)
-    stringlike = stringlike.body.to_s if stringlike.respond_to?(:body)
-
-    case stringlike
-    when REXML::Document
-      stringlike.root
-    when REXML::Node, Array
-      stringlike
-    else
-      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
-
-end

data/vendor/webrat/lib/webrat/core_extensions/blank.rb

@@ -1,58 +0,0 @@
-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/vendor/webrat/lib/webrat/core_extensions/deprecate.rb

@@ -1,8 +0,0 @@
-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/vendor/webrat/lib/webrat/core_extensions/detect_mapped.rb

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

data/vendor/webrat/lib/webrat/core_extensions/meta_class.rb

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

data/vendor/webrat/lib/webrat/core_extensions/nil_to_param.rb

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

data/vendor/webrat/lib/webrat/core_extensions/tcp_socket.rb

@@ -1,27 +0,0 @@
-class TCPSocket
-
-  def self.wait_for_service_with_timeout(options)
-    start_time = Time.now
-
-    until listening_service?(options)
-      verbose_wait
-
-      if options[:timeout] && (Time.now > start_time + options[:timeout])
-        raise SocketError.new("Socket did not open within #{options[:timeout]} seconds")
-      end
-    end
-  end
-
-  def self.wait_for_service_termination_with_timeout(options)
-    start_time = Time.now
-
-    while listening_service?(options)
-      verbose_wait
-
-      if options[:timeout] && (Time.now > start_time + options[:timeout])
-        raise SocketError.new("Socket did not terminate within #{options[:timeout]} seconds")
-      end
-    end
-  end
-
-end

data/vendor/webrat/lib/webrat/mechanize.rb

@@ -1,74 +0,0 @@
-require "mechanize"
-
-module Webrat #:nodoc:
-  class MechanizeSession < Session #:nodoc:
-
-    attr_accessor :response
-    alias :page :response
-
-    def request_page(url, http_method, data) #:nodoc:
-      super(absolute_url(url), http_method, data)
-    end
-
-    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
-
-    def absolute_url(url) #:nodoc:
-      current_host, current_path = split_current_url
-      if url =~ Regexp.new('^https?://')
-        url
-      elsif url =~ Regexp.new('^/')
-        current_host + url
-      elsif url =~ Regexp.new('^\.')
-        current_host + absolute_path(current_path, url)
-      else
-        url
-      end
-    end
-
-    private
-      def split_current_url
-        current_url =~ Regexp.new('^(https?://[^/]+)(/.*)?')
-        [Regexp.last_match(1), Regexp.last_match(2)]
-      end
-
-      def absolute_path(current_path, url)
-        levels_up = url.split('/').find_all { |x| x == '..' }.size
-        ancestor = if current_path.nil?
-          ""
-        else
-          current_path.split("/")[0..(-1 - levels_up)].join("/")
-        end
-        descendent = url.split("/")[levels_up..-1].join
-        "#{ancestor}/#{descendent}"
-      end
-  end
-end

data/vendor/webrat/lib/webrat/merb.rb

@@ -1,9 +0,0 @@
-require "webrat"
-
-# This is a temporary hack to support backwards compatibility
-# with Merb 1.0.8 until it's updated to use the new Webrat.configure
-# syntax
-
-Webrat.configure do |config|
-  config.mode = :merb
-end

data/vendor/webrat/lib/webrat/merb_multipart_support.rb

@@ -1,27 +0,0 @@
-module Webrat
-
-  # These methods are copied from merb-core/two-oh.rb which defines new
-  # multipart_post and multipart_put methods for Merb::Test::MultipartRequestHelper.
-  # We can't require two-oh.rb because it alters Merb's own behavior, causing
-  # failing specs in Merb when Webrat is required.
-  module MerbMultipartSupport
-    def multipart_request(path, params = {}, env = {})
-      multipart = Merb::Test::MultipartRequestHelper::Post.new(params)
-      body, head = multipart.to_multipart
-      env["CONTENT_TYPE"] = head
-      env["CONTENT_LENGTH"] = body.size
-      env[:input] = StringIO.new(body)
-      request(path, env)
-    end
-
-    def multipart_post(path, params = {}, env = {})
-      env[:method] = "POST"
-      multipart_request(path, params, env)
-    end
-
-    def multipart_put(path, params = {}, env = {}, &block)
-      env[:method] = "PUT"
-      multipart_request(path, params, env)
-    end
-  end
-end

data/vendor/webrat/lib/webrat/merb_session.rb

@@ -1,82 +0,0 @@
-require "webrat"
-require "merb-core"
-require "webrat/merb_multipart_support"
-
-module Webrat
-  class MerbSession #:nodoc:
-    include Merb::Test::MakeRequest
-
-    # Include Webrat's own version of multipart_post/put because the officially
-    # supported methods in Merb don't perform the request correctly.
-    include MerbMultipartSupport
-
-    attr_accessor :response
-
-    def initialize(context=nil); end
-
-    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)
-      if method == "POST" && has_file?(data)
-        @response = multipart_post(url, data, :headers => headers)
-
-      elsif method == "PUT" && has_file?(data)
-        @response = multipart_put(url, data, :headers => headers)
-
-      else
-        @response = request(url,
-          :params => (data && data.any?) ? data : nil,
-          :headers => headers,
-          :method => method)
-      end
-    end
-
-    protected
-
-      # Recursively search the data for a file attachment.
-      def has_file?(data)
-        data.each do |key, value|
-          if value.is_a?(Hash)
-            return has_file?(value)
-          else
-            return true if value.is_a?(File)
-          end
-        end
-        return false
-      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
-    end
-  end
-end

data/vendor/webrat/lib/webrat/rack.rb

@@ -1,25 +0,0 @@
-require "rack/test"
-
-module Webrat
-  class RackSession
-    extend Forwardable
-
-    def_delegators :@session, :get, :post, :put, :delete
-
-    def initialize(session) #:nodoc:
-      @session = session
-    end
-
-    def response_body
-      response.body
-    end
-
-    def response_code
-      response.status
-    end
-
-    def response
-      @session.last_response
-    end
-  end
-end

data/vendor/webrat/lib/webrat/rails.rb

@@ -1,106 +0,0 @@
-require "webrat"
-
-require "action_controller"
-require "action_controller/integration"
-require "action_controller/record_identifier"
-
-module Webrat
-  class RailsSession #:nodoc:
-    include ActionController::RecordIdentifier
-
-    attr_reader :integration_session
-
-    def initialize(session)
-      @integration_session = session
-    end
-
-    # The Rails version of within supports passing in a model and Webrat
-    # will apply a scope based on Rails' dom_id for that model.
-    #
-    # Example:
-    #   within User.last do
-    #     click_link "Delete"
-    #   end
-    def within(selector_or_object, &block)
-      if selector_or_object.is_a?(String)
-        super
-      else
-        super('#' + dom_id(selector_or_object), &block)
-      end
-    end
-
-    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 do_request(http_method, url, data, headers) #:nodoc:
-      update_protocol(url)
-      integration_session.send(http_method, normalize_url(url), data, headers)
-    end
-
-    # remove protocol, host and anchor
-    def normalize_url(href) #:nodoc:
-      uri = URI.parse(href)
-      normalized_url = []
-      normalized_url << "#{uri.scheme}://" if uri.scheme
-      normalized_url << uri.host if uri.host
-      normalized_url << ":#{uri.port}" if uri.port && ![80,443].include?(uri.port)
-      normalized_url << uri.path if uri.path
-      normalized_url << "?#{uri.query}" if uri.query
-      normalized_url.join
-    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:
-  IntegrationTest.class_eval do
-    include Webrat::Methods
-    include Webrat::Matchers
-  end
-end