actionpack 2.0.5 → 2.1.0

data/lib/action_view/compiled_templates.rb

@@ -1,69 +0,0 @@
-module ActionView
-
-  # CompiledTemplates modules hold methods that have been compiled.
-  # Templates are compiled into these methods so that they do not need to be
-  # read and parsed for each request.
-  #
-  # Each template may be compiled into one or more methods. Each method accepts a given
-  # set of parameters which is used to implement local assigns passing.
-  #
-  # To use a compiled template module, create a new instance and include it into the class
-  # in which you want the template to be rendered.
-  class CompiledTemplates < Module
-    attr_reader :method_names
-
-    def initialize
-      @method_names = Hash.new do |hash, key|
-        hash[key] = "__compiled_method_#{(hash.length + 1)}"
-      end
-      @mtimes = {}
-    end
-    
-    # Return the full key for the given identifier and argument names
-    def full_key(identifier, arg_names)
-      [identifier, arg_names]
-    end
-
-    # Return the selector for this method or nil if it has not been compiled
-    def selector(identifier, arg_names)
-      key = full_key(identifier, arg_names)
-      method_names.key?(key) ? method_names[key] : nil
-    end
-    alias :compiled? :selector
-
-    # Return the time at which the method for the given identifier and argument names was compiled.
-    def mtime(identifier, arg_names)
-      @mtimes[full_key(identifier, arg_names)]
-    end
-    
-    # Compile the provided source code for the given argument names and with the given initial line number.
-    # The identifier should be unique to this source.
-    #
-    # The file_name, if provided will appear in backtraces. If not provided, the file_name defaults
-    # to the identifier.
-    #
-    # This method will return the selector for the compiled version of this method.
-    def compile_source(identifier, arg_names, source, initial_line_number = 0, file_name = nil)
-      file_name ||= identifier
-      name = method_names[full_key(identifier, arg_names)]
-      arg_desc = arg_names.empty? ? '' : "(#{arg_names * ', '})"
-      fake_file_name = "#{file_name}#{arg_desc}" # Include the arguments for this version (for now)
-      
-      method_def = wrap_source(name, arg_names, source)
-      
-      begin
-        module_eval(method_def, fake_file_name, initial_line_number)
-        @mtimes[full_key(identifier, arg_names)] = Time.now
-      rescue Exception => e  # errors from compiled source
-        e.blame_file! identifier
-        raise
-      end
-      name
-    end
-    
-    # Wrap the provided source in a def ... end block.
-    def wrap_source(name, arg_names, source)
-      "def #{name}(#{arg_names * ', '})\n#{source}\nend"
-    end
-  end
-end

data/test/action_view_test.rb

@@ -1,44 +0,0 @@
-require File.dirname(__FILE__) + '/abstract_unit'
-require 'test/unit'
-
-class ActionViewTests < Test::Unit::TestCase
-  def test_find_template_extension_from_first_render
-    base = ActionView::Base.new
-
-    assert_nil base.send(:find_template_extension_from_first_render)
-
-    {
-      nil => nil,
-      '' => nil,
-      'foo' => nil,
-      '/foo' => nil,
-      'foo.rb' => 'rb',
-      'foo.bar.rb' => 'bar.rb',
-      'baz/foo.rb' => 'rb',
-      'baz/foo.bar.rb' => 'bar.rb',
-      'baz/foo.o/foo.rb' => 'rb',
-      'baz/foo.o/foo.bar.rb' => 'bar.rb',
-    }.each do |input,expectation|
-      base.instance_variable_set('@first_render', input)
-      assert_equal expectation, base.send(:find_template_extension_from_first_render)
-    end
-  end
-  
-  def test_should_report_file_exists_correctly
-    base = ActionView::Base.new
-
-    assert_nil base.send(:find_template_extension_from_first_render)
-    
-    assert_equal false, base.send(:file_exists?, 'test.rhtml')
-    assert_equal false, base.send(:file_exists?, 'test.rb')
-
-    base.instance_variable_set('@first_render', 'foo.rb')
-    
-    assert_equal 'rb', base.send(:find_template_extension_from_first_render)
-    
-    assert_equal false, base.send(:file_exists?, 'baz')
-    assert_equal false, base.send(:file_exists?, 'baz.rb')
-
-  end
-  
-end

data/test/activerecord/fixtures_test.rb

@@ -1,24 +0,0 @@
-require File.dirname(__FILE__) + '/../active_record_unit'
-require "action_controller/test_case"
-
-class ActionController::TestCase
-  self.fixture_path = File.dirname(__FILE__) + '/../fixtures'
-  self.use_transactional_fixtures = false
-end
-
-class DeveloperController < ActionController::Base
-end
-
-class DeveloperControllerTest < ActionController::TestCase
-  fixtures :developers
-
-  def setup
-    @david = developers(:david)
-  end
-
-  def test_should_have_loaded_fixtures
-    assert_kind_of(Developer, @david)
-    assert_kind_of(Developer, developers(:jamis))
-    assert_equal(@developers.size, Developer.count)
-  end
-end

data/test/controller/fragment_store_setting_test.rb

@@ -1,47 +0,0 @@
-require File.dirname(__FILE__) + '/../abstract_unit'
-
-MemCache = Struct.new(:MemCache, :address) unless Object.const_defined?(:MemCache)
-
-class FragmentCacheStoreSettingTest < Test::Unit::TestCase
-  def teardown
-    ActionController::Base.fragment_cache_store = ActionController::Caching::Fragments::MemoryStore.new
-  end
-  
-  def test_file_fragment_cache_store
-    ActionController::Base.fragment_cache_store = :file_store, "/path/to/cache/directory"
-    assert_kind_of(
-      ActionController::Caching::Fragments::FileStore,
-      ActionController::Base.fragment_cache_store
-    )
-    assert_equal "/path/to/cache/directory", ActionController::Base.fragment_cache_store.cache_path
-  end
-  
-  def test_drb_fragment_cache_store
-    ActionController::Base.fragment_cache_store = :drb_store, "druby://localhost:9192"
-    assert_kind_of(
-      ActionController::Caching::Fragments::DRbStore,
-      ActionController::Base.fragment_cache_store
-    )
-    assert_equal "druby://localhost:9192", ActionController::Base.fragment_cache_store.address
-  end
-
-  if defined? CGI::Session::MemCacheStore
-    def test_mem_cache_fragment_cache_store
-      ActionController::Base.fragment_cache_store = :mem_cache_store, "localhost"
-      assert_kind_of(
-        ActionController::Caching::Fragments::MemCacheStore,
-        ActionController::Base.fragment_cache_store
-      )
-      assert_equal %w(localhost), ActionController::Base.fragment_cache_store.addresses
-    end
-  end
-
-  def test_object_assigned_fragment_cache_store
-    ActionController::Base.fragment_cache_store = ActionController::Caching::Fragments::FileStore.new("/path/to/cache/directory")
-    assert_kind_of(
-      ActionController::Caching::Fragments::FileStore,
-      ActionController::Base.fragment_cache_store
-    )
-    assert_equal "/path/to/cache/directory", ActionController::Base.fragment_cache_store.cache_path
-  end
-end

data/test/template/compiled_templates_test.rb

@@ -1,197 +0,0 @@
-require "#{File.dirname(__FILE__)}/../abstract_unit"
-require 'action_view/helpers/date_helper'
-require 'action_view/compiled_templates'
-
-class CompiledTemplateTests < Test::Unit::TestCase
-  def setup
-    @ct = ActionView::CompiledTemplates.new
-    @v = Class.new
-    @v.send :include, @ct
-    @a = './test_compile_template_a.rhtml'
-    @b = './test_compile_template_b.rhtml'
-    @s = './test_compile_template_link.rhtml'
-  end
-  def teardown
-    [@a, @b, @s].each do |f|
-      FileUtils.rm(f) if File.exist?(f) || File.symlink?(f)
-    end
-  end
-  attr_reader :ct, :v
-
-  def test_name_allocation
-    hi_world = ct.method_names['hi world']
-    hi_sexy = ct.method_names['hi sexy']
-    wish_upon_a_star = ct.method_names['I love seeing decent error messages']
-
-    assert_equal hi_world, ct.method_names['hi world']
-    assert_equal hi_sexy, ct.method_names['hi sexy']
-    assert_equal wish_upon_a_star, ct.method_names['I love seeing decent error messages']
-    assert_equal 3, [hi_world, hi_sexy, wish_upon_a_star].uniq.length
-  end
-
-  def test_wrap_source
-    assert_equal(
-      "def aliased_assignment(value)\nself.value = value\nend",
-      @ct.wrap_source(:aliased_assignment, [:value], 'self.value = value')
-    )
-
-    assert_equal(
-      "def simple()\nnil\nend",
-      @ct.wrap_source(:simple, [], 'nil')
-    )
-  end
-
-  def test_compile_source_single_method
-    selector = ct.compile_source('doubling method', [:a], 'a + a')
-    assert_equal 2, @v.new.send(selector, 1)
-    assert_equal 4, @v.new.send(selector, 2)
-    assert_equal -4, @v.new.send(selector, -2)
-    assert_equal 0, @v.new.send(selector, 0)
-    selector
-  end
-
-  def test_compile_source_two_method
-    sel1 = test_compile_source_single_method # compile the method in the other test
-    sel2 = ct.compile_source('doubling method', [:a, :b], 'a + b + a + b')
-    assert_not_equal sel1, sel2
-
-    assert_equal 2, @v.new.send(sel1, 1)
-    assert_equal 4, @v.new.send(sel1, 2)
-
-    assert_equal 6, @v.new.send(sel2, 1, 2)
-    assert_equal 32, @v.new.send(sel2, 15, 1)
-  end
-
-  def test_mtime
-    t1 = Time.now
-
-    test_compile_source_single_method
-    mtime = ct.mtime('doubling method', [:a])
-
-    assert mtime < Time.now
-    assert mtime > t1
-  end
-
-  uses_mocha 'test_compile_time' do
-  def test_compile_time
-    t = Time.now
-
-    File.open(@a, "w"){|f| f.puts @a}
-    File.open(@b, "w"){|f| f.puts @b}
-    # windows doesn't support symlinks (even under cygwin)
-    windows = (RUBY_PLATFORM =~ /win32/)
-    `ln -s #{@a} #{@s}` unless windows
-
-    v = ActionView::Base.new
-    v.base_path = '.'
-    v.cache_template_loading = false
-
-    # All templates were created at t+1
-    File::Stat.any_instance.expects(:mtime).times(windows ? 2 : 3).returns(t + 1.second)
-
-    # private methods template_changed_since? and compile_template?
-    # should report true for all since they have not been compiled
-    assert v.send(:template_changed_since?, @a, t)
-    assert v.send(:template_changed_since?, @b, t)
-    assert v.send(:template_changed_since?, @s, t) unless windows
-
-    assert v.send(:compile_template?, nil, @a, {})
-    assert v.send(:compile_template?, nil, @b, {})
-    assert v.send(:compile_template?, nil, @s, {}) unless windows
-
-    @handler = ActionView::Base.handler_for_extension(:rhtml)
-
-    # All templates are rendered at t+2
-    Time.expects(:now).times(windows ? 2 : 3).returns(t + 2.seconds)
-    v.send(:compile_and_render_template, @handler, '', @a)
-    v.send(:compile_and_render_template, @handler, '', @b)
-    v.send(:compile_and_render_template, @handler, '', @s) unless windows
-    a_n = v.method_names[@a]
-    b_n = v.method_names[@b]
-    s_n = v.method_names[@s] unless windows
-    # all of the files have changed since last compile
-    assert v.compile_time[a_n] > t
-    assert v.compile_time[b_n] > t
-    assert v.compile_time[s_n] > t unless windows
-
-    # private methods template_changed_since? and compile_template?
-    # should report false for all since none have changed since compile
-    File::Stat.any_instance.expects(:mtime).times(windows ? 6 : 12).returns(t + 1.second)
-    assert !v.send(:template_changed_since?, @a, v.compile_time[a_n])
-    assert !v.send(:template_changed_since?, @b, v.compile_time[b_n])
-    assert !v.send(:template_changed_since?, @s, v.compile_time[s_n]) unless windows
-    assert !v.send(:compile_template?, nil, @a, {})
-    assert !v.send(:compile_template?, nil, @b, {})
-    assert !v.send(:compile_template?, nil, @s, {}) unless windows
-    v.send(:compile_and_render_template, @handler, '', @a)
-    v.send(:compile_and_render_template, @handler, '', @b)
-    v.send(:compile_and_render_template, @handler, '', @s)  unless windows
-    # none of the files have changed since last compile
-    assert v.compile_time[a_n] < t + 3.seconds
-    assert v.compile_time[b_n] < t + 3.seconds
-    assert v.compile_time[s_n] < t + 3.seconds  unless windows
-
-    `rm #{@s}; ln -s #{@b} #{@s}` unless windows
-    # private methods template_changed_since? and compile_template?
-    # should report true for symlink since it has changed since compile
-    
-    # t + 3.seconds is for the symlink
-    File::Stat.any_instance.expects(:mtime).times(windows ? 6 : 9).returns(
-      *(windows ? [ t + 1.second, t + 1.second ] :
-        [ t + 1.second, t + 1.second, t + 3.second ]) * 3)
-    assert !v.send(:template_changed_since?, @a, v.compile_time[a_n])
-    assert !v.send(:template_changed_since?, @b, v.compile_time[b_n])
-    assert v.send(:template_changed_since?, @s, v.compile_time[s_n]) unless windows
-    assert !v.send(:compile_template?, nil, @a, {})
-    assert !v.send(:compile_template?, nil, @b, {})
-    assert v.send(:compile_template?, nil, @s, {}) unless windows
-
-    # Only the symlink template gets rendered at t+3
-    Time.stubs(:now).returns(t + 3.seconds) unless windows
-    v.send(:compile_and_render_template, @handler, '', @a)
-    v.send(:compile_and_render_template, @handler, '', @b)
-    v.send(:compile_and_render_template, @handler, '', @s) unless windows
-    # the symlink has changed since last compile
-    assert v.compile_time[a_n] < t + 3.seconds
-    assert v.compile_time[b_n] < t + 3.seconds
-    assert_equal v.compile_time[s_n], t + 3.seconds unless windows
-
-    FileUtils.touch @b
-    # private methods template_changed_since? and compile_template?
-    # should report true for symlink and file at end of symlink
-    # since it has changed since last compile
-    #
-    # t+4 is for @b and also for the file that @s points to, which is @b
-    File::Stat.any_instance.expects(:mtime).times(windows ? 6 : 12).returns(
-      *(windows ? [ t + 1.second, t + 4.seconds ] :
-        [ t + 1.second, t + 4.seconds, t + 3.second, t + 4.seconds ]) * 3)
-    assert !v.send(:template_changed_since?, @a, v.compile_time[a_n])
-    assert v.send(:template_changed_since?, @b, v.compile_time[b_n])
-    assert v.send(:template_changed_since?, @s, v.compile_time[s_n]) unless windows
-    assert !v.send(:compile_template?, nil, @a, {})
-    assert v.send(:compile_template?, nil, @b, {})
-    assert v.send(:compile_template?, nil, @s, {}) unless windows
-
-    Time.expects(:now).times(windows ? 1 : 2).returns(t + 5.seconds)
-    v.send(:compile_and_render_template, @handler, '', @a)
-    v.send(:compile_and_render_template, @handler, '', @b)
-    v.send(:compile_and_render_template, @handler, '', @s) unless windows
-    # the file at the end of the symlink has changed since last compile
-    # both the symlink and the file at the end of it should be recompiled
-    assert v.compile_time[a_n] < t + 5.seconds
-    assert_equal v.compile_time[b_n], t + 5.seconds
-    assert_equal v.compile_time[s_n], t + 5.seconds unless windows
-  end
-  end
-end
-
-module ActionView
-  class Base
-    def compile_time
-      @@compile_time
-    end
-    def method_names
-      @@method_names
-    end
-  end
-end

data/test/template/deprecate_ivars_test.rb

@@ -1,51 +0,0 @@
-require File.dirname(__FILE__) + '/../abstract_unit'
-
-class DeprecateIvars < ActionController::Base
-  def use_logger
-    render :inline => "<%= logger.class -%>"
-  end
-  
-  def use_old_logger
-    render :inline => "<%= @logger.class -%>"
-  end
-  
-  def use_action_name
-    render :inline => "<%= action_name -%>"
-  end
-  
-  def use_old_action_name
-    render :inline => "<%= @action_name -%>"
-  end
-end
-
-class DeprecateIvarsTest < Test::Unit::TestCase
-  def setup
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
-    
-    @controller = DeprecateIvars.new
-    @controller.logger = Logger.new(nil)
-    
-    @request.host = "rubyonrails.com"
-  end
-  
-  def test_logger
-    assert_not_deprecated { get :use_logger }
-    assert_equal "Logger", @response.body
-  end
-  
-  def test_deprecated_logger
-    assert_deprecated { get :use_old_logger }
-    assert_equal "Logger", @response.body
-  end
-  
-  def test_action_name
-    assert_not_deprecated { get :use_action_name }
-    assert_equal "use_action_name", @response.body
-  end
-  
-  def test_deprecated_action_name
-    assert_deprecated { get :use_old_action_name }
-    assert_equal "use_old_action_name", @response.body
-  end
-end