mirror of
https://github.com/TracksApp/tracks.git
synced 2025-12-21 09:40:13 +01:00
901a58f8a3
Changes you will need to make: * In your environment.rb, you will need to update references to a few files per environment.rb.tmpl * In your environment.rb, you will need to specify the local time zone of the computer that is running your Tracks install. Other notes on my changes: * Modified our code to take advantage of Rails 2.1's slick time zone support. * Upgraded will_paginate for compatibility * Hacked the Selenium on Rails plugin, which has not been updated in some time and does not support Rails 2.1 * Verified that all tests pass on my machine, including Selenium tests -- I'd like confirmation from others, too.
263 lines
9.9 KiB
Ruby
263 lines
9.9 KiB
Ruby
require File.dirname(__FILE__) + '/options'
|
|
require File.dirname(__FILE__) + '/manifest'
|
|
require File.dirname(__FILE__) + '/spec'
|
|
require File.dirname(__FILE__) + '/generated_attribute'
|
|
|
|
module Rails
|
|
# Rails::Generator is a code generation platform tailored for the Rails
|
|
# web application framework. Generators are easily invoked within Rails
|
|
# applications to add and remove components such as models and controllers.
|
|
# New generators are easy to create and may be distributed as RubyGems,
|
|
# tarballs, or Rails plugins for inclusion system-wide, per-user,
|
|
# or per-application.
|
|
#
|
|
# For actual examples see the rails_generator/generators directory in the
|
|
# Rails source (or the +railties+ directory if you have frozen the Rails
|
|
# source in your application).
|
|
#
|
|
# Generators may subclass other generators to provide variations that
|
|
# require little or no new logic but replace the template files.
|
|
#
|
|
# For a RubyGem, put your generator class and templates in the +lib+
|
|
# directory. For a Rails plugin, make a +generators+ directory at the
|
|
# root of your plugin.
|
|
#
|
|
# The layout of generator files can be seen in the built-in
|
|
# +controller+ generator:
|
|
#
|
|
# generators/
|
|
# components/
|
|
# controller/
|
|
# controller_generator.rb
|
|
# templates/
|
|
# controller.rb
|
|
# functional_test.rb
|
|
# helper.rb
|
|
# view.html.erb
|
|
#
|
|
# The directory name (+controller+) matches the name of the generator file
|
|
# (controller_generator.rb) and class (ControllerGenerator). The files
|
|
# that will be copied or used as templates are stored in the +templates+
|
|
# directory.
|
|
#
|
|
# The filenames of the templates don't matter, but choose something that
|
|
# will be self-explanatory since you will be referencing these in the
|
|
# +manifest+ method inside your generator subclass.
|
|
#
|
|
#
|
|
module Generator
|
|
class GeneratorError < StandardError; end
|
|
class UsageError < GeneratorError; end
|
|
|
|
|
|
# The base code generator is bare-bones. It sets up the source and
|
|
# destination paths and tells the logger whether to keep its trap shut.
|
|
#
|
|
# It's useful for copying files such as stylesheets, images, or
|
|
# javascripts.
|
|
#
|
|
# For more comprehensive template-based passive code generation with
|
|
# arguments, you'll want Rails::Generator::NamedBase.
|
|
#
|
|
# Generators create a manifest of the actions they perform then hand
|
|
# the manifest to a command which replays the actions to do the heavy
|
|
# lifting (such as checking for existing files or creating directories
|
|
# if needed). Create, destroy, and list commands are included. Since a
|
|
# single manifest may be used by any command, creating new generators is
|
|
# as simple as writing some code templates and declaring what you'd like
|
|
# to do with them.
|
|
#
|
|
# The manifest method must be implemented by subclasses, returning a
|
|
# Rails::Generator::Manifest. The +record+ method is provided as a
|
|
# convenience for manifest creation. Example:
|
|
#
|
|
# class StylesheetGenerator < Rails::Generator::Base
|
|
# def manifest
|
|
# record do |m|
|
|
# m.directory('public/stylesheets')
|
|
# m.file('application.css', 'public/stylesheets/application.css')
|
|
# end
|
|
# end
|
|
# end
|
|
#
|
|
# See Rails::Generator::Commands::Create for a list of methods available
|
|
# to the manifest.
|
|
class Base
|
|
include Options
|
|
|
|
# Declare default options for the generator. These options
|
|
# are inherited to subclasses.
|
|
default_options :collision => :ask, :quiet => false
|
|
|
|
# A logger instance available everywhere in the generator.
|
|
cattr_accessor :logger
|
|
|
|
# Every generator that is dynamically looked up is tagged with a
|
|
# Spec describing where it was found.
|
|
class_inheritable_accessor :spec
|
|
|
|
attr_reader :source_root, :destination_root, :args
|
|
|
|
def initialize(runtime_args, runtime_options = {})
|
|
@args = runtime_args
|
|
parse!(@args, runtime_options)
|
|
|
|
# Derive source and destination paths.
|
|
@source_root = options[:source] || File.join(spec.path, 'templates')
|
|
if options[:destination]
|
|
@destination_root = options[:destination]
|
|
elsif defined? ::RAILS_ROOT
|
|
@destination_root = ::RAILS_ROOT
|
|
end
|
|
|
|
# Silence the logger if requested.
|
|
logger.quiet = options[:quiet]
|
|
|
|
# Raise usage error if help is requested.
|
|
usage if options[:help]
|
|
end
|
|
|
|
# Generators must provide a manifest. Use the +record+ method to create
|
|
# a new manifest and record your generator's actions.
|
|
def manifest
|
|
raise NotImplementedError, "No manifest for '#{spec.name}' generator."
|
|
end
|
|
|
|
# Return the full path from the source root for the given path.
|
|
# Example for source_root = '/source':
|
|
# source_path('some/path.rb') == '/source/some/path.rb'
|
|
#
|
|
# The given path may include a colon ':' character to indicate that
|
|
# the file belongs to another generator. This notation allows any
|
|
# generator to borrow files from another. Example:
|
|
# source_path('model:fixture.yml') = '/model/source/path/fixture.yml'
|
|
def source_path(relative_source)
|
|
# Check whether we're referring to another generator's file.
|
|
name, path = relative_source.split(':', 2)
|
|
|
|
# If not, return the full path to our source file.
|
|
if path.nil?
|
|
File.join(source_root, name)
|
|
|
|
# Otherwise, ask our referral for the file.
|
|
else
|
|
# FIXME: this is broken, though almost always true. Others'
|
|
# source_root are not necessarily the templates dir.
|
|
File.join(self.class.lookup(name).path, 'templates', path)
|
|
end
|
|
end
|
|
|
|
# Return the full path from the destination root for the given path.
|
|
# Example for destination_root = '/dest':
|
|
# destination_path('some/path.rb') == '/dest/some/path.rb'
|
|
def destination_path(relative_destination)
|
|
File.join(destination_root, relative_destination)
|
|
end
|
|
|
|
protected
|
|
# Convenience method for generator subclasses to record a manifest.
|
|
def record
|
|
Rails::Generator::Manifest.new(self) { |m| yield m }
|
|
end
|
|
|
|
# Override with your own usage banner.
|
|
def banner
|
|
"Usage: #{$0} #{spec.name} [options]"
|
|
end
|
|
|
|
# Read USAGE from file in generator base path.
|
|
def usage_message
|
|
File.read(File.join(spec.path, 'USAGE')) rescue ''
|
|
end
|
|
end
|
|
|
|
|
|
# The base generator for named components: models, controllers, mailers,
|
|
# etc. The target name is taken as the first argument and inflected to
|
|
# singular, plural, class, file, and table forms for your convenience.
|
|
# The remaining arguments are aliased to +actions+ as an array for
|
|
# controller and mailer convenience.
|
|
#
|
|
# Several useful local variables and methods are populated in the
|
|
# +initialize+ method. See below for a list of Attributes and
|
|
# External Aliases available to both the manifest and to all templates.
|
|
#
|
|
# If no name is provided, the generator raises a usage error with content
|
|
# optionally read from the USAGE file in the generator's base path.
|
|
#
|
|
# For example, the +controller+ generator takes the first argument as
|
|
# the name of the class and subsequent arguments as the names of
|
|
# actions to be generated:
|
|
#
|
|
# ./script/generate controller Article index new create
|
|
#
|
|
# See Rails::Generator::Base for a discussion of manifests,
|
|
# Rails::Generator::Commands::Create for methods available to the manifest,
|
|
# and Rails::Generator for a general discussion of generators.
|
|
class NamedBase < Base
|
|
attr_reader :name, :class_name, :singular_name, :plural_name, :table_name
|
|
attr_reader :class_path, :file_path, :class_nesting, :class_nesting_depth
|
|
alias_method :file_name, :singular_name
|
|
alias_method :actions, :args
|
|
|
|
def initialize(runtime_args, runtime_options = {})
|
|
super
|
|
|
|
# Name argument is required.
|
|
usage if runtime_args.empty?
|
|
|
|
@args = runtime_args.dup
|
|
base_name = @args.shift
|
|
assign_names!(base_name)
|
|
end
|
|
|
|
protected
|
|
# Override with your own usage banner.
|
|
def banner
|
|
"Usage: #{$0} #{spec.name} #{spec.name.camelize}Name [options]"
|
|
end
|
|
|
|
def attributes
|
|
@attributes ||= @args.collect do |attribute|
|
|
Rails::Generator::GeneratedAttribute.new(*attribute.split(":"))
|
|
end
|
|
end
|
|
|
|
|
|
private
|
|
def assign_names!(name)
|
|
@name = name
|
|
base_name, @class_path, @file_path, @class_nesting, @class_nesting_depth = extract_modules(@name)
|
|
@class_name_without_nesting, @singular_name, @plural_name = inflect_names(base_name)
|
|
@table_name = (!defined?(ActiveRecord::Base) || ActiveRecord::Base.pluralize_table_names) ? plural_name : singular_name
|
|
@table_name.gsub! '/', '_'
|
|
if @class_nesting.empty?
|
|
@class_name = @class_name_without_nesting
|
|
else
|
|
@table_name = @class_nesting.underscore << "_" << @table_name
|
|
@class_name = "#{@class_nesting}::#{@class_name_without_nesting}"
|
|
end
|
|
end
|
|
|
|
# Extract modules from filesystem-style or ruby-style path:
|
|
# good/fun/stuff
|
|
# Good::Fun::Stuff
|
|
# produce the same results.
|
|
def extract_modules(name)
|
|
modules = name.include?('/') ? name.split('/') : name.split('::')
|
|
name = modules.pop
|
|
path = modules.map { |m| m.underscore }
|
|
file_path = (path + [name.underscore]).join('/')
|
|
nesting = modules.map { |m| m.camelize }.join('::')
|
|
[name, path, file_path, nesting, modules.size]
|
|
end
|
|
|
|
def inflect_names(name)
|
|
camel = name.camelize
|
|
under = camel.underscore
|
|
plural = under.pluralize
|
|
[camel, under, plural]
|
|
end
|
|
end
|
|
end
|
|
end
|