rails 1.2.6 → 2.0.0

data/lib/rails/plugin.rb

@@ -0,0 +1,84 @@
+module Rails
+
+  # The Plugin class should be an object which provides the following methods:
+  #
+  # * +name+       - used during initialisation to order the plugin (based on name and
+  #                  the contents of <tt>config.plugins</tt>)
+  # * +valid?+     - returns true if this plugin can be loaded
+  # * +load_paths+ - each path within the returned array will be added to the $LOAD_PATH
+  # * +load+       - finally 'load' the plugin.
+  #
+  # These methods are expected by the Rails::Plugin::Locator and Rails::Plugin::Loader classes.
+  # The default implementation returns the <tt>lib</tt> directory as its </tt>load_paths</tt>, 
+  # and evaluates <tt>init.rb</tt> when <tt>load</tt> is called.
+  class Plugin
+    include Comparable
+    
+    attr_reader :directory, :name
+    
+    def initialize(directory)
+      @directory = directory
+      @name = File.basename(@directory) rescue nil
+      @loaded = false
+    end
+    
+    def valid?
+      File.directory?(directory) && (has_lib_directory? || has_init_file?)
+    end
+  
+    # Returns a list of paths this plugin wishes to make available in $LOAD_PATH
+    def load_paths
+      report_nonexistant_or_empty_plugin! unless valid?
+      has_lib_directory? ? [lib_path] : []
+    end
+
+    # Evaluates a plugin's init.rb file
+    def load(initializer)
+      return if loaded?
+      report_nonexistant_or_empty_plugin! unless valid?
+      evaluate_init_rb(initializer)
+      @loaded = true
+    end
+    
+    def loaded?
+      @loaded
+    end
+    
+    def <=>(other_plugin)
+      name <=> other_plugin.name
+    end
+    
+    private
+
+      def report_nonexistant_or_empty_plugin!
+        raise LoadError, "Can not find the plugin named: #{name}"
+      end      
+    
+      def lib_path
+        File.join(directory, 'lib')
+      end
+
+      def init_path
+        File.join(directory, 'init.rb')
+      end
+
+      def has_lib_directory?
+        File.directory?(lib_path)
+      end
+
+      def has_init_file?
+        File.file?(init_path)
+      end
+
+      def evaluate_init_rb(initializer)
+         if has_init_file?
+           silence_warnings do
+             # Allow plugins to reference the current configuration object
+             config = initializer.configuration
+             
+             eval(IO.read(init_path), binding, init_path)
+           end
+         end
+      end               
+  end
+end

data/lib/rails/plugin/loader.rb

@@ -0,0 +1,150 @@
+require "rails/plugin"
+
+module Rails
+  class Plugin
+    class Loader
+      attr_reader :initializer
+
+      # Creates a new Plugin::Loader instance, associated with the given
+      # Rails::Initializer. This default implementation automatically locates
+      # all plugins, and adds all plugin load paths, when it is created. The plugins
+      # are then fully loaded (init.rb is evaluated) when load_plugins is called.
+      #
+      # It is the loader's responsibility to ensure that only the plugins specified
+      # in the configuration are actually loaded, and that the order defined
+      # is respected.
+      def initialize(initializer)
+        @initializer = initializer
+      end
+      
+      # Returns the plugins to be loaded, in the order they should be loaded.
+      def plugins
+        @plugins ||= all_plugins.select { |plugin| should_load?(plugin) }.sort { |p1, p2| order_plugins(p1, p2) }
+      end
+
+      # Returns all the plugins that could be found by the current locators.
+      def all_plugins
+        @all_plugins ||= locate_plugins
+        @all_plugins
+      end
+    
+      def load_plugins
+        plugins.each do |plugin| 
+          plugin.load(initializer)
+          register_plugin_as_loaded(plugin)
+        end
+        ensure_all_registered_plugins_are_loaded!
+      end
+      
+      # Adds the load paths for every plugin into the $LOAD_PATH. Plugin load paths are
+      # added *after* the application's <tt>lib</tt> directory, to ensure that an application
+      # can always override code within a plugin.
+      #
+      # Plugin load paths are also added to Dependencies.load_paths, and Dependencies.load_once_paths.  
+      def add_plugin_load_paths
+        plugins.each do |plugin|
+          plugin.load_paths.each do |path|
+            $LOAD_PATH.insert(application_lib_index + 1, path)
+            Dependencies.load_paths      << path
+            Dependencies.load_once_paths << path
+          end
+        end
+        $LOAD_PATH.uniq!
+      end      
+      
+      protected
+      
+        # The locate_plugins method uses each class in config.plugin_locators to
+        # find the set of all plugins available to this Rails application.
+        def locate_plugins
+          configuration.plugin_locators.map { |locator|
+            locator.new(initializer).plugins
+          }.flatten
+          # TODO: sorting based on config.plugins
+        end
+
+        def register_plugin_as_loaded(plugin)
+          initializer.loaded_plugins << plugin
+        end
+
+        def configuration
+          initializer.configuration
+        end
+        
+        def should_load?(plugin)
+          # uses Plugin#name and Plugin#valid?
+          enabled?(plugin) && plugin.valid?
+        end
+
+        def order_plugins(plugin_a, plugin_b)
+          if !explicit_plugin_loading_order?
+            plugin_a <=> plugin_b
+          else
+            if !explicitly_enabled?(plugin_a) && !explicitly_enabled?(plugin_b)
+              plugin_a <=> plugin_b
+            else
+              effective_order_of(plugin_a) <=> effective_order_of(plugin_b)
+            end            
+          end
+        end
+        
+        def effective_order_of(plugin)
+          if explicitly_enabled?(plugin)
+            registered_plugin_names.index(plugin.name) 
+          else
+            registered_plugin_names.index('all')
+          end        
+        end
+
+        def application_lib_index
+          $LOAD_PATH.index(File.join(RAILS_ROOT, 'lib')) || 0
+        end      
+
+        def enabled?(plugin)
+          !explicit_plugin_loading_order? || registered?(plugin)
+        end
+
+        def explicit_plugin_loading_order?
+          !registered_plugin_names.nil?
+        end
+
+        def registered?(plugin)
+          explicit_plugin_loading_order? && registered_plugins_names_plugin?(plugin)
+        end
+
+        def explicitly_enabled?(plugin)
+          !explicit_plugin_loading_order? || explicitly_registered?(plugin)
+        end
+
+        def explicitly_registered?(plugin)
+          explicit_plugin_loading_order? && registered_plugin_names.include?(plugin.name)
+        end
+      
+        def registered_plugins_names_plugin?(plugin)
+          registered_plugin_names.include?(plugin.name) || registered_plugin_names.include?('all')
+        end
+        
+        # The plugins that have been explicitly listed with config.plugins. If this list is nil
+        # then it means the client does not care which plugins or in what order they are loaded, 
+        # so we load all in alphabetical order. If it is an empty array, we load no plugins, if it is
+        # non empty, we load the named plugins in the order specified.
+        def registered_plugin_names
+          configuration.plugins ? configuration.plugins.map(&:to_s) : nil
+        end
+        
+        def loaded?(plugin_name)
+          initializer.loaded_plugins.detect { |plugin| plugin.name == plugin_name.to_s }
+        end
+        
+        def ensure_all_registered_plugins_are_loaded!
+          if explicit_plugin_loading_order?
+            if configuration.plugins.detect {|plugin| plugin != :all && !loaded?(plugin) }
+              missing_plugins = configuration.plugins - (plugins + [:all])
+              raise LoadError, "Could not locate the following plugins: #{missing_plugins.to_sentence}"
+            end
+          end
+        end
+  
+    end
+  end
+end

data/lib/rails/plugin/locator.rb

@@ -0,0 +1,78 @@
+module Rails
+  class Plugin
+    
+    # The Plugin::Locator class should be subclasses to provide custom plugin-finding
+    # abilities to Rails (i.e. loading plugins from Gems, etc). Each subclass should implement
+    # the <tt>located_plugins</tt> method, which return an array of Plugin objects that have been found.
+    class Locator
+      include Enumerable
+      
+      attr_reader :initializer
+      
+      def initialize(initializer)
+        @initializer = initializer
+      end
+      
+      # This method should return all the plugins which this Plugin::Locator can find
+      # These will then be used by the current Plugin::Loader, which is responsible for actually
+      # loading the plugins themselves
+      def plugins
+        raise "The `plugins' method must be defined by concrete subclasses of #{self.class}"
+      end
+      
+      def each(&block)
+        plugins.each(&block)
+      end
+      
+      def plugin_names
+        plugins.map(&:name)
+      end
+    end
+    
+    # The Rails::Plugin::FileSystemLocator will try to locate plugins by examining the directories
+    # the the paths given in configuration.plugin_paths. Any plugins that can be found are returned
+    # in a list. 
+    #
+    # The criteria for a valid plugin in this case is found in Rails::Plugin#valid?, although
+    # other subclasses of Rails::Plugin::Locator can of course use different conditions.
+    class FileSystemLocator < Locator
+      
+      # Returns all the plugins which can be loaded in the filesystem, under the paths given
+      # by configuration.plugin_paths.
+      def plugins
+        initializer.configuration.plugin_paths.flatten.inject([]) do |plugins, path|
+          plugins.concat locate_plugins_under(path)
+          plugins
+        end.flatten
+      end
+          
+      private
+      
+        # Attempts to create a plugin from the given path. If the created plugin is valid?
+        # (see Rails::Plugin#valid?) then the plugin instance is returned; otherwise nil.
+        def create_plugin(path)
+          plugin = Rails::Plugin.new(path)
+          plugin.valid? ? plugin : nil
+        end
+
+        # This starts at the base path looking for valid plugins (see Rails::Plugin#valid?).
+        # Since plugins can be nested arbitrarily deep within an unspecified number of intermediary 
+        # directories, this method runs recursively until it finds a plugin directory, e.g.
+        #
+        #     locate_plugins_under('vendor/plugins/acts/acts_as_chunky_bacon')
+        #     => <Rails::Plugin name: 'acts_as_chunky_bacon' ... >
+        #
+        def locate_plugins_under(base_path)
+           Dir.glob(File.join(base_path, '*')).inject([]) do |plugins, path|
+            if plugin = create_plugin(path)
+              plugins << plugin
+            elsif File.directory?(path)
+              plugins.concat locate_plugins_under(path)
+            end
+            plugins
+          end
+        end
+        
+    end
+  end
+end

data/lib/rails/version.rb

@@ -1,8 +1,8 @@
 module Rails
   module VERSION #:nodoc:
-    MAJOR = 1
-    MINOR = 2
-    TINY  = 6
+    MAJOR = 2
+    MINOR = 0
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/rails_generator/base.rb

@@ -26,13 +26,14 @@ module Rails
   # +controller+ generator:
   #   
   #   generators/
-  #     controller/
-  #       controller_generator.rb
-  #       templates/
-  #         controller.rb
-  #         functional_test.rb
-  #         helper.rb
-  #         view.rhtml
+  #     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
@@ -40,7 +41,7 @@ module Rails
   # directory.
   #
   # The filenames of the templates don't matter, but choose something that
-  # will be self-explatatory since you will be referencing these in the 
+  # will be self-explanatory since you will be referencing these in the 
   # +manifest+ method inside your generator subclass.
   #
   # 
@@ -228,7 +229,8 @@ module Rails
           @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 = ActiveRecord::Base.pluralize_table_names ? plural_name : singular_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

data/lib/rails_generator/commands.rb

@@ -70,7 +70,7 @@ module Rails
           end
 
           def current_migration_number
-            Dir.glob("#{@migration_directory}/[0-9]*.rb").inject(0) do |max, file_path|
+            Dir.glob("#{RAILS_ROOT}/#{@migration_directory}/[0-9]*_*.rb").inject(0) do |max, file_path|
               n = File.basename(file_path).split('_', 2).first.to_i
               if n > max then n else max end
             end
@@ -93,9 +93,9 @@ module Rails
         private
           # Ask the user interactively whether to force collision.
           def force_file_collision?(destination, src, dst, file_options = {}, &block)
-            $stdout.print "overwrite #{destination}? [Ynaqd] "
-            case $stdin.gets
-              when /d/i
+            $stdout.print "overwrite #{destination}? (enter \"h\" for help) [Ynaqdh] "
+            case $stdin.gets.chomp
+              when /\Ad\z/i
                 Tempfile.open(File.basename(destination), File.dirname(dst)) do |temp|
                   temp.write render_file(src, file_options, &block)
                   temp.rewind
@@ -103,14 +103,24 @@ module Rails
                 end
                 puts "retrying"
                 raise 'retry diff'
-              when /a/i
+              when /\Aa\z/i
                 $stdout.puts "forcing #{spec.name}"
                 options[:collision] = :force
-              when /q/i
+              when /\Aq\z/i
                 $stdout.puts "aborting #{spec.name}"
                 raise SystemExit
-              when /n/i then :skip
-              else :force
+              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'
             end
           rescue
             retry
@@ -260,7 +270,7 @@ module Rails
         end
 
         # Generate a file for a Rails application using an ERuby template.
-        # Looks up and evalutes a template by name and writes the result.
+        # Looks up and evaluates a template by name and writes the result.
         #
         # The ERB template uses explicit trim mode to best control the
         # proliferation of whitespace in generated code.  <%- trims leading
@@ -559,7 +569,7 @@ end_message
              return
            end
 
-           logger.refreshing "#{template_options[:insert].gsub(/\.rhtml/,'')} inside #{relative_destination}"
+           logger.refreshing "#{template_options[:insert].gsub(/\.erb/,'')} inside #{relative_destination}"
 
            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]))

data/lib/rails_generator/generators/applications/app/USAGE

@@ -7,10 +7,3 @@ Example:
 
     This generates a skeletal Rails installation in ~/Code/Ruby/weblog.
     See the README in the newly created application to get going.
-
-WARNING:
-    Only specify --without-gems if you did not use gems to install Rails.
-    Your application will expect to find activerecord, actionpack, and
-    actionmailer directories in the vendor directory.  A popular way to track
-    the bleeding edge of Rails development is to checkout from source control
-    directly to the vendor directory.  See http://dev.rubyonrails.com

data/lib/rails_generator/generators/applications/app/app_generator.rb

@@ -1,4 +1,6 @@
 require 'rbconfig'
+require 'digest/md5' 
+require 'rails_generator/secret_key_generator'
 
 class AppGenerator < Rails::Generator::Base
   DEFAULT_SHEBANG = File.join(Config::CONFIG['bindir'],
@@ -6,7 +8,8 @@ class AppGenerator < Rails::Generator::Base
 
   DATABASES = %w(mysql oracle postgresql sqlite2 sqlite3 frontbase)
 
-  default_options   :db => "mysql", :shebang => DEFAULT_SHEBANG, :freeze => false
+  default_options   :db => (ENV["RAILS_DEFAULT_DATABASE"] || "mysql"),
+    :shebang => DEFAULT_SHEBANG, :freeze => false
   mandatory_options :source => "#{File.dirname(__FILE__)}/../../../../.."
 
   def initialize(runtime_args, runtime_options = {})
@@ -22,6 +25,18 @@ class AppGenerator < Rails::Generator::Base
     script_options     = { :chmod => 0755, :shebang => options[:shebang] == DEFAULT_SHEBANG ? nil : options[:shebang] }
     dispatcher_options = { :chmod => 0755, :shebang => options[:shebang] }
 
+    # duplicate CGI::Session#generate_unique_id
+    md5 = Digest::MD5.new
+    now = Time.now
+    md5 << now.to_s
+    md5 << String(now.usec)
+    md5 << String(rand(0))
+    md5 << String($$)
+    md5 << @app_name
+
+    # Do our best to generate a secure secret key for CookieStore
+    secret = Rails::SecretKeyGenerator.new(@app_name).generate_secret
+
     record do |m|
       # Root directory and all subdirectories.
       m.directory ''
@@ -32,7 +47,7 @@ class AppGenerator < Rails::Generator::Base
       m.file "README",         "README"
 
       # Application
-      m.template "helpers/application.rb",        "app/controllers/application.rb", :assigns => { :app_name => @app_name }
+      m.template "helpers/application.rb",        "app/controllers/application.rb", :assigns => { :app_name => @app_name, :app_secret => md5.hexdigest }
       m.template "helpers/application_helper.rb", "app/helpers/application_helper.rb"
       m.template "helpers/test_helper.rb",        "test/test_helper.rb"
 
@@ -44,15 +59,19 @@ class AppGenerator < Rails::Generator::Base
       m.template "configs/routes.rb",     "config/routes.rb"
       m.template "configs/apache.conf",   "public/.htaccess"
 
+      # Initializers
+      m.template "configs/initializers/inflections.rb", "config/initializers/inflections.rb"
+      m.template "configs/initializers/mime_types.rb",  "config/initializers/mime_types.rb"
+
       # Environments
       m.file "environments/boot.rb",    "config/boot.rb"
-      m.template "environments/environment.rb", "config/environment.rb", :assigns => { :freeze => options[:freeze] }
+      m.template "environments/environment.rb", "config/environment.rb", :assigns => { :freeze => options[:freeze], :app_name => @app_name, :app_secret => secret }
       m.file "environments/production.rb",  "config/environments/production.rb"
       m.file "environments/development.rb", "config/environments/development.rb"
       m.file "environments/test.rb",        "config/environments/test.rb"
 
       # Scripts
-      %w( about breakpointer console destroy generate performance/benchmarker performance/profiler process/reaper process/spawner process/inspector runner server plugin ).each do |file|
+      %w( about console destroy generate performance/benchmarker performance/profiler performance/request process/reaper process/spawner process/inspector runner server plugin ).each do |file|
         m.file "bin/#{file}", "script/#{file}", script_options
       end
 
@@ -62,7 +81,7 @@ class AppGenerator < Rails::Generator::Base
       m.file "dispatches/dispatch.fcgi", "public/dispatch.fcgi", dispatcher_options
 
       # HTML files
-      %w(404 500 index).each do |file|
+      %w(404 422 500 index).each do |file|
         m.template "html/#{file}.html", "public/#{file}.html"
       end
 
@@ -121,7 +140,7 @@ class AppGenerator < Rails::Generator::Base
     app/models
     app/views/layouts
     config/environments
-    components
+    config/initializers
     db
     doc
     lib