require 'active_support/core_ext/object/blank'
require 'action_controller'
require 'action_controller/test_case'
require 'action_view'

unless defined?(ActionView::TestCase::Behavior)


  # This has been merged to rails HEAD after the 3.0.0.beta.3 release (see
  # https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/4678).
  # Once 3.0.0.rc.1 comes out, we can remove it.
  module ActionView

    # This line is NOT part of the code merged into Rails, but ensures that
    # we're using the correct code for rails-3.0.0.beta.3
    remove_const :TestCase 

    class TestCase < ActiveSupport::TestCase
      class TestController < ActionController::Base
        include ActionDispatch::TestProcess

        attr_accessor :request, :response, :params

        class << self
          attr_writer :controller_path
        end

        def controller_path=(path)
          self.class.controller_path=(path)
        end

        def initialize
          self.class.controller_path = ""
          @request = ActionController::TestRequest.new
          @response = ActionController::TestResponse.new

          @request.env.delete('PATH_INFO')

          @params = {}
        end
      end

      module Behavior
        extend ActiveSupport::Concern

        include ActionDispatch::Assertions, ActionDispatch::TestProcess
        include ActionController::TemplateAssertions
        include ActionView::Context

        include ActionController::PolymorphicRoutes
        include ActionController::RecordIdentifier

        include AbstractController::Helpers
        include ActionView::Helpers

        attr_accessor :controller, :output_buffer, :rendered
        
        module ClassMethods
          def tests(helper_class)
            self.helper_class = helper_class
          end

          def determine_default_helper_class(name)
            mod = name.sub(/Test$/, '').constantize
            mod.is_a?(Class) ? nil : mod
          rescue NameError
            nil
          end

          def helper_method(*methods)
            # Almost a duplicate from ActionController::Helpers
            methods.flatten.each do |method|
              _helpers.module_eval <<-end_eval
                def #{method}(*args, &block)                    # def current_user(*args, &block)
                  _test_case.send(%(#{method}), *args, &block)  #   test_case.send(%(current_user), *args, &block)
                end                                             # end
              end_eval
            end
          end

          attr_writer :helper_class

          def helper_class
            @helper_class ||= determine_default_helper_class(name)
          end

        private

          def include_helper_modules!
            helper(helper_class) if helper_class
            include _helpers
          end

        end

        def setup_with_controller
          @controller = ActionView::TestCase::TestController.new
          @output_buffer = ActiveSupport::SafeBuffer.new
          @rendered = ''

          self.class.send(:include_helper_modules!)
          make_test_case_available_to_view!
          say_no_to_protect_against_forgery!
        end

        def config
          @controller.config if @controller.respond_to?(:config)
        end

        def render(options = {}, local_assigns = {}, &block)
          @rendered << output = _view.render(options, local_assigns, &block)
          output
        end

        included do
          setup :setup_with_controller
        end

      private

        # Support the selector assertions
        #
        # Need to experiment if this priority is the best one: rendered => output_buffer
        def response_from_page_or_rjs
          HTML::Document.new(@rendered.blank? ? @output_buffer : @rendered).root
        end

        def say_no_to_protect_against_forgery!
          _helpers.module_eval do
            def protect_against_forgery?
              false
            end
          end
        end

        def make_test_case_available_to_view!
          test_case_instance = self
          _helpers.module_eval do
            define_method(:_test_case) { test_case_instance }
            private :_test_case
          end
        end

        def _view
          view = ActionView::Base.new(ActionController::Base.view_paths, _assigns, @controller)
          view.singleton_class.send :include, _helpers
          view.singleton_class.send :include, @controller._router.url_helpers
          view.singleton_class.send :delegate, :alert, :notice, :to => "request.flash"
          view.output_buffer = self.output_buffer
          view
        end

        EXCLUDE_IVARS = %w{
          @_result
          @output_buffer
          @rendered
          @templates
          @view_context_class
          @layouts
          @partials
          @controller

          @method_name
          @fixture_cache
          @loaded_fixtures
          @test_passed
        }

        def _instance_variables
          instance_variables - EXCLUDE_IVARS
          instance_variables
        end

        def _assigns
          _instance_variables.inject({}) do |hash, var|
            name = var[1..-1].to_sym
            hash[name] = instance_variable_get(var)
            hash
          end
        end

        def _router
          @controller._router if @controller.respond_to?(:_router)
        end

        def method_missing(selector, *args)
          if @controller.respond_to?(:_router) &&
          @controller._router.named_routes.helpers.include?(selector)
            @controller.__send__(selector, *args)
          else
            super
          end
        end

      end

      include Behavior

    end
  end
end