railties 3.0.0.beta

data/lib/rails/engine.rb

@@ -0,0 +1,130 @@
+require 'active_support/core_ext/module/delegation'
+require 'rails/railtie'
+
+module Rails
+  class Engine < Railtie
+    autoload :Configurable,  "rails/engine/configurable"
+    autoload :Configuration, "rails/engine/configuration"
+
+    class << self
+      attr_accessor :called_from
+
+      alias :engine_name  :railtie_name
+      alias :engine_names :railtie_names
+
+      def inherited(base)
+        unless abstract_railtie?(base)
+          base.called_from = begin
+            call_stack = caller.map { |p| p.split(':').first }
+            File.dirname(call_stack.detect { |p| p !~ %r[railties/lib/rails|rack/lib/rack] })
+          end
+        end
+
+        super
+      end
+
+      def find_root_with_flag(flag, default=nil)
+        root_path = self.called_from
+
+        while root_path && File.directory?(root_path) && !File.exist?("#{root_path}/#{flag}")
+          parent = File.dirname(root_path)
+          root_path = parent != root_path && parent
+        end
+
+        root = File.exist?("#{root_path}/#{flag}") ? root_path : default
+        raise "Could not find root path for #{self}" unless root
+
+        RUBY_PLATFORM =~ /(:?mswin|mingw)/ ?
+          Pathname.new(root).expand_path : Pathname.new(root).realpath
+      end
+    end
+
+    delegate :middleware, :paths, :root, :to => :config
+
+    def load_tasks
+      super 
+      config.paths.lib.tasks.to_a.sort.each { |ext| load(ext) }
+    end
+
+    # Add configured load paths to ruby load paths and remove duplicates.
+    initializer :set_load_path, :before => :bootstrap_load_path do
+      config.load_paths.reverse_each do |path|
+        $LOAD_PATH.unshift(path) if File.directory?(path)
+      end
+      $LOAD_PATH.uniq!
+    end
+
+    # Set the paths from which Rails will automatically load source files,
+    # and the load_once paths.
+    initializer :set_autoload_paths, :before => :bootstrap_load_path do |app|
+      ActiveSupport::Dependencies.load_paths.unshift(*config.load_paths)
+
+      if reloadable?(app)
+        ActiveSupport::Dependencies.load_once_paths.unshift(*config.load_once_paths)
+      else
+        ActiveSupport::Dependencies.load_once_paths.unshift(*config.load_paths)
+      end
+
+      # Freeze so future modifications will fail rather than do nothing mysteriously
+      config.load_paths.freeze
+      config.load_once_paths.freeze
+    end
+
+    initializer :add_routing_paths do |app|
+      paths.config.routes.to_a.each do |route|
+        app.routes_reloader.paths.unshift(route) if File.exists?(route)
+      end
+    end
+
+    initializer :add_routing_namespaces do |app|
+      paths.app.controllers.to_a.each do |load_path|
+        load_path = File.expand_path(load_path)
+        Dir["#{load_path}/*/*_controller.rb"].collect do |path|
+          namespace = File.dirname(path).sub(/#{load_path}\/?/, '')
+          app.routes.controller_namespaces << namespace unless namespace.empty?
+        end
+      end
+    end
+
+    # I18n load paths are a special case since the ones added
+    # later have higher priority.
+    initializer :add_locales do
+      config.i18n.engines_load_path.concat(paths.config.locales.to_a)
+    end
+
+    initializer :add_view_paths do
+      views = paths.app.views.to_a
+      ActionController::Base.view_paths.unshift(*views) if defined?(ActionController)
+      ActionMailer::Base.view_paths.unshift(*views)     if defined?(ActionMailer)
+    end
+
+    initializer :add_metals do |app|
+      app.metal_loader.paths.unshift(*paths.app.metals.to_a)
+    end
+
+    initializer :load_application_initializers do
+      paths.config.initializers.to_a.sort.each do |initializer|
+        load(initializer)
+      end
+    end
+
+    initializer :load_application_classes do |app|
+      next if $rails_rake_task
+
+      if app.config.cache_classes
+        config.eager_load_paths.each do |load_path|
+          matcher = /\A#{Regexp.escape(load_path)}\/(.*)\.rb\Z/
+          Dir.glob("#{load_path}/**/*.rb").sort.each do |file|
+            require_dependency file.sub(matcher, '\1')
+          end
+        end
+      end
+    end
+
+  protected
+
+    def reloadable?(app)
+      app.config.reload_engines
+    end
+  end
+end

data/lib/rails/engine/configurable.rb

@@ -0,0 +1,25 @@
+module Rails
+  class Engine
+    module Configurable
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        delegate :middleware, :root, :paths, :to => :config
+
+        def config
+          @config ||= Engine::Configuration.new(find_root_with_flag("lib"))
+        end
+
+        def inherited(base)
+          raise "You cannot inherit from a Rails::Engine child"
+        end
+      end
+
+      def config
+        self.class.config
+      end
+    end
+  end
+end

data/lib/rails/engine/configuration.rb

@@ -0,0 +1,49 @@
+require 'rails/railtie/configuration'
+
+module Rails
+  class Engine
+    class Configuration < ::Rails::Railtie::Configuration
+      attr_reader :root
+      attr_writer :eager_load_paths, :load_once_paths, :load_paths
+
+      def initialize(root=nil)
+        @root = root
+      end
+
+      def paths
+        @paths ||= begin
+          paths = Rails::Paths::Root.new(@root)
+          paths.app                 "app",                 :eager_load => true, :glob => "*"
+          paths.app.controllers     "app/controllers",     :eager_load => true
+          paths.app.helpers         "app/helpers",         :eager_load => true
+          paths.app.models          "app/models",          :eager_load => true
+          paths.app.metals          "app/metal"
+          paths.app.views           "app/views"
+          paths.lib                 "lib",                 :load_path => true
+          paths.lib.tasks           "lib/tasks",           :glob => "**/*.rake"
+          paths.config              "config"
+          paths.config.initializers "config/initializers", :glob => "**/*.rb"
+          paths.config.locales      "config/locales",      :glob => "*.{rb,yml}"
+          paths.config.routes       "config/routes.rb"
+          paths
+        end
+      end
+
+      def root=(value)
+        @root = paths.path = Pathname.new(value).expand_path
+      end
+
+      def eager_load_paths
+        @eager_load_paths ||= paths.eager_load
+      end
+
+      def load_once_paths
+        @eager_load_paths ||= paths.load_once
+      end
+
+      def load_paths
+        @load_paths ||= paths.load_paths
+      end
+    end
+  end
+end

data/lib/rails/generators.rb

@@ -0,0 +1,289 @@
+activesupport_path = File.expand_path('../../../../activesupport/lib', __FILE__)
+$:.unshift(activesupport_path) if File.directory?(activesupport_path) && !$:.include?(activesupport_path)
+
+require 'active_support'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/object/metaclass'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/hash/deep_merge'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/string/inflections'
+
+require 'rails/generators/base'
+require 'rails/generators/named_base'
+
+module Rails
+  module Generators
+    DEFAULT_ALIASES = {
+      :rails => {
+        :actions => '-a',
+        :orm => '-o',
+        :resource_controller => '-c',
+        :scaffold_controller => '-c',
+        :stylesheets => '-y',
+        :template_engine => '-e',
+        :test_framework => '-t'
+      },
+
+      :test_unit => {
+        :fixture_replacement => '-r',
+      },
+
+      :plugin => {
+        :generator => '-g',
+        :tasks => '-r'
+      }
+    }
+
+    DEFAULT_OPTIONS = {
+      :erb => {
+        :layout => true
+      },
+
+      :rails => {
+        :force_plural => false,
+        :helper => true,
+        :layout => true,
+        :orm => nil,
+        :integration_tool => nil,
+        :performance_tool => nil,
+        :resource_controller => :controller,
+        :scaffold_controller => :scaffold_controller,
+        :singleton => false,
+        :stylesheets => true,
+        :test_framework => nil,
+        :template_engine => :erb
+      },
+
+      :plugin => {
+        :generator => false,
+        :tasks => false
+      }
+    }
+
+    def self.configure!(config = Rails.application.config.generators) #:nodoc:
+      no_color! unless config.colorize_logging
+      aliases.deep_merge! config.aliases
+      options.deep_merge! config.options
+      fallbacks.merge! config.fallbacks
+    end
+
+    def self.aliases #:nodoc:
+      @aliases ||= DEFAULT_ALIASES.dup
+    end
+
+    def self.options #:nodoc:
+      @options ||= DEFAULT_OPTIONS.dup
+    end
+
+    # Hold configured generators fallbacks. If a plugin developer wants a
+    # generator group to fallback to another group in case of missing generators,
+    # they can add a fallback.
+    #
+    # For example, shoulda is considered a test_framework and is an extension
+    # of test_unit. However, most part of shoulda generators are similar to
+    # test_unit ones.
+    #
+    # Shoulda then can tell generators to search for test_unit generators when
+    # some of them are not available by adding a fallback:
+    #
+    #   Rails::Generators.fallbacks[:shoulda] = :test_unit
+    #
+    def self.fallbacks
+      @fallbacks ||= {}
+    end
+
+    # Remove the color from output.
+    def self.no_color!
+      Thor::Base.shell = Thor::Shell::Basic
+    end
+
+    # Track all generators subclasses.
+    def self.subclasses
+      @subclasses ||= []
+    end
+
+    # Rails finds namespaces similar to thor, it only adds one rule:
+    #
+    # Generators names must end with "_generator.rb". This is required because Rails
+    # looks in load paths and loads the generator just before it's going to be used.
+    #
+    # ==== Examples
+    #
+    #   find_by_namespace :webrat, :rails, :integration
+    #
+    # Will search for the following generators:
+    #
+    #   "rails:webrat", "webrat:integration", "webrat"
+    #
+    # Notice that "rails:generators:webrat" could be loaded as well, what
+    # Rails looks for is the first and last parts of the namespace.
+    #
+    def self.find_by_namespace(name, base=nil, context=nil) #:nodoc:
+      lookups = []
+      lookups << "#{base}:#{name}"    if base
+      lookups << "#{name}:#{context}" if context
+
+      unless base || context
+        unless name.to_s.include?(?:)
+          lookups << "#{name}:#{name}"
+          lookups << "rails:#{name}"
+        end
+        lookups << "#{name}"
+      end
+
+      lookup(lookups)
+
+      namespaces = subclasses.inject({}) do |hash, klass|
+        hash[klass.namespace] = klass
+        hash
+      end
+
+      lookups.each do |namespace|
+        klass = namespaces[namespace]
+        return klass if klass
+      end
+
+      invoke_fallbacks_for(name, base) || invoke_fallbacks_for(context, name)
+    end
+
+    # Receives a namespace, arguments and the behavior to invoke the generator.
+    # It's used as the default entry point for generate, destroy and update
+    # commands.
+    def self.invoke(namespace, args=ARGV, config={})
+      names = namespace.to_s.split(':')
+      if klass = find_by_namespace(names.pop, names.shift)
+        args << "--help" if args.empty? && klass.arguments.any? { |a| a.required? }
+        klass.start(args, config)
+      else
+        puts "Could not find generator #{namespace}."
+      end
+    end
+
+    # Show help message with available generators.
+    def self.help
+      lookup!
+
+      namespaces = subclasses.map{ |k| k.namespace }
+      namespaces.sort!
+
+      groups = Hash.new { |h,k| h[k] = [] }
+      namespaces.each do |namespace|
+        base = namespace.split(':').first
+        groups[base] << namespace
+      end
+
+      puts "Usage: rails generate GENERATOR [args] [options]"
+      puts
+      puts "General options:"
+      puts "  -h, [--help]     # Print generators options and usage"
+      puts "  -p, [--pretend]  # Run but do not make any changes"
+      puts "  -f, [--force]    # Overwrite files that already exist"
+      puts "  -s, [--skip]     # Skip files that already exist"
+      puts "  -q, [--quiet]    # Supress status output"
+      puts
+      puts "Please choose a generator below."
+      puts
+
+      # Print Rails defaults first.
+      rails = groups.delete("rails")
+      rails.map! { |n| n.sub(/^rails:/, '') }
+      rails.delete("app")
+      print_list("rails", rails)
+
+      groups.sort.each { |b, n| print_list(b, n) }
+    end
+
+    protected
+
+      # Prints a list of generators.
+      def self.print_list(base, namespaces) #:nodoc:
+        return if namespaces.empty?
+        puts "#{base.camelize}:"
+        namespaces.each { |namespace| puts("  #{namespace}") }
+        puts
+      end
+
+      # Try fallbacks for the given base.
+      def self.invoke_fallbacks_for(name, base) #:nodoc:
+        return nil unless base && fallbacks[base.to_sym]
+        invoked_fallbacks = []
+
+        Array(fallbacks[base.to_sym]).each do |fallback|
+          next if invoked_fallbacks.include?(fallback)
+          invoked_fallbacks << fallback
+
+          klass = find_by_namespace(name, fallback)
+          return klass if klass
+        end
+
+        nil
+      end
+
+      # Receives namespaces in an array and tries to find matching generators
+      # in the load path.
+      def self.lookup(namespaces) #:nodoc:
+        load_generators_from_railties!
+        paths = namespaces_to_paths(namespaces)
+
+        paths.each do |raw_path|
+          ["rails_generators", "generators"].each do |base|
+            path = "#{base}/#{raw_path}_generator"
+
+            begin
+              require path
+              return
+            rescue LoadError => e
+              raise unless e.message =~ /#{Regexp.escape(path)}$/
+            rescue NameError => e
+              raise unless e.message =~ /Rails::Generator([\s(::)]|$)/
+              warn "[WARNING] Could not load generator #{path.inspect} because it's a Rails 2.x generator, which is not supported anymore. Error: #{e.message}.\n#{e.backtrace.join("\n")}"
+            rescue Exception => e
+              warn "[WARNING] Could not load generator #{path.inspect}. Error: #{e.message}.\n#{e.backtrace.join("\n")}"
+            end
+          end
+        end
+      end
+
+      # This will try to load any generator in the load path to show in help.
+      def self.lookup! #:nodoc:
+        load_generators_from_railties!
+
+        $LOAD_PATH.each do |base|
+          Dir[File.join(base, "{generators,rails_generators}", "**", "*_generator.rb")].each do |path|
+            begin
+              require path
+            rescue Exception => e
+              # No problem
+            end
+          end
+        end
+      end
+
+      # Allow generators to be loaded from custom paths.
+      def self.load_generators_from_railties! #:nodoc:
+        return if defined?(@generators_from_railties) || Rails.application.nil?
+        @generators_from_railties = true
+        Rails.application.load_generators
+      end
+
+      # Convert namespaces to paths by replacing ":" for "/" and adding
+      # an extra lookup. For example, "rails:model" should be searched
+      # in both: "rails/model/model_generator" and "rails/model_generator".
+      def self.namespaces_to_paths(namespaces) #:nodoc:
+        paths = []
+        namespaces.each do |namespace|
+          pieces = namespace.split(":")
+          paths << pieces.dup.push(pieces.last).join("/") unless pieces.uniq.size == 1
+          paths << pieces.join("/")
+        end
+        paths.uniq!
+        paths
+      end
+
+  end
+end
+
+# If the application was already defined, configure generators,
+# otherwise you have to configure it by hand.
+Rails::Generators.configure! if Rails.respond_to?(:application) && Rails.application