openskies 0.0.5.2 → 0.0.6.0

data/lib/rails/paths.rb

@@ -1,211 +0,0 @@
-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

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

data/lib/rails/plugin.rb

@@ -1,92 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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