libgems 0.0.1

data/lib/libgems/test_utilities.rb

@@ -0,0 +1,147 @@
+require 'tempfile'
+require 'libgems'
+require 'libgems/remote_fetcher'
+
+##
+# A fake LibGems::RemoteFetcher for use in tests or to avoid real live HTTP
+# requests when testing code that uses SlimGems.
+#
+# Example:
+#
+#   @fetcher = LibGems::FakeFetcher.new
+#   @fetcher.data['http://gems.example.com/yaml'] = source_index.to_yaml
+#   LibGems::RemoteFetcher.fetcher = @fetcher
+#
+#   # invoke SlimGems code
+#
+#   paths = @fetcher.paths
+#   assert_equal 'http://gems.example.com/yaml', paths.shift
+#   assert paths.empty?, paths.join(', ')
+#
+# See SlimGems' tests for more examples of FakeFetcher.
+
+class LibGems::FakeFetcher
+
+  attr_reader :data
+  attr_reader :last_request
+  attr_accessor :paths
+
+  def initialize
+    @data = {}
+    @paths = []
+  end
+
+  def find_data(path)
+    path = path.to_s
+    @paths << path
+    raise ArgumentError, 'need full URI' unless path =~ %r'^https?://'
+
+    unless @data.key? path then
+      raise LibGems::RemoteFetcher::FetchError.new("no data for #{path}", path)
+    end
+
+    @data[path]
+  end
+
+  def fetch_path path, mtime = nil
+    data = find_data(path)
+
+    if data.respond_to?(:call) then
+      data.call
+    else
+      if path.to_s =~ /gz$/ and not data.nil? and not data.empty? then
+        data = LibGems.gunzip data
+      end
+
+      data
+    end
+  end
+
+  # Thanks, FakeWeb!
+  def open_uri_or_path(path)
+    data = find_data(path)
+    body, code, msg = data
+
+    response = Net::HTTPResponse.send(:response_class, code.to_s).new("1.0", code.to_s, msg)
+    response.instance_variable_set(:@body, body)
+    response.instance_variable_set(:@read, true)
+    response
+  end
+
+  def request(uri, request_class, last_modified = nil)
+    data = find_data(uri)
+    body, code, msg = data
+
+    @last_request = request_class.new uri.request_uri
+    yield @last_request if block_given?
+
+    response = Net::HTTPResponse.send(:response_class, code.to_s).new("1.0", code.to_s, msg)
+    response.instance_variable_set(:@body, body)
+    response.instance_variable_set(:@read, true)
+    response
+  end
+
+  def fetch_size(path)
+    path = path.to_s
+    @paths << path
+
+    raise ArgumentError, 'need full URI' unless path =~ %r'^http://'
+
+    unless @data.key? path then
+      raise LibGems::RemoteFetcher::FetchError.new("no data for #{path}", path)
+    end
+
+    data = @data[path]
+
+    data.respond_to?(:call) ? data.call : data.length
+  end
+
+  def download spec, source_uri, install_dir = LibGems.dir
+    name = spec.file_name
+    path = File.join(install_dir, 'cache', name)
+
+    LibGems.ensure_gem_subdirectories install_dir
+
+    if source_uri =~ /^http/ then
+      File.open(path, "wb") do |f|
+        f.write fetch_path(File.join(source_uri, "gems", name))
+      end
+    else
+      FileUtils.cp source_uri, path
+    end
+
+    path
+  end
+
+end
+
+# :stopdoc:
+class LibGems::RemoteFetcher
+
+  def self.fetcher=(fetcher)
+    @fetcher = fetcher
+  end
+
+end
+# :startdoc:
+
+##
+# A StringIO duck-typed class that uses Tempfile instead of String as the
+# backing store.
+#--
+# This class was added to flush out problems in Rubinius' IO implementation.
+
+class TempIO < Tempfile
+  def initialize(string = '')
+    super "TempIO"
+    binmode
+    write string
+    rewind
+  end
+
+  def string
+    flush
+    LibGems.read_binary path
+  end
+end
+

data/lib/libgems/text.rb

@@ -0,0 +1,65 @@
+require 'libgems'
+
+##
+# A collection of text-wrangling methods
+
+module LibGems::Text
+
+  ##
+  # Wraps +text+ to +wrap+ characters and optionally indents by +indent+
+  # characters
+
+  def format_text(text, wrap, indent=0)
+    result = []
+    work = text.dup
+
+    while work.length > wrap do
+      if work =~ /^(.{0,#{wrap}})[ \n]/ then
+        result << $1
+        work.slice!(0, $&.length)
+      else
+        result << work.slice!(0, wrap)
+      end
+    end
+
+    result << work if work.length.nonzero?
+    result.join("\n").gsub(/^/, " " * indent)
+  end
+
+  # This code is based directly on the Text gem implementation
+  # Returns a value representing the "cost" of transforming str1 into str2
+  def levenshtein_distance str1, str2
+    s = str1
+    t = str2
+    n = s.length
+    m = t.length
+    max = n/2
+
+    return m if (0 == n)
+    return n if (0 == m)
+    return n if (n - m).abs > max
+
+    d = (0..m).to_a
+    x = nil
+
+    n.times do |i|
+      e = i+1
+
+      m.times do |j|
+        cost = (s[i] == t[j]) ? 0 : 1
+        x = [
+             d[j+1] + 1, # insertion
+             e + 1,      # deletion
+             d[j] + cost # substitution
+            ].min
+        d[j] = e
+        e = x
+      end
+
+      d[m] = x
+    end
+
+    return x
+  end
+end
+

data/lib/libgems/uninstaller.rb

@@ -0,0 +1,278 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require 'fileutils'
+require 'libgems'
+require 'libgems/dependency_list'
+require 'libgems/doc_manager'
+require 'libgems/user_interaction'
+
+# Restores RubyGems
+LibGems.post_uninstall do |uninstaller|
+  site_lib = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+  old_lib = File.join(site_lib, 'rubygems-backup')
+  if File.directory?(old_lib)
+    uninstaller.say "Restoring RubyGems"
+    Dir.glob(File.join(old_lib, '*')).each do |file|
+      fname = File.basename(file)
+      old_file = File.join(site_lib, fname)
+      FileUtils.rm_rf(old_file) if File.exist?(old_file)
+      FileUtils.mv(file, File.join(site_lib, fname))
+    end
+    FileUtils.rm_rf(old_lib)
+  end
+end
+
+##
+# An Uninstaller.
+#
+# The uninstaller fires pre and post uninstall hooks.  Hooks can be added
+# either through a rubygems_plugin.rb file in an installed gem or via a
+# rubygems/defaults/#{RUBY_ENGINE}.rb or rubygems/defaults/operating_system.rb
+# file.  See LibGems.pre_uninstall and LibGems.post_uninstall for details.
+
+class LibGems::Uninstaller
+
+  include LibGems::UserInteraction
+
+  ##
+  # The directory a gem's executables will be installed into
+
+  attr_reader :bin_dir
+
+  ##
+  # The gem repository the gem will be installed into
+
+  attr_reader :gem_home
+
+  ##
+  # The LibGems::Specification for the gem being uninstalled, only set during
+  # #uninstall_gem
+
+  attr_reader :spec
+
+  ##
+  # Constructs an uninstaller that will uninstall +gem+
+
+  def initialize(gem, options = {})
+    @gem = gem
+    @version = options[:version] || LibGems::Requirement.default
+    gem_home = options[:install_dir] || LibGems.dir
+    @gem_home = File.expand_path gem_home
+    @force_executables = options[:executables]
+    @force_all = options[:all]
+    @force_ignore = options[:ignore]
+    @bin_dir = options[:bin_dir]
+
+    # only add user directory if install_dir is not set
+    @user_install = false
+    @user_install = options[:user_install] unless options[:install_dir]
+
+    spec_dir = File.join @gem_home, 'specifications'
+    @source_index = LibGems::SourceIndex.from_gems_in spec_dir
+
+    if @user_install then
+      user_dir = File.join LibGems.user_dir, 'specifications'
+      @user_index = LibGems::SourceIndex.from_gems_in user_dir
+    end
+  end
+
+  ##
+  # Performs the uninstall of the gem.  This removes the spec, the LibGems
+  # directory, and the cached .gem file.
+
+  def uninstall
+    list = @source_index.find_name @gem, @version
+    list += @user_index.find_name @gem, @version if @user_install
+
+    if list.empty? then
+      raise LibGems::InstallError, "cannot uninstall, check `gem list -d #{@gem}`"
+
+    elsif list.size > 1 and @force_all then
+      remove_all list.dup
+
+    elsif list.size > 1 then
+      gem_names = list.collect {|gem| gem.full_name} + ["All versions"]
+
+      say
+      _, index = choose_from_list "Select gem to uninstall:", gem_names
+
+      if index == list.size then
+        remove_all list.dup
+      elsif index >= 0 && index < list.size then
+        uninstall_gem list[index], list.dup
+      else
+        say "Error: must enter a number [1-#{list.size+1}]"
+      end
+    else
+      uninstall_gem list.first, list.dup
+    end
+  end
+
+  ##
+  # Uninstalls gem +spec+
+
+  def uninstall_gem(spec, specs)
+    @spec = spec
+
+    LibGems.pre_uninstall_hooks.each do |hook|
+      hook.call self
+    end
+
+    remove_executables @spec
+    remove @spec, specs
+
+    LibGems.post_uninstall_hooks.each do |hook|
+      hook.call self
+    end
+
+    @spec = nil
+  end
+
+  ##
+  # Removes installed executables and batch files (windows only) for
+  # +gemspec+.
+
+  def remove_executables(spec)
+    return if spec.nil?
+
+    unless spec.executables.empty? then
+      bindir = @bin_dir ? @bin_dir : LibGems.bindir(spec.installation_path)
+
+      list = @source_index.find_name(spec.name).delete_if { |s|
+        s.version == spec.version
+      }
+
+      executables = spec.executables.clone
+
+      list.each do |s|
+        s.executables.each do |exe_name|
+          executables.delete exe_name
+        end
+      end
+
+      return if executables.empty?
+
+      answer = if @force_executables.nil? then
+                 ask_yes_no("Remove executables:\n" \
+                            "\t#{spec.executables.join(", ")}\n\nin addition to the gem?",
+                            true) # " # appease ruby-mode - don't ask
+               else
+                 @force_executables
+               end
+
+      unless answer then
+        say "Executables and scripts will remain installed."
+      else
+        raise LibGems::FilePermissionError, bindir unless File.writable? bindir
+
+        spec.executables.each do |exe_name|
+          say "Removing #{exe_name}"
+          FileUtils.rm_f File.join(bindir, exe_name)
+          FileUtils.rm_f File.join(bindir, "#{exe_name}.bat")
+        end
+      end
+    end
+  end
+
+  ##
+  # Removes all gems in +list+.
+  #
+  # NOTE: removes uninstalled gems from +list+.
+
+  def remove_all(list)
+    list.dup.each { |spec| uninstall_gem spec, list }
+  end
+
+  ##
+  # spec:: the spec of the gem to be uninstalled
+  # list:: the list of all such gems
+  #
+  # Warning: this method modifies the +list+ parameter.  Once it has
+  # uninstalled a gem, it is removed from that list.
+
+  def remove(spec, list)
+    unless dependencies_ok? spec then
+      raise LibGems::DependencyRemovalException,
+            "Uninstallation aborted due to dependent gem(s)"
+    end
+
+    unless path_ok?(@gem_home, spec) or
+           (@user_install and path_ok?(LibGems.user_dir, spec)) then
+      e = LibGems::GemNotInHomeException.new \
+            "Gem is not installed in directory #{@gem_home}"
+      e.spec = spec
+
+      raise e
+    end
+
+    raise LibGems::FilePermissionError, spec.installation_path unless
+      File.writable?(spec.installation_path)
+
+    FileUtils.rm_rf spec.full_gem_path
+
+    original_platform_name = [
+      spec.name, spec.version, spec.original_platform].join '-'
+
+    spec_dir = File.join spec.installation_path, 'specifications'
+    gemspec = File.join spec_dir, spec.spec_name
+
+    unless File.exist? gemspec then
+      gemspec = File.join spec_dir, "#{original_platform_name}.gemspec"
+    end
+
+    FileUtils.rm_rf gemspec
+
+    cache_dir = File.join spec.installation_path, 'cache'
+    gem = File.join cache_dir, spec.file_name
+
+    unless File.exist? gem then
+      gem = File.join cache_dir, "#{original_platform_name}.gem"
+    end
+
+    FileUtils.rm_rf gem
+
+    LibGems::DocManager.new(spec).uninstall_doc
+
+    say "Successfully uninstalled #{spec.full_name}"
+
+    list.delete spec
+  end
+
+  ##
+  # Is +spec+ in +gem_dir+?
+
+  def path_ok?(gem_dir, spec)
+    full_path = File.join gem_dir, 'gems', spec.full_name
+    original_path = File.join gem_dir, 'gems', spec.original_name
+
+    full_path == spec.full_gem_path || original_path == spec.full_gem_path
+  end
+
+  def dependencies_ok?(spec)
+    return true if @force_ignore
+
+    deplist = LibGems::DependencyList.from_source_index @source_index
+    deplist.add(*@user_index.gems.values) if @user_install
+    deplist.ok_to_remove?(spec.full_name) || ask_if_ok(spec)
+  end
+
+  def ask_if_ok(spec)
+    msg = ['']
+    msg << 'You have requested to uninstall the gem:'
+    msg << "\t#{spec.full_name}"
+    spec.dependent_gems.each do |gem,dep,satlist|
+      msg <<
+        ("#{gem.name}-#{gem.version} depends on " +
+        "[#{dep.name} (#{dep.requirement})]")
+    end
+    msg << 'If you remove this gems, one or more dependencies will not be met.'
+    msg << 'Continue with Uninstall?'
+    return ask_yes_no(msg.join("\n"), true)
+  end
+
+end
+