1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
|
require 'rake'
require 'rake/testtask'
require 'rake/rdoctask'
require 'rake/gempackagetask'
require 'rake/contrib/rubyforgepublisher'
require 'date'
require 'rbconfig'
require File.join(File.dirname(__FILE__), 'lib/rails', 'version')
PKG_BUILD = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
PKG_NAME = 'rails'
PKG_VERSION = Rails::VERSION::STRING + PKG_BUILD
PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
PKG_DESTINATION = ENV["RAILS_PKG_DESTINATION"] || "../#{PKG_NAME}"
RELEASE_NAME = "REL #{PKG_VERSION}"
RUBY_FORGE_PROJECT = "rails"
RUBY_FORGE_USER = "webster132"
task :default => :test
## This is required until the regular test task
## below passes. It's not ideal, but at least
## we can see the failures
task :test do
Dir['test/**/*_test.rb'].all? do |file|
system("ruby -Itest #{file}")
end or raise "Failures"
end
Rake::TestTask.new("regular_test") do |t|
t.libs << 'test'
t.pattern = 'test/**/*_test.rb'
t.warning = true
t.verbose = true
end
BASE_DIRS = %w(
app
config/environments
config/initializers
components
db
doc
log
lib
lib/tasks
public
script
script/performance
script/process
test
vendor
vendor/plugins
tmp/sessions
tmp/cache
tmp/sockets
tmp/pids
)
APP_DIRS = %w( models controllers helpers views views/layouts )
PUBLIC_DIRS = %w( images javascripts stylesheets )
TEST_DIRS = %w( fixtures unit functional mocks mocks/development mocks/test )
LOG_FILES = %w( server.log development.log test.log production.log )
HTML_FILES = %w( 422.html 404.html 500.html index.html robots.txt favicon.ico images/rails.png
javascripts/prototype.js javascripts/application.js
javascripts/effects.js javascripts/dragdrop.js javascripts/controls.js )
BIN_FILES = %w( about console destroy generate performance/benchmarker performance/profiler process/reaper process/spawner process/inspector runner server plugin )
VENDOR_LIBS = %w( actionpack activerecord actionmailer activesupport activeresource railties )
desc "Generates a fresh Rails package with documentation"
task :fresh_rails => [ :clean, :make_dir_structure, :initialize_file_stubs, :copy_vendor_libraries, :copy_ties_content, :generate_documentation ]
desc "Generates a fresh Rails package using GEMs with documentation"
task :fresh_gem_rails => [ :clean, :make_dir_structure, :initialize_file_stubs, :copy_ties_content, :copy_gem_environment ]
desc "Generates a fresh Rails package without documentation (faster)"
task :fresh_rails_without_docs => [ :clean, :make_dir_structure, :initialize_file_stubs, :copy_vendor_libraries, :copy_ties_content ]
desc "Generates a fresh Rails package without documentation (faster)"
task :fresh_rails_without_docs_using_links => [ :clean, :make_dir_structure, :initialize_file_stubs, :link_vendor_libraries, :copy_ties_content ]
desc "Generates minimal Rails package using symlinks"
task :dev => [ :clean, :make_dir_structure, :initialize_file_stubs, :link_vendor_libraries, :copy_ties_content ]
desc "Packages the fresh Rails package with documentation"
task :package => [ :clean, :fresh_rails ] do
system %{cd ..; tar -czvf #{PKG_NAME}-#{PKG_VERSION}.tgz #{PKG_NAME}}
system %{cd ..; zip -r #{PKG_NAME}-#{PKG_VERSION}.zip #{PKG_NAME}}
end
task :clean do
rm_rf PKG_DESTINATION
end
# Get external spinoffs -------------------------------------------------------------------
desc "Updates railties to the latest version of the javascript spinoffs"
task :update_js do
for js in %w( prototype controls dragdrop effects )
rm "html/javascripts/#{js}.js"
cp "./../actionpack/lib/action_view/helpers/javascripts/#{js}.js", "html/javascripts"
end
end
# Make directory structure ----------------------------------------------------------------
def make_dest_dirs(dirs, path = '.')
mkdir_p dirs.map { |dir| File.join(PKG_DESTINATION, path.to_s, dir) }
end
desc "Make the directory structure for the new Rails application"
task :make_dir_structure => [ :make_base_dirs, :make_app_dirs, :make_public_dirs, :make_test_dirs ]
task(:make_base_dirs) { make_dest_dirs BASE_DIRS }
task(:make_app_dirs) { make_dest_dirs APP_DIRS, 'app' }
task(:make_public_dirs) { make_dest_dirs PUBLIC_DIRS, 'public' }
task(:make_test_dirs) { make_dest_dirs TEST_DIRS, 'test' }
# Initialize file stubs -------------------------------------------------------------------
desc "Initialize empty file stubs (such as for logging)"
task :initialize_file_stubs => [ :initialize_log_files ]
task :initialize_log_files do
log_dir = File.join(PKG_DESTINATION, 'log')
chmod 0777, log_dir
LOG_FILES.each do |log_file|
log_path = File.join(log_dir, log_file)
touch log_path
chmod 0666, log_path
end
end
# Copy Vendors ----------------------------------------------------------------------------
desc "Copy in all the Rails packages to vendor"
task :copy_vendor_libraries do
mkdir File.join(PKG_DESTINATION, 'vendor', 'rails')
VENDOR_LIBS.each { |dir| cp_r File.join('..', dir), File.join(PKG_DESTINATION, 'vendor', 'rails', dir) }
FileUtils.rm_r(Dir.glob(File.join(PKG_DESTINATION, 'vendor', 'rails', "**", ".svn")))
end
desc "Link in all the Rails packages to vendor"
task :link_vendor_libraries do
mkdir File.join(PKG_DESTINATION, 'vendor', 'rails')
VENDOR_LIBS.each { |dir| ln_s File.join('..', '..', '..', dir), File.join(PKG_DESTINATION, 'vendor', 'rails', dir) }
end
# Copy Ties Content -----------------------------------------------------------------------
desc "Make copies of all the default content of ties"
task :copy_ties_content => [
:copy_rootfiles, :copy_dispatches, :copy_html_files, :copy_application,
:copy_configs, :copy_binfiles, :copy_test_helpers, :copy_app_doc_readme ]
task :copy_dispatches do
copy_with_rewritten_ruby_path("dispatches/dispatch.rb", "#{PKG_DESTINATION}/public/dispatch.rb")
chmod 0755, "#{PKG_DESTINATION}/public/dispatch.rb"
copy_with_rewritten_ruby_path("dispatches/dispatch.rb", "#{PKG_DESTINATION}/public/dispatch.cgi")
chmod 0755, "#{PKG_DESTINATION}/public/dispatch.cgi"
copy_with_rewritten_ruby_path("dispatches/dispatch.fcgi", "#{PKG_DESTINATION}/public/dispatch.fcgi")
chmod 0755, "#{PKG_DESTINATION}/public/dispatch.fcgi"
# copy_with_rewritten_ruby_path("dispatches/gateway.cgi", "#{PKG_DESTINATION}/public/gateway.cgi")
# chmod 0755, "#{PKG_DESTINATION}/public/gateway.cgi"
end
task :copy_html_files do
HTML_FILES.each { |file| cp File.join('html', file), File.join(PKG_DESTINATION, 'public', file) }
end
task :copy_application do
cp "helpers/application.rb", "#{PKG_DESTINATION}/app/controllers/application.rb"
cp "helpers/application_helper.rb", "#{PKG_DESTINATION}/app/helpers/application_helper.rb"
end
task :copy_configs do
app_name = "rails"
socket = nil
require 'erb'
File.open("#{PKG_DESTINATION}/config/database.yml", 'w') {|f| f.write ERB.new(IO.read("configs/databases/mysql.yml"), nil, '-').result(binding)}
cp "configs/routes.rb", "#{PKG_DESTINATION}/config/routes.rb"
cp "configs/initializers/inflections.rb", "#{PKG_DESTINATION}/config/initializers/inflections.rb"
cp "configs/initializers/mime_types.rb", "#{PKG_DESTINATION}/config/initializers/mime_types.rb"
cp "environments/boot.rb", "#{PKG_DESTINATION}/config/boot.rb"
cp "environments/environment.rb", "#{PKG_DESTINATION}/config/environment.rb"
cp "environments/production.rb", "#{PKG_DESTINATION}/config/environments/production.rb"
cp "environments/development.rb", "#{PKG_DESTINATION}/config/environments/development.rb"
cp "environments/test.rb", "#{PKG_DESTINATION}/config/environments/test.rb"
end
task :copy_binfiles do
BIN_FILES.each do |file|
dest_file = File.join(PKG_DESTINATION, 'script', file)
copy_with_rewritten_ruby_path(File.join('bin', file), dest_file)
chmod 0755, dest_file
end
end
task :copy_rootfiles do
cp "fresh_rakefile", "#{PKG_DESTINATION}/Rakefile"
cp "README", "#{PKG_DESTINATION}/README"
cp "CHANGELOG", "#{PKG_DESTINATION}/CHANGELOG"
end
task :copy_test_helpers do
cp "helpers/test_helper.rb", "#{PKG_DESTINATION}/test/test_helper.rb"
end
task :copy_app_doc_readme do
cp "doc/README_FOR_APP", "#{PKG_DESTINATION}/doc/README_FOR_APP"
end
def copy_with_rewritten_ruby_path(src_file, dest_file)
ruby = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
File.open(dest_file, 'w') do |df|
File.open(src_file) do |sf|
line = sf.gets
if (line =~ /#!.+ruby\s*/) != nil
df.puts("#!#{ruby}")
else
df.puts(line)
end
df.write(sf.read)
end
end
end
# Generate documentation ------------------------------------------------------------------
desc "Generate documentation for the framework and for the empty application"
task :generate_documentation => [ :generate_app_doc, :generate_rails_framework_doc ]
task :generate_rails_framework_doc do
system %{cd #{PKG_DESTINATION}; rake doc:rails}
end
task :generate_app_doc do
cp "doc/README_FOR_APP", "#{PKG_DESTINATION}/doc/README_FOR_APP"
system %{cd #{PKG_DESTINATION}; rake doc:app}
end
Rake::RDocTask.new { |rdoc|
rdoc.rdoc_dir = 'doc'
rdoc.title = "Railties -- Gluing the Engine to the Rails"
rdoc.options << '--line-numbers' << '--inline-source' << '--accessor' << 'cattr_accessor=object'
rdoc.options << '--charset' << 'utf-8'
rdoc.template = ENV['template'] ? "#{ENV['template']}.rb" : '../doc/template/horo'
rdoc.rdoc_files.include('README', 'CHANGELOG')
rdoc.rdoc_files.include('lib/*.rb')
rdoc.rdoc_files.include('lib/rails/*.rb')
rdoc.rdoc_files.include('lib/rails_generator/*.rb')
rdoc.rdoc_files.include('lib/commands/**/*.rb')
}
guides = [
'securing_rails_applications',
'testing_rails_applications',
'creating_plugins',
'migrations',
{ 'routing' => 'routing_outside_in' },
{ 'debugging' => 'debugging_rails_applications' }
]
guides_html_files = []
guides.each do |entry|
if entry.is_a?(Hash)
guide_folder = entry.keys.first
guide_name = entry.values.first
else
guide_folder = entry
guide_name = entry
end
input = "doc/guides/#{guide_folder}/#{guide_name}.txt"
output = "doc/guides/#{guide_folder}/#{guide_name}.html"
guides_html_files << output
file output => Dir["doc/guides/#{guide_folder}/*.txt"] do
sh "mizuho", input, "--template", "manualsonrails", "--icons-dir", "../icons"
end
end
desc "Generate HTML output for the guides"
task :generate_guides => guides_html_files
# Generate GEM ----------------------------------------------------------------------------
task :copy_gem_environment do
cp "environments/environment.rb", "#{PKG_DESTINATION}/config/environment.rb"
chmod 0755, dest_file
end
PKG_FILES = FileList[
'[a-zA-Z]*',
'bin/**/*',
'builtin/**/*',
'configs/**/*',
'doc/**/*',
'dispatches/**/*',
'environments/**/*',
'helpers/**/*',
'generators/**/*',
'html/**/*',
'lib/**/*'
] - [ 'test' ]
spec = Gem::Specification.new do |s|
s.platform = Gem::Platform::RUBY
s.name = 'rails'
s.version = PKG_VERSION
s.summary = "Web-application framework with template engine, control-flow layer, and ORM."
s.description = <<-EOF
Rails is a framework for building web-application using CGI, FCGI, mod_ruby, or WEBrick
on top of either MySQL, PostgreSQL, SQLite, DB2, SQL Server, or Oracle with eRuby- or Builder-based templates.
EOF
s.add_dependency('rake', '>= 0.8.1')
s.add_dependency('activesupport', '= 2.1.0' + PKG_BUILD)
s.add_dependency('activerecord', '= 2.1.0' + PKG_BUILD)
s.add_dependency('actionpack', '= 2.1.0' + PKG_BUILD)
s.add_dependency('actionmailer', '= 2.1.0' + PKG_BUILD)
s.add_dependency('activeresource', '= 2.1.0' + PKG_BUILD)
s.rdoc_options << '--exclude' << '.'
s.has_rdoc = false
s.files = PKG_FILES.to_a.delete_if {|f| f.include?('.svn')}
s.require_path = 'lib'
s.bindir = "bin" # Use these for applications.
s.executables = ["rails"]
s.default_executable = "rails"
s.author = "David Heinemeier Hansson"
s.email = "david@loudthinking.com"
s.homepage = "http://www.rubyonrails.org"
s.rubyforge_project = "rails"
end
Rake::GemPackageTask.new(spec) do |pkg|
pkg.gem_spec = spec
end
# Publishing -------------------------------------------------------
desc "Publish the rails gem"
task :pgem => [:gem] do
Rake::SshFilePublisher.new("wrath.rubyonrails.org", "public_html/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
`ssh wrath.rubyonrails.org './gemupdate.sh'`
end
desc "Publish the API documentation"
task :pdoc => :rdoc do
# railties API isn't separately published
end
desc "Publish the release files to RubyForge."
task :release => [ :package ] do
require 'rubyforge'
packages = %w( gem ).collect{ |ext| "pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}" }
rubyforge = RubyForge.new
rubyforge.login
rubyforge.add_release(PKG_NAME, PKG_NAME, "REL #{PKG_VERSION}", *packages)
end
|