merb 0.5.3 → 0.9.2

data/lib/merb/test/hpricot.rb

@@ -1,136 +0,0 @@
-# http://yehudakatz.com/2007/01/27/a-better-assert_select-assert_elements/
-# based on assert_elements
-# Author: Yehuda Katz
-# Email:  wycats @nospam@ gmail.com
-# Web:    http://www.yehudakatz.com
-#
-# which was based on HpricotTestHelper
-# Author: Luke Redpath
-# Email: contact @nospam@ lukeredpath.co.uk
-# Web: www.lukeredpath.co.uk / opensource.agileevolved.com
-
-require 'hpricot'
-
-class Hpricot::Elem
-  def should_contain(value)
-    self.inner_text.include?(value)
-  end
-
-  def should_match(regex)
-    self.inner_text.match(regex)
-  end
-  
-  # courtesy of 'thomas' from the comments
-  # of _whys blog - get in touch if you want a better credit!
-  def inner_text
-    self.children.collect do |child|
-      child.is_a?(Hpricot::Text) ? child.content : ((child.respond_to?("inner_text") && child.inner_text) || "")
-    end.join.strip
-  end
-end
-
-module HpricotTestHelper
-  # returns the inner content of
-  # the first tag found by the css query
-  def tag(css_query)
-    process_output
-    @output.content_for(css_query)
-  end
-  
-  # returns an array of tag contents
-  # for all of the tags found by the
-  # css query
-  def tags(css_query)
-    process_output
-    @output.content_for_all(css_query)
-  end
-  
-  # returns a raw Hpricot::Elem object
-  # for the first result found by the query
-  def element(css_query)
-    process_output
-    @output[css_query].first
-  end
-  
-  # returns an array of Hpricot::Elem objects
-  # for the results found by the query
-  def elements(css_query)
-    process_output
-    Hpricot::Elements[*css_query.split(",").map(&:strip).map do |query|
-      @output[query]
-    end.flatten]
-  end
-  
-  def get_elements css_query, text
-    els = elements(css_query)
-    case text
-      when String then els.reject! {|t| !t.should_contain(text) }
-      when Regexp then els.reject! {|t| !t.should_match(text) }
-    end
-    els
-  end
-  
-  def assert_elements css_query, equality = nil, &block
-    message = equality.delete(:message) if equality.is_a?(Hash)
-
-    case equality
-      when Numeric then equality = {:count => equality}
-      when Range then equality = {:minimum => equality.to_a.first, :maximum => equality.to_a.last }
-      else equality ||= {}
-    end
-    
-    equality.merge!({:minimum => 1}) if (equality.keys & [:minimum, :maximum, :count]).empty?
-    
-    els = get_elements(css_query, equality[:text])
-
-    ret = equality.keys.include?(:minimum) ? (els.size >= equality[:minimum]) : true 
-    ret &&= (els.size <= equality[:maximum]) if equality.keys.include?(:maximum)
-    ret &&= (els.size == equality[:count]) if equality.keys.include?(:count)
-    
-    if block && !els.empty?
-      ret &&= self.dup.instance_eval do
-        @output = HpricotTestHelper::DocumentOutput.new(els.inner_html)
-        @block = true 
-        instance_eval(&block)
-      end
-    end
-    
-    if(equality[:count] != 0)
-      assert ret, "#{ message } \"#{ css_query }\" with \"#{ equality.inspect }\" was not found."
-    else
-      assert ret, "#{ message } \"#{ css_query }\" with \"#{ equality.reject{|k,v| k == :count}.inspect }\" was found, but you specified :count => 0."
-    end
-    ret
-  end
-  
-  # small utility class for working with
-  # the Hpricot parser class
-  class DocumentOutput
-    def initialize(response_body)
-      @parser = Hpricot.parse(response_body)
-    end
-
-    def content_for(css_query)
-      @parser.search(css_query).first.inner_text
-    end
-
-    def content_for_all(css_query)
-      @parser.search(css_query).collect(&:inner_text)
-    end
-
-    def [](css_query)
-      @parser.search(css_query)
-    end
-  end
-  
-  protected
-    # creates a new DocumentOutput object from the response
-    # body if hasn't already been created. This is
-    # called automatically by the element and tag methods
-    def process_output
-      if !@block && (@output.nil? || (@controller.body != @response_output))
-        @output = HpricotTestHelper::DocumentOutput.new(@controller.body)
-        @response_output = @controller.body  
-      end
-    end
-end

data/lib/merb/test/multipart.rb

@@ -1,66 +0,0 @@
-module Merb
-  module Test
-    module Multipart
-      require 'rubygems'
-      require 'mime/types'
-
-      class Param
-        attr_accessor :key, :value
-        def initialize(key, value)
-          @key   = key
-          @value = value
-        end
-
-        def to_multipart
-          return %(Content-Disposition: form-data; name="#{key}"\r\n\r\n#{value}\r\n)
-        end
-      end
-
-      class FileParam
-        attr_accessor :key, :filename, :content
-        def initialize(key, filename, content)
-          @key      = key
-          @filename = filename
-          @content  = content
-        end
-
-        def to_multipart
-          return %(Content-Disposition: form-data; name="#{key}"; filename="#{filename}"\r\n) + "Content-Type: #{MIME::Types.type_for(@filename)}\r\n\r\n" + content + "\r\n"
-        end
-      end
-      
-      class Post
-        BOUNDARY = '----------0xKhTmLbOuNdArY'
-        CONTENT_TYPE = "multipart/form-data, boundary=" + BOUNDARY
-
-        def initialize(params = {})
-          @multipart_params = []
-          push_params(params)
-        end
-        
-        def push_params(params, prefix = nil)
-          params.sort_by {|k| k.to_s}.each do |key, value|
-            param_key = prefix.nil? ? key : "#{prefix}[#{key}]"
-            if value.respond_to?(:read)
-              @multipart_params << FileParam.new(param_key, value.path, value.read)
-            else
-              if value.is_a?(Hash) || value.is_a?(Mash)
-                value.keys.each do |k|
-                  push_params(value, param_key)
-                end
-              else
-                @multipart_params << Param.new(param_key, value)
-              end
-            end
-          end
-        end
-
-        def to_multipart
-          query = @multipart_params.collect { |param| "--" + BOUNDARY + "\r\n" + param.to_multipart }.join("") + "--" + BOUNDARY + "--"
-          return query, CONTENT_TYPE
-        end
-      end 
-     
-    end    
-  end
-end

data/lib/merb/test/rspec.rb

@@ -1,18 +0,0 @@
-require 'hpricot'
-require 'spec'
-
-# Get all the rspec matchers for merb and include them
-Dir[(File.dirname(__FILE__) + "/rspec_matchers/**/*.rb")].each do |file|
-  require "#{file[0...-3]}"
-end
-
-module Merb
-  module Test
-    module RspecMatchers
-      
-      include ControllerMatchers
-      include MarkupMatchers
-
-    end
-  end
-end

data/lib/merb/test/rspec_matchers/controller_matchers.rb

@@ -1,117 +0,0 @@
-module Merb
-  module Test
-    module ControllerMatchers
-      
-      class BeRedirect
-        def matches?(target)
-          @target = target
-          [301, 302].include? target
-        end
-        def failure_message
-          "expected to redirect"
-        end
-        def negative_failure_message
-          "expected not to redirect"
-        end
-      end
-
-      class Redirect
-        def matches?(target)
-          @target = target
-          BeRedirect.new.matches?(target.status)
-        end
-        def failure_message
-          "expected #{@target.inspect} to redirect"
-        end
-        def negative_failure_message
-          "expected #{@target.inspect} not to redirect"
-        end
-      end
-
-      class RedirectTo
-        def initialize(expected)
-          @expected = expected
-        end
-
-        def matches?(target)
-          @target = target.headers['Location']
-          @redirected = BeRedirect.new.matches?(target.status)
-          @target == @expected
-        end
-
-        def failure_message
-          msg = "expected a redirect to <#{@expected}>, but "
-          if @redirected
-            msg << "found one to <#{@target}>" 
-          else
-            msg << "there was no redirect"
-          end
-        end
-
-        def negative_failure_message
-          "expected not to redirect to <#{@expected}>, but did anyway"
-        end
-      end
-
-      class BeSuccess
-  
-        def matches?(target)
-          @target = target.status
-          (200..299).include?(@target)
-        end
-  
-        def failure_message
-          "expected #{@target} to be successful but was #{@target.status}"
-        end
-  
-        def negative_failure_message
-          "expected #{@target} not to be successful but it was"
-        end
-      end
-      
-      class BeMissing
-        def matches?(target)
-          @target = target
-          (400..499).include?(@target.status)
-        end
-        
-        def failure_message
-          "expected #{@target} to be missing but was #{@target.status}"
-        end
-        
-        def negative_failure_message
-          "expected #{@target} not to be missing but it was"
-        end
-      end
-          
-
-      def be_redirect
-        BeRedirect.new
-      end
-
-      def redirect
-        Redirect.new
-      end
-
-      def redirect_to(expected)
-        RedirectTo.new(expected)
-      end
-
-      def be_success
-        BeSuccess.new
-      end
-
-      def be_successful
-        BeSuccess.new
-      end
-
-      def respond_successfully
-        BeSuccess.new
-      end
-      
-      def be_missing
-        BeMissing.new
-      end
-    end
-  end
-end

data/lib/merb/test/rspec_matchers/markup_matchers.rb

@@ -1,98 +0,0 @@
-module Merb
-  module Test
-    module MarkupMatchers
-      class HaveSelector
-        def initialize(expected)
-          @expected = expected
-        end
-    
-        def matches?(stringlike)
-          @document = case stringlike
-          when Hpricot::Elem
-            stringlike
-          when StringIO
-            Hpricot.parse(stringlike.string)
-          else
-            Hpricot.parse(stringlike)
-          end
-          !@document.search(@expected).empty?
-        end
-    
-        def failure_message
-          "expected following text to match selector #{@expected}:\n#{@document}"
-        end
-
-        def negative_failure_message
-          "expected following text to not match selector #{@expected}:\n#{@document}"
-        end
-      end
-  
-      class MatchTag
-        def initialize(name, attrs)
-          @name, @attrs = name, attrs
-          @content = @attrs.delete(:content)
-        end
-
-        def matches?(target)
-          @errors = []
-          unless target.include?("<#{@name}")
-            @errors << "Expected a <#{@name}>, but was #{target}"
-          end
-          @attrs.each do |attr, val|
-            unless target.include?("#{attr}=\"#{val}\"")
-              @errors << "Expected #{attr}=\"#{val}\", but was #{target}"
-            end
-          end
-          if @content
-            unless target.include?(">#{@content}<")
-              @errors << "Expected #{target} to include #{@content}"
-            end
-          end
-          @errors.size == 0
-        end
-    
-        def failure_message
-          @errors[0]
-        end
-    
-        def negative_failure_message
-          "Expected not to match against <#{@name} #{@attrs.map{ |a,v| "#{a}=\"#{v}\"" }.join(" ")}> tag, but it matched"
-        end
-      end
-  
-      class NotMatchTag
-        def initialize(attrs)
-          @attrs = attrs
-        end
-    
-        def matches?(target)
-          @errors = []
-          @attrs.each do |attr, val|
-            if target.include?("#{attr}=\"#{val}\"")
-              @errors << "Should not include #{attr}=\"#{val}\", but was #{target}"
-            end
-          end
-          @errors.size == 0
-        end
-    
-        def failure_message
-          @errors[0]
-        end
-      end
-  
-      def match_tag(name, attrs={})
-        MatchTag.new(name, attrs)
-      end
-      def not_match_tag(attrs)
-        NotMatchTag.new(attrs)
-      end
-  
-      def have_selector(expected)
-        HaveSelector.new(expected)
-      end
-      alias_method :match_selector, :have_selector
-      
-      
-    end
-  end
-end

data/lib/merb/upload_handler.rb

@@ -1,80 +0,0 @@
-module Mongrel
-  module Const
-    POST         = 'POST'.freeze         unless const_defined?(:POST)
-    PUT          = 'PUT'.freeze          unless const_defined?(:PUT)
-    QUERY_STRING = 'QUERY_STRING'.freeze unless const_defined?(:QUERY_STRING)
-    UPLOAD_ID    = 'upload_id'.freeze
-  end
-  
-  unless ENV['EVENT'] || ENV['SWIFT']
-    HttpHandler.class_eval do
-      def request_aborted(params)
-      end
-    end
-    
-    HttpRequest.class_eval do
-      def initialize_with_abort(params, socket, dispatchers)
-        initialize_without_abort(params, socket, dispatchers)
-        dispatchers.each {|d| d.request_aborted(params) if @body.nil? && d }
-      end
-      
-      alias_method :initialize_without_abort, :initialize
-      alias_method :initialize, :initialize_with_abort
-    end
-  end
-end
-
-
-class MerbUploadHandler < Mongrel::HttpHandler
-
-  def initialize(options = {})
-    @path_match     = Regexp.new(options[:upload_path_match])
-    @frequency      = options[:upload_frequency] || 3
-    @request_notify = true
-    if options[:start_drb]
-      require 'drb'
-      DRb.start_service
-      Mongrel.const_set :Uploads, DRbObject.new(nil, "druby://#{options[:host]}:#{options[:drb_server_port]}").upload_progress
-    else
-      Mongrel.const_set :Uploads, Merb::UploadProgress.new
-    end
-    Mongrel::Uploads.debug = true if options[:debug]
-  end
-
-  def request_begins(params)
-    upload_notify(:add, params, params[Mongrel::Const::CONTENT_LENGTH].to_i)
-  end
-
-  def request_progress(params, clen, total)
-    upload_notify(:mark, params, clen)
-  end
-
-  def process(request, response)
-    upload_notify(:finish, request.params)
-  end
-  
-  def request_aborted(params)
-    return unless upload_id = valid_upload?(params)
-    Mongrel::Uploads.finish(upload_id)
-    Merb.logger.info "#{self.class.name} - request aborted for " <<
-      "id: #{upload_id.inspect}, params: #{params.inspect}"
-  end
-
-  private
-    def upload_notify(action, params, *args)
-      return unless upload_id = valid_upload?(params)
-      if action == :mark
-        last_checked_time = Mongrel::Uploads.last_checked(upload_id)
-        return unless last_checked_time && Time.now - last_checked_time > @frequency
-      end
-      Mongrel::Uploads.send(action, upload_id, *args) 
-      Mongrel::Uploads.update_checked_time(upload_id) unless action == :finish
-    end
-    
-    def valid_upload?(params)
-      params[Mongrel::Const::PATH_INFO].match(@path_match) &&
-        [Mongrel::Const::POST, Mongrel::Const::PUT].include?(params[Mongrel::Const::REQUEST_METHOD]) &&
-        Mongrel::HttpRequest.query_parse(params[Mongrel::Const::QUERY_STRING])[Mongrel::Const::UPLOAD_ID]
-    end
-end
-