openskies 0.0.5.2 → 0.0.6.0

data/guides/w3c_validator.rb

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

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

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

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

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

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

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

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