openskies 0.0.1

data/guides/w3c_validator.rb

@@ -0,0 +1,91 @@
+# ---------------------------------------------------------------------------
+#
+# This script validates the generated guides against the W3C Validator.
+#
+# Guides are taken from the output directory, from where all .html files are
+# submitted to the validator.
+#
+# This script is prepared to be launched from the railties directory as a rake task:
+#
+# rake validate_guides
+#
+# If nothing is specified, all files will be validated, but you can check just
+# some of them using this environment variable:
+#
+#   ONLY
+#     Use ONLY if you want to validate only one or a set of guides. Prefixes are
+#     enough:
+#
+#       # validates only association_basics.html
+#       ONLY=assoc rake validate_guides
+#
+#     Separate many using commas:
+#
+#       # validates only association_basics.html and migrations.html
+#       ONLY=assoc,migrations rake validate_guides
+#
+# ---------------------------------------------------------------------------
+
+require 'rubygems'
+require 'w3c_validators'
+include W3CValidators
+
+module RailsGuides
+  class Validator
+
+    def validate
+      validator = MarkupValidator.new
+      STDOUT.sync = true
+      errors_on_guides = {}
+
+      guides_to_validate.each do |f|
+        results = validator.validate_file(f)
+
+        if results.validity
+          print "."
+        else
+          print "E"
+          errors_on_guides[f] = results.errors
+        end
+      end
+
+      show_results(errors_on_guides)
+    end
+
+    private
+    def guides_to_validate
+      guides = Dir["./guides/output/*.html"]
+      guides.delete("./guides/output/layout.html")
+      ENV.key?('ONLY') ? select_only(guides) : guides
+    end
+
+    def select_only(guides)
+      prefixes = ENV['ONLY'].split(",").map(&:strip)
+      guides.select do |guide|
+        prefixes.any? {|p| guide.start_with?("./guides/output/#{p}")}
+      end
+    end
+
+    def show_results(error_list)
+      if error_list.size == 0
+        puts "\n\nAll checked guides validate OK!"
+      else
+        error_summary = error_detail = ""
+
+        error_list.each_pair do |name, errors|
+          error_summary += "\n  #{name}"
+          error_detail += "\n\n  #{name} has #{errors.size} validation error(s):\n"
+          errors.each do |error|
+            error_detail += "\n    "+error.to_s.gsub("\n", "")
+          end
+        end
+
+        puts "\n\nThere are #{error_list.size} guides with validation errors:\n" + error_summary
+        puts "\nHere are the detailed errors for each guide:" + error_detail
+      end
+    end
+
+  end
+end
+
+RailsGuides::Validator.new.validate

data/lib/rails/all.rb

@@ -0,0 +1,15 @@
+require "rails"
+
+%w(
+  active_record
+  action_controller
+  action_mailer
+  active_resource
+  rails/test_unit
+  sprockets
+).each do |framework|
+  begin
+    require "#{framework}/railtie"
+  rescue LoadError
+  end
+end

data/lib/rails/application/bootstrap.rb

@@ -0,0 +1,73 @@
+require "active_support/notifications"
+require "active_support/dependencies"
+require "active_support/descendants_tracker"
+
+module Rails
+  class Application
+    module Bootstrap
+      include Initializable
+
+      initializer :load_environment_hook, :group => :all do end
+
+      initializer :load_active_support, :group => :all do
+        require "active_support/all" unless config.active_support.bare
+      end
+
+      # Preload all frameworks specified by the Configuration#frameworks.
+      # Used by Passenger to ensure everything's loaded before forking and
+      # to avoid autoload race conditions in JRuby.
+      initializer :preload_frameworks, :group => :all do
+        ActiveSupport::Autoload.eager_autoload! if config.preload_frameworks
+      end
+
+      # Initialize the logger early in the stack in case we need to log some deprecation.
+      initializer :initialize_logger, :group => :all do
+        Rails.logger ||= config.logger || begin
+          path = config.paths["log"].first
+          unless File.exist? File.dirname path
+            FileUtils.mkdir_p File.dirname path
+          end
+
+          f = File.open path, 'a'
+          f.binmode
+          f.sync = true # make sure every write flushes
+
+          logger = ActiveSupport::TaggedLogging.new(
+            ActiveSupport::BufferedLogger.new(f)
+          )
+          logger.level = ActiveSupport::BufferedLogger.const_get(config.log_level.to_s.upcase)
+          logger
+        rescue StandardError
+          logger = ActiveSupport::TaggedLogging.new(ActiveSupport::BufferedLogger.new(STDERR))
+          logger.level = ActiveSupport::BufferedLogger::WARN
+          logger.warn(
+            "Rails Error: Unable to access log file. Please ensure that #{path} exists and is chmod 0666. " +
+            "The log level has been raised to WARN and the output directed to STDERR until the problem is fixed."
+          )
+          logger
+        end
+      end
+
+      # Initialize cache early in the stack so railties can make use of it.
+      initializer :initialize_cache, :group => :all do
+        unless defined?(RAILS_CACHE)
+          silence_warnings { Object.const_set "RAILS_CACHE", ActiveSupport::Cache.lookup_store(config.cache_store) }
+
+          if RAILS_CACHE.respond_to?(:middleware)
+            config.middleware.insert_before("Rack::Runtime", RAILS_CACHE.middleware)
+          end
+        end
+      end
+
+      # Sets the dependency loading mechanism.
+      # TODO: Remove files from the $" and always use require.
+      initializer :initialize_dependency_mechanism, :group => :all do
+        ActiveSupport::Dependencies.mechanism = config.cache_classes ? :require : :load
+      end
+
+      initializer :bootstrap_hook, :group => :all do |app|
+        ActiveSupport.run_load_hooks(:before_initialize, app)
+      end
+    end
+  end
+end

data/lib/rails/application/configuration.rb

@@ -0,0 +1,151 @@
+require 'active_support/core_ext/string/encoding'
+require 'active_support/core_ext/kernel/reporting'
+require 'active_support/file_update_checker'
+require 'rails/engine/configuration'
+
+module Rails
+  class Application
+    class Configuration < ::Rails::Engine::Configuration
+      attr_accessor :allow_concurrency, :asset_host, :asset_path, :assets,
+                    :cache_classes, :cache_store, :consider_all_requests_local,
+                    :dependency_loading, :exceptions_app, :file_watcher, :filter_parameters,
+                    :force_ssl, :helpers_paths, :logger, :log_tags, :preload_frameworks,
+                    :railties_order, :relative_url_root, :reload_plugins, :secret_token,
+                    :serve_static_assets, :ssl_options, :static_cache_control, :session_options,
+                    :time_zone, :reload_classes_only_on_change, :whiny_nils
+
+      attr_writer :log_level
+      attr_reader :encoding
+
+      def initialize(*)
+        super
+        self.encoding = "utf-8"
+        @allow_concurrency             = false
+        @consider_all_requests_local   = false
+        @filter_parameters             = []
+        @helpers_paths                 = []
+        @dependency_loading            = true
+        @serve_static_assets           = true
+        @static_cache_control          = nil
+        @force_ssl                     = false
+        @ssl_options                   = {}
+        @session_store                 = :cookie_store
+        @session_options               = {}
+        @time_zone                     = "UTC"
+        @log_level                     = nil
+        @middleware                    = app_middleware
+        @generators                    = app_generators
+        @cache_store                   = [ :file_store, "#{root}/tmp/cache/" ]
+        @railties_order                = [:all]
+        @relative_url_root             = ENV["RAILS_RELATIVE_URL_ROOT"]
+        @reload_classes_only_on_change = true
+        @file_watcher                  = ActiveSupport::FileUpdateChecker
+        @exceptions_app                = nil
+
+        @assets = ActiveSupport::OrderedOptions.new
+        @assets.enabled                  = false
+        @assets.paths                    = []
+        @assets.precompile               = [ Proc.new{ |path| !File.extname(path).in?(['.js', '.css']) },
+                                             /(?:\/|\\|\A)application\.(css|js)$/ ]
+        @assets.prefix                   = "/assets"
+        @assets.version                  = ''
+        @assets.debug                    = false
+        @assets.compile                  = true
+        @assets.digest                   = false
+        @assets.manifest                 = nil
+        @assets.cache_store              = [ :file_store, "#{root}/tmp/cache/assets/" ]
+        @assets.js_compressor            = nil
+        @assets.css_compressor           = nil
+        @assets.initialize_on_precompile = true
+        @assets.logger                   = nil
+      end
+
+      def compiled_asset_path
+        "/"
+      end
+
+      def encoding=(value)
+        @encoding = value
+        if "ruby".encoding_aware?
+          silence_warnings do
+            Encoding.default_external = value
+            Encoding.default_internal = value
+          end
+        else
+          $KCODE = value
+          if $KCODE == "NONE"
+            raise "The value you specified for config.encoding is " \
+                  "invalid. The possible values are UTF8, SJIS, or EUC"
+          end
+        end
+      end
+
+      def paths
+        @paths ||= begin
+          paths = super
+          paths.add "config/database",    :with => "config/database.yml"
+          paths.add "config/environment", :with => "config/environment.rb"
+          paths.add "lib/templates"
+          paths.add "log",                :with => "log/#{Rails.env}.log"
+          paths.add "public"
+          paths.add "public/javascripts"
+          paths.add "public/stylesheets"
+          paths.add "tmp"
+          paths
+        end
+      end
+
+      # Enable threaded mode. Allows concurrent requests to controller actions and
+      # multiple database connections. Also disables automatic dependency loading
+      # after boot, and disables reloading code on every request, as these are
+      # fundamentally incompatible with thread safety.
+      def threadsafe!
+        self.preload_frameworks = true
+        self.cache_classes = true
+        self.dependency_loading = false
+        self.allow_concurrency = true
+        self
+      end
+
+      # Loads and returns the contents of the #database_configuration_file. The
+      # contents of the file are processed via ERB before being sent through
+      # YAML::load.
+      def database_configuration
+        require 'erb'
+        YAML::load(ERB.new(IO.read(paths["config/database"].first)).result)
+      end
+
+      def log_level
+        @log_level ||= Rails.env.production? ? :info : :debug
+      end
+
+      def colorize_logging
+        @colorize_logging
+      end
+
+      def colorize_logging=(val)
+        @colorize_logging = val
+        ActiveSupport::LogSubscriber.colorize_logging = val
+        self.generators.colorize_logging = val
+      end
+
+      def session_store(*args)
+        if args.empty?
+          case @session_store
+          when :disabled
+            nil
+          when :active_record_store
+            ActiveRecord::SessionStore
+          when Symbol
+            ActionDispatch::Session.const_get(@session_store.to_s.camelize)
+          else
+            @session_store
+          end
+        else
+          @session_store = args.shift
+          @session_options = args.shift || {}
+        end
+      end
+    end
+  end
+end

data/lib/rails/application/finisher.rb

@@ -0,0 +1,98 @@
+module Rails
+  class Application
+    module Finisher
+      include Initializable
+
+      initializer :add_generator_templates do
+        config.generators.templates.unshift(*paths["lib/templates"].existent)
+      end
+
+      initializer :ensure_autoload_once_paths_as_subset do
+        extra = ActiveSupport::Dependencies.autoload_once_paths -
+                ActiveSupport::Dependencies.autoload_paths
+
+        unless extra.empty?
+          abort <<-end_error
+            autoload_once_paths must be a subset of the autoload_paths.
+            Extra items in autoload_once_paths: #{extra * ','}
+          end_error
+        end
+      end
+
+      initializer :add_builtin_route do |app|
+        if Rails.env.development?
+          app.routes.append do
+            match '/rails/info/properties' => "rails/info#properties"
+          end
+        end
+      end
+
+      initializer :build_middleware_stack do
+        build_middleware_stack
+      end
+
+      initializer :define_main_app_helper do |app|
+        app.routes.define_mounted_helper(:main_app)
+      end
+
+      initializer :add_to_prepare_blocks do
+        config.to_prepare_blocks.each do |block|
+          ActionDispatch::Reloader.to_prepare(&block)
+        end
+      end
+
+      # This needs to happen before eager load so it happens
+      # in exactly the same point regardless of config.cache_classes
+      initializer :run_prepare_callbacks do
+        ActionDispatch::Reloader.prepare!
+      end
+
+      initializer :eager_load! do
+        if config.cache_classes && !(defined?($rails_rake_task) && $rails_rake_task)
+          ActiveSupport.run_load_hooks(:before_eager_load, self)
+          eager_load!
+        end
+      end
+
+      # All initialization is done, including eager loading in production
+      initializer :finisher_hook do
+        ActiveSupport.run_load_hooks(:after_initialize, self)
+      end
+
+      # Set app reload just after the finisher hook to ensure
+      # routes added in the hook are still loaded.
+      initializer :set_routes_reloader_hook do
+        reloader = routes_reloader
+        reloader.execute_if_updated
+        self.reloaders << reloader
+        ActionDispatch::Reloader.to_prepare { reloader.execute_if_updated }
+      end
+
+      # Set app reload just after the finisher hook to ensure
+      # paths added in the hook are still loaded.
+      initializer :set_clear_dependencies_hook, :group => :all do
+        callback = lambda do
+          ActiveSupport::DescendantsTracker.clear
+          ActiveSupport::Dependencies.clear
+        end
+
+        if config.reload_classes_only_on_change
+          reloader = config.file_watcher.new(*watchable_args, &callback)
+          self.reloaders << reloader
+          # We need to set a to_prepare callback regardless of the reloader result, i.e.
+          # models should be reloaded if any of the reloaders (i18n, routes) were updated.
+          ActionDispatch::Reloader.to_prepare(:prepend => true){ reloader.execute }
+        else
+          ActionDispatch::Reloader.to_cleanup(&callback)
+        end
+      end
+
+      # Disable dependency loading during request cycle
+      initializer :disable_dependency_loading do
+        if config.cache_classes && !config.dependency_loading
+          ActiveSupport::Dependencies.unhook!
+        end
+      end
+    end
+  end
+end

data/lib/rails/application/railties.rb

@@ -0,0 +1,13 @@
+require 'rails/engine/railties'
+
+module Rails
+  class Application < Engine
+    class Railties < Rails::Engine::Railties
+      def all(&block)
+        @all ||= railties + engines + plugins
+        @all.each(&block) if block
+        @all
+      end
+    end
+  end
+end

data/lib/rails/application/route_inspector.rb

@@ -0,0 +1,84 @@
+module Rails
+  class Application
+    ##
+    # This class is just used for displaying route information when someone
+    # executes `rake routes`.  People should not use this class.
+    class RouteInspector # :nodoc:
+      def initialize
+        @engines = ActiveSupport::OrderedHash.new
+      end
+
+      def format all_routes, filter = nil
+        if filter
+          all_routes = all_routes.select{ |route| route.defaults[:controller] == filter }
+        end
+
+        routes = collect_routes(all_routes)
+
+        formatted_routes(routes) +
+          formatted_routes_for_engines
+      end
+
+      def collect_routes(routes)
+        routes = routes.collect do |route|
+          route_reqs = route.requirements
+
+          rack_app = discover_rack_app(route.app)
+
+          controller = route_reqs[:controller] || ':controller'
+          action     = route_reqs[:action]     || ':action'
+
+          endpoint = rack_app ? rack_app.inspect : "#{controller}##{action}"
+          constraints = route_reqs.except(:controller, :action)
+
+          reqs = endpoint
+          reqs += " #{constraints.inspect}" unless constraints.empty?
+
+          verb = route.verb.source.gsub(/[$^]/, '')
+
+          collect_engine_routes(reqs, rack_app)
+
+          {:name => route.name.to_s, :verb => verb, :path => route.path.spec.to_s, :reqs => reqs }
+        end
+
+        # Skip the route if it's internal info route
+        routes.reject { |r| r[:path] =~ %r{/rails/info/properties|^#{Rails.application.config.assets.prefix}} }
+      end
+
+      def collect_engine_routes(name, rack_app)
+        return unless rack_app && rack_app.respond_to?(:routes)
+        return if @engines[name]
+
+        routes = rack_app.routes
+        if routes.is_a?(ActionDispatch::Routing::RouteSet)
+          @engines[name] = collect_routes(routes.routes)
+        end
+      end
+
+      def formatted_routes_for_engines
+        @engines.map do |name, routes|
+          ["\nRoutes for #{name}:"] + formatted_routes(routes)
+        end.flatten
+      end
+
+      def formatted_routes(routes)
+        name_width = routes.map{ |r| r[:name].length }.max
+        verb_width = routes.map{ |r| r[:verb].length }.max
+        path_width = routes.map{ |r| r[:path].length }.max
+
+        routes.map do |r|
+          "#{r[:name].rjust(name_width)} #{r[:verb].ljust(verb_width)} #{r[:path].ljust(path_width)} #{r[:reqs]}"
+        end
+      end
+
+      def discover_rack_app(app)
+        class_name = app.class.name.to_s
+        if class_name == "ActionDispatch::Routing::Mapper::Constraints"
+          discover_rack_app(app.app)
+        elsif class_name !~ /^ActionDispatch::Routing/
+          app
+        end
+      end
+    end
+  end
+end

data/lib/rails/application/routes_reloader.rb

@@ -0,0 +1,56 @@
+require "active_support/core_ext/module/delegation"
+
+module Rails
+  class Application
+    class RoutesReloader
+      attr_reader :route_sets, :paths
+      delegate :execute_if_updated, :execute, :updated?, :to => :updater
+
+      def initialize
+        @paths      = []
+        @route_sets = []
+      end
+
+      def reload!
+        clear!
+        load_paths
+        finalize!
+      ensure
+        revert
+      end
+
+    private
+
+      def updater
+        @updater ||= begin
+          updater = ActiveSupport::FileUpdateChecker.new(paths) { reload! }
+          updater.execute
+          updater
+        end
+      end
+
+      def clear!
+        route_sets.each do |routes|
+          routes.disable_clear_and_finalize = true
+          routes.clear!
+        end
+      end
+
+      def load_paths
+        paths.each { |path| load(path) }
+      end
+
+      def finalize!
+        route_sets.each do |routes|
+          ActiveSupport.on_load(:action_controller) { routes.finalize! }
+        end
+      end
+
+      def revert
+        route_sets.each do |routes|
+          routes.disable_clear_and_finalize = false
+        end
+      end
+    end
+  end
+end