openskies 0.0.1

data/lib/rails/railtie.rb

@@ -0,0 +1,202 @@
+require 'rails/initializable'
+require 'rails/configuration'
+require 'active_support/inflector'
+require 'active_support/core_ext/module/introspection'
+require 'active_support/core_ext/module/delegation'
+
+module Rails
+  # Railtie is the core of the Rails framework and provides several hooks to extend
+  # Rails and/or modify the initialization process.
+  #
+  # Every major component of Rails (Action Mailer, Action Controller,
+  # Action View, Active Record and Active Resource) is a Railtie. Each of
+  # them is responsible for their own initialization. This makes Rails itself
+  # absent of any component hooks, allowing other components to be used in
+  # place of any of the Rails defaults.
+  #
+  # Developing a Rails extension does _not_ require any implementation of
+  # Railtie, but if you need to interact with the Rails framework during
+  # or after boot, then Railtie is needed.
+  #
+  # For example, an extension doing any of the following would require Railtie:
+  #
+  # * creating initializers
+  # * configuring a Rails framework for the application, like setting a generator
+  # * adding config.* keys to the environment
+  # * setting up a subscriber with ActiveSupport::Notifications
+  # * adding rake tasks
+  #
+  # == Creating your Railtie
+  #
+  # To extend Rails using Railtie, create a Railtie class which inherits
+  # from Rails::Railtie within your extension's namespace. This class must be
+  # loaded during the Rails boot process.
+  #
+  # The following example demonstrates an extension which can be used with or without Rails.
+  #
+  #   # lib/my_gem/railtie.rb
+  #   module MyGem
+  #     class Railtie < Rails::Railtie
+  #     end
+  #   end
+  #
+  #   # lib/my_gem.rb
+  #   require 'my_gem/railtie' if defined?(Rails)
+  #
+  # == Initializers
+  #
+  # To add an initialization step from your Railtie to Rails boot process, you just need
+  # to create an initializer block:
+  #
+  #   class MyRailtie < Rails::Railtie
+  #     initializer "my_railtie.configure_rails_initialization" do
+  #       # some initialization behavior
+  #     end
+  #   end
+  #
+  # If specified, the block can also receive the application object, in case you
+  # need to access some application specific configuration, like middleware:
+  #
+  #   class MyRailtie < Rails::Railtie
+  #     initializer "my_railtie.configure_rails_initialization" do |app|
+  #       app.middleware.use MyRailtie::Middleware
+  #     end
+  #   end
+  #
+  # Finally, you can also pass :before and :after as option to initializer, in case
+  # you want to couple it with a specific step in the initialization process.
+  #
+  # == Configuration
+  #
+  # Inside the Railtie class, you can access a config object which contains configuration
+  # shared by all railties and the application:
+  #
+  #   class MyRailtie < Rails::Railtie
+  #     # Customize the ORM
+  #     config.app_generators.orm :my_railtie_orm
+  #
+  #     # Add a to_prepare block which is executed once in production
+  #     # and before each request in development
+  #     config.to_prepare do
+  #       MyRailtie.setup!
+  #     end
+  #   end
+  #
+  # == Loading rake tasks and generators
+  #
+  # If your railtie has rake tasks, you can tell Rails to load them through the method
+  # rake_tasks:
+  #
+  #   class MyRailtie < Rails::Railtie
+  #     rake_tasks do
+  #       load "path/to/my_railtie.tasks"
+  #     end
+  #   end
+  #
+  # By default, Rails load generators from your load path. However, if you want to place
+  # your generators at a different location, you can specify in your Railtie a block which
+  # will load them during normal generators lookup:
+  #
+  #   class MyRailtie < Rails::Railtie
+  #     generators do
+  #       require "path/to/my_railtie_generator"
+  #     end
+  #   end
+  #
+  # == Application, Plugin and Engine
+  #
+  # A Rails::Engine is nothing more than a Railtie with some initializers already set.
+  # And since Rails::Application and Rails::Plugin are engines, the same configuration
+  # described here can be used in all three.
+  #
+  # Be sure to look at the documentation of those specific classes for more information.
+  #
+  class Railtie
+    autoload :Configurable,  "rails/railtie/configurable"
+    autoload :Configuration, "rails/railtie/configuration"
+
+    include Initializable
+
+    ABSTRACT_RAILTIES = %w(Rails::Railtie Rails::Plugin Rails::Engine Rails::Application)
+
+    class << self
+      private :new
+
+      def subclasses
+        @subclasses ||= []
+      end
+
+      def inherited(base)
+        unless base.abstract_railtie?
+          base.send(:include, Railtie::Configurable)
+          subclasses << base
+        end
+      end
+
+      def rake_tasks(&blk)
+        @rake_tasks ||= []
+        @rake_tasks << blk if blk
+        @rake_tasks
+      end
+
+      def console(&blk)
+        @load_console ||= []
+        @load_console << blk if blk
+        @load_console
+      end
+
+      def generators(&blk)
+        @generators ||= []
+        @generators << blk if blk
+        @generators
+      end
+
+      def abstract_railtie?
+        ABSTRACT_RAILTIES.include?(name)
+      end
+
+      def railtie_name(name = nil)
+        @railtie_name = name.to_s if name
+        @railtie_name ||= generate_railtie_name(self.name)
+      end
+
+      protected
+        def generate_railtie_name(class_or_module)
+          ActiveSupport::Inflector.underscore(class_or_module).gsub("/", "_")
+        end
+    end
+
+    delegate :railtie_name, :to => "self.class"
+
+    def config
+      @config ||= Railtie::Configuration.new
+    end
+
+    def eager_load!
+    end
+
+    def load_console(app=self)
+      self.class.console.each { |block| block.call(app) }
+    end
+
+    def load_tasks(app=self)
+      extend Rake::DSL if defined? Rake::DSL
+      self.class.rake_tasks.each { |block| self.instance_exec(app, &block) }
+
+      # load also tasks from all superclasses
+      klass = self.class.superclass
+      while klass.respond_to?(:rake_tasks)
+        klass.rake_tasks.each { |t| self.instance_exec(app, &t) }
+        klass = klass.superclass
+      end
+    end
+
+    def load_generators(app=self)
+      self.class.generators.each { |block| block.call(app) }
+    end
+
+    def railtie_namespace
+      @railtie_namespace ||= self.class.parents.detect { |n| n.respond_to?(:railtie_namespace) }
+    end
+  end
+end

data/lib/rails/ruby_version_check.rb

@@ -0,0 +1,23 @@
+if RUBY_VERSION < '1.8.7'
+  desc = defined?(RUBY_DESCRIPTION) ? RUBY_DESCRIPTION : "ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE})"
+  abort <<-end_message
+
+    Rails 3 requires Ruby 1.8.7 or >= 1.9.2.
+
+    You're running
+      #{desc}
+
+    Please upgrade to continue.
+
+  end_message
+elsif RUBY_VERSION > '1.9' and RUBY_VERSION < '1.9.2'
+  $stderr.puts <<-end_message
+
+    Rails 3 doesn't officially support Ruby 1.9.1 since recent stable
+    releases have segfaulted the test suite. Please upgrade to Ruby 1.9.2 or later.
+
+    You're running
+      #{RUBY_DESCRIPTION}
+
+  end_message
+end

data/lib/rails/rubyprof_ext.rb

@@ -0,0 +1,35 @@
+require 'prof'
+
+module Prof #:nodoc:
+  # Adapted from Shugo Maeda's unprof.rb
+  def self.print_profile(results, io = $stderr)
+    total = results.detect { |i|
+      i.method_class.nil? && i.method_id == :"#toplevel"
+    }.total_time
+    total = 0.001 if total < 0.001
+
+    io.puts "  %%   cumulative   self              self     total"
+    io.puts " time   seconds   seconds    calls  ms/call  ms/call  name"
+
+    sum = 0.0
+    for r in results
+      sum += r.self_time
+
+      name =  if r.method_class.nil?
+                r.method_id.to_s
+              elsif r.method_class.is_a?(Class)
+                "#{r.method_class}##{r.method_id}"
+              else
+                "#{r.method_class}.#{r.method_id}"
+              end
+      io.printf "%6.2f %8.3f  %8.3f %8d %8.2f %8.2f  %s\n",
+        r.self_time / total * 100,
+        sum,
+        r.self_time,
+        r.count,
+        r.self_time * 1000 / r.count,
+        r.total_time * 1000 / r.count,
+        name
+    end
+  end
+end

data/lib/rails/script_rails_loader.rb

@@ -0,0 +1,29 @@
+require 'pathname'
+
+module Rails
+  module ScriptRailsLoader
+    RUBY = File.join(*RbConfig::CONFIG.values_at("bindir", "ruby_install_name")) + RbConfig::CONFIG["EXEEXT"]
+    SCRIPT_RAILS = File.join('script', 'rails')
+
+    def self.exec_script_rails!
+      cwd = Dir.pwd
+      return unless in_rails_application? || in_rails_application_subdirectory?
+      exec RUBY, SCRIPT_RAILS, *ARGV if in_rails_application?
+      Dir.chdir("..") do
+        # Recurse in a chdir block: if the search fails we want to be sure
+        # the application is generated in the original working directory.
+        exec_script_rails! unless cwd == Dir.pwd
+      end
+    rescue SystemCallError
+      # could not chdir, no problem just return
+    end
+
+    def self.in_rails_application?
+      File.exists?(SCRIPT_RAILS)
+    end
+
+    def self.in_rails_application_subdirectory?(path = Pathname.new(Dir.pwd))
+      File.exists?(File.join(path, SCRIPT_RAILS)) || !path.root? && in_rails_application_subdirectory?(path.parent)
+    end
+  end
+end

data/lib/rails/source_annotation_extractor.rb

@@ -0,0 +1,104 @@
+# Implements the logic behind the rake tasks for annotations like
+#
+#   rake notes
+#   rake notes:optimize
+#
+# and friends. See <tt>rake -T notes</tt> and <tt>railties/lib/tasks/annotations.rake</tt>.
+#
+# Annotation objects are triplets <tt>:line</tt>, <tt>:tag</tt>, <tt>:text</tt> that
+# represent the line where the annotation lives, its tag, and its text. Note
+# the filename is not stored.
+#
+# Annotations are looked for in comments and modulus whitespace they have to
+# start with the tag optionally followed by a colon. Everything up to the end
+# of the line (or closing ERB comment tag) is considered to be their text.
+class SourceAnnotationExtractor
+  class Annotation < Struct.new(:line, :tag, :text)
+
+    # Returns a representation of the annotation that looks like this:
+    #
+    #   [126] [TODO] This algorithm is simple and clearly correct, make it faster.
+    #
+    # If +options+ has a flag <tt>:tag</tt> the tag is shown as in the example above.
+    # Otherwise the string contains just line and text.
+    def to_s(options={})
+      s = "[%3d] " % line
+      s << "[#{tag}] " if options[:tag]
+      s << text
+    end
+  end
+
+  # Prints all annotations with tag +tag+ under the root directories +app+, +config+, +lib+,
+  # +script+, and +test+ (recursively). Only filenames with extension 
+  # +.builder+, +.rb+, and +.erb+ are taken into account. The +options+
+  # hash is passed to each annotation's +to_s+.
+  #
+  # This class method is the single entry point for the rake tasks.
+  def self.enumerate(tag, options={})
+    extractor = new(tag)
+    extractor.display(extractor.find, options)
+  end
+
+  attr_reader :tag
+
+  def initialize(tag)
+    @tag = tag
+  end
+
+  # Returns a hash that maps filenames under +dirs+ (recursively) to arrays
+  # with their annotations.
+  def find(dirs=%w(app config lib script test))
+    dirs.inject({}) { |h, dir| h.update(find_in(dir)) }
+  end
+
+  # Returns a hash that maps filenames under +dir+ (recursively) to arrays
+  # with their annotations. Only files with annotations are included, and only
+  # those with extension +.builder+, +.rb+, +.erb+, +.haml+, +.slim+ and +.coffee+
+  # are taken into account.
+  def find_in(dir)
+    results = {}
+
+    Dir.glob("#{dir}/*") do |item|
+      next if File.basename(item)[0] == ?.
+
+      if File.directory?(item)
+        results.update(find_in(item))
+      elsif item =~ /\.(builder|rb|coffee)$/
+        results.update(extract_annotations_from(item, /#\s*(#{tag}):?\s*(.*)$/))
+      elsif item =~ /\.erb$/
+        results.update(extract_annotations_from(item, /<%\s*#\s*(#{tag}):?\s*(.*?)\s*%>/))
+      elsif item =~ /\.haml$/
+        results.update(extract_annotations_from(item, /-\s*#\s*(#{tag}):?\s*(.*)$/))
+      elsif item =~ /\.slim$/
+        results.update(extract_annotations_from(item, /\/\s*\s*(#{tag}):?\s*(.*)$/))
+      end
+    end
+
+    results
+  end
+
+  # If +file+ is the filename of a file that contains annotations this method returns
+  # a hash with a single entry that maps +file+ to an array of its annotations.
+  # Otherwise it returns an empty hash.
+  def extract_annotations_from(file, pattern)
+    lineno = 0
+    result = File.readlines(file).inject([]) do |list, line|
+      lineno += 1
+      next list unless line =~ pattern
+      list << Annotation.new(lineno, $1, $2)
+    end
+    result.empty? ? {} : { file => result }
+  end
+
+  # Prints the mapping from filenames to annotations in +results+ ordered by filename.
+  # The +options+ hash is passed to each annotation's +to_s+.
+  def display(results, options={})
+    results.keys.sort.each do |file|
+      puts "#{file}:"
+      results[file].each do |note|
+        puts "  * #{note.to_s(options)}"
+      end
+      puts
+    end
+  end
+end

data/lib/rails/tasks/annotations.rake

@@ -0,0 +1,20 @@
+require 'rails/source_annotation_extractor'
+
+desc "Enumerate all annotations (use notes:optimize, :fixme, :todo for focus)"
+task :notes do
+  SourceAnnotationExtractor.enumerate "OPTIMIZE|FIXME|TODO", :tag => true
+end
+
+namespace :notes do
+  ["OPTIMIZE", "FIXME", "TODO"].each do |annotation|
+    # desc "Enumerate all #{annotation} annotations"
+    task annotation.downcase.intern do
+      SourceAnnotationExtractor.enumerate annotation
+    end
+  end
+
+  desc "Enumerate a custom annotation, specify with ANNOTATION=CUSTOM"
+  task :custom do
+    SourceAnnotationExtractor.enumerate ENV['ANNOTATION']
+  end
+end

data/lib/rails/tasks/documentation.rake

@@ -0,0 +1,155 @@
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+# Monkey-patch to remove redoc'ing and clobber descriptions to cut down on rake -T noise
+class RDocTaskWithoutDescriptions < RDoc::Task
+  include ::Rake::DSL if defined?(::Rake::DSL)
+
+  def define
+    task rdoc_task_name
+
+    task rerdoc_task_name => [clobber_task_name, rdoc_task_name]
+
+    task clobber_task_name do
+      rm_r rdoc_dir rescue nil
+    end
+
+    task :clobber => [clobber_task_name]
+
+    directory @rdoc_dir
+    task rdoc_task_name => [rdoc_target]
+    file rdoc_target => @rdoc_files + [Rake.application.rakefile] do
+      rm_r @rdoc_dir rescue nil
+      @before_running_rdoc.call if @before_running_rdoc
+      args = option_list + @rdoc_files
+      if @external
+        argstring = args.join(' ')
+        sh %{ruby -Ivendor vendor/rd #{argstring}}
+      else
+        require 'rdoc/rdoc'
+        RDoc::RDoc.new.document(args)
+      end
+    end
+    self
+  end
+end
+
+namespace :doc do
+  def gem_path(gem_name)
+    path = $LOAD_PATH.grep(/#{gem_name}[\w.-]*\/lib$/).first
+    yield File.dirname(path) if path
+  end
+
+  RDocTaskWithoutDescriptions.new("app") { |rdoc|
+    rdoc.rdoc_dir = 'doc/app'
+    rdoc.template = ENV['template'] if ENV['template']
+    rdoc.title    = ENV['title'] || "Rails Application Documentation"
+    rdoc.options << '--line-numbers'
+    rdoc.options << '--charset' << 'utf-8'
+    rdoc.rdoc_files.include('doc/README_FOR_APP')
+    rdoc.rdoc_files.include('app/**/*.rb')
+    rdoc.rdoc_files.include('lib/**/*.rb')
+  }
+  Rake::Task['doc:app'].comment = "Generate docs for the app -- also available doc:rails, doc:guides, doc:plugins (options: TEMPLATE=/rdoc-template.rb, TITLE=\"Custom Title\")"
+
+  # desc 'Generate documentation for the Rails framework.'
+  RDocTaskWithoutDescriptions.new("rails") { |rdoc|
+    rdoc.rdoc_dir = 'doc/api'
+    rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+    rdoc.title    = "Rails Framework Documentation"
+    rdoc.options << '--line-numbers'
+    rdoc.rdoc_files.include('README.rdoc')
+
+    gem_path('actionmailer') do |actionmailer|
+      %w(README.rdoc CHANGELOG.md MIT-LICENSE lib/action_mailer/base.rb).each do |file|
+        rdoc.rdoc_files.include("#{actionmailer}/#{file}")
+      end
+    end
+
+    gem_path('actionpack') do |actionpack|
+      %w(README.rdoc CHANGELOG.md MIT-LICENSE lib/action_controller/**/*.rb lib/action_view/**/*.rb).each do |file|
+        rdoc.rdoc_files.include("#{actionpack}/#{file}")
+      end
+    end
+
+    gem_path('activemodel') do |activemodel|
+      %w(README.rdoc CHANGELOG.md MIT-LICENSE lib/active_model/**/*.rb).each do |file|
+        rdoc.rdoc_files.include("#{activemodel}/#{file}")
+      end
+    end
+
+    gem_path('activerecord') do |activerecord|
+      %w(README.rdoc CHANGELOG.md lib/active_record/**/*.rb).each do |file|
+        rdoc.rdoc_files.include("#{activerecord}/#{file}")
+      end
+    end
+
+    gem_path('activeresource') do |activeresource|
+      %w(README.rdoc CHANGELOG.md lib/active_resource.rb lib/active_resource/*).each do |file|
+        rdoc.rdoc_files.include("#{activeresource}/#{file}")
+      end
+    end
+
+    gem_path('activesupport') do |activesupport|
+      %w(README.rdoc CHANGELOG.md lib/active_support/**/*.rb).each do |file|
+        rdoc.rdoc_files.include("#{activesupport}/#{file}")
+      end
+    end
+
+    gem_path('railties') do |railties|
+      %w(README.rdoc CHANGELOG.md lib/{*.rb,commands/*.rb,generators/*.rb}).each do |file|
+        rdoc.rdoc_files.include("#{railties}/#{file}")
+      end
+    end
+  }
+
+  plugins = FileList['vendor/plugins/**'].collect { |plugin| File.basename(plugin) }
+
+  # desc "Generate documentation for all installed plugins"
+  task :plugins => plugins.collect { |plugin| "doc:plugins:#{plugin}" }
+
+  # desc "Remove plugin documentation"
+  task :clobber_plugins do
+    rm_rf 'doc/plugins' rescue nil
+  end
+
+  # desc "Generate Rails Guides"
+  task :guides do
+    # FIXME: Reaching outside lib directory is a bad idea
+    require File.expand_path('../../../../guides/rails_guides', __FILE__)
+    RailsGuides::Generator.new(Rails.root.join("doc/guides")).generate
+  end
+
+  namespace :plugins do
+    # Define doc tasks for each plugin
+    plugins.each do |plugin|
+      # desc "Generate documentation for the #{plugin} plugin"
+      task(plugin => :environment) do
+        plugin_base   = "vendor/plugins/#{plugin}"
+        options       = []
+        files         = Rake::FileList.new
+        options << "-o doc/plugins/#{plugin}"
+        options << "--title '#{plugin.titlecase} Plugin Documentation'"
+        options << '--line-numbers'
+        options << '--charset' << 'utf-8'
+        options << '-T html'
+
+        files.include("#{plugin_base}/lib/**/*.rb")
+        if File.exist?("#{plugin_base}/README")
+          files.include("#{plugin_base}/README")
+          options << "--main '#{plugin_base}/README'"
+        end
+        files.include("#{plugin_base}/CHANGELOG") if File.exist?("#{plugin_base}/CHANGELOG")
+
+        options << files.to_s
+
+        sh %(rdoc #{options * ' '})
+      end
+    end
+  end
+end

data/lib/rails/tasks/engine.rake

@@ -0,0 +1,72 @@
+task "load_app" do
+  namespace :app do
+    load APP_RAKEFILE
+  end
+  task :environment => "app:environment"
+
+  if !defined?(ENGINE_PATH) || !ENGINE_PATH
+    ENGINE_PATH = find_engine_path(APP_RAKEFILE)
+  end
+end
+
+def app_task(name)
+  task name => [:load_app, "app:db:#{name}"]
+end
+
+namespace :db do
+  app_task "reset"
+
+  desc "Migrate the database (options: VERSION=x, VERBOSE=false)."
+  app_task "migrate"
+  app_task "migrate:up"
+  app_task "migrate:down"
+  app_task "migrate:redo"
+  app_task "migrate:reset"
+
+  desc "Display status of migrations"
+  app_task "migrate:status"
+
+  desc 'Create the database from config/database.yml for the current Rails.env (use db:create:all to create all dbs in the config)'
+  app_task "create"
+  app_task "create:all"
+
+  desc 'Drops the database for the current Rails.env (use db:drop:all to drop all databases)'
+  app_task "drop"
+  app_task "drop:all"
+
+  desc "Load fixtures into the current environment's database."
+  app_task "fixtures:load"
+
+  desc "Rolls the schema back to the previous version (specify steps w/ STEP=n)."
+  app_task "rollback"
+
+  desc "Create a db/schema.rb file that can be portably used against any DB supported by AR"
+  app_task "schema:dump"
+
+  desc "Load a schema.rb file into the database"
+  app_task "schema:load"
+
+  desc "Load the seed data from db/seeds.rb"
+  app_task "seed"
+
+  desc "Create the database, load the schema, and initialize with the seed data (use db:reset to also drop the db first)"
+  app_task "setup"
+
+  desc "Dump the database structure to an SQL file"
+  app_task "structure:dump"
+
+  desc "Retrieves the current schema version number"
+  app_task "version"
+end
+
+def find_engine_path(path)
+  return if path == "/"
+
+  if Rails::Engine.find(path)
+    path
+  else
+    find_engine_path(File.expand_path('..', path))
+  end
+end
+
+Rake.application.invoke_task(:load_app)