rapt 0.1.0

data/lib/commands/plugin/plugin.rb

@@ -0,0 +1,148 @@
+require 'open-uri'
+
+class Plugin
+    
+  attr_reader :name, :uri
+  
+  def initialize(uri, name=nil)
+    @uri = uri
+    guess_name(uri)
+  end
+  
+  def self.find(name)
+    name =~ /\// ? new(name) : Repositories.instance.find_plugin(name)
+  end
+  
+  def to_s
+    "#{@name.ljust(30)}#{@uri}"
+  end
+  
+  def svn_url?
+    @uri =~ /svn(?:\+ssh)?:\/\/*/
+  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?
+    method   = :export if method == :http and svn_url?
+
+    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
+    # clean up svn:externals
+    externals = rails_env.externals
+    externals.reject!{|n,u| name == n or name == u}
+    rails_env.externals = externals
+  end
+
+  # Returns a hash representing this plugin's metadata
+  def about(force_refresh=false)
+    # Look in cache first
+    unless force_refresh
+      if Repositories.instance.source_cache['plugins'].has_key?(name)
+        return Repositories.instance.source_cache['plugins'][name]
+      end
+    end
+    # Get from original source
+    tmp = "#{rails_env.root}/_tmp_about.yml"
+    if svn_url?
+      cmd = %(svn export #{@uri}/about.yml "#{tmp}")
+      puts cmd if $verbose
+      system(cmd)
+    end
+    about_uri = svn_url? ? tmp : File.join(@uri, 'about.yml')
+    open(about_uri) do |stream|
+      about_hash = YAML.load(stream.read)
+      unless about_hash.is_a?(Hash) && !about_hash['plugin'].nil?
+        raise("#{name}'s about.yml wasn't valid YAML")
+      end
+      return about_hash
+    end 
+  rescue
+    # Make yaml on the fly for this plugin. 
+    # The 'plugin' field (uri to the resource) is the only required field.
+    {
+      'plugin' => 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.exists? 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.exists? 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"
+      Dir.chdir "#{root}/vendor/plugins"
+      puts "fetching from '#{uri}'" if $verbose
+      fetcher = RecursiveHTTPFetcher.new(uri)
+      fetcher.quiet = true if options[:quiet]
+      fetcher.fetch
+    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
+    end
+    
+    def rails_env
+      @rails_env || RailsEnvironment.default
+    end
+end

data/lib/commands/plugin/rails_environment.rb

@@ -0,0 +1,87 @@
+
+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
+    unless plugin.nil?
+      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"`
+    ext.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

data/lib/commands/plugin/recursive_http_fetcher.rb

@@ -0,0 +1,65 @@
+require 'open-uri'
+
+class RecursiveHTTPFetcher
+  attr_accessor :quiet
+  def initialize(urls_to_fetch, cwd = ".")
+    @cwd = cwd
+    @urls_to_fetch = urls_to_fetch.to_a
+    @quiet = false
+  end
+
+  def ls
+    @urls_to_fetch.collect do |url|
+      if url =~ /^svn:\/\/.*/
+        `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 =~ /^http/i || 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)
+    push_d(File.basename(url))
+    open(url) do |stream|
+      contents =  stream.read
+      fetch(links(url, contents))
+    end
+    pop_d
+  end
+end

data/lib/commands/plugin/repositories.rb

@@ -0,0 +1,128 @@
+require 'yaml'
+
+class Repositories
+  include Enumerable
+
+  attr_accessor :source_cache
+  
+  def initialize(cache_file = File.join(find_home, ".rails", "plugin_source_cache.yml"))
+    @cache_file = File.expand_path(cache_file)
+    load!
+  end
+  
+  def each(&block)
+    @repositories.each(&block)
+  end
+  
+  def add(uri)
+    unless find { |repo| repo.uri == uri }
+      repository = Repository.new(uri)
+      refresh_repository!(repository)
+      @repositories.push(repository).last
+    end
+  end
+  
+  def remove(uri)
+    @repositories.reject!{|repo| repo.uri == uri}
+  end
+  
+  def exist?(uri)
+    @repositories.detect{|repo| repo.uri == uri }
+  end
+  
+  def all
+    @repositories
+  end
+  
+  def find_plugin(name)
+    # Try to get plugin from cache first
+    if @source_cache['plugins'].has_key?(name) && @source_cache['plugins'][name].has_key?('plugin')
+      return Plugin.new(@source_cache['plugins'][name]['plugin'], name)
+    end
+    
+    @repositories.each do |repo|
+      repo.each do |plugin|
+        return plugin if plugin.name == name
+      end
+    end
+    return nil
+  end
+
+  # List the known plugins from the sources cache.
+  def cached_plugins
+    @source_cache['plugins'].keys.sort.map do |plugin_name| 
+      Plugin.new(@source_cache['plugins'][plugin_name]['plugin'], plugin_name)
+    end
+  end
+
+  # Returns the number of known plugins in the cache.
+  def plugin_count
+    source_cache['plugins'].keys.length
+  rescue
+    0
+  end
+  
+  # Gets the updated list of plugins available at each repository.
+  def refresh!
+    @repositories.each { |repo| refresh_repository!(repo) }
+  end
+
+  # Gets the list of plugins available at this repository.
+  def refresh_repository!(repository)
+    repository.plugins.each do |plugin|
+      if about_hash = plugin.about(true)
+        @source_cache['plugins'][plugin.name] = about_hash
+      end
+    end    
+  end
+  
+  
+  def load!
+    @source_cache = File.exist?(@cache_file) ? YAML.load(File.read(@cache_file)) : defaults
+    @source_cache = defaults if @source_cache.keys.nil?
+    @repositories = @source_cache['repositories'].map { |source| Repository.new(source.strip) }
+  end
+  
+  def save
+    mkdir_p(File.dirname(@cache_file)) unless File.exist?(File.dirname(@cache_file))
+    File.open(@cache_file, 'w') do |f|
+      @source_cache['repositories'] = @repositories.map {|r| r.uri }.uniq
+      f.write(@source_cache.to_yaml)
+      f.write("\n")
+    end
+  end
+  
+  def defaults
+    {
+      'repositories' => ['http://dev.rubyonrails.com/svn/rails/plugins/'],
+      'plugins' => {}
+      }
+  end
+ 
+  def find_home
+    ['HOME', 'USERPROFILE'].each do |homekey|
+      return ENV[homekey] if ENV[homekey]
+    end
+    if ENV['HOMEDRIVE'] && ENV['HOMEPATH']
+      return "#{ENV['HOMEDRIVE']}:#{ENV['HOMEPATH']}"
+    end
+    begin
+      File.expand_path("~")
+    rescue StandardError => ex
+      if File::ALT_SEPARATOR
+        "C:/"
+      else
+        "/"
+      end
+    end
+  end
+
+  def self.instance
+    # TODO Use test cache file if $testing
+    @instance ||= Repositories.new
+  end
+  
+  def self.each(&block)
+    self.instance.each(&block)
+  end
+end

data/lib/commands/plugin/repository.rb

@@ -0,0 +1,34 @@
+
+class Repository
+  include Enumerable
+  attr_reader :uri, :plugins
+  
+  def initialize(uri)
+    @uri = uri.chomp('/') << "/"
+    @plugins = nil
+  end
+    
+  def plugins
+    unless @plugins
+      if $verbose
+        puts "Discovering plugins in #{@uri}" 
+        puts index
+      end
+
+      @plugins = index.reject{ |line| line !~ /\/$/ }
+      @plugins.map! { |name| Plugin.new(File.join(@uri, name), name) }
+    end
+
+    @plugins
+  end
+  
+  def each(&block)
+    plugins.each(&block)
+  end
+  
+  private
+    def index
+      @index ||= RecursiveHTTPFetcher.new(@uri).ls
+    end
+end
+