rleber-textmate 0.9.7.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Yehuda Katz
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,47 @@
+# textmate
+
+A binary that provides package management for TextMate.
+
+# Usage
+
+`textmate [COMMAND] [*PARAMS]`
+
+Textmate bundles are automatically reloaded after install or uninstall operations.
+
+## List available remote bundles
+
+`textmate remote [SEARCH]`
+
+List all of the available bundles in the remote repository, optionally filtering by `search`.
+
+## List installed bundles
+
+`textmate list [SEARCH]`
+
+List all of the bundles that are installed on the local system, optionally filtering by `search`.
+
+## Installing new bundles
+
+`textmate install NAME [SOURCE]`
+
+Installs a bundle from the remote repository. SOURCE filters known remote bundle locations.
+For example, if you want to install the "Ruby on Rails" bundle off GitHub, you'd type the following:
+
+`textmate install "Ruby on Rails" GitHub`
+
+Available remote bundle locations are:
+* Macromates Trunk
+* Macromates Review
+* GitHub
+
+## Updateing bundles
+
+`textmate update`
+
+Tries to update all installed bundles.
+
+## Uninstalling bundles
+
+`textmate uninstall NAME`
+
+Uninstalls a bundle from the local repository.

data/bin/textmate

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+# Invoke TextMate Bundle Manager
+
+require File.dirname(__FILE__) + '/../lib/textmate.rb'
+
+TextMateBundleManager.start

data/lib/textmate.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "fileutils"
+require "rubygems"
+require "thor"
+require "open-uri"
+require "yaml"
+require "net/http"
+require "cgi"
+require "pp"
+
+dir = File.dirname(__FILE__) + "/textmate/"
+require dir + "main.rb"
+require dir + 'commands.rb'

data/lib/textmate/bundle.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+# TextMateBundleManager Bundle class
+
+class TextMateBundleManager
+  class Bundle
+    attr_accessor :name, :repository
+    def initialize(options={})
+      @name=options[:name]
+      @repository = options[:repository]
+    end
+  end
+end

data/lib/textmate/commands.rb

@@ -0,0 +1,280 @@
+#!/usr/bin/env ruby
+
+# TextMateBundleManager commands
+
+# TODO "Move" task
+# TODO "Copy" task?
+# TODO "Rename" task?
+# TODO "Shell" or "Find" task
+# TODO "Finder" task -- open relevant directory in the Finder
+# TODO "Where" or "Which" task
+# TODO "Push" task?
+# TODO "Pull" task? Is this different from update?
+# TODO "Edit" task
+# TODO "Hide" task
+# TODO "Show" task (i.e. reverse of Hide)
+# TODO "Duplicates" task
+# TODO "Find" task -- e.g. find all bundles linked to svn, find all dirty, etc. (or options to list command?)
+
+class TextMateBundleManager < Thor
+
+  # CHANGED: renamed list to remote. Could there be a better name?
+  desc "search [SEARCH]", "Lists all the matching remote bundles"
+  def search(search_term = "")
+    search_term = Regexp.new(".*#{search_term}.*", "i")
+    
+    bundles_by_source = {}
+    each_remote_bundle(search_term) do |location|
+      name = location[:name]
+      bundles_by_source[name] ||= {:name=>name, :path=>location[:path], :bundles=>[]}
+      bundles_by_source[name][:bundles] << location
+    end
+       
+    each_remote_source do |source|
+      name = source[:name]
+      next unless v=bundles_by_source[name]
+      banner = name.to_s << " Remote Bundles [#{v[:path]}]"
+      puts "\n" << banner << "\n" << banner.to_s.gsub(/./,'-')
+      v[:bundles].each do |b|
+        s = b[:file].sub(/[-\.]?tmbundle\/?$/i,'')
+        s << " (by #{b[:username]})" if b[:username]
+        puts s
+      end
+    end
+  end
+
+  desc "list [SEARCH]", "lists all the bundles installed locally"
+  method_options :status=>false, :flat=>false, :exact=>false
+  def list(search_term = "")
+    search_term = options[:exact] ? Regexp.new("^#{Regexp.escape(search_term)}$") : Regexp.new(search_term, "i")
+    rows = []
+    rows << (options[:status] ? %w{Location Bundle SCM Status Source} : %w{Location Bundle}) if options[:flat]
+    local_locations.each do |bundles_definition|
+      name = bundles_definition[:name]
+      bundles_path = bundles_definition[:path]
+      installed_bundles = get_local_bundles(bundles_path).map {|x| x.split("/").last.split(".").first}.
+        select {|x| x =~ search_term}
+      if installed_bundles.size > 0
+        unless options[:flat]
+          banner = name.to_s << " Bundles [#{bundles_path}]"
+          puts "\n" << banner << "\n" << banner.to_s.gsub(/./,'-')
+        end
+        if options[:status]
+          table = []
+          table << %w{Name SCM Status Source} unless options[:flat]
+          table += installed_bundles.map do |bundle|
+            path = File.join(bundles_path, bundle + '.tmbundle')
+            status = bundle_status(path)
+            row = [bundle, status[:scm] ? status[:scm].to_s : '-', status[:status] ? status[:status].to_s : '-', 
+              status[:source] ? status[:source].to_s : '-' ]
+            row.unshift name.to_s if options[:flat]
+            row
+          end
+          if options[:flat]
+            rows += table
+          else
+            print_table table
+          end
+        elsif options[:flat]
+          rows += installed_bundles.map {|b| [name.to_s, b]}
+        else
+          puts installed_bundles.join("\n")
+        end
+      end
+    end
+    print_table rows, :separator=>" | " if options[:flat] && rows.size > 1
+  end
+
+  # TODO Allow install to system folders
+  # TODO Install to User/System, with copy to Pristine
+  desc "install NAME", "Install a bundle. Source must be one of trunk, review, github, or personal. \n" \
+                       "If multiple gems with the same name exist, you will be prompted to \n" \
+                       "choose from the available list.\n"
+  method_options :source=>:string
+  def install(bundle_name)
+    FileUtils.mkdir_p install_bundles_path
+    puts "Checking out #{bundle_name}..."
+
+    # CHANGED: It's faster to just try and fail for each repo than to search them all first
+    installed=false
+    remote_locations.each do |location|
+      next unless remote_location(options["source"]) == location if options.key?("source")
+      name = location[:name]
+      cmd = case location[:scm]
+            when :git
+              'echo "git remotes not implemented yet"'
+            when :svn
+              %[svn co "#{location[:path]}/#{url_escape bundle_name}.tmbundle" #{e_sh install_bundles_path}/#{e_sh bundle_name}.tmbundle 2>&1]
+            when :github
+              repos = find_github_bundles(location, denormalize_github_repo_name(bundle_name))
+
+              # Handle possible multiple Repos with the same name
+              case repos.size
+              when 0
+                'echo "Sorry, no such bundle found"'
+              when 1
+                git_clone(repos.first[:username], repos.first[:name])
+              else
+                puts "Multiple bundles with that name found. Please choose which one you want to install:"
+                repos.each_with_index {|repo, idx|
+                  puts "%d: %s by %s" %
+                  [
+                    idx + 1,
+                    normalize_github_repo_name(repo[:name]),
+                    repo[:username]
+                  ]
+                }
+                print "Your choice: "
+
+                # Since to_i defaults to 0, we have to use Integer
+                choice = Integer(STDIN.gets.chomp) rescue nil
+                until choice && (0...repos.size).include?( choice - 1 ) do
+                  print "Sorry, invalid choice. Please enter a valid number or Ctrl+C to stop: "
+                  choice = Integer(STDIN.gets.chomp) rescue nil
+                end
+
+                git_clone(repos[choice - 1][:username], repos[choice - 1][:name])
+              end
+            end
+
+      res = %x{#{cmd}}
+
+      puts cmd, res.gsub(/^/,'    ')
+
+      installed=true and break if res =~ /Checked out revision|Initialized empty Git repository/
+    end
+    abort 'Not Installed' unless installed
+
+    reload :verbose => true
+  end
+
+  # TODO select which folders to uninstall from
+  desc "uninstall NAME", "uninstall a bundle"
+  def uninstall(bundle_name)
+    removed = false
+
+    puts "Removing bundle..."
+    # When moving to the trash, maybe move the bundle into a trash/disabled_bundles subfolder
+    #   named as the bundles_path key. Just in case there are multiple versions of
+    #     the same bundle in multiple bundle paths
+    each_local_bundle do |bundle_path|
+      next unless File.basename(bundle_path, '.*') == bundle_name
+      removed = true
+      %x[osascript -e 'tell application "Finder" to move the POSIX file "#{bundle_path}" to trash']
+      break
+    end
+
+    unless removed
+      say "There is no bundle #{bundle_name} in the system", :red
+      exit
+    else
+      reload :verbose => true
+    end
+  end
+
+  desc "update", "updates all installed bundles"
+  def update
+    each_local_bundle do |path|
+      svn_path = File.join(path, ".svn")
+      github_path = File.join(path, ".git")
+      if File.exist?(github_path)
+        puts "Updating #{path}"
+        %x[git --git-dir=#{e_sh github_path} --work-tree=#{e_sh path}pull]
+      elsif File.exist?(svn_path)
+        puts "Updating #{path}"
+        %x[svn up #{e_sh path}]
+      end
+    end
+  end
+
+  VALID_SCM_TYPES = %w{git svn github}
+
+  desc "register NAME URL", "Register a remote Bundle repository"
+  method_options :short=>:string, :scm=>:string
+  def register(name, path)
+    short = options[:short] || name.to_s.downcase.gsub(/\s/,'_')
+    scm = options[:scm] || :git
+    abort "Unknown Bundle repository type #{options[:scm]}. Should be #{VALID_SCM_TYPES.join(', ')}" unless
+      VALID_SCM_TYPES.include?(scm.to_s)
+    add_remote_location(name, short, scm, path)
+    save_remote_locations
+  end
+
+  desc "unregister", "Unregister a remote Bundle repository"
+  def unregister(name)
+    if remove_remote_location(name)
+      save_remote_locations
+    else
+      abort "Location #{name} not found"
+    end
+  end
+
+  desc "reload", "Reloads TextMate Bundles"
+  method_options :verbose => :boolean
+  def reload(opts = {})
+    puts "Reloading bundles..." if opts[:verbose]
+    reload_bundles
+    puts "Done." if opts[:verbose]
+  end
+
+  desc "locations", "List TextMate Bundle locations"
+  def locations
+    remote_repos = remote_locations.map {|l| ['Remote', l[:short].to_s, l[:name].to_s, l[:path]]}
+    local_repos = local_locations.map   {|l| ['Local',  l[:short].to_s, l[:name].to_s, l[:path]]}
+    print_table([%w{Zone Short Name Location}] + local_repos + remote_repos)
+  end
+
+  desc "get", "Get repository locations for local bundles"
+  method_options :fork=>true, :system=>false, :exact=>false, :force=>false
+  def get(bundle_name=nil, repo_path=nil)
+    replacements = 0
+    if options[:exact]
+      bundle_name = bundle_name.to_s
+      bundle_name += '.tmbundle' unless bundle_name =~ /\.tmbundle$/
+      search_pattern =/^#{Regexp.escape(bundle_name.to_s)}$/
+    else
+      search_pattern = /#{Regexp.escape(bundle_name.to_s)}[^\/]*\.tmbundle$/i
+    end
+    fixed_source = if repo_path
+      {
+        :scm => repo_path =~ /github/ ? :github : (repo_path =~ /git/ ? :git : :svn),
+        :repo => repo_path,
+        :file => File.basename(repo_path),
+        :short => :manual,
+        :name => :'Manually Provided',
+      }
+    else
+      nil
+    end
+    
+    each_local_bundle do |path|
+      next if !bundle_name.nil? && File.basename(path) !~ search_pattern # Find matching bundles; nil == all
+      install_bundle_name = File.basename(path)
+      found_bundle_name = File.basename(path, '.*')
+      install_location = options[:system] ? 'System' : 'User'
+      source = nil
+      [install_location.to_sym, "#{install_location} Pristine".to_sym].each do |loc|
+        location = local_location(loc)
+        install_path = File.join(location[:path],install_bundle_name)
+        next if !options[:force] && bundle_name.nil? && bundle_source(install_path) # Skip bundles which are already linked to a source
+        source ||= fixed_source || get_remote_source(found_bundle_name)
+        if source.nil?
+          puts "No matching bundle found for #{found_bundle_name.inspect}"
+          break
+        end
+        if options[:fork] && source[:scm] == :github && github_owner(source) != current_github_user
+          puts "Forking #{source[:repo]} to #{github_path(current_github_user, source[:file])}"
+          github_fork source
+          source[:username] = current_github_user
+          source[:repo] = github_path(current_github_user, source[:file])
+        end
+        puts "Installing #{source[:repo]} to #{install_bundle_name} in #{location[:name]}"
+        install_bundle(source, install_path)
+        replacements += 1
+      end
+      break unless bundle_name.nil? # Save needless repetition if a single matching bundle was found
+    end
+  ensure
+    reload_bundles if replacements > 0
+  end
+end

data/lib/textmate/main.rb

@@ -0,0 +1,511 @@
+#!/usr/bin/env ruby
+
+# TextMateBundleManager Main file
+
+# TODO Refactor repositories, bundles, bundle lists as first-class objects
+# TODO Refactor search, list and install using iterators
+# TODO Treat "name:" as a location, not a bundle
+# TODO Add tests
+
+class TextMateBundleManager < Thor
+
+  private
+
+  def current_github_user
+    user = `git config --global github.user`.chomp
+    return nil unless user.size > 0
+    user
+  end
+
+  def current_github_token
+    token = `git config --global github.token`.chomp
+    return nil unless token.size > 0
+    token
+  end
+  
+  # In order of precedence, from highest to lowest
+  DEFAULT_REMOTE_LOCATIONS = [
+    {:name => :'GitHub',            :short => :github, :scm => :github, :path => 'http://github.com/api/v2/yaml/repos/search/tmbundle'},
+    {:name => :'Macromates Trunk',  :short => :trunk,  :scm => :svn,    :path => 'http://svn.textmate.org/trunk/Bundles'},
+    {:name => :'Macromates Review', :short => :review, :scm => :svn,    :path => 'http://svn.textmate.org/trunk/Review/Bundles'},
+  ]
+  
+  def default_remote_locations
+    res = DEFAULT_REMOTE_LOCATIONS
+    if current_github_user
+      res = res.dup.unshift(
+        {:name => :'Personal', :short => :personal, :scm => :github, :path => "http://github.com/api/v2/yaml/repos/show/#{current_github_user}", :single_page=>true}
+      )
+    end
+    res
+  end
+  
+  def remote_locations
+    @remote_locations ||= load_remote_locations
+    @remote_locations ||= default_remote_locations
+  end
+  
+  def add_remote_location(position, name, short_name, scm, path)
+    name=name.to_sym
+    remote_locations.insert(position, {:name=>name, :short=>short_name.to_sym, :scm=>scm.to_sym, :path=>path})
+    name
+  end
+  
+  def remove_remote_location(name)
+    index = find_remote_location_index(name)
+    remote_locations.delete_at(index) if index
+    name
+  end
+  
+  def get_remote_source(bundle_name)
+    choices = get_remote_sources(bundle_name)
+    case choices.size
+    when 0
+      return nil
+    when 1
+      choices.first
+    else
+      puts "Please choose one bundle for #{bundle_name.inspect}:"
+      choices.each_with_index do |repo, idx|
+        puts "  #{idx + 1}) #{repo[:short]} #{repo[:file]} #{repo[:username] ? 'by ' + repo[:username] : ''} "
+      end
+      input_choices = "1..#{choices.size}, q"
+      prompt = "  Your choice (#{input_choices})? "
+      choice = nil
+      loop do
+        print prompt
+        case choice = $stdin.gets.chomp
+        when 'q'
+          abort "Quit"
+        when /\d+/
+          choice = choice.to_i
+          break if (1..choices.size).include?(choice)
+        end
+        prompt = "  Sorry, invalid choice. Please enter #{input_choices}: "
+      end
+      choices[choice-1]
+    end
+  end
+  
+  def get_remote_sources(bundle_name)
+    res = []
+    each_remote_bundle(bundle_name) do |location|
+      res << location
+    end
+    res
+  end
+  
+  def each_remote_source(source=nil)
+    remote_locations.each do |location|
+      next unless remote_location(source) == location if source
+      yield location
+    end
+  end
+  
+  def each_remote_bundle(bundle=nil, source=nil, &blk)
+    each_remote_source(source) do |location|
+      case location[:scm]
+      when :git
+        abort "Git remote repositories not implemented"
+      when :svn
+        each_svn_bundle(location, bundle, &blk)
+      when :github
+        each_github_bundle(location, bundle, &blk)
+      else
+        abort "Unknown remote repository type #{location[:scm]}"
+      end
+    end
+  end
+  
+  def remote_bundles(bundle=nil, source=nil)
+    bundles = []
+    each_remote_bundle(bundle, source) {|b| bundles << b}
+    bundles
+  end
+  
+  def each_svn_bundle(location=nil, bundle=nil, &blk)
+    search_term = /#{bundle.to_s}.*tmbundle/i
+    %x[svn list #{e_sh location[:path]}].split("\n").select {|x| x =~ search_term}.each do |file|
+      yield(location.merge(:file=>file, :repo=>"#{location[:path]}/#{file}"))
+    end
+  end
+  
+  def each_github_bundle(location=nil, bundle=nil, &blk)
+    search_term = /#{bundle.to_s}.*tmbundle/i
+    gh_bundles = find_github_bundles(location, search_term)
+    gh_bundles.each do |specification|
+      yield(location.merge(
+        :file=>specification[:name], 
+        :username=>specification[:username], 
+        :repo=>github_path(specification[:username], specification[:name])))
+    end
+  end
+
+  # TODO Maybe we should never install into System or other bundles? Install to System or User, with copy to Pristine?
+  def install_bundle(bundle, to)
+    FileUtils.mkdir_p File.dirname(to)
+    if File.exists?(to)
+      saved_bundle = to.sub(/\.tmbundle/,'.orig.tmbundle')
+      FileUtils.mv(to, saved_bundle) # Save the bundle, in case we fail
+    end
+    success = false
+    begin
+      case bundle[:scm]
+      when :git
+        abort "Installation of git bundles not implemented yet"
+      when :svn
+        command = %Q[svn co "#{bundle[:repo]}" #{e_sh to} 2>&1]
+        res = %x[#{command}]
+        success = res =~ /Checked out revision/
+      when :github
+        command = %Q[git clone "#{bundle[:repo]}" #{e_sh to} 2>&1]
+        res = %x[#{command}]
+        success = res =~ /Cloning into/
+      end
+      abort "Unable to install to #{to} from #{bundle[:repo]}:\n#{command} => #{res}" unless success
+    ensure
+      if success
+        FileUtils.rm_rf(saved_bundle) if saved_bundle && File.exists?(saved_bundle) # Clean up saved bundle, if any
+      else
+        FileUtils.mv(saved_bundle, to) if saved_bundle && File.exists?(saved_bundle) # Restore the bundle on failure
+      end
+    end
+  end
+  
+  CONFIG_FILE = File.join(ENV['HOME'], '.textmate.yml')
+  def config
+    @config ||= load_config
+  end
+  
+  def load_config
+    return {} unless File.exists?(CONFIG_FILE)
+    YAML.load(File.read(CONFIG_FILE)) rescue {}
+  end
+  
+  def save_config
+    File.open(CONFIG_FILE, 'w') {|f| f.write(YAML.dump(@config))}
+  end
+  
+  def load_remote_locations
+    config[:remote_locations]
+  end
+  
+  def save_remote_locations
+    config[:remote_locations] = @remote_locations
+    save_config
+  end
+  
+  def remote_location(name)
+    find_remote_location_by(:name, name) || find_remote_location_by(:short, name)
+  end
+  
+  def find_remote_location_by(field, name)
+    remote_locations.find {|l| l[field] == name }
+  end
+  
+  def find_remote_location_index(name)
+    find_remote_location_index_by(:name, name) || find_remote_location_index_by(:short, name)
+  end
+  
+  def find_remote_location_index_by(field, name)
+    remote_locations.each_with_index do |l, i|
+      return i if l[field] == name
+    end
+    return nil
+  end
+  
+  def long_remote_location_name(name)
+    l = remote_location(name)
+    return nil unless l
+    l[:name]
+  end
+
+  def local_locations
+    @local_locations ||= [
+      # From highest precedence to lowest
+      {:name => :User,              :short=>:user,     :path=>"#{ENV["HOME"]}/Library/Application Support/TextMate/Bundles"},
+      {:name => :'User Pristine',   :short=>:user_p,   :path=>"#{ENV["HOME"]}/Library/Application Support/TextMate/Pristine Copy/Bundles"},
+      {:name => :System,            :short=>:system,   :path=>'/Library/Application Support/TextMate/Bundles'},
+      {:name => :'System Pristine', :short=>:system_p, :path=>'/Library/Application Support/TextMate/Pristine Copy/Bundles'},
+      {:name => :Application,       :short=>:app,      :path=>"#{textmate_app}/Contents/SharedSupport/Bundles"},
+    ]
+  end
+  
+  def local_location(name)
+    l = find_local_location_by(:name, name)
+    return l if l
+    find_local_location_by(:short, name)
+  end
+  
+  def find_local_location_by(field, name)
+    local_locations.find {|l| l[field] == name }
+  end
+  
+  def long_local_location_name(name)
+    l = local_location(name)
+    return nil unless l
+    l[:name]
+  end
+
+  def each_local_bundle(&blk)
+    local_locations.each do |name, bundles_definition|
+      bundles_path = bundles_definition[:path]
+      get_local_bundles(bundles_path).each do |file|
+        yield(File.join(bundles_path, file))
+      end
+    end
+  end
+  
+  def get_local_bundles(path)
+    Dir["#{e_sh path}/*.tmbundle"]
+  end
+  
+  def textmate_app
+    @textmate_app ||= `mdfind -name "TextMate" | grep "/TextMate.app\$"`.chomp
+  end
+
+  def reload_bundles
+    %x[osascript -e 'tell app "TextMate" to reload bundles']
+  end
+  
+  def install_bundles_path
+    local_location(:'User Pristine')[:path]
+  end
+  
+  # Retrieve the status of a Bundle.
+  #
+  # ==== Parameters
+  # String
+  # String
+  #
+  # ==== Returns
+  # {:name=>bundle_name, :scm=>scm_type, :source=>source_repo}
+  def bundle_status(bundle_path)
+    scm = bundle_scm(bundle_path)
+    case scm
+    when :git
+      branch = `cd #{e_sh bundle_path}; git branch 2>&1`.split("\n").select {|line| line =~ /^\s*\*/}[0]
+      branch = branch[/^\s*\*\s*(.*?)\s*$/,1] if branch
+      origin = `cd #{e_sh bundle_path}; git config branch.#{branch}.remote 2>&1`.chomp
+      if origin
+        source = `cd #{e_sh bundle_path}; git remote -v 2>&1`.split("\n").select {|line| line =~ /\b#{Regexp.escape(origin)}\b.*\bfetch\b/ }[0]
+        source = source[/#{Regexp.escape(origin)}\s+(.*?)\s*\(fetch/,1] if source
+        status = nil
+        `cd #{e_sh bundle_path}; git fetch #{origin} 2>&1`
+        status = $1 if `cd #{e_sh bundle_path}; git branch -v -v 2>&1`.chomp =~ /(\b(?:ahead|behind)\s+\d+(?:\s*,\s*behind\s+\d+)?)/
+      else
+        status = nil
+      end
+    when :svn
+      source = `cd #{e_sh bundle_path}; svn info 2>&1`.split("\n").select{|line| line =~ /URL/ }[0]
+      source = source[/URL:\s*(.*?)\s*$/,1] if source
+      status = `cd #{e_sh bundle_path}; svn st 2>&1`.split("\n").size>0 && "dirty"
+    else
+      source = status = nil
+    end
+    {:name=>File.basename(bundle_path, '.*'), :scm=>scm, :status=>status, :source=>source}
+  end
+  
+  def bundle_source(path)
+    bundle_status(path)[:source]
+  end
+  
+  def bundle_scm(path)
+    if File.exists?(File.join(path, '.git'))
+      :git
+    elsif File.exists?(File.join(path, '.svn'))
+      :svn
+    else
+      nil
+    end
+  end
+  
+  # Prints a table.
+  # Basic code borrowed from Thor: https://github.com/wycats/thor
+  #
+  # ==== Parameters
+  # Array[Array[String, String, ...]]
+  #
+  # ==== Options
+  # ident<Integer>:: Indent the first column by ident value.
+  # colwidth<Integer>:: Force the first column to colwidth spaces wide.
+  #
+  def print_table(table, options={})
+    return if table.empty?
+
+    formats, ident, colwidth, separator = [], options[:ident].to_i, options[:colwidth], options[:separator]
+    separator ||= "  "
+#    options[:truncate] = terminal_width if options[:truncate] == true
+
+    formats << "%-#{colwidth}s#{separator}" if colwidth
+    start = colwidth ? 1 : 0
+
+    start.upto(table.first.length - 2) do |i|
+      maxima ||= table.max{|a,b| a[i].size <=> b[i].size }[i].size
+      formats << "%-#{maxima}s#{separator}"
+    end
+
+    formats[0] = formats[0].insert(0, " " * ident)
+    formats << "%s"
+
+    table.each do |row|
+      sentence = ""
+
+      row.each_with_index do |column, i|
+        sentence << formats[i] % column.to_s
+      end
+
+      sentence = truncate(sentence, options[:truncate]) if options[:truncate]
+      stdout.puts sentence
+    end
+  end
+  
+  # For compatibility with print_table
+  def stdout
+    $stdout
+  end
+
+  # Copied from http://macromates.com/svn/Bundles/trunk/Support/lib/escape.rb
+  # escape text to make it useable in a shell script as one “word” (string)
+  def e_sh(str)
+  	str.to_s.gsub(/(?=[^a-zA-Z0-9_.\/\-\x7F-\xFF\n])/, '\\').gsub(/\n/, "'\n'").sub(/^$/, "''")
+  end
+
+  def url_escape(str)
+    chars = ((33...47).to_a + (94...96).to_a + (123...126).to_a).map {|c| c.chr }.join + "\\[\\]\\\\"
+    str = str.to_s.gsub(%r{[#{chars}]}) {|m| CGI.escape(m) }
+  end
+
+  CAPITALIZATION_EXCEPTIONS = %w[tmbundle on]
+  # Convert a GitHub repo name into a "normal" TM bundle name
+  # e.g. ruby-on-rails-tmbundle => Ruby on Rails.tmbundle
+  def normalize_github_repo_name(name)
+    name = name.gsub(/[\-\.]/, " ").split.each{|part| part.capitalize! unless CAPITALIZATION_EXCEPTIONS.include? part}.join(" ")
+    name[-9] = ?. if name =~ / tmbundle$/
+    name
+  end
+
+  # Does the opposite of normalize_github_repo_name
+  def denormalize_github_repo_name(name)
+    name = name.split(' ').each{|part| part.downcase!}.join(' ').gsub(' ', '-')
+    name += ".tmbundle" unless name =~ /.tmbundle$/
+    name
+  end
+
+  def find_github_bundles(location, search_term)
+    # Until GitHub fixes http://support.github.com/discussions/feature-requests/11-api-search-results,
+    # we need to account for multiple pages of results:
+    page = 1
+    path = location[:path]
+    repositories = YAML.load(open("#{path}?start_page=#{page}"))['repositories'] rescue []
+    results = []
+    until repositories.empty?
+      results += repositories.find_all do |result|
+        result[:name] = result.delete('name') if result['name']
+        result[:username] = result.delete('username') if result['username']
+        name = result[:name]
+        name.match(search_term) && name=~/tmbundle$/
+      end
+      break if location[:single_page]
+      page += 1
+      repositories = YAML.load(open("#{path}?start_page=#{page}"))['repositories'] rescue []
+    end
+    results.each do |result|
+      result[:username] ||= current_github_user
+    end
+    results.sort_by {|r| r[:name] }
+  end
+
+  def git_clone(username, name)
+    bundle_name = normalize_github_repo_name(name)
+
+    path = "#{install_bundles_path}/#{bundle_name}"
+    escaped_path = "#{e_sh(install_bundles_path)}/#{e_sh(bundle_name)}"
+
+    if File.directory?(path)
+      say "Sorry, that bundle is already installed. Please uninstall it first.", :red
+      exit
+    end
+
+    %[git clone "#{github_path(username, name)}" #{escaped_path} 2>&1]
+  end
+
+  GITHUB_API_REPO   = 'http://github.com/api/v2/yaml/repos/show/%s/%s'
+  GITHUB_API_FORK   = 'http://github.com/api/v2/yaml/repos/fork/%s/%s'
+
+  # ... hardcore forking action ...
+  # > git remote add -f YOUR_USER git@github.com:YOUR_USER/CURRENT_REPO.git
+  # Code borrowed (with thanks!) from Chris Wanstrath https://github.com/defunkt/hub/tree/master/lib/hub
+  def github_fork(from_repo)
+    # can't do anything without token and original owner name
+    repo_name = from_repo[:file]
+    abort "git config must include github.user and github.token. See http://help.github.com/git-email-settings/ for details" \
+      unless current_github_user && current_github_token
+    abort "#{current_github_user}/#{repo_name} already exists on GitHub" \
+      if github_repo_exists?(current_github_user, repo_name)
+    fork_github_repo(from_repo)
+  end
+  
+  def fork_github_repo(from_repo)
+    repo_owner = github_owner(from_repo)
+    repo_name = from_repo[:file]
+    path = GITHUB_API_FORK % [repo_owner, repo_name]
+    Net::HTTP.post_form(URI(path), 'login' => current_github_user, 'token' => current_github_token)
+  end
+  
+  def github_repo_exists?(user, repo_name)
+    path = GITHUB_API_REPO % [user, repo_name]
+    Net::HTTPSuccess === Net::HTTP.get_response(URI(path))
+  end
+  
+  def github_owner(repo)
+    res = File.basename(File.dirname(repo[:repo]))
+    res = $1 if res =~ /^git@github.com:(.*)/
+    res
+  end
+  
+  def github_path(username, name)
+    if username == current_github_user
+      "git@github.com:#{url_escape(username)}/#{url_escape(name)}.git"
+    else
+      "git://github.com/#{url_escape(username)}/#{url_escape(name)}.git"
+    end
+  end
+
+end
+
+# TODO: create a "monument to personal cleverness" by class-izing everything?
+# class TextMateBundle
+#   def self.find_local(bundle_name)
+#
+#   end
+#
+#   def self.find_remote(bundle_name)
+#
+#   end
+#   attr_reader :name
+#   attr_reader :location
+#   attr_reader :scm
+#   def initialize(name, location, scm)
+#     @name     = name
+#     @location = location
+#     @scm      = scm
+#   end
+#
+#   def install!
+#
+#   end
+#
+#   def uninstall!
+#
+#   end
+#
+#
+#   def installed?
+#     # List all the installed versions, and where they're at
+#   end
+#
+#   # TODO: dirty? method to show if there are any deltas
+# end
+
+