kotovalexarian-likes-github/rails--rails
1
0
Fork 0
mirror of https://github.com/rails/rails.git synced 2022-11-09 12:12:34 -05:00
Code Releases Activity

Merge branch 'master' of git://github.com/rails/rails

Browse source
This commit is contained in:
José Valim 2009-07-08 12:53:13 +02:00
commit c07746cbdf
18 changed files with 495 additions and 168 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

38
actionpack/lib/action_view/helpers/asset_tag_helper.rb
View file

@ -462,12 +462,27 @@ module ActionView
# video_path("hd") # => /videos/hd
# video_path("hd.avi") # => /videos/hd.avi
# video_path("trailers/hd.avi") # => /videos/trailers/hd.avi
# video_path("/trailers/hd.avi") # => /videos/hd.avi
# video_path("/trailers/hd.avi") # => /trailers/hd.avi
# video_path("http://www.railsapplication.com/vid/hd.avi") # => http://www.railsapplication.com/vid/hd.avi
def video_path(source)
compute_public_path(source, 'videos')
end
alias_method :path_to_video, :video_path # aliased to avoid conflicts with an video_path named route
alias_method :path_to_video, :video_path # aliased to avoid conflicts with a video_path named route
# Computes the path to an audio asset in the public audios directory.
# Full paths from the document root will be passed through.
# Used internally by +audio_tag+ to build the audio path.
#
# ==== Examples
# audio_path("horse") # => /audios/horse
# audio_path("horse.wav") # => /audios/horse.avi
# audio_path("sounds/horse.wav") # => /audios/sounds/horse.avi
# audio_path("/sounds/horse.wav") # => /sounds/horse.avi
# audio_path("http://www.railsapplication.com/sounds/horse.wav") # => http://www.railsapplication.com/sounds/horse.wav
def audio_path(source)
compute_public_path(source, 'audios')
end
alias_method :path_to_audio, :audio_path # aliased to avoid conflicts with an audio_path named route
# Returns an html image tag for the +source+. The +source+ can be a full
# path or a file that exists in your public images directory.
@ -542,7 +557,7 @@ module ActionView
# video_tag("trailer.ogg") # =>
# <video src="/videos/trailer.ogg" />
# video_tag("trailer.ogg", :controls => true, :autobuffer => true) # =>
# <video autobuffer="autobuffer" controls="controls" src="/videos/trailer.ogg" />
# <video autobuffer="true" controls="true" src="/videos/trailer.ogg" />
# video_tag("trailer.m4v", :size => "16x10", :poster => "screenshot.png") # =>
# <video src="/videos/trailer.m4v" width="16" height="10" poster="/images/screenshot.png" />
# video_tag("/trailers/hd.avi", :size => "16x16") # =>
@ -572,6 +587,23 @@ module ActionView
end
end
# Returns an html audio tag for the +source+.
# The +source+ can be full path or file that exists in
# your public audios directory.
#
# ==== Examples
# audio_tag("sound") # =>
# <audio src="/audios/sound" />
# audio_tag("sound.wav") # =>
# <audio src="/audios/sound.wav" />
# audio_tag("sound.wav", :autoplay => true, :controls => true) # =>
# <audio autoplay="autoplay" controls="controls" src="/audios/sound.wav" />
def audio_tag(source, options = {})
options.symbolize_keys!
options[:src] = path_to_audio(source)
tag("audio", options)
end
def self.cache_asset_timestamps
@@cache_asset_timestamps
end

3
actionpack/lib/action_view/helpers/tag_helper.rb
View file

@ -8,8 +8,7 @@ module ActionView
module TagHelper
include ERB::Util
BOOLEAN_ATTRIBUTES = %w(disabled readonly multiple checked autobuffer
autoplay controls loop).to_set
BOOLEAN_ATTRIBUTES = %w(disabled readonly multiple checked).to_set
BOOLEAN_ATTRIBUTES.merge(BOOLEAN_ATTRIBUTES.map {|attr| attr.to_sym })
# Returns an empty HTML tag of type +name+ which by default is XHTML

40
actionpack/test/template/asset_tag_helper_test.rb
View file

@ -158,8 +158,8 @@ class AssetTagHelperTest < ActionView::TestCase
VideoLinkToTag = {
%(video_tag("xml.ogg")) => %(<video src="/videos/xml.ogg" />),
%(video_tag("rss.m4v", :autoplay => true, :controls => true)) => %(<video autoplay="autoplay" controls="controls" src="/videos/rss.m4v" />),
%(video_tag("rss.m4v", :autobuffer => true)) => %(<video autobuffer="autobuffer" src="/videos/rss.m4v" />),
%(video_tag("rss.m4v", :autoplay => true, :controls => true)) => %(<video autoplay="true" controls="true" src="/videos/rss.m4v" />),
%(video_tag("rss.m4v", :autobuffer => true)) => %(<video autobuffer="true" src="/videos/rss.m4v" />),
%(video_tag("gold.m4v", :size => "160x120")) => %(<video height="120" src="/videos/gold.m4v" width="160" />),
%(video_tag("gold.m4v", "size" => "320x240")) => %(<video height="240" src="/videos/gold.m4v" width="320" />),
%(video_tag("trailer.ogg", :poster => "screenshot.png")) => %(<video poster="/images/screenshot.png" src="/videos/trailer.ogg" />),
@ -168,7 +168,27 @@ class AssetTagHelperTest < ActionView::TestCase
%(video_tag("error.avi", "size" => "x")) => %(<video src="/videos/error.avi" />),
%(video_tag("http://media.rubyonrails.org/video/rails_blog_2.mov")) => %(<video src="http://media.rubyonrails.org/video/rails_blog_2.mov" />),
%(video_tag(["multiple.ogg", "multiple.avi"])) => %(<video><source src="multiple.ogg" /><source src="multiple.avi" /></video>),
%(video_tag(["multiple.ogg", "multiple.avi"], :size => "160x120", :controls => true)) => %(<video controls="controls" height="120" width="160"><source src="multiple.ogg" /><source src="multiple.avi" /></video>)
%(video_tag(["multiple.ogg", "multiple.avi"], :size => "160x120", :controls => true)) => %(<video controls="true" height="120" width="160"><source src="multiple.ogg" /><source src="multiple.avi" /></video>)
}
AudioPathToTag = {
%(audio_path("xml")) => %(/audios/xml),
%(audio_path("xml.wav")) => %(/audios/xml.wav),
%(audio_path("dir/xml.wav")) => %(/audios/dir/xml.wav),
%(audio_path("/dir/xml.wav")) => %(/dir/xml.wav)
}
PathToAudioToTag = {
%(path_to_audio("xml")) => %(/audios/xml),
%(path_to_audio("xml.wav")) => %(/audios/xml.wav),
%(path_to_audio("dir/xml.wav")) => %(/audios/dir/xml.wav),
%(path_to_audio("/dir/xml.wav")) => %(/dir/xml.wav)
}
AudioLinkToTag = {
%(audio_tag("xml.wav")) => %(<audio src="/audios/xml.wav" />),
%(audio_tag("rss.wav", :autoplay => true, :controls => true)) => %(<audio autoplay="true" controls="true" src="/audios/rss.wav" />),
%(audio_tag("http://media.rubyonrails.org/audio/rails_blog_2.mov")) => %(<audio src="http://media.rubyonrails.org/audio/rails_blog_2.mov" />),
}
def test_auto_discovery_link_tag
@ -311,6 +331,18 @@ class AssetTagHelperTest < ActionView::TestCase
VideoLinkToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
end
def test_audio_path
AudioPathToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
end
def test_path_to_audio_alias_for_audio_path
PathToAudioToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
end
def test_audio_tag
AudioLinkToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
end
def test_timebased_asset_id
expected_time = File.stat(File.expand_path(File.dirname(__FILE__) + "/../fixtures/public/images/rails.png")).mtime.to_i.to_s
assert_equal %(<img alt="Rails" src="/images/rails.png?#{expected_time}" />), image_tag("rails.png")
@ -354,7 +386,7 @@ class AssetTagHelperTest < ActionView::TestCase
"#{request.protocol}assets#{source.length}.example.com"
end
end
ActionController::Base.perform_caching = true

6
activerecord/lib/active_record/schema_dumper.rb
View file

@ -78,11 +78,14 @@ HEADER
begin
tbl = StringIO.new
# first dump primary key column
if @connection.respond_to?(:pk_and_sequence_for)
pk, pk_seq = @connection.pk_and_sequence_for(table)
elsif @connection.respond_to?(:primary_key)
pk = @connection.primary_key(table)
end
pk ||= 'id'
tbl.print " create_table #{table.inspect}"
if columns.detect { |c| c.name == pk }
if pk != 'id'
@ -94,6 +97,7 @@ HEADER
tbl.print ", :force => true"
tbl.puts " do |t|"
# then dump all non-primary key columns
column_specs = columns.map do |column|
raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" if @types[column.type].nil?
next if column.name == pk

14
activerecord/test/cases/schema_dumper_test.rb
View file

@ -156,6 +156,13 @@ class SchemaDumperTest < ActiveRecord::TestCase
index_definition = standard_dump.split(/\n/).grep(/add_index.*companies/).first.strip
assert_equal 'add_index "companies", ["firm_id", "type", "rating", "ruby_type"], :name => "company_index"', index_definition
end
def test_schema_dump_should_honor_nonstandard_primary_keys
output = standard_dump
match = output.match(%r{create_table "movies"(.*)do})
assert_not_nil(match, "nonstandardpk table not found")
assert_match %r(:primary_key => "movieid"), match[1], "non-standard primary key not preserved"
end
if current_adapter?(:MysqlAdapter)
def test_schema_dump_should_not_add_default_value_for_mysql_text_field
@ -163,13 +170,6 @@ class SchemaDumperTest < ActiveRecord::TestCase
assert_match %r{t.text\s+"body",\s+:null => false$}, output
end
def test_mysql_schema_dump_should_honor_nonstandard_primary_keys
output = standard_dump
match = output.match(%r{create_table "movies"(.*)do})
assert_not_nil(match, "nonstandardpk table not found")
assert_match %r(:primary_key => "movieid"), match[1], "non-standard primary key not preserved"
end
def test_schema_dump_includes_length_for_mysql_blob_and_text_fields
output = standard_dump
assert_match %r{t.binary\s+"tiny_blob",\s+:limit => 255$}, output

1
activesupport/lib/active_support/core_ext/string.rb
View file

@ -7,3 +7,4 @@ require 'active_support/core_ext/string/access'
require 'active_support/core_ext/string/iterators'
require 'active_support/core_ext/string/xchar'
require 'active_support/core_ext/string/behavior'
require 'active_support/core_ext/string/interpolation'

87
activesupport/lib/active_support/core_ext/string/interpolation.rb Normal file
View file

@ -0,0 +1,87 @@
if RUBY_VERSION < '1.9'
=begin
string.rb - Extension for String.
Copyright (C) 2005-2009 Masao Mutoh
You may redistribute it and/or modify it under the same
license terms as Ruby.
=end
# This feature is included in Ruby 1.9 or later but not occur TypeError.
#
# String#% method which accepts named arguments. Particularly useful if the
# string is to be used by a translator because named arguments mean more
# than %s/%d style.
class String
unless instance_methods.find {|m| m.to_s == 'bytesize'}
# For older ruby (such as ruby-1.8.5)
alias :bytesize :size
end
alias :_old_format_m :% # :nodoc:
PERCENT_MATCH_RE = Regexp.union(
/%%/,
/%\{(\w+)\}/,
/%<(\w+)>(.*?\d*\.?\d*[bBdiouxXeEfgGcps])/
)
# call-seq:
# %(arg)
# %(hash)
#
# Format - Uses str as a format specification, and returns the result of applying it to arg.
# If the format specification contains more than one substitution, then arg must be
# an Array containing the values to be substituted. See Kernel::sprintf for details of the
# format string. This is the default behavior of the String class.
# * arg: an Array or other class except Hash.
# * Returns: formatted String
# Example:
# "%s, %s" % ["Masao", "Mutoh"]
#
# Also you can use a Hash as the "named argument". This is recommended way so translators
# can understand the meanings of the msgids easily.
# * hash: {:key1 => value1, :key2 => value2, ... }
# * Returns: formatted String
# Example:
# For strings.
# "%{firstname}, %{familyname}" % {:firstname => "Masao", :familyname => "Mutoh"}
#
# With field type to specify format such as d(decimal), f(float),...
# "%<age>d, %<weight>.1f" % {:age => 10, :weight => 43.4}
def %(args)
if args.kind_of?(Hash)
ret = dup
ret.gsub!(PERCENT_MATCH_RE) {|match|
if match == '%%'
'%'
elsif $1
key = $1.to_sym
args.has_key?(key) ? args[key] : match
elsif $2
key = $2.to_sym
args.has_key?(key) ? sprintf("%#{$3}", args[key]) : match
end
}
ret
else
ret = gsub(/%([{<])/, '%%\1')
begin
ret._old_format_m(args)
rescue ArgumentError => e
if $DEBUG
$stderr.puts " The string:#{ret}"
$stderr.puts " args:#{args.inspect}"
puts e.backtrace
else
raise ArgumentError, e.message
end
end
end
end
end
end

146
activesupport/lib/active_support/testing/isolation.rb
View file

@ -1,94 +1,96 @@
module ActiveSupport::Testing
class ProxyTestResult
def initialize
@calls = []
end
module ActiveSupport
module Testing
class ProxyTestResult
def initialize
@calls = []
end
def __replay__(result)
@calls.each do |name, args|
result.send(name, *args)
def __replay__(result)
@calls.each do |name, args|
result.send(name, *args)
end
end
def method_missing(name, *args)
@calls << [name, args]
end
end
def method_missing(name, *args)
@calls << [name, args]
end
end
module Isolation
def self.forking_env?
!ENV["NO_FORK"] && RUBY_PLATFORM !~ /mswin|mingw|java/
end
def run(result)
unless defined?(@@ran_class_setup)
self.class.setup
@@ran_class_setup = true
module Isolation
def self.forking_env?
!ENV["NO_FORK"] && RUBY_PLATFORM !~ /mswin|mingw|java/
end
yield(Test::Unit::TestCase::STARTED, name)
@_result = result
proxy = run_in_isolation do |proxy|
super(proxy) { }
end
proxy.__replay__(@_result)
yield(Test::Unit::TestCase::FINISHED, name)
end
module Forking
def run_in_isolation(&blk)
read, write = IO.pipe
pid = fork do
read.close
proxy = ProxyTestResult.new
yield proxy
write.puts [Marshal.dump(proxy)].pack("m")
exit!
def run(result)
unless defined?(@@ran_class_setup)
self.class.setup if self.class.respond_to?(:setup)
@@ran_class_setup = true
end
write.close
result = read.read
Process.wait2(pid)
Marshal.load(result.unpack("m")[0])
yield(Test::Unit::TestCase::STARTED, name)
@_result = result
proxy = run_in_isolation do |proxy|
super(proxy) { }
end
proxy.__replay__(@_result)
yield(Test::Unit::TestCase::FINISHED, name)
end
end
module Subprocess
# Crazy H4X to get this working in windows / jruby with
# no forking.
def run_in_isolation(&blk)
require "tempfile"
module Forking
def run_in_isolation(&blk)
read, write = IO.pipe
if ENV["ISOLATION_TEST"]
proxy = ProxyTestResult.new
yield proxy
File.open(ENV["ISOLATION_OUTPUT"], "w") do |file|
file.puts [Marshal.dump(proxy)].pack("m")
pid = fork do
read.close
proxy = ProxyTestResult.new
yield proxy
write.puts [Marshal.dump(proxy)].pack("m")
exit!
end
exit!
else
Tempfile.open("isolation") do |tmpfile|
ENV["ISOLATION_TEST"] = @method_name
ENV["ISOLATION_OUTPUT"] = tmpfile.path
load_paths = $-I.map {|p| "-I\"#{File.expand_path(p)}\"" }.join(" ")
`#{Gem.ruby} #{load_paths} #{$0} #{ORIG_ARGV.join(" ")} -t\"#{self.class}\"`
write.close
result = read.read
Process.wait2(pid)
Marshal.load(result.unpack("m")[0])
end
end
ENV.delete("ISOLATION_TEST")
ENV.delete("ISOLATION_OUTPUT")
module Subprocess
# Crazy H4X to get this working in windows / jruby with
# no forking.
def run_in_isolation(&blk)
require "tempfile"
return Marshal.load(tmpfile.read.unpack("m")[0])
if ENV["ISOLATION_TEST"]
proxy = ProxyTestResult.new
yield proxy
File.open(ENV["ISOLATION_OUTPUT"], "w") do |file|
file.puts [Marshal.dump(proxy)].pack("m")
end
exit!
else
Tempfile.open("isolation") do |tmpfile|
ENV["ISOLATION_TEST"] = @method_name
ENV["ISOLATION_OUTPUT"] = tmpfile.path
load_paths = $-I.map {|p| "-I\"#{File.expand_path(p)}\"" }.join(" ")
`#{Gem.ruby} #{load_paths} #{$0} #{ORIG_ARGV.join(" ")} -t\"#{self.class}\"`
ENV.delete("ISOLATION_TEST")
ENV.delete("ISOLATION_OUTPUT")
return Marshal.load(tmpfile.read.unpack("m")[0])
end
end
end
end
end
include forking_env? ? Forking : Subprocess
include forking_env? ? Forking : Subprocess
end
end
end

9
activesupport/lib/active_support/vendor.rb
View file

@ -19,10 +19,9 @@ rescue Gem::LoadError
$:.unshift "#{File.dirname(__FILE__)}/vendor/tzinfo-0.3.13"
end
# TODO I18n gem has not been released yet
# begin
# gem 'i18n', '~> 0.1.3'
# rescue Gem::LoadError
begin
gem 'i18n', '~> 0.1.3'
rescue Gem::LoadError
$:.unshift "#{File.dirname(__FILE__)}/vendor/i18n-0.1.3/lib"
require 'i18n'
# end
end

62
activesupport/test/core_ext/string_ext_test.rb
View file

@ -280,3 +280,65 @@ class CoreExtStringMultibyteTest < ActiveSupport::TestCase
end
end
end
=begin
string.rb - Interpolation for String.
Copyright (C) 2005-2009 Masao Mutoh
You may redistribute it and/or modify it under the same
license terms as Ruby.
=end
class TestGetTextString < Test::Unit::TestCase
def test_sprintf
assert_equal("foo is a number", "%{msg} is a number" % {:msg => "foo"})
assert_equal("bar is a number", "%s is a number" % ["bar"])
assert_equal("bar is a number", "%s is a number" % "bar")
assert_equal("1, test", "%{num}, %{record}" % {:num => 1, :record => "test"})
assert_equal("test, 1", "%{record}, %{num}" % {:num => 1, :record => "test"})
assert_equal("1, test", "%d, %s" % [1, "test"])
assert_equal("test, 1", "%2$s, %1$d" % [1, "test"])
assert_raise(ArgumentError) { "%-%" % [1] }
end
def test_percent
assert_equal("% 1", "%% %<num>d" % {:num => 1.0})
assert_equal("%{num} %<num>d", "%%{num} %%<num>d" % {:num => 1})
end
def test_sprintf_percent_in_replacement
assert_equal("%<not_translated>s", "%{msg}" % { :msg => '%<not_translated>s', :not_translated => 'should not happen' })
end
def test_sprintf_lack_argument
assert_equal("%{num}, test", "%{num}, %{record}" % {:record => "test"})
assert_equal("%{record}", "%{record}" % {:num => 1})
end
def test_no_placeholder
assert_equal("aaa", "aaa" % {:num => 1})
assert_equal("bbb", "bbb" % [1])
end
def test_sprintf_ruby19_style
assert_equal("1", "%<num>d" % {:num => 1})
assert_equal("0b1", "%<num>#b" % {:num => 1})
assert_equal("foo", "%<msg>s" % {:msg => "foo"})
assert_equal("1.000000", "%<num>f" % {:num => 1.0})
assert_equal(" 1", "%<num>3.0f" % {:num => 1.0})
assert_equal("100.00", "%<num>2.2f" % {:num => 100.0})
assert_equal("0x64", "%<num>#x" % {:num => 100.0})
assert_raise(ArgumentError) { "%<num>,d" % {:num => 100} }
assert_raise(ArgumentError) { "%<num>/d" % {:num => 100} }
end
def test_sprintf_old_style
assert_equal("foo 1.000000", "%s %f" % ["foo", 1.0])
end
def test_sprintf_mix
assert_equal("foo 1.000000", "%{name} %<num>f" % {:name => "foo", :num => 1.0})
assert_equal("%{name} 1.000000", "%{name} %f" % [1.0])
assert_equal("%{name} 1.000000", "%{name} %f" % [1.0, 2.0])
end
end

4
railties/lib/initializer.rb
View file

@ -12,6 +12,10 @@ require 'rails/configuration'
RAILS_ENV = (ENV['RAILS_ENV'] || 'development').dup unless defined?(RAILS_ENV)
module Rails
# Sanity check to make sure this file is only loaded once
# TODO: Get to the point where this can be removed.
raise "It looks like initializer.rb was required twice" if defined?(Initializer)
class Initializer
class Error < StandardError ; end

40
railties/lib/rails/configuration.rb
View file

@ -62,33 +62,19 @@ module Rails
end
@paths = Rails::Application::Root.new(root_path)
@paths.app = "app"
@paths.app.metals = "app/metal"
@paths.app.models = "app/models"
@paths.app.controllers = "app/controllers"
@paths.app.helpers = "app/helpers"
@paths.app.services = "app/services"
@paths.lib = "lib"
@paths.vendor = "vendor"
@paths.vendor.plugins = "vendor/plugins"
@paths.cache = "tmp/cache"
@paths.config = "config"
@paths.config.locales = "config/locales"
@paths.config.environments = "config/environments"
@paths.app.controllers.concat builtin_directories
@paths.app.load_path!
@paths.app.metals.load_path!
@paths.app.models.eager_load!
@paths.app.controllers.eager_load!
@paths.app.helpers.eager_load!
@paths.app.services.load_path!
@paths.app.metals.eager_load!
@paths.lib.load_path!
@paths.vendor.load_path!
@paths.config.environments.glob = "#{RAILS_ENV}.rb"
@paths.app "app", :load_path => true
@paths.app.metals "app/metal", :eager_load => true
@paths.app.models "app/models", :eager_load => true
@paths.app.controllers "app/controllers", builtin_directories, :eager_load => true
@paths.app.helpers "app/helpers", :eager_load => true
@paths.app.services "app/services", :load_path => true
@paths.lib "lib", :load_path => true
@paths.vendor "vendor", :load_path => true
@paths.vendor.plugins "vendor/plugins"
@paths.cache "tmp/cache"
@paths.config "config"
@paths.config.locales "config/locales"
@paths.config.environments "config/environments", :glob => "#{RAILS_ENV}.rb"
RAILS_ROOT.replace root_path
end

40
railties/lib/rails/paths.rb
View file

@ -6,8 +6,8 @@ module Rails
def method_missing(id, *args)
name = id.to_s
if name =~ /^(.*)=$/
@children[$1] = Path.new(args.first, @root)
if name =~ /^(.*)=$/ || args.any?
@children[$1 || name] = Path.new(@root, *args)
elsif path = @children[name]
path
else
@ -28,17 +28,15 @@ module Rails
# TODO: Move logic from set_root_path initializer
@path = File.expand_path(path)
@root = self
@load_once, @eager_load, @all_paths = [], [], []
@all_paths = []
end
def load_once
@load_once.uniq!
@load_once
all_paths.map { |path| path.paths if path.load_once? }.compact.flatten.uniq
end
def eager_load
@eager_load.uniq!
@eager_load
all_paths.map { |path| path.paths if path.eager_load? }.compact.flatten.uniq
end
def all_paths
@ -47,7 +45,7 @@ module Rails
end
def load_paths
all_paths.map { |path| path.paths }.flatten
all_paths.map { |path| path.paths if path.load_path? }.compact.flatten.uniq
end
def add_to_load_path
@ -55,6 +53,14 @@ module Rails
$LOAD_PATH.unshift(path) if File.directory?(path)
end
end
def push(*)
raise "Application root can only have one physical path"
end
alias unshift push
alias << push
alias concat push
end
class Path
@ -63,11 +69,18 @@ module Rails
attr_reader :path
attr_accessor :glob
def initialize(path, root)
def initialize(root, *paths)
@options = paths.last.is_a?(::Hash) ? paths.pop : {}
@children = {}
@root = root
@paths = [path].flatten
@glob = "**/*.rb"
@paths = paths.flatten
@glob = @options[:glob] || "**/*.rb"
@load_once = @options[:load_once]
@eager_load = @options[:eager_load]
@load_path = @options[:load_path] || @eager_load
@root.all_paths << self
end
def push(path)
@ -86,7 +99,6 @@ module Rails
def load_once!
@load_once = true
@root.load_once.push *self.paths
end
def load_once?
@ -95,8 +107,7 @@ module Rails
def eager_load!
@eager_load = true
@root.all_paths << self
@root.eager_load.push *self.paths
@load_path = true
end
def eager_load?
@ -105,7 +116,6 @@ module Rails
def load_path!
@load_path = true
@root.all_paths << self
end
def load_path?

2
railties/test/initializer/check_ruby_version_test.rb
View file

@ -1,7 +1,7 @@
require "initializer/test_helper"
module InitializerTests
class PathsTest < ActiveSupport::TestCase
class PathsTest < Test::Unit::TestCase
include ActiveSupport::Testing::Isolation
test "rails does not initialize with ruby version 1.8.1" do

29
railties/test/initializer/install_gem_spec_stubs_test.rb
View file

@ -1,7 +1,7 @@
require "initializer/test_helper"
module InitializerTests
class GemSpecStubsTest < ActiveSupport::TestCase
class GemSpecStubsTest < Test::Unit::TestCase
include ActiveSupport::Testing::Isolation
def setup
@ -34,19 +34,20 @@ module InitializerTests
assert $rubygems_required
end
test "does not fail if rubygems does not exist" do
Kernel.module_eval do
alias old_require require
def require(name)
raise LoadError if name == "rubygems"
old_require(name)
end
end
assert_nothing_raised do
Rails::Initializer.run { |c| c.frameworks = [] }
end
end
# Pending until we're further along
# test "does not fail if rubygems does not exist" do
# Kernel.module_eval do
# alias old_require require
# def require(name)
# raise LoadError if name == "rubygems"
# old_require(name)
# end
# end
#
# assert_nothing_raised do
# Rails::Initializer.run { |c| c.frameworks = [] }
# end
# end
test "adds fake Rubygems stubs if a framework is not loaded in Rubygems and we've vendored" do
Rails.vendor_rails = true

2
railties/test/initializer/path_test.rb
View file

@ -1,6 +1,6 @@
require "initializer/test_helper"
class PathsTest < ActiveSupport::TestCase
class PathsTest < Test::Unit::TestCase
include ActiveSupport::Testing::Isolation
def self.setup

48
railties/test/initializer/test_helper.rb
View file

@ -1,17 +1,18 @@
require 'abstract_unit'
require 'active_support/ruby/shim'
require 'initializer'
# This is a test helper file that simulates a rails application being
# boot from scratch in vendored mode. This file should really only be
# required in test cases that use the isolation helper so that requires
# can be reset correctly.
RAILS_ROOT = File.join(File.dirname(__FILE__), "root")
RAILS_FRAMEWORK_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..'))
RAILS_ROOT.replace File.join(File.dirname(__FILE__), "root")
require "test/unit"
# We are purposely avoiding adding things to the load path to catch bugs that only happen in the genuine article
require File.join(RAILS_FRAMEWORK_ROOT, 'activesupport', 'lib', 'active_support', 'testing', 'isolation')
require File.join(RAILS_FRAMEWORK_ROOT, 'activesupport', 'lib', 'active_support', 'testing', 'declarative')
module Rails
class << self
attr_accessor :vendor_rails
def vendor_rails?() @vendor_rails end
end
end
class Test::Unit::TestCase
extend ActiveSupport::Testing::Declarative
class ActiveSupport::TestCase
def assert_stderr(match)
$stderr = StringIO.new
yield
@ -21,4 +22,27 @@ class ActiveSupport::TestCase
ensure
$stderr = STDERR
end
end
end
# Fake boot.rb
module Rails
class << self
attr_accessor :vendor_rails
def vendor_rails?
@vendor_rails
end
def boot!
# Require the initializer
require File.join(RAILS_FRAMEWORK_ROOT, 'railties', 'lib', 'initializer')
# Run the initializer the same way boot.rb does it
Rails::Initializer.run(:install_gem_spec_stubs)
Rails::GemDependency.add_frozen_gem_path
Rails::Initializer.run(:set_load_path)
end
end
end
# All that for this:
Rails.boot!

92
railties/test/paths_test.rb
View file

@ -17,17 +17,37 @@ class PathsTest < ActiveSupport::TestCase
assert_equal ["/foo/bar"], @root.app.to_a
end
test "creating a root level path without assignment" do
@root.app "/foo/bar"
assert_equal ["/foo/bar"], @root.app.to_a
end
test "trying to access a path that does not exist raises NoMethodError" do
assert_raises(NoMethodError) { @root.app }
end
test "relative paths are relative to the paths root" do
@root.app = "app"
assert_equal ["/foo/bar/app"], @root.app.to_a
end
test "relative paths are relative to the paths root without assignment" do
@root.app "app"
assert_equal ["/foo/bar/app"], @root.app.to_a
end
test "creating a child level path" do
@root.app = "/foo/bar"
@root.app.models = "/foo/bar/baz"
assert_equal ["/foo/bar/baz"], @root.app.models.to_a
end
test "creating a child level path without assignment" do
@root.app = "/foo/bar"
@root.app.models "/foo/bar/baz"
assert_equal ["/foo/bar/baz"], @root.app.models.to_a
end
test "child level paths are relative from the root" do
@root.app = "/app"
@root.app.models = "baz"
@ -40,6 +60,11 @@ class PathsTest < ActiveSupport::TestCase
assert_equal ["/app", "/app2"], @root.app.to_a
end
test "adding multiple physical paths as an array without assignment" do
@root.app "/app", "/app2"
assert_equal ["/app", "/app2"], @root.app.to_a
end
test "adding multiple physical paths using #push" do
@root.app = "/app"
@root.app.push "/app2"
@ -66,10 +91,10 @@ class PathsTest < ActiveSupport::TestCase
test "the root can only have one physical path" do
assert_raise(RuntimeError) { Rails::Application::Root.new(["/fiz", "/biz"]) }
assert_raise(NoMethodError) { @root.push "/biz" }
assert_raise(NoMethodError) { @root.unshift "/biz" }
assert_raise(NoMethodError) { @root.concat ["/biz"]}
assert_raise(NoMethodError) { @root << "/biz" }
assert_raise(RuntimeError) { @root.push "/biz" }
assert_raise(RuntimeError) { @root.unshift "/biz" }
assert_raise(RuntimeError) { @root.concat ["/biz"]}
assert_raise(RuntimeError) { @root << "/biz" }
end
test "it is possible to add a path that should be loaded only once" do
@ -79,6 +104,19 @@ class PathsTest < ActiveSupport::TestCase
assert @root.load_once.include?(@root.app.paths.first)
end
test "it is possible to add a path without assignment and specify it should be loaded only once" do
@root.app "/app", :load_once => true
assert @root.app.load_once?
assert @root.load_once.include?("/app")
end
test "it is possible to add multiple paths without assignment and specify it should be loaded only once" do
@root.app "/app", "/app2", :load_once => true
assert @root.app.load_once?
assert @root.load_once.include?("/app")
assert @root.load_once.include?("/app2")
end
test "making a path load_once more than once only includes it once in @root.load_once" do
@root.app = "/app"
@root.app.load_once!
@ -86,6 +124,13 @@ class PathsTest < ActiveSupport::TestCase
assert_equal 1, @root.load_once.select {|p| p == @root.app.paths.first }.size
end
test "paths added to a load_once path should be added to the load_once collection" do
@root.app = "/app"
@root.app.load_once!
@root.app << "/app2"
assert_equal 2, @root.load_once.size
end
test "it is possible to mark a path as eager" do
@root.app = "/app"
@root.app.eager_load!
@ -93,6 +138,27 @@ class PathsTest < ActiveSupport::TestCase
assert @root.eager_load.include?(@root.app.paths.first)
end
test "it is possible to add a path without assignment and mark it as eager" do
@root.app "/app", :eager_load => true
assert @root.app.eager_load?
assert @root.eager_load.include?("/app")
end
test "it is possible to add multiple paths without assignment and mark them as eager" do
@root.app "/app", "/app2", :eager_load => true
assert @root.app.eager_load?
assert @root.eager_load.include?("/app")
assert @root.eager_load.include?("/app2")
end
test "it is possible to create a path without assignment and mark it both as eager and load once" do
@root.app "/app", :eager_load => true, :load_once => true
assert @root.app.eager_load?
assert @root.app.load_once?
assert @root.eager_load.include?("/app")
assert @root.load_once.include?("/app")
end
test "making a path eager more than once only includes it once in @root.eager_paths" do
@root.app = "/app"
@root.app.eager_load!
@ -100,6 +166,13 @@ class PathsTest < ActiveSupport::TestCase
assert_equal 1, @root.eager_load.select {|p| p == @root.app.paths.first }.size
end
test "paths added to a eager_load path should be added to the eager_load collection" do
@root.app = "/app"
@root.app.eager_load!
@root.app << "/app2"
assert_equal 2, @root.eager_load.size
end
test "a path should have a glob that defaults to **/*.rb" do
@root.app = "/app"
assert_equal "**/*.rb", @root.app.glob
@ -111,6 +184,11 @@ class PathsTest < ActiveSupport::TestCase
assert_equal "*.rb", @root.app.glob
end
test "it should be possible to override a path's default glob without assignment" do
@root.app "/app", :glob => "*.rb"
assert_equal "*.rb", @root.app.glob
end
test "a path can be added to the load path" do
@root.app = "app"
@root.app.load_path!
@ -118,6 +196,12 @@ class PathsTest < ActiveSupport::TestCase
assert_equal ["/foo/bar/app"], @root.load_paths
end
test "a path can be added to the load path on creation" do
@root.app "/app", :load_path => true
assert @root.app.load_path?
assert_equal ["/app"], @root.load_paths
end
test "adding a path to the eager paths also adds it to the load path" do
@root.app = "app"
@root.app.eager_load!