prototype-rails 4.0.0 → 4.0.1

data/test/fixtures/test/greeting.js.rjs

@@ -1 +0,0 @@
-page[:body].visual_effect :highlight

data/test/fixtures/test/render_explicit_html_template.js.rjs

@@ -1 +0,0 @@
-page.call "document.write", render(:partial => 'one')

data/test/fixtures/test/render_implicit_html_template.js.rjs

@@ -1 +0,0 @@
-page.call "document.write", render(:partial => "one")

data/test/javascript_helper_test.rb

@@ -1,61 +0,0 @@
-require 'abstract_unit'
-
-class JavaScriptHelperTest < ActionView::TestCase
-  tests ActionView::Helpers::JavaScriptHelper
-
-  def _evaluate_assigns_and_ivars() end
-
-  attr_accessor :formats, :output_buffer
-
-  def update_details(details)
-    @details = details
-    yield if block_given?
-  end
-
-  def setup
-    super
-    ActiveSupport.escape_html_entities_in_json  = true
-    @template = self
-  end
-
-  def teardown
-    ActiveSupport.escape_html_entities_in_json  = false
-  end
-  
-  def test_link_to_function_with_rjs_block
-    html = link_to_function( "Greet me!" ) do |page|
-      page.replace_html 'header', "<h1>Greetings</h1>"
-    end
-    assert_dom_equal %(<a href="#" onclick="Element.update(&quot;header&quot;, &quot;\\u003Ch1\\u003EGreetings\\u003C/h1\\u003E&quot;);; return false;">Greet me!</a>), html
-  end
-
-  def test_link_to_function_with_rjs_block_and_options
-    html = link_to_function( "Greet me!", :class => "updater" ) do |page|
-      page.replace_html 'header', "<h1>Greetings</h1>"
-    end
-    assert_dom_equal %(<a href="#" class="updater" onclick="Element.update(&quot;header&quot;, &quot;\\u003Ch1\\u003EGreetings\\u003C/h1\\u003E&quot;);; return false;">Greet me!</a>), html
-  end
-
-  def test_link_to_function_with_inner_block_does_not_raise_exception
-    html = link_to_function( "Greet me!" ) do |page|
-      page.replace_html 'header', (content_tag :h1 do
-        'Greetings'
-      end)
-    end
-    assert_dom_equal %(<a href="#" onclick="Element.update(&quot;header&quot;, &quot;\\u003Ch1\\u003EGreetings\\u003C/h1\\u003E&quot;);; return false;">Greet me!</a>), html
-  end
-  
-  def test_button_to_function_with_rjs_block
-    html = button_to_function( "Greet me!" ) do |page|
-      page.replace_html 'header', "<h1>Greetings</h1>"
-    end
-    assert_dom_equal %(<input type="button" onclick="Element.update(&quot;header&quot;, &quot;\\u003Ch1\\u003EGreetings\\u003C/h1\\u003E&quot;);;" value="Greet me!" />), html
-  end
-
-  def test_button_to_function_with_rjs_block_and_options
-    html = button_to_function( "Greet me!", :class => "greeter" ) do |page|
-      page.replace_html 'header', "<h1>Greetings</h1>"
-    end
-    assert_dom_equal %(<input type="button" class="greeter" onclick="Element.update(&quot;header&quot;, &quot;\\u003Ch1\\u003EGreetings\\u003C\/h1\\u003E&quot;);;" value="Greet me!" />), html
-  end
-end

data/test/lib/abstract_unit.rb

@@ -1,225 +0,0 @@
-require 'rubygems'
-require 'bundler/setup'
-require 'minitest/autorun'
-
-require 'active_support'
-require 'active_support/test_case'
-require 'action_controller'
-require 'action_view'
-require 'action_view/testing/resolvers'
-
-require 'prototype-rails/on_load_action_controller'
-require 'prototype-rails/on_load_action_view'
-
-FIXTURE_LOAD_PATH = File.expand_path('../../fixtures', __FILE__)
-FIXTURES = Pathname.new(FIXTURE_LOAD_PATH)
-
-
-module SetupOnce
-  extend ActiveSupport::Concern
-
-  included do
-    cattr_accessor :setup_once_block
-    self.setup_once_block = nil
-
-    setup :run_setup_once
-  end
-
-  module ClassMethods
-    def setup_once(&block)
-      self.setup_once_block = block
-    end
-  end
-
-  private
-    def run_setup_once
-      if self.setup_once_block
-        self.setup_once_block.call
-        self.setup_once_block = nil
-      end
-    end
-end
-
-SharedTestRoutes = ActionDispatch::Routing::RouteSet.new
-
-module ActiveSupport
-  class TestCase
-    include SetupOnce
-    # Hold off drawing routes until all the possible controller classes
-    # have been loaded.
-    setup_once do
-      SharedTestRoutes.draw do
-        get ':controller(/:action)'
-      end
-
-      ActionDispatch::IntegrationTest.app.routes.draw do
-        get ':controller(/:action)'
-      end
-    end
-  end
-end
-
-class RoutedRackApp
-  attr_reader :routes
-
-  def initialize(routes, &blk)
-    @routes = routes
-    @stack = ActionDispatch::MiddlewareStack.new(&blk).build(@routes)
-  end
-
-  def call(env)
-    @stack.call(env)
-  end
-end
-
-class BasicController
-  attr_accessor :request
-
-  def config
-    @config ||= ActiveSupport::InheritableOptions.new(ActionController::Base.config).tap do |config|
-      # VIEW TODO: View tests should not require a controller
-      public_dir = "#{FIXTURE_LOAD_PATH}/public"
-      config.assets_dir = public_dir
-      config.javascripts_dir = "#{public_dir}/javascripts"
-      config.stylesheets_dir = "#{public_dir}/stylesheets"
-      config
-    end
-  end
-end
-
-class ActionDispatch::IntegrationTest < ActiveSupport::TestCase
-  setup do
-    @routes = SharedTestRoutes
-  end
-
-  def self.build_app(routes = nil)
-    RoutedRackApp.new(routes || ActionDispatch::Routing::RouteSet.new) do |middleware|
-      middleware.use "ActionDispatch::ShowExceptions", ActionDispatch::PublicExceptions.new("#{FIXTURE_LOAD_PATH}/public")
-      middleware.use "ActionDispatch::Callbacks"
-      middleware.use "ActionDispatch::ParamsParser"
-      middleware.use "ActionDispatch::Cookies"
-      middleware.use "ActionDispatch::Flash"
-      middleware.use "Rack::Head"
-      yield(middleware) if block_given?
-    end
-  end
-
-  self.app = build_app
-
-  # Stub Rails dispatcher so it does not get controller references and
-  # simply return the controller#action as Rack::Body.
-  class StubDispatcher < ::ActionDispatch::Routing::RouteSet::Dispatcher
-    protected
-    def controller_reference(controller_param)
-      controller_param
-    end
-
-    def dispatch(controller, action, env)
-      [200, {'Content-Type' => 'text/html'}, ["#{controller}##{action}"]]
-    end
-  end
-
-  def self.stub_controllers
-    old_dispatcher = ActionDispatch::Routing::RouteSet::Dispatcher
-    ActionDispatch::Routing::RouteSet.module_eval { remove_const :Dispatcher }
-    ActionDispatch::Routing::RouteSet.module_eval { const_set :Dispatcher, StubDispatcher }
-    yield ActionDispatch::Routing::RouteSet.new
-  ensure
-    ActionDispatch::Routing::RouteSet.module_eval { remove_const :Dispatcher }
-    ActionDispatch::Routing::RouteSet.module_eval { const_set :Dispatcher, old_dispatcher }
-  end
-
-  def with_routing(&block)
-    temporary_routes = ActionDispatch::Routing::RouteSet.new
-    old_app, self.class.app = self.class.app, self.class.build_app(temporary_routes)
-    old_routes = SharedTestRoutes
-    silence_warnings { Object.const_set(:SharedTestRoutes, temporary_routes) }
-
-    yield temporary_routes
-  ensure
-    self.class.app = old_app
-    silence_warnings { Object.const_set(:SharedTestRoutes, old_routes) }
-  end
-
-  def with_autoload_path(path)
-    path = File.join(File.dirname(__FILE__), "fixtures", path)
-    if ActiveSupport::Dependencies.autoload_paths.include?(path)
-      yield
-    else
-      begin
-        ActiveSupport::Dependencies.autoload_paths << path
-        yield
-      ensure
-        ActiveSupport::Dependencies.autoload_paths.reject! {|p| p == path}
-        ActiveSupport::Dependencies.clear
-      end
-    end
-  end
-end
-
-# Temporary base class
-class Rack::TestCase < ActionDispatch::IntegrationTest
-  def self.testing(klass = nil)
-    if klass
-      @testing = "/#{klass.name.underscore}".sub!(/_controller$/, '')
-    else
-      @testing
-    end
-  end
-
-  def get(thing, *args)
-    if thing.is_a?(Symbol)
-      super("#{self.class.testing}/#{thing}", *args)
-    else
-      super
-    end
-  end
-
-  def assert_body(body)
-    assert_equal body, Array.wrap(response.body).join
-  end
-
-  def assert_status(code)
-    assert_equal code, response.status
-  end
-
-  def assert_response(body, status = 200, headers = {})
-    assert_body   body
-    assert_status status
-    headers.each do |header, value|
-      assert_header header, value
-    end
-  end
-
-  def assert_content_type(type)
-    assert_equal type, response.headers["Content-Type"]
-  end
-
-  def assert_header(name, value)
-    assert_equal value, response.headers[name]
-  end
-end
-
-module ActionController
-  class Base
-    include ActionController::Testing
-    # This stub emulates the Railtie including the URL helpers from a Rails application
-    include SharedTestRoutes.url_helpers
-
-    self.view_paths = FIXTURE_LOAD_PATH
-
-    def self.test_routes(&block)
-      routes = ActionDispatch::Routing::RouteSet.new
-      routes.draw(&block)
-      include routes.url_helpers
-    end
-  end
-
-  class TestCase
-    include ActionDispatch::TestProcess
-
-    setup do
-      @routes = SharedTestRoutes
-    end
-  end
-end

data/test/lib/controller/fake_models.rb

@@ -1,29 +0,0 @@
-require "active_model"
-
-class Customer < Struct.new(:name, :id)
-  extend ActiveModel::Naming
-  include ActiveModel::Conversion
-
-  undef_method :to_json
-
-  def to_xml(options={})
-    if options[:builder]
-      options[:builder].name name
-    else
-      "<name>#{name}</name>"
-    end
-  end
-
-  def to_js(options={})
-    "name: #{name.inspect}"
-  end
-  alias :to_text :to_js
-
-  def errors
-    []
-  end
-
-  def persisted?
-    id.present?
-  end
-end

data/test/render_other_test.rb

@@ -1,256 +0,0 @@
-require 'abstract_unit'
-require 'pathname'
-require 'securerandom'
-
-ActionController.add_renderer :simon do |says, options|
-  self.content_type  = Mime::TEXT
-  self.response_body = "Simon says: #{says}"
-end
-
-class RenderOtherTest < ActionController::TestCase
-  class TestController < ActionController::Base
-    protect_from_forgery
-
-    def self.controller_path
-      'test'
-    end
-
-    layout :determine_layout
-
-    module RenderTestHelper
-      def rjs_helper_method_from_module
-        page.visual_effect :highlight
-      end
-    end
-
-    helper RenderTestHelper
-    helper do
-      def rjs_helper_method(value)
-        page.visual_effect :highlight, value
-      end
-    end
-
-    def enum_rjs_test
-      render :update do |page|
-        page.select('.product').each do |value|
-          page.rjs_helper_method_from_module
-          page.rjs_helper_method(value)
-          page.sortable(value, :url => { :action => "order" })
-          page.draggable(value)
-        end
-      end
-    end
-
-    def render_explicit_html_template
-    end
-
-    def render_custom_code_rjs
-      render :update, :status => 404 do |page|
-        page.replace :foo, :partial => 'partial'
-      end
-    end
-
-    def render_implicit_html_template
-    end
-
-    def render_js_with_explicit_template
-      @project_id = 4
-      render :template => 'test/delete_with_js'
-    end
-
-    def render_js_with_explicit_action_template
-      @project_id = 4
-      render :action => 'delete_with_js'
-    end
-
-    def delete_with_js
-      @project_id = 4
-    end
-
-    def update_page
-      render :update do |page|
-        page.replace_html 'balance', '$37,000,000.00'
-        page.visual_effect :highlight, 'balance'
-      end
-    end
-
-    def update_page_with_instance_variables
-      @money = '$37,000,000.00'
-      @div_id = 'balance'
-      render :update do |page|
-        page.replace_html @div_id, @money
-        page.visual_effect :highlight, @div_id
-      end
-    end
-
-    def update_page_with_view_method
-      render :update do |page|
-        page.replace_html 'person', pluralize(2, 'person')
-      end
-    end
-
-    def partial_as_rjs
-      render :update do |page|
-        page.replace :foo, :partial => 'partial'
-      end
-    end
-
-    def respond_to_partial_as_rjs
-      respond_to do |format|
-        format.js do
-          render :update do |page|
-            page.replace :foo, :partial => 'partial'
-          end
-        end
-      end
-    end
-
-    def render_alternate_default
-      # For this test, the method "default_render" is overridden:
-      @alternate_default_render = lambda do
-        render :update do |page|
-          page.replace :foo, :partial => 'partial'
-        end
-      end
-    end
-
-    def render_simon_says
-      render :simon => "foo"
-    end
-
-    private
-      def default_render
-        @alternate_default_render ||= nil
-        if @alternate_default_render
-          @alternate_default_render.call
-        else
-          super
-        end
-      end
-
-      def determine_layout
-        case action_name
-          when "hello_world", "layout_test", "rendering_without_layout",
-               "rendering_nothing_on_layout", "render_text_hello_world",
-               "render_text_hello_world_with_layout",
-               "hello_world_with_layout_false",
-               "partial_only", "partial_only_with_layout",
-               "accessing_params_in_template",
-               "accessing_params_in_template_with_layout",
-               "render_with_explicit_template",
-               "render_with_explicit_string_template",
-               "update_page", "update_page_with_instance_variables"
-
-            "layouts/standard"
-          when "action_talk_to_layout", "layout_overriding_layout"
-            "layouts/talk_from_action"
-          when "render_implicit_html_template_from_xhr_request"
-            (request.xhr? ? 'layouts/xhr' : 'layouts/standard')
-        end
-      end
-  end
-
-  tests TestController
-
-  def setup
-    # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get
-    # a more accurate simulation of what happens in "real life".
-    super
-    @controller.logger = Logger.new(nil)
-
-    @request.host = "www.nextangle.com"
-  end
-
-  def test_enum_rjs_test
-    pre = %[$$(".product").each(function(value, index) {
-      new Effect.Highlight(element,{});
-      new Effect.Highlight(value,{});
-      Sortable.create(value, {onUpdate:function(){new Ajax.Request('/render_other_test/test/order', {asynchronous:true, evalScripts:true, parameters:Sortable.serialize(value) + '&authenticity_token=' + encodeURIComponent('].gsub(/^\s+/, '')
-    post = %[')})}});\nnew Draggable(value, {});\n});]
-
-    get :enum_rjs_test
-    assert_match pre, @response.body
-    assert_match post, @response.body
-  end
-
-  def test_explicitly_rendering_an_html_template_with_implicit_html_template_renders_should_be_possible_from_an_rjs_template
-    [:js, "js"].each do |format|
-      assert_nothing_raised do
-        get :render_explicit_html_template, :format => format
-        assert_equal %(document.write("Hello world\\n");), @response.body
-      end
-    end
-  end
-
-  def test_render_custom_code_rjs
-    get :render_custom_code_rjs
-    assert_response 404
-    assert_equal %(Element.replace("foo", "partial html");), @response.body
-  end
-
-  def test_render_in_an_rjs_template_should_pick_html_templates_when_available
-    [:js, "js"].each do |format|
-      assert_nothing_raised do
-        get :render_implicit_html_template, :format => format
-        assert_equal %(document.write("Hello world\\n");), @response.body
-      end
-    end
-  end
-
-  def test_render_rjs_template_explicitly
-    get :render_js_with_explicit_template
-    assert_equal %!Element.remove("person");\nnew Effect.Highlight(\"project-4\",{});!, @response.body
-  end
-
-  def test_rendering_rjs_action_explicitly
-    get :render_js_with_explicit_action_template
-    assert_equal %!Element.remove("person");\nnew Effect.Highlight(\"project-4\",{});!, @response.body
-  end
-
-  def test_render_rjs_with_default
-    get :delete_with_js
-    assert_equal %!Element.remove("person");\nnew Effect.Highlight(\"project-4\",{});!, @response.body
-  end
-
-  def test_update_page
-    get :update_page
-    assert_template nil
-    assert_equal 'text/javascript; charset=utf-8', @response.headers['Content-Type']
-    assert_equal 2, @response.body.split($/).length
-  end
-
-  def test_update_page_with_instance_variables
-    get :update_page_with_instance_variables
-    assert_template nil
-    assert_equal 'text/javascript; charset=utf-8', @response.headers["Content-Type"]
-    assert_match(/balance/, @response.body)
-    assert_match(/\$37/, @response.body)
-  end
-
-  def test_update_page_with_view_method
-    get :update_page_with_view_method
-    assert_template nil
-    assert_equal 'text/javascript; charset=utf-8', @response.headers["Content-Type"]
-    assert_match(/2 people/, @response.body)
-  end
-
-  def test_should_render_html_formatted_partial_with_rjs
-    xhr :get, :partial_as_rjs
-    assert_equal %(Element.replace("foo", "partial html");), @response.body
-  end
-
-  def test_should_render_html_formatted_partial_with_rjs_and_js_format
-    xhr :get, :respond_to_partial_as_rjs
-    assert_equal %(Element.replace("foo", "partial html");), @response.body
-  end
-
-  def test_should_render_with_alternate_default_render
-    xhr :get, :render_alternate_default
-    assert_equal %(Element.replace("foo", "partial html");), @response.body
-  end
-
-  def test_using_custom_render_option
-    get :render_simon_says
-    assert_equal "Simon says: foo", @response.body
-  end
-end