openskies 0.0.5.2 → 0.0.6.0

data/lib/rails/application.rb

@@ -1,320 +0,0 @@
-require 'active_support/core_ext/hash/reverse_merge'
-require 'fileutils'
-require 'rails/plugin'
-require 'rails/engine'
-
-module Rails
-  # In Rails 3.0, a Rails::Application object was introduced which is nothing more than
-  # an Engine but with the responsibility of coordinating the whole boot process.
-  #
-  # == Initialization
-  #
-  # Rails::Application is responsible for executing all railties, engines and plugin
-  # initializers. It also executes some bootstrap initializers (check
-  # Rails::Application::Bootstrap) and finishing initializers, after all the others
-  # are executed (check Rails::Application::Finisher).
-  #
-  # == Configuration
-  #
-  # Besides providing the same configuration as Rails::Engine and Rails::Railtie,
-  # the application object has several specific configurations, for example
-  # "allow_concurrency", "cache_classes", "consider_all_requests_local", "filter_parameters",
-  # "logger", "reload_plugins" and so forth.
-  #
-  # Check Rails::Application::Configuration to see them all.
-  #
-  # == Routes
-  #
-  # The application object is also responsible for holding the routes and reloading routes
-  # whenever the files change in development.
-  #
-  # == Middlewares
-  #
-  # The Application is also responsible for building the middleware stack.
-  #
-  # == Booting process
-  #
-  # The application is also responsible for setting up and executing the booting
-  # process. From the moment you require "config/application.rb" in your app,
-  # the booting process goes like this:
-  #
-  #   1)  require "config/boot.rb" to setup load paths
-  #   2)  require railties and engines
-  #   3)  Define Rails.application as "class MyApp::Application < Rails::Application"
-  #   4)  Run config.before_configuration callbacks
-  #   5)  Load config/environments/ENV.rb
-  #   6)  Run config.before_initialize callbacks
-  #   7)  Run Railtie#initializer defined by railties, engines and application.
-  #       One by one, each engine sets up its load paths, routes and runs its config/initializers/* files.
-  #   9)  Custom Railtie#initializers added by railties, engines and applications are executed
-  #   10) Build the middleware stack and run to_prepare callbacks
-  #   11) Run config.before_eager_load and eager_load if cache classes is true
-  #   12) Run config.after_initialize callbacks
-  #
-  class Application < Engine
-    autoload :Bootstrap,      'rails/application/bootstrap'
-    autoload :Configuration,  'rails/application/configuration'
-    autoload :Finisher,       'rails/application/finisher'
-    autoload :Railties,       'rails/application/railties'
-    autoload :RoutesReloader, 'rails/application/routes_reloader'
-
-    class << self
-      def inherited(base)
-        raise "You cannot have more than one Rails::Application" if Rails.application
-        super
-        Rails.application = base.instance
-        Rails.application.add_lib_to_load_path!
-        ActiveSupport.run_load_hooks(:before_configuration, base.instance)
-      end
-    end
-
-    attr_accessor :assets, :sandbox
-    alias_method :sandbox?, :sandbox
-    attr_reader :reloaders
-
-    delegate :default_url_options, :default_url_options=, :to => :routes
-
-    def initialize
-      super
-      @initialized = false
-      @reloaders   = []
-    end
-
-    # This method is called just after an application inherits from Rails::Application,
-    # allowing the developer to load classes in lib and use them during application
-    # configuration.
-    #
-    #   class MyApplication < Rails::Application
-    #     require "my_backend" # in lib/my_backend
-    #     config.i18n.backend = MyBackend
-    #   end
-    #
-    # Notice this method takes into consideration the default root path. So if you
-    # are changing config.root inside your application definition or having a custom
-    # Rails application, you will need to add lib to $LOAD_PATH on your own in case
-    # you need to load files in lib/ during the application configuration as well.
-    def add_lib_to_load_path! #:nodoc:
-      path = config.root.join('lib').to_s
-      $LOAD_PATH.unshift(path) if File.exists?(path)
-    end
-
-    def require_environment! #:nodoc:
-      environment = paths["config/environment"].existent.first
-      require environment if environment
-    end
-
-    # Reload application routes regardless if they changed or not.
-    def reload_routes!
-      routes_reloader.reload!
-    end
-
-    def routes_reloader #:nodoc:
-      @routes_reloader ||= RoutesReloader.new
-    end
-
-    # Returns an array of file paths appended with a hash of directories-extensions
-    # suitable for ActiveSupport::FileUpdateChecker API.
-    def watchable_args
-      files = []
-      files.concat config.watchable_files
-
-      dirs = {}
-      dirs.merge! config.watchable_dirs
-      ActiveSupport::Dependencies.autoload_paths.each do |path|
-        dirs[path.to_s] = [:rb]
-      end
-
-      [files, dirs]
-    end
-
-    # Initialize the application passing the given group. By default, the
-    # group is :default but sprockets precompilation passes group equals
-    # to assets if initialize_on_precompile is false to avoid booting the
-    # whole app.
-    def initialize!(group=:default) #:nodoc:
-      raise "Application has been already initialized." if @initialized
-      run_initializers(group, self)
-      @initialized = true
-      self
-    end
-
-    # Load the application and its railties tasks and invoke the registered hooks.
-    # Check <tt>Rails::Railtie.rake_tasks</tt> for more info.
-    def load_tasks(app=self)
-      initialize_tasks
-      super
-      self
-    end
-
-    # Load the application console and invoke the registered hooks.
-    # Check <tt>Rails::Railtie.console</tt> for more info.
-    def load_console(app=self)
-      initialize_console
-      super
-      self
-    end
-
-    # Rails.application.env_config stores some of the Rails initial environment parameters.
-    # Currently stores:
-    #
-    #   * "action_dispatch.parameter_filter"         => config.filter_parameters,
-    #   * "action_dispatch.secret_token"             => config.secret_token,
-    #   * "action_dispatch.show_exceptions"          => config.action_dispatch.show_exceptions,
-    #   * "action_dispatch.show_detailed_exceptions" => config.consider_all_requests_local,
-    #   * "action_dispatch.logger"                   => Rails.logger,
-    #   * "action_dispatch.backtrace_cleaner"        => Rails.backtrace_cleaner
-    #
-    # These parameters will be used by middlewares and engines to configure themselves.
-    #
-    def env_config
-      @env_config ||= super.merge({
-        "action_dispatch.parameter_filter" => config.filter_parameters,
-        "action_dispatch.secret_token" => config.secret_token,
-        "action_dispatch.show_exceptions" => config.action_dispatch.show_exceptions,
-        "action_dispatch.show_detailed_exceptions" => config.consider_all_requests_local,
-        "action_dispatch.logger" => Rails.logger,
-        "action_dispatch.backtrace_cleaner" => Rails.backtrace_cleaner
-      })
-    end
-
-    # Returns the ordered railties for this application considering railties_order.
-    def ordered_railties #:nodoc:
-      @ordered_railties ||= begin
-        order = config.railties_order.map do |railtie|
-          if railtie == :main_app
-            self
-          elsif railtie.respond_to?(:instance)
-            railtie.instance
-          else
-            railtie
-          end
-        end
-
-        all = (railties.all - order)
-        all.push(self)   unless (all + order).include?(self)
-        order.push(:all) unless order.include?(:all)
-
-        index = order.index(:all)
-        order[index] = all
-        order.reverse.flatten
-      end
-    end
-
-    def initializers #:nodoc:
-      Bootstrap.initializers_for(self) +
-      super +
-      Finisher.initializers_for(self)
-    end
-
-    def config #:nodoc:
-      @config ||= Application::Configuration.new(find_root_with_flag("config.ru", Dir.pwd))
-    end
-
-    def to_app
-      self
-    end
-
-    def helpers_paths #:nodoc:
-      config.helpers_paths
-    end
-
-    def call(env)
-      env["ORIGINAL_FULLPATH"] = build_original_fullpath(env)
-      super(env)
-    end
-
-  protected
-
-    alias :build_middleware_stack :app
-
-    def reload_dependencies?
-      config.reload_classes_only_on_change != true || reloaders.map(&:updated?).any?
-    end
-
-    def default_middleware_stack
-      require 'action_controller/railtie'
-
-      ActionDispatch::MiddlewareStack.new.tap do |middleware|
-        if rack_cache = config.action_controller.perform_caching && config.action_dispatch.rack_cache
-          require "action_dispatch/http/rack_cache"
-          middleware.use ::Rack::Cache, rack_cache
-        end
-
-        if config.force_ssl
-          require "rack/ssl"
-          middleware.use ::Rack::SSL, config.ssl_options
-        end
-
-        if config.serve_static_assets
-          middleware.use ::ActionDispatch::Static, paths["public"].first, config.static_cache_control
-        end
-
-        middleware.use ::Rack::Lock unless config.allow_concurrency
-        middleware.use ::Rack::Runtime
-        middleware.use ::Rack::MethodOverride
-        middleware.use ::ActionDispatch::RequestId
-        middleware.use ::Rails::Rack::Logger, config.log_tags # must come after Rack::MethodOverride to properly log overridden methods
-        middleware.use ::ActionDispatch::ShowExceptions, config.exceptions_app || ActionDispatch::PublicExceptions.new(Rails.public_path)
-        middleware.use ::ActionDispatch::DebugExceptions
-        middleware.use ::ActionDispatch::RemoteIp, config.action_dispatch.ip_spoofing_check, config.action_dispatch.trusted_proxies
-
-        if config.action_dispatch.x_sendfile_header.present?
-          middleware.use ::Rack::Sendfile, config.action_dispatch.x_sendfile_header
-        end
-
-        unless config.cache_classes
-          app = self
-          middleware.use ::ActionDispatch::Reloader, lambda { app.reload_dependencies? }
-        end
-
-        middleware.use ::ActionDispatch::Callbacks
-        middleware.use ::ActionDispatch::Cookies
-
-        if config.session_store
-          if config.force_ssl && !config.session_options.key?(:secure)
-            config.session_options[:secure] = true
-          end
-          middleware.use config.session_store, config.session_options
-          middleware.use ::ActionDispatch::Flash
-        end
-
-        middleware.use ::ActionDispatch::ParamsParser
-        middleware.use ::ActionDispatch::Head
-        middleware.use ::Rack::ConditionalGet
-        middleware.use ::Rack::ETag, "no-cache"
-
-        if config.action_dispatch.best_standards_support
-          middleware.use ::ActionDispatch::BestStandardsSupport, config.action_dispatch.best_standards_support
-        end
-      end
-    end
-
-    def initialize_tasks #:nodoc:
-      self.class.rake_tasks do
-        require "rails/tasks"
-        task :environment do
-          $rails_rake_task = true
-          require_environment!
-        end
-      end
-    end
-
-    def initialize_console #:nodoc:
-      require "pp"
-      require "rails/console/app"
-      require "rails/console/helpers"
-    end
-
-    def build_original_fullpath(env)
-      path_info    = env["PATH_INFO"]
-      query_string = env["QUERY_STRING"]
-      script_name  = env["SCRIPT_NAME"]
-
-      if query_string.present?
-        "#{script_name}#{path_info}?#{query_string}"
-      else
-        "#{script_name}#{path_info}"
-      end
-    end
-  end
-end

data/lib/rails/backtrace_cleaner.rb

@@ -1,42 +0,0 @@
-require 'active_support/backtrace_cleaner'
-
-module Rails
-  class BacktraceCleaner < ActiveSupport::BacktraceCleaner
-    APP_DIRS_PATTERN = /^\/?(app|config|lib|test)/
-    RENDER_TEMPLATE_PATTERN = /:in `_render_template_\w*'/
-
-    def initialize
-      super
-      add_filter   { |line| line.sub("#{Rails.root}/", '') }
-      add_filter   { |line| line.sub(RENDER_TEMPLATE_PATTERN, '') }
-      add_filter   { |line| line.sub('./', '/') } # for tests
-
-      add_gem_filters
-      add_silencer { |line| line !~ APP_DIRS_PATTERN }
-    end
-
-    private
-      def add_gem_filters
-        return unless defined?(Gem)
-
-        gems_paths = (Gem.path + [Gem.default_dir]).uniq.map!{ |p| Regexp.escape(p) }
-        return if gems_paths.empty?
-
-        gems_regexp = %r{(#{gems_paths.join('|')})/gems/([^/]+)-([\w.]+)/(.*)}
-        add_filter { |line| line.sub(gems_regexp, '\2 (\3) \4') }
-      end
-  end
-
-  # For installing the BacktraceCleaner in the test/unit
-  module BacktraceFilterForTestUnit #:nodoc:
-    def self.included(klass)
-      klass.send :alias_method_chain, :filter_backtrace, :cleaning
-    end
-
-    def filter_backtrace_with_cleaning(backtrace, prefix=nil)
-      backtrace = filter_backtrace_without_cleaning(backtrace, prefix)
-      backtrace = backtrace.first.split("\n") if backtrace.size == 1
-      Rails.backtrace_cleaner.clean(backtrace)
-    end
-  end
-end

data/lib/rails/cli.rb

@@ -1,16 +0,0 @@
-require 'rbconfig'
-require 'rails/script_rails_loader'
-
-# If we are inside a Rails application this method performs an exec and thus
-# the rest of this script is not run.
-Rails::ScriptRailsLoader.exec_script_rails!
-
-require 'rails/ruby_version_check'
-Signal.trap("INT") { puts; exit(1) }
-
-if ARGV.first == 'plugin'
-  ARGV.shift
-  require 'rails/commands/plugin_new'
-else
-  require 'rails/commands/application'
-end

data/lib/rails/code_statistics.rb

@@ -1,118 +0,0 @@
-class CodeStatistics #:nodoc:
-
-  TEST_TYPES = %w(Units Functionals Unit\ tests Functional\ tests Integration\ tests)
-
-  def initialize(*pairs)
-    @pairs      = pairs
-    @statistics = calculate_statistics
-    @total      = calculate_total if pairs.length > 1
-  end
-
-  def to_s
-    print_header
-    @pairs.each { |pair| print_line(pair.first, @statistics[pair.first]) }
-    print_splitter
-
-    if @total
-      print_line("Total", @total)
-      print_splitter
-    end
-
-    print_code_test_stats
-  end
-
-  private
-    def calculate_statistics
-      Hash[@pairs.map{|pair| [pair.first, calculate_directory_statistics(pair.last)]}]
-    end
-
-    def calculate_directory_statistics(directory, pattern = /.*\.rb$/)
-      stats = { "lines" => 0, "codelines" => 0, "classes" => 0, "methods" => 0 }
-
-      Dir.foreach(directory) do |file_name|
-        if File.directory?(directory + "/" + file_name) and (/^\./ !~ file_name)
-          newstats = calculate_directory_statistics(directory + "/" + file_name, pattern)
-          stats.each { |k, v| stats[k] += newstats[k] }
-        end
-
-        next unless file_name =~ pattern
-
-        f = File.open(directory + "/" + file_name)
-        comment_started = false
-        while line = f.gets
-          stats["lines"]     += 1
-          if(comment_started)
-            if line =~ /^=end/
-              comment_started = false
-            end
-            next
-          else
-            if line =~ /^=begin/
-              comment_started = true
-              next
-            end
-          end
-          stats["classes"]   += 1 if line =~ /^\s*class\s+[_A-Z]/
-          stats["methods"]   += 1 if line =~ /^\s*def\s+[_a-z]/
-          stats["codelines"] += 1 unless line =~ /^\s*$/ || line =~ /^\s*#/
-        end
-      end
-
-      stats
-    end
-
-    def calculate_total
-      total = { "lines" => 0, "codelines" => 0, "classes" => 0, "methods" => 0 }
-      @statistics.each_value { |pair| pair.each { |k, v| total[k] += v } }
-      total
-    end
-
-    def calculate_code
-      code_loc = 0
-      @statistics.each { |k, v| code_loc += v['codelines'] unless TEST_TYPES.include? k }
-      code_loc
-    end
-
-    def calculate_tests
-      test_loc = 0
-      @statistics.each { |k, v| test_loc += v['codelines'] if TEST_TYPES.include? k }
-      test_loc
-    end
-
-    def print_header
-      print_splitter
-      puts "| Name                 | Lines |   LOC | Classes | Methods | M/C | LOC/M |"
-      print_splitter
-    end
-
-    def print_splitter
-      puts "+----------------------+-------+-------+---------+---------+-----+-------+"
-    end
-
-    def print_line(name, statistics)
-      m_over_c   = (statistics["methods"] / statistics["classes"])   rescue m_over_c = 0
-      loc_over_m = (statistics["codelines"] / statistics["methods"]) - 2 rescue loc_over_m = 0
-
-      start = if TEST_TYPES.include? name
-        "| #{name.ljust(20)} "
-      else
-        "| #{name.ljust(20)} "
-      end
-
-      puts start +
-           "| #{statistics["lines"].to_s.rjust(5)} " +
-           "| #{statistics["codelines"].to_s.rjust(5)} " +
-           "| #{statistics["classes"].to_s.rjust(7)} " +
-           "| #{statistics["methods"].to_s.rjust(7)} " +
-           "| #{m_over_c.to_s.rjust(3)} " +
-           "| #{loc_over_m.to_s.rjust(5)} |"
-    end
-
-    def print_code_test_stats
-      code  = calculate_code
-      tests = calculate_tests
-
-      puts "  Code LOC: #{code}     Test LOC: #{tests}     Code to Test Ratio: 1:#{sprintf("%.1f", tests.to_f/code)}"
-      puts ""
-    end
-end

data/lib/rails/commands/application.rb

@@ -1,36 +0,0 @@
-if ['--version', '-v'].include?(ARGV.first)
-  puts "openskies version 0.0.5"
-  exit(0)
-end
-
-if ARGV.first != "new"
-  ARGV[0] = "--help"
-else
-  ARGV.shift
-  railsrc = File.join(File.expand_path("~"), ".railsrc")
-  if File.exist?(railsrc)
-    extra_args_string = File.open(railsrc).read
-    extra_args = extra_args_string.split(/\n+/).map {|l| l.split}.flatten
-    puts "Using #{extra_args.join(" ")} from #{railsrc}"
-    ARGV << extra_args
-    ARGV.flatten!
-  end
-end
-
-require 'rubygems' if ARGV.include?("--dev")
-require 'rails/generators'
-require 'rails/generators/rails/app/app_generator'
-
-module Rails
-  module Generators
-    class AppGenerator
-      # We want to exit on failure to be kind to other libraries
-      # This is only when accessing via CLI
-      def self.exit_on_failure?
-        true
-      end
-    end
-  end
-end
-
-Rails::Generators::AppGenerator.start

data/lib/rails/commands/benchmarker.rb

@@ -1,34 +0,0 @@
-require 'optparse'
-require 'rails/test_help'
-require 'rails/performance_test_help'
-
-ARGV.push('--benchmark') # HAX
-require 'active_support/testing/performance'
-ARGV.pop
-
-def options
-  options = {}
-  defaults = ActiveSupport::Testing::Performance::DEFAULTS
-
-  OptionParser.new do |opt|
-    opt.banner = "Usage: rails benchmarker 'Ruby.code' 'Ruby.more_code' ... [OPTS]"
-    opt.on('-r', '--runs N', Numeric, 'Number of runs.', "Default: #{defaults[:runs]}") { |r| options[:runs] = r }
-    opt.on('-o', '--output PATH', String, 'Directory to use when writing the results.', "Default: #{defaults[:output]}") { |o| options[:output] = o }
-    opt.on('-m', '--metrics a,b,c', Array, 'Metrics to use.', "Default: #{defaults[:metrics].join(",")}") { |m| options[:metrics] = m.map(&:to_sym) }
-    opt.parse!(ARGV)
-  end
-
-  options
-end
-
-class BenchmarkerTest < ActionDispatch::PerformanceTest #:nodoc:
-  self.profile_options = options
-
-  ARGV.each do |expression|
-    eval <<-RUBY
-      def test_#{expression.parameterize('_')}
-        #{expression}
-      end
-    RUBY
-  end
-end

data/lib/rails/commands/console.rb

@@ -1,55 +0,0 @@
-require 'optparse'
-require 'irb'
-require 'irb/completion'
-
-module Rails
-  class Console
-    def self.start(app)
-      new(app).start
-    end
-
-    def initialize(app)
-      @app = app
-    end
-
-    def start
-      options = {}
-
-      OptionParser.new do |opt|
-        opt.banner = "Usage: console [environment] [options]"
-        opt.on('-s', '--sandbox', 'Rollback database modifications on exit.') { |v| options[:sandbox] = v }
-        opt.on("--debugger", 'Enable ruby-debugging for the console.') { |v| options[:debugger] = v }
-        opt.on('--irb', "DEPRECATED: Invoke `/your/choice/of/ruby script/rails console` instead") { |v| abort '--irb option is no longer supported. Invoke `/your/choice/of/ruby script/rails console` instead' }
-        opt.parse!(ARGV)
-      end
-
-      @app.sandbox = options[:sandbox]
-      @app.load_console
-
-      if options[:debugger]
-        begin
-          require 'ruby-debug'
-          puts "=> Debugger enabled"
-        rescue Exception
-          puts "You need to install ruby-debug to run the console in debugging mode. With gems, use 'gem install ruby-debug'"
-          exit
-        end
-      end
-
-      if options[:sandbox]
-        puts "Loading #{Rails.env} environment in sandbox (Rails #{Rails.version})"
-        puts "Any modifications you make will be rolled back on exit"
-      else
-        puts "Loading #{Rails.env} environment (Rails #{Rails.version})"
-      end
-
-      IRB::ExtendCommandBundle.send :include, Rails::ConsoleMethods
-      IRB.start
-    end
-  end
-end
-
-# Has to set the RAILS_ENV before config/application is required
-if ARGV.first && !ARGV.first.index("-") && env = ARGV.shift # has to shift the env ARGV so IRB doesn't freak
-  ENV['RAILS_ENV'] = %w(production development test).detect {|e| e =~ /^#{env}/} || env
-end