rails 0.9.5 → 0.10.0

data/lib/dispatcher.rb

@@ -24,56 +24,34 @@
 require 'breakpoint'
 
 class Dispatcher
-  class <<self
+  class << self
     def dispatch(cgi = CGI.new, session_options = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS)
       begin
-        Breakpoint.activate_drb("druby://localhost:#{BREAKPOINT_SERVER_PORT}", nil, !defined?(FastCGI)) if defined?(BREAKPOINT_SERVER_PORT)
-
-        request  = ActionController::CgiRequest.new(cgi, session_options)
-        response = ActionController::CgiResponse.new(cgi)
-    
-        controller_name, module_name = controller_name(request.parameters), module_name(request.parameters)
-
-        require_or_load("application")
-        require_or_load(controller_path(controller_name, module_name))
-
-        controller_class(controller_name).process(request, response).out
+        request, response = ActionController::CgiRequest.new(cgi, session_options), ActionController::CgiResponse.new(cgi)
+        prepare_application
+        ActionController::Routing::Routes.recognize!(request).process(request, response).out
       rescue Object => exception
         ActionController::Base.process_with_exception(request, response, exception).out
       ensure
-        reset_application if Dependencies.load?
-        Breakpoint.deactivate_drb if defined?(BREAKPOINT_SERVER_PORT)
+        reset_application
       end
     end
     
     private
-      def reset_application
-        Dependencies.clear
-        Dependencies.remove_subclasses_for(ActiveRecord::Base, ActiveRecord::Observer, ActionController::Base)
+      def prepare_application
+        ActionController::Routing::Routes.reload if Dependencies.load?
+        Breakpoint.activate_drb("druby://localhost:#{BREAKPOINT_SERVER_PORT}", nil, !defined?(FastCGI)) if defined?(BREAKPOINT_SERVER_PORT)
+        Controllers.const_load!(:ApplicationController, "application") unless Controllers.const_defined?(:ApplicationController)
       end
     
-      def controller_path(controller_name, module_name = nil)
-        if module_name
-          "#{module_name}/#{controller_name.underscore}_controller"
-        else
-          "#{controller_name.underscore}_controller"
+      def reset_application
+        if Dependencies.load?
+          Controllers.clear!
+          Dependencies.clear
+          Dependencies.remove_subclasses_for(ActiveRecord::Base, ActiveRecord::Observer, ActionController::Base)
         end
-      end
-
-      def controller_class(controller_name)
-        Object.const_get(controller_class_name(controller_name))
-      end
-
-      def controller_class_name(controller_name)
-        "#{controller_name.camelize}Controller"
-      end
-
-      def controller_name(parameters)
-        parameters["controller"].downcase.gsub(/[^_a-zA-Z0-9]/, "").untaint
-      end
 
-      def module_name(parameters)
-        parameters["module"].downcase.gsub(/[^_a-zA-Z0-9]/, "").untaint if parameters["module"]
+        Breakpoint.deactivate_drb if defined?(BREAKPOINT_SERVER_PORT)
       end
   end
-end
+end

data/lib/rails_generator.rb

@@ -1,201 +1,42 @@
-require 'fileutils'
-
-module Rails
-  module Generator
-    class GeneratorError < StandardError; end
-    class UsageError < GeneratorError; end
-
-    CONTRIB_ROOT = "#{RAILS_ROOT}/script/generators"
-    BUILTIN_ROOT = "#{File.dirname(__FILE__)}/../generators"
-    DEFAULT_SEARCH_PATHS = [CONTRIB_ROOT, BUILTIN_ROOT]
-
-    class << self
-      def instance(name, args = [], search_paths = DEFAULT_SEARCH_PATHS)
-        # RAILS_ROOT constant must be set.
-        unless Object.const_get(:RAILS_ROOT)
-          raise GeneratorError, "RAILS_ROOT must be set.  Did you require 'config/environment'?"
-        end
-
-        # Force canonical name.
-        name = Inflector.underscore(name.downcase)
-
-        # Search for filesystem path to requested generator.
-        unless path = find_generator_path(name, search_paths)
-          raise GeneratorError, "#{name} generator not found."
-        end
-
-        # Check for templates directory.
-        template_root = "#{path}/templates"
-        unless File.directory?(template_root)
-          raise GeneratorError, "missing template directory #{template_root}"
-        end
-
-        # Require class file according to naming convention.
-        require "#{path}/#{name}_generator.rb"
-
-        # Find class according to naming convention.  Allow Nesting::In::Modules.
-        class_name = Inflector.classify("#{name}_generator")
-        unless klass = find_generator_class(name)
-          raise GeneratorError, "no #{class_name} class defined in #{path}/#{name}_generator.rb"
-        end
-
-        # Instantiate and return generator.
-        klass.new(template_root, RAILS_ROOT, search_paths, args)
-      end
-
-
-      def builtin_generators
-        generators([BUILTIN_ROOT])
-      end
-
-      def contrib_generators
-        generators([CONTRIB_ROOT])
-      end
-
-      def generators(search_paths)
-        generator_paths(search_paths).keys.uniq.sort
-      end
-
-      # Find all generator paths.
-      def generator_paths(search_paths)
-        @paths ||= {}
-        unless @paths[search_paths]
-          paths = Hash.new { |h,k| h[k] = [] }
-          search_paths.each do |path|
-            Dir["#{path}/[a-z]*"].each do |dir|
-              paths[File.basename(dir)] << dir if File.directory?(dir)
-            end
-          end
-          @paths[search_paths] = paths
-        end
-        @paths[search_paths]
-      end
-
-      def find_generator_path(name, search_paths)
-        generator_paths(search_paths)[name].first
-      end
-
-      # Find all generator classes.
-      def generator_classes
-        classes = Hash.new { |h,k| h[k] = [] }
-        class_re = /([^:]+)Generator$/
-        ObjectSpace.each_object(Class) do |object|
-          if md = class_re.match(object.name) and object < Rails::Generator::Base
-            classes[Inflector.underscore(md.captures.first)] << object
-          end
-        end
-        classes
-      end
-
-      def find_generator_class(name)
-        generator_classes[name].first
-      end
-    end
-
-
-    # Talk about generators.
-    class Base
-      attr_reader :template_root, :destination_root, :args, :options,
-                  :class_name, :singular_name, :plural_name
-
-      alias_method :file_name,  :singular_name
-      alias_method :table_name, :plural_name
-
-      def self.generator_name
-        Inflector.underscore(name.gsub('Generator', ''))
-      end
-
-      def initialize(template_root, destination_root, search_paths, args)
-        @template_root, @destination_root = template_root, destination_root
-        usage if args.empty?
-        @search_paths, @original_args = search_paths, args.dup
-        @class_name, @singular_name, @plural_name = inflect_names(args.shift)
-        @options = extract_options!(args)
-        @args = args
-      end
-
-      # Checks whether the class name that was assigned to this generator
-      # would cause a collision with a Class, Module or other constant
-      # that is already used up by Ruby or RubyOnRails.
-      def collision_with_builtin?
-        builtin = Object.const_get(full_class_name) rescue nil
-        type = case builtin
-          when Class: "Class"
-          when Module: "Module"
-          else "Constant"
-        end
-
-        if builtin then
-          "Sorry, you can't have a #{self.class.generator_name} named " +
-          "'#{full_class_name}' because Ruby or Rails already has a #{type} with that name.\n" + 
-          "Please rerun the generator with a different name."
-        end
-      end
-
-      # Returns the complete name that the resulting Class would have.
-      # Used in collision_with_builtin(). The default guess is that it is
-      # the same as class_name. Override this in your generator in case
-      # it is wrong.
-      def full_class_name
-        class_name
-      end
-
-      protected
-        # Look up another generator with the same arguments.
-        def generator(name)
-          Rails::Generator.instance(name, @original_args, @search_paths)
-        end
-
-        # Generate a file for a Rails application using an ERuby template.
-        # Looks up and evalutes a template by name and writes the result
-        # to a file relative to +destination_root+.  The template
-        # is evaluated in the context of the optional eval_binding argument.
-        #
-        # 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.
-        def template(template_name, destination_path, eval_binding = nil)
-          # Determine full paths for source and destination files.
-          template_path     = find_template_path(template_name)
-          destination_path  = File.join(destination_root, destination_path)
-
-          # Create destination directories.
-          FileUtils.mkdir_p(File.dirname(destination_path))
-
-          # Render template and write result.
-          eval_binding ||= binding
-          contents = ERB.new(File.read(template_path), nil, '-').result(eval_binding)
-          File.open(destination_path, 'w') { |file| file.write(contents) }
-        end
-
-        def usage
-          raise UsageError.new, File.read(usage_path)
-        end
-
-      private
-        def find_template_path(template_name)
-          name, path = template_name.split('/', 2)
-          if path.nil?
-            File.join(template_root, name)
-          elsif generator_path = Rails::Generator.find_generator_path(name, @search_paths)
-            File.join(generator_path, 'templates', path)
-          end
-        end
+#--
+# Copyright (c) 2004 Jeremy Kemper
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+$:.unshift(File.dirname(__FILE__))
+
+begin
+  require 'active_support'
+rescue LoadError
+  require 'rubygems'
+  require_gem 'activesupport'
+end
 
-        def inflect_names(name)
-          camel  = Inflector.camelize(Inflector.underscore(name))
-          under  = Inflector.underscore(camel)
-          plural = Inflector.pluralize(under)
-          [camel, under, plural]
-        end
+require 'rails_generator/base'
+require 'rails_generator/lookup'
+require 'rails_generator/commands'
 
-        def extract_options!(args)
-          if args.last.is_a?(Hash) then args.pop else {} end
-        end
+Rails::Generator::Base.send(:include, Rails::Generator::Lookup)
+Rails::Generator::Base.send(:include, Rails::Generator::Commands)
 
-        def usage_path
-          "#{template_root}/../USAGE"
-        end
-    end
-  end
-end
+# Set up a default logger for convenience.
+require 'rails_generator/simple_logger'
+Rails::Generator::Base.logger = Rails::Generator::SimpleLogger.new(STDOUT)

data/lib/rails_generator/base.rb

@@ -0,0 +1,203 @@
+require File.dirname(__FILE__) + '/options'
+require File.dirname(__FILE__) + '/manifest'
+require File.dirname(__FILE__) + '/spec'
+
+# 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 or
+# tarballs for inclusion system-wide, per-user, or per-application.
+#
+# Generators may subclass other generators to provide variations that
+# require little or no new logic but replace the template files.
+# The postback generator is an example:  it subclasses the scaffold
+# generator and just replaces the code templates with its own.
+#
+# Now go forth and multiply^Wgenerate.
+module Rails
+  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.
+    # You're probably looking for NamedBase, a subclass meant for generating
+    # "named" components such as models, controllers, and mailers.
+    #
+    # Generators create a manifest of the actions they perform then hand
+    # the manifest to a command which replay the actions to do the heavy
+    # lifting.  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 EliteGenerator < Rails::Generator::Base
+    #     def manifest
+    #       record do |m|
+    #         m.do(some)
+    #         m.things(in) { here }
+    #       end
+    #     end
+    #   end
+    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 for controller and
+    # mailer convenience.
+    #
+    # 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.
+    #
+    # See Rails::Generator::Base for a discussion of Manifests and Commands.
+    class NamedBase < Base
+      attr_reader   :name, :class_name, :singular_name, :plural_name
+      attr_reader   :class_path, :file_path, :class_nesting, :class_nesting_depth
+      alias_method  :file_name,  :singular_name
+      alias_method  :table_name, :plural_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
+
+      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)
+          if @class_nesting.empty?
+            @class_name = @class_name_without_nesting
+          else
+            @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