erails 2.1.2

data/lib/rails_generator/secret_key_generator.rb

@@ -0,0 +1,164 @@
+module Rails
+  # 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)"
+  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
+
+      if OpenSSL::OPENSSL_VERSION_NUMBER > 0x00908000
+        OpenSSL::Digest::SHA512.new(data).hexdigest
+      else
+        generate_secret_with_prng
+      end
+    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.exist?('/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/simple_logger.rb

@@ -0,0 +1,46 @@
+module Rails
+  module Generator
+    class SimpleLogger # :nodoc:
+      attr_reader :out
+      attr_accessor :quiet
+
+      def initialize(out = $stdout)
+        @out = out
+        @quiet = false
+        @level = 0
+      end
+
+      def log(status, message, &block)
+        @out.print("%12s  %s%s\n" % [status, '  ' * @level, message]) unless quiet
+        indent(&block) if block_given?
+      end
+
+      def indent(&block)
+        @level += 1
+        if block_given?
+          begin
+            block.call
+          ensure
+            outdent
+          end
+        end
+      end
+
+      def outdent
+        @level -= 1
+        if block_given?
+          begin
+            block.call
+          ensure
+            indent
+          end
+        end
+      end
+
+      private
+        def method_missing(method, *args, &block)
+          log(method.to_s, args.first, &block)
+        end
+    end
+  end
+end

data/lib/rails_generator/spec.rb

@@ -0,0 +1,44 @@
+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, GemPathSource, etc.)
+    class Spec
+      attr_reader :name, :path, :source
+
+      def initialize(name, path, source)
+        @name, @path, @source = name, path, source
+      end
+
+      # Look up the generator class.  Require its class file, find the class
+      # in ObjectSpace, tag it with this spec, and return.
+      def klass
+        unless @klass
+          require class_file
+          @klass = lookup_class
+          @klass.spec = self
+        end
+        @klass
+      end
+
+      def class_file
+        "#{path}/#{name}_generator.rb"
+      end
+
+      def class_name
+        "#{name.camelize}Generator"
+      end
+
+      private
+        # Search for the first Class descending from Rails::Generator::Base
+        # whose name matches the requested class name.
+        def lookup_class
+          ObjectSpace.each_object(Class) do |obj|
+            return obj if obj.ancestors.include?(Rails::Generator::Base) and
+                          obj.name.split('::').last == class_name
+          end
+          raise NameError, "Missing #{class_name} class in #{class_file}"
+        end
+    end
+  end
+end

data/lib/rails_generator.rb

@@ -0,0 +1,43 @@
+#--
+# 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__))
+$:.unshift(File.dirname(__FILE__) + "/../../activesupport/lib")
+
+begin
+  require 'active_support'  
+rescue LoadError
+  require 'rubygems'
+  gem 'activesupport'
+end
+
+require 'rails_generator/base'
+require 'rails_generator/lookup'
+require 'rails_generator/commands'
+
+Rails::Generator::Base.send(:include, Rails::Generator::Lookup)
+Rails::Generator::Base.send(:include, Rails::Generator::Commands)
+
+# Set up a default logger for convenience.
+require 'rails_generator/simple_logger'
+Rails::Generator::Base.logger = Rails::Generator::SimpleLogger.new(STDOUT)

data/lib/railties_path.rb

@@ -0,0 +1 @@
+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/rubyprof_ext.rb

@@ -0,0 +1,35 @@
+require 'prof'
+
+module Prof #:nodoc:
+  # Adapted from Shugo Maeda's unprof.rb
+  def self.print_profile(results, io = $stderr)
+    total = results.detect { |i|
+      i.method_class.nil? && i.method_id == :"#toplevel"
+    }.total_time
+    total = 0.001 if total < 0.001
+
+    io.puts "  %%   cumulative   self              self     total"
+    io.puts " time   seconds   seconds    calls  ms/call  ms/call  name"
+
+    sum = 0.0
+    for r in results
+      sum += r.self_time
+
+      name =  if r.method_class.nil?
+                r.method_id.to_s
+              elsif r.method_class.is_a?(Class)
+                "#{r.method_class}##{r.method_id}"
+              else
+                "#{r.method_class}.#{r.method_id}"
+              end
+      io.printf "%6.2f %8.3f  %8.3f %8d %8.2f %8.2f  %s\n",
+        r.self_time / total * 100,
+        sum,
+        r.self_time,
+        r.count,
+        r.self_time * 1000 / r.count,
+        r.total_time * 1000 / r.count,
+        name
+    end
+  end
+end

data/lib/source_annotation_extractor.rb

@@ -0,0 +1,102 @@
+# Implements the logic behind the rake tasks for annotations like
+#
+#   rake notes
+#   rake notes:optimize
+#
+# and friends. See <tt>rake -T notes</tt> and <tt>erailties/lib/tasks/annotations.rake</tt>.
+#
+# Annotation objects are triplets <tt>:line</tt>, <tt>:tag</tt>, <tt>:text</tt> that
+# represent the line where the annotation lives, its tag, and its text. Note
+# the filename is not stored.
+#
+# Annotations are looked for in comments and modulus whitespace they have to
+# start with the tag optionally followed by a colon. Everything up to the end
+# of the line (or closing ERb comment tag) is considered to be their text.
+class SourceAnnotationExtractor
+  class Annotation < Struct.new(:line, :tag, :text)
+
+    # Returns a representation of the annotation that looks like this:
+    #
+    #   [126] [TODO] This algorithm is simple and clearly correct, make it faster.
+    #
+    # If +options+ has a flag <tt>:tag</tt> the tag is shown as in the example above.
+    # Otherwise the string contains just line and text.
+    def to_s(options={})
+      s = "[%3d] " % line
+      s << "[#{tag}] " if options[:tag]
+      s << text
+    end
+  end
+
+  # Prints all annotations with tag +tag+ under the root directories +app+, +lib+,
+  # and +test+ (recursively). Only filenames with extension +.builder+, +.rb+,
+  # +.rxml+, +.rhtml+, or +.erb+ are taken into account. The +options+
+  # hash is passed to each annotation's +to_s+.
+  #
+  # This class method is the single entry point for the rake tasks.
+  def self.enumerate(tag, options={})
+    extractor = new(tag)
+    extractor.display(extractor.find, options)
+  end
+
+  attr_reader :tag
+
+  def initialize(tag)
+    @tag = tag
+  end
+
+  # Returns a hash that maps filenames under +dirs+ (recursively) to arrays
+  # with their annotations. Only files with annotations are included, and only
+  # those with extension +.builder+, +.rb+, +.rxml+, +.rhtml+, and +.erb+
+  # are taken into account.
+  def find(dirs=%w(app lib test))
+    dirs.inject({}) { |h, dir| h.update(find_in(dir)) }
+  end
+
+  # Returns a hash that maps filenames under +dir+ (recursively) to arrays
+  # with their annotations. Only files with annotations are included, and only
+  # those with extension +.builder+, +.rb+, +.rxml+, +.rhtml+, and +.erb+
+  # are taken into account.
+  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
+
+  # If +file+ is the filename of a file that contains annotations this method returns
+  # a hash with a single entry that maps +file+ to an array of its annotations.
+  # Otherwise it returns an empty hash.
+  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
+
+  # Prints the mapping from filenames to annotations in +results+ ordered by filename.
+  # The +options+ hash is passed to each annotation's +to_s+.
+  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