rails 1.0.0 → 2.0.0

data/lib/rails_generator/generators/components/scaffold/templates/view_show.html.erb

@@ -0,0 +1,10 @@
+<% for attribute in attributes -%>
+<p>
+  <b><%= attribute.column.human_name %>:</b>
+  <%%=h @<%= singular_name %>.<%= attribute.name %> %>
+</p>
+
+<% end -%>
+
+<%%= link_to 'Edit', edit_<%= singular_name %>_path(@<%= singular_name %>) %> |
+<%%= link_to 'Back', <%= plural_name %>_path %>

data/lib/rails_generator/generators/components/session_migration/USAGE

@@ -1,15 +1,10 @@
 Description:
-    The session table migration generator creates a migration for adding a session table 
-    used by CGI::Session::ActiveRecordStore.
-
-    The generator takes a migration name as its argument.  The migration name may be
-    given in CamelCase or under_score.
-
-    The generator creates a migration class in db/migrate prefixed by its number
-    in the queue.
+    Creates a migration to add the sessions table used by the Active Record
+    session store. Pass the migration name, either CamelCased or under_scored,
+    as an argument.
 
 Example:
-    ./script/generate session_migration AddSessionTable
+    `./script/generate session_migration CreateSessionTable`
 
-    With 4 existing migrations, this will create an AddSessionTable migration in the
-    file db/migrate/5_add_session_table.rb
+    With 4 existing migrations, this creates the AddSessionTable migration
+    in db/migrate/005_add_session_table.rb

data/lib/rails_generator/generators/components/session_migration/session_migration_generator.rb

@@ -6,7 +6,13 @@ class SessionMigrationGenerator < Rails::Generator::NamedBase
 
   def manifest
     record do |m|
-      m.migration_template 'migration.rb', 'db/migrate'
+      m.migration_template 'migration.rb', 'db/migrate',
+        :assigns => { :session_table_name => default_session_table_name }
     end
   end
+
+  protected
+    def default_session_table_name
+      ActiveRecord::Base.pluralize_table_names ? 'session'.pluralize : 'session'
+    end
 end

data/lib/rails_generator/generators/components/session_migration/templates/migration.rb

@@ -1,15 +1,16 @@
 class <%= class_name %> < ActiveRecord::Migration
   def self.up
-    create_table :sessions do |t|
-      t.column :session_id, :string
-      t.column :data, :text
-      t.column :updated_at, :datetime
+    create_table :<%= session_table_name %> do |t|
+      t.string :session_id, :null => false
+      t.text :data
+      t.timestamps
     end
-    
-    add_index :sessions, :session_id
+
+    add_index :<%= session_table_name %>, :session_id
+    add_index :<%= session_table_name %>, :updated_at
   end
 
   def self.down
-    drop_table :sessions
+    drop_table :<%= session_table_name %>
   end
 end

data/lib/rails_generator/lookup.rb

@@ -46,10 +46,9 @@ module Rails
     #
     # A spec is not a generator:  it's a description of where to find
     # the generator and how to create it.  A source is anything that
-    # yields generators from #each.  PathSource and GemSource are provided.
+    # yields generators from #each.  PathSource and GemGeneratorSource are provided.
     module Lookup
-      def self.append_features(base)
-        super
+      def self.included(base)
         base.extend(ClassMethods)
         base.use_component_sources!
       end
@@ -93,18 +92,26 @@ module Rails
         # 1.  Rails application.  If RAILS_ROOT is defined we know we're
         #     generating in the context of a Rails application, so search
         #     RAILS_ROOT/generators.
-        # 2.  User home directory.  Search ~/.rails/generators.
-        # 3.  RubyGems.  Search for gems named *_generator.
-        # 4.  Builtins.  Model, controller, mailer, scaffold.
+        # 2.  Look in plugins, either for generators/ or rails_generators/ 
+        #     directories within each plugin
+        # 3.  User home directory.  Search ~/.rails/generators.
+        # 4.  RubyGems.  Search for gems named *_generator, and look for 
+        #     generators within any RubyGem's 
+        #     /rails_generators/<generator_name>_generator.rb file.
+        # 5.  Builtins.  Model, controller, mailer, scaffold, and so on.
         def use_component_sources!
           reset_sources
           if defined? ::RAILS_ROOT
             sources << PathSource.new(:lib, "#{::RAILS_ROOT}/lib/generators")
             sources << PathSource.new(:vendor, "#{::RAILS_ROOT}/vendor/generators")
-            sources << PathSource.new(:plugins, "#{::RAILS_ROOT}/vendor/plugins/**/generators")
+            sources << PathSource.new(:plugins, "#{::RAILS_ROOT}/vendor/plugins/*/**/generators")
+            sources << PathSource.new(:plugins, "#{::RAILS_ROOT}/vendor/plugins/*/**/rails_generators")
           end
           sources << PathSource.new(:user, "#{Dir.user_home}/.rails/generators")
-          sources << GemSource.new if Object.const_defined?(:Gem)
+          if Object.const_defined?(:Gem)
+            sources << GemGeneratorSource.new
+            sources << GemPathSource.new
+          end
           sources << PathSource.new(:builtin, "#{File.dirname(__FILE__)}/generators/components")
         end
 
@@ -186,14 +193,15 @@ module Rails
       end
     end
 
-
-    # GemSource hits the mines to quarry for generators.  The latest versions
-    # of gems named *_generator are selected.
-    class GemSource < Source
+    class AbstractGemSource < Source
       def initialize
         super :RubyGems
       end
+    end
 
+    # GemGeneratorSource hits the mines to quarry for generators.  The latest versions
+    # of gems named *_generator are selected.
+    class GemGeneratorSource < AbstractGemSource
       # Yield latest versions of generator gems.
       def each
         Gem::cache.search(/_generator$/).inject({}) { |latest, gem|
@@ -206,5 +214,31 @@ module Rails
       end
     end
 
+    # GemPathSource looks for generators within any RubyGem's /rails_generators/<generator_name>_generator.rb file.
+    class GemPathSource < AbstractGemSource
+      # Yield each generator within rails_generator subdirectories.
+      def each
+        generator_full_paths.each do |generator|
+          yield Spec.new(File.basename(generator).sub(/_generator.rb$/, ''), File.dirname(generator), label)
+        end
+      end
+
+      private
+        def generator_full_paths
+          @generator_full_paths ||=
+            Gem::cache.inject({}) do |latest, name_gem|
+              name, gem = name_gem
+              hem = latest[gem.name]
+              latest[gem.name] = gem if hem.nil? or gem.version > hem.version
+              latest
+            end.values.inject([]) do |mem, gem|
+              Dir[gem.full_gem_path + '/{rails_,}generators/**/*_generator.rb'].each do |generator|
+                mem << generator
+              end
+              mem
+            end
+        end
+    end
+
   end
 end

data/lib/rails_generator/options.rb

@@ -3,8 +3,7 @@ require 'optparse'
 module Rails
   module Generator
     module Options
-      def self.append_features(base)
-        super
+      def self.included(base)
         base.extend(ClassMethods)
         class << base
           if respond_to?(:inherited)
@@ -96,8 +95,8 @@ module Rails
 
         # Raise a usage error.  Override usage_message to provide a blurb
         # after the option parser summary.
-        def usage
-          raise UsageError, "#{@option_parser}\n#{usage_message}"
+        def usage(message = usage_message)
+          raise UsageError, "#{@option_parser}\n#{message}"
         end
 
         def usage_message
@@ -118,15 +117,19 @@ module Rails
 
         # Adds general options like -h and --quiet.  Usually don't override.
         def add_general_options!(opt)
+          opt.separator ''
+          opt.separator 'Rails Info:'
+          opt.on('-v', '--version', 'Show the Rails version number and quit.')
+          opt.on('-h', '--help', 'Show this help message and quit.') { |v| options[:help] = v }
+
           opt.separator ''
           opt.separator 'General Options:'
 
-          opt.on('-p', '--pretend', 'Run but do not make any changes.') { |options[:pretend]| }
+          opt.on('-p', '--pretend', 'Run but do not make any changes.') { |v| options[:pretend] = v }
           opt.on('-f', '--force', 'Overwrite files that already exist.') { options[:collision] = :force }
           opt.on('-s', '--skip', 'Skip files that already exist.') { options[:collision] = :skip }
-          opt.on('-q', '--quiet', 'Suppress normal output.') { |options[:quiet]| }
-          opt.on('-t', '--backtrace', 'Debugging: show backtrace on errors.') { |options[:backtrace]| }
-          opt.on('-h', '--help', 'Show this help message.') { |options[:help]| }
+          opt.on('-q', '--quiet', 'Suppress normal output.') { |v| options[:quiet] = v }
+          opt.on('-t', '--backtrace', 'Debugging: show backtrace on errors.') { |v| options[:backtrace] = v }
           opt.on('-c', '--svn', 'Modify files with subversion. (Note: svn must be in path)') do
             options[:svn] = `svn status`.inject({}) do |opt, e|
               opt[e.chomp[7..-1]] = true

data/lib/rails_generator/scripts/destroy.rb

@@ -3,5 +3,28 @@ require File.dirname(__FILE__) + '/../scripts'
 module Rails::Generator::Scripts
   class Destroy < Base
     mandatory_options :command => :destroy
+    
+    protected
+    def usage_message
+      usage = "\nInstalled Generators\n"
+      Rails::Generator::Base.sources.each do |source|
+        label = source.label.to_s.capitalize
+        names = source.names
+        usage << "  #{label}: #{names.join(', ')}\n" unless names.empty?
+      end
+
+      usage << <<end_blurb
+
+This script will destroy all files created by the corresponding 
+script/generate command. For instance, script/destroy migration CreatePost
+will delete the appropriate ###_create_post.rb file in db/migrate, while 
+script/destroy scaffold Post will delete the posts controller and 
+views, post model and migration, all associated tests, and the map.resources
+:posts line in config/routes.rb.
+      
+For instructions on finding new generators, run script/generate
+end_blurb
+      return usage
+    end
   end
 end

data/lib/rails_generator/scripts.rb

@@ -38,14 +38,17 @@ module Rails
         protected
           # Override with your own script usage banner.
           def banner
-            "Usage: #{$0} [options] generator [args]"
+            "Usage: #{$0} generator [options] [args]"
           end
 
           def usage_message
             usage = "\nInstalled Generators\n"
-            Rails::Generator::Base.sources.each do |source|
+            Rails::Generator::Base.sources.inject({}) do |mem, source|
               label = source.label.to_s.capitalize
-              names = source.names
+              mem[label] ||= []
+              mem[label] |= source.names
+              mem
+            end.each_pair do |label, names|
               usage << "  #{label}: #{names.join(', ')}\n" unless names.empty?
             end
 
@@ -59,7 +62,7 @@ end_blurb
 
             if Object.const_defined?(:RAILS_ROOT)
               usage << <<end_blurb
-     or to #{File.expand_path(RAILS_ROOT)}/generators/login
+     or to #{File.expand_path(RAILS_ROOT)}/lib/generators/login
      to use with this app only.
 end_blurb
             end

data/lib/rails_generator/secret_key_generator.rb

@@ -0,0 +1,160 @@
+# A class for creating random secret keys. This class will do its best to create a
+# random secret key that's as secure as possible, using whatever methods are
+# available on the current platform. For example:
+#
+#   generator = Rails::SecretKeyGenerator("some unique identifier, such as the application name")
+#   generator.generate_secret     # => "f3f1be90053fa851... (some long string)"
+
+module Rails
+  class SecretKeyGenerator
+    GENERATORS = [ :secure_random, :win32_api, :urandom, :openssl, :prng ].freeze
+
+    def initialize(identifier)
+      @identifier = identifier
+    end
+
+    # Generate a random secret key with the best possible method available on
+    # the current platform.
+    def generate_secret
+      generator = GENERATORS.find do |g|
+        self.class.send("supports_#{g}?")
+      end
+      send("generate_secret_with_#{generator}")
+    end
+
+    # Generate a random secret key by using the Win32 API. Raises LoadError
+    # if the current platform cannot make use of the Win32 API. Raises
+    # SystemCallError if some other error occured.
+    def generate_secret_with_win32_api
+      # Following code is based on David Garamond's GUID library for Ruby.
+      require 'Win32API'
+
+      crypt_acquire_context = Win32API.new("advapi32", "CryptAcquireContext",
+                                           'PPPII', 'L')
+      crypt_gen_random = Win32API.new("advapi32", "CryptGenRandom",
+                                      'LIP', 'L')
+      crypt_release_context = Win32API.new("advapi32", "CryptReleaseContext",
+                                         'LI', 'L')
+      prov_rsa_full       = 1
+      crypt_verifycontext = 0xF0000000
+
+      hProvStr = " " * 4
+      if crypt_acquire_context.call(hProvStr, nil, nil, prov_rsa_full,
+                                    crypt_verifycontext) == 0
+        raise SystemCallError, "CryptAcquireContext failed: #{lastWin32ErrorMessage}"
+      end
+      hProv, = hProvStr.unpack('L')
+      bytes = " " * 64
+      if crypt_gen_random.call(hProv, bytes.size, bytes) == 0
+        raise SystemCallError, "CryptGenRandom failed: #{lastWin32ErrorMessage}"
+      end
+      if crypt_release_context.call(hProv, 0) == 0
+        raise SystemCallError, "CryptReleaseContext failed: #{lastWin32ErrorMessage}"
+      end
+      bytes.unpack("H*")[0]
+    end
+
+    # Generate a random secret key with Ruby 1.9's SecureRandom module.
+    # Raises LoadError if the current Ruby version does not support
+    # SecureRandom.
+    def generate_secret_with_secure_random
+      require 'securerandom'
+      return SecureRandom.hex(64)
+    end
+
+    # Generate a random secret key with OpenSSL. If OpenSSL is not
+    # already loaded, then this method will attempt to load it.
+    # LoadError will be raised if that fails.
+    def generate_secret_with_openssl
+      require 'openssl'
+      if !File.exist?("/dev/urandom")
+        # OpenSSL transparently seeds the random number generator with
+        # data from /dev/urandom. On platforms where that is not
+        # available, such as Windows, we have to provide OpenSSL with
+        # our own seed. Unfortunately there's no way to provide a
+        # secure seed without OS support, so we'll have to do with
+        # rand() and Time.now.usec().
+        OpenSSL::Random.seed(rand(0).to_s + Time.now.usec.to_s)
+      end
+      data = OpenSSL::BN.rand(2048, -1, false).to_s
+      return OpenSSL::Digest::SHA512.new(data).hexdigest
+    end
+
+    # Generate a random secret key with /dev/urandom.
+    # Raises SystemCallError on failure.
+    def generate_secret_with_urandom
+      return File.read("/dev/urandom", 64).unpack("H*")[0]
+    end
+
+    # Generate a random secret key with Ruby's pseudo random number generator,
+    # as well as some environment information.
+    #
+    # This is the least cryptographically secure way to generate a secret key,
+    # and should be avoided whenever possible.
+    def generate_secret_with_prng
+      require 'digest/sha2'
+      sha = Digest::SHA2.new(512)
+      now = Time.now
+      sha << now.to_s
+      sha << String(now.usec)
+      sha << String(rand(0))
+      sha << String($$)
+      sha << @identifier
+      return sha.hexdigest
+    end
+
+    private
+      def lastWin32ErrorMessage
+        # Following code is based on David Garamond's GUID library for Ruby.
+        get_last_error = Win32API.new("kernel32", "GetLastError", '', 'L')
+        format_message = Win32API.new("kernel32", "FormatMessageA",
+                                      'LPLLPLPPPPPPPP', 'L')
+        format_message_ignore_inserts  = 0x00000200
+        format_message_from_system     = 0x00001000
+
+        code = get_last_error.call
+        msg = "\0" * 1024
+        len = format_message.call(format_message_ignore_inserts +
+                                  format_message_from_system, 0,
+                                  code, 0, msg, 1024, nil, nil,
+                                  nil, nil, nil, nil, nil, nil)
+        msg[0, len].tr("\r", '').chomp
+      end
+
+      def self.supports_secure_random?
+        begin
+          require 'securerandom'
+          true
+        rescue LoadError
+          false
+        end
+      end
+
+      def self.supports_win32_api?
+        return false unless RUBY_PLATFORM =~ /(:?mswin|mingw)/
+        begin
+          require 'Win32API'
+          true
+        rescue LoadError
+          false
+        end
+      end
+
+      def self.supports_urandom?
+        File.exists?('/dev/urandom')
+      end
+
+      def self.supports_openssl?
+        begin
+          require 'openssl'
+          true
+        rescue LoadError
+          false
+        end
+      end
+
+      def self.supports_prng?
+        true
+      end
+  end
+end

data/lib/rails_generator/spec.rb

@@ -2,7 +2,7 @@ module Rails
   module Generator
     # A spec knows where a generator was found and how to instantiate it.
     # Metadata include the generator's name, its base path, and the source
-    # which yielded it (PathSource, GemSource, etc.)
+    # which yielded it (PathSource, GemPathSource, etc.)
     class Spec
       attr_reader :name, :path, :source
 

data/lib/rails_generator.rb

@@ -28,7 +28,7 @@ begin
   require 'active_support'  
 rescue LoadError
   require 'rubygems'
-  require_gem 'activesupport'
+  gem 'activesupport'
 end
 
 require 'rails_generator/base'

data/lib/railties_path.rb

@@ -1 +1 @@
-RAILTIES_PATH = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+RAILTIES_PATH = File.join(File.dirname(__FILE__), '..')

data/lib/ruby_version_check.rb

@@ -0,0 +1,17 @@
+min_release  = "1.8.2 (2004-12-25)"
+ruby_release = "#{RUBY_VERSION} (#{RUBY_RELEASE_DATE})"
+if ruby_release =~ /1\.8\.3/
+  abort <<-end_message
+
+    Rails does not work with Ruby version 1.8.3.
+    Please upgrade to version 1.8.4 or downgrade to 1.8.2.
+
+  end_message
+elsif ruby_release < min_release
+  abort <<-end_message
+
+    Rails requires Ruby version #{min_release} or later.
+    You're running #{ruby_release}; please upgrade to continue.
+
+  end_message
+end

data/lib/source_annotation_extractor.rb

@@ -0,0 +1,62 @@
+class SourceAnnotationExtractor
+  class Annotation < Struct.new(:line, :tag, :text)
+    def to_s(options={})
+      s = "[%3d] " % line
+      s << "[#{tag}] " if options[:tag]
+      s << text
+    end
+  end
+
+  def self.enumerate(tag, options={})
+    extractor = new(tag)
+    extractor.display(extractor.find, options)
+  end
+
+  attr_reader :tag
+
+  def initialize(tag)
+    @tag = tag
+  end
+
+  def find(dirs=%w(app lib test))
+    dirs.inject({}) { |h, dir| h.update(find_in(dir)) }
+  end
+
+  def find_in(dir)
+    results = {}
+
+    Dir.glob("#{dir}/*") do |item|
+      next if File.basename(item)[0] == ?.
+
+      if File.directory?(item)
+        results.update(find_in(item))
+      elsif item =~ /\.(builder|(r(?:b|xml|js)))$/
+        results.update(extract_annotations_from(item, /#\s*(#{tag}):?\s*(.*)$/))
+      elsif item =~ /\.(rhtml|erb)$/
+        results.update(extract_annotations_from(item, /<%\s*#\s*(#{tag}):?\s*(.*?)\s*%>/))
+      end
+    end
+
+    results
+  end
+
+  def extract_annotations_from(file, pattern)
+    lineno = 0
+    result = File.readlines(file).inject([]) do |list, line|
+      lineno += 1
+      next list unless line =~ pattern
+      list << Annotation.new(lineno, $1, $2)
+    end
+    result.empty? ? {} : { file => result }
+  end
+
+  def display(results, options={})
+    results.keys.sort.each do |file|
+      puts "#{file}:"
+      results[file].each do |note|
+        puts "  * #{note.to_s(options)}"
+      end
+      puts
+    end
+  end
+end

data/lib/tasks/annotations.rake

@@ -0,0 +1,23 @@
+require 'source_annotation_extractor'
+
+desc "Enumerate all annotations"
+task :notes do
+  SourceAnnotationExtractor.enumerate "OPTIMIZE|FIXME|TODO", :tag => true
+end
+
+namespace :notes do
+  desc "Enumerate all OPTIMIZE annotations"
+  task :optimize do
+    SourceAnnotationExtractor.enumerate "OPTIMIZE"
+  end
+
+  desc "Enumerate all FIXME annotations"
+  task :fixme do
+    SourceAnnotationExtractor.enumerate "FIXME"
+  end
+
+  desc "Enumerate all TODO annotations"
+  task :todo do
+    SourceAnnotationExtractor.enumerate "TODO"
+  end
+end