actionpack 2.3.18 → 3.0.0.beta

data/lib/action_view/template_handler.rb

@@ -1,34 +0,0 @@
-# Legacy TemplateHandler stub
-module ActionView
-  module TemplateHandlers #:nodoc:
-    module Compilable
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        def call(template)
-          new.compile(template)
-        end
-      end
-
-      def compile(template)
-         raise "Need to implement #{self.class.name}#compile(template)"
-       end
-    end
-  end
-
-  class TemplateHandler
-    def self.call(template)
-      "#{name}.new(self).render(template, local_assigns)"
-    end
-
-    def initialize(view = nil)
-      @view = view
-    end
-
-    def render(template, local_assigns)
-      raise "Need to implement #{self.class.name}#render(template, local_assigns)"
-    end
-  end
-end

data/lib/action_view/template_handlers.rb

@@ -1,48 +0,0 @@
-module ActionView #:nodoc:
-  module TemplateHandlers #:nodoc:
-    autoload :ERB, 'action_view/template_handlers/erb'
-    autoload :RJS, 'action_view/template_handlers/rjs'
-    autoload :Builder, 'action_view/template_handlers/builder'
-
-    def self.extended(base)
-      base.register_default_template_handler :erb, TemplateHandlers::ERB
-      base.register_template_handler :rjs, TemplateHandlers::RJS
-      base.register_template_handler :builder, TemplateHandlers::Builder
-
-      # TODO: Depreciate old template extensions
-      base.register_template_handler :rhtml, TemplateHandlers::ERB
-      base.register_template_handler :rxml, TemplateHandlers::Builder
-    end
-
-    @@template_handlers = {}
-    @@default_template_handlers = nil
-
-    # Register a class that knows how to handle template files with the given
-    # extension. This can be used to implement new template types.
-    # The constructor for the class must take the ActiveView::Base instance
-    # as a parameter, and the class must implement a +render+ method that
-    # takes the contents of the template to render as well as the Hash of
-    # local assigns available to the template. The +render+ method ought to
-    # return the rendered template as a string.
-    def register_template_handler(extension, klass)
-      @@template_handlers[extension.to_sym] = klass
-    end
-
-    def template_handler_extensions
-      @@template_handlers.keys.map(&:to_s).sort
-    end
-
-    def registered_template_handler(extension)
-      extension && @@template_handlers[extension.to_sym]
-    end
-
-    def register_default_template_handler(extension, klass)
-      register_template_handler(extension, klass)
-      @@default_template_handlers = klass
-    end
-
-    def handler_class_for_extension(extension)
-      registered_template_handler(extension) || @@default_template_handlers
-    end
-  end
-end

data/lib/action_view/template_handlers/erb.rb

@@ -1,25 +0,0 @@
-module ActionView
-  module TemplateHandlers
-    class ERB < TemplateHandler
-      include Compilable
-
-      ##
-      # :singleton-method:
-      # Specify trim mode for the ERB compiler. Defaults to '-'.
-      # See ERb documentation for suitable values.
-      cattr_accessor :erb_trim_mode
-      self.erb_trim_mode = '-'
-
-      def compile(template)
-        magic = $1 if template.source =~ /\A(<%#.*coding[:=]\s*(\S+)\s*-?%>)/
-        erb = "#{magic}<% __in_erb_template=true %>#{template.source}"
-
-        if erb.respond_to?(:force_encoding)
-          erb.force_encoding(template.source.encoding)
-        end
-
-        ::ERB.new(erb, nil, erb_trim_mode, '@output_buffer').src
-      end
-    end
-  end
-end

data/lib/actionpack.rb

@@ -1,2 +0,0 @@
-require 'action_pack'
-ActiveSupport::Deprecation.warn 'require "actionpack" is deprecated and will be removed in Rails 3. Use require "action_pack" instead.'

data/test/abstract_unit.rb

@@ -1,78 +0,0 @@
-$:.unshift File.expand_path('../../lib', __FILE__)
-$:.unshift File.expand_path('../../../activesupport/lib', __FILE__)
-$:.unshift File.expand_path('../fixtures/helpers', __FILE__)
-$:.unshift File.expand_path('../fixtures/alternate_helpers', __FILE__)
-
-require 'rubygems'
-require 'yaml'
-require 'stringio'
-require 'test/unit'
-
-gem 'mocha', '>= 0.9.7'
-require 'mocha'
-
-begin
-  require 'ruby-debug'
-  Debugger.settings[:autoeval] = true
-  Debugger.start
-rescue LoadError
-  # Debugging disabled. `gem install ruby-debug` to enable.
-end
-
-require 'action_controller'
-require 'action_controller/cgi_ext'
-require 'action_controller/test_process'
-require 'action_view/test_case'
-
-# Show backtraces for deprecated behavior for quicker cleanup.
-ActiveSupport::Deprecation.debug = true
-
-ActionController::Base.logger = nil
-ActionController::Routing::Routes.reload rescue nil
-
-ActionController::Base.session_store = nil
-
-# Register languages for testing
-I18n.backend.store_translations 'da', "da" => {}
-I18n.backend.store_translations 'pt-BR', "pt-BR" => {}
-ORIGINAL_LOCALES = I18n.available_locales.map(&:to_s).sort
-
-FIXTURE_LOAD_PATH = File.join(File.dirname(__FILE__), 'fixtures')
-ActionView::Base.cache_template_loading = true
-ActionController::Base.view_paths = FIXTURE_LOAD_PATH
-CACHED_VIEW_PATHS = ActionView::Base.cache_template_loading? ?
-                      ActionController::Base.view_paths :
-                      ActionController::Base.view_paths.map {|path| ActionView::Template::EagerPath.new(path.to_s)}
-
-class DummyMutex
-  def lock
-    @locked = true
-  end
-
-  def unlock
-    @locked = false
-  end
-
-  def locked?
-    @locked
-  end
-end
-
-class ActionController::IntegrationTest < ActiveSupport::TestCase
-  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
-
-ActionController::Reloader.default_lock = DummyMutex.new

data/test/active_record_unit.rb

@@ -1,104 +0,0 @@
-require 'abstract_unit'
-
-# Define the essentials
-class ActiveRecordTestConnector
-  cattr_accessor :able_to_connect
-  cattr_accessor :connected
-
-  # Set our defaults
-  self.connected = false
-  self.able_to_connect = true
-end
-
-# Try to grab AR
-if defined?(ActiveRecord) && defined?(Fixtures)
-  $stderr.puts 'Active Record is already loaded, running tests'
-else
-  $stderr.print 'Attempting to load Active Record... '
-  begin
-    PATH_TO_AR = File.expand_path('../../../activerecord/lib', __FILE__)
-    raise LoadError, "#{PATH_TO_AR} doesn't exist" unless File.directory?(PATH_TO_AR)
-    $LOAD_PATH.unshift PATH_TO_AR
-    require 'active_record'
-    require 'active_record/fixtures'
-    $stderr.puts 'success'
-  rescue LoadError => e
-    $stderr.print "failed. Skipping Active Record assertion tests: #{e}"
-    ActiveRecordTestConnector.able_to_connect = false
-  end
-end
-$stderr.flush
-
-
-# Define the rest of the connector
-class ActiveRecordTestConnector
-  class << self
-    def setup
-      unless self.connected || !self.able_to_connect
-        setup_connection
-        load_schema
-        require_fixture_models
-        self.connected = true
-      end
-    rescue Exception => e  # errors from ActiveRecord setup
-      $stderr.puts "\nSkipping ActiveRecord assertion tests: #{e}"
-      #$stderr.puts "  #{e.backtrace.join("\n  ")}\n"
-      self.able_to_connect = false
-    end
-
-    private
-      def setup_connection
-        if Object.const_defined?(:ActiveRecord)
-          defaults = { :database => ':memory:' }
-          begin
-            adapter = defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'
-            options = defaults.merge :adapter => adapter, :timeout => 500
-            ActiveRecord::Base.establish_connection(options)
-            ActiveRecord::Base.configurations = { 'sqlite3_ar_integration' => options }
-            ActiveRecord::Base.connection
-          rescue Exception  # errors from establishing a connection
-            $stderr.puts 'SQLite 3 unavailable; trying SQLite 2.'
-            options = defaults.merge :adapter => 'sqlite'
-            ActiveRecord::Base.establish_connection(options)
-            ActiveRecord::Base.configurations = { 'sqlite2_ar_integration' => options }
-            ActiveRecord::Base.connection
-          end
-
-          Object.send(:const_set, :QUOTED_TYPE, ActiveRecord::Base.connection.quote_column_name('type')) unless Object.const_defined?(:QUOTED_TYPE)
-        else
-          raise "Can't setup connection since ActiveRecord isn't loaded."
-        end
-      end
-
-      # Load actionpack sqlite tables
-      def load_schema
-        File.read(File.dirname(__FILE__) + "/fixtures/db_definitions/sqlite.sql").split(';').each do |sql|
-          ActiveRecord::Base.connection.execute(sql) unless sql.blank?
-        end
-      end
-
-      def require_fixture_models
-        Dir.glob(File.dirname(__FILE__) + "/fixtures/*.rb").each {|f| require f}
-      end
-  end
-end
-
-class ActiveRecordTestCase < ActionController::TestCase
-  include ActiveRecord::TestFixtures
-
-  # Set our fixture path
-  if ActiveRecordTestConnector.able_to_connect
-    self.fixture_path = [FIXTURE_LOAD_PATH]
-    self.use_transactional_fixtures = false
-  end
-
-  def self.fixtures(*args)
-    super if ActiveRecordTestConnector.connected
-  end
-
-  def run(*args)
-    super if ActiveRecordTestConnector.connected
-  end
-end
-
-ActiveRecordTestConnector.setup

data/test/activerecord/active_record_store_test.rb

@@ -1,221 +0,0 @@
-require 'active_record_unit'
-
-class ActiveRecordStoreTest < ActionController::IntegrationTest
-  DispatcherApp = ActionController::Dispatcher.new
-  SessionApp = ActiveRecord::SessionStore.new(DispatcherApp,
-                :key => '_session_id')
-  SessionAppWithFixation = ActiveRecord::SessionStore.new(DispatcherApp,
-                            :key => '_session_id', :cookie_only => false)
-
-  class TestController < ActionController::Base
-    def no_session_access
-      head :ok
-    end
-
-    def set_session_value
-      session[:foo] = params[:foo] || "bar"
-      head :ok
-    end
-
-    def get_session_value
-      render :text => "foo: #{session[:foo].inspect}"
-    end
-
-    def get_session_id
-      render :text => "#{request.session_options[:id]}"
-    end
-
-    def call_reset_session
-      session[:foo]
-      reset_session
-      session[:foo] = "baz"
-      head :ok
-    end
-
-    def rescue_action(e) raise end
-  end
-
-  def setup
-    ActiveRecord::SessionStore.session_class.create_table!
-    @integration_session = open_session(SessionApp)
-  end
-
-  def teardown
-    ActiveRecord::SessionStore.session_class.drop_table!
-  end
-
-  %w{ session sql_bypass }.each do |class_name|
-    define_method("test_setting_and_getting_session_value_with_#{class_name}_store") do
-      with_store class_name do
-        with_test_route_set do
-          get '/set_session_value'
-          assert_response :success
-          assert cookies['_session_id']
-
-          get '/get_session_value'
-          assert_response :success
-          assert_equal 'foo: "bar"', response.body
-
-          get '/set_session_value', :foo => "baz"
-          assert_response :success
-          assert cookies['_session_id']
-
-          get '/get_session_value'
-          assert_response :success
-          assert_equal 'foo: "baz"', response.body
-        end
-      end
-    end
-  end
-
-  def test_getting_nil_session_value
-    with_test_route_set do
-      get '/get_session_value'
-      assert_response :success
-      assert_equal 'foo: nil', response.body
-    end
-  end
-
-  def test_setting_session_value_after_session_reset
-    with_test_route_set do
-      get '/set_session_value'
-      assert_response :success
-      assert cookies['_session_id']
-      session_id = cookies['_session_id']
-
-      get '/call_reset_session'
-      assert_response :success
-      assert_not_equal [], headers['Set-Cookie']
-
-      get '/get_session_value'
-      assert_response :success
-      assert_equal 'foo: "baz"', response.body
-
-      get '/get_session_id'
-      assert_response :success
-      assert_not_equal session_id, response.body
-    end
-  end
-
-  def test_getting_session_id
-    with_test_route_set do
-      get '/set_session_value'
-      assert_response :success
-      assert cookies['_session_id']
-      session_id = cookies['_session_id']
-
-      get '/get_session_id'
-      assert_response :success
-      assert_equal session_id, response.body
-    end
-  end
-
-  def test_getting_session_value
-    with_test_route_set do
-      get '/set_session_value'
-      assert_response :success
-      assert cookies['_session_id']
-
-      get '/get_session_value'
-      assert_response :success
-      assert_equal nil, headers['Set-Cookie'], "should not resend the cookie again if session_id cookie is already exists"
-      session_id = cookies["_session_id"]
-
-      get '/call_reset_session'
-      assert_response :success
-      assert_not_equal [], headers['Set-Cookie']
-
-      cookies["_session_id"] = session_id # replace our new session_id with our old, pre-reset session_id
-
-      get '/get_session_value'
-      assert_response :success
-      assert_equal 'foo: nil', response.body, "data for this session should have been obliterated from the database"
-    end
-  end
-
-  def test_getting_from_nonexistent_session
-    with_test_route_set do
-      get '/get_session_value'
-      assert_response :success
-      assert_equal 'foo: nil', response.body
-      assert_nil cookies['_session_id'], "should only create session on write, not read"
-    end
-  end
-
-  def test_prevents_session_fixation
-    with_test_route_set do
-      get '/set_session_value'
-      assert_response :success
-      assert cookies['_session_id']
-
-      get '/get_session_value'
-      assert_response :success
-      assert_equal 'foo: "bar"', response.body
-      session_id = cookies['_session_id']
-      assert session_id
-
-      reset!
-
-      get '/set_session_value', :_session_id => session_id, :foo => "baz"
-      assert_response :success
-      assert_equal nil, cookies['_session_id']
-
-      get '/get_session_value', :_session_id => session_id
-      assert_response :success
-      assert_equal 'foo: nil', response.body
-      assert_equal nil, cookies['_session_id']
-    end
-  end
-
-  def test_allows_session_fixation
-    @integration_session = open_session(SessionAppWithFixation)
-
-    with_test_route_set do
-      get '/set_session_value'
-      assert_response :success
-      assert cookies['_session_id']
-
-      get '/get_session_value'
-      assert_response :success
-      assert_equal 'foo: "bar"', response.body
-      session_id = cookies['_session_id']
-      assert session_id
-
-      reset!
-      @integration_session = open_session(SessionAppWithFixation)
-
-      get '/set_session_value', :_session_id => session_id, :foo => "baz"
-      assert_response :success
-      assert_equal session_id, cookies['_session_id']
-
-      get '/get_session_value', :_session_id => session_id
-      assert_response :success
-      assert_equal 'foo: "baz"', response.body
-      assert_equal session_id, cookies['_session_id']
-    end
-  end
-
-  private
-    def with_test_route_set
-      with_routing do |set|
-        set.draw do |map|
-          map.with_options :controller => "active_record_store_test/test" do |c|
-            c.connect "/:action"
-          end
-        end
-        yield
-      end
-    end
-
-    def with_store(class_name)
-      begin
-        session_class = ActiveRecord::SessionStore.session_class
-        ActiveRecord::SessionStore.session_class = "ActiveRecord::SessionStore::#{class_name.camelize}".constantize
-        yield
-      rescue
-        ActiveRecord::SessionStore.session_class = session_class
-        raise
-      end
-    end
-
-end