Class Rails::Generator::Commands::Create < Rails::Generator::Commands::Base

# File rails/railties/lib/rails_generator/commands.rb, line 157
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.
    if last and last.const_defined?(name.camelize)
      raise_class_collision(class_name)
    end
  end
end

# File rails/railties/lib/rails_generator/commands.rb, line 288
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

# File rails/railties/lib/rails_generator/commands.rb, line 297
def directory(relative_path)
  path = destination_path(relative_path)
  if File.exists?(path)
    logger.exists relative_path
  else
    logger.create relative_path
    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

# File rails/railties/lib/rails_generator/commands.rb, line 196
def file(relative_source, relative_destination, file_options = {}, &block)
  # Determine full paths for source and destination files.
  source              = source_path(relative_source)
  destination         = destination_path(relative_destination)
  destination_exists  = File.exists?(destination)

  # If source and destination are identical then we're done.
  if destination_exists and identical?(source, destination, &block)
    return logger.identical(relative_destination) 
  end

  # Check for and resolve file collisions.
  if destination_exists

    # Make a choice whether to overwrite the file.  :force and
    # :skip already have their mind made up, but give :ask a shot.
    choice = case (file_options[:collision] || options[:collision]).to_sym #|| :ask
      when :ask   then force_file_collision?(relative_destination, source, destination, file_options, &block)
      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.
  File.open(destination, 'wb') do |dest|
    dest.write render_file(source, file_options, &block)
  end

  # Optionally change permissions.
  if file_options[:chmod]
    FileUtils.chmod(file_options[:chmod], destination)
  end

  # Optionally add file to subversion
  system("svn add #{destination}") if options[:svn]
end

# File rails/railties/lib/rails_generator/commands.rb, line 255
def identical?(source, destination, &block)
  return false if File.directory? destination
  source      = block_given? ? File.open(source) {|sf| yield(sf)} : IO.read(source)
  destination = IO.read(destination)
  source == destination
end

# File rails/railties/lib/rails_generator/commands.rb, line 333
def migration_template(relative_source, relative_destination, template_options = {})
  migration_directory relative_destination
  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)
end

# File rails/railties/lib/rails_generator/commands.rb, line 325
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

# File rails/railties/lib/rails_generator/commands.rb, line 340
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}"
  unless options[:pretend]
    gsub_file 'config/routes.rb', %r(#{Regexp.escape(sentinel)})/i do |match|
      "#{match}\n  map.resources #{resource_list}\n"
    end
  end
end

# File rails/railties/lib/rails_generator/commands.rb, line 276
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