rq 3.4.0 → 3.5.0

data/rails/vendor/rails/actionpack/lib/action_view/template_error.rb

@@ -1,110 +0,0 @@
-module ActionView
-  # The TemplateError exception is raised when the compilation of the template fails. This exception then gathers a
-  # bunch of intimate details and uses it to report a very precise exception message.
-  class TemplateError < ActionViewError #:nodoc:
-    SOURCE_CODE_RADIUS = 3
-
-    attr_reader :original_exception
-
-    def initialize(base_path, file_path, assigns, source, original_exception)
-      @base_path, @assigns, @source, @original_exception =
-        base_path, assigns.dup, source, original_exception
-      @file_path = file_path
-
-      remove_deprecated_assigns!
-    end
-
-    def message
-      ActiveSupport::Deprecation.silence { original_exception.message }
-    end
-
-    def clean_backtrace
-      original_exception.clean_backtrace
-    end
-
-    def sub_template_message
-      if @sub_templates
-        "Trace of template inclusion: " +
-        @sub_templates.collect { |template| strip_base_path(template) }.join(", ")
-      else
-        ""
-      end
-    end
-
-    def source_extract(indentation = 0)
-      return unless num = line_number
-      num = num.to_i
-
-      source_code = IO.readlines(@file_path)
-
-      start_on_line = [ num - SOURCE_CODE_RADIUS - 1, 0 ].max
-      end_on_line   = [ num + SOURCE_CODE_RADIUS - 1, source_code.length].min
-
-      indent = ' ' * indentation
-      line_counter = start_on_line
-
-      source_code[start_on_line..end_on_line].sum do |line|
-        line_counter += 1
-        "#{indent}#{line_counter}: #{line}"
-      end
-    end
-
-    def sub_template_of(template_path)
-      @sub_templates ||= []
-      @sub_templates << template_path
-    end
-
-    def line_number
-      @line_number ||=
-        if file_name
-          regexp = /#{Regexp.escape File.basename(file_name)}:(\d+)/
-
-          $1 if message =~ regexp or clean_backtrace.find { |line| line =~ regexp }
-        end
-    end
-
-    def file_name
-      stripped = strip_base_path(@file_path)
-      stripped.slice!(0,1) if stripped[0] == ?/
-      stripped
-    end
-
-    def to_s
-      "\n\n#{self.class} (#{message}) #{source_location}:\n" +
-        "#{source_extract}\n    #{clean_backtrace.join("\n    ")}\n\n"
-    end
-
-    def backtrace
-      [
-        "#{source_location.capitalize}\n\n#{source_extract(4)}\n    " +
-        clean_backtrace.join("\n    ")
-      ]
-    end
-
-    private
-      def remove_deprecated_assigns!
-        ActionController::Base::DEPRECATED_INSTANCE_VARIABLES.each do |ivar|
-          @assigns.delete(ivar)
-        end
-      end
-
-      def strip_base_path(path)
-        File.expand_path(path).
-          gsub(/^#{Regexp.escape File.expand_path(RAILS_ROOT)}/, '').
-          gsub(@base_path, "")
-      end
-
-      def source_location
-        if line_number
-          "on line ##{line_number} of "
-        else
-          'in '
-        end + file_name
-      end
-  end
-end
-
-if defined?(Exception::TraceSubstitutions)
-  Exception::TraceSubstitutions << [/:in\s+`_run_(html|xml).*'\s*$/, '']
-  Exception::TraceSubstitutions << [%r{^\s*#{Regexp.escape RAILS_ROOT}}, '#{RAILS_ROOT}'] if defined?(RAILS_ROOT)
-end

data/rails/vendor/rails/actionpack/test/abstract_unit.rb

@@ -1,16 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-$:.unshift(File.dirname(__FILE__) + '/../../activesupport/lib/active_support')
-$:.unshift(File.dirname(__FILE__) + '/fixtures/helpers')
-
-require 'yaml'
-require 'test/unit'
-require 'action_controller'
-require 'breakpoint'
-require 'action_controller/test_process'
-
-# Show backtraces for deprecated behavior for quicker cleanup.
-ActiveSupport::Deprecation.debug = true
-
-ActionController::Base.logger = nil
-ActionController::Base.ignore_missing_templates = false
-ActionController::Routing::Routes.reload rescue nil

data/rails/vendor/rails/actionpack/test/active_record_unit.rb

@@ -1,116 +0,0 @@
-require  File.dirname(__FILE__) + '/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.dirname(__FILE__)}/../../activerecord/lib"
-    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)
-        begin
-          connection_options = {:adapter => 'sqlite3', :dbfile => ':memory:'}
-          ActiveRecord::Base.establish_connection(connection_options)
-          ActiveRecord::Base.configurations = { 'sqlite3_ar_integration' => connection_options } 
-          ActiveRecord::Base.connection
-        rescue Exception  # errors from establishing a connection
-          $stderr.puts 'SQLite 3 unavailable; falling to SQLite 2.'
-          connection_options = {:adapter => 'sqlite', :dbfile => ':memory:'}
-          ActiveRecord::Base.establish_connection(connection_options)
-          ActiveRecord::Base.configurations = { 'sqlite2_ar_integration' => connection_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 "Couldn't locate ActiveRecord."
-      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
-
-# Test case for inheiritance
-class ActiveRecordTestCase < Test::Unit::TestCase
-  # Set our fixture path
-  if ActiveRecordTestConnector.able_to_connect
-    self.fixture_path = "#{File.dirname(__FILE__)}/fixtures/"
-    self.use_transactional_fixtures = false
-  end
-
-  def self.fixtures(*args)
-    super if ActiveRecordTestConnector.connected
-  end
-
-  def setup
-    abort_tests unless ActiveRecordTestConnector.connected
-  end
-
-  # Default so Test::Unit::TestCase doesn't complain
-  def test_truth
-  end
-
-  private
-    # If things go wrong, we don't want to run our test cases. We'll just define them to test nothing.
-    def abort_tests
-      $stderr.puts 'No Active Record connection, aborting tests.'
-      self.class.public_instance_methods.grep(/^test./).each do |method|
-        self.class.class_eval { define_method(method.to_sym){} }
-      end
-    end
-end
-
-ActiveRecordTestConnector.setup

data/rails/vendor/rails/actionpack/test/activerecord/active_record_assertions_test.rb

@@ -1,92 +0,0 @@
-require "#{File.dirname(__FILE__)}/../active_record_unit"
-
-class ActiveRecordAssertionsController < ActionController::Base
-  self.template_root = "#{File.dirname(__FILE__)}/../fixtures/"
-
-  # fail with 1 bad column
-  def nasty_columns_1
-    @company = Company.new
-    @company.name = "B"
-    @company.rating = 2
-    render :inline => "snicker...."
-  end
-
-  # fail with 2 bad columns
-  def nasty_columns_2
-    @company = Company.new
-    @company.name = ""
-    @company.rating = 2
-    render :inline => "double snicker...."
-  end
-
-  # this will pass validation
-  def good_company
-    @company = Company.new
-    @company.name = "A"
-    @company.rating = 69
-    render :inline => "Goodness Gracious!"
-  end
-
-  # this will fail validation
-  def bad_company
-    @company = Company.new 
-    render :inline => "Who's Bad?"
-  end
-
-  # the safety dance......
-  def rescue_action(e) raise; end
-end
-
-class ActiveRecordAssertionsControllerTest < ActiveRecordTestCase
-  fixtures :companies
-
-  def setup
-    @request = ActionController::TestRequest.new
-    @response = ActionController::TestResponse.new
-    @controller = ActiveRecordAssertionsController.new
-    super
-  end
-
-  # test for 1 bad apple column
-  def test_some_invalid_columns
-    process :nasty_columns_1
-    assert_response :success
-
-    assert_deprecated_assertion { assert_invalid_record 'company' }
-    assert_deprecated_assertion { assert_invalid_column_on_record 'company', 'rating' }
-    assert_deprecated_assertion { assert_valid_column_on_record 'company', 'name' }
-    assert_deprecated_assertion { assert_valid_column_on_record 'company', %w(name id) }
-  end
-
-  # test for 2 bad apples columns
-  def test_all_invalid_columns
-    process :nasty_columns_2
-    assert_response :success
-
-    assert_deprecated_assertion { assert_invalid_record 'company' }
-    assert_deprecated_assertion { assert_invalid_column_on_record 'company', 'rating' }
-    assert_deprecated_assertion { assert_invalid_column_on_record 'company', 'name' }
-    assert_deprecated_assertion { assert_invalid_column_on_record 'company', %w(name rating) }
-  end
-
-  # ensure we have no problems with an ActiveRecord
-  def test_valid_record
-    process :good_company
-    assert_response :success
-
-    assert_deprecated_assertion { assert_valid_record 'company' }
-  end
-
-  # ensure we have problems with an ActiveRecord
-  def test_invalid_record
-    process :bad_company
-    assert_response :success
-
-    assert_deprecated_assertion { assert_invalid_record 'company' }
-  end
-
-  protected
-    def assert_deprecated_assertion(message = nil, &block)
-      assert_deprecated(/assert_.*from test_/, &block)
-    end
-end

data/rails/vendor/rails/actionpack/test/activerecord/active_record_store_test.rb

@@ -1,142 +0,0 @@
-# These tests exercise CGI::Session::ActiveRecordStore, so you're going to
-# need AR in a sibling directory to AP and have SQLite installed.
-require File.dirname(__FILE__) + '/../active_record_unit'
-require 'action_controller/session/active_record_store'
-
-
-module CommonActiveRecordStoreTests
-  def test_basics
-    s = session_class.new(:session_id => '1234', :data => { 'foo' => 'bar' })
-    assert_equal 'bar', s.data['foo']
-    assert s.save
-    assert_equal 'bar', s.data['foo']
-
-    assert_not_nil t = session_class.find_by_session_id('1234')
-    assert_not_nil t.data
-    assert_equal 'bar', t.data['foo']
-  end
-
-  def test_reload_same_session
-    @new_session.update
-    reloaded = CGI::Session.new(CGI.new, 'session_id' => @new_session.session_id, 'database_manager' => CGI::Session::ActiveRecordStore)
-    assert_equal 'bar', reloaded['foo']
-  end
-
-  def test_tolerates_close_close
-    assert_nothing_raised do
-      @new_session.close
-      @new_session.close
-    end
-  end
-end
-
-class ActiveRecordStoreTest < ActiveRecordTestCase
-  include CommonActiveRecordStoreTests
-
-  def session_class
-    CGI::Session::ActiveRecordStore::Session
-  end
-
-  def session_id_column
-    "session_id"
-  end
-
-  def setup
-    session_class.create_table!
-
-    ENV['REQUEST_METHOD'] = 'GET'
-    ENV['REQUEST_URI'] = '/'
-    CGI::Session::ActiveRecordStore.session_class = session_class
-
-    @cgi = CGI.new
-    @new_session = CGI::Session.new(@cgi, 'database_manager' => CGI::Session::ActiveRecordStore, 'new_session' => true)
-    @new_session['foo'] = 'bar'
-  end
-
-# this test only applies for eager sesssion saving
-#  def test_another_instance
-#    @another = CGI::Session.new(@cgi, 'session_id' => @new_session.session_id, 'database_manager' => CGI::Session::ActiveRecordStore)
-#    assert_equal @new_session.session_id, @another.session_id
-#  end
-
-  def test_model_attribute
-    assert_kind_of CGI::Session::ActiveRecordStore::Session, @new_session.model
-    assert_equal({ 'foo' => 'bar' }, @new_session.model.data)
-  end
-
-  def test_save_unloaded_session
-    c = session_class.connection
-    bogus_class = c.quote(Base64.encode64("\004\010o:\vBlammo\000"))
-    c.insert("INSERT INTO #{session_class.table_name} ('#{session_id_column}', 'data') VALUES ('abcdefghijklmnop', #{bogus_class})")
-
-    sess = session_class.find_by_session_id('abcdefghijklmnop')
-    assert_not_nil sess
-    assert !sess.loaded?
-
-    # because the session is not loaded, the save should be a no-op. If it
-    # isn't, this'll try and unmarshall the bogus class, and should get an error.
-    assert_nothing_raised { sess.save }
-  end
-
-  def teardown
-    session_class.drop_table!
-  end
-end
-
-class ColumnLimitTest < ActiveRecordTestCase
-  def setup
-    @session_class = CGI::Session::ActiveRecordStore::Session
-    @session_class.create_table!
-  end
-
-  def teardown
-    @session_class.drop_table!
-  end
-
-  def test_protection_from_data_larger_than_column
-    # Can't test this unless there is a limit
-    return unless limit = @session_class.data_column_size_limit
-    too_big = ':(' * limit
-    s = @session_class.new(:session_id => '666', :data => {'foo' => too_big})
-    s.data
-    assert_raise(ActionController::SessionOverflowError) { s.save }
-  end
-end
-
-class DeprecatedActiveRecordStoreTest < ActiveRecordStoreTest
-  def session_id_column
-    "sessid"
-  end
-
-  def setup
-    session_class.connection.execute 'create table old_sessions (id integer primary key, sessid text unique, data text)'
-    session_class.table_name = 'old_sessions'
-    session_class.send :setup_sessid_compatibility!
-
-    ENV['REQUEST_METHOD'] = 'GET'
-    CGI::Session::ActiveRecordStore.session_class = session_class
-
-    @new_session = CGI::Session.new(CGI.new, 'database_manager' => CGI::Session::ActiveRecordStore, 'new_session' => true)
-    @new_session['foo'] = 'bar'
-  end
-
-  def teardown
-    session_class.connection.execute 'drop table old_sessions'
-    session_class.table_name = 'sessions'
-  end
-end
-
-class SqlBypassActiveRecordStoreTest < ActiveRecordStoreTest
-  def session_class
-    unless @session_class
-      @session_class = CGI::Session::ActiveRecordStore::SqlBypass
-      @session_class.connection = CGI::Session::ActiveRecordStore::Session.connection
-    end
-    @session_class
-  end
-
-  def test_model_attribute
-    assert_kind_of CGI::Session::ActiveRecordStore::SqlBypass, @new_session.model
-    assert_equal({ 'foo' => 'bar' }, @new_session.model.data)
-  end
-end