openskies 0.0.1

data/lib/rails/commands/dbconsole.rb

@@ -0,0 +1,123 @@
+require 'erb'
+
+begin
+  require 'psych'
+rescue LoadError
+end
+
+require 'yaml'
+require 'optparse'
+require 'rbconfig'
+
+module Rails
+  class DBConsole
+    def self.start(app)
+      new(app).start
+    end
+
+    def initialize(app)
+      @app = app
+    end
+
+    def start
+      include_password = false
+      options = {}
+      OptionParser.new do |opt|
+        opt.banner = "Usage: dbconsole [environment] [options]"
+        opt.on("-p", "--include-password", "Automatically provide the password from database.yml") do |v|
+          include_password = true
+        end
+
+        opt.on("--mode [MODE]", ['html', 'list', 'line', 'column'],
+          "Automatically put the sqlite3 database in the specified mode (html, list, line, column).") do |mode|
+            options['mode'] = mode
+        end
+
+        opt.on("--header") do |h|
+          options['header'] = h
+        end
+
+        opt.parse!(ARGV)
+        abort opt.to_s unless (0..1).include?(ARGV.size)
+      end
+
+      unless config = @app.config.database_configuration[Rails.env]
+        abort "No database is configured for the environment '#{Rails.env}'"
+      end
+
+
+      def find_cmd(*commands)
+        dirs_on_path = ENV['PATH'].to_s.split(File::PATH_SEPARATOR)
+        commands += commands.map{|cmd| "#{cmd}.exe"} if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+
+        full_path_command = nil
+        found = commands.detect do |cmd|
+          dir = dirs_on_path.detect do |path|
+            full_path_command = File.join(path, cmd)
+            File.executable? full_path_command
+          end
+        end
+        found ? full_path_command : abort("Couldn't find database client: #{commands.join(', ')}. Check your $PATH and try again.")
+      end
+
+      case config["adapter"]
+      when /^mysql/
+        args = {
+          'host'      => '--host',
+          'port'      => '--port',
+          'socket'    => '--socket',
+          'username'  => '--user',
+          'encoding'  => '--default-character-set'
+        }.map { |opt, arg| "#{arg}=#{config[opt]}" if config[opt] }.compact
+
+        if config['password'] && include_password
+          args << "--password=#{config['password']}"
+        elsif config['password'] && !config['password'].to_s.empty?
+          args << "-p"
+        end
+
+        args << config['database']
+
+        exec(find_cmd('mysql', 'mysql5'), *args)
+
+      when "postgresql", "postgres"
+        ENV['PGUSER']     = config["username"] if config["username"]
+        ENV['PGHOST']     = config["host"] if config["host"]
+        ENV['PGPORT']     = config["port"].to_s if config["port"]
+        ENV['PGPASSWORD'] = config["password"].to_s if config["password"] && include_password
+        exec(find_cmd('psql'), config["database"])
+
+      when "sqlite"
+        exec(find_cmd('sqlite'), config["database"])
+
+      when "sqlite3"
+        args = []
+
+        args << "-#{options['mode']}" if options['mode']
+        args << "-header" if options['header']
+        args << config['database']
+
+        exec(find_cmd('sqlite3'), *args)
+
+      when "oracle", "oracle_enhanced"
+        logon = ""
+
+        if config['username']
+          logon = config['username']
+          logon << "/#{config['password']}" if config['password'] && include_password
+          logon << "@#{config['database']}" if config['database']
+        end
+
+        exec(find_cmd('sqlplus'), logon)
+
+      else
+        abort "Unknown command-line client for #{config['database']}. Submit a Rails patch to add support!"
+      end
+    end
+  end
+end
+
+# Has to set the RAILS_ENV before config/application is required
+if ARGV.first && !ARGV.first.index("-") && env = ARGV.first
+  ENV['RAILS_ENV'] = %w(production development test).detect {|e| e =~ /^#{env}/} || env
+end

data/lib/rails/commands/destroy.rb

@@ -0,0 +1,10 @@
+require 'rails/generators'
+require 'active_support/core_ext/object/inclusion'
+
+if ARGV.first.in?([nil, "-h", "--help"])
+  Rails::Generators.help 'destroy'
+  exit
+end
+
+name = ARGV.shift
+Rails::Generators.invoke name, ARGV, :behavior => :revoke, :destination_root => Rails.root

data/lib/rails/commands/generate.rb

@@ -0,0 +1,12 @@
+require 'rails/generators'
+require 'active_support/core_ext/object/inclusion'
+
+if ARGV.first.in?([nil, "-h", "--help"])
+  Rails::Generators.help 'generate'
+  exit
+end
+
+name = ARGV.shift
+
+root = defined?(ENGINE_ROOT) ? ENGINE_ROOT : Rails.root
+Rails::Generators.invoke name, ARGV, :behavior => :invoke, :destination_root => root

data/lib/rails/commands/plugin.rb

@@ -0,0 +1,544 @@
+# Rails Plugin Manager.
+#
+# Installing plugins:
+#
+#   $ rails plugin install continuous_builder asset_timestamping
+#
+# Specifying revisions:
+#
+#   * Subversion revision is a single integer.
+#
+#   * Git revision format:
+#     - full - 'refs/tags/1.8.0' or 'refs/heads/experimental'
+#     - short: 'experimental' (equivalent to 'refs/heads/experimental')
+#              'tag 1.8.0' (equivalent to 'refs/tags/1.8.0')
+#
+#
+# This is Free Software, copyright 2005 by Ryan Tomayko (rtomayko@gmail.com)
+# and is licensed MIT: (http://www.opensource.org/licenses/mit-license.php)
+
+$verbose = false
+
+require 'open-uri'
+require 'fileutils'
+require 'tempfile'
+
+include FileUtils
+
+class RailsEnvironment
+  attr_reader :root
+
+  def initialize(dir)
+    @root = dir
+  end
+
+  def self.find(dir=nil)
+    dir ||= pwd
+    while dir.length > 1
+      return new(dir) if File.exist?(File.join(dir, 'config', 'environment.rb'))
+      dir = File.dirname(dir)
+    end
+  end
+
+  def self.default
+    @default ||= find
+  end
+
+  def self.default=(rails_env)
+    @default = rails_env
+  end
+
+  def install(name_uri_or_plugin)
+    if name_uri_or_plugin.is_a? String
+      if name_uri_or_plugin =~ /:\/\//
+        plugin = Plugin.new(name_uri_or_plugin)
+      else
+        plugin = Plugins[name_uri_or_plugin]
+      end
+    else
+      plugin = name_uri_or_plugin
+    end
+    if plugin
+      plugin.install
+    else
+      puts "Plugin not found: #{name_uri_or_plugin}"
+    end
+  end
+
+  def use_svn?
+    require 'active_support/core_ext/kernel'
+    silence_stderr {`svn --version` rescue nil}
+    !$?.nil? && $?.success?
+  end
+
+  def use_externals?
+    use_svn? && File.directory?("#{root}/vendor/plugins/.svn")
+  end
+
+  def use_checkout?
+    # this is a bit of a guess. we assume that if the rails environment
+    # is under subversion then they probably want the plugin checked out
+    # instead of exported. This can be overridden on the command line
+    File.directory?("#{root}/.svn")
+  end
+
+  def best_install_method
+    return :http unless use_svn?
+    case
+      when use_externals? then :externals
+      when use_checkout? then :checkout
+      else :export
+    end
+  end
+
+  def externals
+    return [] unless use_externals?
+    ext = `svn propget svn:externals "#{root}/vendor/plugins"`
+    lines = ext.respond_to?(:lines) ? ext.lines : ext
+    lines.reject{ |line| line.strip == '' }.map do |line|
+      line.strip.split(/\s+/, 2)
+    end
+  end
+
+  def externals=(items)
+    unless items.is_a? String
+      items = items.map{|name,uri| "#{name.ljust(29)} #{uri.chomp('/')}"}.join("\n")
+    end
+    Tempfile.open("svn-set-prop") do |file|
+      file.write(items)
+      file.flush
+      system("svn propset -q svn:externals -F \"#{file.path}\" \"#{root}/vendor/plugins\"")
+    end
+  end
+end
+
+class Plugin
+  attr_reader :name, :uri
+
+  def initialize(uri, name = nil)
+    @uri = uri
+    guess_name(uri)
+  end
+
+  def self.find(name)
+    new(name)
+  end
+
+  def to_s
+    "#{@name.ljust(30)}#{@uri}"
+  end
+
+  def svn_url?
+    @uri =~ /svn(?:\+ssh)?:\/\/*/
+  end
+
+  def git_url?
+    @uri =~ /^git:\/\// || @uri =~ /\.git$/
+  end
+
+  def installed?
+    File.directory?("#{rails_env.root}/vendor/plugins/#{name}") \
+      or rails_env.externals.detect{ |name, repo| self.uri == repo }
+  end
+
+  def install(method=nil, options = {})
+    method ||= rails_env.best_install_method?
+    if :http == method
+      method = :export if svn_url?
+      method = :git    if git_url?
+    end
+
+    uninstall if installed? and options[:force]
+
+    unless installed?
+      send("install_using_#{method}", options)
+      run_install_hook
+    else
+      puts "already installed: #{name} (#{uri}).  pass --force to reinstall"
+    end
+  end
+
+  def uninstall
+    path = "#{rails_env.root}/vendor/plugins/#{name}"
+    if File.directory?(path)
+      puts "Removing 'vendor/plugins/#{name}'" if $verbose
+      run_uninstall_hook
+      rm_r path
+    else
+      puts "Plugin doesn't exist: #{path}"
+    end
+
+    if rails_env.use_externals?
+      # clean up svn:externals
+      externals = rails_env.externals
+      externals.reject!{|n, u| name == n or name == u}
+      rails_env.externals = externals
+    end
+  end
+
+  def info
+    tmp = "#{rails_env.root}/_tmp_about.yml"
+    if svn_url?
+      cmd = "svn export #{@uri} \"#{rails_env.root}/#{tmp}\""
+      puts cmd if $verbose
+      system(cmd)
+    end
+    open(svn_url? ? tmp : File.join(@uri, 'about.yml')) do |stream|
+      stream.read
+    end rescue "No about.yml found in #{uri}"
+  ensure
+    FileUtils.rm_rf tmp if svn_url?
+  end
+
+  private
+
+    def run_install_hook
+      install_hook_file = "#{rails_env.root}/vendor/plugins/#{name}/install.rb"
+      load install_hook_file if File.exist? install_hook_file
+    end
+
+    def run_uninstall_hook
+      uninstall_hook_file = "#{rails_env.root}/vendor/plugins/#{name}/uninstall.rb"
+      load uninstall_hook_file if File.exist? uninstall_hook_file
+    end
+
+    def install_using_export(options = {})
+      svn_command :export, options
+    end
+
+    def install_using_checkout(options = {})
+      svn_command :checkout, options
+    end
+
+    def install_using_externals(options = {})
+      externals = rails_env.externals
+      externals.push([@name, uri])
+      rails_env.externals = externals
+      install_using_checkout(options)
+    end
+
+    def install_using_http(options = {})
+      root = rails_env.root
+      mkdir_p "#{root}/vendor/plugins/#{@name}"
+      Dir.chdir "#{root}/vendor/plugins/#{@name}" do
+        puts "fetching from '#{uri}'" if $verbose
+        fetcher = RecursiveHTTPFetcher.new(uri, -1)
+        fetcher.quiet = true if options[:quiet]
+        fetcher.fetch
+      end
+    end
+
+    def install_using_git(options = {})
+      root = rails_env.root
+      mkdir_p(install_path = "#{root}/vendor/plugins/#{name}")
+      Dir.chdir install_path do
+        init_cmd = "git init"
+        init_cmd += " -q" if options[:quiet] and not $verbose
+        puts init_cmd if $verbose
+        system(init_cmd)
+        base_cmd = "git pull --depth 1 #{uri}"
+        base_cmd += " -q" if options[:quiet] and not $verbose
+        base_cmd += " #{options[:revision]}" if options[:revision]
+        puts base_cmd if $verbose
+        if system(base_cmd)
+          puts "removing: .git .gitignore" if $verbose
+          rm_rf %w(.git .gitignore)
+        else
+          rm_rf install_path
+        end
+      end
+    end
+
+    def svn_command(cmd, options = {})
+      root = rails_env.root
+      mkdir_p "#{root}/vendor/plugins"
+      base_cmd = "svn #{cmd} #{uri} \"#{root}/vendor/plugins/#{name}\""
+      base_cmd += ' -q' if options[:quiet] and not $verbose
+      base_cmd += " -r #{options[:revision]}" if options[:revision]
+      puts base_cmd if $verbose
+      system(base_cmd)
+    end
+
+    def guess_name(url)
+      @name = File.basename(url)
+      if @name == 'trunk' || @name.empty?
+        @name = File.basename(File.dirname(url))
+      end
+      @name.gsub!(/\.git$/, '') if @name =~ /\.git$/
+    end
+
+    def rails_env
+      @rails_env || RailsEnvironment.default
+    end
+end
+
+# load default environment and parse arguments
+require 'optparse'
+module Rails
+  module Commands
+    class Plugin
+      attr_reader :environment, :script_name
+      def initialize
+        @environment = RailsEnvironment.default
+        @rails_root = RailsEnvironment.default.root
+        @script_name = File.basename($0)
+      end
+
+      def environment=(value)
+        @environment = value
+        RailsEnvironment.default = value
+      end
+
+      def options
+        OptionParser.new do |o|
+          o.set_summary_indent('  ')
+          o.banner =    "Usage: plugin [OPTIONS] command"
+          o.define_head "Rails plugin manager."
+
+          o.separator ""
+          o.separator "GENERAL OPTIONS"
+
+          o.on("-r", "--root=DIR", String,
+               "Set an explicit rails app directory.",
+               "Default: #{@rails_root}") { |rails_root| @rails_root = rails_root; self.environment = RailsEnvironment.new(@rails_root) }
+
+          o.on("-v", "--verbose", "Turn on verbose output.") { |verbose| $verbose = verbose }
+          o.on("-h", "--help", "Show this help message.") { puts o; exit }
+
+          o.separator ""
+          o.separator "COMMANDS"
+
+          o.separator "  install    Install plugin(s) from known repositories or URLs."
+          o.separator "  remove     Uninstall plugins."
+
+          o.separator ""
+          o.separator "EXAMPLES"
+          o.separator "  Install a plugin from a subversion URL:"
+          o.separator "    #{@script_name} plugin install http://example.com/my_svn_plugin\n"
+          o.separator "  Install a plugin from a git URL:"
+          o.separator "    #{@script_name} plugin install git://github.com/SomeGuy/my_awesome_plugin.git\n"
+          o.separator "  Install a plugin and add a svn:externals entry to vendor/plugins"
+          o.separator "    #{@script_name} plugin install -x my_svn_plugin\n"
+        end
+      end
+
+      def parse!(args=ARGV)
+        general, sub = split_args(args)
+        options.parse!(general)
+
+        command = general.shift
+        if command =~ /^(install|remove)$/
+          command = Commands.const_get(command.capitalize).new(self)
+          command.parse!(sub)
+        else
+          puts "Unknown command: #{command}" unless command.blank?
+          puts options
+          exit 1
+        end
+      end
+
+      def split_args(args)
+        left = []
+        left << args.shift while args[0] and args[0] =~ /^-/
+        left << args.shift if args[0]
+        [left, args]
+      end
+
+      def self.parse!(args=ARGV)
+        Plugin.new.parse!(args)
+      end
+    end
+
+    class Install
+      def initialize(base_command)
+        @base_command = base_command
+        @method = :http
+        @options = { :quiet => false, :revision => nil, :force => false }
+      end
+
+      def options
+        OptionParser.new do |o|
+          o.set_summary_indent('  ')
+          o.banner =    "Usage: #{@base_command.script_name} install PLUGIN [PLUGIN [PLUGIN] ...]"
+          o.define_head "Install one or more plugins."
+          o.separator   ""
+          o.separator   "Options:"
+          o.on(         "-x", "--externals",
+                        "Use svn:externals to grab the plugin.",
+                        "Enables plugin updates and plugin versioning.") { |v| @method = :externals }
+          o.on(         "-o", "--checkout",
+                        "Use svn checkout to grab the plugin.",
+                        "Enables updating but does not add a svn:externals entry.") { |v| @method = :checkout }
+          o.on(         "-e", "--export",
+                        "Use svn export to grab the plugin.",
+                        "Exports the plugin, allowing you to check it into your local repository. Does not enable updates or add an svn:externals entry.") { |v| @method = :export }
+          o.on(         "-q", "--quiet",
+                        "Suppresses the output from installation.",
+                        "Ignored if -v is passed (rails plugin -v install ...)") { |v| @options[:quiet] = true }
+          o.on(         "-r REVISION", "--revision REVISION",
+                        "Checks out the given revision from subversion or git.",
+                        "Ignored if subversion/git is not used.") { |v| @options[:revision] = v }
+          o.on(         "-f", "--force",
+                        "Reinstalls a plugin if it's already installed.") { |v| @options[:force] = true }
+          o.separator   ""
+          o.separator   "You can specify plugin names as given in 'plugin list' output or absolute URLs to "
+          o.separator   "a plugin repository."
+        end
+      end
+
+      def determine_install_method
+        best = @base_command.environment.best_install_method
+        @method = :http if best == :http and @method == :export
+        case
+        when (best == :http and @method != :http)
+          msg = "Cannot install using subversion because `svn' cannot be found in your PATH"
+        when (best == :export and (@method != :export and @method != :http))
+          msg = "Cannot install using #{@method} because this project is not under subversion."
+        when (best != :externals and @method == :externals)
+          msg = "Cannot install using externals because vendor/plugins is not under subversion."
+        end
+        if msg
+          puts msg
+          exit 1
+        end
+        @method
+      end
+
+      def parse!(args)
+        options.parse!(args)
+        if args.blank?
+          puts options
+          exit 1
+        end
+        environment = @base_command.environment
+        install_method = determine_install_method
+        puts "Plugins will be installed using #{install_method}" if $verbose
+        args.each do |name|
+          ::Plugin.find(name).install(install_method, @options)
+        end
+      rescue StandardError => e
+        puts "Plugin not found: #{args.inspect}"
+        puts e.inspect if $verbose
+        exit 1
+      end
+    end
+
+    class Remove
+      def initialize(base_command)
+        @base_command = base_command
+      end
+
+      def options
+        OptionParser.new do |o|
+          o.set_summary_indent('  ')
+          o.banner =    "Usage: #{@base_command.script_name} remove name [name]..."
+          o.define_head "Remove plugins."
+        end
+      end
+
+      def parse!(args)
+        options.parse!(args)
+        if args.blank?
+          puts options
+          exit 1
+        end
+        root = @base_command.environment.root
+        args.each do |name|
+          ::Plugin.new(name).uninstall
+        end
+      end
+    end
+
+    class Info
+      def initialize(base_command)
+        @base_command = base_command
+      end
+
+      def options
+        OptionParser.new do |o|
+          o.set_summary_indent('  ')
+          o.banner =    "Usage: #{@base_command.script_name} info name [name]..."
+          o.define_head "Shows plugin info at {url}/about.yml."
+        end
+      end
+
+      def parse!(args)
+        options.parse!(args)
+        args.each do |name|
+          puts ::Plugin.find(name).info
+          puts
+        end
+      end
+    end
+  end
+end
+
+class RecursiveHTTPFetcher
+  attr_accessor :quiet
+  def initialize(urls_to_fetch, level = 1, cwd = ".")
+    @level = level
+    @cwd = cwd
+    @urls_to_fetch = RUBY_VERSION >= '1.9' ? urls_to_fetch.lines : urls_to_fetch.to_a
+    @quiet = false
+  end
+
+  def ls
+    @urls_to_fetch.collect do |url|
+      if url =~ /^svn(\+ssh)?:\/\/.*/
+        `svn ls #{url}`.split("\n").map {|entry| "/#{entry}"} rescue nil
+      else
+        open(url) do |stream|
+          links("", stream.read)
+        end rescue nil
+      end
+    end.flatten
+  end
+
+  def push_d(dir)
+    @cwd = File.join(@cwd, dir)
+    FileUtils.mkdir_p(@cwd)
+  end
+
+  def pop_d
+    @cwd = File.dirname(@cwd)
+  end
+
+  def links(base_url, contents)
+    links = []
+    contents.scan(/href\s*=\s*\"*[^\">]*/i) do |link|
+      link = link.sub(/href="/i, "")
+      next if link =~ /svnindex.xsl$/
+      next if link =~ /^(\w*:|)\/\// || link =~ /^\./
+      links << File.join(base_url, link)
+    end
+    links
+  end
+
+  def download(link)
+    puts "+ #{File.join(@cwd, File.basename(link))}" unless @quiet
+    open(link) do |stream|
+      File.open(File.join(@cwd, File.basename(link)), "wb") do |file|
+        file.write(stream.read)
+      end
+    end
+  end
+
+  def fetch(links = @urls_to_fetch)
+    links.each do |l|
+      (l =~ /\/$/ || links == @urls_to_fetch) ? fetch_dir(l) : download(l)
+    end
+  end
+
+  def fetch_dir(url)
+    @level += 1
+    push_d(File.basename(url)) if @level > 0
+    open(url) do |stream|
+      contents =  stream.read
+      fetch(links(url, contents))
+    end
+    pop_d if @level > 0
+    @level -= 1
+  end
+end
+
+Rails::Commands::Plugin.parse!

data/lib/rails/commands/plugin_new.rb

@@ -0,0 +1,11 @@
+require 'rubygems' if ARGV.include?("--dev")
+
+if ARGV.first != "new"
+  ARGV[0] = "--help"
+else
+  ARGV.shift
+end
+
+require 'rails/generators'
+require 'rails/generators/rails/plugin_new/plugin_new_generator'
+Rails::Generators::PluginNewGenerator.start