openskies 0.0.1

data/lib/rails/commands/profiler.rb

@@ -0,0 +1,32 @@
+require 'optparse'
+require 'rails/test_help'
+require 'rails/performance_test_help'
+require 'active_support/testing/performance'
+
+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.on('-f', '--formats x,y,z', Array, 'Formats to output to.', "Default: #{defaults[:formats].join(",")}") { |m| options[:formats] = m.map(&:to_sym) }
+    opt.parse!(ARGV)
+  end
+
+  options
+end
+
+class ProfilerTest < 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/runner.rb

@@ -0,0 +1,54 @@
+require 'optparse'
+require 'rbconfig'
+
+options = { :environment => (ENV['RAILS_ENV'] || "development").dup }
+code_or_file = nil
+
+if ARGV.first.nil?
+  ARGV.push "-h"
+end
+
+ARGV.clone.options do |opts|
+  script_name = File.basename($0)
+  opts.banner = "Usage: runner [options] ('Some.ruby(code)' or a filename)"
+
+  opts.separator ""
+
+  opts.on("-e", "--environment=name", String,
+          "Specifies the environment for the runner to operate under (test/development/production).",
+          "Default: development") { |v| options[:environment] = v }
+
+  opts.separator ""
+
+  opts.on("-h", "--help",
+          "Show this help message.") { $stdout.puts opts; exit }
+
+  if RbConfig::CONFIG['host_os'] !~ /mswin|mingw/
+    opts.separator ""
+    opts.separator "You can also use runner as a shebang line for your scripts like this:"
+    opts.separator "-------------------------------------------------------------"
+    opts.separator "#!/usr/bin/env #{File.expand_path($0)} runner"
+    opts.separator ""
+    opts.separator "Product.all.each { |p| p.price *= 2 ; p.save! }"
+    opts.separator "-------------------------------------------------------------"
+  end
+
+  opts.order! { |o| code_or_file ||= o } rescue retry
+end
+
+ARGV.delete(code_or_file)
+
+ENV["RAILS_ENV"] = options[:environment]
+
+require APP_PATH
+Rails.application.require_environment!
+
+if code_or_file.nil?
+  $stderr.puts "Run '#{$0} -h' for help."
+  exit 1
+elsif File.exist?(code_or_file)
+  $0 = code_or_file
+  eval(File.read(code_or_file), nil, code_or_file)
+else
+  eval(code_or_file)
+end

data/lib/rails/commands/server.rb

@@ -0,0 +1,100 @@
+require 'fileutils'
+require 'optparse'
+require 'action_dispatch'
+
+module Rails
+  class Server < ::Rack::Server
+    class Options
+      def parse!(args)
+        args, options = args.dup, {}
+
+        opt_parser = OptionParser.new do |opts|
+          opts.banner = "Usage: rails server [mongrel, thin, etc] [options]"
+          opts.on("-p", "--port=port", Integer,
+                  "Runs Rails on the specified port.", "Default: 3000") { |v| options[:Port] = v }
+          opts.on("-b", "--binding=ip", String,
+                  "Binds Rails to the specified ip.", "Default: 0.0.0.0") { |v| options[:Host] = v }
+          opts.on("-c", "--config=file", String,
+                  "Use custom rackup configuration file") { |v| options[:config] = v }
+          opts.on("-d", "--daemon", "Make server run as a Daemon.") { options[:daemonize] = true }
+          opts.on("-u", "--debugger", "Enable ruby-debugging for the server.") { options[:debugger] = true }
+          opts.on("-e", "--environment=name", String,
+                  "Specifies the environment to run this server under (test/development/production).",
+                  "Default: development") { |v| options[:environment] = v }
+          opts.on("-P","--pid=pid",String,
+                  "Specifies the PID file.",
+                  "Default: tmp/pids/server.pid") { |v| options[:pid] = v }
+
+          opts.separator ""
+
+          opts.on("-h", "--help", "Show this help message.") { puts opts; exit }
+        end
+
+        opt_parser.parse! args
+
+        options[:server] = args.shift
+        options
+      end
+    end
+
+    def initialize(*)
+      super
+      set_environment
+    end
+
+    def app
+      @app ||= super.respond_to?(:to_app) ? super.to_app : super
+    end
+
+    def opt_parser
+      Options.new
+    end
+
+    def set_environment
+      ENV["RAILS_ENV"] ||= options[:environment]
+    end
+
+    def start
+      url = "#{options[:SSLEnable] ? 'https' : 'http'}://#{options[:Host]}:#{options[:Port]}"
+      puts "=> Booting #{ActiveSupport::Inflector.demodulize(server)}"
+      puts "=> Rails #{Rails.version} application starting in #{Rails.env} on #{url}"
+      puts "=> Call with -d to detach" unless options[:daemonize]
+      trap(:INT) { exit }
+      puts "=> Ctrl-C to shutdown server" unless options[:daemonize]
+
+      #Create required tmp directories if not found
+      %w(cache pids sessions sockets).each do |dir_to_make|
+        FileUtils.mkdir_p(Rails.root.join('tmp', dir_to_make))
+      end
+
+      super
+    ensure
+      # The '-h' option calls exit before @options is set.
+      # If we call 'options' with it unset, we get double help banners.
+      puts 'Exiting' unless @options && options[:daemonize]
+    end
+
+    def middleware
+      middlewares = []
+      middlewares << [Rails::Rack::LogTailer, log_path] unless options[:daemonize]
+      middlewares << [Rails::Rack::Debugger]  if options[:debugger]
+      middlewares << [::Rack::ContentLength]
+      Hash.new(middlewares)
+    end
+
+    def log_path
+      "log/#{options[:environment]}.log"
+    end
+
+    def default_options
+      super.merge({
+        :Port        => 3000,
+        :environment => (ENV['RAILS_ENV'] || "development").dup,
+        :daemonize   => false,
+        :debugger    => false,
+        :pid         => File.expand_path("tmp/pids/server.pid"),
+        :config      => File.expand_path("config.ru")
+      })
+    end
+  end
+end

data/lib/rails/commands/update.rb

@@ -0,0 +1,9 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'generators'))
+
+if ARGV.size == 0
+  Rails::Generators.help
+  exit
+end
+
+name = ARGV.shift
+Rails::Generators.invoke name, ARGV, :behavior => :skip

data/lib/rails/commands.rb

@@ -0,0 +1,104 @@
+require 'active_support/core_ext/object/inclusion'
+
+ARGV << '--help' if ARGV.empty?
+
+aliases = {
+  "g"  => "generate",
+  "d"  => "destroy",
+  "c"  => "console",
+  "s"  => "server",
+  "db" => "dbconsole",
+  "r"  => "runner"
+}
+
+command = ARGV.shift
+command = aliases[command] || command
+
+case command
+when 'generate', 'destroy', 'plugin'
+  require 'rails/generators'
+
+  if command == 'plugin' && ARGV.first == 'new'
+    require "rails/commands/plugin_new"
+  else
+    require APP_PATH
+    Rails.application.require_environment!
+
+    Rails.application.load_generators
+
+    require "rails/commands/#{command}"
+  end
+
+when 'benchmarker', 'profiler'
+  require APP_PATH
+  Rails.application.require_environment!
+  require "rails/commands/#{command}"
+
+when 'console'
+  require 'rails/commands/console'
+  require APP_PATH
+  Rails.application.require_environment!
+  Rails::Console.start(Rails.application)
+
+when 'server'
+  # Change to the application's path if there is no config.ru file in current dir.
+  # This allows us to run script/rails server from other directories, but still get
+  # the main config.ru and properly set the tmp directory.
+  Dir.chdir(File.expand_path('../../', APP_PATH)) unless File.exists?(File.expand_path("config.ru"))
+
+  require 'rails/commands/server'
+  Rails::Server.new.tap { |server|
+    # We need to require application after the server sets environment,
+    # otherwise the --environment option given to the server won't propagate.
+    require APP_PATH
+    Dir.chdir(Rails.application.root)
+    server.start
+  }
+
+when 'dbconsole'
+  require 'rails/commands/dbconsole'
+  require APP_PATH
+  Rails::DBConsole.start(Rails.application)
+
+when 'application', 'runner'
+  require "rails/commands/#{command}"
+
+when 'new'
+  if ARGV.first.in?(['-h', '--help'])
+    require 'rails/commands/application'
+  else
+    puts "Can't initialize a new Rails application within the directory of another, please change to a non-Rails directory first.\n"
+    puts "Type 'rails' for help."
+    exit(1)
+  end
+
+when '--version', '-v'
+  ARGV.unshift '--version'
+  require 'rails/commands/application'
+
+else
+  puts "Error: Command not recognized" unless command.in?(['-h', '--help'])
+  puts <<-EOT
+Usage: rails COMMAND [ARGS]
+
+The most common rails commands are:
+ generate    Generate new code (short-cut alias: "g")
+ console     Start the Rails console (short-cut alias: "c")
+ server      Start the Rails server (short-cut alias: "s")
+ dbconsole   Start a console for the database specified in config/database.yml
+             (short-cut alias: "db")
+ new         Create a new Rails application. "rails new my_app" creates a
+             new application called MyApp in "./my_app"
+
+In addition to those, there are:
+ application  Generate the Rails application code
+ destroy      Undo code generated with "generate" (short-cut alias: "d")
+ benchmarker  See how fast a piece of code runs
+ profiler     Get profile information from a piece of code
+ plugin       Install a plugin
+ runner       Run a piece of code in the application environment (short-cut alias: "r")
+
+All commands can be run with -h (or --help) for more information.
+  EOT
+  exit(1)
+end

data/lib/rails/configuration.rb

@@ -0,0 +1,89 @@
+require 'active_support/deprecation'
+require 'active_support/ordered_options'
+require 'active_support/core_ext/hash/deep_dup'
+require 'rails/paths'
+require 'rails/rack'
+
+module Rails
+  module Configuration
+    class MiddlewareStackProxy #:nodoc:
+      def initialize
+        @operations = []
+      end
+
+      def insert_before(*args, &block)
+        @operations << [:insert_before, args, block]
+      end
+
+      alias :insert :insert_before
+
+      def insert_after(*args, &block)
+        @operations << [:insert_after, args, block]
+      end
+
+      def swap(*args, &block)
+        @operations << [:swap, args, block]
+      end
+
+      def use(*args, &block)
+        @operations << [:use, args, block]
+      end
+
+      def delete(*args, &block)
+        @operations << [:delete, args, block]
+      end
+
+      def merge_into(other)
+        @operations.each do |operation, args, block|
+          other.send(operation, *args, &block)
+        end
+        other
+      end
+    end
+
+    class Generators #:nodoc:
+      attr_accessor :aliases, :options, :templates, :fallbacks, :colorize_logging
+      attr_reader :hidden_namespaces
+
+      def initialize
+        @aliases = Hash.new { |h,k| h[k] = {} }
+        @options = Hash.new { |h,k| h[k] = {} }
+        @fallbacks = {}
+        @templates = []
+        @colorize_logging = true
+        @hidden_namespaces = []
+      end
+
+      def initialize_copy(source)
+        @aliases = @aliases.deep_dup
+        @options = @options.deep_dup
+        @fallbacks = @fallbacks.deep_dup
+        @templates = @templates.dup
+      end
+
+      def hide_namespace(namespace)
+        @hidden_namespaces << namespace
+      end
+
+      def method_missing(method, *args)
+        method = method.to_s.sub(/=$/, '').to_sym
+
+        return @options[method] if args.empty?
+
+        if method == :rails || args.first.is_a?(Hash)
+          namespace, configuration = method, args.shift
+        else
+          namespace, configuration = args.shift, args.shift
+          namespace = namespace.to_sym if namespace.respond_to?(:to_sym)
+          @options[:rails][method] = namespace
+        end
+
+        if configuration
+          aliases = configuration.delete(:aliases)
+          @aliases[namespace].merge!(aliases) if aliases
+          @options[namespace].merge!(configuration)
+        end
+      end
+    end
+  end
+end

data/lib/rails/console/app.rb

@@ -0,0 +1,36 @@
+require 'active_support/all'
+require 'active_support/test_case'
+require 'action_controller'
+
+# work around the at_exit hook in test/unit, which kills IRB
+Test::Unit.run = true if Test::Unit.respond_to?(:run=)
+
+module Rails
+  module ConsoleMethods
+    # reference the global "app" instance, created on demand. To recreate the
+    # instance, pass a non-false value as the parameter.
+    def app(create=false)
+      @app_integration_instance = nil if create
+      @app_integration_instance ||= new_session do |sess|
+        sess.host! "www.example.com"
+      end
+    end
+
+    # create a new session. If a block is given, the new session will be yielded
+    # to the block before being returned.
+    def new_session
+      app = Rails.application
+      session = ActionDispatch::Integration::Session.new(app)
+      yield session if block_given?
+      session
+    end
+
+    # reloads the environment
+    def reload!(print=true)
+      puts "Reloading..." if print
+      ActionDispatch::Reloader.cleanup!
+      ActionDispatch::Reloader.prepare!
+      true
+    end
+  end
+end

data/lib/rails/console/helpers.rb

@@ -0,0 +1,11 @@
+module Rails
+  module ConsoleMethods
+    def helper
+      @helper ||= ApplicationController.helpers
+    end
+
+    def controller
+      @controller ||= ApplicationController.new
+    end
+  end
+end

data/lib/rails/engine/commands.rb

@@ -0,0 +1,43 @@
+require 'active_support/core_ext/object/inclusion'
+
+ARGV << '--help' if ARGV.empty?
+
+aliases = {
+  "g" => "generate",
+  "d" => "destroy"
+}
+
+command = ARGV.shift
+command = aliases[command] || command
+
+require ENGINE_PATH
+engine = ::Rails::Engine.find(ENGINE_ROOT)
+
+case command
+when 'generate', 'destroy'
+  require 'rails/generators'
+  Rails::Generators.namespace = engine.railtie_namespace
+  engine.load_generators
+  require "rails/commands/#{command}"
+
+when '--version', '-v'
+  ARGV.unshift '--version'
+  require 'rails/commands/application'
+
+else
+  puts "Error: Command not recognized" unless command.in?(['-h', '--help'])
+  puts <<-EOT
+Usage: rails COMMAND [ARGS]
+
+The common rails commands available for engines are:
+ generate    Generate new code (short-cut alias: "g")
+ destroy     Undo code generated with "generate" (short-cut alias: "d")
+
+All commands can be run with -h for more information.
+
+If you want to run any commands that need to be run in context
+of the application, like `rails server` or `rails console`,
+you should do it from application's directory (typically test/dummy).
+  EOT
+  exit(1)
+end

data/lib/rails/engine/configuration.rb

@@ -0,0 +1,84 @@
+require 'rails/railtie/configuration'
+
+module Rails
+  class Engine
+    class Configuration < ::Rails::Railtie::Configuration
+      attr_reader :root
+      attr_writer :middleware, :eager_load_paths, :autoload_once_paths, :autoload_paths
+      attr_accessor :plugins
+
+      def initialize(root=nil)
+        super()
+        @root = root
+        @generators = app_generators.dup
+      end
+
+      # Returns the middleware stack for the engine.
+      def middleware
+        @middleware ||= Rails::Configuration::MiddlewareStackProxy.new
+      end
+
+      # Holds generators configuration:
+      #
+      #   config.generators do |g|
+      #     g.orm             :datamapper, :migration => true
+      #     g.template_engine :haml
+      #     g.test_framework  :rspec
+      #   end
+      #
+      # If you want to disable color in console, do:
+      #
+      #   config.generators.colorize_logging = false
+      #
+      def generators #:nodoc:
+        @generators ||= Rails::Configuration::Generators.new
+        yield(@generators) if block_given?
+        @generators
+      end
+
+      def paths
+        @paths ||= begin
+          paths = Rails::Paths::Root.new(@root)
+          paths.add "app",                 :eager_load => true, :glob => "*"
+          paths.add "app/assets",          :glob => "*"
+          paths.add "app/controllers",     :eager_load => true
+          paths.add "app/helpers",         :eager_load => true
+          paths.add "app/models",          :eager_load => true
+          paths.add "app/mailers",         :eager_load => true
+          paths.add "app/views"
+          paths.add "lib",                 :load_path => true
+          paths.add "lib/assets",          :glob => "*"
+          paths.add "lib/tasks",           :glob => "**/*.rake"
+          paths.add "config"
+          paths.add "config/environments", :glob => "#{Rails.env}.rb"
+          paths.add "config/initializers", :glob => "**/*.rb"
+          paths.add "config/locales",      :glob => "*.{rb,yml}"
+          paths.add "config/routes",       :with => "config/routes.rb"
+          paths.add "db"
+          paths.add "db/migrate"
+          paths.add "db/seeds",            :with => "db/seeds.rb"
+          paths.add "vendor",              :load_path => true
+          paths.add "vendor/assets",       :glob => "*"
+          paths.add "vendor/plugins"
+          paths
+        end
+      end
+
+      def root=(value)
+        @root = paths.path = Pathname.new(value).expand_path
+      end
+
+      def eager_load_paths
+        @eager_load_paths ||= paths.eager_load
+      end
+
+      def autoload_once_paths
+        @autoload_once_paths ||= paths.autoload_once
+      end
+
+      def autoload_paths
+        @autoload_paths ||= paths.autoload_paths
+      end
+    end
+  end
+end

data/lib/rails/engine/railties.rb

@@ -0,0 +1,33 @@
+module Rails
+  class Engine < Railtie
+    class Railties
+      # TODO Write tests for this behavior extracted from Application
+      def initialize(config)
+        @config = config
+      end
+
+      def all(&block)
+        @all ||= plugins
+        @all.each(&block) if block
+        @all
+      end
+
+      def plugins
+        @plugins ||= begin
+          plugin_names = (@config.plugins || [:all]).map { |p| p.to_sym }
+          Plugin.all(plugin_names, @config.paths["vendor/plugins"].existent)
+        end
+      end
+
+      def self.railties
+        @railties ||= ::Rails::Railtie.subclasses.map(&:instance)
+      end
+
+      def self.engines
+        @engines ||= ::Rails::Engine.subclasses.map(&:instance)
+      end
+
+      delegate :railties, :engines, :to => "self.class"
+    end
+  end
+end