metry 1.0.0

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

@@ -0,0 +1,24 @@
+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

@@ -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/vendor/webrat/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/vendor/webrat/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/vendor/webrat/lib/webrat/core_extensions/meta_class.rb

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

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

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

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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,80 @@
+require "webrat"
+require "merb-core"
+require "webrat/merb_multipart_support"
+
+module Webrat
+  class MerbSession < Session #: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 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

@@ -0,0 +1,24 @@
+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

data/vendor/webrat/lib/webrat/rack_test.rb

@@ -0,0 +1,32 @@
+module Webrat
+  class RackTestSession < Session
+
+    def initialize(rack_test_session) #:nodoc:
+      super()
+      @rack_test_session = rack_test_session
+    end
+
+    def response_body
+      response.body
+    end
+
+    def response_code
+      response.status
+    end
+
+    def response
+      @rack_test_session.last_response
+    end
+
+  protected
+
+    def process_request(http_method, url, data = {}, headers = {})
+      headers ||= {}
+      data    ||= {}
+
+      env = headers.merge(:params => data, :method => http_method.to_s.upcase)
+      @rack_test_session.request(url, env)
+    end
+
+  end
+end

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

@@ -0,0 +1,105 @@
+require "webrat"
+
+require "action_controller"
+require "action_controller/integration"
+require "action_controller/record_identifier"
+
+module Webrat
+  class RailsSession < Session #:nodoc:
+    include ActionController::RecordIdentifier
+
+    # 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 integration_session
+      @context
+    end
+
+    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