openskies 0.0.1

data/lib/rails/paths.rb

@@ -0,0 +1,211 @@
+require 'set'
+
+module Rails
+  module Paths
+    # This object is an extended hash that behaves as root of the <tt>Rails::Paths</tt> system.
+    # It allows you to collect information about how you want to structure your application
+    # paths by a Hash like API. It requires you to give a physical path on initialization.
+    #
+    #   root = Root.new "/rails"
+    #   root.add "app/controllers", :eager_load => true
+    #
+    # The command above creates a new root object and add "app/controllers" as a path.
+    # This means we can get a +Rails::Paths::Path+ object back like below:
+    #
+    #   path = root["app/controllers"]
+    #   path.eager_load?               # => true
+    #   path.is_a?(Rails::Paths::Path) # => true
+    #
+    # The +Path+ object is simply an array and allows you to easily add extra paths:
+    #
+    #   path.is_a?(Array) # => true
+    #   path.inspect      # => ["app/controllers"]
+    #
+    #   path << "lib/controllers"
+    #   path.inspect      # => ["app/controllers", "lib/controllers"]
+    #
+    # Notice that when you add a path using +add+, the path object created already
+    # contains the path with the same path value given to +add+. In some situations,
+    # you may not want this behavior, so you can give :with as option.
+    #
+    #   root.add "config/routes", :with => "config/routes.rb"
+    #   root["config/routes"].inspect # => ["config/routes.rb"]
+    #
+    # The +add+ method accepts the following options as arguments:
+    # eager_load, autoload, autoload_once and glob.
+    #
+    # Finally, the +Path+ object also provides a few helpers:
+    #
+    #   root = Root.new "/rails"
+    #   root.add "app/controllers"
+    #
+    #   root["app/controllers"].expanded # => ["/rails/app/controllers"]
+    #   root["app/controllers"].existent # => ["/rails/app/controllers"]
+    #
+    # Check the <tt>Rails::Paths::Path</tt> documentation for more information.
+    class Root < ::Hash
+      attr_accessor :path
+
+      def initialize(path)
+        raise "Argument should be a String of the physical root path" if path.is_a?(Array)
+        @current = nil
+        @path = path
+        @root = self
+        super()
+      end
+
+      def []=(path, value)
+        value = Path.new(self, path, value) unless value.is_a?(Path)
+        super(path, value)
+      end
+
+      def add(path, options={})
+        with = options[:with] || path
+        self[path] = Path.new(self, path, with, options)
+      end
+
+      def all_paths
+        values.tap { |v| v.uniq! }
+      end
+
+      def autoload_once
+        filter_by(:autoload_once?)
+      end
+
+      def eager_load
+        filter_by(:eager_load?)
+      end
+
+      def autoload_paths
+        filter_by(:autoload?)
+      end
+
+      def load_paths
+        filter_by(:load_path?)
+      end
+
+    protected
+
+      def filter_by(constraint)
+        all = []
+        all_paths.each do |path|
+          if path.send(constraint)
+            paths  = path.existent
+            paths -= path.children.map { |p| p.send(constraint) ? [] : p.existent }.flatten
+            all.concat(paths)
+          end
+        end
+        all.uniq!
+        all
+      end
+    end
+
+    class Path < Array
+      attr_reader :path
+      attr_accessor :glob
+
+      def initialize(root, current, *paths)
+        options = paths.last.is_a?(::Hash) ? paths.pop : {}
+        super(paths.flatten)
+
+        @current  = current
+        @root     = root
+        @glob     = options[:glob]
+
+        options[:autoload_once] ? autoload_once! : skip_autoload_once!
+        options[:eager_load]    ? eager_load!    : skip_eager_load!
+        options[:autoload]      ? autoload!      : skip_autoload!
+        options[:load_path]     ? load_path!     : skip_load_path!
+      end
+
+      def children
+        keys = @root.keys.select { |k| k.include?(@current) }
+        keys.delete(@current)
+        @root.values_at(*keys.sort)
+      end
+
+      def first
+        expanded.first
+      end
+
+      def last
+        expanded.last
+      end
+
+      %w(autoload_once eager_load autoload load_path).each do |m|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{m}!        # def eager_load!
+            @#{m} = true   #   @eager_load = true
+          end              # end
+                           #
+          def skip_#{m}!   # def skip_eager_load!
+            @#{m} = false  #   @eager_load = false
+          end              # end
+                           #
+          def #{m}?        # def eager_load?
+            @#{m}          #   @eager_load
+          end              # end
+        RUBY
+      end
+
+      # Expands all paths against the root and return all unique values.
+      def expanded
+        raise "You need to set a path root" unless @root.path
+        result = []
+
+        each do |p|
+          path = File.expand_path(p, @root.path)
+
+          if @glob
+            if File.directory? path
+              result.concat expand_dir(path, @glob)
+            else
+              # FIXME: I think we can remove this branch, but I'm not sure.
+              # Say the filesystem has this file:
+              #
+              #   /tmp/foobar
+              #
+              # and someone adds this path:
+              #
+              #   /tmp/foo
+              #
+              # with a glob of "*", then this function will return
+              #
+              #   /tmp/foobar
+              #
+              # We need to figure out if that is desired behavior.
+              result.concat expand_file(path, @glob)
+            end
+          else
+            result << path
+          end
+        end
+
+        result.uniq!
+        result
+      end
+
+      # Returns all expanded paths but only if they exist in the filesystem.
+      def existent
+        expanded.select { |f| File.exists?(f) }
+      end
+
+      def existent_directories
+        expanded.select { |d| File.directory?(d) }
+      end
+
+      alias to_a expanded
+
+      private
+      def expand_file(path, glob)
+        Dir[File.join(path, glob)].sort
+      end
+
+      def expand_dir(path, glob)
+        Dir.chdir(path) do
+          Dir.glob(@glob).map { |file| File.join path, file }.sort
+        end
+      end
+    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,92 @@
+require 'rails/engine'
+require 'active_support/core_ext/array/conversions'
+
+module Rails
+  # Rails::Plugin is nothing more than a Rails::Engine, but since it's loaded too late
+  # in the boot process, it does not have the same configuration powers as a bare
+  # Rails::Engine.
+  #
+  # Opposite to Rails::Railtie and Rails::Engine, you are not supposed to inherit from
+  # Rails::Plugin. Rails::Plugin is automatically configured to be an engine by simply
+  # placing inside vendor/plugins. Since this is done automatically, you actually cannot
+  # declare a Rails::Engine inside your Plugin, otherwise it would cause the same files
+  # to be loaded twice. This means that if you want to ship an Engine as gem it cannot
+  # be used as plugin and vice-versa.
+  #
+  # Besides this conceptual difference, the only difference between Rails::Engine and
+  # Rails::Plugin is that plugins automatically load the file "init.rb" at the plugin
+  # root during the boot process.
+  #
+  class Plugin < Engine
+    def self.global_plugins
+      @global_plugins ||= []
+    end
+
+    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)
+          if global_plugins.include?(plugin.name)
+            warn "WARNING: plugin #{plugin.name} from #{path} was not loaded. Plugin with the same name has been already loaded."
+            next
+          end
+          global_plugins << plugin.name
+          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 railtie_name
+      name.to_s
+    end
+
+    def initialize(root)
+      ActiveSupport::Deprecation.warn "You have Rails 2.3-style plugins in vendor/plugins! Support for these plugins will be removed in Rails 4.0. Move them out and bundle them in your Gemfile, or fold them in to your app as lib/myplugin/* and config/initializers/myplugin.rb. See the release notes for more on this: http://weblog.rubyonrails.org/2012/1/4/rails-3-2-0-rc2-has-been-released"
+      @name = File.basename(root).to_sym
+      config.root = root
+    end
+
+    def config
+      @config ||= Engine::Configuration.new
+    end
+
+    initializer :handle_lib_autoload, :before => :set_load_path do |app|
+      autoload = if app.config.reload_plugins
+        config.autoload_paths
+      else
+        config.autoload_once_paths
+      end
+
+      autoload.concat paths["lib"].existent
+    end
+
+    initializer :load_init_rb, :before => :load_config_initializers do |app|
+      init_rb = File.expand_path("init.rb", root)
+      if File.file?(init_rb)
+        # This double assignment is to prevent an "unused variable" warning on Ruby 1.9.3.
+        config = config = app.config
+        # TODO: think about evaling initrb in context of Engine (currently it's
+        # always evaled in context of Rails::Application)
+        eval(File.read(init_rb), binding, init_rb)
+      end
+    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 a plugin"
+      end
+    end
+  end
+end

data/lib/rails/rack/debugger.rb

@@ -0,0 +1,24 @@
+module Rails
+  module Rack
+    class Debugger
+      def initialize(app)
+        @app = app
+
+        ARGV.clear # clear ARGV so that rails server options aren't passed to IRB
+
+        require 'ruby-debug'
+
+        ::Debugger.start
+        ::Debugger.settings[:autoeval] = true if ::Debugger.respond_to?(:settings)
+        puts "=> Debugger enabled"
+      rescue LoadError
+        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,34 @@
+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 = nil
+        if ::File.exists?(path)
+          @cursor = ::File.size(path)
+          @file = ::File.open(path, 'r')
+        end
+      end
+
+      def call(env)
+        response = @app.call(env)
+        tail!
+        response
+      end
+
+      def tail!
+        return unless @cursor
+        @file.seek @cursor
+
+        unless @file.eof?
+          contents = @file.read
+          @cursor = @file.tell
+          $stdout.print contents
+        end
+      end
+    end
+  end
+end

data/lib/rails/rack/logger.rb

@@ -0,0 +1,60 @@
+require 'active_support/core_ext/time/conversions'
+require 'active_support/core_ext/object/blank'
+
+module Rails
+  module Rack
+    # Sets log tags, logs the request, calls the app, and flushes the logs.
+    class Logger < ActiveSupport::LogSubscriber
+      def initialize(app, taggers = nil)
+        @app, @taggers = app, taggers || []
+      end
+
+      def call(env)
+        request = ActionDispatch::Request.new(env)
+
+        if Rails.logger.respond_to?(:tagged)
+          Rails.logger.tagged(compute_tags(request)) { call_app(request, env) }
+        else
+          call_app(request, env)
+        end
+      end
+
+    protected
+
+      def call_app(request, env)
+        # Put some space between requests in development logs.
+        if Rails.env.development?
+          Rails.logger.info ''
+          Rails.logger.info ''
+        end
+
+        Rails.logger.info started_request_message(request)
+        @app.call(env)
+      ensure
+        ActiveSupport::LogSubscriber.flush_all!
+      end
+
+      # Started GET "/session/new" for 127.0.0.1 at 2012-09-26 14:51:42 -0700
+      def started_request_message(request)
+        'Started %s "%s" for %s at %s' % [
+          request.request_method,
+          request.filtered_path,
+          request.ip,
+          Time.now.to_default_s ]
+      end
+
+      def compute_tags(request)
+        @taggers.collect do |tag|
+          case tag
+          when Proc
+            tag.call(request)
+          when Symbol
+            request.send(tag)
+          else
+            tag
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/rack.rb

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

data/lib/rails/railtie/configurable.rb

@@ -0,0 +1,35 @@
+require 'active_support/concern'
+
+module Rails
+  class Railtie
+    module Configurable
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        delegate :config, :to => :instance
+
+        def inherited(base)
+          raise "You cannot inherit from a #{self.superclass.name} child"
+        end
+
+        def instance
+          @instance ||= new
+        end
+
+        def respond_to?(*args)
+          super || instance.respond_to?(*args)
+        end
+
+        def configure(&block)
+          class_eval(&block)
+        end
+
+        protected
+
+        def method_missing(*args, &block)
+          instance.send(*args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/rails/railtie/configuration.rb

@@ -0,0 +1,90 @@
+require 'rails/configuration'
+
+module Rails
+  class Railtie
+    class Configuration
+      def initialize
+        @@options ||= {}
+      end
+
+      # Add files that should be watched for change.
+      def watchable_files
+        @@watchable_files ||= []
+      end
+
+      # Add directories that should be watched for change.
+      # The key of the hashes should be directories and the values should
+      # be an array of extensions to match in each directory.
+      def watchable_dirs
+        @@watchable_dirs ||= {}
+      end
+
+      # This allows you to modify the application's middlewares from Engines.
+      #
+      # All operations you run on the app_middleware will be replayed on the
+      # application once it is defined and the default_middlewares are
+      # created
+      def app_middleware
+        @@app_middleware ||= Rails::Configuration::MiddlewareStackProxy.new
+      end
+
+      # This allows you to modify application's generators from Railties.
+      #
+      # Values set on app_generators will become defaults for application, unless
+      # application overwrites them.
+      def app_generators
+        @@app_generators ||= Rails::Configuration::Generators.new
+        yield(@@app_generators) if block_given?
+        @@app_generators
+      end
+
+      # First configurable block to run. Called before any initializers are run.
+      def before_configuration(&block)
+        ActiveSupport.on_load(:before_configuration, :yield => true, &block)
+      end
+
+      # Third configurable block to run. Does not run if config.cache_classes
+      # set to false.
+      def before_eager_load(&block)
+        ActiveSupport.on_load(:before_eager_load, :yield => true, &block)
+      end
+
+      # Second configurable block to run. Called before frameworks initialize.
+      def before_initialize(&block)
+        ActiveSupport.on_load(:before_initialize, :yield => true, &block)
+      end
+
+      # Last configurable block to run. Called after frameworks initialize.
+      def after_initialize(&block)
+        ActiveSupport.on_load(:after_initialize, :yield => true, &block)
+      end
+
+      # Array of callbacks defined by #to_prepare.
+      def to_prepare_blocks
+        @@to_prepare_blocks ||= []
+      end
+
+      # Defines generic callbacks to run before #after_initialize. Useful for
+      # Rails::Railtie subclasses.
+      def to_prepare(&blk)
+        to_prepare_blocks << blk if blk
+      end
+
+      def respond_to?(name)
+        super || @@options.key?(name.to_sym)
+      end
+
+    private
+
+      def method_missing(name, *args, &blk)
+        if name.to_s =~ /=$/
+          @@options[$`.to_sym] = args.first
+        elsif @@options.key?(name)
+          @@options[name]
+        else
+          super
+        end
+      end
+    end
+  end
+end