2005-02-07 08:14:05 -05:00
require 'delegate'
require 'optparse'
require 'fileutils'
2006-11-02 03:36:41 -05:00
require 'tempfile'
2005-02-07 08:14:05 -05:00
require 'erb'
module Rails
module Generator
module Commands
# Here's a convenient way to get a handle on generator commands.
# Command.instance('destroy', my_generator) instantiates a Destroy
# delegate of my_generator ready to do your dirty work.
def self . instance ( command , generator )
const_get ( command . to_s . camelize ) . new ( generator )
end
# Even more convenient access to commands. Include Commands in
# the generator Base class to get a nice #command instance method
# which returns a delegate for the requested command.
2006-04-29 14:10:14 -04:00
def self . included ( base )
2005-02-07 08:14:05 -05:00
base . send ( :define_method , :command ) do | command |
Commands . instance ( command , self )
end
end
# Generator commands delegate Rails::Generator::Base and implement
# a standard set of actions. Their behavior is defined by the way
# they respond to these actions: Create brings life; Destroy brings
# death; List passively observes.
#
# Commands are invoked by replaying (or rewinding) the generator's
# manifest of actions. See Rails::Generator::Manifest and
# Rails::Generator::Base#manifest method that generator subclasses
# are required to override.
#
# Commands allows generators to "plug in" invocation behavior, which
# corresponds to the GoF Strategy pattern.
class Base < DelegateClass ( Rails :: Generator :: Base )
# Replay action manifest. RewindBase subclass rewinds manifest.
def invoke!
manifest . replay ( self )
end
def dependency ( generator_name , args , runtime_options = { } )
logger . dependency ( generator_name ) do
self . class . new ( instance ( generator_name , args , full_options ( runtime_options ) ) ) . invoke!
end
end
# Does nothing for all commands except Create.
def class_collisions ( * class_names )
end
# Does nothing for all commands except Create.
def readme ( * args )
end
2005-11-19 23:21:06 -05:00
protected
2005-11-20 00:13:59 -05:00
def migration_directory ( relative_path )
directory ( @migration_directory = relative_path )
end
2005-11-19 23:21:06 -05:00
def existing_migrations ( file_name )
2006-01-13 04:26:53 -05:00
Dir . glob ( " #{ @migration_directory } /[0-9]*_*.rb " ) . grep ( / [0-9]+_ #{ file_name } .rb$ / )
2005-11-19 23:21:06 -05:00
end
def migration_exists? ( file_name )
not existing_migrations ( file_name ) . empty?
end
def current_migration_number
2005-11-20 00:13:59 -05:00
Dir . glob ( " #{ @migration_directory } /[0-9]*.rb " ) . inject ( 0 ) do | max , file_path |
2005-11-19 23:21:06 -05:00
n = File . basename ( file_path ) . split ( '_' , 2 ) . first . to_i
if n > max then n else max end
end
end
def next_migration_number
current_migration_number + 1
end
def next_migration_string ( padding = 3 )
" %. #{ padding } d " % next_migration_number
end
2006-10-31 20:57:06 -05:00
def gsub_file ( relative_destination , regexp , * args , & block )
path = destination_path ( relative_destination )
content = File . read ( path ) . gsub ( regexp , * args , & block )
File . open ( path , 'wb' ) { | file | file . write ( content ) }
end
2005-02-07 08:14:05 -05:00
private
# Ask the user interactively whether to force collision.
2006-11-02 03:36:41 -05:00
def force_file_collision? ( destination , src , dst , file_options = { } , & block )
2007-10-11 11:15:32 -04:00
$stdout . print " overwrite #{ destination } ? (enter \" h \" for help) [Ynaqdh] "
case $stdin . gets . chomp
when / \ Ad \ z /i
2007-01-12 23:09:18 -05:00
Tempfile . open ( File . basename ( destination ) , File . dirname ( dst ) ) do | temp |
2006-11-02 03:36:41 -05:00
temp . write render_file ( src , file_options , & block )
temp . rewind
$stdout . puts ` #{ diff_cmd } #{ dst } #{ temp . path } `
end
puts " retrying "
raise 'retry diff'
2007-10-11 11:15:32 -04:00
when / \ Aa \ z /i
2005-02-07 08:14:05 -05:00
$stdout . puts " forcing #{ spec . name } "
options [ :collision ] = :force
2007-10-11 11:15:32 -04:00
when / \ Aq \ z /i
2005-02-07 08:14:05 -05:00
$stdout . puts " aborting #{ spec . name } "
raise SystemExit
2007-10-11 11:15:32 -04:00
when / \ An \ z /i then :skip
when / \ Ay \ z /i then :force
else
$stdout . puts <<-HELP
Y - yes , overwrite
n - no , do not overwrite
a - all , overwrite this and all others
q - quit , abort
d - diff , show the differences between the old and the new
h - help , show this help
HELP
raise 'retry'
2005-02-07 08:14:05 -05:00
end
rescue
retry
end
2006-11-02 03:36:41 -05:00
def diff_cmd
ENV [ 'RAILS_DIFF' ] || 'diff -u'
end
2005-02-07 08:14:05 -05:00
def render_template_part ( template_options )
# Getting Sandbox to evaluate part template in it
part_binding = template_options [ :sandbox ] . call . sandbox_binding
part_rel_path = template_options [ :insert ]
part_path = source_path ( part_rel_path )
# Render inner template within Sandbox binding
rendered_part = ERB . new ( File . readlines ( part_path ) . join , nil , '-' ) . result ( part_binding )
begin_mark = template_part_mark ( template_options [ :begin_mark ] , template_options [ :mark_id ] )
end_mark = template_part_mark ( template_options [ :end_mark ] , template_options [ :mark_id ] )
begin_mark + rendered_part + end_mark
2005-11-19 23:21:06 -05:00
end
2005-02-07 08:14:05 -05:00
2005-11-19 23:21:06 -05:00
def template_part_mark ( name , id )
" <!--[ #{ name } : #{ id } ]--> \n "
2005-02-07 08:14:05 -05:00
end
end
# Base class for commands which handle generator actions in reverse, such as Destroy.
class RewindBase < Base
# Rewind action manifest.
def invoke!
manifest . rewind ( self )
end
end
# Create is the premier generator command. It copies files, creates
# directories, renders templates, and more.
class Create < Base
# Check whether the given class names are already taken by
# Ruby or Rails. In the future, expand to check other namespaces
# such as the rest of the user's app.
def class_collisions ( * class_names )
class_names . flatten . each do | class_name |
# Convert to string to allow symbol arguments.
class_name = class_name . to_s
# Skip empty strings.
next if class_name . strip . empty?
# Split the class from its module nesting.
nesting = class_name . split ( '::' )
name = nesting . pop
# Extract the last Module in the nesting.
last = nesting . inject ( Object ) { | last , nest |
break unless last . const_defined? ( nest )
last . const_get ( nest )
}
# If the last Module exists, check whether the given
# class exists and raise a collision if so.
2005-02-19 11:41:39 -05:00
if last and last . const_defined? ( name . camelize )
2005-02-07 08:14:05 -05:00
raise_class_collision ( class_name )
end
end
end
# Copy a file from source to destination with collision checking.
#
2006-02-25 20:12:58 -05:00
# The file_options hash accepts :chmod and :shebang and :collision options.
2005-02-07 08:14:05 -05:00
# :chmod sets the permissions of the destination file:
# file 'config/empty.log', 'log/test.log', :chmod => 0664
# :shebang sets the #!/usr/bin/ruby line for scripts
# file 'bin/generate.rb', 'script/generate', :chmod => 0755, :shebang => '/usr/bin/env ruby'
2006-02-25 20:12:58 -05:00
# :collision sets the collision option only for the destination file:
# file 'settings/server.yml', 'config/server.yml', :collision => :skip
2005-02-07 08:14:05 -05:00
#
# Collisions are handled by checking whether the destination file
# exists and either skipping the file, forcing overwrite, or asking
# the user what to do.
2005-10-08 14:40:00 -04:00
def file ( relative_source , relative_destination , file_options = { } , & block )
2005-02-07 08:14:05 -05:00
# Determine full paths for source and destination files.
2005-10-08 12:56:36 -04:00
source = source_path ( relative_source )
destination = destination_path ( relative_destination )
destination_exists = File . exists? ( destination )
2005-10-08 14:40:00 -04:00
# If source and destination are identical then we're done.
if destination_exists and identical? ( source , destination , & block )
return logger . identical ( relative_destination )
end
2005-02-07 08:14:05 -05:00
# Check for and resolve file collisions.
2005-10-08 12:56:36 -04:00
if destination_exists
2005-02-07 08:14:05 -05:00
# Make a choice whether to overwrite the file. :force and
# :skip already have their mind made up, but give :ask a shot.
2006-02-25 20:12:58 -05:00
choice = case ( file_options [ :collision ] || options [ :collision ] ) . to_sym #|| :ask
2006-11-02 03:36:41 -05:00
when :ask then force_file_collision? ( relative_destination , source , destination , file_options , & block )
2005-02-07 08:14:05 -05:00
when :force then :force
when :skip then :skip
else raise " Invalid collision option: #{ options [ :collision ] . inspect } "
end
# Take action based on our choice. Bail out if we chose to
# skip the file; otherwise, log our transgression and continue.
case choice
when :force then logger . force ( relative_destination )
when :skip then return ( logger . skip ( relative_destination ) )
else raise " Invalid collision choice: #{ choice } .inspect "
end
# File doesn't exist so log its unbesmirched creation.
else
logger . create relative_destination
end
# If we're pretending, back off now.
return if options [ :pretend ]
# Write destination file with optional shebang. Yield for content
# if block given so templaters may render the source file. If a
# shebang is requested, replace the existing shebang or insert a
# new one.
2006-11-02 03:36:41 -05:00
File . open ( destination , 'wb' ) do | dest |
dest . write render_file ( source , file_options , & block )
2005-02-07 08:14:05 -05:00
end
# Optionally change permissions.
if file_options [ :chmod ]
FileUtils . chmod ( file_options [ :chmod ] , destination )
end
2006-11-02 03:36:41 -05:00
2005-09-09 05:02:55 -04:00
# Optionally add file to subversion
system ( " svn add #{ destination } " ) if options [ :svn ]
2005-02-07 08:14:05 -05:00
end
2005-10-08 14:40:00 -04:00
# Checks if the source and the destination file are identical. If
# passed a block then the source file is a template that needs to first
# be evaluated before being compared to the destination.
def identical? ( source , destination , & block )
2005-10-08 14:57:14 -04:00
return false if File . directory? destination
2005-10-08 14:40:00 -04:00
source = block_given? ? File . open ( source ) { | sf | yield ( sf ) } : IO . read ( source )
destination = IO . read ( destination )
2005-10-08 16:12:16 -04:00
source == destination
2005-10-08 12:56:36 -04:00
end
2005-02-07 08:14:05 -05:00
# Generate a file for a Rails application using an ERuby template.
2007-09-28 10:18:47 -04:00
# Looks up and evaluates a template by name and writes the result.
2005-02-07 08:14:05 -05:00
#
# The ERB template uses explicit trim mode to best control the
# proliferation of whitespace in generated code. <%- trims leading
# whitespace; -%> trims trailing whitespace including one newline.
#
# A hash of template options may be passed as the last argument.
# The options accepted by the file are accepted as well as :assigns,
# a hash of variable bindings. Example:
# template 'foo', 'bar', :assigns => { :action => 'view' }
#
# Template is implemented in terms of file. It calls file with a
# block which takes a file handle and returns its rendered contents.
def template ( relative_source , relative_destination , template_options = { } )
file ( relative_source , relative_destination , template_options ) do | file |
# Evaluate any assignments in a temporary, throwaway binding.
vars = template_options [ :assigns ] || { }
b = binding
vars . each { | k , v | eval " #{ k } = vars[: #{ k } ] || vars[' #{ k } '] " , b }
# Render the source file with the temporary binding.
ERB . new ( file . read , nil , '-' ) . result ( b )
end
end
def complex_template ( relative_source , relative_destination , template_options = { } )
options = template_options . dup
options [ :assigns ] || = { }
options [ :assigns ] [ 'template_for_inclusion' ] = render_template_part ( template_options )
template ( relative_source , relative_destination , options )
end
# Create a directory including any missing parent directories.
# Always directories which exist.
def directory ( relative_path )
path = destination_path ( relative_path )
if File . exists? ( path )
logger . exists relative_path
else
logger . create relative_path
2006-11-02 02:55:04 -05:00
unless options [ :pretend ]
FileUtils . mkdir_p ( path )
# Subversion doesn't do path adds, so we need to add
# each directory individually.
# So stack up the directory tree and add the paths to
# subversion in order without recursion.
if options [ :svn ]
stack = [ relative_path ]
until File . dirname ( stack . last ) == stack . last # dirname('.') == '.'
stack . push File . dirname ( stack . last )
end
stack . reverse_each do | rel_path |
svn_path = destination_path ( rel_path )
system ( " svn add -N #{ svn_path } " ) unless File . directory? ( File . join ( svn_path , '.svn' ) )
end
end
end
end
end
2005-02-07 08:14:05 -05:00
# Display a README.
def readme ( * relative_sources )
relative_sources . flatten . each do | relative_source |
logger . readme relative_source
puts File . read ( source_path ( relative_source ) ) unless options [ :pretend ]
end
end
2005-11-19 23:21:06 -05:00
# When creating a migration, it knows to find the first available file in db/migrate and use the migration.rb template.
def migration_template ( relative_source , relative_destination , template_options = { } )
2005-11-20 00:13:59 -05:00
migration_directory relative_destination
2006-02-25 15:26:14 -05:00
migration_file_name = template_options [ :migration_file_name ] || file_name
raise " Another migration is already named #{ migration_file_name } : #{ existing_migrations ( migration_file_name ) . first } " if migration_exists? ( migration_file_name )
template ( relative_source , " #{ relative_destination } / #{ next_migration_string } _ #{ migration_file_name } .rb " , template_options )
2005-11-19 23:21:06 -05:00
end
2006-10-31 20:57:06 -05:00
def route_resources ( * resources )
resource_list = resources . map { | r | r . to_sym . inspect } . join ( ', ' )
sentinel = 'ActionController::Routing::Routes.draw do |map|'
logger . route " map.resources #{ resource_list } "
2006-12-26 14:39:30 -05:00
unless options [ :pretend ]
gsub_file 'config/routes.rb' , / ( #{ Regexp . escape ( sentinel ) } ) /mi do | match |
" #{ match } \n map.resources #{ resource_list } \n "
end
2006-10-31 20:57:06 -05:00
end
end
2005-02-07 08:14:05 -05:00
private
2006-11-02 03:36:41 -05:00
def render_file ( path , options = { } )
File . open ( path , 'rb' ) do | file |
if block_given?
yield file
else
content = ''
if shebang = options [ :shebang ]
content << " # ! #{ shebang } \n "
if line = file . gets
content << " line \n " if line !~ / ^ # ! /
end
end
content << file . read
end
end
end
2005-02-07 08:14:05 -05:00
# Raise a usage error with an informative WordNet suggestion.
# Thanks to Florian Gross (flgr).
def raise_class_collision ( class_name )
message = <<end_message
The name '#{class_name}' is reserved by Ruby on Rails .
Please choose an alternative and run this generator again .
end_message
if suggest = find_synonyms ( class_name )
message << " \n Suggestions: \n \n "
message << suggest . join ( " \n " )
end
raise UsageError , message
end
SYNONYM_LOOKUP_URI = " http://wordnet.princeton.edu/cgi-bin/webwn2.0?stage=2&word=%s&posnumber=1&searchtypenumber=2&senses=&showglosses=1 "
# Look up synonyms on WordNet. Thanks to Florian Gross (flgr).
def find_synonyms ( word )
require 'open-uri'
require 'timeout'
timeout ( 5 ) do
open ( SYNONYM_LOOKUP_URI % word ) do | stream |
data = stream . read . gsub ( " " , " " ) . gsub ( " <BR> " , " " )
data . scan ( / ^Sense \ d+ \ n.+? \ n \ n /m )
end
end
rescue Exception
return nil
end
end
# Undo the actions performed by a generator. Rewind the action
# manifest and attempt to completely erase the results of each action.
class Destroy < RewindBase
# Remove a file if it exists and is a file.
2005-09-09 05:02:55 -04:00
def file ( relative_source , relative_destination , file_options = { } )
2005-02-07 08:14:05 -05:00
destination = destination_path ( relative_destination )
if File . exists? ( destination )
logger . rm relative_destination
2005-09-09 05:02:55 -04:00
unless options [ :pretend ]
if options [ :svn ]
# If the file has been marked to be added
2005-09-11 02:26:38 -04:00
# but has not yet been checked in, revert and delete
2005-09-09 05:02:55 -04:00
if options [ :svn ] [ relative_destination ]
system ( " svn revert #{ destination } " )
FileUtils . rm ( destination )
else
# If the directory is not in the status list, it
# has no modifications so we can simply remove it
system ( " svn rm #{ destination } " )
end
else
FileUtils . rm ( destination )
end
end
2005-02-07 08:14:05 -05:00
else
logger . missing relative_destination
return
end
end
# Templates are deleted just like files and the actions take the
# same parameters, so simply alias the file method.
alias_method :template , :file
# Remove each directory in the given path from right to left.
# Remove each subdirectory if it exists and is a directory.
def directory ( relative_path )
parts = relative_path . split ( '/' )
until parts . empty?
partial = File . join ( parts )
path = destination_path ( partial )
if File . exists? ( path )
if Dir [ File . join ( path , '*' ) ] . empty?
logger . rmdir partial
2005-09-09 05:02:55 -04:00
unless options [ :pretend ]
if options [ :svn ]
# If the directory has been marked to be added
2005-09-11 02:26:38 -04:00
# but has not yet been checked in, revert and delete
2005-09-09 05:02:55 -04:00
if options [ :svn ] [ relative_path ]
system ( " svn revert #{ path } " )
FileUtils . rmdir ( path )
else
# If the directory is not in the status list, it
# has no modifications so we can simply remove it
system ( " svn rm #{ path } " )
end
else
FileUtils . rmdir ( path )
end
end
2005-02-07 08:14:05 -05:00
else
logger . notempty partial
end
else
logger . missing partial
end
parts . pop
end
end
def complex_template ( * args )
# nothing should be done here
end
2005-11-19 23:21:06 -05:00
# When deleting a migration, it knows to delete every file named "[0-9]*_#{file_name}".
def migration_template ( relative_source , relative_destination , template_options = { } )
2005-11-20 00:13:59 -05:00
migration_directory relative_destination
2006-03-19 01:06:20 -05:00
migration_file_name = template_options [ :migration_file_name ] || file_name
2006-03-26 17:15:19 -05:00
unless migration_exists? ( migration_file_name )
puts " There is no migration named #{ migration_file_name } "
return
end
2006-03-19 01:06:20 -05:00
existing_migrations ( migration_file_name ) . each do | file_path |
2005-11-19 23:21:06 -05:00
file ( relative_source , file_path , template_options )
end
end
2006-10-31 20:57:06 -05:00
def route_resources ( * resources )
resource_list = resources . map { | r | r . to_sym . inspect } . join ( ', ' )
look_for = " \n map.resources #{ resource_list } \n "
logger . route " map.resources #{ resource_list } "
gsub_file 'config/routes.rb' , / ( #{ look_for } ) /mi , ''
end
2005-02-07 08:14:05 -05:00
end
# List a generator's action manifest.
class List < Base
def dependency ( generator_name , args , options = { } )
logger . dependency " #{ generator_name } ( #{ args . join ( ', ' ) } , #{ options . inspect } ) "
end
def class_collisions ( * class_names )
logger . class_collisions class_names . join ( ', ' )
end
def file ( relative_source , relative_destination , options = { } )
logger . file relative_destination
end
def template ( relative_source , relative_destination , options = { } )
logger . template relative_destination
end
def complex_template ( relative_source , relative_destination , options = { } )
logger . template " #{ options [ :insert ] } inside #{ relative_destination } "
end
def directory ( relative_path )
logger . directory " #{ destination_path ( relative_path ) } / "
end
def readme ( * args )
logger . readme args . join ( ', ' )
end
2005-11-19 23:21:06 -05:00
def migration_template ( relative_source , relative_destination , options = { } )
2005-11-20 00:13:59 -05:00
migration_directory relative_destination
2005-11-19 23:21:06 -05:00
logger . migration_template file_name
end
2006-10-31 20:57:06 -05:00
def route_resources ( * resources )
resource_list = resources . map { | r | r . to_sym . inspect } . join ( ', ' )
logger . route " map.resources #{ resource_list } "
end
2005-02-07 08:14:05 -05:00
end
# Update generator's action manifest.
class Update < Create
def file ( relative_source , relative_destination , options = { } )
# logger.file relative_destination
end
def template ( relative_source , relative_destination , options = { } )
# logger.template relative_destination
end
def complex_template ( relative_source , relative_destination , template_options = { } )
begin
dest_file = destination_path ( relative_destination )
source_to_update = File . readlines ( dest_file ) . join
rescue Errno :: ENOENT
logger . missing relative_destination
return
end
2007-02-20 19:29:44 -05:00
logger . refreshing " #{ template_options [ :insert ] . gsub ( / \ .erb / , '' ) } inside #{ relative_destination } "
2005-02-07 08:14:05 -05:00
begin_mark = Regexp . quote ( template_part_mark ( template_options [ :begin_mark ] , template_options [ :mark_id ] ) )
end_mark = Regexp . quote ( template_part_mark ( template_options [ :end_mark ] , template_options [ :mark_id ] ) )
# Refreshing inner part of the template with freshly rendered part.
rendered_part = render_template_part ( template_options )
source_to_update . gsub! ( / #{ begin_mark } .*? #{ end_mark } /m , rendered_part )
File . open ( dest_file , 'w' ) { | file | file . write ( source_to_update ) }
end
def directory ( relative_path )
# logger.directory "#{destination_path(relative_path)}/"
end
end
end
end
end