railties 3.0.0.beta

data/lib/rails/initializable.rb

@@ -0,0 +1,97 @@
+require 'tsort'
+
+module Rails
+  module Initializable
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    class Initializer
+      attr_reader :name, :block
+
+      def initialize(name, context, options, &block)
+        @name, @context, @options, @block = name, context, options, block
+      end
+
+      def before
+        @options[:before]
+      end
+
+      def after
+        @options[:after]
+      end
+
+      def run(*args)
+        @context.instance_exec(*args, &block)
+      end
+
+      def bind(context)
+        return self if @context
+        Initializer.new(@name, context, @options, &block)
+      end
+    end
+
+    class Collection < Array
+      include TSort
+
+      alias :tsort_each_node :each
+      def tsort_each_child(initializer, &block)
+        select { |i| i.before == initializer.name || i.name == initializer.after }.each(&block)
+      end
+
+      def initialize(initializers = [])
+        super(initializers)
+        replace(tsort)
+      end
+
+      def +(other)
+        Collection.new(to_a + other.to_a)
+      end
+    end
+
+    def run_initializers(*args)
+      return if instance_variable_defined?(:@ran)
+      initializers.each do |initializer|
+        initializer.run(*args)
+      end
+      @ran = true
+    end
+
+    def initializers
+      @initializers ||= self.class.initializers_for(self)
+    end
+
+    module ClassMethods
+      def initializers
+        @initializers ||= []
+      end
+
+      def initializers_chain
+        initializers = Collection.new
+        ancestors.reverse_each do |klass|
+          next unless klass.respond_to?(:initializers)
+          initializers = initializers + klass.initializers
+        end
+        initializers
+      end
+
+      def initializers_for(binding)
+        Collection.new(initializers_chain.map { |i| i.bind(binding) })
+      end
+
+      def initializer(name, opts = {}, &blk)
+        raise ArgumentError, "A block must be passed when defining an initializer" unless blk
+        opts[:after] ||= initializers.last.name unless initializers.empty? || initializers.find { |i| i.name == opts[:before] }
+        initializers << Initializer.new(name, nil, opts, &blk)
+      end
+
+      def run_initializers(*args)
+        return if @ran
+        initializers_chain.each do |initializer|
+          instance_exec(*args, &initializer.block)
+        end
+        @ran = true
+      end
+    end
+  end
+end

data/lib/rails/paths.rb

@@ -0,0 +1,144 @@
+require 'set'
+
+module Rails
+  module Paths
+    module PathParent
+      def method_missing(id, *args)
+        name = id.to_s
+
+        if name =~ /^(.*)=$/ || args.any?
+          @children[$1 || name] = Path.new(@root, *args)
+        elsif path = @children[name]
+          path
+        else
+          super
+        end
+      end
+    end
+
+    class Root
+      include PathParent
+
+      attr_accessor :path
+
+      def initialize(path)
+        raise if path.is_a?(Array)
+
+        @children = {}
+
+        @path = path
+        @root = self
+        @all_paths = []
+      end
+
+      def all_paths
+        @all_paths.uniq!
+        @all_paths
+      end
+
+      def load_once
+        filter { |path| path.paths if path.load_once? }
+      end
+
+      def eager_load
+        filter { |path| path.paths if path.eager_load? }
+      end
+
+      def load_paths
+        filter { |path| path.paths if path.load_path? }
+      end
+
+      def push(*)
+        raise "Application root can only have one physical path"
+      end
+
+      alias unshift push
+      alias << push
+      alias concat push
+
+    protected
+
+      def filter(&block)
+        all_paths.map(&block).compact.flatten.uniq.select { |p| File.exists?(p) }
+      end
+    end
+
+    class Path
+      include PathParent, Enumerable
+
+      attr_reader :path
+      attr_accessor :glob
+
+      def initialize(root, *paths)
+        @options  = paths.last.is_a?(::Hash) ? paths.pop : {}
+        @children = {}
+        @root     = root
+        @paths    = paths.flatten
+        @glob     = @options.delete(:glob)
+
+        @load_once  = @options[:load_once]
+        @eager_load = @options[:eager_load]
+        @load_path  = @options[:load_path] || @eager_load || @load_once
+
+        @root.all_paths << self
+      end
+
+      def each
+        to_a.each { |p| yield p }
+      end
+
+      def push(path)
+        @paths.push path
+      end
+
+      alias << push
+
+      def unshift(path)
+        @paths.unshift path
+      end
+
+      def concat(paths)
+        @paths.concat paths
+      end
+
+      def load_once!
+        @load_once = true
+        @load_path = true
+      end
+
+      def load_once?
+        @load_once
+      end
+
+      def eager_load!
+        @eager_load = true
+        @load_path  = true
+      end
+
+      def eager_load?
+        @eager_load
+      end
+
+      def load_path!
+        @load_path = true
+      end
+
+      def load_path?
+        @load_path
+      end
+
+      def paths
+        raise "You need to set a path root" unless @root.path
+        result = @paths.map do |p|
+          path = File.expand_path(p, @root.path)
+          @glob ? Dir[File.join(path, @glob)] : path
+        end
+        result.flatten!
+        result.uniq!
+        result
+      end
+
+      alias to_a paths
+    end
+  end
+end

data/lib/rails/performance_test_help.rb

@@ -0,0 +1,3 @@
+ActionController::Base.perform_caching = true
+ActiveSupport::Dependencies.mechanism = :require
+Rails.logger.level = ActiveSupport::BufferedLogger::INFO

data/lib/rails/plugin.rb

@@ -0,0 +1,64 @@
+require 'rails/engine'
+
+module Rails
+  class Plugin < Engine
+    def self.inherited(base)
+      raise "You cannot inherit from Rails::Plugin"
+    end
+
+    def self.all(list, paths)
+      plugins = []
+      paths.each do |path|
+        Dir["#{path}/*"].each do |plugin_path|
+          plugin = new(plugin_path)
+          next unless list.include?(plugin.name) || list.include?(:all)
+          plugins << plugin
+        end
+      end
+
+      plugins.sort_by do |p|
+        [list.index(p.name) || list.index(:all), p.name.to_s]
+      end
+    end
+
+    attr_reader :name, :path
+
+    def load_tasks
+      super
+      extra_tasks = Dir["#{root}/{tasks,rails/tasks}/**/*.rake"]
+
+      unless extra_tasks.empty?
+        ActiveSupport::Deprecation.warn "Having rake tasks in PLUGIN_PATH/tasks or " <<
+          "PLUGIN_PATH/rails/tasks is deprecated. Use to PLUGIN_PATH/lib/tasks instead"
+        extra_tasks.sort.each { |ext| load(ext) }
+      end
+    end
+
+    def initialize(root)
+      @name = File.basename(root).to_sym
+      config.root = root
+    end
+
+    def config
+      @config ||= Engine::Configuration.new
+    end
+
+    initializer :load_init_rb, :before => :load_application_initializers do |app|
+      file   = Dir["#{root}/{rails/init,init}.rb"].first
+      config = app.config
+      eval(File.read(file), binding, file) if file && File.file?(file)
+    end
+
+    initializer :sanity_check_railties_collision do
+      if Engine.subclasses.map { |k| k.root.to_s }.include?(root.to_s)
+        raise "\"#{name}\" is a Railtie/Engine and cannot be installed as plugin"
+      end
+    end
+
+  protected
+
+    def reloadable?(app)
+      app.config.reload_plugins
+    end
+  end
+end

data/lib/rails/rack.rb

@@ -0,0 +1,8 @@
+module Rails
+  module Rack
+    autoload :Debugger,  "rails/rack/debugger"
+    autoload :Logger,    "rails/rack/logger"
+    autoload :LogTailer, "rails/rack/log_tailer"
+    autoload :Static,    "rails/rack/static"
+  end
+end

data/lib/rails/rack/debugger.rb

@@ -0,0 +1,23 @@
+module Rails
+  module Rack
+    class Debugger
+      def initialize(app)
+        @app = app
+
+        ARGV.clear # clear ARGV so that script/server options aren't passed to IRB
+
+        require_library_or_gem 'ruby-debug'
+        ::Debugger.start
+        ::Debugger.settings[:autoeval] = true if ::Debugger.respond_to?(:settings)
+        puts "=> Debugger enabled"
+      rescue Exception
+        puts "You need to install ruby-debug to run the server in debugging mode. With gems, use 'gem install ruby-debug'"
+        exit
+      end
+
+      def call(env)
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/rails/rack/log_tailer.rb

@@ -0,0 +1,33 @@
+module Rails
+  module Rack
+    class LogTailer
+      def initialize(app, log = nil)
+        @app = app
+
+        path = Pathname.new(log || "#{File.expand_path(Rails.root)}/log/#{Rails.env}.log").cleanpath
+        @cursor = ::File.size(path)
+        @last_checked = Time.now.to_f
+
+        @file = ::File.open(path, 'r')
+      end
+
+      def call(env)
+        response = @app.call(env)
+        tail!
+        response
+      end
+
+      def tail!
+        @file.seek @cursor
+
+        mod = @file.mtime.to_f
+        if mod > @last_checked
+          contents = @file.read
+          @last_checked = mod
+          @cursor += contents.size
+          $stdout.print contents
+        end
+      end
+    end
+  end
+end

data/lib/rails/rack/logger.rb

@@ -0,0 +1,34 @@
+require 'rails/subscriber'
+
+module Rails
+  module Rack
+    # Log the request started and flush all loggers after it.
+    class Logger < Rails::Subscriber
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        before_dispatch(env)
+        @app.call(env)
+      ensure
+        after_dispatch(env)
+      end
+
+      protected
+
+        def before_dispatch(env)
+          request = ActionDispatch::Request.new(env)
+          path = request.request_uri.inspect rescue "unknown"
+
+          info "\n\nStarted #{request.method.to_s.upcase} #{path} " <<
+                      "for #{request.remote_ip} at #{Time.now.to_s(:db)}"
+        end
+
+        def after_dispatch(env)
+          Rails::Subscriber.flush_all!
+        end
+
+    end
+  end
+end

data/lib/rails/rack/static.rb

@@ -0,0 +1,5 @@
+require 'action_dispatch'
+
+module Rails::Rack
+  Static = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('Rails::Rack::Static', ActionDispatch::Static)
+end

data/lib/rails/railtie.rb

@@ -0,0 +1,74 @@
+require 'rails/initializable'
+require 'rails/configuration'
+
+module Rails
+  class Railtie
+    autoload :Configurable,  "rails/railtie/configurable"
+    autoload :Configuration, "rails/railtie/configuration"
+
+    include Initializable
+
+    ABSTRACT_RAILTIES = %w(Rails::Plugin Rails::Engine Rails::Application)
+
+    class << self
+      def subclasses
+        @subclasses ||= []
+      end
+
+      def inherited(base)
+        unless abstract_railtie?(base)
+          base.send(:include, self::Configurable)
+          subclasses << base
+        end
+      end
+
+      def railtie_name(railtie_name = nil)
+        @railtie_name ||= name.demodulize.underscore
+        @railtie_name = railtie_name if railtie_name
+        @railtie_name
+      end
+
+      def railtie_names
+        subclasses.map { |p| p.railtie_name }
+      end
+
+      def subscriber(subscriber)
+        Rails::Subscriber.add(railtie_name, subscriber)
+      end
+
+      def rake_tasks(&blk)
+        @rake_tasks ||= []
+        @rake_tasks << blk if blk
+        @rake_tasks
+      end
+
+      def generators(&blk)
+        @generators ||= []
+        @generators << blk if blk
+        @generators
+      end
+
+    protected
+
+      def abstract_railtie?(base)
+        ABSTRACT_RAILTIES.include?(base.name)
+      end
+    end
+
+    def rake_tasks
+      self.class.rake_tasks
+    end
+
+    def generators
+      self.class.generators
+    end
+
+    def load_tasks
+      rake_tasks.each { |blk| blk.call }
+    end
+
+    def load_generators
+      generators.each { |blk| blk.call }
+    end
+  end
+end