openskies 0.0.5.2 → 0.0.6.0

data/lib/rails/railtie.rb

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

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

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

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

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

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

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

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