openskies 0.0.5.2 → 0.0.6.0

data/lib/rails/commands/profiler.rb

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

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

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

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

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

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

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

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

data/lib/rails/engine/commands.rb

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

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

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