openskies 0.0.1

data/lib/rails/tasks/framework.rake

@@ -0,0 +1,76 @@
+namespace :rails do
+  desc "Update configs and some other initially generated files (or use just update:configs, update:scripts, or update:application_controller)"
+  task :update => [ "update:configs", "update:scripts", "update:application_controller" ]
+
+  desc "Applies the template supplied by LOCATION=(/path/to/template) or URL"
+  task :template do
+    template = ENV["LOCATION"]
+    raise "No LOCATION value given. Please set LOCATION either as path to a file or a URL" if template.blank?
+    template = File.expand_path(template) if template !~ %r{\A[A-Za-z][A-Za-z0-9+\-\.]*://}
+    require 'rails/generators'
+    require 'rails/generators/rails/app/app_generator'
+    generator = Rails::Generators::AppGenerator.new [Rails.root], {}, :destination_root => Rails.root
+    generator.apply template, :verbose => false
+  end
+
+  namespace :templates do
+    # desc "Copy all the templates from rails to the application directory for customization. Already existing local copies will be overwritten"
+    task :copy do
+      generators_lib = File.expand_path("../../generators", __FILE__)
+      project_templates = "#{Rails.root}/lib/templates"
+
+      default_templates = { "erb"   => %w{controller mailer scaffold},
+                            "rails" => %w{controller helper scaffold_controller assets} }
+
+      default_templates.each do |type, names|
+        local_template_type_dir = File.join(project_templates, type)
+        FileUtils.mkdir_p local_template_type_dir
+
+        names.each do |name|
+          dst_name = File.join(local_template_type_dir, name)
+          src_name = File.join(generators_lib, type, name, "templates")
+          FileUtils.cp_r src_name, dst_name
+        end
+      end
+     end
+  end
+
+  namespace :update do
+    def invoke_from_app_generator(method)
+      app_generator.send(method)
+    end
+
+    def app_generator
+      @app_generator ||= begin
+        require 'rails/generators'
+        require 'rails/generators/rails/app/app_generator'
+        gen = Rails::Generators::AppGenerator.new ["rails"], { :with_dispatchers => true },
+                                                             :destination_root => Rails.root
+        File.exists?(Rails.root.join("config", "application.rb")) ?
+          gen.send(:app_const) : gen.send(:valid_app_const?)
+        gen
+      end
+    end
+
+    # desc "Update config/boot.rb from your current rails install"
+    task :configs do
+      invoke_from_app_generator :create_boot_file
+      invoke_from_app_generator :create_config_files
+    end
+
+    # desc "Adds new scripts to the application script/ directory"
+    task :scripts do
+      invoke_from_app_generator :create_script_files
+    end
+
+    # desc "Rename application.rb to application_controller.rb"
+    task :application_controller do
+      old_style = Rails.root + '/app/controllers/application.rb'
+      new_style = Rails.root + '/app/controllers/application_controller.rb'
+      if File.exists?(old_style) && !File.exists?(new_style)
+        FileUtils.mv(old_style, new_style)
+        puts "#{old_style} has been renamed to #{new_style}, update your SCM as necessary"
+      end
+    end
+  end
+end

data/lib/rails/tasks/log.rake

@@ -0,0 +1,9 @@
+namespace :log do
+  desc "Truncates all *.log files in log/ to zero bytes"
+  task :clear do
+    FileList["log/*.log"].each do |log_file|
+      f = File.open(log_file, "w")
+      f.close
+    end
+  end
+end

data/lib/rails/tasks/middleware.rake

@@ -0,0 +1,7 @@
+desc 'Prints out your Rack middleware stack'
+task :middleware => :environment do
+  Rails.configuration.middleware.each do |middleware|
+    puts "use #{middleware.inspect}"
+  end
+  puts "run #{Rails.application.class.name}.routes"
+end

data/lib/rails/tasks/misc.rake

@@ -0,0 +1,67 @@
+task :rails_env do
+  # TODO Do we really need this?
+  unless defined? RAILS_ENV
+    RAILS_ENV = ENV['RAILS_ENV'] ||= 'development'
+  end
+end
+
+desc 'Generate a cryptographically secure secret key (this is typically used to generate a secret for cookie sessions).'
+task :secret do
+  require 'securerandom'
+  puts SecureRandom.hex(64)
+end
+
+desc 'List versions of all Rails frameworks and the environment'
+task :about => :environment do
+  puts Rails::Info
+end
+
+namespace :time do
+  namespace :zones do
+    desc 'Displays all time zones, also available: time:zones:us, time:zones:local -- filter with OFFSET parameter, e.g., OFFSET=-6'
+    task :all do
+      build_time_zone_list(:all)
+    end
+
+    # desc 'Displays names of US time zones recognized by the Rails TimeZone class, grouped by offset. Results can be filtered with optional OFFSET parameter, e.g., OFFSET=-6'
+    task :us do
+      build_time_zone_list(:us_zones)
+    end
+
+    # desc 'Displays names of time zones recognized by the Rails TimeZone class with the same offset as the system local time'
+    task :local do
+      require 'active_support'
+      require 'active_support/time'
+      jan_offset = Time.now.beginning_of_year.utc_offset
+      jul_offset = Time.now.beginning_of_year.change(:month => 7).utc_offset
+      offset = jan_offset < jul_offset ? jan_offset : jul_offset
+      build_time_zone_list(:all, offset)
+    end
+
+    # to find UTC -06:00 zones, OFFSET can be set to either -6, -6:00 or 21600
+    def build_time_zone_list(method, offset = ENV['OFFSET'])
+      require 'active_support'
+      require 'active_support/time'
+      if offset
+        offset = if offset.to_s.match(/(\+|-)?(\d+):(\d+)/)
+          sign = $1 == '-' ? -1 : 1
+          hours, minutes = $2.to_f, $3.to_f
+          ((hours * 3600) + (minutes.to_f * 60)) * sign
+        elsif offset.to_f.abs <= 13
+          offset.to_f * 3600
+        else
+          offset.to_f
+        end
+      end
+      previous_offset = nil
+      ActiveSupport::TimeZone.__send__(method).each do |zone|
+        if offset.nil? || offset == zone.utc_offset
+          puts "\n* UTC #{zone.formatted_offset} *" unless zone.utc_offset == previous_offset
+          puts zone.name
+          previous_offset = zone.utc_offset
+        end
+      end
+      puts "\n"
+    end
+  end
+end

data/lib/rails/tasks/routes.rake

@@ -0,0 +1,9 @@
+desc 'Print out all defined routes in match order, with names. Target specific controller with CONTROLLER=x.'
+task :routes => :environment do
+  Rails.application.reload_routes!
+  all_routes = Rails.application.routes.routes
+
+  require 'rails/application/route_inspector'
+  inspector = Rails::Application::RouteInspector.new
+  puts inspector.format(all_routes, ENV['CONTROLLER']).join "\n"
+end

data/lib/rails/tasks/statistics.rake

@@ -0,0 +1,16 @@
+STATS_DIRECTORIES = [
+  %w(Controllers        app/controllers),
+  %w(Helpers            app/helpers),
+  %w(Models             app/models),
+  %w(Libraries          lib/),
+  %w(APIs               app/apis),
+  %w(Integration\ tests test/integration),
+  %w(Functional\ tests  test/functional),
+  %w(Unit\ tests        test/unit)
+].collect { |name, dir| [ name, "#{Rails.root}/#{dir}" ] }.select { |name, dir| File.directory?(dir) }
+
+desc "Report code statistics (KLOCs, etc) from the application"
+task :stats do
+  require 'rails/code_statistics'
+  CodeStatistics.new(*STATS_DIRECTORIES).to_s
+end

data/lib/rails/tasks/tmp.rake

@@ -0,0 +1,37 @@
+namespace :tmp do
+  desc "Clear session, cache, and socket files from tmp/ (narrow w/ tmp:sessions:clear, tmp:cache:clear, tmp:sockets:clear)"
+  task :clear => [ "tmp:sessions:clear",  "tmp:cache:clear", "tmp:sockets:clear"]
+
+  desc "Creates tmp directories for sessions, cache, sockets, and pids"
+  task :create do
+    FileUtils.mkdir_p(%w( tmp/sessions tmp/cache tmp/sockets tmp/pids tmp/cache/assets ))
+  end
+
+  namespace :sessions do
+    # desc "Clears all files in tmp/sessions"
+    task :clear do
+      FileUtils.rm(Dir['tmp/sessions/[^.]*'])
+    end
+  end
+
+  namespace :cache do
+    # desc "Clears all files and directories in tmp/cache"
+    task :clear do
+      FileUtils.rm_rf(Dir['tmp/cache/[^.]*'])
+    end
+  end
+
+  namespace :sockets do
+    # desc "Clears all files in tmp/sockets"
+    task :clear do
+      FileUtils.rm(Dir['tmp/sockets/[^.]*'])
+    end
+  end
+
+  namespace :pids do
+    # desc "Clears all files in tmp/pids"
+    task :clear do
+      FileUtils.rm(Dir['tmp/pids/[^.]*'])
+    end
+  end
+end

data/lib/rails/tasks.rb

@@ -0,0 +1,16 @@
+$VERBOSE = nil
+
+# Load Rails rakefile extensions
+%w(
+  annotations
+  documentation
+  framework
+  log
+  middleware
+  misc
+  routes
+  statistics
+  tmp
+).each do |task|
+  load "rails/tasks/#{task}.rake"
+end

data/lib/rails/test_help.rb

@@ -0,0 +1,56 @@
+# Make double-sure the RAILS_ENV is not set to production,
+# so fixtures aren't loaded into that environment
+abort("Abort testing: Your Rails environment is running in production mode!") if Rails.env.production?
+
+require 'test/unit'
+require 'active_support/test_case'
+require 'action_controller/test_case'
+require 'action_dispatch/testing/integration'
+
+if defined?(Test::Unit::Util::BacktraceFilter) && ENV['BACKTRACE'].nil?
+  require 'rails/backtrace_cleaner'
+  Test::Unit::Util::BacktraceFilter.module_eval { include Rails::BacktraceFilterForTestUnit }
+end
+
+if defined?(MiniTest)
+  # Enable turn if it is available
+  begin
+    require 'turn'
+
+    Turn.config do |c|
+      c.natural = true
+    end
+  rescue LoadError
+  end
+end
+
+if defined?(ActiveRecord::Base)
+  require 'active_record/test_case'
+
+  class ActiveSupport::TestCase
+    include ActiveRecord::TestFixtures
+    self.fixture_path = "#{Rails.root}/test/fixtures/"
+
+    setup do
+      ActiveRecord::IdentityMap.clear
+    end
+  end
+
+  ActionDispatch::IntegrationTest.fixture_path = ActiveSupport::TestCase.fixture_path
+
+  def create_fixtures(*table_names, &block)
+    Fixtures.create_fixtures(ActiveSupport::TestCase.fixture_path, table_names, {}, &block)
+  end
+end
+
+class ActionController::TestCase
+  setup do
+    @routes = Rails.application.routes
+  end
+end
+
+class ActionDispatch::IntegrationTest
+  setup do
+    @routes = Rails.application.routes
+  end
+end

data/lib/rails/test_unit/railtie.rb

@@ -0,0 +1,15 @@
+module Rails
+  class TestUnitRailtie < Rails::Railtie
+    config.app_generators do |c|
+      c.test_framework :test_unit, :fixture => true,
+                                   :fixture_replacement => nil
+
+      c.integration_tool :test_unit
+      c.performance_tool :test_unit
+    end
+
+    rake_tasks do
+      load "rails/test_unit/testing.rake"
+    end
+  end
+end

data/lib/rails/test_unit/sub_test_task.rb

@@ -0,0 +1,8 @@
+module Rails
+  # Silence the default description to cut down on `rake -T` noise.
+  class SubTestTask < Rake::TestTask
+    def desc(string)
+      # Ignore the description.
+    end
+  end
+end

data/lib/rails/test_unit/testing.rake

@@ -0,0 +1,146 @@
+require 'rbconfig'
+require 'rake/testtask'
+require 'rails/test_unit/sub_test_task'
+
+TEST_CHANGES_SINCE = Time.now - 600
+
+# Look up tests for recently modified sources.
+def recent_tests(source_pattern, test_path, touched_since = 10.minutes.ago)
+  FileList[source_pattern].map do |path|
+    if File.mtime(path) > touched_since
+      tests = []
+      source_dir = File.dirname(path).split("/")
+      source_file = File.basename(path, '.rb')
+
+      # Support subdirs in app/models and app/controllers
+      modified_test_path = source_dir.length > 2 ? "#{test_path}/" << source_dir[1..source_dir.length].join('/') : test_path
+
+      # For modified files in app/ run the tests for it. ex. /test/functional/account_controller.rb
+      test = "#{modified_test_path}/#{source_file}_test.rb"
+      tests.push test if File.exist?(test)
+
+      # For modified files in app, run tests in subdirs too. ex. /test/functional/account/*_test.rb
+      test = "#{modified_test_path}/#{File.basename(path, '.rb').sub("_controller","")}"
+      FileList["#{test}/*_test.rb"].each { |f| tests.push f } if File.exist?(test)
+
+      return tests
+
+    end
+  end.flatten.compact
+end
+
+
+# Recreated here from Active Support because :uncommitted needs it before Rails is available
+module Kernel
+  remove_method :silence_stderr # Removing old method to prevent method redefined warning
+  def silence_stderr
+    old_stderr = STDERR.dup
+    STDERR.reopen(RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ ? 'NUL:' : '/dev/null')
+    STDERR.sync = true
+    yield
+  ensure
+    STDERR.reopen(old_stderr)
+  end
+end
+
+task :default => :test
+
+desc 'Runs test:units, test:functionals, test:integration together (also available: test:benchmark, test:profile, test:plugins)'
+task :test do
+  Rake::Task[ENV['TEST'] ? 'test:single' : 'test:run'].invoke
+end
+
+namespace :test do
+  task :prepare do
+    # Placeholder task for other Railtie and plugins to enhance. See Active Record for an example.
+  end
+
+  task :run do
+    errors = %w(test:units test:functionals test:integration).collect do |task|
+      begin
+        Rake::Task[task].invoke
+        nil
+      rescue => e
+        { :task => task, :exception => e }
+      end
+    end.compact
+
+    if errors.any?
+      puts errors.map { |e| "Errors running #{e[:task]}! #{e[:exception].inspect}" }.join("\n")
+      abort
+    end
+  end
+
+  Rake::TestTask.new(:recent => "test:prepare") do |t|
+    since = TEST_CHANGES_SINCE
+    touched = FileList['test/**/*_test.rb'].select { |path| File.mtime(path) > since } +
+      recent_tests('app/models/**/*.rb', 'test/unit', since) +
+      recent_tests('app/controllers/**/*.rb', 'test/functional', since)
+
+    t.libs << 'test'
+    t.test_files = touched.uniq
+  end
+  Rake::Task['test:recent'].comment = "Test recent changes"
+
+  Rake::TestTask.new(:uncommitted => "test:prepare") do |t|
+    def t.file_list
+      if File.directory?(".svn")
+        changed_since_checkin = silence_stderr { `svn status` }.split.map { |path| path.chomp[7 .. -1] }
+      elsif File.directory?(".git")
+        changed_since_checkin = silence_stderr { `git ls-files --modified --others` }.split.map { |path| path.chomp }
+      else
+        abort "Not a Subversion or Git checkout."
+      end
+
+      models      = changed_since_checkin.select { |path| path =~ /app[\\\/]models[\\\/].*\.rb$/ }
+      controllers = changed_since_checkin.select { |path| path =~ /app[\\\/]controllers[\\\/].*\.rb$/ }
+
+      unit_tests       = models.map { |model| "test/unit/#{File.basename(model, '.rb')}_test.rb" }
+      functional_tests = controllers.map { |controller| "test/functional/#{File.basename(controller, '.rb')}_test.rb" }
+      (unit_tests + functional_tests).uniq.select { |file| File.exist?(file) }
+    end
+
+    t.libs << 'test'
+  end
+  Rake::Task['test:uncommitted'].comment = "Test changes since last checkin (only Subversion and Git)"
+
+  Rake::TestTask.new(:single => "test:prepare") do |t|
+    t.libs << "test"
+  end
+
+  Rails::SubTestTask.new(:units => "test:prepare") do |t|
+    t.libs << "test"
+    t.pattern = 'test/unit/**/*_test.rb'
+  end
+
+  Rails::SubTestTask.new(:functionals => "test:prepare") do |t|
+    t.libs << "test"
+    t.pattern = 'test/functional/**/*_test.rb'
+  end
+
+  Rails::SubTestTask.new(:integration => "test:prepare") do |t|
+    t.libs << "test"
+    t.pattern = 'test/integration/**/*_test.rb'
+  end
+
+  Rails::SubTestTask.new(:benchmark => 'test:prepare') do |t|
+    t.libs << 'test'
+    t.pattern = 'test/performance/**/*_test.rb'
+    t.options = '-- --benchmark'
+  end
+
+  Rails::SubTestTask.new(:profile => 'test:prepare') do |t|
+    t.libs << 'test'
+    t.pattern = 'test/performance/**/*_test.rb'
+  end
+
+  Rails::SubTestTask.new(:plugins => :environment) do |t|
+    t.libs << "test"
+
+    if ENV['PLUGIN']
+      t.pattern = "vendor/plugins/#{ENV['PLUGIN']}/test/**/*_test.rb"
+    else
+      t.pattern = 'vendor/plugins/*/**/test/**/*_test.rb'
+    end
+  end
+end

data/lib/rails/version.rb

@@ -0,0 +1,10 @@
+module Rails
+  module VERSION #:nodoc:
+    MAJOR = 3
+    MINOR = 2
+    TINY  = 10
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
+  end
+end

data/lib/rails.rb

@@ -0,0 +1,126 @@
+require 'rails/ruby_version_check'
+
+require 'pathname'
+
+require 'active_support'
+require 'active_support/core_ext/kernel/reporting'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/logger'
+
+require 'rails/application'
+require 'rails/version'
+
+require 'active_support/railtie'
+require 'action_dispatch/railtie'
+
+# For Ruby 1.8, this initialization sets $KCODE to 'u' to enable the
+# multibyte safe operations. Plugin authors supporting other encodings
+# should override this behavior and set the relevant +default_charset+
+# on ActionController::Base.
+#
+# For Ruby 1.9, UTF-8 is the default internal and external encoding.
+if RUBY_VERSION < '1.9'
+  $KCODE='u'
+else
+  silence_warnings do
+    Encoding.default_external = Encoding::UTF_8
+    Encoding.default_internal = Encoding::UTF_8
+  end
+end
+
+module Rails
+  autoload :Info, 'rails/info'
+  autoload :InfoController, 'rails/info_controller'
+
+  class << self
+    def application
+      @@application ||= nil
+    end
+
+    def application=(application)
+      @@application = application
+    end
+
+    # The Configuration instance used to configure the Rails environment
+    def configuration
+      application.config
+    end
+
+    def initialize!
+      application.initialize!
+    end
+
+    def initialized?
+      @@initialized || false
+    end
+
+    def initialized=(initialized)
+      @@initialized ||= initialized
+    end
+
+    def logger
+      @@logger ||= nil
+    end
+
+    def logger=(logger)
+      @@logger = logger
+    end
+
+    def backtrace_cleaner
+      @@backtrace_cleaner ||= begin
+        # Relies on Active Support, so we have to lazy load to postpone definition until AS has been loaded
+        require 'rails/backtrace_cleaner'
+        Rails::BacktraceCleaner.new
+      end
+    end
+
+    def root
+      application && application.config.root
+    end
+
+    def env
+      @_env ||= ActiveSupport::StringInquirer.new(ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development")
+    end
+
+    def env=(environment)
+      @_env = ActiveSupport::StringInquirer.new(environment)
+    end
+
+    def cache
+      RAILS_CACHE
+    end
+
+    # Returns all rails groups for loading based on:
+    #
+    # * The Rails environment;
+    # * The environment variable RAILS_GROUPS;
+    # * The optional envs given as argument and the hash with group dependencies;
+    #
+    # == Examples
+    #
+    #   groups :assets => [:development, :test]
+    #
+    #   # Returns
+    #   # => [:default, :development, :assets] for Rails.env == "development"
+    #   # => [:default, :production]           for Rails.env == "production"
+    #
+    def groups(*groups)
+      hash = groups.extract_options!
+      env = Rails.env
+      groups.unshift(:default, env)
+      groups.concat ENV["RAILS_GROUPS"].to_s.split(",")
+      groups.concat hash.map { |k,v| k if v.map(&:to_s).include?(env) }
+      groups.compact!
+      groups.uniq!
+      groups
+    end
+
+    def version
+      VERSION::STRING
+    end
+
+    def public_path
+      application && application.paths["public"].first
+    end
+  end
+end