gem_manager.rb

module GemManager
  class Base
    def initialize
      @gems = {}
      
      output = `gem list -l`
      output.each_line do |line|
        installed_gem = parse(line, true)
        @gems[installed_gem.name] = installed_gem
      end
      
      file = File.open(ARGV.first, 'r')
      file.each_line do |line|
        listed_gem = parse(line, false)
        if not @gems.has_key?(listed_gem.name)
          @gems[listed_gem.name] = listed_gem
        else
          installed_gem = @gems[listed_gem.name]
          difference = listed_gem.all_versions - installed_gem.installed_versions
          if difference.any?
            difference.each do |version|
              installed_gem.versions << Version.new(version, false)
            end
          end
        end
      end
      file.close
    end
    
    def install_uninstalled
      @gems.each_value do |g|
        uninstalled_versions = g.uninstalled_versions
        if uninstalled_versions.any?
          uninstalled_versions.each do |version|
            output = `sudo gem install #{g.name} --version=#{version} --no-rdoc --no-ri --ignore-dependencies`
            output.each_line do |line|
              if line.match(/\ASuccessfully installed/)
                g.versions.delete(version)
                g.versions << Version.new(version, true)
                puts line
                break
              end
            end
          end
        end
      end      
    end
    
    def to_s
      report = []
      @gems.each_value do |g|
        installed_versions   = g.installed_versions.empty?   ? 'X' : g.installed_versions.join(', ')
        uninstalled_versions = g.uninstalled_versions.empty? ? 'X' : g.uninstalled_versions.join(', ')
        lines = []
        lines << g.name
        lines << "  Installed:   #{installed_versions}"
        lines << "  Uninstalled: #{uninstalled_versions}"
        report << lines.join("\n")
      end
      report.join("\n")
    end
    
    private
    
      def parse(line, installed)
        split    = line.split
        name     = split.slice!(0)
        versions = []
        split.each do |version|
          version.gsub!(/[\(\),]/, '')
          versions << Version.new(version, installed)
        end
        Gem.new(name, versions)
      end
  end
  
  class Gem
    attr_reader   :name
    attr_accessor :versions
    
    def initialize(name, versions)
      @name     = name
      @versions = versions
    end
    
    def all_versions
      all = []
      versions.each do |version|
        all << version.version
      end
      all
    end
    
    def installed_versions
      installed = []
      versions.each do |version|
        installed << version.version if version.installed?
      end
      installed
    end
    
    def uninstalled_versions
      uninstalled = []
      versions.each do |version|
        uninstalled << version.version unless version.installed?
      end
      uninstalled
    end
  end
  
  class Version
    attr_reader   :version
    attr_accessor :installed

    def initialize(version, installed)
      @version   = version
      @installed = installed
    end

    def installed?
      installed
    end
  end
end

def print_help
  help = []
  help << 'Usage:'
  help << '  ruby gem_manager.rb gem_list.txt --compare'
  help << '  ruby gem_manager.rb gem_list.txt --install-uninstalled'
  puts help
  Process.exit
end

if ARGV[0].nil?
  print_help
end

case ARGV[1]
  when nil
    print_help
  when '--compare'
    puts GemManager::Base.new.to_s
  when '--install-uninstalled'
    GemManager::Base.new.install_uninstalled
end